python-general-be-lib 0.7.1__py3-none-any.whl → 0.8.0__py3-none-any.whl

general/exception/access_exceptions.py

@@ -1,11 +1,23 @@
+"""Eccezioni HTTP per autenticazione e autorizzazione.
+
+A differenza di ``crud_exceptions``, queste eccezioni non sono sollevate
+automaticamente dalla libreria: sono a disposizione dei layer di autenticazione
+e autorizzazione dei progetti che la usano.
+
+Il package ``general.exception`` non re-esporta questi simboli: vanno importati
+dal modulo, ``from general.exception.access_exceptions import ForbiddenException``.
+"""
+
 from .exception_interface import ExceptionInterface
 
 
 class ForbiddenException(ExceptionInterface):
+    """403 — Utente autenticato ma senza i permessi per la risorsa richiesta."""
     status_code = 403
     default_message = "Risorsa non accessibile da questo utente"
 
 
 class UnauthorizedException(ExceptionInterface):
+    """401 — Richiesta priva di credenziali valide."""
     status_code = 401
     default_message = "Non autorizzato"

general/exception/crud_exceptions.py

@@ -1,31 +1,78 @@
+"""Eccezioni HTTP per le operazioni di persistenza.
+
+Sono le eccezioni su cui ``CrudRepository._handle_exception`` mappa gli errori
+SQLAlchemy:
+
+- ``OperationalError`` → ``ServiceUnavailableException`` (503)
+- ``NoResultFound`` → ``EntityNotFoundException`` (404)
+- ``DataError`` | ``IntegrityError`` → ``BadRequestException`` (400)
+
+Il package ``general.exception`` non re-esporta questi simboli: vanno importati
+dal modulo, ``from general.exception.crud_exceptions import BadRequestException``.
+"""
+
 from .exception_interface import ExceptionInterface
 
 
 class BadRequestException(ExceptionInterface):
+    """400 — Dati della richiesta non validi o vincolo di integrità violato.
+
+    Sollevata al posto di ``DataError`` e ``IntegrityError`` (es. violazione di
+    una foreign key, di un unique o di un NOT NULL).
+    """
     status_code = 400
     default_message = "Richiesta non corretta"
 
 
 class EntityNotFoundException(ExceptionInterface):
+    """404 — Nessun record corrisponde ai criteri richiesti.
+
+    Sollevata al posto di ``NoResultFound``.
+    """
     status_code = 404
     default_message = "Dato non trovato"
 
 
 class ServiceUnavailableException(ExceptionInterface):
+    """503 — Database non raggiungibile.
+
+    Sollevata al posto di ``OperationalError`` (connessione caduta, pool esaurito,
+    server non in ascolto).
+    """
     status_code = 503
     default_message = "Servizio momentaneamente non disponibile, riprovare più tardi"
 
 
 class UnprocessableEntityException(ExceptionInterface):
+    """422 — Entità sintatticamente valida ma non processabile.
+
+    Non è sollevata automaticamente dai repository: è a disposizione dei service
+    per gli errori di validazione applicativa.
+    """
     status_code = 422
     default_message = "Entità non processabile"
 
 
 class HasNoAttributeException(ExceptionInterface):
+    """400 — Colonna o attributo non presente sull'entità.
+
+    Sollevata quando un nome di colonna passato a ``columns``, ``exclude_columns``
+    o ``order_by`` non esiste sull'entità.
+
+    Example:
+        >>> raise HasNoAttributeException("cognome")
+        # detail: "Richiesta non corretta - Attributo cognome non presente"
+    """
     status_code = 400
     default_message = "Richiesta non corretta"
 
     def __init__(self, attr: str = ""):
+        """Compone il dettaglio in base alla presenza del nome dell'attributo.
+
+        Args:
+            attr (str): Nome dell'attributo mancante. Se omesso, viene usato un
+                messaggio generico che non identifica la colonna.
+        """
         if attr:
             super().__init__(custom_message=f"Attributo {attr} non presente", )
         else:
@@ -33,5 +80,11 @@ class HasNoAttributeException(ExceptionInterface):
 
 
 class InternalServerException(ExceptionInterface):
+    """500 — Errore interno non previsto.
+
+    Usata come fallback dal decorator ``@log`` per ogni eccezione che non sia già
+    una ``HTTPException``, e da ``CrudMetadata.get_table`` per una tabella
+    inesistente.
+    """
     status_code = 500
     default_message = "Impossibile gestire la richiesta al momento"

general/exception/exception_interface.py

@@ -2,9 +2,37 @@ from fastapi import HTTPException
 
 
 class ExceptionInterface(HTTPException):
+    """Interfaccia base per tutte le eccezioni della libreria.
+
+    Estende ``fastapi.HTTPException`` spostando status code e messaggio su
+    **attributi di classe**: ogni sottoclasse dichiara il proprio ``status_code``
+    e ``default_message`` e può quindi essere sollevata senza argomenti.
+
+    Sollevata dentro un endpoint FastAPI, viene serializzata automaticamente nella
+    risposta di errore con lo status code dichiarato.
+
+    Attributes:
+        status_code (int): Status code HTTP della risposta.
+        default_message (str): Messaggio di default usato come ``detail``.
+
+    Example:
+        >>> class TeapotException(ExceptionInterface):
+        ...     status_code = 418
+        ...     default_message = "Sono una teiera"
+        >>> raise TeapotException("niente caffè")
+        # detail: "Sono una teiera - niente caffè"
+    """
     status_code: int
     default_message: str
 
     def __init__(self, custom_message: str = None):
+        """Compone il ``detail`` a partire dal messaggio di default e da quello custom.
+
+        Args:
+            custom_message (str, optional): Dettaglio aggiuntivo, accodato al
+                ``default_message`` nella forma
+                ``"{default_message} - {custom_message}"``. Se omesso, il ``detail``
+                è il solo ``default_message``.
+        """
         detail = f"{self.default_message} - {custom_message}" if custom_message else self.default_message
         super().__init__(status_code=self.status_code, detail=detail)

general/interface/base/declarative_base.py

@@ -111,6 +111,9 @@ class Base:
 def retrieve_mapper_entity(entity_name: str):
     """Cerca e restituisce una sottoclasse di ``Base`` per nome della classe.
 
+    Itera su ``Base.__subclasses__()``: trova quindi solo le sottoclassi **dirette**
+    di ``Base``, non quelle annidate in ulteriori livelli di ereditarietà.
+
     Args:
         entity_name (str): Nome della classe ORM da cercare (es. ``"User"``).
 
@@ -129,6 +132,9 @@ def retrieve_mapper_entity(entity_name: str):
 def retrieve_mapper_from_table(table_name: str):
     """Cerca e restituisce una sottoclasse di ``Base`` per nome della tabella.
 
+    Itera su ``Base.__subclasses__()``: trova quindi solo le sottoclassi **dirette**
+    di ``Base``, non quelle annidate in ulteriori livelli di ereditarietà.
+
     Args:
         table_name (str): Nome della tabella nel database (es. ``"users"``).
 

