python-general-be-lib 0.5.4__py3-none-any.whl → 0.6.0__py3-none-any.whl

general/interface/metadata/crud_metadata.py

@@ -5,18 +5,58 @@ 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.exc import NoSuchTableError
 
-from ...exception.crud_exceptions import HasNoAttributeException
+from ...exception.crud_exceptions import HasNoAttributeException, InternalServerException
 
 
 class CrudMetadata:
+    """Repository CRUD basato su SQLAlchemy Core e ``MetaData``, senza ORM.
+
+    Alternativa a ``CrudRepository`` che opera su tabelle riflesse (``Table``)
+    e ``Connection`` invece che su entità mappate e ``Session``. Utile per
+    lavorare con tabelle prive di un modello ORM: lo schema viene riflesso a
+    runtime e le tabelle sono risolte per nome.
+
+    Le operazioni accettano una connessione esterna opzionale: se fornita
+    (``keep_open=True``) i risultati grezzi vengono restituiti senza commit né
+    chiusura; altrimenti la connessione viene aperta, committata e chiusa
+    internamente.
+
+    Attributes:
+        schema (str | None): Nome dello schema di default per le tabelle.
+        metadata (MetaData): Contenitore SQLAlchemy delle tabelle riflesse/definite.
+        engine (Engine): Istanza SQLAlchemy Engine connessa al database.
+        engine_inspection (Inspector): Inspector usato per le introspezioni
+            (es. presenza tabelle).
+
+    Example:
+        >>> meta = CrudMetadata(engine=engine, schema_name="public")
+        >>> rows = meta.find(from_table="users", where={"active": True}, limit=10)
+    """
     __slots__ = "schema", "metadata", "engine", "engine_inspection"
 
     @property
     def open_connection(self):
+        """Apre e restituisce una nuova connessione all'engine.
+
+        Returns:
+            Connection: Nuova connessione associata all'engine configurato.
+        """
         return self.engine.connect()
 
     def __init__(self, engine: Engine, schema_name: str = None, reflect: bool = True):
+        """Inizializza il repository con l'engine e (opzionalmente) riflette lo schema.
+
+        Args:
+            engine (Engine): Istanza SQLAlchemy Engine connessa al database.
+            schema_name (str, optional): Nome dello schema di default a cui
+                appartengono le tabelle. Se ``None``, viene usato lo schema di
+                default della connessione.
+            reflect (bool): Se ``True``, riflette tutte le tabelle dello schema
+                indicato alla costruzione (operazione potenzialmente costosa su
+                schemi grandi). Default: ``True``.
+        """
         self.schema = schema_name
         self.metadata = MetaData(schema_name) if schema_name else MetaData()
         self.engine = engine
@@ -27,21 +67,62 @@ class CrudMetadata:
     # ---------------------------
 
     def _handle_exception(self, connection: Connection, e: Exception, to_raise: bool = True):
+        """Chiude la connessione, logga l'errore ed eventualmente lo rilancia.
+
+        Args:
+            connection (Connection): Connessione da chiudere.
+            e (Exception): Eccezione catturata.
+            to_raise (bool): Se ``True``, rilancia l'eccezione dopo il logging.
+                Default: ``True``.
+
+        Raises:
+            Exception: L'eccezione originale, se ``to_raise=True``.
+        """
         connection.close()
         logging.error(e)
         if to_raise:
             raise e
 
     def commit(self, connection: Connection):
+        """Esegue il commit sulla connessione, gestendo eventuali eccezioni.
+
+        Args:
+            connection (Connection): Connessione su cui eseguire il commit.
+
+        Raises:
+            Exception: In caso di errore durante il commit (via ``_handle_exception``).
+        """
         try:
             connection.commit()
         except Exception as e:
             self._handle_exception(connection, e)
 
     def has_columns(self, *columns: Iterable[str], table: Table):
+        """Verifica che tutte le colonne specificate esistano sulla tabella.
+
+        Args:
+            *columns (str): Nomi delle colonne da verificare.
+            table (Table): Tabella su cui effettuare la verifica.
+
+        Returns:
+            bool: ``True`` se tutte le colonne sono presenti, ``False`` altrimenti.
+        """
         return all([column in [c.key for c in table.c] for column in columns])
 
     def _select(self, table: Table, columns: list[str] = None):
+        """Costruisce lo statement SELECT sulla tabella.
+
+        Args:
+            table (Table): Tabella su cui costruire il SELECT.
+            columns (list[str], optional): Colonne da selezionare. Se ``None``,
+                seleziona tutte le colonne della tabella.
+
+        Returns:
+            Select: Statement SELECT configurato.
+
+        Raises:
+            HasNoAttributeException: Se una colonna specificata non esiste sulla tabella.
+        """
         try:
             stmt = table.select() if not columns else select(*[table.c[column] for column in columns])
         except:
@@ -50,6 +131,25 @@ class CrudMetadata:
 
     def _return(self, connection: Connection, result: CursorResult | RowMapping | Sequence[RowMapping] | Sequence[dict] = None, keep_open: bool = False, commit: bool = True,
                 parsing_model: Type[BaseModel] | BaseModel = None):
+        """Serializza il risultato e chiude la connessione se necessario.
+
+        Se ``keep_open=True`` (connessione esterna), restituisce il risultato
+        grezzo senza chiudere la connessione. Altrimenti esegue il commit (se
+        richiesto), serializza con il ``parsing_model`` e chiude la connessione.
+
+        Args:
+            connection (Connection): Connessione corrente.
+            result (CursorResult | RowMapping | Sequence): Righe risultanti
+                (tipicamente mapping ``{colonna: valore}``).
+            keep_open (bool): Se ``True``, non chiude la connessione e non serializza.
+            commit (bool): Se ``True`` e ``keep_open=False``, esegue il commit.
+            parsing_model (Type[BaseModel], optional): Modello Pydantic con cui
+                istanziare ogni riga (``parsing_model(**row)``). Se ``None``,
+                restituisce le righe grezze.
+
+        Returns:
+            list[BaseModel] | Sequence: Modelli serializzati o righe grezze.
+        """
         if keep_open:
             return result
         else:
