chore(quality): apply ruff autofixes and formatting (29 fixes, 41 files reformatted)

2026-06-10 21:31:41 +00:00
parent 054d4041e6
commit 7c12a96cdc
43 changed files with 1096 additions and 524 deletions
@@ -5,7 +5,7 @@ from sqlalchemy import select, func, or_
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import selectinload

-from app.api.deps import get_current_user, require_permission
+from app.api.deps import require_permission
 from app.db.session import get_async_session
 from app.models import User, Vehicle, VehicleAssignment
 from app.schemas.vehicle import (
@@ -25,6 +25,7 @@ assign_router = APIRouter(prefix="/vehicle-assignments", tags=["vehicle-assignme

 # ===== Vehicle Endpoints =====

+
@router.get("", response_model=VehicleListResponse)
 async def list_vehicles(
    page: int = Query(1, ge=1),
@@ -41,8 +42,12 @@ async def list_vehicles(
    if search:
        pattern = f"%{search}%"
        base_q = base_q.where(
-            or_(Vehicle.name.ilike(pattern), Vehicle.license_plate.ilike(pattern),
-                Vehicle.brand.ilike(pattern), Vehicle.model.ilike(pattern))
+            or_(
+                Vehicle.name.ilike(pattern),
+                Vehicle.license_plate.ilike(pattern),
+                Vehicle.brand.ilike(pattern),
+                Vehicle.model.ilike(pattern),
+            )
        )
    if vehicle_type:
        base_q = base_q.where(Vehicle.vehicle_type == vehicle_type)
@@ -52,11 +57,21 @@ async def list_vehicles(
    count_q = select(func.count()).select_from(base_q.subquery())
    total = (await session.execute(count_q)).scalar() or 0

-    q = base_q.options(selectinload(Vehicle.assignments)).order_by(Vehicle.name).offset((page-1)*size).limit(size)
+    q = (
+        base_q.options(selectinload(Vehicle.assignments))
+        .order_by(Vehicle.name)
+        .offset((page - 1) * size)
+        .limit(size)
+    )
    result = await session.execute(q)
    items = result.unique().scalars().all()

-    return VehicleListResponse(items=[VehicleResponse.model_validate(i) for i in items], total=total, page=page, size=size)
+    return VehicleListResponse(
+        items=[VehicleResponse.model_validate(i) for i in items],
+        total=total,
+        page=page,
+        size=size,
+    )


@router.post("", response_model=VehicleResponse, status_code=status.HTTP_201_CREATED)
@@ -81,12 +96,15 @@ async def get_vehicle(
 ):
    account_id = current_user.account_id
    result = await session.execute(
-        select(Vehicle).options(selectinload(Vehicle.assignments))
+        select(Vehicle)
+        .options(selectinload(Vehicle.assignments))
        .where(Vehicle.id == vehicle_id, Vehicle.account_id == account_id)
    )
    vehicle = result.unique().scalars().first()
    if not vehicle:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Vehicle not found")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Vehicle not found"
+        )
    return VehicleResponse.model_validate(vehicle)


@@ -99,12 +117,15 @@ async def update_vehicle(
 ):
    account_id = current_user.account_id
    result = await session.execute(
-        select(Vehicle).options(selectinload(Vehicle.assignments))
+        select(Vehicle)
+        .options(selectinload(Vehicle.assignments))
        .where(Vehicle.id == vehicle_id, Vehicle.account_id == account_id)
    )
    vehicle = result.unique().scalars().first()
    if not vehicle:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Vehicle not found")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Vehicle not found"
+        )
    update_data = body.model_dump(exclude_unset=True)
    for field, value in update_data.items():
        setattr(vehicle, field, value)
@@ -120,10 +141,16 @@ async def delete_vehicle(
    session: AsyncSession = Depends(get_async_session),
 ):
    account_id = current_user.account_id
-    result = await session.execute(select(Vehicle).where(Vehicle.id == vehicle_id, Vehicle.account_id == account_id))
+    result = await session.execute(
+        select(Vehicle).where(
+            Vehicle.id == vehicle_id, Vehicle.account_id == account_id
+        )
+    )
    vehicle = result.scalars().first()
    if not vehicle:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Vehicle not found")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Vehicle not found"
+        )
    await session.delete(vehicle)
    await session.commit()
    return None
@@ -131,6 +158,7 @@ async def delete_vehicle(

 # ===== VehicleAssignment Endpoints =====

+
@assign_router.get("", response_model=VehicleAssignmentListResponse)
 async def list_assignments(
    page: int = Query(1, ge=1),
@@ -141,28 +169,47 @@ async def list_assignments(
    session: AsyncSession = Depends(get_async_session),
 ):
    account_id = current_user.account_id
-    base_q = select(VehicleAssignment).join(Vehicle).where(Vehicle.account_id == account_id)
+    base_q = (
+        select(VehicleAssignment).join(Vehicle).where(Vehicle.account_id == account_id)
+    )
    if vehicle_id:
        base_q = base_q.where(VehicleAssignment.vehicle_id == vehicle_id)
    if status:
        base_q = base_q.where(VehicleAssignment.status == status)
    count_q = select(func.count()).select_from(base_q.subquery())
    total = (await session.execute(count_q)).scalar() or 0
-    q = base_q.order_by(VehicleAssignment.start_date.desc()).offset((page-1)*size).limit(size)
+    q = (
+        base_q.order_by(VehicleAssignment.start_date.desc())
+        .offset((page - 1) * size)
+        .limit(size)
+    )
    result = await session.execute(q)
    items = result.scalars().all()
-    return VehicleAssignmentListResponse(items=[VehicleAssignmentResponse.model_validate(i) for i in items], total=total, page=page, size=size)
+    return VehicleAssignmentListResponse(
+        items=[VehicleAssignmentResponse.model_validate(i) for i in items],
+        total=total,
+        page=page,
+        size=size,
+    )


-@assign_router.post("", response_model=VehicleAssignmentResponse, status_code=status.HTTP_201_CREATED)
+@assign_router.post(
+    "", response_model=VehicleAssignmentResponse, status_code=status.HTTP_201_CREATED
+)
 async def create_assignment(
    body: VehicleAssignmentCreateRequest,
    current_user: User = Depends(require_permission("vehicles:write")),
    session: AsyncSession = Depends(get_async_session),
 ):
-    v_result = await session.execute(select(Vehicle).where(Vehicle.id == body.vehicle_id, Vehicle.account_id == current_user.account_id))
+    v_result = await session.execute(
+        select(Vehicle).where(
+            Vehicle.id == body.vehicle_id, Vehicle.account_id == current_user.account_id
+        )
+    )
    if not v_result.scalars().first():
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Vehicle not found")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Vehicle not found"
+        )
    assign = VehicleAssignment(**body.model_dump())
    session.add(assign)
    await session.commit()
@@ -178,11 +225,18 @@ async def update_assignment(
    session: AsyncSession = Depends(get_async_session),
 ):
    result = await session.execute(
-        select(VehicleAssignment).join(Vehicle).where(VehicleAssignment.id == assign_id, Vehicle.account_id == current_user.account_id)
+        select(VehicleAssignment)
+        .join(Vehicle)
+        .where(
+            VehicleAssignment.id == assign_id,
+            Vehicle.account_id == current_user.account_id,
+        )
    )
    assign = result.scalars().first()
    if not assign:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Assignment not found")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Assignment not found"
+        )
    update_data = body.model_dump(exclude_unset=True)
    for field, value in update_data.items():
        setattr(assign, field, value)
@@ -198,11 +252,18 @@ async def delete_assignment(
    session: AsyncSession = Depends(get_async_session),
 ):
    result = await session.execute(
-        select(VehicleAssignment).join(Vehicle).where(VehicleAssignment.id == assign_id, Vehicle.account_id == current_user.account_id)
+        select(VehicleAssignment)
+        .join(Vehicle)
+        .where(
+            VehicleAssignment.id == assign_id,
+            Vehicle.account_id == current_user.account_id,
+        )
    )
    assign = result.scalars().first()
    if not assign:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Assignment not found")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Assignment not found"
+        )
    await session.delete(assign)
    await session.commit()
    return None