fastapi-sqlalchemy-toolkit 0.6.13__tar.gz → 0.7.0__tar.gz

{fastapi_sqlalchemy_toolkit-0.6.13 → fastapi_sqlalchemy_toolkit-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi_sqlalchemy_toolkit
-Version: 0.6.13
+Version: 0.7.0
 Summary: FastAPI SQLAlchemy Toolkit
 Project-URL: Homepage, https://github.com/e-kondr01/fastapi-sqlalchemy-toolkit
 Author-email: Egor Kondrashov <e.kondr01@gmail.com>
@@ -34,7 +34,7 @@ REST API и взаимодействии с СУБД через `SQLAlchemy`;
 
 - Фильтрация с обработкой необязательных параметров запроса (см. раздел **Фильтрация**)
 
-- Декларативная сортировка с помощью `ordering_dep` (см. раздел **Сортировка**)
+- Декларативная сортировка с помощью `ordering_depends` (см. раздел **Сортировка**)
 
 - Валидация существования внешних ключей
 
@@ -426,37 +426,49 @@ async def get_my_objects(
 связанных моделей join'ы будут сделаны автоматически.
 
 Для применения декларативной сортировки нужно:
-1. Определить список полей, по которым доступна фильтрация. Поле может быть
-строкой, если это поле основной модели, или атрибутом модели, если оно находится
-на связанной модели.
+1. Определить поля, по которым доступна фильтрация.
+
+Это может быть либо списком/кортежем полей основной модели:
 
 ```python
-from app.models import Parent
+from app.models import Child
 
 child_ordering_fields = (
-    "title",
-    "created_at",
-    Parent.title,
-    Parent.created_at
+    Child.title,
+    Child.created_at
 )
 ```
 
-Для каждого из указаных полей будет доступна сортировка по возрастанию и убыванию.
-Чтобы сортировать по полю по убыванию, нужно в квери параметре сортировки
-передать его название, начиная с дефиса (Django style).
-Таким образом, `?order_by=title` сортирует по `title` по возрастанию,
-а `?order_by=-title` сортирует по `title` по убыванию.
+В таком случае, будут доступны следующий параметря для сортировки:
+`title`, `-title`, `created_at`, `-created_at`.
+
+Дефис первым символом означает направление сортировки по убыванию.
+
+Либо можно определить маппинг строковых полей для сортировки
+на соответствующие поля моделей:
+
+```python
+from app.models import Child, Parent
+
+child_ordering_fields = (
+    "title": MyModel.title,
+    "parent_title": ParentModel.title
+)
+```
+
+В таком случае, будут доступны следующий параметря для сортировки:
+`title`, `-title`, `parent_title`, `-parent_title`.
 
 2. В параметрах энпдоинта передать определённый выше список
-в `ordering_dep`
+в `ordering_depends`
 
 ```python
-from fastapi_sqlalchemy_toolkit import ordering_dep
+from fastapi_sqlalchemy_toolkit import ordering_depends
 
 @router.get("/children")
 async def get_child_objects(
     session: Session,
-    order_by: ordering_dep(child_ordering_fields)
+    order_by: ordering_depends(child_ordering_fields)
 ) -> list[ChildListSchema]
     ...
 ```
@@ -467,6 +479,61 @@ async def get_child_objects(
     return await child_manager.list(session=session, order_by=order_by)
 ```
 
+Если `order_by` передаётся в методы `list` или `paginated_list`,
+и поле для сортировки относится к модели, напрямую связанную с основной,
+то будет выполнен необходимый `join` для применения сортировки.
+
+## Транзакции
+
+`fastapi-sqlalchemy-toolkit` поддерживает оба подхода к работе с транзакциями `SQAlchemy`.
+
+### Commit as you go
+
+https://docs.sqlalchemy.org/en/20/orm/session_transaction.html#commit-as-you-go
+
+```python
+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
+from app.managers import my_model_manager
+
+...
+
+    engine = create_async_engine(
+        "...",
+    )
+    async with async_sessionmaker(engine) as session:
+        # This call produces SQL COMMIT
+        created_obj = await my_model_manager.create(session, input_data)
+        # This call does not produce SQL COMMIT
+        await my_model_manager.update(session, created_obj, name="updated_name", commit=False)
+    # Only 1st statement is persisted
+```
+
+### Begin once
+
+https://docs.sqlalchemy.org/en/20/orm/session_transaction.html#begin-once
+
+```python
+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
+from app.managers import my_model_manager
+
+...
+
+    engine = create_async_engine(
+        "...",
+    )
+    # Start transaction with context manager
+    async with async_sessionmaker(engine) as session, session.begin():
+        # This call only flushes, no SQL COMMIT yet
+        created_obj = await my_model_manager.create(session, input_data)
+        # This call only flushes, no SQL COMMIT yet
+        await my_model_manager.update(session, created_obj, name="updated_name")
+    # Everything is SQL COMMITed, if no errors occured in nested block
+```
+
+## Создание и обновление объектов
+
+TODO...
+
 
 ## Расширение
 Методы `ModelManager` легко расширить дополнительной логикой.

{fastapi_sqlalchemy_toolkit-0.6.13 → fastapi_sqlalchemy_toolkit-0.7.0}/README.md

@@ -17,7 +17,7 @@ REST API и взаимодействии с СУБД через `SQLAlchemy`;
 
 - Фильтрация с обработкой необязательных параметров запроса (см. раздел **Фильтрация**)
 
-- Декларативная сортировка с помощью `ordering_dep` (см. раздел **Сортировка**)
+- Декларативная сортировка с помощью `ordering_depends` (см. раздел **Сортировка**)
 
 - Валидация существования внешних ключей
 
@@ -409,37 +409,49 @@ async def get_my_objects(
 связанных моделей join'ы будут сделаны автоматически.
 
 Для применения декларативной сортировки нужно:
-1. Определить список полей, по которым доступна фильтрация. Поле может быть
-строкой, если это поле основной модели, или атрибутом модели, если оно находится
-на связанной модели.
+1. Определить поля, по которым доступна фильтрация.
+
+Это может быть либо списком/кортежем полей основной модели:
 
 ```python
-from app.models import Parent
+from app.models import Child
 
 child_ordering_fields = (
-    "title",
-    "created_at",
-    Parent.title,
-    Parent.created_at
+    Child.title,
+    Child.created_at
 )
 ```
 
-Для каждого из указаных полей будет доступна сортировка по возрастанию и убыванию.
-Чтобы сортировать по полю по убыванию, нужно в квери параметре сортировки
-передать его название, начиная с дефиса (Django style).
-Таким образом, `?order_by=title` сортирует по `title` по возрастанию,
-а `?order_by=-title` сортирует по `title` по убыванию.
+В таком случае, будут доступны следующий параметря для сортировки:
+`title`, `-title`, `created_at`, `-created_at`.
+
+Дефис первым символом означает направление сортировки по убыванию.
+
+Либо можно определить маппинг строковых полей для сортировки
+на соответствующие поля моделей:
+
+```python
+from app.models import Child, Parent
+
+child_ordering_fields = (
+    "title": MyModel.title,
+    "parent_title": ParentModel.title
+)
+```
+
+В таком случае, будут доступны следующий параметря для сортировки:
+`title`, `-title`, `parent_title`, `-parent_title`.
 
 2. В параметрах энпдоинта передать определённый выше список
-в `ordering_dep`
+в `ordering_depends`
 
 ```python
-from fastapi_sqlalchemy_toolkit import ordering_dep
+from fastapi_sqlalchemy_toolkit import ordering_depends
 
 @router.get("/children")
 async def get_child_objects(
     session: Session,
-    order_by: ordering_dep(child_ordering_fields)
+    order_by: ordering_depends(child_ordering_fields)
 ) -> list[ChildListSchema]
     ...
 ```
@@ -450,6 +462,61 @@ async def get_child_objects(
     return await child_manager.list(session=session, order_by=order_by)
 ```
 
+Если `order_by` передаётся в методы `list` или `paginated_list`,
+и поле для сортировки относится к модели, напрямую связанную с основной,
+то будет выполнен необходимый `join` для применения сортировки.
+
+## Транзакции
+
+`fastapi-sqlalchemy-toolkit` поддерживает оба подхода к работе с транзакциями `SQAlchemy`.
+
+### Commit as you go
+
+https://docs.sqlalchemy.org/en/20/orm/session_transaction.html#commit-as-you-go
+
+```python
+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
+from app.managers import my_model_manager
+
+...
+
+    engine = create_async_engine(
+        "...",
+    )
+    async with async_sessionmaker(engine) as session:
+        # This call produces SQL COMMIT
+        created_obj = await my_model_manager.create(session, input_data)
+        # This call does not produce SQL COMMIT
+        await my_model_manager.update(session, created_obj, name="updated_name", commit=False)
+    # Only 1st statement is persisted
+```
+
+### Begin once
+
+https://docs.sqlalchemy.org/en/20/orm/session_transaction.html#begin-once
+
+```python
+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
+from app.managers import my_model_manager
+
+...
+
+    engine = create_async_engine(
+        "...",
+    )
+    # Start transaction with context manager
+    async with async_sessionmaker(engine) as session, session.begin():
+        # This call only flushes, no SQL COMMIT yet
+        created_obj = await my_model_manager.create(session, input_data)
+        # This call only flushes, no SQL COMMIT yet
+        await my_model_manager.update(session, created_obj, name="updated_name")
+    # Everything is SQL COMMITed, if no errors occured in nested block
+```
+
+## Создание и обновление объектов
+
+TODO...
+
 
 ## Расширение
 Методы `ModelManager` легко расширить дополнительной логикой.

fastapi_sqlalchemy_toolkit-0.7.0/examples/app/api/deps.py

@@ -0,0 +1,14 @@
+from typing import Annotated, AsyncGenerator
+
+from app.db import async_session_factory
+from fastapi import Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+
+
+async def get_async_session() -> AsyncGenerator[AsyncSession, None]:
+    async_session = async_session_factory()  # type: ignore
+    async with async_session:
+        yield async_session
+
+
+Session = Annotated[AsyncSession, Depends(get_async_session)]

{fastapi_sqlalchemy_toolkit-0.6.13 → fastapi_sqlalchemy_toolkit-0.7.0}/examples/app/api/endpoints/child.py

@@ -1,8 +1,7 @@
 from datetime import date
-from typing import Annotated
 from uuid import UUID
 
-from app.deps import get_async_session
+from app.api.deps import Session
 from app.managers import child_manager
 from app.models import Child, Parent
 from app.schemas import (
@@ -12,26 +11,28 @@ from app.schemas import (
     HTTPErrorSchema,
     PatchChildSchema,
 )
-from fastapi import APIRouter, Depends, Response, status
-from fastapi_pagination import Page, Params
+from fastapi import APIRouter, Response, status
+from fastapi_pagination import Page
 from sqlalchemy import func
-from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import joinedload
 
-from fastapi_sqlalchemy_toolkit import ordering_dep
+from fastapi_sqlalchemy_toolkit import ordering_depends
 
 router = APIRouter()
 
-Session = Annotated[AsyncSession, Depends(get_async_session)]
-PaginationParams = Annotated[Params, Depends()]
 
-children_ordering_fields = (Parent.created_at, Parent.title, "created_at", "title")
+children_ordering_fields = {
+    "title": Child.title,
+    "created_at": Child.created_at,
+    "parent_title": Parent.title,
+    "parent_created_at": Parent.created_at,
+}
 
 
 @router.get("")
 async def get_list(
     session: Session,
-    order_by: ordering_dep(children_ordering_fields),
+    order_by: ordering_depends(children_ordering_fields),
     title: str | None = None,
     slug: str | None = None,
     parent_title: str | None = None,

{fastapi_sqlalchemy_toolkit-0.6.13 → fastapi_sqlalchemy_toolkit-0.7.0}/examples/app/config.py

@@ -18,8 +18,6 @@ class Settings(BaseSettings):
     POSTGRES_DB: str
     SQLALCHEMY_DATABASE_URL: str | None = None
 
-    SENTRY_DSN: str | None = None
-
     @field_validator("SQLALCHEMY_DATABASE_URL", mode="before")
     def assemble_db_connection_string(
         cls, value: PostgresDsn | None, info: FieldValidationInfo

fastapi_sqlalchemy_toolkit-0.7.0/examples/app/db.py

@@ -0,0 +1,7 @@
+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
+
+from .config import settings
+
+engine = create_async_engine(settings.SQLALCHEMY_DATABASE_URL, future=True, echo=False)
+
+async_session_factory = async_sessionmaker(engine, expire_on_commit=False)

{fastapi_sqlalchemy_toolkit-0.6.13 → fastapi_sqlalchemy_toolkit-0.7.0}/examples/app/models.py

@@ -1,7 +1,5 @@
 from datetime import datetime
-from uuid import UUID
-from uuid import UUID as _py_uuid
-from uuid import uuid4
+from uuid import UUID, uuid4
 
 from sqlalchemy import DateTime, ForeignKey, func
 from sqlalchemy.orm import (
@@ -14,8 +12,10 @@ from sqlalchemy.orm import (
 
 
 class Base(DeclarativeBase):
-    id: Mapped[_py_uuid] = mapped_column(
-        UUID(as_uuid=True), primary_key=True, default=uuid4
+    id: Mapped[UUID] = mapped_column(
+        primary_key=True,
+        default=uuid4,
+        server_default=func.gen_random_uuid(),
     )
 
     created_at: Mapped[datetime] = mapped_column(

{fastapi_sqlalchemy_toolkit-0.6.13 → fastapi_sqlalchemy_toolkit-0.7.0}/fastapi_sqlalchemy_toolkit/__init__.py

@@ -1,4 +1,4 @@
 from .filters import NullableQuery
 from .model_manager import ModelManager, sqlalchemy_model_to_dict
-from .ordering import ordering_dep
+from .ordering import ordering_depends
 from .utils import CommaSepQuery, comma_sep_q_to_list, make_partial_model

{fastapi_sqlalchemy_toolkit-0.6.13 → fastapi_sqlalchemy_toolkit-0.7.0}/fastapi_sqlalchemy_toolkit/model_manager.py

@@ -15,7 +15,6 @@ from sqlalchemy.sql.functions import Function
 from sqlalchemy.sql.selectable import Exists
 
 from .filters import null_query_values
-from .ordering import OrderingField
 
 ModelT = TypeVar("ModelT", bound=DeclarativeBase)
 CreateSchemaT = TypeVar("CreateSchemaT", bound=BaseModel)
@@ -129,7 +128,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
         await self.run_db_validation(session, in_obj=create_data)
         db_obj = self.model(**create_data)
         session.add(db_obj)
-        await self.maybe_commit(session, commit)
+        await self.persist(session, commit)
         await session.refresh(db_obj, attribute_names=refresh_attribute_names)
         return db_obj
 
@@ -137,7 +136,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
         self,
         session: AsyncSession,
         options: List[Any] | Any | None = None,
-        order_by: OrderingField | None = None,
+        order_by: InstrumentedAttribute | UnaryExpression | None = None,
         where: Any | None = None,
         base_stmt: Select | None = None,
         **simple_filters: Any,
@@ -149,7 +148,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
 
         :param options: параметры для метода .options() загрузчика SQLAlchemy
 
-        :param order_by: поле для сортировки (экземпляр OrderingField)
+        :param order_by: поле для сортировки
 
         :param where: выражение, которое будет передано в метод .where() SQLAlchemy
 
@@ -174,7 +173,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
         self,
         session: AsyncSession,
         options: List[Any] | Any | None = None,
-        order_by: OrderingField | None = None,
+        order_by: InstrumentedAttribute | UnaryExpression | None = None,
         where: Any | None = None,
         base_stmt: Select | None = None,
         **simple_filters: Any,
@@ -186,7 +185,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
 
         :param options: параметры для метода .options() загрузчика SQLAlchemy
 
-        :param order_by: поле для сортировки (экземпляр OrderingField)
+        :param order_by: поле для сортировки
 
         :param where: выражение, которое будет передано в метод .where() SQLAlchemy
 
@@ -294,7 +293,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
     async def paginated_filter(
         self,
         session: AsyncSession,
-        order_by: OrderingField | None = None,
+        order_by: InstrumentedAttribute | UnaryExpression | None = None,
         options: List[Any] | Any | None = None,
         where: Any | None = None,
         base_stmt: Select | None = None,
@@ -306,7 +305,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
 
         :param session: сессия SQLAlchemy
 
-        :param order_by: поле для сортировки (экземпляр OrderingField)
+        :param order_by: поле для сортировки
 
         :param options: параметры для метода .options() загрузчика SQLAlchemy
 
@@ -330,7 +329,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
     async def paginated_list(
         self,
         session: AsyncSession,
-        order_by: OrderingField | None = None,
+        order_by: InstrumentedAttribute | UnaryExpression | None = None,
         filter_expressions: dict[InstrumentedAttribute | Callable, Any] | None = None,
         nullable_filter_expressions: dict[InstrumentedAttribute | Callable, Any]
         | None = None,
@@ -346,7 +345,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
 
         :param session: сессия SQLAlchemy
 
-        :param order_by: поле для сортировки (экземпляр OrderingField)
+        :param order_by: поле для сортировки
 
         :param filter_expressions: словарь, отображающий поля для фильтрации
         на их значения. Фильтрация по None не применяется. См. раздел "фильтрация"
@@ -405,7 +404,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
     async def filter(
         self,
         session: AsyncSession,
-        order_by: OrderingField | None = None,
+        order_by: InstrumentedAttribute | UnaryExpression | None = None,
         options: List[Any] | Any | None = None,
         where: Any | None = None,
         unique: bool = False,
@@ -417,7 +416,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
 
         :param session: сессия SQLAlchemy
 
-        :param order_by: поле для сортировки (экземпляр OrderingField)
+        :param order_by: поле для сортировки
 
         :param options: параметры для метода .options() загрузчика SQLAlchemy
 
@@ -446,7 +445,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
     async def list(
         self,
         session: AsyncSession,
-        order_by: OrderingField | None = None,
+        order_by: InstrumentedAttribute | UnaryExpression | None = None,
         filter_expressions: dict[InstrumentedAttribute | Callable, Any] | None = None,
         nullable_filter_expressions: dict[InstrumentedAttribute | Callable, Any]
         | None = None,
@@ -462,7 +461,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
 
         :param session: сессия SQLAlchemy
 
-        :param order_by: поле для сортировки (экземпляр OrderingField)
+        :param order_by: поле для сортировки
 
         :param filter_expressions: словарь, отображающий поля для фильтрации
         на их значения. Фильтрация по None не применяется. См. раздел "фильтрация"
@@ -525,7 +524,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
         self,
         session: AsyncSession,
         options: List[Any] | Any | None = None,
-        order_by: OrderingField | None = None,
+        order_by: InstrumentedAttribute | UnaryExpression | None = None,
         where: Any | None = None,
         **simple_filters: Any,
     ) -> int:
@@ -536,7 +535,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
 
         :param options: параметры для метода .options() загрузчика SQLAlchemy
 
-        :param order_by: поле для сортировки (экземпляр OrderingField)
+        :param order_by: поле для сортировки
 
         :param where: выражение, которое будет передано в метод .where() SQLAlchemy
 
@@ -603,13 +602,13 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
         for field in update_data:
             setattr(db_obj, field, update_data[field])
         session.add(db_obj)
-        await self.maybe_commit(session, commit)
+        await self.persist(session, commit)
         await session.refresh(db_obj, attribute_names=refresh_attribute_names)
         return db_obj
 
     async def delete(
         self, session: AsyncSession, db_obj: ModelT, commit: bool = True
-    ) -> ModelT | None:
+    ) -> ModelT:
         """
         Удаление экземпляра модели из БД.
 
@@ -619,9 +618,11 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
 
         :param commit: нужно ли вызывать `session.commit()`, если используется
         подход commit as you go
+
+        :returns: переданный в функцию экземпляр модели
         """
         await session.delete(db_obj)
-        await self.maybe_commit(session, commit)
+        await self.persist(session, commit)
         return db_obj
 
     ##################################################################################
@@ -629,21 +630,25 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
     ##################################################################################
 
     @staticmethod
-    async def maybe_commit(session: AsyncSession, commit: bool = True) -> None:
+    async def persist(session: AsyncSession, commit: bool = True) -> None:
         """
-        Обработка необходимости коммита при разном использовании сессии:
-        подходах commit as you go и begin once.
+        Сохраняет изменения в БД, обрабатывая разное использовании сессии:
+        "commit as you go" или "begin once".
 
-        Если используется подход commit as you go, и параметр :commit: передан
-        True, то выполняется commit.
+        Если используется подход "commit as you go", и параметр :commit: передан
+        True, то выполняется `commit()`; иначе `flush()`.
 
-        Если используется подход begin once (`async with session.begin():`),
-        то commit не выполняется, чтобы не закрывать транзакцию в контекстном
+        Если используется подход "begin once" (`async with session.begin():`),
+        то не выполняется `flush()`, чтобы не закрывать транзакцию в контекстном
         менеджере.
         """
 
-        if not session.sync_session._trans_context_manager and commit:
+        if session.sync_session._trans_context_manager:
+            await session.flush()
+        elif commit:
             await session.commit()
+        else:
+            await session.flush()
 
     async def run_db_validation(
         self,
@@ -676,7 +681,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
         base_query: Select,
         filter_expressions: dict[InstrumentedAttribute | Callable, Any],
         options: List[Any] | None = None,
-        order_by: OrderingField | None = None,
+        order_by: InstrumentedAttribute | UnaryExpression | None = None,
     ) -> Select:
         """
         Делает необходимые join'ы при фильтрации и сортировке по полям
@@ -691,12 +696,16 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
 
         joined_query = base_query
         models_to_join = set()
-        if (
-            order_by
-            and not isinstance(order_by.field, str)
-            and order_by.field.parent.class_ != self.model
-        ):
-            models_to_join.add(order_by.field.parent.class_)
+
+        if order_by:
+            if isinstance(order_by, InstrumentedAttribute):
+                ordering_model = order_by.parent.class_
+            else:
+                ordering_model = order_by._propagate_attrs[
+                    "plugin_subject"
+                ]._identity_class
+            if ordering_model != self.model:
+                models_to_join.add(ordering_model)
 
         for filter_expression in filter_expressions.keys():
             if isinstance(filter_expression, InstrumentedAttribute):
@@ -725,11 +734,13 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
                 options.append(contains_eager(self.models_to_relationship_attrs[model]))
         return joined_query
 
-    def get_order_by_expression(self, order_by: OrderingField | None):
+    def get_order_by_expression(
+        self, order_by: InstrumentedAttribute | UnaryExpression | None
+    ):
         if order_by is not None:
             if self.default_ordering is not None:
-                return order_by.get_directed_field(self.model), self.default_ordering
-            return order_by.get_directed_field(self.model)
+                return order_by, self.default_ordering
+            return order_by
         return self.default_ordering
 
     @staticmethod
@@ -777,7 +788,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
     def assemble_stmt(
         self,
         base_stmt: Select | None = None,
-        order_by: OrderingField | None = None,
+        order_by: InstrumentedAttribute | UnaryExpression | None = None,
         options: List[Any] | Any | None = None,
         where: Any | None = None,
         **simple_filters: Any,

fastapi_sqlalchemy_toolkit-0.7.0/fastapi_sqlalchemy_toolkit/ordering.py

@@ -0,0 +1,68 @@
+from enum import Enum
+from typing import Annotated, Sequence
+from uuid import uuid4
+
+from fastapi import Depends
+from sqlalchemy.orm.attributes import InstrumentedAttribute
+from sqlalchemy.sql.elements import UnaryExpression
+
+
+def get_ordering_enum(
+    ordering_fields_mapping: dict[str, InstrumentedAttribute],
+) -> Enum:
+    """
+    Собирает Enum из возможных значений сортировки для документации OpenAPI
+    """
+    enum_attrs = {}
+    for field_name in ordering_fields_mapping:
+        enum_attrs[field_name] = field_name
+        enum_attrs[f"desc_{field_name}"] = "-" + field_name
+    return Enum(str(uuid4()), enum_attrs)
+
+
+def ordering_depends(
+    ordering_fields: Sequence[InstrumentedAttribute] | dict[str, InstrumentedAttribute]
+):
+    """
+    Создаёт fastapi.Depends для квери параметра сортировки по переданным полям модели.
+
+    :ordering_fields: поля для сортировки.
+    Может быть последовательностью полей основной модели:
+    ordering_fields=(MyModel.title, MyModel.created_at)
+    В таком случае будут доступны параметры сортировки "title", "-title",
+    "created_at", "-created_at".
+    Дефис первым символом означает сортировку по убыванию.
+    Либо может быть маппингом строковых полей для сортировки
+    на соответствующие поля моделей:
+    ordering_fields={
+        "title": MyModel.title,
+        "parent_title": ParentModel.title
+    }
+    В таком случае будут доступны параметры сортировки "title", "-title",
+    "parent_title", "-parent_title".
+    Если order_by передаётся в методы list или paginated_list,
+    и поле для сортировки относится к модели, напрямую связанную с основной,
+    то будет выполнен необходимый join для применения сортировки.
+    """
+
+    if isinstance(ordering_fields, dict):
+        ordering_fields_mapping = ordering_fields
+
+    else:
+        ordering_fields_mapping = {field.name: field for field in ordering_fields}
+
+    def get_ordering_field(
+        order_by: get_ordering_enum(ordering_fields_mapping) = None,
+    ) -> InstrumentedAttribute | UnaryExpression | None:
+        if order_by:
+            desc = order_by.value.startswith("-")
+            field = ordering_fields_mapping[order_by.value.lstrip("-")]
+            if desc:
+                return field.desc()
+            return field
+        return None
+
+    return Annotated[
+        InstrumentedAttribute | UnaryExpression | None,
+        Depends(get_ordering_field),
+    ]

{fastapi_sqlalchemy_toolkit-0.6.13 → fastapi_sqlalchemy_toolkit-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "fastapi_sqlalchemy_toolkit"
-version = "0.6.13"
+version = "0.7.0"
 authors = [
   { name="Egor Kondrashov", email="e.kondr01@gmail.com" },
 ]

fastapi_sqlalchemy_toolkit-0.6.13/examples/app/db.py

@@ -1,10 +0,0 @@
-from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
-from sqlalchemy.orm import sessionmaker
-
-from .config import settings
-
-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.6.13/examples/app/deps.py

@@ -1,13 +0,0 @@
-from typing import AsyncGenerator
-
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from .db import async_session_factory
-
-
-async def get_async_session() -> AsyncGenerator[AsyncSession, None]:
-    async_session: AsyncSession = async_session_factory()  # type: ignore
-    try:
-        yield async_session
-    finally:
-        await async_session.close()

fastapi_sqlalchemy_toolkit-0.6.13/fastapi_sqlalchemy_toolkit/ordering.py

@@ -1,71 +0,0 @@
-from dataclasses import dataclass
-from enum import Enum
-from typing import Annotated, Sequence, Type
-from uuid import uuid4
-
-from fastapi import Depends
-from sqlalchemy.orm import DeclarativeBase
-from sqlalchemy.orm.attributes import InstrumentedAttribute
-
-
-@dataclass
-class OrderingField:
-    """
-    Класс для направленный сортировки по полям модели SQLAlchemy
-    или полям связанных с ней моделей.
-    """
-
-    field: InstrumentedAttribute | str
-    desc: bool = False
-
-    def get_directed_field(self, model: Type[DeclarativeBase]):
-        if isinstance(self.field, str):
-            field = getattr(model, self.field)
-        else:
-            field = self.field
-        if self.desc:
-            return field.desc()
-        return field
-
-
-def get_ordering_enum(
-    ordering_fields: Sequence[str | InstrumentedAttribute],
-) -> Type[Enum]:
-    """
-    Собирает Enum из возможных значений сортировки для документации OpenAPI
-    """
-    enum_attrs = {}
-    for field in ordering_fields:
-        if isinstance(field, str):
-            field_name = field
-        else:
-            # Если передан атрибут модели
-            field_name = str(field).lower().replace(".", "_")
-        enum_attrs[field_name] = field_name
-        enum_attrs[f"desc_{field_name}"] = "-" + field_name
-    return Enum(str(uuid4()), enum_attrs)
-
-
-def ordering_dep(ordering_fields: Sequence[str | InstrumentedAttribute]):
-    """
-    Создаёт Depends из FastAPI для квери параметра сортировки по переданным полям.
-    Поля могут быть строками (поле основной модели) либо атрибутами моделей SQLAlchemy,
-    связанных с основной.
-    """
-
-    def get_ordering_field(
-        order_by: get_ordering_enum(ordering_fields) = None,
-    ) -> OrderingField | None:
-        if order_by:
-            desc = False
-            if order_by.value.startswith("-"):
-                desc = True
-            for field in ordering_fields:
-                if str(field).lower().replace(".", "_") == order_by.value.lstrip("-"):
-                    return OrderingField(field=field, desc=desc)
-        return None
-
-    return Annotated[
-        OrderingField | None,
-        Depends(get_ordering_field),
-    ]