python-general-be-lib 0.6.0__tar.gz → 0.7.0__tar.gz

{python_general_be_lib-0.6.0 → python_general_be_lib-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-general-be-lib
-Version: 0.6.0
+Version: 0.7.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.6.0 → python_general_be_lib-0.7.0}/general/interface/base/base_model.py

@@ -1,9 +1,21 @@
 __all__ = ["ExtBaseModel", "CamelExtBaseModel"]
 
+from functools import lru_cache
+
 from pydantic import BaseModel, ConfigDict
 from pydantic.alias_generators import to_camel
 
 
+@lru_cache(maxsize=None)
+def _alias_to_name(model: type[BaseModel]) -> dict[str, str]:
+    """Mappa ``{alias: nome_campo}`` di un modello, costruita una volta per classe.
+
+    Cachata sulla classe (long-lived) per evitare la scansione lineare di
+    ``model_fields`` a ogni ``get_attr_by_alias``.
+    """
+    return {field.alias: name for name, field in model.model_fields.items() if field.alias}
+
+
 class ConfigModel(BaseModel):
     """Modello Pydantic base con configurazione condivisa.
 
@@ -40,10 +52,7 @@ class CamelConfigModel(ConfigModel):
             >>> MyModel.get_attr_by_alias("myField")
             'my_field'
         """
-        for name, field in cls.model_fields.items():
-            if field.alias == alias:
-                return name
-        return alias
+        return _alias_to_name(cls).get(alias, alias)
 
 
 class ExtBaseModel(ConfigModel):

{python_general_be_lib-0.6.0 → python_general_be_lib-0.7.0}/general/interface/metadata/crud_metadata.py

@@ -4,7 +4,7 @@ import logging
 from typing import Optional, Any, Type, Iterable, Sequence
 
 from pydantic import BaseModel
-from sqlalchemy import MetaData, Engine, Column, Table, inspect, Connection, select, RowMapping, CursorResult, not_
+from sqlalchemy import MetaData, Engine, Column, Table, inspect, Connection, select, RowMapping, CursorResult, not_, ARRAY, type_coerce
 from sqlalchemy.exc import NoSuchTableError
 
 from ...exception.crud_exceptions import HasNoAttributeException, InternalServerException
@@ -496,7 +496,15 @@ class CrudMetadata:
         Returns:
             ColumnElement: Espressione booleana SQLAlchemy.
         """
-        eq_where = col.in_(condition) if isinstance(condition, list) else col == condition if str(col.type) != "ARRAY" else condition == col.any_()
+        is_array = isinstance(col.type, ARRAY)
+        if is_array and isinstance(condition, list):
+            eq_where = col.op("&&")(type_coerce(condition, col.type))
+        elif isinstance(condition, list):
+            eq_where = col.in_(condition)
+        elif is_array:
+            eq_where = condition == col.any_()
+        else:
+            eq_where = col == condition
         if neq:
             eq_where = not_(eq_where)
         return eq_where

{python_general_be_lib-0.6.0 → python_general_be_lib-0.7.0}/general/interface/repository/crud_repository.py

@@ -2,10 +2,11 @@ __all__ = ["CrudRepository"]
 
 import logging
 import math
+from functools import lru_cache
 from typing import Any, Type, Sequence, Iterable, Optional, Mapping
 
-from pydantic import BaseModel
-from sqlalchemy import select, delete, update, insert, tuple_, Row, RowMapping, ColumnElement, Select, Insert, Update, Delete
+from pydantic import BaseModel, TypeAdapter
+from sqlalchemy import select, delete, update, insert, tuple_, Row, RowMapping, ColumnElement, Select, Insert, Update, Delete, func, ARRAY
 from sqlalchemy.engine.base import Engine
 from sqlalchemy.exc import DataError, IntegrityError, NoResultFound, OperationalError
 from sqlalchemy.inspection import inspect
@@ -19,6 +20,18 @@ from ...interface.base.declarative_base import Base
 from ...paginator_dto import PaginatorResponseModel
 
 
+@lru_cache(maxsize=None)
+def _list_adapter(model: Type[BaseModel]) -> TypeAdapter:
+    """Restituisce (cachato per classe) un ``TypeAdapter`` per ``list[model]``.
+
+    Validare l'intera lista con un solo ``validate_python`` fa iterare il loop
+    dentro pydantic-core (Rust) invece che con una list-comprehension che chiama
+    ``model_validate`` riga per riga in Python. Il ``TypeAdapter`` è costruito una
+    sola volta per modello e riusato (anche per i ``parsing_model`` alternativi).
+    """
+    return TypeAdapter(list[model])
+
+
 class CrudRepository[Entity: Base | Type[Base]]:
     """Repository ORM generico con operazioni CRUD complete su una singola entità SQLAlchemy.
 