general/interface/metadata/crud_metadata.py

@@ -23,6 +23,14 @@ class CrudMetadata:
     chiusura; altrimenti la connessione viene aperta, committata e chiusa
     internamente.
 
+    Differenze rispetto a ``CrudRepository``:
+    - **non** usa la pipeline degli handler: i filtri passano direttamente da
+      ``_eq_where``, quindi non c'è supporto per JSON, ILIKE, intervalli o alias;
+    - le eccezioni SQLAlchemy **non** vengono mappate su eccezioni HTTP: vengono
+      loggate e rilanciate tal quali (vedi ``_handle_exception``);
+    - la serializzazione avviene con ``parsing_model(**row)`` sui mapping delle
+      righe, non con ``model_validate`` su entità ORM.
+
     Attributes:
         schema (str | None): Nome dello schema di default per le tabelle.
         metadata (MetaData): Contenitore SQLAlchemy delle tabelle riflesse/definite.
@@ -483,9 +491,10 @@ class CrudMetadata:
     def _eq_where(self, col: Column, condition, neq: bool = False):
         """Costruisce la singola condizione WHERE per una colonna.
 
-        Logica applicata:
+        Logica applicata (stessa di ``BaseHandler._handle``):
+        - 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``
 
         Args:

general/interface/metadata/geom_metadata.py

@@ -19,7 +19,10 @@ class GeomMetadata(CrudMetadata):
     della tabella.
 
     Gestisce la riproiezione automatica tra SRID diversi e il buffering opzionale
-    della geometria di input.
+    della geometria di input. Il parametro ``tolerance`` è sempre un **buffer**
+    (``ST_Buffer``) applicato alla geometria di input: a differenza di
+    ``GeometryRepository.intersects``, che con ``tolerance > 0`` passa a
+    ``ST_DWithin``, qui il predicato resta ``ST_Intersects``.
 
     Example:
         >>> meta = GeomMetadata(engine=engine, schema_name="public")

general/interface/repository/crud_repository.py

@@ -179,8 +179,9 @@ class CrudRepository[Entity: Base | Type[Base]]:
 
         Args:
             *columns (str): Nomi delle colonne da verificare.
-            entity (Type[Base], optional): Entità su cui verificare. Se ``None``,
-                usa ``self.entity``.
+            entity (Type[Base]): Entità su cui verificare. Obbligatoria nei fatti:
+                pur avendo default ``None``, il metodo non applica nessun fallback
+                a ``self.entity`` e con ``None`` solleva ``AttributeError``.
 
         Returns:
             bool: ``True`` se tutte le colonne sono presenti, ``False`` altrimenti.
@@ -301,6 +302,13 @@ class CrudRepository[Entity: Base | Type[Base]]:
             list[Entity]: Lista di modelli serializzati (o entità grezze se
                 sessione esterna).
 
+        Raises:
+            HasNoAttributeException: Se una colonna in ``columns``,
+                ``exclude_columns`` o ``order_by`` non esiste sull'entità.
+
+        Note:
+            Essendo una lettura pura non esegue nessun commit (``commit=False``).
+
         Example:
             >>> repo.find(active=True, limit=10)
             >>> repo.find(where={"role": ["admin", "editor"]})
@@ -606,16 +614,20 @@ class CrudRepository[Entity: Base | Type[Base]]:
         """Esegue una ricerca paginata con supporto a ordinamento e offset.
 
         Calcola il numero totale di pagine in base al count reale dei record
-        filtrati, e restituisce solo la pagina richiesta.
+        filtrati, e restituisce solo la pagina richiesta. Il count riusa la
+        ``whereclause`` già costruita sullo statement di selezione
+        (``_preconf_count``), così i filtri vengono tradotti una sola volta.
 
         Args:
             session (Session, optional): Sessione esterna.
             where (dict[str, Any], optional): Filtri come dizionario.
             columns (list[str], optional): Colonne da includere.
             exclude_columns (list[str], optional): Colonne da escludere.
-            limit (int): Numero di elementi per pagina. Default: 0 (nessun limite).
+            limit (int): Numero di elementi per pagina. Default: 0 (nessun limite,
+                quindi una sola pagina).
             page (int): Numero di pagina richiesta (1-based). Default: 1.
-            order_by (str, optional): Colonna per l'ordinamento.
+            order_by (str, optional): Colonna per l'ordinamento. Se ``None``, viene
+                usata la prima colonna della chiave primaria.
             asc (bool): Ordinamento crescente se ``True``. Default: ``True``.
             parsing_model (Type[BaseModel], optional): Modello alternativo per
                 la serializzazione.
@@ -681,8 +693,8 @@ class CrudRepository[Entity: Base | Type[Base]]:
         """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
+        tutte le righe e dedupplicare in Python. Tipicamente usato per popolare le
+        opzioni di un filtro lato client. Per le colonne ``ARRAY`` srotola in
         parallelo chiave ed etichetta con ``unnest`` (lateral implicito).
 
         Args:
@@ -694,6 +706,14 @@ class CrudRepository[Entity: Base | Type[Base]]:
 
         Returns:
             list[Row]: Coppie ``(key, value)`` distinte.
+
+        Note:
+            A differenza degli altri metodi restituisce ``Row`` (tuple) e non modelli
+            Pydantic: non passa da ``_return`` e non accetta un ``parsing_model``.
+
+        Example:
+            >>> repo.distinct_pairs("id_operatore", "operatore", where={"id_azienda": 3})
+            [(1, 'Rossi'), (2, 'Bianchi')]
         """
         if where is None:
             where = kwhere if kwhere else {}
@@ -723,6 +743,11 @@ class CrudRepository[Entity: Base | Type[Base]]:
 
         In caso di errore, delega la gestione a ``_handle_exception``.
 
+        Poiché usa ``.scalars()``, di ogni riga viene restituita solo la **prima**
+        colonna: statement arricchiti con ``add_columns`` perdono le colonne
+        aggiuntive. Per leggerle serve eseguire lo statement direttamente sulla
+        sessione (vedi ``distinct_pairs``, che usa ``session.execute(...).all()``).
+
         Args:
             session (Session): Sessione su cui eseguire lo statement.
             stmt (Select | Insert | Update | Delete): Statement da eseguire.

general/interface/repository/geometry_repository.py

@@ -150,50 +150,48 @@ class GeometryRepository[Entity: Base | Type[Base]](CrudRepository[Entity]):
         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,
