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

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

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

@@ -278,6 +278,27 @@ async def get_parents(
 
 `GET /parents?title=foo&slug=bar` — both filters are applied with `AND`.
 
+**Case 4: Expression with a falsy value** (`MyModel.column.in_(value)`, `MyModel.column.endswith(value)`, `MyModel.column.startswith(value)`)
+
+If `value` is an empty list (`[]`) or an empty string (`""`), the filter is skipped.
+This covers `in_([])`, `endswith("")`, `startswith("")` and similar operators.
+
+```python
+@router.get("/parents")
+async def get_parents(
+    session: Session,
+    slugs: list[str] = Query(default=[]),
+) -> list[ParentListSchema]:
+    return await parent_manager.list(
+        session,
+        optional_where=Parent.slug.in_(slugs),
+    )
+```
+
+`GET /parents` — no filter applied, all `Parent` objects are returned.
+
+`GET /parents?slugs=foo&slugs=bar` — only `Parent` objects whose `slug` is in `['foo', 'bar']` are returned.
+
 > **Note**: nesting of compound expressions (e.g. `(a & b) | c`) is not supported.
 
 **Multiple expressions as separate arguments**

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

@@ -218,6 +218,10 @@ async def get_parents(
 
 Аналогично кейсу 1 — если `value` равно `None`, фильтр пропускается.
 
+Также если `value` является пустым списком (`[]`) или пустой строкой (`""`), фильтр пропускается.
+Это распространяется на `in_([])`, `endswith("")`, `startswith("")` и аналогичные операторы, которые
+не допускают передачи `None`.
+
 ```python
 @router.get("/parents")
 async def get_parents(

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

@@ -26,7 +26,7 @@ from sqlalchemy.orm import DeclarativeBase, contains_eager, load_only
 from sqlalchemy.orm.attributes import InstrumentedAttribute
 from sqlalchemy.orm.relationships import Relationship
 from sqlalchemy.sql import Select
-from sqlalchemy.sql.elements import Null, UnaryExpression
+from sqlalchemy.sql.elements import BindParameter, Null, UnaryExpression
 from sqlalchemy.sql.expression import BinaryExpression, ColumnElement
 from sqlalchemy.sql.functions import Function
 from sqlalchemy.sql.schema import ScalarElementColumnDefault
@@ -46,6 +46,15 @@ def sqlalchemy_model_to_dict(model: DeclarativeBase) -> dict:
     return db_obj_dict
 
 
+def _is_falsy_bind_param(right: Any) -> bool:
+    """Return True if *right* is a BindParameter with a falsy str or list value."""
+    return (
+        isinstance(right, BindParameter)
+        and isinstance(right.value, str | list)
+        and not right.value
+    )
+
+
 def _get_model_pk(model: type[DeclarativeBase]) -> InstrumentedAttribute:
     """Получить атрибут первичного ключа для произвольной модели."""
     pk_columns = list(model.__table__.primary_key.columns)
@@ -1148,10 +1157,8 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
                 model = filter_expression.parent._identity_class
             elif isinstance(filter_expression, Function):
                 model = filter_expression.entity_namespace
-            elif isinstance(filter_expression, ColumnElement):
-                model = self.model  # Not supported
             else:
-                model = filter_expression.__self__.parent._identity_class
+                model = self.model  # Not supported
             if model != self.model:
                 models_to_join.add(model)
         for model in models_to_join:
@@ -1238,16 +1245,20 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
     @classmethod
     def handle_optional_where_expression(cls, optional_where: Any) -> Any:
         """
-        Обрабатывает одно выражение optional_where, пропуская фильтр, если его значение None.
+        Обрабатывает одно выражение optional_where, пропуская фильтр,
+        если его значение None.
 
         Поддерживает:
         1. Простые выражения вида MyModel.field == value
         2. Выражения с функциями/операторами вида func.date(MyModel.field) == value
         3. Составные выражения вида (expr1) & (expr2) или (expr1) | (expr2)
            (без вложенности)
+        4. Выражения с "пустым" значением вида MyModel.column.in_([]),
+           MyModel.column.endswith(""), MyModel.column.startswith("")
 
-        Если value равно None, фильтр не применяется.
-        В составных выражениях исключаются части с value == None,
+        Если value равно None или является пустой строкой/списком,
+        фильтр не применяется.
+        В составных выражениях исключаются части с такими значениями,
         при этом оператор & или | сохраняется.
         """
         if optional_where is None:
@@ -1259,17 +1270,17 @@ class ModelManager(Generic[ModelT, CreateSchemaT, UpdateSchemaT]):
                 clause
                 for clause in optional_where.clauses
                 if not isinstance(clause.right, Null)
+                and not _is_falsy_bind_param(getattr(clause, "right", None))
             ]
             if not remaining:
                 return None
             if len(remaining) == 1:
                 return remaining[0]
-            if optional_where.operator.__name__ == "and_":
-                return and_(*remaining)
-            return or_(*remaining)
+            combiner = and_ if optional_where.operator.__name__ == "and_" else or_
+            return combiner(*remaining)
 
-        # simple binary expression
-        if isinstance(getattr(optional_where, "right", None), Null):
+        right = getattr(optional_where, "right", None)
+        if isinstance(right, Null) or _is_falsy_bind_param(right):
             return None
         return optional_where
 

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

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

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

@@ -1079,6 +1079,122 @@ async def test_list_with_optional_where_multi_all_none(session: AsyncSession):
     assert len(parents) == 2
 
 
+async def test_list_with_optional_where_in_applied(session: AsyncSession):
+    """Case 4: in_ expression, non-empty list — filter is applied."""
+    target_slug = "optional-where-in-slug1"
+    await session.execute(
+        insert(Parent),
+        [
+            {"title": "optional-where-in-title-1", "slug": target_slug},
+            {"title": "optional-where-in-title-2", "slug": "optional-where-in-slug2"},
+        ],
+    )
+    await session.commit()
+
+    parents = await parent_manager.list(
+        session=session,
+        optional_where=Parent.slug.in_([target_slug]),
+    )
+    assert len(parents) == 1
+    assert parents[0].slug == target_slug
+
+
+async def test_list_with_optional_where_in_skipped(session: AsyncSession):
+    """Case 4: in_ expression, empty list — filter is skipped (all returned)."""
+    await session.execute(
+        insert(Parent),
+        [
+            {
+                "title": "optional-where-in-skip-title-1",
+                "slug": "optional-where-in-skip-slug1",
+            },
+            {
+                "title": "optional-where-in-skip-title-2",
+                "slug": "optional-where-in-skip-slug2",
+            },
+        ],
+    )
+    await session.commit()
+
+    parents = await parent_manager.list(
+        session=session,
+        optional_where=Parent.slug.in_([]),
+    )
+    assert len(parents) == 2
+
+
+async def test_list_with_optional_where_endswith_applied(session: AsyncSession):
+    """Case 4: endswith expression, non-empty string — filter is applied."""
+    target_slug = "optional-where-ends-slug-xyz"
+    await session.execute(
+        insert(Parent),
+        [
+            {"title": "optional-where-ends-title-1", "slug": target_slug},
+            {
+                "title": "optional-where-ends-title-2",
+                "slug": "optional-where-ends-slug-abc",
+            },
+        ],
+    )
+    await session.commit()
+
+    parents = await parent_manager.list(
+        session=session,
+        optional_where=Parent.slug.endswith("xyz"),
+    )
+    assert len(parents) == 1
+    assert parents[0].slug == target_slug
+
+
+async def test_list_with_optional_where_endswith_skipped(session: AsyncSession):
+    """Case 4: endswith expression, empty string — filter is skipped (all returned)."""
+    await session.execute(
+        insert(Parent),
+        [
+            {
+                "title": "optional-where-ends-skip-title-1",
+                "slug": "optional-where-ends-skip-slug1",
+            },
+            {
+                "title": "optional-where-ends-skip-title-2",
+                "slug": "optional-where-ends-skip-slug2",
+            },
+        ],
+    )
+    await session.commit()
+
+    parents = await parent_manager.list(
+        session=session,
+        optional_where=Parent.slug.endswith(""),
+    )
+    assert len(parents) == 2
+
+
+async def test_list_with_optional_where_in_compound_one_empty(session: AsyncSession):
+    """Case 4 in compound: in_([]) in & expression — only non-empty filter applied."""
+    target_title = "optional-where-compound-in-title"
+    await session.execute(
+        insert(Parent),
+        [
+            {"title": target_title, "slug": "optional-where-compound-in-slug1"},
+            {"title": target_title, "slug": "optional-where-compound-in-slug2"},
+            {
+                "title": "optional-where-compound-in-other",
+                "slug": "optional-where-compound-in-slug3",
+            },
+        ],
+    )
+    await session.commit()
+
+    parents = await parent_manager.list(
+        session=session,
+        optional_where=(Parent.title == target_title) & Parent.slug.in_([]),
+    )
+    assert len(parents) == 2
+    for parent in parents:
+        assert parent.title == target_title
+
+
 async def test_create_unique_constraint_validation(session: AsyncSession):
     await parent_manager.create(
         session=session,