@@ -41,13 +54,27 @@ class CrudRepository[Entity: Base | Type[Base]]:
         >>> repo.create()
         >>> users = repo.find(active=True, limit=10)
     """
-    __slots__ = "model", "entity", "engine", "columns", "stmt_manager", "relationship_attributes"
+    __slots__ = "model", "entity", "engine", "columns", "stmt_manager", "_relationship_attributes"
 
     model: Type[BaseModel] | BaseModel
     entity: Entity
     engine: Type[Engine] | Engine
     stmt_manager: StatementManager | Type[StatementManager]
 
+    @property
+    def relationship_attributes(self) -> set[str]:
+        """Nomi degli attributi di relazione dell'entità (calcolati una volta, poi cachati).
+
+        Lazy di proposito: accedere a ``__mapper__.relationships`` a import-time
+        (quando le repository vengono istanziate) forzerebbe la configurazione dei
+        mapper prima che tutte le entità siano importate, rompendo le relationship
+        con forward-ref non ancora risolvibili. Al primo accesso (a runtime, in
+        ``_select``) i mapper sono già configurati.
+        """
+        if self._relationship_attributes is None:
+            self._relationship_attributes = set(self.entity.__mapper__.relationships.keys())
+        return self._relationship_attributes
+
     @property
     def open_session(self):
         """Apre e restituisce una nuova sessione SQLAlchemy.
@@ -74,6 +101,7 @@ class CrudRepository[Entity: Base | Type[Base]]:
         self.model = model
         self.engine = engine
         self.columns = self.entity.columns()
+        self._relationship_attributes = None  # popolato lazy dalla property relationship_attributes
 
         base_handler = handler_class(self.columns) if handler_class else BaseHandler(self.columns)
 
@@ -181,8 +209,7 @@ class CrudRepository[Entity: Base | Type[Base]]:
         try:
             stmt = select(entity)
             if columns:
-                relationship_attributes = set(entity.__mapper__.relationships.keys())
-                entity_columns = {column for column in columns if column not in relationship_attributes}
+                entity_columns = {column for column in columns if column not in self.relationship_attributes}
                 stmt = stmt.options(load_only(*[getattr(self.entity, column) for column in entity_columns]))
             if exclude_columns:
                 stmt = stmt.options(defer(*[getattr(self.entity, column) for column in exclude_columns]))
@@ -222,7 +249,7 @@ class CrudRepository[Entity: Base | Type[Base]]:
             return_model = parsing_model or self.model
             if commit:
                 self._flush(session=session)
-            models = [return_model.model_validate(entity) for entity in entities]
+            models = _list_adapter(return_model).validate_python(entities, from_attributes=True)
             if commit:
                 self.commit(session=session)
             session.close()
@@ -607,7 +634,7 @@ class CrudRepository[Entity: Base | Type[Base]]:
         session = self.open_session if session is None else session
         paginated = self._paging_find(session=session, where=where, columns=columns, exclude_columns=exclude_columns, limit=limit, page=page, order_by=order_by, asc=asc, **kwhere)
         if not keep_open:
-            paginated.data = [parsing_model.model_validate(entity) for entity in paginated.data] if parsing_model else [self.model.model_validate(entity) for entity in paginated.data]
+            paginated.data = _list_adapter(parsing_model or self.model).validate_python(paginated.data, from_attributes=True)
             session.close()
         return paginated
 
@@ -619,9 +646,9 @@ class CrudRepository[Entity: Base | Type[Base]]:
 
         row_numbers = self._preconf_count(session=session, where=stmt.whereclause)
 
+        order_by = order_by or self.entity.primary_key()[0].name
         stmt = self.stmt_manager.limit_offset_condition(stmt=stmt, limit=limit, page=page)