@@ -60,15 +160,48 @@ class CrudMetadata:
         return result
 
     def create_table(self, name: str, columns: Iterable[Column], **kwargs):
+        """Crea una nuova tabella sul database.
+
+        Args:
+            name (str): Nome della tabella da creare.
+            columns (Iterable[Column]): Colonne che compongono la tabella.
+            **kwargs: Argomenti aggiuntivi passati al costruttore ``Table``
+                (es. ``schema``, vincoli, ``Index``).
+        """
         table = Table(name=name, metadata=self.metadata, *columns, **kwargs)
         table.create(self.engine)
 
     def drop_table(self, name: str):
+        """Elimina una tabella dal database e dal ``MetaData`` locale.
+
+        Args:
+            name (str): Nome della tabella da eliminare.
+        """
         table = self.get_table(name=name)
         table.drop(self.engine)
         self.metadata.remove(table=table)
 
     def find(self, from_table: str, connection: Connection = None, where: dict[str, Any] = None, columns: list[str] = None, limit: int = 0, parsing_model: Type[BaseModel] = None, **kwhere):
+        """Cerca le righe della tabella che corrispondono ai criteri specificati.
+
+        Args:
+            from_table (str): Nome della tabella su cui eseguire la ricerca.
+            connection (Connection, optional): Connessione esterna. Se ``None``,
+                ne viene aperta una nuova che viene chiusa al termine.
+            where (dict[str, Any], optional): Filtri come dizionario
+                ``{colonna: valore}``. Ha precedenza su ``**kwhere``.
+            columns (list[str], optional): Colonne da includere nel risultato.
+            limit (int): Numero massimo di righe. 0 = nessun limite. Default: 0.
+            parsing_model (Type[BaseModel], optional): Modello Pydantic per la
+                serializzazione delle righe.
+            **kwhere: Filtri aggiuntivi come keyword arguments.
+
+        Returns:
+            list[BaseModel] | Sequence[RowMapping]: Righe serializzate o mapping grezzi.
+
+        Example:
+            >>> meta.find(from_table="users", name="Mario", limit=10)
+        """
         keep_open = False if connection is None else True
         connection = self.open_connection if connection is None else connection
         table = self.get_table(name=from_table)
@@ -76,6 +209,20 @@ class CrudMetadata:
         return self._return(connection=connection, result=result, keep_open=keep_open, commit=False, parsing_model=parsing_model)
 
     def _find(self, table: Table, connection: Connection, where: dict[str, Any] = None, columns: list[str] = None, limit: int = 0, **kwhere):
+        """Costruisce ed esegue lo statement SELECT con filtri e limit.
+
+        Args:
+            table (Table): Tabella su cui eseguire la SELECT.
+            connection (Connection): Connessione corrente.
+            where (dict[str, Any], optional): Filtri ``{colonna: valore}``.
+                Se ``None``, usa ``**kwhere``.
+            columns (list[str], optional): Colonne da selezionare.
+            limit (int): Numero massimo di righe. Default: 0 (nessun limite).
+            **kwhere: Filtri aggiuntivi come keyword arguments.
+
+        Returns:
+            Sequence[RowMapping]: Righe risultanti come mapping.
+        """
         if where is None:
             where = kwhere if kwhere else {}
         stmt = self._select(table=table, columns=columns)
@@ -85,6 +232,30 @@ class CrudMetadata:
 
     def insert(self, from_table: str, connection: Connection = None, models: list[Type[BaseModel] | BaseModel] = None, values: list[dict[str, Any]] = None, returning: bool = True,
                parsing_model: Type[BaseModel] | BaseModel = None):
+        """Inserisce righe nella tabella a partire da modelli e/o dizionari di valori.
+
+        Le righe possono essere fornite come modelli Pydantic (``models``, da cui
+        si estraggono i valori con ``model_dump(exclude_none=True)``) e/o come
+        dizionari grezzi (``values``). Le due fonti vengono unite.
+
+        Args:
+            from_table (str): Nome della tabella su cui inserire.
+            connection (Connection, optional): Connessione esterna. Se ``None``,
+                ne viene aperta una nuova con commit automatico.
+            models (list[BaseModel], optional): Modelli Pydantic da inserire.
+            values (list[dict[str, Any]], optional): Righe come dizionari grezzi.
+            returning (bool): Se ``True``, usa ``RETURNING`` per recuperare le righe
+                inserite. Default: ``True``.
+            parsing_model (Type[BaseModel], optional): Modello per la serializzazione
+                del risultato.
+
+        Returns:
+            list[BaseModel] | Sequence[RowMapping]: Righe inserite (serializzate o grezze).
+
+        Note:
+            Se ``values`` è fornito, viene esteso in-place con i valori derivati
+            da ``models``.
+        """
         keep_open = False if connection is None else True
         connection = self.open_connection if connection is None else connection
         table = self.get_table(name=from_table)
@@ -94,6 +265,19 @@ class CrudMetadata:
         return self._return(connection=connection, result=result, keep_open=keep_open, commit=True, parsing_model=parsing_model)
 
     def _insert(self, table: Table, connection: Connection, values: list[dict[str, Any]] = None, returning: bool = True):
+        """Costruisce ed esegue lo statement INSERT con i valori forniti.
+
+        Args:
+            table (Table): Tabella su cui inserire.
+            connection (Connection): Connessione corrente.
+            values (list[dict[str, Any]], optional): Righe da inserire. Se vuoto,
+                non esegue nessuna operazione.
+            returning (bool): Se ``True``, usa ``RETURNING``. Default: ``True``.
+
+        Returns:
+            Sequence[RowMapping] | list: Righe inserite come mapping, o lista vuota
+                se non ci sono valori.
+        """
         if values:
             stmt = table.insert().values(values)
             stmt = stmt if not returning else stmt.returning()
