python-general-be-lib 0.4.2__tar.gz → 0.5.0__tar.gz

{python_general_be_lib-0.4.2/python_general_be_lib.egg-info → python_general_be_lib-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-general-be-lib
-Version: 0.4.2
+Version: 0.5.0
 Summary: General purpose backend library — SQLAlchemy CRUD/Geometry repositories, FastAPI exceptions, Pydantic base models, logger utilities.
 Author-email: Andrea Di Placido <a.diplacido@arpes.it>, "Arpes S.r.l." <it.admin@arpes.it>
 License: MIT

{python_general_be_lib-0.4.2 → python_general_be_lib-0.5.0}/general/interface/repository/crud_repository.py

@@ -13,30 +13,34 @@ from sqlalchemy.orm import Session, load_only, defer
 from sqlalchemy.sql.functions import count
 
 from .handler.base_handler import BaseHandler
+from .handler.statement_manager import StatementManager
 from ...exception.crud_exceptions import HasNoAttributeException, EntityNotFoundException, ServiceUnavailableException, BadRequestException
 from ...interface.base.declarative_base import Base
 from ...paginator_dto import PaginatorResponseModel
 
 
 class CrudRepository[Entity: Base | Type[Base]]:
-    __slots__ = "model", "entity", "engine", "columns", "handler", "relationship_attributes"
+    __slots__ = "model", "entity", "engine", "columns", "stmt_manager", "relationship_attributes"
 
     model: Type[BaseModel] | BaseModel
     entity: Entity
     engine: Type[Engine] | Engine
-    handler: Type[BaseHandler] | BaseHandler
+    stmt_manager: StatementManager | Type[StatementManager]
 
     @property
     def open_session(self):
         return Session(self.engine)
 
-    def __init__(self, entity: Entity, model: Type[BaseModel] | BaseModel, engine: Type[Engine] | Engine, handler_class: Type[BaseHandler] | BaseHandler = None) -> None:
+    def __init__(self, entity: Entity, model: Type[BaseModel] | BaseModel, engine: Type[Engine] | Engine, handlers: list[BaseHandler | Type[BaseHandler]] = None,
+                 handler_class: Type[BaseHandler] | BaseHandler = None) -> None:
         self.entity = entity
         self.model = model
         self.engine = engine
         self.columns = self.entity.columns()
 
-        self.handler = handler_class(self.columns) if handler_class else BaseHandler(self.columns)
+        base_handler = handler_class(self.columns) if handler_class else BaseHandler(self.columns)
+
+        self.stmt_manager = StatementManager(handlers=handlers, base_handler=base_handler)
 
     # -------------------------
 
@@ -106,8 +110,8 @@ class CrudRepository[Entity: Base | Type[Base]]:
         if where is None:
             where = kwhere if kwhere else {}
         stmt = self._select(entity=self.entity, columns=columns, exclude_columns=exclude_columns)
-        stmt = self.handler.prepare_statement(stmt=stmt, **where)
-        stmt = self.handler.limit_offset_condition(stmt=stmt, limit=limit)
+        stmt = self.stmt_manager.prepare_statement(stmt=stmt, **where)
+        stmt = self.stmt_manager.limit_offset_condition(stmt=stmt, limit=limit)
         return self.execute(session, stmt)
 
     def insert(self, session: Session = None, models: list[Type[BaseModel] | BaseModel] = None, returning: bool = True, parsing_model: Type[BaseModel] | BaseModel = None) -> list[Entity]:
@@ -146,7 +150,7 @@ class CrudRepository[Entity: Base | Type[Base]]:
         if where is None:
             where = {}
         stmt = update(self.entity)
-        stmt = self.handler.prepare_statement(stmt=stmt, **where)
+        stmt = self.stmt_manager.prepare_statement(stmt=stmt, **where)
 
         stmt = stmt.values(**kwargs)
         stmt = stmt if not returning else stmt.returning(self.entity)
@@ -167,7 +171,7 @@ class CrudRepository[Entity: Base | Type[Base]]:
         if where is None:
             where = kwhere if kwhere else {}
         stmt = delete(self.entity)
-        stmt = self.handler.prepare_statement(stmt=stmt, **where)
+        stmt = self.stmt_manager.prepare_statement(stmt=stmt, **where)
         try:
             result = session.execute(stmt)
         except Exception as e:
@@ -218,7 +222,7 @@ class CrudRepository[Entity: Base | Type[Base]]:
         if where is None:
             where = kwhere if kwhere else {}
         stmt = select(count(pk))
-        stmt = self.handler.prepare_statement(stmt=stmt, **where)
+        stmt = self.stmt_manager.prepare_statement(stmt=stmt, **where)
         result = session.execute(stmt).all()[0]
         return result[0]
 
@@ -244,13 +248,13 @@ class CrudRepository[Entity: Base | Type[Base]]:
         if where is None:
             where = kwhere if kwhere else {}
         stmt = self._select(entity=self.entity, columns=columns, exclude_columns=exclude_columns)
-        stmt = self.handler.prepare_statement(stmt=stmt, **where)
+        stmt = self.stmt_manager.prepare_statement(stmt=stmt, **where)
 
         row_numbers = self._preconf_count(session=session, where=stmt.whereclause)
 
-        stmt = self.handler.limit_offset_condition(stmt=stmt, limit=limit, page=page)
+        stmt = self.stmt_manager.limit_offset_condition(stmt=stmt, limit=limit, page=page)
         if order_by:
-            stmt = self.handler.order_by_condition(stmt=stmt, order_by=order_by, asc=asc)
+            stmt = self.stmt_manager.order_by_condition(stmt=stmt, order_by=order_by, asc=asc)
 
         entities = self.execute(session, stmt)
         return self.parse_pagination(limit=limit, page=page, order_by=order_by, count=row_numbers, asc=asc, data=entities)

{python_general_be_lib-0.4.2 → python_general_be_lib-0.5.0}/general/interface/repository/geometry_repository.py

@@ -38,11 +38,11 @@ class GeometryRepository[Entity: Base | Type[Base]](CrudRepository[Entity]):
 
         intersecting_geom = self._geom_condition(geom=geom, geom_srid=geom_srid, buffer=tolerance)
 
-        stmt = self.handler.prepare_statement(stmt=stmt, **where)
-        stmt = self.handler.prepare_statement(stmt=stmt, neq=True, **not_where)
+        stmt = self.stmt_manager.prepare_statement(stmt=stmt, **where)
+        stmt = self.stmt_manager.prepare_statement(stmt=stmt, neq=True, **not_where)
 
         stmt = stmt.where(self.geom_column.ST_Intersects(intersecting_geom))
-        stmt = self.handler.limit_offset_condition(stmt=stmt, limit=limit)
+        stmt = self.stmt_manager.limit_offset_condition(stmt=stmt, limit=limit)
 
         return self.execute(session, stmt)
 
@@ -60,14 +60,14 @@ class GeometryRepository[Entity: Base | Type[Base]](CrudRepository[Entity]):
             where = {}
 
         stmt = self._select(entity=self.entity, columns=columns, exclude_columns=exclude_columns)
-        stmt = self.handler.prepare_statement(stmt=stmt, **where)
+        stmt = self.stmt_manager.prepare_statement(stmt=stmt, **where)
 
         geom_condition = self._geom_condition(geom=geom, geom_srid=geom_srid, buffer=tolerance)
         geom_condition = self.geom_column.ST_Contains(geom_condition) if not contained else geom_condition.ST_Contains(self.geom_column)
 
         stmt = stmt.where(geom_condition)
 
-        stmt = self.handler.limit_offset_condition(stmt=stmt, limit=limit)
+        stmt = self.stmt_manager.limit_offset_condition(stmt=stmt, limit=limit)
         return self.execute(session, stmt)
 
     def nearest(self, geom: WKBElement, session: Session = None, columns: list[str] = None, exclude_columns: list[str] = None, limit: int = 1, where: dict[str, Any] = None, geom_srid: int = 4326,
@@ -89,9 +89,9 @@ class GeometryRepository[Entity: Base | Type[Base]](CrudRepository[Entity]):
         if distance:
             stmt = stmt.add_columns(distance_col)
 
-        stmt = self.handler.prepare_statement(stmt=stmt, **where)
+        stmt = self.stmt_manager.prepare_statement(stmt=stmt, **where)
         stmt = stmt.order_by(literal_column("distance"))
-        stmt = self.handler.limit_offset_condition(stmt=stmt, limit=limit)
+        stmt = self.stmt_manager.limit_offset_condition(stmt=stmt, limit=limit)
 
         rows = self.execute(session, stmt)
         return rows

{python_general_be_lib-0.4.2 → python_general_be_lib-0.5.0}/general/interface/repository/handler/__init__.py

@@ -2,3 +2,4 @@ from .base_handler import *
 from .ilike_handler import *
 from .interval_handler import *
 from .json_handler import *
+from .statement_manager import *

python_general_be_lib-0.5.0/general/interface/repository/handler/base_handler.py

@@ -0,0 +1,23 @@
+__all__ = ["BaseHandler"]
+
+from typing import Any
+
+from sqlalchemy import Select, Update, Delete, Column, not_
+from sqlalchemy.sql.base import ReadOnlyColumnCollection
+
+
+class BaseHandler:
+    __slots__ = "columns"
+
+    def __init__(self, columns: ReadOnlyColumnCollection[str, Column[Any]]):
+        self.columns = columns
+
+    def handle(self, stmt: Select | Update | Delete, neq: bool = False, where: dict[str, Any] = None):
+        stmt = stmt.where(*[self._handle(column=self.columns[column], condition=condition, neq=neq) for column, condition in where.items()])
+        return stmt
+
+    def _handle(self, column: Column, condition: Any, neq: bool = False):
+        eq_where = column.in_(condition) if isinstance(condition, list) else column == condition if str(column.type) != "ARRAY" else condition == column.any_()
+        if neq:
+            eq_where = not_(eq_where)
+        return eq_where

{python_general_be_lib-0.4.2 → python_general_be_lib-0.5.0}/general/interface/repository/handler/ilike_handler.py

@@ -15,24 +15,19 @@ class ILikeHandler(BaseHandler):
 
     def __init__(self, columns: ReadOnlyColumnCollection[str, Column[Any]], ilike_aliases: list[str] = None, ilike_attributes: list[str] = None):
         self.columns = columns
-        self.ilike_aliases = ilike_aliases if not ilike_aliases else []
-        self.ilike_attributes = ilike_attributes if not ilike_attributes else []
+        self.ilike_aliases = ilike_aliases if ilike_aliases is not None else []
+        self.ilike_attributes = ilike_attributes if ilike_attributes is not None else []
 
-    def prepare_statement(self, stmt: Select | Update | Delete, **where):
-        ilike_values = self.retrieve_ilike_values(where)
-        ilike_conditions = [self._ilike_condition(ilike_value) for _, ilike_value in ilike_values]
+        for ilike_attribute in self.ilike_attributes:
+            if ilike_attribute not in self.columns:
+                raise ValueError(f"{ilike_attribute} not in columns")
 
-        stmt = super().prepare_statement(stmt=stmt, **where)
-        stmt = stmt.where(*ilike_conditions)
-        return stmt
-
-    def _ilike_condition(self, condition):
-        return or_(*[self.columns[col].ilike(f'%{condition}%') for col in self.ilike_attributes])
-
-    def retrieve_ilike_values(self, where: dict[str, Any]):
-        ilike_values = []
+    def handle(self, stmt: Select | Update | Delete, where: dict[str, Any] = None, **kwargs):
         for alias in self.ilike_aliases:
             condition = where.pop(alias, None)
             if condition:
-                ilike_values.append((alias, condition))
-        return ilike_values
+                stmt = stmt.where(self._handle(alias, condition))
+        return stmt
+
+    def _handle(self, alias: str, condition: str, neq: bool = False):
+        return or_(*[self.columns[col].ilike(f'%{condition}%') for col in self.ilike_attributes])

{python_general_be_lib-0.4.2 → python_general_be_lib-0.5.0}/general/interface/repository/handler/interval_handler.py

@@ -14,18 +14,15 @@ class IntervalHandler(BaseHandler):
     to_: Any
     inf_is_none: bool
 
-    def __init__(self, columns: ReadOnlyColumnCollection[str, Column[Any]], from_: Any = None, to_: Any = None, inf_is_none: bool = None):
+    def __init__(self, columns: ReadOnlyColumnCollection[str, Column[Any]], from_: Any = None, to_: Any = None, inf_is_none: bool = False):
         self.columns = columns
         self.from_ = from_
         self.to_ = to_
         self.inf_is_none = inf_is_none
 
-    def prepare_statement(self, stmt: Select | Update | Delete, **where):
-
+    def handle(self, stmt: Select | Update | Delete, where: dict[str, Any] = None, **kwargs):
         from_condition = where.pop(self.from_, None)
-        to_condition = where.pop(self.from_, None)
-
-        stmt = super().prepare_statement(stmt=stmt, **where)
+        to_condition = where.pop(self.to_, None)
         if from_condition:
             stmt = stmt.where(self.columns[self.from_] >= from_condition)
         if to_condition:

{python_general_be_lib-0.4.2 → python_general_be_lib-0.5.0}/general/interface/repository/handler/json_handler.py

@@ -22,10 +22,8 @@ class JsonHandler(BaseHandler):
             except NotImplementedError:
                 continue
 
-    def prepare_statement(self, stmt: Select | Update | Delete, **where):
+    def handle(self, stmt: Select | Update | Delete, where: dict[str, Any] = None, **kwargs):
         json_keys = {key for key in where.keys() if key not in self.columns}
         json_conditions = {key: where.pop(key) for key in json_keys}
-
-        stmt = super().prepare_statement(stmt=stmt, **where)
         stmt = stmt.where(*[self.columns[self.json_column][key].as_string() == str(value) for key, value in json_conditions.items()])
         return stmt

python_general_be_lib-0.5.0/general/interface/repository/handler/statement_manager.py

@@ -0,0 +1,40 @@
+__all__ = ["StatementManager"]
+
+from ast import Delete
+from typing import Type
+
+from sqlalchemy import Select, Update
+
+from general.exception.crud_exceptions import HasNoAttributeException
+from .base_handler import BaseHandler
+
+
+class StatementManager:
+    __slots__ = "_handlers", "_base_handler"
+
+    def __init__(self, handlers: list[BaseHandler | Type[BaseHandler]] = None, base_handler: BaseHandler = None):
+        if not base_handler:
+            raise ValueError("StatemantManager: base_handler is not set")
+        self._handlers = handlers if handlers else []
+        self._base_handler = base_handler
+
+    def prepare_statement(self, stmt: Select | Update | Delete, neq: bool = False, **where):
+        for handler in self._handlers:
+            stmt = handler.handle(stmt=stmt, neq=neq, where=where)
+        stmt = self._base_handler.handle(stmt=stmt, neq=neq, where=where)
+        return stmt
+
+    def order_by_condition(self, stmt: Select, order_by: str, asc: bool):
+        try:
+            stmt = stmt.order_by(self._base_handler.columns[order_by].asc()) if asc else stmt.order_by(self._base_handler.columns[order_by].desc())
+        except KeyError:
+            raise HasNoAttributeException(order_by)
+        return stmt
+
+    def limit_offset_condition(self, stmt: Select, limit: int, page: int = None):
+        if limit and limit > 0:
+            stmt = stmt.limit(limit)
+            if page and page > 0:
+                offset = (page - 1) * limit
+                stmt = stmt.offset(offset)
+        return stmt

{python_general_be_lib-0.4.2 → python_general_be_lib-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.backends.legacy:build"
 
 [project]
 name = "python-general-be-lib"
-version = "0.4.2"
+version = "0.5.0"
 description = "General purpose backend library — SQLAlchemy CRUD/Geometry repositories, FastAPI exceptions, Pydantic base models, logger utilities."
 readme = "README.md"
 license = { text = "MIT" }

{python_general_be_lib-0.4.2 → python_general_be_lib-0.5.0/python_general_be_lib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-general-be-lib
-Version: 0.4.2
+Version: 0.5.0
 Summary: General purpose backend library — SQLAlchemy CRUD/Geometry repositories, FastAPI exceptions, Pydantic base models, logger utilities.
 Author-email: Andrea Di Placido <a.diplacido@arpes.it>, "Arpes S.r.l." <it.admin@arpes.it>
 License: MIT

{python_general_be_lib-0.4.2 → python_general_be_lib-0.5.0}/python_general_be_lib.egg-info/SOURCES.txt

@@ -25,6 +25,7 @@ general/interface/repository/handler/base_handler.py
 general/interface/repository/handler/ilike_handler.py
 general/interface/repository/handler/interval_handler.py
 general/interface/repository/handler/json_handler.py
+general/interface/repository/handler/statement_manager.py
 python_general_be_lib.egg-info/PKG-INFO
 python_general_be_lib.egg-info/SOURCES.txt
 python_general_be_lib.egg-info/dependency_links.txt

{python_general_be_lib-0.4.2 → python_general_be_lib-0.5.0}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="python-general-be-lib",
-    version="0.4.2",
+    version="0.5.0",
     packages=find_packages(include=["general*"]),
     python_requires=">=3.12",
     install_requires=[

python_general_be_lib-0.4.2/general/interface/repository/handler/base_handler.py

@@ -1,40 +0,0 @@
-__all__ = ["BaseHandler"]
-
-from typing import Any
-
-from sqlalchemy import Select, Update, Delete, Column, not_
-from sqlalchemy.sql.base import ReadOnlyColumnCollection
-
-from general.exception.crud_exceptions import HasNoAttributeException
-
-
-class BaseHandler:
-    __slots__ = "columns"
-
-    def __init__(self, columns: ReadOnlyColumnCollection[str, Column[Any]]):
-        self.columns = columns
-
-    def prepare_statement(self, stmt: Select | Update | Delete, neq: bool = False, **where):
-        stmt = stmt.where(*[self.handle(column=self.columns[column], condition=condition, neq=neq) for column, condition in where.items()])
-        return stmt
-
-    def order_by_condition(self, stmt: Select, order_by: str, asc: bool):
-        try:
-            stmt = stmt.order_by(self.columns[order_by].asc()) if asc else stmt.order_by(self.columns[order_by].desc())
-        except KeyError:
-            raise HasNoAttributeException(order_by)
-        return stmt
-
-    def limit_offset_condition(self, stmt: Select, limit: int, page: int = None):
-        if limit and limit > 0:
-            stmt = stmt.limit(limit)
-            if page and page > 0:
-                offset = (page - 1) * limit
-                stmt = stmt.offset(offset)
-        return stmt
-
-    def handle(self, column: Column, condition: Any, neq: bool = False):
-        eq_where = column.in_(condition) if isinstance(condition, list) else column == condition if str(column.type) != "ARRAY" else condition == column.any_()
-        if neq:
-            eq_where = not_(eq_where)
-        return eq_where