-                distance: bool = True, parsing_model: Type[BaseModel] | BaseModel = None) -> list[Entity]:
+                parsing_model: Type[BaseModel] | BaseModel = None) -> list[Entity]:
         """Restituisce le entità più vicine alla geometria fornita, ordinate per distanza.
 
-        Aggiunge una colonna ``distance`` ai risultati con la distanza calcolata
-        tramite ``ST_Distance``. L'ordinamento usa l'operatore KNN ``<->``
-        (``distance_centroid``) anziché ``ST_Distance``: con ``LIMIT`` impostato,
-        PostGIS può servire la ricerca dei più vicini tramite l'indice spaziale
-        GiST, evitando il calcolo della distanza su tutte le righe.
+        L'ordinamento usa l'operatore KNN ``<->`` (``distance_centroid``) anziché
+        ``ST_Distance``: con ``LIMIT`` impostato, PostGIS può servire la ricerca dei
+        più vicini tramite l'indice spaziale GiST, evitando il calcolo della
+        distanza su tutte le righe.
 
         Args:
-            geom (WKBElement): Geometria di riferimento per il calcolo della distanza.
+            geom (WKBElement): Geometria di riferimento per il calcolo della prossimità.
             session (Session, optional): Sessione esterna.
             columns (list[str], optional): Colonne da includere.
             exclude_columns (list[str], optional): Colonne da escludere.
             limit (int): Numero di entità più vicine da restituire. Default: 1.
             where (dict[str, Any], optional): Filtri aggiuntivi.
             geom_srid (int): SRID della geometria fornita. Default: 4326.
-            distance (bool): Se ``True``, aggiunge ai risultati la colonna ``distance``
-                con la distanza calcolata via ``ST_Distance``. Default: ``True``.
-                L'ordinamento per prossimità (operatore KNN ``<->``) viene applicato
-                in ogni caso, indipendentemente da questo flag.
             parsing_model (Type[BaseModel], optional): Modello alternativo.
 
         Returns:
             list[Entity]: Entità ordinate dalla più vicina alla più lontana.
 
+        Note:
+            Restituisce solo le entità, senza il valore della distanza: la distanza
+            è usata unicamente per l'ordinamento lato database. Per ottenerla come
+            colonna serve uno statement custom, dato che ``execute`` restituisce
+            ``result.scalars().all()`` e terrebbe solo la prima colonna di ogni riga.
+
         Example:
             >>> nearest = repo.nearest(geom=my_point, limit=5)
         """
         keep_open = False if session is None else True
         session = self.open_session if session is None else session
-        entities = self._nearest(session=session, geom=geom, where=where, columns=columns, exclude_columns=exclude_columns, limit=limit, geom_srid=geom_srid, distance=distance)
+        entities = self._nearest(session=session, geom=geom, where=where, columns=columns, exclude_columns=exclude_columns, limit=limit, geom_srid=geom_srid)
         return self._return(session=session, entities=entities, keep_open=keep_open, commit=False, parsing_model=parsing_model)
 
-    def _nearest(self, session: Session, geom: WKBElement, columns: list[str] = None, exclude_columns: list[str] = None, limit: int = 1, where: dict[str, Any] = None, geom_srid: int = 4326, distance: bool = True):
+    def _nearest(self, session: Session, geom: WKBElement, columns: list[str] = None, exclude_columns: list[str] = None, limit: int = 1, where: dict[str, Any] = None, geom_srid: int = 4326):
         if where is None:
             where = {}
         stmt = self._select(entity=self.entity, columns=columns, exclude_columns=exclude_columns)
 
         geom_condition = self._geom_condition(geom=geom, geom_srid=geom_srid)
 
-        if distance:
-            stmt = stmt.add_columns(self.geom_column.ST_Distance(geom_condition).label("distance"))
-
         stmt = self.stmt_manager.prepare_statement(stmt=stmt, **where)
         stmt = stmt.order_by(self.geom_column.distance_centroid(geom_condition))
         stmt = self.stmt_manager.limit_offset_condition(stmt=stmt, limit=limit)

general/interface/repository/handler/base_handler.py

@@ -10,7 +10,14 @@ class BaseHandler:
     """Handler base per la costruzione di filtri WHERE su statement SQLAlchemy.
 
     Gestisce i casi standard di uguaglianza, liste (``IN``) e colonne di tipo
-    ``ARRAY``. Può essere esteso per supportare logiche di filtraggio personalizzate.
+    ``ARRAY``. È anche la classe base di tutti gli handler specializzati, che
+    possono estenderla per logiche di filtraggio personalizzate.
+
+    Nella pipeline dello ``StatementManager`` è sempre l'**ultimo** handler
+    eseguito: riceve le chiavi del ``where`` non consumate dagli handler
+    precedenti e le tratta come filtri su colonne reali. A differenza degli
+    handler specializzati non rimuove nulla dal dizionario, perché non ha
+    successori.
 
     Attributes:
         columns (ReadOnlyColumnCollection): Colonne della tabella su cui operare.
@@ -43,9 +50,14 @@ class BaseHandler:
             neq (bool): Se ``True``, applica la negazione (``NOT``) a ogni condizione.
                 Default: ``False``.
             where (dict[str, Any]): Dizionario ``{nome_colonna: valore}`` con i filtri.
+                Tutte le chiavi devono corrispondere a colonne reali della tabella.
 
         Returns:
             Select | Update | Delete: Statement arricchito con le clausole WHERE.
+
+        Raises:
+            KeyError: Se una chiave del ``where`` non corrisponde a nessuna colonna,
+                ovvero se nessun handler precedente l'ha consumata.
         """
         stmt = stmt.where(*[self._handle(column=self.columns[column], condition=condition, neq=neq) for column, condition in where.items()])
         return stmt

general/interface/repository/handler/interval_handler.py

@@ -15,21 +15,32 @@ class IntervalHandler(BaseHandler):
     condizioni ``>=`` e ``<=``. Supporta la semantica di "infinito come NULL"
     per il limite superiore.
 
+    Gli alias separano il nome del parametro esposto dall'API dal nome fisico
+    della colonna: ``from_``/``to_`` indicano le **colonne**, ``from_alias``/
+    ``to_alias`` le **chiavi del dizionario** ``where`` da cui leggere i valori.
+    Se non forniti, gli alias coincidono col nome della colonna.
+
+    Quando i due alias coincidono l'handler entra in modalità ``between``: una
+    singola chiave nel ``where`` valorizza entrambi i limiti (vedi ``handle``).
+
     Attributes:
-        from\\_ (Any): Chiave nel dizionario ``where`` per il limite inferiore.
-        to\\_ (Any): Chiave nel dizionario ``where`` per il limite superiore.
+        from\\_ (Any): Nome della colonna su cui applicare il limite inferiore (``>=``).
+        to\\_ (Any): Nome della colonna su cui applicare il limite superiore (``<=``).
+        from_alias (str): Chiave del ``where`` che valorizza il limite inferiore.
+        to_alias (str): Chiave del ``where`` che valorizza il limite superiore.
         inf_is_none (bool): Se ``True``, un valore ``NULL`` nella colonna ``to_``
             viene trattato come "senza limite superiore" (infinito).