@@ -102,6 +286,25 @@ class CrudMetadata:
             return []
 
     def update(self, from_table: str, connection: Connection = None, where: dict[str, Any] = None, returning: bool = True, parsing_model: Type[BaseModel] | BaseModel = None, **kwargs):
+        """Aggiorna le righe che soddisfano i criteri ``where`` con i valori in ``**kwargs``.
+
+        Args:
+            from_table (str): Nome della tabella da aggiornare.
+            connection (Connection, optional): Connessione esterna. Se ``None``,
+                ne viene aperta una nuova con commit automatico.
+            where (dict[str, Any], optional): Filtri per selezionare le righe da
+                aggiornare. Se ``None``, aggiorna tutte le righe (usare con cautela).
+            returning (bool): Se ``True``, usa ``RETURNING``. Default: ``True``.
+            parsing_model (Type[BaseModel], optional): Modello per la serializzazione
+                del risultato.
+            **kwargs: Valori da impostare sulle righe trovate.
+
+        Returns:
+            list[BaseModel] | Sequence[RowMapping]: Righe aggiornate (serializzate o grezze).
+
+        Example:
+            >>> meta.update(from_table="users", where={"id": 1}, name="Luigi")
+        """
         keep_open = False if connection is None else True
         connection = self.open_connection if connection is None else connection
         table = self.get_table(name=from_table)
@@ -109,6 +312,18 @@ class CrudMetadata:
         return self._return(connection=connection, result=result, keep_open=keep_open, commit=True, parsing_model=parsing_model)
 
     def _update(self, table: Table, connection: Connection, where: dict[str, Any] = None, returning: bool = True, **kwargs):
+        """Costruisce ed esegue lo statement UPDATE con filtri e valori.
+
+        Args:
+            table (Table): Tabella da aggiornare.
+            connection (Connection): Connessione corrente.
+            where (dict[str, Any], optional): Filtri per le righe da aggiornare.
+            returning (bool): Se ``True``, usa ``RETURNING``. Default: ``True``.
+            **kwargs: Valori da impostare sulle righe.
+
+        Returns:
+            Sequence[RowMapping]: Righe aggiornate come mapping.
+        """
         if where is None:
             where = {}
         stmt = table.update()
@@ -118,6 +333,22 @@ class CrudMetadata:
         return self.execute(connection=connection, stmt=stmt, mapping=True)
 
     def delete(self, from_table: str, connection: Connection = None, where: dict[str, Any] = None, **kwhere):
+        """Elimina le righe che soddisfano i criteri specificati.
+
+        Args:
+            from_table (str): Nome della tabella da cui eliminare.
+            connection (Connection, optional): Connessione esterna. Se fornita, il
+                commit non viene eseguito automaticamente.
+            where (dict[str, Any], optional): Filtri come dizionario.
+                Ha precedenza su ``**kwhere``.
+            **kwhere: Filtri come keyword arguments.
+
+        Returns:
+            int: Numero di righe eliminate.
+
+        Example:
+            >>> meta.delete(from_table="users", id=5)
+        """
         keep_open = False if connection is None else True
         connection = self.open_connection if connection is None else connection
         table = self.get_table(name=from_table)
@@ -130,6 +361,18 @@ class CrudMetadata:
         return num_rows
 
     def _delete(self, table: Table, connection: Connection, where: dict[str, Any] = None, **kwhere):
+        """Costruisce ed esegue lo statement DELETE con i filtri forniti.
+
+        Args:
+            table (Table): Tabella da cui eliminare.
+            connection (Connection): Connessione corrente.
+            where (dict[str, Any], optional): Filtri ``{colonna: valore}``.
+                Se ``None``, usa ``**kwhere``.
+            **kwhere: Filtri come keyword arguments.
+
+        Returns:
+            int: Numero di righe eliminate (``rowcount``).
+        """
         if where is None:
             where = kwhere if kwhere else {}
         stmt = table.delete()
@@ -139,6 +382,22 @@ class CrudMetadata:
     # --------------
 
     def execute(self, connection: Connection, stmt, mapping: bool = False):
+        """Esegue uno statement sulla connessione, gestendo le eccezioni.
+
+        Args:
+            connection (Connection): Connessione su cui eseguire lo statement.
+            stmt: Statement SQLAlchemy Core da eseguire.
+            mapping (bool): Se ``True``, restituisce le righe come mapping
+                (``result.mappings().all()``); altrimenti restituisce il
+                ``CursorResult`` grezzo. Default: ``False``.
+
+        Returns:
+            Sequence[RowMapping] | CursorResult: Righe come mapping se ``mapping=True``,
+                altrimenti il result grezzo.
+
+        Raises:
+            Exception: In caso di errore durante l'esecuzione (via ``_handle_exception``).
+        """
         try:
             result = connection.execute(stmt)
         except Exception as e:
@@ -149,6 +408,16 @@ class CrudMetadata:
             return result
 
     def _get_table(self, name: str):
+        """Recupera una tabella dal ``MetaData`` locale per nome.
+
+        Normalizza il nome anteponendo lo schema configurato, se necessario.
+
+        Args:
+            name (str): Nome della tabella (con o senza prefisso di schema).
+
+        Returns:
+            Table | None: La tabella se già presente nel ``MetaData``, altrimenti ``None``.
+        """
         if self.schema is not None:
             table_name = name if name.startswith(f"{self.schema}.") else f"{self.schema}.{name}"
         else:
@@ -156,15 +425,54 @@ class CrudMetadata:
         return self.metadata.tables.get(table_name)
 
     def get_table(self, name: str) -> Optional[Table]:
