fastapi-sqlalchemy-toolkit 0.7.19__tar.gz → 0.8.0__tar.gz

{fastapi_sqlalchemy_toolkit-0.7.19 → fastapi_sqlalchemy_toolkit-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi_sqlalchemy_toolkit
-Version: 0.7.19
+Version: 0.8.0
 Summary: FastAPI SQLAlchemy Toolkit
 Project-URL: Homepage, https://github.com/e-kondr01/fastapi-sqlalchemy-toolkit
 Author-email: Egor Kondrashov <e.kondr01@gmail.com>

{fastapi_sqlalchemy_toolkit-0.7.19 → fastapi_sqlalchemy_toolkit-0.8.0}/fastapi_sqlalchemy_toolkit/__init__.py

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

{fastapi_sqlalchemy_toolkit-0.7.19 → fastapi_sqlalchemy_toolkit-0.8.0}/fastapi_sqlalchemy_toolkit/model_manager.py

@@ -1,6 +1,6 @@
 # ruff: noqa: UP006
 from collections.abc import Callable, Iterable
-from typing import Any, Generic, List, TypeVar  # noqa: UP035
+from typing import Any, Generic, List, TypeVar, overload  # noqa: UP035
 
 from fastapi import HTTPException, status
 from fastapi_pagination.bases import BasePage
@@ -44,6 +44,12 @@ def sqlalchemy_model_to_dict(model: DeclarativeBase) -> dict:
     return db_obj_dict
 
 
+def _get_model_pk(model: type[DeclarativeBase]) -> InstrumentedAttribute:
+    """Получить атрибут первичного ключа для произвольной модели."""
+    pk_columns = list(model.__table__.primary_key.columns)
+    return getattr(model, pk_columns[0].name)
+
+
 class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
     def __init__(
         self,
@@ -61,6 +67,15 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
         self.model = model
         self.default_ordering = default_ordering
 
+        # Introspect primary key
+        pk_columns = list(self.model.__table__.primary_key.columns)
+        if len(pk_columns) != 1:
+            raise ValueError(
+                f"{self.model.__name__} has a composite primary key, "
+                f"which is not supported by ModelManager."
+            )
+        self.pk_column: InstrumentedAttribute = getattr(self.model, pk_columns[0].name)
+
         # str() of FK attr to related model
         # "parent_id": <class app.models.parent.Parent>
         # Используется для валидации существования FK при создании/обновлении объекта
@@ -79,7 +94,11 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
                 elif isinstance(table_arg, Index) and table_arg.unique is True:
                     self.unique_indexes.append(table_arg)
 
+        # str of reverse relationship to its Model
+        # "parents": <class app.models.parent.Parent>
         self.reverse_relationships: dict[str, type[ModelT]] = {}
+        # str of M2M relationship to its Model
+        # "parents": <class app.models.parent.Parent>
         self.m2m_relationships: dict[str, type[ModelT]] = {}
         # Model to related attr
         # Parent : Child.parent
@@ -215,6 +234,32 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
             return result.scalars().all()
         return None
 
+    @overload
+    async def get(
+        self,
+        session: AsyncSession,
+        options: List[Any] | Any | None = ...,
+        order_by: InstrumentedAttribute | UnaryExpression | None = ...,
+        where: Any | None = ...,
+        base_stmt: None = ...,
+        *,
+        unique: bool = ...,
+        **simple_filters: Any,
+    ) -> ModelT | None: ...
+
+    @overload
+    async def get(
+        self,
+        session: AsyncSession,
+        options: List[Any] | Any | None = ...,
+        order_by: InstrumentedAttribute | UnaryExpression | None = ...,
+        where: Any | None = ...,
+        base_stmt: Select = ...,
+        *,
+        unique: bool = ...,
+        **simple_filters: Any,
+    ) -> Row | None: ...
+
     async def get(
         self,
         session: AsyncSession,
@@ -261,6 +306,32 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
             return result.scalar_one_or_none()
         return result.first()
 
+    @overload
+    async def get_or_404(
+        self,
+        session: AsyncSession,
+        options: List[Any] | Any | None = ...,
+        order_by: InstrumentedAttribute | UnaryExpression | None = ...,
+        where: Any | None = ...,
+        base_stmt: None = ...,
+        *,
+        unique: bool = ...,
+        **simple_filters: Any,
+    ) -> ModelT: ...
+
+    @overload
+    async def get_or_404(
+        self,
+        session: AsyncSession,
+        options: List[Any] | Any | None = ...,
+        order_by: InstrumentedAttribute | UnaryExpression | None = ...,
+        where: Any | None = ...,
+        base_stmt: Select = ...,
+        *,
+        unique: bool = ...,
+        **simple_filters: Any,
+    ) -> Row: ...
+
     async def get_or_404(
         self,
         session: AsyncSession,
@@ -340,7 +411,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
         :returns: True если объект существует, иначе False
         """
         stmt = self.assemble_stmt(
-            select(self.model.id), None, options, where, **simple_filters
+            select(self.pk_column), None, options, where, **simple_filters
         )
         result = await session.execute(stmt)
         return result.first() is not None
@@ -388,6 +459,30 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
             )
         return True
 
+    @overload
+    async def paginated_filter(
+        self,
+        session: AsyncSession,
+        order_by: InstrumentedAttribute | UnaryExpression | None = ...,
+        options: List[Any] | Any | None = ...,
+        where: Any | None = ...,
+        base_stmt: None = ...,
+        transformer: Callable | None = ...,
+        **simple_filters: Any,
+    ) -> BasePage[ModelT]: ...
+
+    @overload
+    async def paginated_filter(
+        self,
+        session: AsyncSession,
+        order_by: InstrumentedAttribute | UnaryExpression | None = ...,
+        options: List[Any] | Any | None = ...,
+        where: Any | None = ...,
+        base_stmt: Select = ...,
+        transformer: Callable | None = ...,
+        **simple_filters: Any,
+    ) -> BasePage[Row]: ...
+
     async def paginated_filter(
         self,
         session: AsyncSession,
@@ -397,7 +492,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
         base_stmt: Select | None = None,
         transformer: Callable | None = None,
         **simple_filters: Any,
-    ) -> BasePage[ModelT | Row]:
+    ) -> BasePage[Any]:
         """
         Получение списка объектов с фильтрами и пагинацией.
 
@@ -424,6 +519,38 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
         stmt = self.assemble_stmt(base_stmt, order_by, options, where, **simple_filters)
         return await paginate(session, stmt, transformer=transformer)
 
+    @overload
+    async def paginated_list(
+        self,
+        session: AsyncSession,
+        order_by: InstrumentedAttribute | UnaryExpression | None = ...,
+        filter_expressions: dict[InstrumentedAttribute | Callable, Any] | None = ...,
+        nullable_filter_expressions: (
+            dict[InstrumentedAttribute | Callable, Any] | None
+        ) = ...,
+        options: List[Any] | Any | None = ...,
+        where: Any | None = ...,
+        base_stmt: None = ...,
+        transformer: Callable | None = ...,
+        **simple_filters: Any,
+    ) -> BasePage[ModelT]: ...
+
+    @overload
+    async def paginated_list(
+        self,
+        session: AsyncSession,
+        order_by: InstrumentedAttribute | UnaryExpression | None = ...,
+        filter_expressions: dict[InstrumentedAttribute | Callable, Any] | None = ...,
+        nullable_filter_expressions: (
+            dict[InstrumentedAttribute | Callable, Any] | None
+        ) = ...,
+        options: List[Any] | Any | None = ...,
+        where: Any | None = ...,
+        base_stmt: Select = ...,
+        transformer: Callable | None = ...,
+        **simple_filters: Any,
+    ) -> BasePage[Row]: ...
+
     async def paginated_list(
         self,
         session: AsyncSession,
@@ -437,7 +564,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
         base_stmt: Select | None = None,
         transformer: Callable | None = None,
         **simple_filters: Any,
-    ) -> BasePage[ModelT | Row]:
+    ) -> BasePage[Any]:
         """
         Получение списка объектов с фильтрами и пагинацией.
         Пропускает фильтры, значения которых None.
@@ -498,6 +625,36 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
 
         return await paginate(session, stmt, transformer=transformer)
 
+    @overload
+    async def filter(
+        self,
+        session: AsyncSession,
+        order_by: InstrumentedAttribute | UnaryExpression | None = ...,
+        options: List[Any] | Any | None = ...,
+        where: Any | None = ...,
+        base_stmt: None = ...,
+        limit: int | None = ...,
+        offset: int | None = ...,
+        *,
+        unique: bool = ...,
+        **simple_filters: Any,
+    ) -> List[ModelT]: ...
+
+    @overload
+    async def filter(
+        self,
+        session: AsyncSession,
+        order_by: InstrumentedAttribute | UnaryExpression | None = ...,
+        options: List[Any] | Any | None = ...,
+        where: Any | None = ...,
+        base_stmt: Select = ...,
+        limit: int | None = ...,
+        offset: int | None = ...,
+        *,
+        unique: bool = ...,
+        **simple_filters: Any,
+    ) -> List[Row]: ...
+
     async def filter(
         self,
         session: AsyncSession,
@@ -510,7 +667,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
         *,
         unique: bool = False,
         **simple_filters: Any,
-    ) -> List[ModelT] | List[Row]:
+    ) -> List[Any]:
         """
         Получение списка объектов с фильтрами
 
@@ -554,6 +711,44 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
             return result.scalars().all()
         return result.all()
 
+    @overload
+    async def list(
+        self,
+        session: AsyncSession,
+        order_by: InstrumentedAttribute | UnaryExpression | None = ...,
+        filter_expressions: dict[InstrumentedAttribute | Callable, Any] | None = ...,
+        nullable_filter_expressions: (
+            dict[InstrumentedAttribute | Callable, Any] | None
+        ) = ...,
+        options: List[Any] | Any | None = ...,
+        where: Any | None = ...,
+        base_stmt: None = ...,
+        limit: int | None = ...,
+        offset: int | None = ...,
+        *,
+        unique: bool = ...,
+        **simple_filters: Any,
+    ) -> List[ModelT]: ...
+
+    @overload
+    async def list(
+        self,
+        session: AsyncSession,
+        order_by: InstrumentedAttribute | UnaryExpression | None = ...,
+        filter_expressions: dict[InstrumentedAttribute | Callable, Any] | None = ...,
+        nullable_filter_expressions: (
+            dict[InstrumentedAttribute | Callable, Any] | None
+        ) = ...,
+        options: List[Any] | Any | None = ...,
+        where: Any | None = ...,
+        base_stmt: Select = ...,
+        limit: int | None = ...,
+        offset: int | None = ...,
+        *,
+        unique: bool = ...,
+        **simple_filters: Any,
+    ) -> List[Row]: ...
+
     async def list(
         self,
         session: AsyncSession,
@@ -570,7 +765,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
         *,
         unique: bool = False,
         **simple_filters: Any,
-    ) -> List[ModelT] | List[Row]:
+    ) -> List[Any]:
         """
         Получение списка объектов с фильтрами.
         Пропускает фильтры, значения которых None.
@@ -666,8 +861,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
 
         :returns: количество объектов по переданным фильтрам
         """
-        # TODO: reference primary key instead of hardcode model.id
-        stmt = select(func.count(self.model.id))
+        stmt = select(func.count(self.pk_column))
         if where is not None:
             stmt = stmt.where(where)
         if simple_filters:
@@ -764,7 +958,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
 
         stmt = update(self.model).values(update_data)
         if ids:
-            stmt = stmt.where(self.model.id.in_(ids))
+            stmt = stmt.where(self.pk_column.in_(ids))
         elif where is not None:
             stmt = stmt.where(where)
         if returning:
@@ -820,7 +1014,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
         """
         stmt = delete(self.model)
         if ids:
-            stmt = stmt.where(self.model.id.in_(ids))
+            stmt = stmt.where(self.pk_column.in_(ids))
         elif where is not None:
             stmt = stmt.where(where)
         await session.execute(stmt)
@@ -993,7 +1187,9 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
         value: Any,
     ) -> Exists:
         relationship: InstrumentedAttribute = getattr(self.model, field_name)
-        return relationship.any(self.reverse_relationships[field_name].id.in_(value))
+        related_model = self.reverse_relationships[field_name]
+        related_pk = _get_model_pk(related_model)
+        return relationship.any(related_pk.in_(value))
 
     def assemble_stmt(
         self,
@@ -1091,17 +1287,19 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
 
         for key in in_obj:
             if key in self.fk_name_to_model and in_obj[key] is not None:
+                related_model = self.fk_name_to_model[key]
+                related_pk = _get_model_pk(related_model)
                 related_object_exists = await session.get(
-                    self.fk_name_to_model[key],
+                    related_model,
                     in_obj[key],
-                    options=[load_only(self.fk_name_to_model[key].id)],
+                    options=[load_only(related_pk)],
                 )
                 if not related_object_exists:
                     raise HTTPException(
-                        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                        status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
                         detail=self.get_error_msg(
-                            self.fk_name_to_model[key].__tablename__,
-                            ["id"],
+                            related_model.__tablename__,
+                            [related_pk.name],
                             field_values=[in_obj[key]],
                             exists=False,
                         ),
@@ -1126,11 +1324,13 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
                 continue
             if query:
                 object_exists = await self.exists(
-                    session, **query, where=(self.model.id != in_obj.get("id"))
+                    session,
+                    **query,
+                    where=(self.pk_column != in_obj.get(self.pk_column.name)),
                 )
                 if object_exists:
                     raise HTTPException(
-                        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                        status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
                         detail=self.get_error_msg(
                             self.model.__tablename__, unique_constraint
                         ),
@@ -1157,11 +1357,11 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
                 object_exists = await self.exists(
                     session,
                     **attrs_to_check,
-                    where=(self.model.id != in_obj.get("id")),
+                    where=(self.pk_column != in_obj.get(self.pk_column.name)),
                 )
                 if object_exists:
                     raise HTTPException(
-                        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                        status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
                         detail=self.get_error_msg(
                             self.model.__tablename__,
                             [column.name],
@@ -1192,7 +1392,11 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
 
             object_exists = await self.exists(
                 session,
-                where=and_(*filters, condition, self.model.id != in_obj.get("id")),
+                where=and_(
+                    *filters,
+                    condition,
+                    self.pk_column != in_obj.get(self.pk_column.name),
+                ),
             )
             if object_exists:
                 raise HTTPException(
@@ -1212,7 +1416,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
                     related_object = await session.get(related_model, related_object_id)
                     if not related_object:
                         raise HTTPException(
-                            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
                             detail=self.get_error_msg(
                                 related_model.__tablename__,
                                 ["id"],