+        between (bool): ``True`` se ``from_alias`` e ``to_alias`` coincidono.
 
     Example:
         >>> handler = IntervalHandler(
         ...     columns=Event.columns(),
-        ...     from_="start_date",
-        ...     to_="end_date",
+        ...     from_="data_inizio", from_alias="da",
+        ...     to_="data_fine", to_alias="a",
         ...     inf_is_none=True
         ... )
-        >>> repo.find(where={"start_date": "2024-01-01", "end_date": "2024-12-31"})
-        # WHERE start_date >= '2024-01-01' AND (end_date <= '2024-12-31' OR end_date IS NULL)
+        >>> repo.find(where={"da": "2024-01-01", "a": "2024-12-31"})
+        # WHERE data_inizio >= '2024-01-01' AND (data_fine <= '2024-12-31' OR data_fine IS NULL)
     """
     __slots__ = "from_", "to_", "inf_is_none", "from_alias", "to_alias", "between"
     from_: Any
@@ -37,19 +48,28 @@ class IntervalHandler(BaseHandler):
     from_alias: str
     to_alias: str
     inf_is_none: bool
+    between: bool
 
     def __init__(self, columns: ReadOnlyColumnCollection[str, Column[Any]], from_: Any = None, from_alias: str = None, to_: Any = None, to_alias: str = None, inf_is_none: bool = False):
-        """Inizializza l'handler con le chiavi per il limite inferiore e superiore.
+        """Inizializza l'handler con le colonne dei limiti e i relativi alias.
 
         Args:
             columns (ReadOnlyColumnCollection): Colonne della tabella.
-            from\\_ (Any, optional): Chiave nel ``where`` per il limite inferiore
+            from\\_ (Any, optional): Nome della colonna per il limite inferiore
                 (condizione ``>=``). Default: ``None`` (disabilitato).
-            to\\_ (Any, optional): Chiave nel ``where`` per il limite superiore
+            from_alias (str, optional): Chiave del ``where`` da cui leggere il limite
+                inferiore. Se omessa, vale ``str(from_)``.
+            to\\_ (Any, optional): Nome della colonna per il limite superiore
                 (condizione ``<=``). Default: ``None`` (disabilitato).
+            to_alias (str, optional): Chiave del ``where`` da cui leggere il limite
+                superiore. Se omessa, vale ``str(to_)``.
             inf_is_none (bool): Se ``True``, aggiunge ``OR col IS NULL`` alla
                 condizione sul limite superiore per trattare NULL come infinito.
                 Default: ``False``.
+
+        Note:
+            Se gli alias risultanti sono uguali viene attivata la modalità
+            ``between`` (attributo ``between``).
         """
         self.columns = columns
         self.from_ = from_
@@ -62,9 +82,14 @@ class IntervalHandler(BaseHandler):
     def handle(self, stmt: Select | Update | Delete, where: dict[str, Any] = None, **kwargs):
         """Applica le condizioni di range allo statement estraendo i valori da ``where``.
 
-        Estrae e rimuove in-place le chiavi ``from_`` e ``to_`` dal dizionario
-        ``where``, quindi aggiunge le relative condizioni allo statement.
-        Se una chiave non è presente in ``where``, quella condizione viene ignorata.
+        Estrae e rimuove in-place le chiavi ``from_alias`` e ``to_alias`` dal
+        dizionario ``where``, quindi aggiunge le relative condizioni allo statement.
+        In modalità ``between`` viene letta solo ``from_alias`` e il suo valore è
+        usato per entrambi i limiti.
+
+        I valori falsy (``None``, ``0``, ``""``) vengono ignorati: la condizione non
+        viene aggiunta, ma la chiave è comunque rimossa dal ``where``. Un limite
+        inferiore pari a ``0`` non produce quindi nessun filtro.
 
         Args:
             stmt (Select | Update | Delete): Statement su cui applicare le condizioni.
@@ -76,16 +101,21 @@ class IntervalHandler(BaseHandler):
             Select | Update | Delete: Statement con le condizioni di range aggiunte.
 
         Note:
-            - Limite inferiore: ``col >= value``
-            - Limite superiore: ``col <= value`` oppure ``(col <= value OR col IS NULL)``
+            - Limite inferiore: ``from_ >= value``
+            - Limite superiore: ``to_ <= value`` oppure ``(to_ <= value OR to_ IS NULL)``
               se ``inf_is_none=True``.
+            - In modalità ``between`` le condizioni generate restano ``from_ >= value``
+              e ``to_ <= value``. Per ottenere la semantica "la riga è valida al valore
+              indicato" le colonne vanno mappate invertite, ad es. ``from_="data_fine"``
+              e ``to_="data_inizio"`` con lo stesso alias ``"data"``, che produce
+              ``data_fine >= value AND data_inizio <= value``.
         """
         from_condition = where.pop(self.from_alias, None)
         to_condition = where.pop(self.to_alias, None) if not self.between else from_condition
         if from_condition:
-            stmt = stmt.where(self.columns[self.from_] <= from_condition)
+            stmt = stmt.where(self.columns[self.from_] >= from_condition)
         if to_condition:
-            condition = self.columns[self.to_] >= to_condition
+            condition = self.columns[self.to_] <= to_condition
             if self.inf_is_none:
                 condition = or_(condition, self.columns[self.to_] == None)
             stmt = stmt.where(condition)

general/interface/repository/handler/json_handler.py

@@ -16,6 +16,9 @@ class JsonHandler(BaseHandler):
     interne al campo JSON. Trova la prima colonna di tipo ``dict`` (JSON/JSONB)
     e applica filtri con ``col['key'].as_string() == str(value)``.
 
+    Il confronto è sempre stringa-contro-stringa (``as_string()`` sulla chiave JSON
+    e ``str(value)`` sul valore): numeri e booleani vengono confrontati come testo.
+
     Attributes:
         json_column (str): Nome della colonna JSON/JSONB rilevata automaticamente.
 
@@ -38,6 +41,11 @@ class JsonHandler(BaseHandler):
 
         Args:
             columns (ReadOnlyColumnCollection): Colonne della tabella.