+        """Restituisce una tabella, riflettendola dal database se non già nota.
+
+        Cerca prima nel ``MetaData`` locale; se assente, tenta il caricamento
+        automatico (``autoload_with``) dal database.
+
+        Args:
+            name (str): Nome della tabella da recuperare.
+
+        Returns:
+            Optional[Table]: La tabella richiesta.
+
+        Raises:
+            InternalServerException: Se la tabella non esiste nel database.
+        """
         table = self._get_table(name=name)
         if table is None:
-            table = Table(name, self.metadata, schema=self.schema, autoload_with=self.engine)
+            try:
+                table = Table(name, self.metadata, schema=self.schema, autoload_with=self.engine)
+            except NoSuchTableError:
+                raise InternalServerException(f"No such table {name}")
         return table
 
     def has_table(self, name: str):
+        """Verifica se una tabella esiste nel database.
+
+        Args:
+            name (str): Nome della tabella da verificare.
+
+        Returns:
+            bool: ``True`` se la tabella esiste nello schema configurato.
+        """
         return self.engine_inspection.has_table(name, self.schema)
 
     def _add_limit_offset_condition(self, stmt, limit: int, page: int = None):
+        """Aggiunge le clausole LIMIT e OFFSET allo statement per la paginazione.
+
+        Non applica nessuna modifica se ``limit`` è 0 o negativo.
+        L'offset viene calcolato come ``(page - 1) * limit``.
+
+        Args:
+            stmt: Statement su cui applicare LIMIT/OFFSET.
+            limit (int): Numero massimo di righe. 0 = nessun limite.
+            page (int, optional): Numero di pagina (1-based). Se ``None`` o <= 0,
+                non viene applicato nessun offset.
+
+        Returns:
+            Statement con LIMIT e/o OFFSET applicati.
+        """
         if limit and limit > 0:
             stmt = stmt.limit(limit)
             if page and page > 0:
@@ -173,7 +481,22 @@ class CrudMetadata:
         return stmt
 
     def _eq_where(self, col: Column, condition, neq: bool = False):
