посмотри роутеры. исходя из лучших практик, скажи, все ли я правильно написал? и стоит ли роутеры разделить в разные модули. сейчас у меня модуль referance_book для настройки справочников для администратора


from typing import List, Optional

from fastapi import (
    APIRouter,
    Depends,
    HTTPException,
    status,
    Response, Query
)
from sqlalchemy.ext.asyncio import AsyncSession

from app.db.crud import (
    product_type as crud_product_type,
    control_type as crud_control_type,
    defect_name as crud_defect_name
)
from app.deps import get_current_admin_user
from app.schemas.control_type import ControlTypeCreate, ControlTypeRead, ControlTypeUpdate
from app.schemas.defect_name import DefectNameCreate, DefectNameUpdate, DefectNameRead
from app.schemas.product_type import (
    ProductTypeRead,
    ProductTypeCreate,
    ProductTypeUpdate
)
from app.schemas.user import UserRead
from app.db.base import get_session


rt_admin_reference_book = APIRouter(tags=['reference_book'])

@rt_admin_reference_book.get(
    "/admin/product_types",
    response_model=List[ProductTypeRead],
    summary="Получить текущий список видов изделий"
)
async def get_product_types(
        db: AsyncSession = Depends(get_session),
        _admin_user: UserRead = Depends(get_current_admin_user)
):
    """
    Получаем текущий список видов изделий
    """
    return await crud_product_type.get_product_types(db=db)

@rt_admin_reference_book.post(
    "/admin/product_types",
    status_code=status.HTTP_201_CREATED,
    summary="Создать новый вид изделия"
)
async def create_product_type(product_type: ProductTypeCreate,
   db: AsyncSession = Depends(get_session),
   _admin_user: UserRead = Depends(get_current_admin_user)
):
    """
    Создание нового вида изделия.
    """
    await crud_product_type.create_product_type(db=db, product_type=product_type)
    return Response(status_code=status.HTTP_201_CREATED)

@rt_admin_reference_book.patch(
    "/admin/product_types/{product_type_id}",
    response_model=ProductTypeRead,
    summary="Обновить вид изделия"
)
async def update_product_type(
    product_type_id: int,
    product_type_update: ProductTypeUpdate,
    db: AsyncSession = Depends(get_session),
    _admin_user: UserRead = Depends(get_current_admin_user),
):
    """
    Обновление вида изделия.
    """
    type_to_update = await crud_product_type.get_by_id(db=db, product_type_id=product_type_id)
    if not type_to_update:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail=f"Вид изделия с id={product_type_id} не найден!"
        )

    try:
        db_product_type = await crud_product_type.update_product_type(db_product_type=type_to_update, product_type_in=product_type_update)

        # 6. Сохраняем ВСЕ изменения
        await db.commit()

    except Exception as e:
        await db.rollback()
        print(f"Ошибка при обновлении вида изделия {product_type_id}: {e}")
        raise HTTPException(status_code=500, detail="Во время обновления вида изделия произошла внутренняя ошибка.")

    # 6. Обновляем объект из БД
    await db.refresh(db_product_type)

    return db_product_type

@rt_admin_reference_book.get(
    "/admin/control_types",
    response_model=List[ControlTypeRead],
    summary="Получить текущий список видов контроля"
)
async def get_control_types(
        db: AsyncSession = Depends(get_session),
        _admin_user: UserRead = Depends(get_current_admin_user)
):
    """
    Получаем текущий список видов изделий
    """
    return await crud_control_type.get_control_types(db=db)

@rt_admin_reference_book.post(
    "/admin/control_types",
    status_code=status.HTTP_201_CREATED,
    summary="Создать новый вид контроля"
)
async def create_control_type(control_type: ControlTypeCreate,
   db: AsyncSession = Depends(get_session),
   _admin_user: UserRead = Depends(get_current_admin_user)
):
    """
    Создание нового вида контроля.
    """
    await crud_control_type.create_control_type(db=db, control_type=control_type)
    return Response(status_code=status.HTTP_201_CREATED)

@rt_admin_reference_book.patch(
    "/admin/control_types/{control_type_id}",
    response_model=ControlTypeRead,
    summary="Обновить вид контроля"
)
async def update_control_type(
    control_type_id: int,
    control_type_update: ControlTypeUpdate,
    db: AsyncSession = Depends(get_session),
    _admin_user: UserRead = Depends(get_current_admin_user),
):
    """
    Обновление вида контроля.
    """
    type_to_update = await crud_control_type.get_by_id(db=db, control_type_id=control_type_id)
    if not type_to_update:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail=f"Вид контроля с id={control_type_id} не найден!"
        )

    try:
        db_control_type = await crud_control_type.update_control_type(
            db_control_type=type_to_update,
            control_type_in=control_type_update
        )

        # 6. Сохраняем ВСЕ изменения
        await db.commit()

    except Exception as e:
        await db.rollback()
        print(f"Ошибка при обновлении вида контроля {control_type_id}: {e}")
        raise HTTPException(status_code=500, detail="Во время обновления вида контроля произошла внутренняя ошибка.")

    # 6. Обновляем объект из БД
    await db.refresh(db_control_type)

    return db_control_type

@rt_admin_reference_book.get("/admin/defect_names", response_model=List[DefectNameRead])
async def get_defect_names(
        db: AsyncSession = Depends(get_session),
        _admin_user: UserRead = Depends(get_current_admin_user),
        control_type_id: Optional[int] = Query(None, description="Фильтр по виду контроля")
):
    """
    Получаем текущий список дефектов, опционально фильтруя по виду контроля
    """
    return await crud_defect_name.get_defect_names(db=db, control_type_id=control_type_id)

@rt_admin_reference_book.post(
    "/admin/defect_names",
    status_code=status.HTTP_201_CREATED,
    summary="Создать новый дефект"
)
async def create_defect_name(defect_name: DefectNameCreate,
   db: AsyncSession = Depends(get_session),
   _admin_user: UserRead = Depends(get_current_admin_user)
):
    """
    Создание нового дефекта.
    """
    await crud_defect_name.create_defect_name(db=db, defect_name=defect_name)
    return Response(status_code=status.HTTP_201_CREATED)

@rt_admin_reference_book.patch(
    "/admin/defect_names/{defect_name_id}",
    response_model=DefectNameRead,
    summary="Обновить дефект"
)
async def update_defect_name(
    defect_name_id: int,
    defect_name_update: DefectNameUpdate,
    db: AsyncSession = Depends(get_session),
    _admin_user: UserRead = Depends(get_current_admin_user),
):
    """
    Обновление дефекта.
    """
    defect_to_update = await crud_defect_name.get_by_id(db=db, defect_name_id=defect_name_id)
    if not defect_to_update:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail=f"Дефект с id={defect_name_id} не найден!"
        )

    try:
        db_defect_name = await crud_defect_name.update_defect_name(
            db_defect_name=defect_to_update,
            defect_name_in=defect_name_update
        )

        # 6. Сохраняем ВСЕ изменения
        await db.commit()

    except Exception as e:
        await db.rollback()
        print(f"Ошибка при обновлени дефекта {defect_name_id}: {e}")
        raise HTTPException(status_code=500, detail="Во время обновления дефекта произошла внутренняя ошибка.")

    # 6. Обновляем объект из БД
    await db.refresh(db_defect_name)

    return db_defect_name