-        if order_by:
-            stmt = self.stmt_manager.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)
@@ -650,6 +677,47 @@ class CrudRepository[Entity: Base | Type[Base]]:
 
         return PaginatorResponseModel(limit=limit, page=page, order_by=order_by, asc=asc, tot_pages=tot_pages, data=data)
 
+    def distinct_pairs(self, key: str, value: str, session: Session = None, where: dict[str, Any] = None, **kwhere) -> list[Row] | None:
+        """Coppie distinte ``(key, value)`` per i record che soddisfano ``where``.
+
+        Calcola i valori distinti lato DB con ``SELECT DISTINCT`` invece di caricare
+        tutte le righe e dedupplicare in Python (usato da ``BaseService.company_filters``
+        per popolare le opzioni dei filtri). Per le colonne ``ARRAY`` srotola in
+        parallelo chiave ed etichetta con ``unnest`` (lateral implicito).
+
+        Args:
+            key (str): Colonna chiave (es. ``"id_operatore"``).
+            value (str): Colonna etichetta (es. ``"operatore"``).
+            session (Session, optional): Sessione esterna; se ``None`` ne apre/chiude una.
+            where (dict, optional): Filtri (es. ``{"id_azienda": ...}``).
+            **kwhere: Filtri aggiuntivi, usati se ``where`` è ``None``.
+
+        Returns:
+            list[Row]: Coppie ``(key, value)`` distinte.
+        """
+        if where is None:
+            where = kwhere if kwhere else {}
+
+        keep_open = session is not None
+        session = self.open_session if session is None else session
+
+        key_col, value_col = self.columns[key], self.columns[value]
+        if isinstance(key_col.type, ARRAY):
+            pairs = func.unnest(key_col, value_col).table_valued("k", "v")
+            stmt = select(pairs.c.k, pairs.c.v).select_from(self.entity, pairs).distinct()
+        else:
+            stmt = select(key_col, value_col).distinct()
+        stmt = self.stmt_manager.prepare_statement(stmt=stmt, **where)
+
+        try:
+            rows = session.execute(stmt).all()
+        except Exception as e:
+            self._handle_exception(session, e)
+        else:
+            if not keep_open:
+                session.close()
+            return rows
+
     def execute(self, session: Session, stmt: Select | Insert | Update | Delete, values: Sequence[Mapping[str, Any]] | Mapping[str, Any] = None):
         """Esegue uno statement SQLAlchemy e restituisce i risultati scalari.
 

{python_general_be_lib-0.6.0 → python_general_be_lib-0.7.0}/general/interface/repository/handler/base_handler.py

@@ -2,7 +2,7 @@ __all__ = ["BaseHandler"]
 
 from typing import Any
 
-from sqlalchemy import Select, Update, Delete, Column, not_
+from sqlalchemy import Select, Update, Delete, Column, not_, ARRAY, type_coerce
 from sqlalchemy.sql.base import ReadOnlyColumnCollection
 
 
@@ -30,7 +30,7 @@ class BaseHandler:
                 ottenute da ``Entity.__table__.c``.
         """
         self.columns = columns
-        self.array_columns = {column.name for column in columns if str(column.type) == "ARRAY"}
+        self.array_columns = {column.name for column in columns if isinstance(column.type, ARRAY)}
 
     def handle(self, stmt: Select | Update | Delete, neq: bool = False, where: dict[str, Any] = None):
         """Applica i filtri WHERE allo statement per tutte le coppie chiave-valore in ``where``.
@@ -54,8 +54,9 @@ class BaseHandler:
         """Costruisce la singola condizione WHERE per una colonna.
 
         Logica applicata:
+        - Colonna ``ARRAY`` + ``list`` → ``col && ARRAY[values]`` (overlap)
+        - Colonna ``ARRAY`` + scalare → ``value = ANY(col)``
         - ``list`` → ``col IN (values)``
-        - Tipo ``ARRAY`` → ``value = ANY(col)``
         - Scalare → ``col == value``
 
         Se ``neq=True``, la condizione viene negata con ``NOT``.