+        """Costruisce la singola condizione WHERE per una colonna.
+
+        Logica applicata:
+        - ``list`` → ``col IN (values)``
+        - Tipo ``ARRAY`` → ``value = ANY(col)``
+        - Scalare → ``col == value``
+
+        Args:
+            col (Column): Colonna su cui applicare la condizione.
+            condition: Valore o lista di valori da confrontare.
+            neq (bool): Se ``True``, nega la condizione (``NOT``). Default: ``False``.
+
+        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_()
         if neq:
-            not_(eq_where)
+            eq_where = not_(eq_where)
         return eq_where

general/interface/metadata/geom_metadata.py

@@ -10,11 +10,57 @@ from .crud_metadata import CrudMetadata
 
 
 class GeomMetadata(CrudMetadata):
+    """Repository Core con operazioni spaziali PostGIS su tabelle riflesse.
+
+    Estende ``CrudMetadata`` (SQLAlchemy Core, senza ORM) aggiungendo query
+    geografiche di intersezione e contenimento via GeoAlchemy2. A differenza di
+    ``GeometryRepository``, la colonna geometrica e il suo SRID non sono fissati
+    sulla classe ma passati come argomenti a ciascun metodo, insieme al nome
+    della tabella.
+
+    Gestisce la riproiezione automatica tra SRID diversi e il buffering opzionale
+    della geometria di input.
+
+    Example:
+        >>> meta = GeomMetadata(engine=engine, schema_name="public")
+        >>> rows = meta.intersects(
+        ...     from_table="zones", geom=point,
+        ...     polygon_column_name="geom", polygon_column_srid=32632,
+        ... )
+    """
 
     def intersects(self, from_table: str, geom: WKBElement, polygon_column_name: str, polygon_column_srid: int, connection: Connection = None, tolerance: float = 0.0, columns: list[str] = None,
                    where: dict[str, Any] = None, not_where: dict[str, Any] = None, limit: int = 0, geom_srid: int = 4326, parsing_model: Type[BaseModel] | BaseModel = None, intersection: bool = False,
                    intersection_area: bool = False):
-
+        """Restituisce le righe la cui geometria interseca quella fornita.
+
+        Supporta buffer opzionale, filtri positivi e negativi, riproiezione
+        automatica e l'aggiunta facoltativa della geometria di intersezione e
+        della sua area.
+
+        Args:
+            from_table (str): Nome della tabella su cui eseguire la query.
+            geom (WKBElement): Geometria di riferimento per l'intersezione.
+            polygon_column_name (str): Nome della colonna geometrica della tabella.
+            polygon_column_srid (int): SRID della colonna geometrica.
+            connection (Connection, optional): Connessione esterna.
+            tolerance (float): Buffer applicato alla geometria prima dell'intersezione
+                (nelle unità del SRID della colonna). Default: 0.0 (nessun buffer).
+            columns (list[str], optional): Colonne da includere nel risultato.
+            where (dict[str, Any], optional): Filtri aggiuntivi positivi.
+            not_where (dict[str, Any], optional): Filtri aggiuntivi negativi.
+            limit (int): Numero massimo di righe. Default: 0 (nessun limite).
+            geom_srid (int): SRID della geometria fornita. Default: 4326.
+            parsing_model (Type[BaseModel], optional): Modello per la serializzazione.
+            intersection (bool): Se ``True``, aggiunge la colonna ``intersection``
+                con la geometria di intersezione. Default: ``False``.
+            intersection_area (bool): Se ``True``, aggiunge la colonna
+                ``intersection_area`` con l'area dell'intersezione (riproiettata in
+                EPSG:3857). Default: ``False``.
+
+        Returns:
+            list[BaseModel] | Sequence[RowMapping]: Righe che intersecano la geometria.
+        """
         keep_open = False if connection is None else True
         connection = self.open_connection if connection is None else connection
         table = self.get_table(name=from_table)
@@ -25,6 +71,26 @@ class GeomMetadata(CrudMetadata):
 
     def _intersects(self, table: Table, geom: WKBElement, polygon_column: Column, polygon_column_srid: int, connection: Connection = None, tolerance: float = 0.0, columns: list[str] = None, where: dict[str, Any] = None,
                     not_where: dict[str, Any] = None, limit: int = 0, geom_srid: int = 4326, intersection: bool = False, intersection_area: bool = False):
+        """Costruisce ed esegue lo statement di intersezione spaziale.
+
+        Args:
+            table (Table): Tabella su cui eseguire la query.
+            geom (WKBElement): Geometria di riferimento.
+            polygon_column (Column): Colonna geometrica della tabella.
+            polygon_column_srid (int): SRID della colonna geometrica.
+            connection (Connection, optional): Connessione corrente.
+            tolerance (float): Buffer applicato alla geometria. Default: 0.0.
+            columns (list[str], optional): Colonne da selezionare.
+            where (dict[str, Any], optional): Filtri positivi.
+            not_where (dict[str, Any], optional): Filtri negativi.
+            limit (int): Numero massimo di righe. Default: 0.
+            geom_srid (int): SRID della geometria fornita. Default: 4326.
+            intersection (bool): Se ``True``, aggiunge la geometria di intersezione.
+            intersection_area (bool): Se ``True``, aggiunge l'area dell'intersezione.
+
+        Returns:
+            Sequence[RowMapping]: Righe risultanti come mapping.
+        """
         if where is None:
             where = {}
         if not_where is None:
@@ -53,7 +119,30 @@ class GeomMetadata(CrudMetadata):
 
     def contains(self, from_table: str, geom: WKBElement, polygon_column_name: str, polygon_column_srid: int, connection: Connection = None, tolerance: float = 0.0, columns: list[str] = None,
                  where: dict[str, Any] = None, limit: int = 0, contained: bool = False, geom_srid: int = 4326, parsing_model: Type[BaseModel] | BaseModel = None):
-
+        """Restituisce le righe che contengono (o sono contenute in) una geometria.
+
+        Il parametro ``contained`` inverte la direzione del contenimento:
+        - ``False`` (default): righe la cui geometria **contiene** ``geom``.
+        - ``True``: righe la cui geometria è **contenuta in** ``geom``.
+
+        Args:
+            from_table (str): Nome della tabella su cui eseguire la query.
+            geom (WKBElement): Geometria di riferimento.
+            polygon_column_name (str): Nome della colonna geometrica della tabella.
+            polygon_column_srid (int): SRID della colonna geometrica.
+            connection (Connection, optional): Connessione esterna.
+            tolerance (float): Buffer applicato alla geometria. Default: 0.0.
+            columns (list[str], optional): Colonne da includere nel risultato.
+            where (dict[str, Any], optional): Filtri aggiuntivi.
+            limit (int): Numero massimo di righe. Default: 0.
+            contained (bool): Se ``True``, inverte la direzione del contenimento.
+                Default: ``False``.
+            geom_srid (int): SRID della geometria fornita. Default: 4326.
+            parsing_model (Type[BaseModel], optional): Modello per la serializzazione.
+
+        Returns:
+            list[BaseModel] | Sequence[RowMapping]: Righe che soddisfano il contenimento.
+        """
         keep_open = False if connection is None else True
         connection = self.open_connection if connection is None else connection
         table = self.get_table(name=from_table)
@@ -64,6 +153,24 @@ class GeomMetadata(CrudMetadata):
 
     def _contains(self, table: Table, geom: WKBElement, polygon_column: Column, polygon_column_srid: int, connection: Connection = None, tolerance: float = 0.0, columns: list[str] = None, where: dict[str, Any] = None,
                   limit: int = 0, contained: bool = False, geom_srid: int = 4326):
+        """Costruisce ed esegue lo statement di contenimento spaziale.
+
+        Args:
+            table (Table): Tabella su cui eseguire la query.
+            geom (WKBElement): Geometria di riferimento.
+            polygon_column (Column): Colonna geometrica della tabella.
+            polygon_column_srid (int): SRID della colonna geometrica.
+            connection (Connection, optional): Connessione corrente.
+            tolerance (float): Buffer applicato alla geometria. Default: 0.0.
+            columns (list[str], optional): Colonne da selezionare.
+            where (dict[str, Any], optional): Filtri aggiuntivi.
+            limit (int): Numero massimo di righe. Default: 0.
+            contained (bool): Se ``True``, inverte la direzione del contenimento.
+            geom_srid (int): SRID della geometria fornita. Default: 4326.
+
+        Returns:
+            Sequence[RowMapping]: Righe risultanti come mapping.
+        """
         if columns is None:
             columns = []
         if where is None:
@@ -82,6 +189,22 @@ class GeomMetadata(CrudMetadata):
         return self.execute(connection=connection, stmt=stmt, mapping=True)
 
     def _geom_condition(self, geom: WKBElement, polygon_column_srid: int = 4326, geom_srid: int = 4326, buffer: float = 0):
+        """Prepara la geometria per le query applicando riproiezione e buffer.
+
+        Se l'SRID della geometria fornita differisce da quello della colonna,
+        applica ``ST_Transform``. Se è specificato un buffer > 0, applica
+        ``ST_Buffer`` dopo la riproiezione.
+
+        Args:
+            geom (WKBElement): Geometria di input.
+            polygon_column_srid (int): SRID della colonna geometrica. Default: 4326.
+            geom_srid (int): SRID della geometria di input. Default: 4326.
+            buffer (float): Distanza del buffer (nelle unità del SRID della colonna).
+                0 = nessun buffer. Default: 0.
+
+        Returns:
+            WKBElement: Geometria pronta per l'uso nelle condizioni PostGIS.
+        """
         geom_condition = geom.ST_Transform(polygon_column_srid) if geom_srid != polygon_column_srid else geom
         geom_condition = geom_condition.ST_Buffer(buffer) if buffer else geom_condition
 

general/interface/repository/crud_repository.py

@@ -5,7 +5,7 @@ import math
 from typing import Any, Type, Sequence, Iterable, Optional, Mapping
 
 from pydantic import BaseModel
-from sqlalchemy import select, delete, update, insert, Row, RowMapping, ColumnElement, Select, Insert, Update, Delete
+from sqlalchemy import select, delete, update, insert, tuple_, Row, RowMapping, ColumnElement, Select, Insert, Update, Delete
 from sqlalchemy.engine.base import Engine
 from sqlalchemy.exc import DataError, IntegrityError, NoResultFound, OperationalError
 from sqlalchemy.inspection import inspect
@@ -126,6 +126,26 @@ class CrudRepository[Entity: Base | Type[Base]]:
         except Exception as e:
             self._handle_exception(session, e)
 
+    def _flush(self, session: Session):
+        """Esegue il flush sulla sessione, gestendo eventuali eccezioni.
+
+        Invia al database le modifiche pendenti (INSERT/UPDATE) senza chiudere
+        la transazione, popolando i valori generati lato server (es. chiavi
+        primarie autoincrement e default). A differenza del commit, non scade
+        (expire) le istanze ORM: gli attributi restano leggibili in memoria.
+
+        Args:
+            session (Session): Sessione su cui eseguire il flush.
+
+        Raises:
+            ServiceUnavailableException | BadRequestException: In caso di errore
+                durante il flush.
+        """
+        try:
+            session.flush()
+        except Exception as e:
+            self._handle_exception(session, e)
+
     def _entity_has_columns(self, *columns: Iterable[str], entity: Type[Base] | Base = None):
         """Verifica che tutte le colonne specificate esistano sull'entità.
 
