fastapi-sqlalchemy-toolkit 0.0.2.2__tar.gz → 0.1__tar.gz

{fastapi_sqlalchemy_toolkit-0.0.2.2 → fastapi_sqlalchemy_toolkit-0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi_sqlalchemy_toolkit
-Version: 0.0.2.2
+Version: 0.1
 Summary: FastAPI SQLAlchemy Toolkit
 Project-URL: Homepage, https://github.com/e-kondr01/fastapi-sqlalchemy-toolkit
 Author-email: Egor Kondrashov <e.kondr01@gmail.com>
@@ -8,10 +8,10 @@ License-File: LICENSE
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.11
-Requires-Dist: dateutil>=2.8.2
 Requires-Dist: fastapi-pagination>=0.12.6
 Requires-Dist: fastapi>=0.100.0
 Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-dateutil>=2.8.2
 Requires-Dist: sqlalchemy>=2.0.0
 Description-Content-Type: text/markdown
 
@@ -49,61 +49,59 @@ pip install fastapi-sqlalchemy-toolkit
 
 Пример использования `fastapi-sqlalchemy-toolkit` доступен в директории `examples/app`
 
-## Получение DB CRUD
+## Инициализация ModelManager
 
-Для использования `fastapi-sqlaclhemy-toolkit` необходимо создать экземпляр `BaseCRUD` для своей модели:
+Для использования `fastapi-sqlaclhemy-toolkit` необходимо создать экземпляр `ModelManager` для своей модели:
 
 ```python
-from fastapi_sqlalchemy_toolkit import BaseCRUD
+from fastapi_sqlalchemy_toolkit import ModelManager
 
 from .models import MyModel
 from .schemas import MyModelCreateSchema, MyModelUpdateSchema
 
-my_model_db = BaseCRUD[MyModel, MyModelCreateSchema, MyModelUpdateSchema](MyModel)
+my_model_manager = ModelManager[MyModel, MyModelCreateSchema, MyModelUpdateSchema](MyModel)
 ```
 
-При инициализации DB CRUD также можно задать параметр `fk_mapping`, необходимый для валидации внешних ключей.
-`fk_mapping` — это словарь, в котором ключи — это названия полей внешних ключей, а значения — модели SQLAlchemy, на которые эти ключи ссылаются.
+При инициализации ModelManager можно задать параметр `fk_mapping`, необходимый для валидации внешних ключей.
+`fk_mapping` — это словарь, в котором ключи — это названия внешних ключей, а значения — модели SQLAlchemy, на которые эти ключи ссылаются.
 
 ```python
-from fastapi_sqlalchemy_toolkit import BaseCRUD
+from fastapi_sqlalchemy_toolkit import ModelManager
 
 from .models import MyModel, MyParentModel
 from .schemas import MyModelCreateSchema, MyModelUpdateSchema
 
-my_model_db = BaseCRUD[MyModel, MyModelCreateSchema, MyModelUpdateSchema](
-    MyModel,
-    fk_mapping={"parent_id": MyParentModel}
+my_model_manager = ModelManager[MyModel, MyModelCreateSchema, MyModelUpdateSchema](
+    MyModel, fk_mapping={"parent_id": MyParentModel}
 )
 ```
 
-Атрибут `default_ordering` определяет сортировку по умолчанию при получении списков объектов. В него нужно передать поле основной модели.
+Атрибут `default_ordering` определяет сортировку по умолчанию при получении списка объектов. В него нужно передать поле основной модели.
 
 ```python
-from fastapi_sqlalchemy_toolkit import BaseCRUD
+from fastapi_sqlalchemy_toolkit import ModelManager
 
 from .models import MyModel
 from .schemas import MyModelCreateSchema, MyModelUpdateSchema
 
-my_model_db = BaseCRUD[MyModel, MyModelCreateSchema, MyModelUpdateSchema](
-    MyModel,
-    default_ordering=MyModel.title
+my_model_manager = ModelManager[MyModel, MyModelCreateSchema, MyModelUpdateSchema](
+    MyModel, default_ordering=MyModel.title
 )
 ```
 
-## Доступные методы `BaseCRUD`
+## Доступные методы `ModelManager`
 
-Ниже перечислены доступные CRUD методы, предоставляемые `BaseCRUD`.
+Ниже перечислены CRUD методы, предоставляемые `ModelManager`.
 Документация параметров, принимаемых методами, находится в докстрингах методов.
 
-- `create` - создание объекта (также выполняет валидацию значений полей на уровне БД)
+- `create` - создание объекта; выполняет валидацию значений полей на уровне БД
 - `get` - получение объекта
-- `get_or_404` - получение объекта или ошибки 404
+- `get_or_404` - получение объекта или ошибки HTTP 404
 - `exists` - проверка существования объекта
-- `paginated_filter` - получение списка объектов с пагинацией через `fastapi_pagination`
-- `filter` - получение списка объектов
+- `paginated_filter` - получение списка объектов с фильтрами и пагинацией через `fastapi_pagination`
+- `filter` - получение списка объектов с фильтрами
 - `count` - получение количества объектов
-- `update` - обновление объекта (также выполняет валидацию значений полей на уровне БД)
+- `update` - обновление объекта; выполняет валидацию значений полей на уровне БД
 - `delete` - удаление объекта
 
 ## Фильтрация
@@ -113,69 +111,86 @@ my_model_db = BaseCRUD[MyModel, MyModelCreateSchema, MyModelUpdateSchema](
 ```python
 from typing import Annotated
 from uuid import UUID
+
 from fastapi import APIRouter, Depends, Response, status
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
+
 from app.deps import get_async_session
-from app.models import MyModel
+from app.models import MyModel, MyParentModel
 from app.schemas import MyObjectListSchema
 
-
 router = APIRouter()
 CurrentSession = Annotated[AsyncSession, Depends(get_async_session)]
 
+
 @router.get("/my-objects")
 async def get_my_objects(
     session: CurrentSession,
     user_id: UUID | None = None,
-    name: str | None = None
+    name: str | None = None,
+    parent_name: str | None = None,
 ) -> list[MyObjectListSchema]:
     stmt = select(MyModel)
     if user_id is not None:
         stmt = stmt.filter_by(user_id=user_id)
     if name is not None:
-        stmt = stmt.filter_by(name=name)
+        stmt = stmt.filter(MyModel.name.ilike == name)
+    if parent_name is not None:
+        stmt = stmt.join(MyModel.parent)
+        stmt = stmt.filter(ParentModel.name.ilike == parent_name)
     result = await session.execute(stmt)
-    return results.scalars().all()
+    return result.scalars().all()
 ```
-Как можно заметить, присутствует дубликация шаблонного кода. А это только строгие сравнения, и поля находятся на основной модели.
+Как можно заметить, для реализации фильтрации необходима дубликация шаблонного кода.
 
 В `fastapi-sqlalchemy-toolkit` этот эндпоинт выглядит так:
 
 ```python
-from app.db_crud import my_object_db
+from fastapi_sqlalchemy_toolkit import FieldFilter
+
+from app.managers import my_object_manager
 
 @router.get("/my-objects")
 async def get_my_objects(
     session: CurrentSession,
     user_id: UUID | None = None,
-    name: str | None = None
+    name: str | None = None,
+    parent_name: str | None = None,
 ) -> list[MyObjectListSchema]:
-    return await my_object_db.filter(session, user_id=user_id, name=name)
+    return await my_object_manager.filter(
+        session,
+        user_id=user_id,
+        name=FieldFilter(name, operator="ilike"),
+        parent_name=FieldFilter(parent_name, operator="ilike", model=ParentModel),
+    )
 ```
 ### Использование FieldFilter
 Дополнительные возможности декларативной фильтрации поддерживаются использованием класса `FieldFilter`.
 `FieldFilter` позволяет:
 - фильтровать по значениям полей связанных моделей при установке атрибута `model`. 
-При этом `BaseCRUD` автоматически сделает необходимые join'ы, если это модель, которая напрямую связана с главной
-- использовать любые операторы сравнения через атрибут `operator`
+При этом `ModelManager` автоматически сделает необходимые join'ы, если это модель, которая напрямую связана с главной
+- использовать любые методы и атрибуты полей SQLAlchemy через атрибут `operator`
 - применять функции SQLAlchemy к полям (например, `date()`) через атрибут `func`
 
 ```python
-from fastapi_sqlalchemy_toolkit import FieldFilter
-from app.db_crud import parent_db
+from app.managers import parent_manager
 from app.models import Child
 
-await parent_db.filter(session, child_title=FieldFilter(value=child_title, model=Child, operator="ilike"))
+from fastapi_sqlalchemy_toolkit import FieldFilter
+
+await parent_manager.filter(
+    session, child_title=FieldFilter(child_title, model=Child, operator="ilike")
+)
 ```
 ### Фильтрация по обратным связям
 Также в методах `filter` и `paginated_filter` есть поддержка фильтрации
 по обратным связям (`relationship()` в направлении один ко многим) с использованием метода `.any()`.
 
 ```python
-# Если Parent.children -- это связь один ко многим
-await parent_db.filter(session, children=[1, 2])
-# Вернёт объекты Parent, у которых есть связь с Child с id 1 или 2
+# Если ParentModel.children -- это связь один ко многим
+await parent_manager.filter(session, children=[1, 2])
+# Вернёт объекты Parent, у которых есть связь с ChildModel с id 1 или 2
 ```
 ### Фильтрация по null
 Для того чтобы осуществить фильтрацию по `null`, квери параметр должен принимать
@@ -187,18 +202,19 @@ from fastapi_sqlalchemy_toolkit import NullableQuery
 @router.get("")
 async def get_children(
     session: CurrentSession,
-    title: NullableQuery | UUID | None = None,
+    activated_at: NullableQuery | datetime.datetime | None = None,
 ) -> Page[ChildRetrieveSchema]:
+    ...
 ```
-`NullableQuery` это пустая строка. То есть запрос с фильтрацией по `title == None` должен выглядеть так:
-`GET /children?title=`
+`NullableQuery` -- это пустая строка. Запрос с фильтрацией по `activated_at == None` должен выглядеть так:
+`GET /children?activated_at=`
 
 *Почему так?*
 
 
-При запросе `GET /children?title=alex` ожидается, что будут возвращены
-объекты с `title == alex`, но при GET `/children` мы не ожидаем, что будут возвращены
-объекты с `title == None`.
+При запросе `GET /children?activated_at=2023-08-01` ожидается, что будут возвращены
+объекты с `activated_at == 2023-08-01`, но при запросе GET `/children` мы не ожидаем, что будут возвращены
+объекты с `activated_at == None` (ожидаемым поведением является отсутствие фильтрации по `activated_at`).
 
 Если в эндпоинте FastAPI определён необязательный квери параметр, и он не передан
 в запросе, то значение этого параметра будет равно `None`. Чтобы не возникала описанная выше некорректная фильтрация, фильтр
@@ -210,7 +226,7 @@ async def get_children(
 а также по полям связанных моделей. При этом необходимые для сортировки по полям
 связанных моделей join'ы будут сделаны автоматически.
 
-Для применения декларативной сортировки нужно сделать следующее:
+Для применения декларативной сортировки нужно:
 1. Определить список полей, по которым доступна фильтрация. Поле может быть
 строкой, если это поле основной модели, или атрибутом модели, если оно находится
 на связанной модели.
@@ -218,12 +234,12 @@ async def get_children(
 ```python
 from app.models import Parent
 
-child_ordering_fields = [
+child_ordering_fields = (
     "title",
     "created_at",
     Parent.title,
     Parent.created_at
-]
+)
 ```
 
 Для каждого из указаных полей будет доступна сортировка по возрастанию и убыванию.
@@ -243,39 +259,40 @@ async def get_child_objects(
     session: CurrentSession,
     order_by: ordering_dep(child_ordering_fields)
 ) -> list[ChildListSchema]
+    ...
 ```
 
-3. Передать параметр сортировки как параметр `order_by` в методы `BaseCRUD`
+3. Передать параметр сортировки как параметр `order_by` в методы `ModelManager`
 
 ```python
-    return await child_db.filter(session=session, order_by=order_by)
+    return await child_manager.filter(session=session, order_by=order_by)
 ```
 
 
 ## Расширение
-Методы `BaseCRUD` легко расширить дополнительной логикой.
+Методы `ModelManager` легко расширить дополнительной логикой.
 
 
-В первую очередь необходимо определить свой класс DB CRUD, унаследовав его от `BaseCRUD`
+В первую очередь необходимо определить свой класс ModelManager:
 
 ```python
-from fastapi_sqlalchemy_toolkit import BaseCRUD
+from fastapi_sqlalchemy_toolkit import ModelManager
 
 
-class MyModelCRUDB[MyModel, MyModelCreateSchema, MyModelUpdateSchema](BaseCRUD):
+class MyModelManager[MyModel, MyModelCreateSchema, MyModelUpdateSchema](ModelManager):
     ...
 ```
 ### Дополнительная валидация
 Дополнительную валидацию можно добавить, переопределив метод `validate`:
 
 ```python
-class MyModelCRUDB[MyModel, MyModelCreateSchema, MyModelUpdateSchema](BaseCRUD):
+class MyModelManager[MyModel, MyModelCreateSchema, MyModelUpdateSchema](ModelManager):
     async def validate_parent_type(self, session: AsyncSession, validated_data: ModelDict) -> None:
         """
         Проверяет тип выбранного объекта Parent
         """
         # объект Parent с таким ID точно есть, так как это проверяется ранее в super().validate
-        parent = await parent_db.get(session, id=in_obj["parent_id"])
+        parent = await parent_manager.get(session, id=in_obj["parent_id"])
         if parent.type != ParentTypes.CanHaveChildren:
             raise HTTPException(
                     status_code=status.HTTP_400_BAD_REQUEST,
@@ -285,19 +302,36 @@ class MyModelCRUDB[MyModel, MyModelCreateSchema, MyModelUpdateSchema](BaseCRUD):
     async def run_db_validation(
             self,
             session: AsyncSession,
-            db_obj: ModelType | None = None,
+            db_obj: MyModel | None = None,
             in_obj: ModelDict | None = None,
         ) -> ModelDict:
         validated_data = await super().validate(session, db_obj, in_obj)
         await self.validate_parent_type(session, validated_data)
         return validated_data
 ```
+
+### Дополнительная бизнес логика при CRUD операциях
+Если при CRUD операциях с моделью необходимо выполнить какую-то дополнительную бизнес логику,
+это можно сделать, переопределив соответствующие методы ModelManager:
+
+```python
+class MyModelManager[MyModel, MyModelCreateSchema, MyModelUpdateSchema](ModelManager):
+    async def create(
+        self, *args, background_tasks: BackgroundTasks | None = None, **kwargs
+    ) -> MyModel:
+    created = await super().create(*args, **kwargs)
+    background_tasks.add_task(send_email, created.id)
+    return created
+```
+
+Такой подход соответствует принципу "Fat Models, Skinny Views" из Django.
+
 ### Использование декларативных фильтров в нестандартных списочных запросах
 Если необходимо получить не просто список объектов, но и какие-то другие поля (допустим, кол-во дочерних объектов)
-или агрегации, но также необходима декларативная фильтрация, то можно определить свой метод DB CRUD,
+или агрегации, но также необходима декларативная фильтрация, то можно новый свой метод менеджера,
 вызвав в нём метод `super().get_filter_expression`:
 ```python
-class MyModelCRUDB[MyModel, MyModelCreateSchema, MyModelUpdateSchema](MyModel):
+class MyModelManager[MyModel, MyModelCreateSchema, MyModelUpdateSchema](MyModel):
     async def get_parents_with_children_count(
         self, session: AsyncSession, **kwargs
     ) -> list[RetrieveParentWithChildrenCountSchema]:
@@ -311,29 +345,64 @@ class MyModelCRUDB[MyModel, MyModelCreateSchema, MyModelUpdateSchema](MyModel):
         )
 
         # Вызываем метод для получения фильтров SQLAlchemy из аргументов методов
-        # filter и paginated_filter BaseCRUD
+        # filter и paginated_filter
         query = query.filter(self.get_filter_expression(**kwargs))
 
         result = await session.execute(query)
         result = result.unique().all()
-        for row in result:
+        for i, row in enumerate(result):
             row.Parent.children_count = row.children_count
-        return [row.Parent for row in result]
+            result[i] = row.Parent
+        return result
 ```
 
 ## Другие полезности
 ### Сохранение пользователя запроса
 
-Задать в создаваемом объекте пользователя запроса можно, передав дополнительный параметр методу `create` (аналогично с `update`)
+Пользователя запроса можно задать в создаваемом/обновляемом объекте,
+передав дополнительный параметр в метод `create` (`update`):
 ```python
 @router.post("")
 async def create_child(
     child_in: CreateUpdateChildSchema, session: CurrentSession, user: CurrentUser
 ) -> CreateUpdateChildSchema:
-    return await child_db.create(session=session, in_obj=child_in, author_id=user.id)
+    return await child_manager.create(session=session, in_obj=child_in, author_id=user.id)
 ```
 
 ### Создание и обновление объектов с M2M связями
-Если на модели определена M2M связь, то использование `BaseCRUD` позволяет передать в это поле список ID объектов.
+Если на модели определена M2M связь, то использование `ModelManager` позволяет передать в это поле список ID объектов.
+
+`fastapi-sqlalchemy-toolkit` провалидирует существование этих объектов и установит им M2M связь,
+без необходимости создавать отдельные эндпоинты для работы с M2M связями.
+
+```python
+# Пусть модели Person и House имеют M2M связь
+from pydantic import BaseModel
+
+
+class PersonCreateSchema(BaseModel):
+    house_ids: list[int]
+
+...
+
+    in_obj = PersonCreateSchema(house_ids=[1, 2, 3])
+    await person_manager.create(session, in_obj)
+    # Создаст объект Person и установит ему M2M связь с House с id 1, 2 и 3
+```
 
-`fastapi-sqlalchemy-toolkit` провалидирует существование этих объектов и установит им M2M связь, без необходимости создавать отдельные эндпоинты для работы с M2M связями.
+### Фильтрация по списку значений
+Один из способов фильтрации по списку значений -- передать этот список в качестве
+квери параметра в строку через запятую.
+`fastapi-sqlalchemy-toolkit` предоставляет утилиту для фильтрации по списку значений, переданного в строку через запятую:
+```python
+from uuid import UUID
+from fastapi_sqlalchemy_toolkit.utils import comma_list_query, get_comma_list_values
+
+@router.get("/children")
+async def get_child_objects(
+    session: CurrentSession,
+    ids: comma_list_query = None,
+) -> list[ChildListSchema]
+    ids = get_comma_list_values(ids, UUID)
+    return await child_manager.filter(session, id=FieldFilter(ids, operator="in_"))
+```

{fastapi_sqlalchemy_toolkit-0.0.2.2 → fastapi_sqlalchemy_toolkit-0.1}/README.md

@@ -32,61 +32,59 @@ pip install fastapi-sqlalchemy-toolkit
 
 Пример использования `fastapi-sqlalchemy-toolkit` доступен в директории `examples/app`
 
-## Получение DB CRUD
+## Инициализация ModelManager
 
-Для использования `fastapi-sqlaclhemy-toolkit` необходимо создать экземпляр `BaseCRUD` для своей модели:
+Для использования `fastapi-sqlaclhemy-toolkit` необходимо создать экземпляр `ModelManager` для своей модели:
 
 ```python
-from fastapi_sqlalchemy_toolkit import BaseCRUD
+from fastapi_sqlalchemy_toolkit import ModelManager
 
 from .models import MyModel
 from .schemas import MyModelCreateSchema, MyModelUpdateSchema
 
-my_model_db = BaseCRUD[MyModel, MyModelCreateSchema, MyModelUpdateSchema](MyModel)
+my_model_manager = ModelManager[MyModel, MyModelCreateSchema, MyModelUpdateSchema](MyModel)
 ```
 
-При инициализации DB CRUD также можно задать параметр `fk_mapping`, необходимый для валидации внешних ключей.
-`fk_mapping` — это словарь, в котором ключи — это названия полей внешних ключей, а значения — модели SQLAlchemy, на которые эти ключи ссылаются.
+При инициализации ModelManager можно задать параметр `fk_mapping`, необходимый для валидации внешних ключей.
+`fk_mapping` — это словарь, в котором ключи — это названия внешних ключей, а значения — модели SQLAlchemy, на которые эти ключи ссылаются.
 
 ```python
-from fastapi_sqlalchemy_toolkit import BaseCRUD
+from fastapi_sqlalchemy_toolkit import ModelManager
 
 from .models import MyModel, MyParentModel
 from .schemas import MyModelCreateSchema, MyModelUpdateSchema
 
-my_model_db = BaseCRUD[MyModel, MyModelCreateSchema, MyModelUpdateSchema](
-    MyModel,
-    fk_mapping={"parent_id": MyParentModel}
+my_model_manager = ModelManager[MyModel, MyModelCreateSchema, MyModelUpdateSchema](
+    MyModel, fk_mapping={"parent_id": MyParentModel}
 )
 ```
 
-Атрибут `default_ordering` определяет сортировку по умолчанию при получении списков объектов. В него нужно передать поле основной модели.
+Атрибут `default_ordering` определяет сортировку по умолчанию при получении списка объектов. В него нужно передать поле основной модели.
 
 ```python
-from fastapi_sqlalchemy_toolkit import BaseCRUD
+from fastapi_sqlalchemy_toolkit import ModelManager
 
 from .models import MyModel
 from .schemas import MyModelCreateSchema, MyModelUpdateSchema
 
-my_model_db = BaseCRUD[MyModel, MyModelCreateSchema, MyModelUpdateSchema](
-    MyModel,
-    default_ordering=MyModel.title
+my_model_manager = ModelManager[MyModel, MyModelCreateSchema, MyModelUpdateSchema](
+    MyModel, default_ordering=MyModel.title
 )
 ```
 
-## Доступные методы `BaseCRUD`
+## Доступные методы `ModelManager`
 
-Ниже перечислены доступные CRUD методы, предоставляемые `BaseCRUD`.
+Ниже перечислены CRUD методы, предоставляемые `ModelManager`.
 Документация параметров, принимаемых методами, находится в докстрингах методов.
 
-- `create` - создание объекта (также выполняет валидацию значений полей на уровне БД)
+- `create` - создание объекта; выполняет валидацию значений полей на уровне БД
 - `get` - получение объекта
-- `get_or_404` - получение объекта или ошибки 404
+- `get_or_404` - получение объекта или ошибки HTTP 404
 - `exists` - проверка существования объекта
-- `paginated_filter` - получение списка объектов с пагинацией через `fastapi_pagination`
-- `filter` - получение списка объектов
+- `paginated_filter` - получение списка объектов с фильтрами и пагинацией через `fastapi_pagination`
+- `filter` - получение списка объектов с фильтрами
 - `count` - получение количества объектов
-- `update` - обновление объекта (также выполняет валидацию значений полей на уровне БД)
+- `update` - обновление объекта; выполняет валидацию значений полей на уровне БД
 - `delete` - удаление объекта
 
 ## Фильтрация
@@ -96,69 +94,86 @@ my_model_db = BaseCRUD[MyModel, MyModelCreateSchema, MyModelUpdateSchema](
 ```python
 from typing import Annotated
 from uuid import UUID
+
 from fastapi import APIRouter, Depends, Response, status
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
+
 from app.deps import get_async_session
-from app.models import MyModel
+from app.models import MyModel, MyParentModel
 from app.schemas import MyObjectListSchema
 
-
 router = APIRouter()
 CurrentSession = Annotated[AsyncSession, Depends(get_async_session)]
 
+
 @router.get("/my-objects")
 async def get_my_objects(
     session: CurrentSession,
     user_id: UUID | None = None,
-    name: str | None = None
+    name: str | None = None,
+    parent_name: str | None = None,
 ) -> list[MyObjectListSchema]:
     stmt = select(MyModel)
     if user_id is not None:
         stmt = stmt.filter_by(user_id=user_id)
     if name is not None:
-        stmt = stmt.filter_by(name=name)
+        stmt = stmt.filter(MyModel.name.ilike == name)
+    if parent_name is not None:
+        stmt = stmt.join(MyModel.parent)
+        stmt = stmt.filter(ParentModel.name.ilike == parent_name)
     result = await session.execute(stmt)
-    return results.scalars().all()
+    return result.scalars().all()
 ```
-Как можно заметить, присутствует дубликация шаблонного кода. А это только строгие сравнения, и поля находятся на основной модели.
+Как можно заметить, для реализации фильтрации необходима дубликация шаблонного кода.
 
 В `fastapi-sqlalchemy-toolkit` этот эндпоинт выглядит так:
 
 ```python
-from app.db_crud import my_object_db
+from fastapi_sqlalchemy_toolkit import FieldFilter
+
+from app.managers import my_object_manager
 
 @router.get("/my-objects")
 async def get_my_objects(
     session: CurrentSession,
     user_id: UUID | None = None,
-    name: str | None = None
+    name: str | None = None,
+    parent_name: str | None = None,
 ) -> list[MyObjectListSchema]:
-    return await my_object_db.filter(session, user_id=user_id, name=name)
+    return await my_object_manager.filter(
+        session,
+        user_id=user_id,
+        name=FieldFilter(name, operator="ilike"),
+        parent_name=FieldFilter(parent_name, operator="ilike", model=ParentModel),
+    )
 ```
 ### Использование FieldFilter
 Дополнительные возможности декларативной фильтрации поддерживаются использованием класса `FieldFilter`.
 `FieldFilter` позволяет:
 - фильтровать по значениям полей связанных моделей при установке атрибута `model`. 
-При этом `BaseCRUD` автоматически сделает необходимые join'ы, если это модель, которая напрямую связана с главной
-- использовать любые операторы сравнения через атрибут `operator`
+При этом `ModelManager` автоматически сделает необходимые join'ы, если это модель, которая напрямую связана с главной
+- использовать любые методы и атрибуты полей SQLAlchemy через атрибут `operator`
 - применять функции SQLAlchemy к полям (например, `date()`) через атрибут `func`
 
 ```python
-from fastapi_sqlalchemy_toolkit import FieldFilter
-from app.db_crud import parent_db
+from app.managers import parent_manager
 from app.models import Child
 
-await parent_db.filter(session, child_title=FieldFilter(value=child_title, model=Child, operator="ilike"))
+from fastapi_sqlalchemy_toolkit import FieldFilter
+
+await parent_manager.filter(
+    session, child_title=FieldFilter(child_title, model=Child, operator="ilike")
+)
 ```
 ### Фильтрация по обратным связям
 Также в методах `filter` и `paginated_filter` есть поддержка фильтрации
 по обратным связям (`relationship()` в направлении один ко многим) с использованием метода `.any()`.
 
 ```python
-# Если Parent.children -- это связь один ко многим
-await parent_db.filter(session, children=[1, 2])
-# Вернёт объекты Parent, у которых есть связь с Child с id 1 или 2
+# Если ParentModel.children -- это связь один ко многим
+await parent_manager.filter(session, children=[1, 2])
+# Вернёт объекты Parent, у которых есть связь с ChildModel с id 1 или 2
 ```
 ### Фильтрация по null
 Для того чтобы осуществить фильтрацию по `null`, квери параметр должен принимать
@@ -170,18 +185,19 @@ from fastapi_sqlalchemy_toolkit import NullableQuery
 @router.get("")
 async def get_children(
     session: CurrentSession,
-    title: NullableQuery | UUID | None = None,
+    activated_at: NullableQuery | datetime.datetime | None = None,
 ) -> Page[ChildRetrieveSchema]:
+    ...
 ```
-`NullableQuery` это пустая строка. То есть запрос с фильтрацией по `title == None` должен выглядеть так:
-`GET /children?title=`
+`NullableQuery` -- это пустая строка. Запрос с фильтрацией по `activated_at == None` должен выглядеть так:
+`GET /children?activated_at=`
 
 *Почему так?*
 
 
-При запросе `GET /children?title=alex` ожидается, что будут возвращены
-объекты с `title == alex`, но при GET `/children` мы не ожидаем, что будут возвращены
-объекты с `title == None`.
+При запросе `GET /children?activated_at=2023-08-01` ожидается, что будут возвращены
+объекты с `activated_at == 2023-08-01`, но при запросе GET `/children` мы не ожидаем, что будут возвращены
+объекты с `activated_at == None` (ожидаемым поведением является отсутствие фильтрации по `activated_at`).
 
 Если в эндпоинте FastAPI определён необязательный квери параметр, и он не передан
 в запросе, то значение этого параметра будет равно `None`. Чтобы не возникала описанная выше некорректная фильтрация, фильтр
@@ -193,7 +209,7 @@ async def get_children(
 а также по полям связанных моделей. При этом необходимые для сортировки по полям
 связанных моделей join'ы будут сделаны автоматически.
 
-Для применения декларативной сортировки нужно сделать следующее:
+Для применения декларативной сортировки нужно:
 1. Определить список полей, по которым доступна фильтрация. Поле может быть
 строкой, если это поле основной модели, или атрибутом модели, если оно находится
 на связанной модели.
@@ -201,12 +217,12 @@ async def get_children(
 ```python
 from app.models import Parent
 
-child_ordering_fields = [
+child_ordering_fields = (
     "title",
     "created_at",
     Parent.title,
     Parent.created_at
-]
+)
 ```
 
 Для каждого из указаных полей будет доступна сортировка по возрастанию и убыванию.
@@ -226,39 +242,40 @@ async def get_child_objects(
     session: CurrentSession,
     order_by: ordering_dep(child_ordering_fields)
 ) -> list[ChildListSchema]
+    ...
 ```
 
-3. Передать параметр сортировки как параметр `order_by` в методы `BaseCRUD`
+3. Передать параметр сортировки как параметр `order_by` в методы `ModelManager`
 
 ```python
-    return await child_db.filter(session=session, order_by=order_by)
+    return await child_manager.filter(session=session, order_by=order_by)
 ```
 
 
 ## Расширение
-Методы `BaseCRUD` легко расширить дополнительной логикой.
+Методы `ModelManager` легко расширить дополнительной логикой.
 
 
-В первую очередь необходимо определить свой класс DB CRUD, унаследовав его от `BaseCRUD`
+В первую очередь необходимо определить свой класс ModelManager:
 
 ```python
-from fastapi_sqlalchemy_toolkit import BaseCRUD
+from fastapi_sqlalchemy_toolkit import ModelManager
 
 
-class MyModelCRUDB[MyModel, MyModelCreateSchema, MyModelUpdateSchema](BaseCRUD):
+class MyModelManager[MyModel, MyModelCreateSchema, MyModelUpdateSchema](ModelManager):
     ...
 ```
 ### Дополнительная валидация
 Дополнительную валидацию можно добавить, переопределив метод `validate`:
 
 ```python
-class MyModelCRUDB[MyModel, MyModelCreateSchema, MyModelUpdateSchema](BaseCRUD):
+class MyModelManager[MyModel, MyModelCreateSchema, MyModelUpdateSchema](ModelManager):
     async def validate_parent_type(self, session: AsyncSession, validated_data: ModelDict) -> None:
         """
         Проверяет тип выбранного объекта Parent
         """
         # объект Parent с таким ID точно есть, так как это проверяется ранее в super().validate
-        parent = await parent_db.get(session, id=in_obj["parent_id"])
+        parent = await parent_manager.get(session, id=in_obj["parent_id"])
         if parent.type != ParentTypes.CanHaveChildren:
             raise HTTPException(
                     status_code=status.HTTP_400_BAD_REQUEST,
@@ -268,19 +285,36 @@ class MyModelCRUDB[MyModel, MyModelCreateSchema, MyModelUpdateSchema](BaseCRUD):
     async def run_db_validation(
             self,
             session: AsyncSession,
-            db_obj: ModelType | None = None,
+            db_obj: MyModel | None = None,
             in_obj: ModelDict | None = None,
         ) -> ModelDict:
         validated_data = await super().validate(session, db_obj, in_obj)
         await self.validate_parent_type(session, validated_data)
         return validated_data
 ```
+
+### Дополнительная бизнес логика при CRUD операциях
+Если при CRUD операциях с моделью необходимо выполнить какую-то дополнительную бизнес логику,
+это можно сделать, переопределив соответствующие методы ModelManager:
+
+```python
+class MyModelManager[MyModel, MyModelCreateSchema, MyModelUpdateSchema](ModelManager):
+    async def create(
+        self, *args, background_tasks: BackgroundTasks | None = None, **kwargs
+    ) -> MyModel:
+    created = await super().create(*args, **kwargs)
+    background_tasks.add_task(send_email, created.id)
+    return created
+```
+
+Такой подход соответствует принципу "Fat Models, Skinny Views" из Django.
+
 ### Использование декларативных фильтров в нестандартных списочных запросах
 Если необходимо получить не просто список объектов, но и какие-то другие поля (допустим, кол-во дочерних объектов)
-или агрегации, но также необходима декларативная фильтрация, то можно определить свой метод DB CRUD,
+или агрегации, но также необходима декларативная фильтрация, то можно новый свой метод менеджера,
 вызвав в нём метод `super().get_filter_expression`:
 ```python
-class MyModelCRUDB[MyModel, MyModelCreateSchema, MyModelUpdateSchema](MyModel):
+class MyModelManager[MyModel, MyModelCreateSchema, MyModelUpdateSchema](MyModel):
     async def get_parents_with_children_count(
         self, session: AsyncSession, **kwargs
     ) -> list[RetrieveParentWithChildrenCountSchema]:
@@ -294,29 +328,64 @@ class MyModelCRUDB[MyModel, MyModelCreateSchema, MyModelUpdateSchema](MyModel):
         )
 
         # Вызываем метод для получения фильтров SQLAlchemy из аргументов методов
-        # filter и paginated_filter BaseCRUD
+        # filter и paginated_filter
         query = query.filter(self.get_filter_expression(**kwargs))
 
         result = await session.execute(query)
         result = result.unique().all()
-        for row in result:
+        for i, row in enumerate(result):
             row.Parent.children_count = row.children_count
-        return [row.Parent for row in result]
+            result[i] = row.Parent
+        return result
 ```
 
 ## Другие полезности
 ### Сохранение пользователя запроса
 
-Задать в создаваемом объекте пользователя запроса можно, передав дополнительный параметр методу `create` (аналогично с `update`)
+Пользователя запроса можно задать в создаваемом/обновляемом объекте,
+передав дополнительный параметр в метод `create` (`update`):
 ```python
 @router.post("")
 async def create_child(
     child_in: CreateUpdateChildSchema, session: CurrentSession, user: CurrentUser
 ) -> CreateUpdateChildSchema:
-    return await child_db.create(session=session, in_obj=child_in, author_id=user.id)
+    return await child_manager.create(session=session, in_obj=child_in, author_id=user.id)
 ```
 
 ### Создание и обновление объектов с M2M связями
-Если на модели определена M2M связь, то использование `BaseCRUD` позволяет передать в это поле список ID объектов.
+Если на модели определена M2M связь, то использование `ModelManager` позволяет передать в это поле список ID объектов.
+
+`fastapi-sqlalchemy-toolkit` провалидирует существование этих объектов и установит им M2M связь,
+без необходимости создавать отдельные эндпоинты для работы с M2M связями.
+
+```python
+# Пусть модели Person и House имеют M2M связь
+from pydantic import BaseModel
+
+
+class PersonCreateSchema(BaseModel):
+    house_ids: list[int]
+
+...
+
+    in_obj = PersonCreateSchema(house_ids=[1, 2, 3])
+    await person_manager.create(session, in_obj)
+    # Создаст объект Person и установит ему M2M связь с House с id 1, 2 и 3
+```
 
-`fastapi-sqlalchemy-toolkit` провалидирует существование этих объектов и установит им M2M связь, без необходимости создавать отдельные эндпоинты для работы с M2M связями.
+### Фильтрация по списку значений
+Один из способов фильтрации по списку значений -- передать этот список в качестве
+квери параметра в строку через запятую.
+`fastapi-sqlalchemy-toolkit` предоставляет утилиту для фильтрации по списку значений, переданного в строку через запятую:
+```python
+from uuid import UUID
+from fastapi_sqlalchemy_toolkit.utils import comma_list_query, get_comma_list_values
+
+@router.get("/children")
+async def get_child_objects(
+    session: CurrentSession,
+    ids: comma_list_query = None,
+) -> list[ChildListSchema]
+    ids = get_comma_list_values(ids, UUID)
+    return await child_manager.filter(session, id=FieldFilter(ids, operator="in_"))
+```

{fastapi_sqlalchemy_toolkit-0.0.2.2 → fastapi_sqlalchemy_toolkit-0.1}/examples/app/.env

@@ -1,5 +1,5 @@
 POSTGRES_DB=postgres
-POSTGRES_USER=postgres
-POSTGRES_PASSWORD=mysecretpassword
+POSTGRES_USER=admin
+POSTGRES_PASSWORD=password123
 POSTGRES_HOST=localhost
 POSTGRES_PORT=5432

{fastapi_sqlalchemy_toolkit-0.0.2.2 → fastapi_sqlalchemy_toolkit-0.1}/examples/app/api/api.py

@@ -1,6 +1,6 @@
 from fastapi import APIRouter
 
-from app.api.endpoints import child
+from .endpoints import child
 
 api_router = APIRouter()
 api_router.include_router(

{fastapi_sqlalchemy_toolkit-0.0.2.2 → fastapi_sqlalchemy_toolkit-0.1}/examples/app/api/endpoints/child.py

@@ -6,10 +6,10 @@ from fastapi_pagination import Page, Params
 from fastapi_sqlalchemy_toolkit import FieldFilter, ordering_dep
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.db_crud import child_db
 from app.deps import get_async_session
+from app.managers import child_manager
 from app.models import Parent
-from app.schemas import CreateUpdateChildSchema, RetrieveChildSchema
+from app.schemas import CreateUpdateChildSchema, HTTPErrorSchema, RetrieveChildSchema
 
 router = APIRouter()
 
@@ -29,7 +29,7 @@ async def get_children(
     parent_title: str | None = None,
     parent_slug: str | None = None,
 ) -> Page[RetrieveChildSchema]:
-    return await child_db.paginated_filter(
+    return await child_manager.paginated_filter(
         session=session,
         pagination_params=params,
         title=FieldFilter(value=title, operator="ilike"),
@@ -40,12 +40,17 @@ async def get_children(
     )
 
 
-@router.get("/{child_id}")
+@router.get(
+    "/{child_id}",
+    responses={
+        status.HTTP_404_NOT_FOUND: {"model": HTTPErrorSchema},
+    },
+)
 async def get_child(
     child_id: UUID,
     session: CurrentSession,
 ) -> RetrieveChildSchema:
-    return await child_db.get_or_404(
+    return await child_manager.get_or_404(
         session=session,
         id=child_id,
     )
@@ -55,21 +60,33 @@ async def get_child(
 async def create_child(
     child_in: CreateUpdateChildSchema, session: CurrentSession
 ) -> CreateUpdateChildSchema:
-    return await child_db.create(session=session, in_obj=child_in)
+    return await child_manager.create(session=session, in_obj=child_in)
 
 
+@router.get(
+    "/{child_id}",
+    responses={
+        status.HTTP_404_NOT_FOUND: {"model": HTTPErrorSchema},
+    },
+)
 @router.patch("/{child_id}")
 async def update_child(
     child_id: UUID, child_in: CreateUpdateChildSchema, session: CurrentSession
 ) -> CreateUpdateChildSchema:
-    child_to_update = await child_db.get_or_404(session=session, id=child_id)
-    return await child_db.update(
+    child_to_update = await child_manager.get_or_404(session=session, id=child_id)
+    return await child_manager.update(
         session=session, db_obj=child_to_update, in_obj=child_in
     )
 
 
+@router.get(
+    "/{child_id}",
+    responses={
+        status.HTTP_404_NOT_FOUND: {"model": HTTPErrorSchema},
+    },
+)
 @router.delete("/{child_id}")
 async def delete_child(child_id: UUID, session: CurrentSession) -> Response:
-    child_to_delete = await child_db.get_or_404(session=session, id=child_id)
-    await child_db.delete(session=session, db_obj=child_to_delete)
+    child_to_delete = await child_manager.get_or_404(session=session, id=child_id)
+    await child_manager.delete(session=session, db_obj=child_to_delete)
     return Response(status_code=status.HTTP_204_NO_CONTENT)

{fastapi_sqlalchemy_toolkit-0.0.2.2 → fastapi_sqlalchemy_toolkit-0.1}/examples/app/config.py

@@ -3,7 +3,6 @@ from pathlib import Path
 from pydantic import FieldValidationInfo, PostgresDsn, field_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
-
 ROOT_DIR = Path(__file__).resolve(strict=True).parent
 
 
@@ -15,10 +14,11 @@ class Settings(BaseSettings):
     POSTGRES_USER: str
     POSTGRES_PASSWORD: str
     POSTGRES_HOST: str
-    POSTGRES_PORT: str
+    POSTGRES_PORT: int
     POSTGRES_DB: str
-    SQLALCHEMY_DATABASE_URL: PostgresDsn | None = None
+    SQLALCHEMY_DATABASE_URL: str | None = None
 
+    SENTRY_DSN: str | None = None
 
     @field_validator("SQLALCHEMY_DATABASE_URL", mode="before")
     def assemble_db_connection_string(
@@ -26,13 +26,15 @@ class Settings(BaseSettings):
     ) -> str | PostgresDsn:
         if isinstance(value, str):
             return value
-        return PostgresDsn.build(
-            scheme="postgresql+asyncpg",
-            username=info.data["POSTGRES_USER"],
-            password=info.data["POSTGRES_PASSWORD"],
-            host=info.data["POSTGRES_HOST"],
-            port=int(info.data["POSTGRES_PORT"]),
-            path=info.data["POSTGRES_DB"],
+        return str(
+            PostgresDsn.build(
+                scheme="postgresql+asyncpg",
+                username=info.data["POSTGRES_USER"],
+                password=info.data["POSTGRES_PASSWORD"],
+                host=info.data["POSTGRES_HOST"],
+                port=info.data["POSTGRES_PORT"],
+                path=info.data["POSTGRES_DB"],
+            )
         )
 
 

{fastapi_sqlalchemy_toolkit-0.0.2.2 → fastapi_sqlalchemy_toolkit-0.1}/examples/app/db.py

@@ -1,11 +1,9 @@
 from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
 from sqlalchemy.orm import sessionmaker
 
-from app.config import settings
+from .config import settings
 
-engine = create_async_engine(
-    str(settings.SQLALCHEMY_DATABASE_URL), future=True, echo=False
-)
+engine = create_async_engine(settings.SQLALCHEMY_DATABASE_URL, future=True, echo=False)
 
 async_session_factory = sessionmaker(
     engine, class_=AsyncSession, expire_on_commit=False

{fastapi_sqlalchemy_toolkit-0.0.2.2 → fastapi_sqlalchemy_toolkit-0.1}/examples/app/deps.py

@@ -2,7 +2,7 @@ from typing import AsyncGenerator
 
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.db import async_session_factory
+from .db import async_session_factory
 
 
 async def get_async_session() -> AsyncGenerator[AsyncSession, None]:

{fastapi_sqlalchemy_toolkit-0.0.2.2 → fastapi_sqlalchemy_toolkit-0.1}/examples/app/main.py

@@ -1,8 +1,7 @@
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 
-from app.api.api import api_router
-
+from .api.api import api_router
 
 app = FastAPI(
     title="fastapi-sqlalchemy-toolkit demo",

fastapi_sqlalchemy_toolkit-0.1/examples/app/managers.py

@@ -0,0 +1,8 @@
+from fastapi_sqlalchemy_toolkit import ModelManager
+
+from .models import Child
+from .schemas import CreateUpdateChildSchema
+
+child_manager = ModelManager[Child, CreateUpdateChildSchema, CreateUpdateChildSchema](
+    Child
+)

{fastapi_sqlalchemy_toolkit-0.0.2.2 → fastapi_sqlalchemy_toolkit-0.1}/examples/app/models.py

@@ -1,9 +1,10 @@
 from uuid import UUID
 
-from fastapi_sqlalchemy_toolkit import Base
 from sqlalchemy import ForeignKey
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
+from fastapi_sqlalchemy_toolkit import Base
+
 
 class Parent(Base):
     title: Mapped[str]

{fastapi_sqlalchemy_toolkit-0.0.2.2 → fastapi_sqlalchemy_toolkit-0.1}/examples/app/schemas.py

@@ -22,4 +22,8 @@ class RetrieveChildSchema(ChildBaseSchema):
 
 
 class RetrieveParentSchema(ParentBaseSchema):
-    children: list[ChildBaseSchema | None]
+    children: list[ChildBaseSchema] | None
+
+
+class HTTPErrorSchema(BaseModel):
+    detail: str

fastapi_sqlalchemy_toolkit-0.1/fastapi_sqlalchemy_toolkit/__init__.py

@@ -0,0 +1,4 @@
+from .base_model import Base
+from .filters import FieldFilter
+from .model_manager import ModelManager
+from .ordering import ordering_dep

{fastapi_sqlalchemy_toolkit-0.0.2.2 → fastapi_sqlalchemy_toolkit-0.1}/fastapi_sqlalchemy_toolkit/filters.py

@@ -30,9 +30,9 @@ class FieldFilter:
         :param operator: Атрибут/метод модели, с помощью которого нужно фильтровать
         :param func: Функция SQLAlchemy, которую нужно применить к полю
         :param model: Модель SQLAlchemy, к которой применяется фильтр
-        По умолчанию, модель из DB CRUD, в котором вызывается метод.
+        По умолчанию, модель из ModelManager, в котором вызывается метод.
         :param alias: Название поля модели
-        (по умолчанию название параметра, по которому фильтр передаётся в db_crud)
+        (по умолчанию название параметра, по которому фильтр передаётся в ModelManager)
         """
         self.value = value
         self.operator = operator

fastapi_sqlalchemy_toolkit-0.0.2.2/fastapi_sqlalchemy_toolkit/db_crud.py → fastapi_sqlalchemy_toolkit-0.1/fastapi_sqlalchemy_toolkit/model_manager.py

@@ -22,7 +22,7 @@ UpdateSchemaType = TypeVar("UpdateSchemaType", bound=BaseModel)
 ModelDict = dict[str, Any]
 
 
-class BaseCRUD(Generic[ModelType, CreateSchemaType, UpdateSchemaType]):
+class ModelManager(Generic[ModelType, CreateSchemaType, UpdateSchemaType]):
     def __init__(
         self,
         model: Type[ModelType],
@@ -30,7 +30,7 @@ class BaseCRUD(Generic[ModelType, CreateSchemaType, UpdateSchemaType]):
         default_ordering: InstrumentedAttribute | None = None,
     ) -> None:
         """
-        Создание экземпляра DB CRUD под конкретную модель.
+        Создание экземпляра ModelManager под конкретную модель.
 
         :param model: модель SQLAlchemy
 
@@ -38,7 +38,7 @@ class BaseCRUD(Generic[ModelType, CreateSchemaType, UpdateSchemaType]):
         которые являются внешними ключами, и модели SQLAlchemy,
         на которые ключи ссылаются.
         Этот параметр нужно определить для валидации внешних ключей.
-        Например, если DB CRUD создаётся для модели Child, которая имеет
+        Например, если ModelManager создаётся для модели Child, которая имеет
         внешний ключ parent_id на модель Parent, то нужно передать
         fk_mapping={"parent_id": Parent}
 
@@ -162,10 +162,11 @@ class BaseCRUD(Generic[ModelType, CreateSchemaType, UpdateSchemaType]):
         """
 
         db_obj = await self.get(session=session, **attrs)
+        attrs_str = ", ".join([f"{key}={value}" for key, value in attrs.items()])
         if not db_obj:
             raise HTTPException(
                 status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"{self.model.__tablename__.capitalize()} not found",
+                detail=f"{self.model.__tablename__} with {attrs_str} not found",
             )
         return db_obj
 
@@ -507,9 +508,9 @@ class BaseCRUD(Generic[ModelType, CreateSchemaType, UpdateSchemaType]):
                 )
                 if not related_object_exists:
                     raise HTTPException(
-                        status_code=status.HTTP_400_BAD_REQUEST,
+                        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
                         detail=(
-                            f"{self.fk_mapping[key].__tablename__} с ID "
+                            f"{self.fk_mapping[key].__tablename__} с id "
                             f"{in_obj[key]} не существует."
                         ),
                     )
@@ -528,7 +529,7 @@ class BaseCRUD(Generic[ModelType, CreateSchemaType, UpdateSchemaType]):
             if object_exists:
                 conflicting_fields = ", ".join(unique_constraint)
                 raise HTTPException(
-                    status_code=status.HTTP_400_BAD_REQUEST,
+                    status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
                     detail=(
                         f"{self.model.__tablename__} с такими "
                         + conflicting_fields
@@ -553,7 +554,7 @@ class BaseCRUD(Generic[ModelType, CreateSchemaType, UpdateSchemaType]):
                 check_unique = await self.exists(session=session, **attrs_to_check)
                 if check_unique:
                     raise HTTPException(
-                        status_code=status.HTTP_400_BAD_REQUEST,
+                        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
                         detail=(
                             f"{self.model.__tablename__} c {column.name} "
                             f"{in_obj[column.name]} уже существует"
@@ -569,9 +570,9 @@ class BaseCRUD(Generic[ModelType, CreateSchemaType, UpdateSchemaType]):
                     related_object = await session.get(related_model, related_object_id)
                     if not related_object:
                         raise HTTPException(
-                            status_code=status.HTTP_400_BAD_REQUEST,
+                            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
                             detail=(
-                                f"{related_model.__tablename__} с ID "
+                                f"{related_model.__tablename__} с id "
                                 f"{related_object_id} не существует."
                             ),
                         )

{fastapi_sqlalchemy_toolkit-0.0.2.2 → fastapi_sqlalchemy_toolkit-0.1}/fastapi_sqlalchemy_toolkit/utils.py

@@ -1,10 +1,10 @@
-from typing import Any, Optional, Type
+from typing import Annotated, Any, Optional, Type
 
 import pydantic
 from fastapi import Query
 
 
-class AllOptional(pydantic.main.ModelMetaclass):
+class AllOptional(pydantic._internal._model_construction.ModelMetaclass):
     """
     Метакласс, который делает все поля модели Pydantic необязательными.
     Полезно для схем PATCH запросов.
@@ -33,13 +33,16 @@ class AllOptional(pydantic.main.ModelMetaclass):
 
 # Утилиты для передачи нескольких значений для фильтрации в одном
 # квери параметре через запятую
-comma_list_query = Query(
-    description="Несколько значений можно передать через запятую",
-    default=None,
-)
+comma_list_query = Annotated[
+    str | None, Query(description="Несколько значений можно передать через запятую")
+]
 
 
 def get_comma_list_values(query: str | None, type_: Type) -> list | None:
+    """
+    :param query: Значение квери параметра
+    :param type_: Тип значений в списке
+    """
     if query:
         return [type_(query_value) for query_value in query.split(",")]
     return None

{fastapi_sqlalchemy_toolkit-0.0.2.2 → fastapi_sqlalchemy_toolkit-0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "fastapi_sqlalchemy_toolkit"
-version = "0.0.2.2"
+version = "0.1"
 authors = [
   { name="Egor Kondrashov", email="e.kondr01@gmail.com" },
 ]
@@ -20,7 +20,7 @@ dependencies = [
     "sqlalchemy>=2.0.0",
     "fastapi_pagination>=0.12.6",
     "pydantic>=2.0.0",
-    "dateutil>=2.8.2"
+    "python-dateutil>=2.8.2"
 ]
 
 [project.urls]

fastapi_sqlalchemy_toolkit-0.0.2.2/examples/app/db_crud.py

@@ -1,7 +0,0 @@
-from fastapi_sqlalchemy_toolkit import BaseCRUD
-
-from app.models import Child, Parent
-from app.schemas import CreateUpdateChildSchema, ParentBaseSchema
-
-child_db = BaseCRUD[Child, CreateUpdateChildSchema, CreateUpdateChildSchema](Child)
-parent_db = BaseCRUD[Parent, ParentBaseSchema, ParentBaseSchema](Parent)

fastapi_sqlalchemy_toolkit-0.0.2.2/fastapi_sqlalchemy_toolkit/__init__.py

@@ -1,4 +0,0 @@
-from .base_model import Base
-from .db_crud import BaseCRUD
-from .ordering import ordering_dep
-from .filters import FieldFilter