@@ -68,9 +69,12 @@ class BaseHandler:
         Returns:
             ColumnElement: Espressione booleana SQLAlchemy.
         """
-        if isinstance(condition, list):
+        is_array = column.name in self.array_columns
+        if is_array and isinstance(condition, list):
+            eq_where = column.op("&&")(type_coerce(condition, column.type))
+        elif isinstance(condition, list):
             eq_where = column.in_(condition)
-        elif column.name in self.array_columns:
+        elif is_array:
             eq_where = condition == column.any_()
         else:
             eq_where = column == condition

python_general_be_lib-0.7.0/general/interface/repository/handler/or_handler.py

@@ -0,0 +1,90 @@
+__all__ = ["OrHandler"]
+
+from typing import Any
+
+from sqlalchemy import Column, Select, Update, Delete, or_
+from sqlalchemy.sql.base import ReadOnlyColumnCollection
+
+from .base_handler import BaseHandler
+
+
+class OrHandler(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:
+        or_aliases (list[str]): Chiavi nel dizionario ``where`` che attivano
+            la ricerca ILIKE (es. ``["search", "q"]``).
+        or_attributes (list[str]): Nomi delle colonne su cui applicare ILIKE
+            (es. ``["name", "surname", "email"]``).
+
+    Example:
+        >>> handler = OrHandler(
+        ...     columns=User.columns(),
+        ...     or_aliases=["search"],
+        ...     or_attributes=["name", "surname"]
+        ... )
+        >>> repo.find(where={"search": "mario"})
+        # WHERE name ILIKE '%mario%' OR surname ILIKE '%mario%'
+    """
+    __slots__ = "or_aliases", "or_attributes"
+    or_aliases: list[str]
+    or_attributes: list[str]
+
+    def __init__(self, columns: ReadOnlyColumnCollection[str, Column[Any]], or_aliases: list[str] = None, or_attributes: list[str] = None):
+        """Inizializza l'handler validando che le colonne ILIKE esistano sull'entità.
+
+        Args:
+            columns (ReadOnlyColumnCollection): Colonne della tabella.
+            or_aliases (list[str], optional): Chiavi alias che attivano la ricerca.
+                Default: lista vuota.
+            or_attributes (list[str], optional): Colonne su cui applicare ILIKE.
+                Default: lista vuota.
+
+        Raises:
+            ValueError: Se uno degli ``or_attributes`` non è presente tra le colonne.
+        """
+        self.columns = columns
+        self.or_aliases = or_aliases if or_aliases is not None else []
+        self.or_attributes = or_attributes if or_attributes is not None else []
+
+        for or_attribute in self.or_attributes:
+            if or_attribute not in self.columns:
+                raise ValueError(f"{or_attribute} not in columns")
+
+    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 ``or_aliases`` e trovato in ``where``,
+        estrae il valore, lo rimuove dal dizionario e aggiunge la condizione ILIKE
+        su tutte le colonne in ``or_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.or_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] == condition for col in self.or_attributes])

{python_general_be_lib-0.6.0 → python_general_be_lib-0.7.0}/general/interface/repository/view_repository.py

@@ -80,8 +80,18 @@ class ViewRepository[Entity: Base | Type[Base]](CrudRepository[Entity]):
             if self.materialized:
                 unique_id_index = f"create unique index on {self.view_name} ({self.entity.primary_key()[0].name});"
                 stmts.append(unique_id_index)
-            if visualizer_db_role and any([isinstance(col.type, Geometry) for col in self.entity.columns()]):
-                grant_visualized = f"grant select on table {self.view_name} to {visualizer_db_role}"
+
+            has_geom = False
+            for col in self.entity.columns():
+                if isinstance(col.type, Geometry):
+                    has_geom = True
+                    # l'indice GIST si può creare solo su materialized view: su una view normale
+                    # CREATE INDEX fallisce e farebbe abortire la transazione (view non creata)
+                    if self.materialized:
+                        stmts.append(f"create index on {self.view_name} using gist ({col.name});")
+
+            if visualizer_db_role and has_geom:
+                grant_visualized = f"grant select on table {self.view_name} to {visualizer_db_role};"
                 stmts.append(grant_visualized)
 
             with self.open_session as session:

{python_general_be_lib-0.6.0 → python_general_be_lib-0.7.0}/pyproject.toml

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-general-be-lib
-Version: 0.6.0
+Version: 0.7.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.6.0 → python_general_be_lib-0.7.0}/python_general_be_lib.egg-info/SOURCES.txt

@@ -26,6 +26,7 @@ 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/or_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.6.0 → python_general_be_lib-0.7.0}/setup.py

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