@@ -175,14 +195,21 @@ class CrudRepository[Entity: Base | Type[Base]]:
         """Serializza le entità e chiude la sessione se necessario.
 
         Se ``keep_open=True`` (sessione esterna), restituisce le entità grezze
-        senza chiudere la sessione. Altrimenti esegue il commit (se richiesto),
-        serializza con ``model_validate`` e chiude la sessione.
+        senza chiudere la sessione. Altrimenti, quando ``commit=True``, esegue
+        prima un ``flush`` (per popolare i valori generati lato server),
+        serializza con ``model_validate`` e solo dopo esegue il ``commit``.
+
+        L'ordine flush → serializzazione → commit evita le query N+1 di reload:
+        il commit con ``expire_on_commit`` di default scadrebbe le istanze ORM,
+        forzando un SELECT per ogni entità al successivo accesso degli attributi.
+        Serializzando prima del commit gli attributi sono letti dallo stato già
+        popolato in memoria.
 
         Args:
             session (Session): Sessione corrente.
             entities (Sequence): Entità SQLAlchemy da serializzare.
             keep_open (bool): Se ``True``, non chiude la sessione e non serializza.
-            commit (bool): Se ``True`` e ``keep_open=False``, esegue il commit.
+            commit (bool): Se ``True`` e ``keep_open=False``, esegue flush + commit.
             parsing_model (Type[BaseModel], optional): Modello alternativo per la
                 serializzazione. Se ``None``, usa ``self.model``.
 
@@ -192,10 +219,12 @@ class CrudRepository[Entity: Base | Type[Base]]:
         if keep_open:
             return entities
         else:
-            if commit:
-                self.commit(session=session)
             return_model = parsing_model or self.model
+            if commit:
+                self._flush(session=session)
             models = [return_model.model_validate(entity) for entity in entities]
+            if commit:
+                self.commit(session=session)
             session.close()
         return models
 
@@ -441,25 +470,58 @@ class CrudRepository[Entity: Base | Type[Base]]:
     def _upsert(self, session: Session, models: list[Type[BaseModel] | BaseModel] = None):
         if models is None:
             models = []
-        updates = {}
-        for i, model in enumerate(models):
-            pks = {pk.name: getattr(model, pk.name) for pk in self.entity.primary_key()}
-            if any([not value for value in pks.values()]):
-                continue
+
+        pk_columns = self.entity.primary_key()
+
+        # Chiave primaria (eventualmente composta) di ogni modello, oppure None
+        # se non tutte le colonne PK sono valorizzate (→ candidato all'insert).
+        model_keys = [self._pk_key(model, pk_columns) for model in models]
+
+        # Un'unica query per recuperare tutte le entità esistenti che corrispondono
+        # alle PK candidate, indicizzate per chiave PK in una mappa in memoria.
+        candidate_keys = [key for key in model_keys if key is not None]
+        existing: dict[tuple, Base] = {}
+        if candidate_keys:
+            stmt = select(self.entity).where(tuple_(*pk_columns).in_(candidate_keys))
+            for entity in self.execute(session=session, stmt=stmt):
+                existing[self._pk_key(entity, pk_columns)] = entity
+
+        # Ripartizione insert/update in base alla presenza nella mappa.
+        inserts = []
+        to_update = []
+        for model, key in zip(models, model_keys):
+            entity = existing.get(key) if key is not None else None
+            if entity is not None:
+                to_update.append((entity, model))
             else:
-                updates[i] = session.get(self.entity, pks)
-        inserts = [models[i] for i in range(len(models)) if i not in updates.keys()]
+                inserts.append(model)
 
         result = self._insert(session=session, models=inserts)
-        for i, entity in updates.items():
-            if entity:
-                for attr, value in models[i].model_dump(exclude_none=True).items():
-                    setattr(entity, attr, value)
-
-        result.extend(updates.values())
+        for entity, model in to_update:
+            for attr, value in model.model_dump(exclude_none=True).items():
+                setattr(entity, attr, value)
+            result.append(entity)
 
         return result
 
+    def _pk_key(self, obj: Type[BaseModel] | BaseModel | Base, pk_columns) -> tuple | None:
+        """Estrae la chiave primaria (eventualmente composta) da un modello o entità.
+
+        Legge i valori delle colonne PK in ordine e li restituisce come tupla,
+        usabile come chiave di mappa e per il filtro ``tuple_(...).in_(...)``.
+
+        Args:
+            obj: Modello Pydantic o entità ORM da cui leggere la PK.
+            pk_columns: Colonne che compongono la chiave primaria
+                (tipicamente ``self.entity.primary_key()``).
+
+        Returns:
+            tuple | None: Tupla dei valori PK in ordine di colonna, oppure ``None``
+                se almeno un valore non è valorizzato (PK incompleta).
+        """
+        values = tuple(getattr(obj, column.name, None) for column in pk_columns)
+        return values if all(values) else None
+
     def count(self, session: Session = None, where: dict[str, Any] = None, **kwhere):
         """Conta i record che soddisfano i criteri specificati.
 
