fix: updated examples (#25)

Author: ViAchKoN

README.md

@@ -75,13 +75,10 @@ from dataclasses import dataclass, asdict
 
 @dataclass
 class CustomDataclass(SqlAlchemyOrderConverterMixin):
-    order_by: typing.Optional[typing.Optional[str, typing.List[str]]] = None
+    order_by: typing.Optional[typing.Union[str, typing.List[str]]] = None
 
     class ConverterConfig:
         model = SomeModel 
-    
-    def dict(self):
-        return {k: str(v) for k, v in asdict(self).items() if v is not None}
 
 custom_dataclass = CustomDataclass(
     order_by=['id', '-name']
@@ -107,19 +104,19 @@ class CustomBaseModel(SqlAlchemyFilterBaseModel):
         model = SomeModel 
 
 
-custom_dataclass = CustomBaseModel(
+custom_basemodel = CustomBaseModel(
     id__gte=1,
     name__in=['abc', 'def'],
     object__place=1,
 )
 
-binary_expression = custom_dataclass.to_binary_expressions()
+binary_expression = custom_basemodel.to_binary_expressions()
 
 query = query.filter(*binary_expression)
 
 # or
 
-query = query.apply_filters(query=query)
+query = custom_basemodel.apply_filters(query=query)
 ```
 
 Sometimes, it is necessary to manipulate sent data before applying filters. 
@@ -139,23 +136,23 @@ class CustomBaseModel(SqlAlchemyFilterBaseModel):
         model = SomeModel 
 
 
-custom_dataclass = CustomBaseModel(
+custom_basemodel = 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(
+binary_expression = custom_basemodel.to_binary_expressions(
     export_params={'exclude': {'filter_to_exclude'}, }
 )
 
 query = query.filter(*binary_expression)
 
 # or
 
-query = query.apply_filters(
+query = custom_basemodel.apply_filters(
     query=query,
     export_params={'exclude': {'filter_to_exclude'}, }
 )
@@ -173,17 +170,17 @@ class CustomBaseModel(SqlAlchemyOrderBaseModel):
     class ConverterConfig:
         model = SomeModel 
 
-custom_dataclass = CustomBaseModel(
+custom_basemodel = CustomBaseModel(
     order_by=['id', '-name']
 )
 
-unary_expressions = custom_dataclass.get_unary_expressions(custom_dataclass.order_by)
+unary_expressions = custom_basemodel.get_unary_expressions(custom_dataclass.order_by)
 
 query = query.order_by(*unary_expressions)
 
 # or 
 
-query = query.apply_order_by(query)
+query = custom_basemodel.apply_order_by(query)
 ```
 ____
 ### FastApi support 

pyproject.toml

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

tests/filtering/test_fields_filters.py

@@ -1,16 +1,57 @@
 import datetime
 import datetime as dt
 import typing as tp
+from dataclasses import asdict, dataclass
 
 import pytest
 from sqlalchemy import select
 
+from dataclass_sqlalchemy_mixins.base.mixins import SqlAlchemyFilterConverterMixin
 from dataclass_sqlalchemy_mixins.pydantic_mixins.sqlalchemy_base_models import (
     BaseModelConverterExtraParams,
 )
 from tests import models, models_factory
 
 
+def test_filter__dataclass__eq__ok(
+    db_session,
+    get_sqlalchemy_filter_base_model,
+):
+    expected_item_name = "expected_item_name"
+
+    # Create expected item
+    expected_item = models_factory.ItemFactory.create(name=expected_item_name)
+
+    # Create unexpected items
+    models_factory.ItemFactory.create_batch(size=4)
+
+    @dataclass
+    class CustomDataclass(SqlAlchemyFilterConverterMixin):
+        name: str = None
+
+        class ConverterConfig:
+            model = models.Item
+
+        def dict(self):
+            return {k: str(v) for k, v in asdict(self).items() if v is not None}
+
+    custom_dataclass = CustomDataclass(name=expected_item_name)
+
+    assert db_session.query(models.Item).count() == 5
+
+    results = (
+        db_session.query(models.Item)
+        .filter(*custom_dataclass.get_binary_expressions(custom_dataclass.dict()))
+        .all()
+    )
+
+    assert len(results) == 1
+
+    result = results[0]
+
+    assert result.as_dict() == expected_item.as_dict()
+
+
 @pytest.mark.parametrize(
     "apply_filters",
     [

tests/ordering/test_fields_orderings.py

@@ -1,11 +1,59 @@
 import datetime as dt
+import typing as tp
+from dataclasses import dataclass
 
 import pytest
 from sqlalchemy import select
 
+from dataclass_sqlalchemy_mixins.base.mixins import SqlAlchemyOrderConverterMixin
 from tests import models, models_factory
 
 
+def test_order_by_id__dataclass__ok(
+    db_session,
+):
+    items = models_factory.ItemFactory.create_batch(size=5)
+
+    @dataclass
+    class CustomDataclass(SqlAlchemyOrderConverterMixin):
+        order_by: tp.Optional[tp.Union[str, tp.List[str]]] = None
+
+        class ConverterConfig:
+            model = models.Item
+
+    for order_by in [
+        "id",
+        [
+            "id",
+        ],
+        "-id",
+        [
+            "-id",
+        ],
+    ]:
+        custom_dataclass = CustomDataclass(order_by=order_by)
+
+        expected_items = items
+        if order_by in [
+            "-id",
+            [
+                "-id",
+            ],
+        ]:
+            expected_items = list(reversed(items))
+
+        results = (
+            db_session.query(models.Item)
+            .order_by(
+                *custom_dataclass.get_unary_expressions(custom_dataclass.order_by)
+            )
+            .all()
+        )
+
+        for expected_item, result in zip(expected_items, results):
+            assert result.as_dict() == expected_item.as_dict()
+
+
 @pytest.mark.parametrize(
     "apply_order_by",
     [