+
+        Note:
+            Se la tabella non ha colonne JSON, ``json_column`` non viene impostato:
+            una chiave sconosciuta nel ``where`` provoca in tal caso un
+            ``AttributeError`` in ``handle``.
         """
         self.columns = columns
         for key, column in columns.items():

general/interface/repository/handler/json_ilike_handler.py

@@ -8,25 +8,35 @@ from sqlalchemy.sql.base import ReadOnlyColumnCollection
 
 
 class JsonILikeHandler(BaseHandler):
-    """Handler per ricerche case-insensitive (ILIKE) su più colonne tramite un alias.
+    """Handler per ricerche ILIKE su colonne reali **e** su sotto-chiavi JSON/JSONB.
 
-    Permette di esporre un singolo parametro di ricerca testuale (es. ``"search"``)
-    che viene applicato come ``ILIKE '%value%'`` su un insieme di colonne con ``OR``.
+    Variante di ``ILikeHandler`` per entità che tengono parte dei dati in una
+    colonna JSON: un singolo parametro di ricerca testuale (es. ``"search"``)
+    viene applicato come ``ILIKE '%value%'`` sia sulle colonne della tabella sia
+    sulle chiavi interne al campo JSON, tutto unito da ``OR``.
+
+    Gli ``ilike_attributes`` passati al costruttore vengono ripartiti
+    automaticamente: i nomi che corrispondono a colonne reali finiscono in
+    ``ilike_attributes``, gli altri in ``json_ilike_keys`` e sono trattati come
+    chiavi dentro ``json_column``. A differenza di ``ILikeHandler``, quindi, un
+    nome sconosciuto non solleva ``ValueError``: è proprio il caso d'uso previsto.
 
     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"]``).
+            la ricerca (es. ``["search", "q"]``).
+        ilike_attributes (list[str]): Colonne reali su cui applicare ILIKE.
+        json_ilike_keys (list[str]): Chiavi interne al campo JSON su cui applicare ILIKE.
+        json_column (str): Nome della colonna JSON/JSONB rilevata automaticamente
+            (la prima con ``python_type == dict``).
 
     Example:
         >>> handler = JsonILikeHandler(
-        ...     columns=User.columns(),
+        ...     columns=Item.columns(),
         ...     ilike_aliases=["search"],
-        ...     ilike_attributes=["name", "surname"]
+        ...     ilike_attributes=["name", "codice_interno"]  # "codice_interno" è una chiave JSON
         ... )
-        >>> repo.find(where={"search": "mario"})
-        # WHERE name ILIKE '%mario%' OR surname ILIKE '%mario%'
+        >>> repo.find(where={"search": "abc"})
+        # WHERE name ILIKE '%abc%' OR attributes ->> 'codice_interno' ILIKE '%abc%'
     """
     __slots__ = "ilike_aliases", "ilike_attributes", "json_column", "json_ilike_keys"
     ilike_aliases: list[str]
@@ -35,17 +45,24 @@ class JsonILikeHandler(BaseHandler):
     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à.
+        """Inizializza l'handler ripartendo gli attributi tra colonne reali e chiavi JSON.
+
+        Itera sugli ``ilike_attributes`` e li smista in base alla presenza tra le
+        colonne della tabella. Individua poi la colonna JSON come la prima con
+        ``type.python_type == dict``; le colonne che non implementano
+        ``python_type`` (es. geometrie) vengono ignorate.
 
         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.
+            ilike_attributes (list[str], optional): Colonne reali e/o chiavi JSON
+                su cui applicare ILIKE. Default: nessun attributo.
 
-        Raises:
-            ValueError: Se uno degli ``ilike_attributes`` non è presente tra le colonne.
+        Note:
+            Se la tabella non ha colonne JSON, ``json_column`` non viene impostato:
+            usare l'handler con delle ``json_ilike_keys`` provoca in tal caso un
+            ``AttributeError`` alla prima ricerca.
         """
         self.columns = columns
         self.ilike_aliases = ilike_aliases if ilike_aliases is not None else []
@@ -70,13 +87,16 @@ class JsonILikeHandler(BaseHandler):
     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``,
+        Per ogni alias presente in ``ilike_aliases`` e valorizzato in ``where``,
         estrae il valore, lo rimuove dal dizionario e aggiunge la condizione ILIKE
-        su tutte le colonne in ``ilike_attributes`` con ``OR``.
+        su tutte le colonne reali e le chiavi JSON configurate, unite da ``OR``.
+
+        I valori falsy (``None``, ``""``) vengono ignorati: la condizione non viene
+        aggiunta, ma la chiave è comunque rimossa dal ``where``.
 
         Args:
             stmt (Select | Update | Delete): Statement su cui applicare i filtri.
-            where (dict[str, Any]): Dizionario dei filtri. Gli alias ILIKE vengono
+            where (dict[str, Any]): Dizionario dei filtri. Gli alias gestiti vengono
                 estratti e rimossi in-place.
             **kwargs: Ignorati (compatibilità con l'interfaccia base).
 
@@ -91,14 +111,18 @@ class JsonILikeHandler(BaseHandler):
         return stmt
 
     def _handle(self, alias: str, condition: str, neq: bool = False):
-        """Costruisce la condizione ILIKE con OR su tutte le colonne configurate.
+        """Costruisce la condizione ILIKE in OR su colonne reali e chiavi JSON.
+
+        Le chiavi JSON vengono estratte con ``json_column[key].as_string()`` prima
+        di applicare l'``ILIKE``, così il confronto avviene sul testo.
 
         Args:
-            alias (str): Alias attivato (usato per identificare la ricerca, non la colonna).
+            alias (str): Alias attivato. Serve solo a identificare la ricerca,
+                non è il nome di una colonna e non viene usato nella condizione.
             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%', ...)``.
+            ColumnElement: Espressione ``OR(col ILIKE '%val%', ..., json_col ->> 'key' 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])

general/interface/repository/handler/or_handler.py

@@ -9,38 +9,47 @@ from .base_handler import BaseHandler
 
 
 class OrHandler(BaseHandler):
-    """Handler per ricerche case-insensitive (ILIKE) su più colonne tramite un alias.
+    """Handler per filtri di uguaglianza applicati a più colonne in ``OR``.
 
-    Permette di esporre un singolo parametro di ricerca testuale (es. ``"search"``)
-    che viene applicato come ``ILIKE '%value%'`` su un insieme di colonne con ``OR``.
+    Permette di esporre un singolo parametro (es. ``"id_soggetto"``) il cui valore
+    viene confrontato per uguaglianza con un insieme di colonne alternative, unite
+    da ``OR``. Utile quando lo stesso dato può comparire indifferentemente su una
+    di più colonne (es. mittente/destinatario, operatore di partenza/arrivo).
+
+    A differenza di ``ILikeHandler`` il confronto è **esatto** (``==``), non
+    ``ILIKE``: non c'è wrapping con ``%`` né case-insensitivity.
 
     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"]``).
+            il filtro (es. ``["id_soggetto"]``).
+        or_attributes (list[str]): Nomi delle colonne messe in ``OR``
+            (es. ``["id_mittente", "id_destinatario"]``).
+
+    Note:
+        Non è re-esportato da ``handler/__init__.py``: va importato dal modulo,
+        ``from general.interface.repository.handler.or_handler import OrHandler``.
 
     Example:
         >>> handler = OrHandler(
-        ...     columns=User.columns(),
-        ...     or_aliases=["search"],
-        ...     or_attributes=["name", "surname"]
+        ...     columns=Doc.columns(),
+        ...     or_aliases=["id_soggetto"],
+        ...     or_attributes=["id_mittente", "id_destinatario"]
         ... )