@@ -491,8 +553,7 @@ class CrudRepository[Entity: Base | Type[Base]]:
             where = kwhere if kwhere else {}
         stmt = select(count(pk))
         stmt = self.stmt_manager.prepare_statement(stmt=stmt, **where)
-        result = session.execute(stmt).all()[0]
-        return result[0]
+        return session.execute(stmt).scalar()
 
     def _preconf_count(self, session: Session, where: Optional[ColumnElement[Any]]):
         """Conta i record usando una clausola WHERE già costruita (ColumnElement).
@@ -509,9 +570,9 @@ class CrudRepository[Entity: Base | Type[Base]]:
         """
         pk = self.entity.primary_key()[0]
         stmt = select(count(pk))
-        stmt = stmt.where(where)
-        result = session.execute(stmt).all()[0]
-        return result[0]
+        if where is not None:
+            stmt = stmt.where(where)
+        return session.execute(stmt).scalar()
 
     def paging_find(self, session: Session = None, where: dict[str, Any] = None, columns: list[str] = None, exclude_columns: list[str] = None, limit: int = 0, page: int = 1, order_by: str = None, asc: bool = True,
                     parsing_model: Type[BaseModel] = None, **kwhere) -> PaginatorResponseModel[Entity]:

general/interface/repository/geometry_repository.py

@@ -4,7 +4,7 @@ from typing import Any, Type
 
 from geoalchemy2 import WKBElement, Geometry
 from pydantic import BaseModel
-from sqlalchemy import literal_column, Column
+from sqlalchemy import Column
 from sqlalchemy.orm import Session
 
 from .crud_repository import CrudRepository
@@ -47,15 +47,17 @@ class GeometryRepository[Entity: Base | Type[Base]](CrudRepository[Entity]):
                    limit: int = 0, geom_srid: int = 4326, parsing_model: Type[BaseModel] | BaseModel = None) -> list[Entity]:
         """Restituisce le entità la cui geometria interseca quella fornita.
 
-        Supporta buffer opzionale, filtri aggiuntivi positivi e negativi,
-        e riproiezione automatica se l'SRID della geometria differisce da
-        quello della colonna.
+        Supporta una tolleranza di distanza opzionale, filtri aggiuntivi positivi
+        e negativi, e riproiezione automatica se l'SRID della geometria differisce
+        da quello della colonna.
 
         Args:
             geom (WKBElement): Geometria di riferimento per l'intersezione.
             session (Session, optional): Sessione esterna.
-            tolerance (float): Buffer applicato alla geometria prima dell'intersezione
-                (nelle unità del SRID della colonna). Default: 0.0 (nessun buffer).
+            tolerance (float): Distanza massima entro cui considerare le geometrie
+                "intersecanti" (nelle unità del SRID della colonna). Se > 0 usa
+                ``ST_DWithin`` (servibile dall'indice spaziale GiST); se 0.0 usa
+                ``ST_Intersects``. Default: 0.0.
             columns (list[str], optional): Colonne da includere nel risultato.
             exclude_columns (list[str], optional): Colonne da escludere.
             where (dict[str, Any], optional): Filtri aggiuntivi positivi.
@@ -85,12 +87,13 @@ class GeometryRepository[Entity: Base | Type[Base]](CrudRepository[Entity]):
 
         stmt = self._select(entity=self.entity, columns=columns, exclude_columns=exclude_columns)
 
-        intersecting_geom = self._geom_condition(geom=geom, geom_srid=geom_srid, buffer=tolerance)
+        intersecting_geom = self._geom_condition(geom=geom, geom_srid=geom_srid)
 
         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))
+        geom_condition = self.geom_column.ST_DWithin(intersecting_geom, tolerance) if tolerance else self.geom_column.ST_Intersects(intersecting_geom)
+        stmt = stmt.where(geom_condition)
         stmt = self.stmt_manager.limit_offset_condition(stmt=stmt, limit=limit)
 
         return self.execute(session, stmt)
@@ -147,11 +150,14 @@ 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,
-                parsing_model: Type[BaseModel] | BaseModel = None) -> list[Entity]:
+                distance: bool = True, 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``, e ordina i risultati in modo crescente.
+        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.
 
         Args:
             geom (WKBElement): Geometria di riferimento per il calcolo della distanza.
@@ -161,6 +167,10 @@ class GeometryRepository[Entity: Base | Type[Base]](CrudRepository[Entity]):
             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:
@@ -171,7 +181,7 @@ class GeometryRepository[Entity: Base | Type[Base]](CrudRepository[Entity]):
         """
         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)
+        entities = self._nearest(session=session, geom=geom, where=where, columns=columns, exclude_columns=exclude_columns, limit=limit, geom_srid=geom_srid, distance=distance)
         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):
@@ -181,13 +191,11 @@ class GeometryRepository[Entity: Base | Type[Base]](CrudRepository[Entity]):
 
         geom_condition = self._geom_condition(geom=geom, geom_srid=geom_srid)
 
-        distance_col = self.geom_column.ST_Distance(geom_condition).label("distance")
-
         if distance:
