python-general-be-lib 0.5.2__tar.gz → 0.5.4__tar.gz

{python_general_be_lib-0.5.2 → python_general_be_lib-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-general-be-lib
-Version: 0.5.2
+Version: 0.5.4
 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.5.2 → python_general_be_lib-0.5.4}/general/interface/repository/crud_repository.py

@@ -217,12 +217,13 @@ class CrudRepository[Entity: Base | Type[Base]]:
         else:
             pass
 
-    def find(self, session: Session = None, where: dict[str, Any] = None, columns: list[str] = None, exclude_columns: list[str] = None, limit: int = 0, parsing_model: Type[BaseModel] = None, **kwhere) -> list[Entity]:
+    def find(self, session: Session = None, where: dict[str, Any] = None, columns: list[str] = None, exclude_columns: list[str] = None, limit: int = 0, parsing_model: Type[BaseModel] = None, order_by: str = None,
+             asc: bool = None, **kwhere) -> list[Entity]:
         """Cerca i record che corrispondono ai criteri specificati.
 
         I filtri possono essere passati come dizionario ``where`` o come
         keyword arguments. Supporta caricamento parziale delle colonne,
-        limit e modelli di parsing alternativi.
+        limit, ordinamento e modelli di parsing alternativi.
 
         Args:
             session (Session, optional): Sessione esterna. Se ``None``, ne viene
@@ -234,6 +235,10 @@ class CrudRepository[Entity: Base | Type[Base]]:
             limit (int): Numero massimo di risultati. 0 = nessun limite. Default: 0.
             parsing_model (Type[BaseModel], optional): Modello Pydantic alternativo
                 per la serializzazione del risultato.
+            order_by (str, optional): Nome della colonna per l'ordinamento dei risultati.
+                Se ``None``, non viene applicato nessun ordinamento.
+            asc (bool, optional): Direzione dell'ordinamento. ``True`` per ASC,
+                ``False`` per DESC. Se ``None``, l'ordinamento di default è DESC.
             **kwhere: Filtri aggiuntivi come keyword arguments.
 
         Returns:
@@ -243,17 +248,21 @@ class CrudRepository[Entity: Base | Type[Base]]:
         Example:
             >>> repo.find(active=True, limit=10)
             >>> repo.find(where={"role": ["admin", "editor"]})
+            >>> repo.find(active=True, order_by="name", asc=True)
         """
+
         keep_open = False if session is None else True
         session = self.open_session if session is None else session
-        entities = self._find(session=session, where=where, columns=columns, exclude_columns=exclude_columns, limit=limit, **kwhere)
+        entities = self._find(session=session, where=where, columns=columns, exclude_columns=exclude_columns, limit=limit, order_by=order_by, asc=asc, **kwhere)
         return self._return(session=session, entities=entities, keep_open=keep_open, commit=False, parsing_model=parsing_model)
 
-    def _find(self, session: Session, where: dict[str, Any] = None, columns: list[str] = None, exclude_columns: list[str] = None, limit: int = 0, **kwhere):
+    def _find(self, session: Session, where: dict[str, Any] = None, columns: list[str] = None, exclude_columns: list[str] = None, limit: int = 0, order_by: str = None,
+              asc: bool = None, **kwhere):
         if where is None:
             where = kwhere if kwhere else {}
         stmt = self._select(entity=self.entity, columns=columns, exclude_columns=exclude_columns)
         stmt = self.stmt_manager.prepare_statement(stmt=stmt, **where)
+        stmt = self.stmt_manager.order_by_condition(stmt=stmt, order_by=order_by, asc=asc)
         stmt = self.stmt_manager.limit_offset_condition(stmt=stmt, limit=limit)
         return self.execute(session, stmt)
 

{python_general_be_lib-0.5.2 → python_general_be_lib-0.5.4}/general/interface/repository/handler/__init__.py

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

python_general_be_lib-0.5.4/general/interface/repository/handler/json_ilike_handler.py