-        >>> repo.find(where={"search": "mario"})
-        # WHERE name ILIKE '%mario%' OR surname ILIKE '%mario%'
+        >>> repo.find(where={"id_soggetto": 42})
+        # WHERE id_mittente = 42 OR id_destinatario = 42
     """
     __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à.
+        """Inizializza l'handler validando che le colonne in OR esistano sull'entità.
 
         Args:
             columns (ReadOnlyColumnCollection): Colonne della tabella.
-            or_aliases (list[str], optional): Chiavi alias che attivano la ricerca.
+            or_aliases (list[str], optional): Chiavi alias che attivano il filtro.
                 Default: lista vuota.
-            or_attributes (list[str], optional): Colonne su cui applicare ILIKE.
+            or_attributes (list[str], optional): Colonne da confrontare in ``OR``.
                 Default: lista vuota.
 
         Raises:
@@ -55,20 +64,23 @@ class OrHandler(BaseHandler):
                 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``.
+        """Applica i filtri in OR allo statement per ogni alias trovato in ``where``.
+
+        Per ogni alias presente in ``or_aliases`` e valorizzato in ``where``,
+        estrae il valore, lo rimuove dal dizionario e aggiunge la condizione di
+        uguaglianza su tutte le colonne in ``or_attributes``, unite da ``OR``.
 
-        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``.
+        I valori falsy (``None``, ``0``, ``""``) vengono ignorati: la condizione
+        non viene aggiunta, ma la chiave è comunque rimossa dal ``where``.
 
         Args:
             stmt (Select | Update | Delete): Statement su cui applicare i filtri.
-            where (dict[str, Any]): Dizionario dei filtri. Gli alias ILIKE vengono
+            where (dict[str, Any]): Dizionario dei filtri. Gli alias gestiti vengono
                 estratti e rimossi in-place.
             **kwargs: Ignorati (compatibilità con l'interfaccia base).
 
         Returns:
-            Select | Update | Delete: Statement con le condizioni ILIKE aggiunte.
+            Select | Update | Delete: Statement con le condizioni in OR aggiunte.
         """
         for alias in self.or_aliases:
             condition = where.pop(alias, None)
@@ -77,14 +89,15 @@ class OrHandler(BaseHandler):
         return stmt
 
     def _handle(self, alias: str, condition: str, neq: bool = False):
-        """Costruisce la condizione ILIKE con OR su tutte le colonne configurate.
+        """Costruisce la condizione di uguaglianza in 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 ``%``).
+            alias (str): Alias attivato. Serve solo a identificare la ricerca,
+                non è il nome di una colonna e non viene usato nella condizione.
+            condition (str): Valore da confrontare per uguaglianza.
             neq (bool): Non utilizzato in questa implementazione.
 
         Returns:
-            ColumnElement: Espressione ``OR(col1 ILIKE '%val%', col2 ILIKE '%val%', ...)``.
+            ColumnElement: Espressione ``OR(col1 = value, col2 = value, ...)``.
         """
         return or_(*[self.columns[col] == condition for col in self.or_attributes])

general/interface/repository/handler/statement_manager.py

@@ -17,6 +17,13 @@ class StatementManager:
 
     L'ordine di esecuzione è: handler aggiuntivi (nell'ordine fornito) → handler base.
 
+    Il contratto della pipeline è che ogni handler specializzato **consuma
+    in-place** le chiavi che riconosce dal dizionario ``where`` (via
+    ``where.pop(...)``), lasciando ai successivi solo le chiavi non gestite.
+    L'handler base, eseguito per ultimo, tratta le chiavi rimanenti come filtri
+    su colonne reali: una chiave che nessun handler consuma e che non è una
+    colonna provoca un ``KeyError``. L'ordine degli handler è quindi significativo.
+
     Attributes:
         _handlers (list[BaseHandler]): Handler aggiuntivi registrati.
         _base_handler (BaseHandler): Handler principale, sempre eseguito per ultimo.
@@ -50,10 +57,16 @@ class StatementManager:
         Args:
             stmt (Select | Update | Delete): Statement su cui applicare i filtri.
             neq (bool): Se ``True``, applica la negazione a tutti i filtri. Default: ``False``.
+                Nota: solo ``BaseHandler`` implementa la negazione; gli handler
+                specializzati ignorano questo flag.
             **where: Filtri come keyword arguments ``{colonna: valore}``.
 
         Returns:
             Select | Update | Delete: Statement con tutte le clausole WHERE applicate.
+
+        Raises:
+            KeyError: Se una chiave non consumata da nessun handler non corrisponde
+                a una colonna reale (sollevato da ``BaseHandler``).
         """
         for handler in self._handlers:
             stmt = handler.handle(stmt=stmt, neq=neq, where=where)

general/interface/repository/many_to_many_repository.py

@@ -15,6 +15,16 @@ class ManyToManyRepository[Entity: Base | Type[Base]](CrudRepository[Entity]):
     Estende ``CrudRepository`` con metodi per sincronizzare collezioni di entità
     figlie rispetto a un parent, gestendo automaticamente insert, update e delete
     in base alle differenze tra la lista corrente e quella desiderata.
+
+    A differenza degli altri repository, tutti i metodi di questa classe
+    **richiedono una ``session`` esplicita**: non ne aprono una propria e non
+    eseguono commit, perché una sincronizzazione differenziale è per definizione
+    un'operazione da svolgere nella stessa transazione del parent. È il chiamante
+    a decidere quando committare. Per lo stesso motivo restituiscono entità ORM
+    grezze e non modelli Pydantic.
+
+    Le ``session.delete(...)`` accodate diventano effettive solo al flush/commit
+    del chiamante.
     """
 
     def diff_upsert_from_parent(self, session: Session, parent: Type[Base], children: list[Type[BaseModel]], relationship_attribute: str, child_fks: dict[str, Any], child_pk: str = "id") -> list[Entity]:

general/logger.py

@@ -57,6 +57,8 @@ class EndpointFilter(logging.Filter):
 
         Args:
             endpoint (str): Stringa dell'endpoint da filtrare (es. ``"/health"``).
+            *args: Argomenti posizionali passati a ``logging.Filter``.
+            **kwargs: Argomenti keyword passati a ``logging.Filter`` (es. ``name``).
         """
         super().__init__(*args, **kwargs)
         self.endpoint = endpoint
@@ -108,6 +110,11 @@ def log(func):
     Returns:
         Callable: Funzione wrapper con logging integrato.
 
+    Note:
+        Il wrapper è **sincrono**: applicato a una coroutine function misura il tempo
+        di creazione della coroutine, non della sua esecuzione, e non intercetta le
+        eccezioni sollevate durante l'await.
+
     Example:
         >>> @log
         ... def get_users():

