feature: allow sending exporting models parameters to to_binary_expressions and apply_filters methods (#23)

Author: ViAchKoN

README.md

@@ -119,6 +119,45 @@ query = query.filter(*binary_expression)
 query = query.apply_filters(query=query)
 ```
 
+Sometimes, it is necessary to manipulate sent data before applying filters. 
+For example, a field should not be directly converted to a filter; instead, custom logic should be applied. 
+As of version `0.1.3`, the `to_binary_expressions` and `apply_filters` methods accept the `export_params` argument to address this situation. 
+Values mentioned in the Pydantic dictionary [export section](https://docs.pydantic.dev/1.10/usage/exporting_models/ ) can be sent as `export_params`.
+
+```python
+import typing
+
+class CustomBaseModel(SqlAlchemyFilterBaseModel):
+    id__gte: int = None
+    name__in: typing.List[str] = None
+    filter_to_exclude: typing.Any = None 
+    
+    class ConverterConfig:
+        model = SomeModel 
+    
+
+custom_dataclass = CustomBaseModel(
+    id__gte=1,
+    name__in=['abc', 'def'],
+    filter_to_exclude="filter_value",
+)
+
+# filter_to_exclude field will be excluded from converting basemodel to sqlalchemy filters
+
+binary_expression = custom_dataclass.to_binary_expressions(
+    export_params={'exclude': {'filter_to_exclude'}, }
+)
+
+query = query.filter(*binary_expression)
+
+# or
+
+query = query.apply_filters(
+    query=query,
+    export_params={'exclude': {'filter_to_exclude'}, }
+)
+```
+
 Order by:
 ```python
 import typing

dataclass_sqlalchemy_mixins/pydantic_mixins/sqlalchemy_base_models.py

@@ -56,8 +56,14 @@ def _to_dict(self, **kwargs):
                                 dict_values[dict_key] = list(map(expected_type, value))
         return dict_values
 
-    def to_binary_expressions(self):
-        filters = self._to_dict(exclude_none=True)
+    def to_binary_expressions(
+        self,
+        export_params=None,
+    ):
+        if export_params is None:
+            export_params = dict()
+
+        filters = self._to_dict(exclude_none=True, **export_params)
 
         return self.get_binary_expressions(
             filters=filters,
@@ -66,8 +72,12 @@ def to_binary_expressions(self):
     def apply_filters(
         self,
         query,
+        export_params=None,
     ):
-        filters = self._to_dict(exclude_none=True)
+        if export_params is None:
+            export_params = dict()
+
+        filters = self._to_dict(exclude_none=True, **export_params)
 
         filters_binary_expressions = self.get_models_binary_expressions(
             filters=filters,

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dataclass-sqlalchemy-mixins"
-version = "0.1.2"
+version = "0.1.3"
 description = "Allows to convert dataclasses to sqlalchemy filters and orderings."
 authors = ["ViAchKoN"]
 readme = "README.md"

tests/filtering/test_fields_filters.py

@@ -631,3 +631,65 @@ def test_filter__like_ilike__ok(
 
         for expected_item, result in zip(expected_items, results):
             assert result.as_dict() == expected_item.as_dict()
+
+
+@pytest.mark.parametrize(
+    "apply_filters",
+    [
+        True,
+        False,
+    ],
+)
+def test_filter__eq__dict_kwargs__ok(
+    db_session,
+    get_sqlalchemy_filter_base_model,
+    apply_filters,
+):
+    expected_item_name = "expected_item_name"
+
+    # Create expected item
+    expected_item = models_factory.ItemFactory.create(name=expected_item_name)
+
+    # Create unexpected items
+    unexpected_items = models_factory.ItemFactory.create_batch(size=4)
+
+    unexpected_items_ids = [unexpected_item.id for unexpected_item in unexpected_items]
+
+    filters_model = get_sqlalchemy_filter_base_model(
+        base_model=models.Item,
+        field_kwargs={"name": (str, ...), "id__in": (tp.List[int], ...)},
+        model_kwargs={
+            "name": expected_item_name,
+            "id__in": unexpected_items_ids,
+        },
+    )
+
+    assert db_session.query(models.Item).count() == 5
+
+    if apply_filters:
+        query = select(models.Item)
+        query = filters_model.apply_filters(
+            query=query,
+            export_params={
+                "exclude": {"id__in"},
+            },
+        )
+        results = db_session.execute(query).scalars().all()
+    else:
+        results = (
+            db_session.query(models.Item)
+            .filter(
+                *filters_model.to_binary_expressions(
+                    export_params={
+                        "exclude": {"id__in"},
+                    }
+                )
+            )
+            .all()
+        )
+
+    assert len(results) == 1
+
+    result = results[0]
+
+    assert result.as_dict() == expected_item.as_dict()