@@ -0,0 +1,104 @@
+__all__ = ["JsonILikeHandler"]
+
+from typing import Any
+
+from general.interface.repository.handler import BaseHandler
+from sqlalchemy import Column, Select, Update, Delete, or_
+from sqlalchemy.sql.base import ReadOnlyColumnCollection
+
+
+class JsonILikeHandler(BaseHandler):
+    """Handler per ricerche case-insensitive (ILIKE) su più colonne tramite un alias.
+
+    Permette di esporre un singolo parametro di ricerca testuale (es. ``"search"``)
+    che viene applicato come ``ILIKE '%value%'`` su un insieme di colonne con ``OR``.
+
+    Attributes:
+        ilike_aliases (list[str]): Chiavi nel dizionario ``where`` che attivano
+            la ricerca ILIKE (es. ``["search", "q"]``).
+        ilike_attributes (list[str]): Nomi delle colonne su cui applicare ILIKE
+            (es. ``["name", "surname", "email"]``).
+
+    Example:
+        >>> handler = JsonILikeHandler(
+        ...     columns=User.columns(),
+        ...     ilike_aliases=["search"],
+        ...     ilike_attributes=["name", "surname"]
+        ... )
+        >>> repo.find(where={"search": "mario"})
+        # WHERE name ILIKE '%mario%' OR surname ILIKE '%mario%'
+    """
+    __slots__ = "ilike_aliases", "ilike_attributes", "json_column", "json_ilike_keys"
+    ilike_aliases: list[str]
+    ilike_attributes: list[str]
+    json_ilike_keys: list[str]
+    json_column: str
+
+    def __init__(self, columns: ReadOnlyColumnCollection[str, Column[Any]], ilike_aliases: list[str] = None, ilike_attributes: list[str] = None):
+        """Inizializza l'handler validando che le colonne ILIKE esistano sull'entità.
+
+        Args:
+            columns (ReadOnlyColumnCollection): Colonne della tabella.
+            ilike_aliases (list[str], optional): Chiavi alias che attivano la ricerca.
+                Default: lista vuota.
+            ilike_attributes (list[str], optional): Colonne su cui applicare ILIKE.
+                Default: lista vuota.
+
+        Raises:
+            ValueError: Se uno degli ``ilike_attributes`` non è presente tra le colonne.
+        """
+        self.columns = columns
+        self.ilike_aliases = ilike_aliases if ilike_aliases is not None else []
+        self.ilike_attributes = []
+        self.json_ilike_keys = []
+
+        if ilike_attributes:
+            for ilike_attribute in ilike_attributes:
+                if ilike_attribute not in self.columns:
+                    self.json_ilike_keys.append(ilike_attribute)
+                else:
+                    self.ilike_attributes.append(ilike_attribute)
+
+        for key, column in columns.items():
+            try:
+                if column.type.python_type == dict:
+                    self.json_column = key
+                    break
+            except NotImplementedError:
+                continue
+
+    def handle(self, stmt: Select | Update | Delete, where: dict[str, Any] = None, **kwargs):
+        """Applica i filtri ILIKE allo statement per ogni alias trovato in ``where``.
+
+        Per ogni alias presente in ``ilike_aliases`` e trovato in ``where``,
+        estrae il valore, lo rimuove dal dizionario e aggiunge la condizione ILIKE
+        su tutte le colonne in ``ilike_attributes`` con ``OR``.
+
+        Args:
+            stmt (Select | Update | Delete): Statement su cui applicare i filtri.
+            where (dict[str, Any]): Dizionario dei filtri. Gli alias ILIKE vengono
+                estratti e rimossi in-place.
+            **kwargs: Ignorati (compatibilità con l'interfaccia base).
+
+        Returns:
+            Select | Update | Delete: Statement con le condizioni ILIKE aggiunte.
+        """
+
+        for alias in self.ilike_aliases:
+            condition = where.pop(alias, None)
+            if condition:
+                stmt = stmt.where(self._handle(alias, condition))
+        return stmt
+
+    def _handle(self, alias: str, condition: str, neq: bool = False):
+        """Costruisce la condizione ILIKE con OR su tutte le colonne configurate.
+
+        Args:
+            alias (str): Alias attivato (usato per identificare la ricerca, non la colonna).
+            condition (str): Stringa da cercare (viene wrappata con ``%``).
+            neq (bool): Non utilizzato in questa implementazione.
+
+        Returns:
+            ColumnElement: Espressione ``OR(col1 ILIKE '%val%', col2 ILIKE '%val%', ...)``.
+        """
+        return or_(*[self.columns[col].ilike(f'%{condition}%') for col in self.ilike_attributes], *[self.columns[self.json_column][key].as_string().ilike(f'%{condition}%') for key in self.json_ilike_keys])

{python_general_be_lib-0.5.2 → python_general_be_lib-0.5.4}/general/interface/repository/handler/statement_manager.py

@@ -74,10 +74,11 @@ class StatementManager:
         Raises:
             HasNoAttributeException: Se la colonna ``order_by`` non esiste sull'entità.
         """
-        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)
+        if order_by:
+            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):

{python_general_be_lib-0.5.2 → python_general_be_lib-0.5.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.backends.legacy:build"
 
 [project]
 name = "python-general-be-lib"
-version = "0.5.2"
+version = "0.5.4"
 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.5.2 → python_general_be_lib-0.5.4}/python_general_be_lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-general-be-lib
-Version: 0.5.2
+Version: 0.5.4
 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.5.2 → python_general_be_lib-0.5.4}/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/json_ilike_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-0.5.2 → python_general_be_lib-0.5.4}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="python-general-be-lib",
-    version="0.5.2",
+    version="0.5.4",
     packages=find_packages(include=["general*"]),
     python_requires=">=3.12",
     install_requires=[
@@ -11,4 +11,4 @@ setup(
         "sqlalchemy>=2.0.0",
         "geoalchemy2>=0.14.0",
     ],
-)
+)