python_general_be_lib-0.8.0.dist-info/METADATA

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: python-general-be-lib
+Version: 0.8.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
+Project-URL: Homepage, https://github.com/Arpes-IS/python-general-be-lib
+Project-URL: Repository, https://github.com/Arpes-IS/python-general-be-lib
+Keywords: backend,sqlalchemy,fastapi,pydantic,repository,crud,geoalchemy2
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Database
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: sqlalchemy>=2.0.0
+Requires-Dist: geoalchemy2>=0.14.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+Dynamic: requires-python
+
+# python-general-be-lib
+
+Libreria backend general purpose per progetti Python: repository CRUD e spaziali
+su **SQLAlchemy** / **GeoAlchemy2**, eccezioni **FastAPI**, modelli base
+**Pydantic** e utility di logging.
+
+- Distribuzione PyPI: `python-general-be-lib`
+- Pacchetto importabile: `general`
+- Python richiesto: **3.12+**
+
+```bash
+pip install python-general-be-lib
+```
+
+```python
+from sqlalchemy import create_engine
+
+from general.interface.repository.crud_repository import CrudRepository
+
+engine = create_engine("postgresql://user:pass@localhost/db")
+repo = CrudRepository(entity=User, model=UserModel, engine=engine)
+
+repo.insert(models=[UserModel(name="Mario", email="mario@example.com")])
+repo.find(active=True, order_by="name", asc=True)
+```
+
+---
+
+## Cosa contiene
+
+| Area | Componenti |
+|---|---|
+| Repository ORM | `CrudRepository`, `GeometryRepository`, `ManyToManyRepository`, `ViewRepository` |
+| Layer Core (senza ORM) | `CrudMetadata`, `GeomMetadata` — CRUD e query spaziali su `Table` riflesse |
+| Motore di filtraggio | `StatementManager` + `BaseHandler`, `JsonHandler`, `ILikeHandler`, `JsonILikeHandler`, `OrHandler`, `IntervalHandler` |
+| Basi | `Base` (declarative base estesa), `ExtBaseModel`, `CamelExtBaseModel` |
+| Paginazione | `PaginatorRequestModel`, `PaginatorResponseModel` |
+| Eccezioni | `ExceptionInterface` e sottoclassi HTTP (400/401/403/404/422/500/503) |
+| Logging | `init_logger`, decorator `@log` |
+
+---
+
+## Documentazione
+
+Il codice della libreria vive nella directory `general/`, che è un **git
+submodule** ([novatellus/shared-be-libs](https://github.com/novatellus/shared-be-libs)).
+Questo repository esterno è il wrapper di packaging e pubblicazione.
+
+- **[general/README.md](general/README.md)** — panoramica, quickstart, contratto
+  di sessione, handler, operazioni spaziali
+- **[general/DOCS.md](general/DOCS.md)** — riferimento completo di ogni metodo
+
+Dopo il clone, inizializza il submodule:
+
+```bash
+git submodule update --init --recursive
+```
+
+---
+
+## Build e pubblicazione
+
+La versione è definita in **entrambi** `setup.py` e `pyproject.toml`: vanno
+aggiornati insieme. I messaggi di commit sono prefissati con la nuova versione
+(es. `0.7.2 OrHandler e distinct_pairs`).
+
+```bash
+python3 setup.py sdist bdist_wheel   # build di sdist + wheel in dist/
+python3 -m twine upload dist/*       # pubblicazione su PyPI
+```
+
+---
+
+## Licenza
+
+MIT — vedi [LICENSE](LICENSE).

python_general_be_lib-0.8.0.dist-info/RECORD

@@ -0,0 +1,32 @@
+general/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+general/log_config.ini,sha256=-uFliGt3D0PYauup7XGJ-B87JF1AvkiS8IakwubNYs8,321
+general/logger.py,sha256=IVWWUHT5HJcCWW1-2QW8x_Ylyc24-Jf_N4eLJHth_fY,4584
+general/paginator_dto.py,sha256=hpR_R0dLOLN_R5IOtSm2slxt4rYl5sxza5id1c-YdnQ,2480
+general/exception/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+general/exception/access_exceptions.py,sha256=pbzNTj3P8-jL7md84px4zZtrdTHUe7Wn8-xVwwetxVg,863
+general/exception/crud_exceptions.py,sha256=C2XPcCDctTAt20-we3II4WbSEb4yCQK4MjgVowlsdLQ,3138
+general/exception/exception_interface.py,sha256=TJ2Yd_RgwP22DWCzNXQSEAMXdRJsAoOH07RLBjY5IwU,1577
+general/interface/base/__init__.py,sha256=SDlTi28M8rzJ9yiKefo5l7V3K109LnnBHW-SuZ-5JtM,58
+general/interface/base/base_model.py,sha256=Tsy70uC6HHe194ZrQaX7pXROqobOkZIOB63VdagmFHE,2561
+general/interface/base/declarative_base.py,sha256=uaY24rt_bfDYRCMZ66QSIjDL5Yf7x5T_Bo26zXv5VLM,5560
+general/interface/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+general/interface/metadata/crud_metadata.py,sha256=BFohkkpUd7w211NYqAD20X4ZpovrXH7BERA1_Rs4Dv0,23291
+general/interface/metadata/geom_metadata.py,sha256=J5SMXMiDUXnzt7bNH12LIQO6S7jcLNf7Cm4CdLXv8Lg,12255
+general/interface/repository/__init__.py,sha256=EcRukwf61Ua-9-JfM_ingVv1wXNRV8HBrrWwjj8m23w,136
+general/interface/repository/crud_repository.py,sha256=ej8J_ybYVAfJUXKLdFPSq4w9iGtoM8z5kqJl34dxRZg,36669
+general/interface/repository/geometry_repository.py,sha256=FZNYWbfiwYSeiJXdZjnmgSm8hbnNXoW_skOw9D5nwNk,11730
+general/interface/repository/many_to_many_repository.py,sha256=ZyuK2fk5ZI9xE8xhZwk5Vb1QItnOxwEF5CGsemnMdn8,9197
+general/interface/repository/view_repository.py,sha256=Rr9toRVop0sLpPwo9QvBDJgLQnB0ca--mp-hiwjGrzE,5835
+general/interface/repository/handler/__init__.py,sha256=J-fc-5Dl_C821oy_EVRdyU-L2iXiNFriYJDbK4ODIMM,184
+general/interface/repository/handler/base_handler.py,sha256=L55CbpMNXPwYNKqPQW12ES08w3KvNC7J8bA_YfXRhSY,4187
+general/interface/repository/handler/ilike_handler.py,sha256=_HHTvj6Tm1L-WvUy1S9faRChoRZni11i9mv76I4Xak0,3919
+general/interface/repository/handler/interval_handler.py,sha256=TFG9xtp92fVp-YfyKfFnD57d89CLRn1n6WrFUIh1KS8,6005
+general/interface/repository/handler/json_handler.py,sha256=1F5t-TFWmzsGNhmazFX9mppZBPBY4WDz-FRpyutACWU,3343
+general/interface/repository/handler/json_ilike_handler.py,sha256=4Rizn9xEUH6VLHSdz8eQhxaUwfo6xAjxdaRGRG4ODNw,6095
+general/interface/repository/handler/or_handler.py,sha256=KG6T0DV3gsAqxgTaXqe6v9rIIyS7VNIqNWajjB3P-qI,4527
+general/interface/repository/handler/statement_manager.py,sha256=PenSFIJ3BK6HJp8M8wemr5DbdrbhJ9Cu3aGcBND3NZ0,5195
+python_general_be_lib-0.8.0.dist-info/licenses/LICENSE,sha256=iUaO1XZyB9P3Tmog0OILuTisP6vXGe3QKz-4yRTxOFk,1069
+python_general_be_lib-0.8.0.dist-info/METADATA,sha256=mCNCdLBpcsDBfzIS890bqp2g-lmgT4bejKv938m18W4,3790
+python_general_be_lib-0.8.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+python_general_be_lib-0.8.0.dist-info/top_level.txt,sha256=tTZePW8_CNUqSgKFd2SEH72ZbnhS0OYjRsgcv0ikSFY,8
+python_general_be_lib-0.8.0.dist-info/RECORD,,

python_general_be_lib-0.7.1.dist-info/METADATA

@@ -1,33 +0,0 @@
-Metadata-Version: 2.4
-Name: python-general-be-lib
-Version: 0.7.1
-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
-Project-URL: Homepage, https://github.com/Arpes-IS/python-general-be-lib
-Project-URL: Repository, https://github.com/Arpes-IS/python-general-be-lib
-Keywords: backend,sqlalchemy,fastapi,pydantic,repository,crud,geoalchemy2
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Database
-Classifier: Topic :: Internet :: WWW/HTTP
-Requires-Python: >=3.12
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: fastapi>=0.100.0
-Requires-Dist: pydantic>=2.0.0
-Requires-Dist: sqlalchemy>=2.0.0
-Requires-Dist: geoalchemy2>=0.14.0
-Provides-Extra: dev
-Requires-Dist: pytest>=7; extra == "dev"
-Requires-Dist: pytest-cov; extra == "dev"
-Requires-Dist: build; extra == "dev"
-Requires-Dist: twine; extra == "dev"
-Dynamic: license-file
-Dynamic: requires-python
-
-# python-general-be-lib

python_general_be_lib-0.7.1.dist-info/RECORD

@@ -1,32 +0,0 @@
-general/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-general/log_config.ini,sha256=-uFliGt3D0PYauup7XGJ-B87JF1AvkiS8IakwubNYs8,321
-general/logger.py,sha256=JrU50FOE2CDSJ61NthFMuVrGhUavfdksbEI5aUrakjI,4201
-general/paginator_dto.py,sha256=hpR_R0dLOLN_R5IOtSm2slxt4rYl5sxza5id1c-YdnQ,2480
-general/exception/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-general/exception/access_exceptions.py,sha256=8AV4_gybcdA7mTpA2XiZdl9rRGx08QCjHpBGv60EL4I,300
-general/exception/crud_exceptions.py,sha256=c-VlatTPjEp7FWzA7rDByqfMqsEOworJqqfUJ3s0Z2w,1101
-general/exception/exception_interface.py,sha256=T4bq8jwZ1YFpGlP60TxbvhkcyIrfsjcw5I6Xlxvzjig,352
-general/interface/base/__init__.py,sha256=SDlTi28M8rzJ9yiKefo5l7V3K109LnnBHW-SuZ-5JtM,58
-general/interface/base/base_model.py,sha256=Tsy70uC6HHe194ZrQaX7pXROqobOkZIOB63VdagmFHE,2561
-general/interface/base/declarative_base.py,sha256=5hw2VpJHHebjixuI3d4wpkyAentGBGN54QXcniaoJ-A,5236
-general/interface/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-general/interface/metadata/crud_metadata.py,sha256=wBBFfwq7xUu1sDlAg14qTAToYtSf6omcEOu2oLn-j5w,22672
-general/interface/metadata/geom_metadata.py,sha256=kc6jkWis-WPdWAP-hN6U97ENVjNjny5NE2j-llwZYOQ,11998
-general/interface/repository/__init__.py,sha256=EcRukwf61Ua-9-JfM_ingVv1wXNRV8HBrrWwjj8m23w,136
-general/interface/repository/crud_repository.py,sha256=-68XWLGeUG-knvJ6wAaf8uOwTs5ZK9h4H4N2mN1HeGY,35351
-general/interface/repository/geometry_repository.py,sha256=ULU-FnDATojHLDrObLPyAA3KErgX_tyYEeTU8h2O4Hs,11989
-general/interface/repository/many_to_many_repository.py,sha256=iEhWyD8nPZSAPL8Z2wXrK-aRBnoh3evaSN-voaf0EP0,8662
-general/interface/repository/view_repository.py,sha256=Rr9toRVop0sLpPwo9QvBDJgLQnB0ca--mp-hiwjGrzE,5835
-general/interface/repository/handler/__init__.py,sha256=J-fc-5Dl_C821oy_EVRdyU-L2iXiNFriYJDbK4ODIMM,184
-general/interface/repository/handler/base_handler.py,sha256=jedf7ACFPlYKHC9U9ZpVN4vCC0EXO3s4Rtyn15kKi_w,3558
-general/interface/repository/handler/ilike_handler.py,sha256=_HHTvj6Tm1L-WvUy1S9faRChoRZni11i9mv76I4Xak0,3919
-general/interface/repository/handler/interval_handler.py,sha256=LGg9MQyalTmlxthdzlIJXv5WT58NEz1QMUB-06pNR7M,4135
-general/interface/repository/handler/json_handler.py,sha256=7bS59seB-It5KHsWXTbHGsEvbQZ6lYyvX-d29BcRLVE,2956
-general/interface/repository/handler/json_ilike_handler.py,sha256=yDuKER3yqtnHpVWndF8PVEaqDThcq1EhZzLaqxbQ0bU,4491
-general/interface/repository/handler/or_handler.py,sha256=v97QMQwqrhTpfpZQWfvL6HC4lM9kjMEmY0-Sps968oI,3818
-general/interface/repository/handler/statement_manager.py,sha256=sGDMU4fPkF0_9-SbDmAw8Vpel1Z7eImBs8fHO-5Lr_0,4429
-python_general_be_lib-0.7.1.dist-info/licenses/LICENSE,sha256=iUaO1XZyB9P3Tmog0OILuTisP6vXGe3QKz-4yRTxOFk,1069
-python_general_be_lib-0.7.1.dist-info/METADATA,sha256=WEDCiuFY7P2ToCxtUhOOxMaYhtYuyDF9GnaQHLO_eBY,1384
-python_general_be_lib-0.7.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-python_general_be_lib-0.7.1.dist-info/top_level.txt,sha256=tTZePW8_CNUqSgKFd2SEH72ZbnhS0OYjRsgcv0ikSFY,8
-python_general_be_lib-0.7.1.dist-info/RECORD,,