refactor typing, fix serializer mapping issue

Author: OleksandrZhydyk

fastapi_sa_orm_filter/__init__.py

@@ -1,3 +1,3 @@
 """FastAPI-SQLAlchemy filter, transform request query string to SQLAlchemy orm query"""
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"

fastapi_sa_orm_filter/main.py

@@ -8,7 +8,7 @@
 from pydantic._internal._model_construction import ModelMetaclass
 from sqlalchemy_to_pydantic import sqlalchemy_to_pydantic
 from sqlalchemy import select, inspect
-from sqlalchemy.orm import InstrumentedAttribute, DeclarativeMeta
+from sqlalchemy.orm import InstrumentedAttribute, DeclarativeBase
 from sqlalchemy.sql.elements import BinaryExpression, UnaryExpression
 from sqlalchemy.sql.expression import and_, or_
 from starlette import status
@@ -27,9 +27,9 @@ class FilterCore:
 
     def __init__(
         self,
-        model: Type[DeclarativeMeta],
+        model: Type[DeclarativeBase],
         allowed_filters: dict[str, list[ops]],
-        select_query_part: Select[Any] = None
+        select_query_part: Select[Any] | None = None
     ) -> None:
         """
         Produce a class:`FilterCore` object against a function
@@ -57,6 +57,7 @@ def get_query(self, custom_filter: str) -> Select[Any]:
             created_at__between=2023-05-01,2023-05-05|
             category__eq=Medicine&
             order_by=-id
+        :param select_query_part: custom select query part (select(model).join(model1))
 
         :return:
             select(model)
@@ -69,16 +70,16 @@ def get_query(self, custom_filter: str) -> Select[Any]:
                         model.category == 'Medicine'
                     ).order_by(model.id.desc())
         """
-        split_query = self.split_by_order_by(custom_filter)
+        split_query = self._split_by_order_by(custom_filter)
         try:
-            complete_query = self.get_complete_query(*split_query)
+            complete_query = self._get_complete_query(*split_query)
         except SAFilterOrmException as e:
             raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=e.args[0])
         return complete_query
 
-    def get_complete_query(self, filter_query_str: str, order_by_query_str: str | None = None) -> Select[Any]:
+    def _get_complete_query(self, filter_query_str: str, order_by_query_str: str | None = None) -> Select[Any]:
         select_query_part = self.get_select_query_part()
-        filter_query_part = self.get_filter_query_part(filter_query_str)
+        filter_query_part = self._get_filter_query_part(filter_query_str)
         complete_query = select_query_part.filter(*filter_query_part)
         group_query_part = self.get_group_by_query_part()
         if group_query_part:
@@ -89,11 +90,11 @@ def get_complete_query(self, filter_query_str: str, order_by_query_str: str | No
         return complete_query
 
     def get_select_query_part(self) -> Select[Any]:
-        if self.select_query_part:
+        if self.select_query_part is not None:
             return self.select_query_part
         return select(self.model)
 
-    def get_filter_query_part(self, filter_query_str: str) -> list[Any]:
+    def _get_filter_query_part(self, filter_query_str: str) -> list[Any]:
         conditions = self._get_filter_query(filter_query_str)
         if len(conditions) == 0:
             return conditions
@@ -123,7 +124,7 @@ def _get_filter_query(self, custom_filter: str) -> list[BinaryExpression]:
             filter_conditions.append(and_(*and_condition))
         return filter_conditions
 
-    def _create_pydantic_serializers(self) -> dict[str, ModelMetaclass]:
+    def _create_pydantic_serializers(self) -> dict[str, dict[str, ModelMetaclass]]:
         """
         Create two pydantic models (optional and list field types)
         for value: str serialization
@@ -139,7 +140,7 @@ class model.__name__(BaseModel):
         """
 
         models = [self.model]
-        models.extend(self.get_relations())
+        models.extend(self._get_relations())
 
         serializers = {}
 
@@ -154,7 +155,7 @@ class model.__name__(BaseModel):
 
         return serializers
 
-    def get_relations(self) -> list:
+    def _get_relations(self) -> list:
         return [relation[1].mapper.class_ for relation in self.relationships]
 
     def _get_orm_for_field(
@@ -192,7 +193,7 @@ def _format_expression(
             raise SAFilterOrmException(f"Incorrect filter value '{value}'")
 
     @staticmethod
-    def split_by_order_by(query) -> list:
+    def _split_by_order_by(query) -> list:
         split_query = [query_part.strip("&") for query_part in query.split("order_by=")]
         if len(split_query) > 2:
             raise SAFilterOrmException("Use only one order_by directive")

fastapi_sa_orm_filter/parsers.py

@@ -2,7 +2,7 @@
 
 from fastapi import HTTPException
 from sqlalchemy import inspect
-from sqlalchemy.orm import InstrumentedAttribute, DeclarativeMeta
+from sqlalchemy.orm import InstrumentedAttribute, DeclarativeBase
 from sqlalchemy.sql.elements import UnaryExpression
 
 from fastapi_sa_orm_filter.exceptions import SAFilterOrmException
@@ -14,7 +14,7 @@ class _OrderByQueryParser:
     """
     Class parse order by part of request query string.
     """
-    def __init__(self, model: Type[DeclarativeMeta]) -> None:
+    def __init__(self, model: Type[DeclarativeBase]) -> None:
         self._model = model
 
     def get_order_by_query(self, order_by_query_str: str) -> List[UnaryExpression]:
@@ -52,7 +52,7 @@ class _FilterQueryParser:
     Class parse filter part of request query string.
     """
 
-    def __init__(self, query: str, model: Type[DeclarativeMeta], allowed_filters: dict[str, list[ops]]) -> None:
+    def __init__(self, query: str, model: Type[DeclarativeBase], allowed_filters: dict[str, list[ops]]) -> None:
         self._query = query
         self._model = model
         self._relationships = inspect(model).relationships.items()
@@ -114,11 +114,12 @@ def _parse_expression(
             raise SAFilterOrmException(f"DB model {model.__name__} doesn't have field '{field_name}'")
         return table, column, operator, value
 
-    def _get_relation_model(self, field_name: str) -> tuple:
+    def _get_relation_model(self, field_name: str) -> tuple[DeclarativeBase, str, str]:
         relation, field_name = field_name.split(".")
         for relationship in self._relationships:
             if relationship[0] == relation:
-                return relationship[1].mapper.class_, relation, field_name
+                model = relationship[1].mapper.class_
+                return model, model.__tablename__, field_name
         raise SAFilterOrmException(f"Can not find relation {relation} in {self._model.__name__} model")
 
     def _validate_query_params(

poetry.lock

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "fastapi-sqlalchemy-filters"
-version = "0.2.1"
+version = "0.2.2"
 description = ""
 authors = ["Alexandr Zhydyk <zhydykalex@ukr.net>"]
 readme = "README.md"

pyproject.toml

@@ -1,9 +1,10 @@
 from datetime import date, datetime
+from typing import Any
 
 import pytest
 import pytest_asyncio
 
-from sqlalchemy import select, func, ForeignKey
+from sqlalchemy import select, func, ForeignKey, Select
 from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
 from sqlalchemy.orm import declarative_base, relationship, joinedload
 from sqlalchemy.orm import Mapped

tests/conftest.py

@@ -1,7 +1,7 @@
 from enum import Enum
 
 
-class JobCategory(str, Enum):
+class JobCategory(Enum):
     finance = "Finance"
     marketing = "Marketing"
     agro = "Agriculture"