fastapi-sqlalchemy-toolkit 0.8.2__tar.gz → 0.8.2.1__tar.gz

{fastapi_sqlalchemy_toolkit-0.8.2 → fastapi_sqlalchemy_toolkit-0.8.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi_sqlalchemy_toolkit
-Version: 0.8.2
+Version: 0.8.2.1
 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.8.2 → fastapi_sqlalchemy_toolkit-0.8.2.1}/docs/filtering.md

@@ -280,6 +280,31 @@ async def get_parents(
 
 > **Note**: nesting of compound expressions (e.g. `(a & b) | c`) is not supported.
 
+**Multiple expressions as separate arguments**
+
+Instead of using `&` to combine expressions, you can pass them as separate arguments
+in a tuple. Each argument supports all three expression kinds above. Non-`None`
+expressions are combined with `AND`.
+
+```python
+@router.get("/parents")
+async def get_parents(
+    session: Session,
+    title: str | None = None,
+    slug: str | None = None,
+) -> list[ParentListSchema]:
+    return await parent_manager.list(
+        session,
+        optional_where=(Parent.title == title, Parent.slug == slug),
+    )
+```
+
+`GET /parents` — no filter applied, all `Parent` objects are returned.
+
+`GET /parents?title=foo` — only the `title` filter is applied.
+
+`GET /parents?title=foo&slug=bar` — both filters are applied with `AND`.
+
 ### Filtering by `null` via API
 
 If in a list API endpoint, you need to be able to filter the field value

{fastapi_sqlalchemy_toolkit-0.8.2 → fastapi_sqlalchemy_toolkit-0.8.2.1}/docs/ru/filtering.md

@@ -257,6 +257,31 @@ async def get_parents(
 
 > **Примечание**: вложенные составные выражения (например, `(a & b) | c`) не поддерживаются.
 
+**Несколько выражений как отдельные аргументы**
+
+Вместо использования `&` для объединения выражений можно передать их как отдельные
+аргументы в виде кортежа. Каждый аргумент поддерживает все три вида выражений выше.
+Оставшиеся (не-`None`) выражения объединяются через `AND`.
+
+```python
+@router.get("/parents")
+async def get_parents(
+    session: Session,
+    title: str | None = None,
+    slug: str | None = None,
+) -> list[ParentListSchema]:
+    return await parent_manager.list(
+        session,
+        optional_where=(Parent.title == title, Parent.slug == slug),
+    )
+```
+
+Запрос `GET /parents` — фильтр не применяется, возвращаются все объекты `Parent`.
+
+Запрос `GET /parents?title=foo` — применяется только фильтр по `title`.
+
+Запрос `GET /parents?title=foo&slug=bar` — применяются оба фильтра через `AND`.
+
 ## Фильтрация без дополнительной обработки
 
 Для фильтрации без дополнительной обработки в методах `list` и `paginated_list` можно

{fastapi_sqlalchemy_toolkit-0.8.2 → fastapi_sqlalchemy_toolkit-0.8.2.1}/fastapi_sqlalchemy_toolkit/model_manager.py

@@ -1235,10 +1235,10 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
         related_pk = _get_model_pk(related_model)
         return relationship.any(related_pk.in_(value))
 
-    @staticmethod
-    def handle_optional_where(optional_where: Any) -> Any:
+    @classmethod
+    def handle_optional_where_expression(cls, optional_where: Any) -> Any:
         """
-        Обрабатывает выражение optional_where, пропуская фильтры, значения которых None.
+        Обрабатывает одно выражение optional_where, пропуская фильтр, если его значение None.
 
         Поддерживает:
         1. Простые выражения вида MyModel.field == value
@@ -1273,6 +1273,30 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
             return None
         return optional_where
 
+    @classmethod
+    def handle_optional_where(cls, optional_where: Any) -> Any:
+        """
+        Обрабатывает выражения optional_where, пропуская фильтры, значения которых None.
+
+        Принимает одно выражение SQLAlchemy или кортеж выражений.
+        Каждое выражение обрабатывается через handle_optional_where_expression
+        и поддерживает все три вида выражений.
+        При передаче кортежа оставшиеся (не-None) выражения
+        объединяются через оператор &.
+        """
+        if isinstance(optional_where, tuple):
+            remaining = []
+            for arg in optional_where:
+                processed = cls.handle_optional_where_expression(arg)
+                if processed is not None:
+                    remaining.append(processed)
+            if not remaining:
+                return None
+            if len(remaining) == 1:
+                return remaining[0]
+            return and_(*remaining)
+        return cls.handle_optional_where_expression(optional_where)
+
     def assemble_stmt(
         self,
         base_stmt: Select | None = None,
@@ -1317,10 +1341,7 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
             stmt = stmt.options(option)
 
         if where is not None:
-            if isinstance(where, tuple):
-                stmt = stmt.where(*where)
-            else:
-                stmt = stmt.where(where)
+            stmt = stmt.where(*where) if isinstance(where, tuple) else stmt.where(where)
 
         if limit is not None:
             stmt = stmt.limit(limit)

{fastapi_sqlalchemy_toolkit-0.8.2 → fastapi_sqlalchemy_toolkit-0.8.2.1}/pyproject.toml

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

{fastapi_sqlalchemy_toolkit-0.8.2 → fastapi_sqlalchemy_toolkit-0.8.2.1}/tests/test_public_methods.py

@@ -990,6 +990,95 @@ async def test_list_with_optional_where_case3_or_one_none(session: AsyncSession)
     assert parents[0].title == target_title
 
 
+async def test_list_with_optional_where_multi_all_applied(session: AsyncSession):
+    """Multi-arg: both values not None — both filters applied with AND."""
+    target_title = "optional-where-multi-title"
+    target_slug = "optional-where-multi-slug1"
+    await session.execute(
+        insert(Parent),
+        [
+            {
+                "title": target_title,
+                "slug": target_slug,
+            },
+            {
+                "title": target_title,
+                "slug": "optional-where-multi-slug2",
+            },
+            {
+                "title": "optional-where-multi-title-other",
+                "slug": "optional-where-multi-slug3",
+            },
+        ],
+    )
+    await session.commit()
+
+    parents = await parent_manager.list(
+        session=session,
+        optional_where=(Parent.title == target_title, Parent.slug == target_slug),
+    )
+    assert len(parents) == 1
+    assert parents[0].title == target_title
+    assert parents[0].slug == target_slug
+
+
+async def test_list_with_optional_where_multi_one_none(session: AsyncSession):
+    """Multi-arg: one value is None — only non-None filter applied."""
+    target_title = "optional-where-multi-none-title"
+    await session.execute(
+        insert(Parent),
+        [
+            {
+                "title": target_title,
+                "slug": "optional-where-multi-none-slug1",
+            },
+            {
+                "title": target_title,
+                "slug": "optional-where-multi-none-slug2",
+            },
+            {
+                "title": "optional-where-multi-none-title-other",
+                "slug": "optional-where-multi-none-slug3",
+            },
+        ],
+    )
+    await session.commit()
+
+    none_value = None
+    parents = await parent_manager.list(
+        session=session,
+        optional_where=(Parent.title == target_title, Parent.slug == none_value),
+    )
+    assert len(parents) == 2
+    for parent in parents:
+        assert parent.title == target_title
+
+
+async def test_list_with_optional_where_multi_all_none(session: AsyncSession):
+    """Multi-arg: all values are None — filter skipped (all returned)."""
+    await session.execute(
+        insert(Parent),
+        [
+            {
+                "title": "optional-where-multi-all-none-title-1",
+                "slug": "optional-where-multi-all-none-slug1",
+            },
+            {
+                "title": "optional-where-multi-all-none-title-2",
+                "slug": "optional-where-multi-all-none-slug2",
+            },
+        ],
+    )
+    await session.commit()
+
+    none_value = None
+    parents = await parent_manager.list(
+        session=session,
+        optional_where=(Parent.title == none_value, Parent.slug == none_value),
+    )
+    assert len(parents) == 2
+
+
 async def test_create_unique_constraint_validation(session: AsyncSession):
     await parent_manager.create(
         session=session,