-            stmt = stmt.add_columns(distance_col)
+            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(literal_column("distance"))
+        stmt = stmt.order_by(self.geom_column.distance_centroid(geom_condition))
         stmt = self.stmt_manager.limit_offset_condition(stmt=stmt, limit=limit)
 
         rows = self.execute(session, stmt)

general/interface/repository/handler/base_handler.py

@@ -14,17 +14,23 @@ class BaseHandler:
 
     Attributes:
         columns (ReadOnlyColumnCollection): Colonne della tabella su cui operare.
+        array_columns (set[str]): Nomi delle colonne di tipo ``ARRAY``, pre-calcolati
+            in fase di inizializzazione.
     """
-    __slots__ = "columns"
+    __slots__ = "columns", "array_columns"
 
     def __init__(self, columns: ReadOnlyColumnCollection[str, Column[Any]]):
         """Inizializza l'handler con la collezione di colonne dell'entità.
 
+        Pre-calcola una volta l'insieme dei nomi delle colonne di tipo ``ARRAY``,
+        evitando il confronto ``str(column.type)`` ad ogni filtro in ``_handle``.
+
         Args:
             columns (ReadOnlyColumnCollection): Colonne della tabella, tipicamente
                 ottenute da ``Entity.__table__.c``.
         """
         self.columns = columns
+        self.array_columns = {column.name for column in columns if str(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``.
@@ -62,7 +68,12 @@ class BaseHandler:
         Returns:
             ColumnElement: Espressione booleana SQLAlchemy.
         """
-        eq_where = column.in_(condition) if isinstance(condition, list) else column == condition if str(column.type) != "ARRAY" else condition == column.any_()
+        if isinstance(condition, list):
+            eq_where = column.in_(condition)
+        elif column.name in self.array_columns:
+            eq_where = condition == column.any_()
+        else:
+            eq_where = column == condition
         if neq:
             eq_where = not_(eq_where)
         return eq_where

{python_general_be_lib-0.5.4.dist-info → python_general_be_lib-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-general-be-lib
-Version: 0.5.4
+Version: 0.6.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.5.4.dist-info → python_general_be_lib-0.6.0.dist-info}/RECORD

@@ -10,22 +10,22 @@ general/interface/base/__init__.py,sha256=SDlTi28M8rzJ9yiKefo5l7V3K109LnnBHW-SuZ
 general/interface/base/base_model.py,sha256=SVrYl1kSAj37yCScfO3Qe6ELyLxou65njpvbYmjTG00,2215
 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=z1fTh77K7fkhDgNus5Xrv4EYerbdlPVl4F1NLbSxqcM,8478
-general/interface/metadata/geom_metadata.py,sha256=CZPzlqos5XuDWn_FeKLxxYqOuGx1Bg9C0xH5-ZR0vXw,5326
+general/interface/metadata/crud_metadata.py,sha256=HcnJkr33buIg8n8aWaH1Tw8QcmlyP_2Gyd1RcWCMtiE,22422
+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=wFO_OhyDDh_KxzQbO0QjACLacF83SMdbsOD2MJa6510,29210
-general/interface/repository/geometry_repository.py,sha256=bJVPhsr-fGhVTywdHwx9Qt_inWPHk5wqq9EFWFLfuGU,11181
+general/interface/repository/crud_repository.py,sha256=kPuP_Jrguw9C_5dtn80NAVZ26gDcJnAZrOhwygWoD6Y,32095
+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=Sm591FUP0iBYlI-ULNWszD5fOvTGwXX0iYoeDbUqo34,5397
 general/interface/repository/handler/__init__.py,sha256=J-fc-5Dl_C821oy_EVRdyU-L2iXiNFriYJDbK4ODIMM,184
-general/interface/repository/handler/base_handler.py,sha256=YEdE-S1JnLMo0LZn_9rHjEUgDNEM-qjcbNZ_rhsBnpg,2800
+general/interface/repository/handler/base_handler.py,sha256=hJkvXyVqnE2USmVWAko0Lnu02-537t4PERmBETJhXB0,3285
 general/interface/repository/handler/ilike_handler.py,sha256=_HHTvj6Tm1L-WvUy1S9faRChoRZni11i9mv76I4Xak0,3919
 general/interface/repository/handler/interval_handler.py,sha256=XxMQr6UuWnoCtbOOO7l80_Yja_aPKYtHhDfhFCRMaKg,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/statement_manager.py,sha256=sGDMU4fPkF0_9-SbDmAw8Vpel1Z7eImBs8fHO-5Lr_0,4429
-python_general_be_lib-0.5.4.dist-info/licenses/LICENSE,sha256=iUaO1XZyB9P3Tmog0OILuTisP6vXGe3QKz-4yRTxOFk,1069
-python_general_be_lib-0.5.4.dist-info/METADATA,sha256=oOe-yd6hkXQ1wumjhGiEO90OI7bRcZRJw0UlamThdaU,1384
-python_general_be_lib-0.5.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-python_general_be_lib-0.5.4.dist-info/top_level.txt,sha256=tTZePW8_CNUqSgKFd2SEH72ZbnhS0OYjRsgcv0ikSFY,8
-python_general_be_lib-0.5.4.dist-info/RECORD,,
+python_general_be_lib-0.6.0.dist-info/licenses/LICENSE,sha256=iUaO1XZyB9P3Tmog0OILuTisP6vXGe3QKz-4yRTxOFk,1069
+python_general_be_lib-0.6.0.dist-info/METADATA,sha256=QKlhIJ_5M8jBwSxHTM7uorYD5q2VUTdAs43l6BSUQaM,1384
+python_general_be_lib-0.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+python_general_be_lib-0.6.0.dist-info/top_level.txt,sha256=tTZePW8_CNUqSgKFd2SEH72ZbnhS0OYjRsgcv0ikSFY,8
+python_general_be_lib-0.6.0.dist-info/RECORD,,