python-general-be-lib 0.9.1__py3-none-any.whl → 0.10.0__py3-none-any.whl

general/context.py

@@ -0,0 +1,31 @@
+"""Context of the operation in progress.
+
+Values the library **reads** and the consumer sets, kept in ``ContextVar`` objects rather
+than in globals: the value is per task, so concurrent requests served by the same process
+do not overwrite each other.
+
+The module imports nothing from the library and nothing from SQLAlchemy, so a middleware
+can set the context without paying for the data access layer.
+"""
+
+__all__ = ["current_user"]
+
+from contextvars import ContextVar
+from typing import Optional
+
+current_user: ContextVar[Optional[str]] = ContextVar("current_user", default=None)
+"""Identifier of the user the current operation is attributed to.
+
+Read by ``AuditMixin`` to fill ``create_uid``/``write_uid``. Setting it is up to the
+consumer, typically in the authentication middleware::
+
+    from general.context import current_user
+
+    @app.middleware("http")
+    async def track_user(request, call_next):
+        current_user.set(request.state.user_id)
+        return await call_next(request)
+
+Left unset it holds ``None``, which is what ends up in the columns for the operations
+having no user behind them: scheduled jobs, migrations, a console session.
+"""

general/exception/__init__.py

@@ -2,9 +2,11 @@
 
 They all extend ``ExceptionInterface``, which in turn extends
 ``fastapi.HTTPException``: raised inside an endpoint they are automatically
-serialized into the response with their own status code. The mapping applied by
-``CrudRepository._handle_exception`` to the SQLAlchemy errors is documented in
-``crud_exceptions``.
+serialized into the response with their own status code.
+
+``raise_http_exception`` is the mapping the data access layers apply to the SQLAlchemy
+errors, shared by ``CrudRepository`` and ``CrudMetadata`` so that the same error gets the
+same status on both.
 """
 
 from .access_exceptions import *
@@ -12,6 +14,7 @@ from .crud_exceptions import *
 from .exception_interface import *
 
 __all__ = [
+    "raise_http_exception",
     "ExceptionInterface",
     "BadRequestException",
     "EntityNotFoundException",

general/exception/crud_exceptions.py

@@ -1,12 +1,14 @@
 """HTTP exceptions for the persistence operations.
 
-These are the exceptions ``CrudRepository._handle_exception`` maps the SQLAlchemy
-errors onto: ``OperationalError`` to ``ServiceUnavailableException`` (503),
-``NoResultFound`` to ``EntityNotFoundException`` (404), ``DataError`` and
-``IntegrityError`` to ``BadRequestException`` (400).
+These are the exceptions the data access layers map the SQLAlchemy errors onto:
+``OperationalError`` to ``ServiceUnavailableException`` (503), ``NoResultFound`` to
+``EntityNotFoundException`` (404), ``DataError`` and ``IntegrityError`` to
+``BadRequestException`` (400). The mapping itself lives in ``raise_http_exception``, so
+that ``CrudRepository`` and ``CrudMetadata`` share one table instead of two copies.
 """
 
 __all__ = [
+    "raise_http_exception",
     "BadRequestException",
     "EntityNotFoundException",
     "ServiceUnavailableException",
@@ -15,6 +17,8 @@ __all__ = [
     "InternalServerException",
 ]
 
+from sqlalchemy.exc import DataError, IntegrityError, NoResultFound, OperationalError
+
 from .exception_interface import ExceptionInterface
 
 
@@ -87,3 +91,32 @@ class InternalServerException(ExceptionInterface):
     """
     status_code = 500
     default_message = "Impossibile gestire la richiesta al momento"
+
+
+def raise_http_exception(e: Exception):
+    """Re-raise a SQLAlchemy error as the matching HTTP exception.
+
+    Translates the error families the data access layers can attribute to a specific
+    HTTP status: anything else is re-raised unchanged, because guessing a status for an
+    unknown error hides the cause. In particular a ``ProgrammingError`` — a malformed
+    statement or a missing relation — stays as it is and surfaces as a 500, which is the
+    honest answer for a defect that is not the client's fault.
+
+    Args:
+        e (Exception): Caught exception.
+
+    Raises:
+        ServiceUnavailableException: On ``OperationalError``, database unreachable.
+        EntityNotFoundException: On ``NoResultFound``.
+        BadRequestException: On ``DataError`` or ``IntegrityError``.
+        Exception: The original exception, for every other type.
+    """
+    match e:
+        case OperationalError():
+            raise ServiceUnavailableException()
+        case NoResultFound():
+            raise EntityNotFoundException()
+        case DataError() | IntegrityError():
+            raise BadRequestException()
+        case _:
+            raise e

general/interface/base/declarative_base.py

@@ -132,10 +132,23 @@ def _attributes_names(entity: type) -> tuple[str, ...]:
 
 
 def retrieve_mapper_entity(entity_name: str):
-    """Look up a subclass of ``Base`` by class name.
+    """Look up a mapped class by class name.
 
-    Iterates over ``Base.__subclasses__()``, so it only finds the **direct** subclasses
-    of ``Base`` and not the ones nested in further inheritance levels.
+    Scans ``Base.registry.mappers``, which holds every mapped class of the registry
+    regardless of how deep in the inheritance it sits: an entity behind an abstract
+    intermediate base, or one in single table inheritance, is found as well. Iterating
+    ``Base.__subclasses__()`` instead — as this did — only reaches the **direct**
+    subclasses, and left those two invisible.
+
+    Reading the collection does **not** trigger ``configure_mappers()``, so the lookup
+    stays usable while the entities referenced by name in a ``relationship`` are still
+    being imported.
+
+    The class name is not unique within a registry: two entities declared in different
+    packages can share it, and since the collection of mappers is a ``frozenset`` the one
+    returned would then depend on the iteration order. Reaching every level of the
+    inheritance made the case more likely, not less — before, the classes nested deeper
+    were invisible. A duplicate name is a project-level problem this function cannot solve.
 
     Args:
         entity_name (str): Name of the ORM class to look for, such as ``"User"``.
@@ -143,23 +156,33 @@ def retrieve_mapper_entity(entity_name: str):
     Returns:
         Type[Base] | None: The matching ORM class, or ``None`` when not found.
     """
-    for mapper in Base.__subclasses__():
-        if mapper.__name__ == entity_name:
-            return mapper
+    for mapper in Base.registry.mappers:
+        if mapper.class_.__name__ == entity_name:
+            return mapper.class_
+    return None
 
 
 def retrieve_mapper_from_table(table_name: str):
-    """Look up a subclass of ``Base`` by table name.
+    """Look up a mapped class by table name.
 
-    Iterates over ``Base.__subclasses__()``, so it only finds the **direct** subclasses
-    of ``Base`` and not the ones nested in further inheritance levels.
+    Scans ``Base.registry.mappers`` like ``retrieve_mapper_entity``, and returns the
+    **root of the hierarchy** for the table. The distinction matters under single table
+    inheritance, where several classes share one table and would all match: the root is
+    the deterministic answer, and the collection of mappers is a ``frozenset``, so
+    returning the first match found would depend on the iteration order.
+
+    Only mapped classes are in the registry, so an abstract intermediate base is excluded
+    by construction. Scanning ``Base.__subclasses__()`` instead — as this did — reached
+    those bases, and since they declare no ``__tablename__`` a single ``__abstract__``
+    class in the project raised ``AttributeError`` on **every** lookup.
 
     Args:
         table_name (str): Name of the table in the database, such as ``"users"``.
 
     Returns:
-        Type[Base] | None: The matching ORM class, or ``None`` when not found.
+        Type[Base] | None: The class the table is mapped on, or ``None`` when not found.
     """
-    for mapper in Base.__subclasses__():
-        if mapper.__tablename__ == table_name:
-            return mapper
+    for mapper in Base.registry.mappers:
+        if mapper.local_table is not None and mapper.local_table.name == table_name:
+            return mapper.base_mapper.class_
+    return None

general/interface/metadata/crud_metadata.py

@@ -4,10 +4,14 @@ import logging
 from typing import Optional, Any, Type, Iterable, Sequence
 
 from pydantic import BaseModel
-from sqlalchemy import MetaData, Engine, Column, Table, inspect, Connection, select, RowMapping, CursorResult, not_, ARRAY, type_coerce
+from sqlalchemy import MetaData, Engine, Column, Table, inspect, Connection, select, RowMapping, CursorResult
 from sqlalchemy.exc import NoSuchTableError
+from sqlalchemy.sql.functions import count
 
-from ...exception.crud_exceptions import HasNoAttributeException, InternalServerException
+from ...exception.crud_exceptions import HasNoAttributeException, InternalServerException, raise_http_exception
+from ...interface.repository.handler.base_handler import BaseHandler
+from ...interface.repository.handler.statement_manager import StatementManager
+from ...paginator_dto import PaginatorResponseModel, parse_pagination
 
 
 class CrudMetadata:
@@ -20,12 +24,13 @@ class CrudMetadata:
     (``keep_open=True``) the raw results are returned with no commit and no close,
     otherwise the connection is opened, committed and closed internally.
 
-    Three things set it apart from ``CrudRepository``: it does not use the handler
-    pipeline, the filters going straight through ``_eq_where``, so there is no support
-    for JSON, ILIKE, intervals or aliases; the SQLAlchemy exceptions are logged and
-    re-raised as they are instead of being mapped onto HTTP exceptions; and the
-    serialization happens through ``parsing_model(**row)`` on the row mappings rather
-    than through ``model_validate`` on ORM entities.
+    The filters go through the same handler pipeline as ``CrudRepository``, built per
+    table from the columns of the reflected ``Table``: the ``BaseHandler`` alone by
+    default, plus whatever ``register_handlers`` adds for that table. The SQLAlchemy
+    exceptions are mapped onto HTTP exceptions with the same table, through
+    ``raise_http_exception``. What still sets this layer apart is the serialization, which
+    happens through ``parsing_model(**row)`` on the row mappings rather than through
+    ``model_validate`` on ORM entities.
 
     Attributes:
         schema (str | None): Name of the default schema of the tables.
@@ -33,8 +38,10 @@ class CrudMetadata:
         engine (Engine): SQLAlchemy Engine instance connected to the database.
         engine_inspection (Inspector): Inspector used for the introspections, such as
             the presence of a table.
+        statement_managers (dict[str, StatementManager]): Handler pipeline per table
+            name, built on first use and replaced by ``register_handlers``.
     """
-    __slots__ = "schema", "metadata", "engine", "engine_inspection"
+    __slots__ = "schema", "metadata", "engine", "engine_inspection", "statement_managers"
 
     @property
     def open_connection(self):
@@ -60,6 +67,7 @@ class CrudMetadata:
         self.metadata = MetaData(schema_name) if schema_name else MetaData()
         self.engine = engine
         self.engine_inspection = inspect(self.engine)
+        self.statement_managers = {}
         if reflect:
             self.metadata.reflect(bind=self.engine, schema=schema_name)
 
@@ -68,6 +76,13 @@ class CrudMetadata:
     def _handle_exception(self, connection: Connection, e: Exception, to_raise: bool = True):
         """Close the connection, log the error and re-raise it when required.
 
+        The mapping is the same one ``CrudRepository`` applies, through the shared
+        ``raise_http_exception``: an ``OperationalError`` becomes a 503, a
+        ``NoResultFound`` a 404, a ``DataError`` or an ``IntegrityError`` a 400, and any
+        other error is re-raised unchanged. Until this layer re-raised every SQLAlchemy
+        error as it was, so a constraint violation on a reflected table reached the client
+        as an unhandled 500 instead of the 400 the ORM layer returns for the same error.
+
         Args:
             connection (Connection): Connection to close.
             e (Exception): Caught exception.
@@ -75,12 +90,15 @@ class CrudMetadata:
                 Default: ``True``.
 
         Raises:
-            Exception: The original exception, when ``to_raise=True``.
+            ServiceUnavailableException: On ``OperationalError``, database unreachable.
+            EntityNotFoundException: On ``NoResultFound``.
+            BadRequestException: On ``DataError`` or ``IntegrityError``.
+            Exception: The original exception, for every other type.
         """
         connection.close()
         logging.error(e)
         if to_raise:
-            raise e
+            raise_http_exception(e)
 
     def commit(self, connection: Connection):
         """Commit the connection, handling the possible exceptions.
@@ -96,6 +114,50 @@ class CrudMetadata:
         except Exception as e:
             self._handle_exception(connection, e)
 
+    def register_handlers(self, from_table: str, handlers: list[BaseHandler]) -> StatementManager:
+        """Configure the specialized handlers for one table.
+
+        Without registration the pipeline of a table holds the ``BaseHandler`` alone,
+        which covers equality, ``IN`` and the ``ARRAY`` operators — the whole filtering
+        this layer used to support. Registering ``ILikeHandler``, ``JsonHandler``,
+        ``IntervalHandler`` or ``OrHandler`` extends it exactly as on ``CrudRepository``:
+        the handler interface works on the column collection of a reflected ``Table``
+        with no adaptation, JSON columns included, since reflection resolves a JSONB
+        column to ``python_type == dict``.
+
+        The registration is per table and per instance, and replaces any previous one.
+
+        Args:
+            from_table (str): Name of the table the handlers apply to.
+            handlers (list[BaseHandler]): Handlers to run before the base one, in order.
+
+        Returns:
+            StatementManager: The pipeline just registered.
+
+        Raises:
+            HasNoAttributeException: If the table does not exist.
+        """
+        table = self._get_table(name=from_table)
+        manager = StatementManager(handlers=handlers, base_handler=BaseHandler(table.c))
+        self.statement_managers[table.name] = manager
+        return manager
+
+    def _statement_manager(self, table: Table) -> StatementManager:
+        """Return the pipeline of a table, building a base-only one on first use.
+
+        Args:
+            table (Table): Table to get the pipeline for.
+
+        Returns:
+            StatementManager: Registered pipeline, or one holding only the
+                ``BaseHandler`` built from the columns of the table.
+        """
+        manager = self.statement_managers.get(table.name)
+        if manager is None:
+            manager = StatementManager(base_handler=BaseHandler(table.c))
+            self.statement_managers[table.name] = manager
+        return manager
+
     def has_columns(self, *columns: str, table: Table) -> bool:
         """Check that every given name is a column of the table.
 
@@ -189,7 +251,8 @@ class CrudMetadata:
         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):
+    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,
+             orders_by: dict[str, bool] = None, **kwhere):
         """Find the rows of the table matching the given criteria.
 
         Args:
@@ -210,10 +273,10 @@ class CrudMetadata:
         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)
-        result = self._find(table=table, connection=connection, where=where, columns=columns, limit=limit, **kwhere)
+        result = self._find(table=table, connection=connection, where=where, columns=columns, limit=limit, orders_by=orders_by, **kwhere)
         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):
+    def _find(self, table: Table, connection: Connection, where: dict[str, Any] = None, columns: list[str] = None, limit: int = 0, orders_by: dict[str, bool] = None, **kwhere):
         """Build and execute the SELECT statement with filters and limit.
 
         Args:
@@ -230,8 +293,10 @@ class CrudMetadata:
         """
         if where is None:
             where = kwhere if kwhere else {}
+        manager = self._statement_manager(table)
         stmt = self._select(table=table, columns=columns)
-        stmt = stmt.where(*[self._eq_where(table.c[column], condition) for column, condition in where.items()])
+        stmt = self._add_orders_by_condition(stmt, table, orders_by)
+        stmt = manager.prepare_statement(stmt=stmt, **where)
         stmt = self._add_limit_offset_condition(stmt, limit)
         return self.execute(connection=connection, stmt=stmt, mapping=True)
 
@@ -281,7 +346,7 @@ class CrudMetadata:
         """
         if values:
             stmt = table.insert().values(values)
-            stmt = stmt if not returning else stmt.returning()
+            stmt = stmt if not returning else stmt.returning(*table.c)
             return self.execute(connection=connection, stmt=stmt, mapping=True)
         else:
             return []
@@ -325,9 +390,9 @@ class CrudMetadata:
         if where is None:
             where = {}
         stmt = table.update()
-        stmt = stmt.where(*[self._eq_where(table.c[column], condition) for column, condition in where.items()])
+        stmt = self._statement_manager(table).prepare_statement(stmt=stmt, **where)
         stmt = stmt.values(**kwargs)
-        stmt = stmt if not returning else stmt.returning()
+        stmt = stmt if not returning else stmt.returning(*table.c)
         return self.execute(connection=connection, stmt=stmt, mapping=True)
 
     def delete(self, from_table: str, connection: Connection = None, where: dict[str, Any] = None, **kwhere):
@@ -371,7 +436,7 @@ class CrudMetadata:
         if where is None:
             where = kwhere if kwhere else {}
         stmt = table.delete()
-        stmt = stmt.where(*[self._eq_where(table.c[column], condition) for column, condition in where.items()])
+        stmt = self._statement_manager(table).prepare_statement(stmt=stmt, **where)
         return self.execute(connection=connection, stmt=stmt).rowcount
 
     # --------------
@@ -379,6 +444,10 @@ class CrudMetadata:
     def execute(self, connection: Connection, stmt, mapping: bool = False):
         """Execute a statement on the connection, handling the exceptions.
 
+        A statement returning no rows — a DML without ``RETURNING`` — yields an empty list
+        when ``mapping=True`` instead of raising: reading its rows would fail **after** the
+        write has already happened, so a retry would duplicate it.
+
         Args:
             connection (Connection): Connection to execute the statement on.
             stmt: SQLAlchemy Core statement to execute.
@@ -399,7 +468,9 @@ class CrudMetadata:
             self._handle_exception(connection, e)
         else:
             if mapping:
-                result = result.mappings().all()
+                # ``returns_rows`` è falso su un DML senza RETURNING: leggerne le righe
+                # solleverebbe ``ResourceClosedError`` **dopo** che la scrittura è avvenuta
+                result = result.mappings().all() if result.returns_rows else []
             return result
 
     def _get_table(self, name: str):
@@ -454,6 +525,174 @@ class CrudMetadata:
         """
         return self.engine_inspection.has_table(name, self.schema)
 
+    def count(self, from_table: str, connection: Connection = None, where: dict[str, Any] = None, **kwhere) -> int:
+        """Count the rows matching the given criteria.
+
+        Args:
+            from_table (str): Name of the table to count on.
+            connection (Connection, optional): External connection. When ``None``, one is
+                opened and closed at the end.
+            where (dict[str, Any], optional): Filters as a dictionary. Takes precedence
+                over ``**kwhere``.
+            **kwhere: Additional filters as keyword arguments.
+
+        Returns:
+            int: Number of matching rows.
+
+        Raises:
+            HasNoAttributeException: If the table does not exist.
+        """
+        keep_open = connection is not None
+        connection = self.open_connection if connection is None else connection
+        table = self.get_table(name=from_table)
+        total = self._count(table=table, connection=connection, where=where, **kwhere)
+        if not keep_open:
+            connection.close()
+        return total
+
+    def _count(self, table: Table, connection: Connection, where: dict[str, Any] = None, **kwhere) -> int:
+        """Run the ``COUNT`` with the filters applied.
+
+        The ``select_from`` is mandatory: ``select(count())`` alone compiles into a
+        ``SELECT count(*)`` with no FROM clause, which always returns 1.
+
+        Args:
+            table (Table): Table to count on.
+            connection (Connection): Connection to run the statement on.
+            where (dict[str, Any], optional): Filters. When ``None``, ``**kwhere`` is used.
+            **kwhere: Additional filters as keyword arguments.
+
+        Returns:
+            int: Number of matching rows.
+        """
+        if where is None:
+            where = kwhere if kwhere else {}
+        stmt = select(count()).select_from(table)
+        stmt = self._statement_manager(table).prepare_statement(stmt=stmt, **where)
+        return self.execute(connection=connection, stmt=stmt).scalar()
+
+    def paging_find(self, from_table: str, connection: Connection = None, where: dict[str, Any] = None, columns: list[str] = None, limit: int = 0, page: int = 1,
+                    parsing_model: Type[BaseModel] = None, orders_by: dict[str, bool] = None, **kwhere) -> PaginatorResponseModel:
+        """Run a paginated search on a reflected table.
+
+        Mirrors ``CrudRepository.paging_find``, including the derived total: the data query
+        runs **first**, so that when the page itself tells how many rows there are the
+        ``COUNT`` is skipped entirely. The derived value is exact, not estimated.
+
+        Args:
+            from_table (str): Name of the table to search on.
+            connection (Connection, optional): External connection. When ``None``, one is
+                opened and closed at the end.
+            where (dict[str, Any], optional): Filters as a dictionary.
+            columns (list[str], optional): Columns to select.
+            limit (int): Number of rows per page. Default: 0, meaning no limit and
+                therefore a single page.
+            page (int): Requested page number, 1-based. Default: 1.
+            parsing_model (Type[BaseModel], optional): Model each row is serialized with.
+            orders_by (dict[str, bool], optional): Ordering, as ``{column: ascending}``,
+                with the clauses following the insertion order of the dictionary. When
+                omitted no ordering is applied, and without a total order two pages can
+                overlap.
+            **kwhere: Additional filters as keyword arguments.
+
+        Returns:
+            PaginatorResponseModel: Object carrying ``data``, ``tot_pages``, ``page``,
+                ``limit`` and the ordering.
+
+        Raises:
+            HasNoAttributeException: If the table or one of the columns does not exist.
+        """
+        keep_open = connection is not None
+        connection = self.open_connection if connection is None else connection
+        table = self.get_table(name=from_table)
+        paginated = self._paging_find(table=table, connection=connection, where=where, columns=columns, limit=limit, page=page, orders_by=orders_by, **kwhere)
+        if not keep_open:
+            if parsing_model is not None:
+                paginated.data = [parsing_model(**row) for row in paginated.data]
+            connection.close()
+        return paginated
+
+    def _paging_find(self, table: Table, connection: Connection, where: dict[str, Any] = None, columns: list[str] = None, limit: int = 0, page: int = 1,
+                     orders_by: dict[str, bool] = None, **kwhere) -> PaginatorResponseModel:
+        """Read the page and derive the total, running the ``COUNT`` only when needed.
+
+        Args:
+            table (Table): Table to search on.
+            connection (Connection): Connection to run the statements on.
+            where (dict[str, Any], optional): Filters. When ``None``, ``**kwhere`` is used.
+            columns (list[str], optional): Columns to select.
+            limit (int): Rows per page. 0 means no limit.
+            page (int): Page number, 1-based.
+            orders_by (dict[str, bool], optional): Ordering to apply.
+            **kwhere: Additional filters as keyword arguments.
+
+        Returns:
+            PaginatorResponseModel: Page and total, with the raw rows as ``data``.
+        """
+        if where is None:
+            where = kwhere if kwhere else {}
+        if orders_by is None:
+            orders_by = {}
+
+        manager = self._statement_manager(table)
+        stmt = self._select(table=table, columns=columns)
+        stmt = self._add_orders_by_condition(stmt, table, orders_by)
+        stmt = self._add_limit_offset_condition(stmt, limit, page)
+        # copia: ``conditions`` consuma le chiavi con ``pop`` e il ``where`` è del chiamante
+        conditions = manager.conditions(where=dict(where))
+        if conditions:
+            stmt = stmt.where(*conditions)
+        stmt = manager.options(stmt=stmt)
+
+        rows = self.execute(connection=connection, stmt=stmt, mapping=True)
+
+        read = len(rows)
+        if not limit or (read < limit and page == 1):
+            total = read
+        elif limit > read > 0 and page > 1:
+            total = (page - 1) * limit + read
+        else:
+            total = self._preconf_count(table=table, connection=connection, where=conditions)
+
+        return parse_pagination(limit=limit, page=page, orders_by=orders_by, count=total, data=rows)
+
+    def _preconf_count(self, table: Table, connection: Connection, where: Optional[list] = None) -> int:
+        """Count from already built WHERE conditions, reusing the ones of the page query.
+
+        Args:
+            table (Table): Table to count on.
+            connection (Connection): Connection to run the statement on.
+            where (list | None): Conditions as ``StatementManager.conditions`` returns
+                them. An empty list or ``None`` counts every row.
+
+        Returns:
+            int: Number of matching rows.
+        """
+        stmt = select(count()).select_from(table)
+        if where:
+            stmt = stmt.where(*where)
+        return self.execute(connection=connection, stmt=stmt).scalar()
+
+    def _add_orders_by_condition(self, stmt, table: Table, orders_by: dict[str, bool] = None):
+        """Add one ORDER BY clause per entry of ``orders_by``, in insertion order.
+
+        Args:
+            stmt: Statement to add the ordering to.
+            table (Table): Table the columns belong to.
+            orders_by (dict[str, bool], optional): ``{column: ascending}``. Nothing is
+                applied when empty or ``None``.
+
+        Returns:
+            Statement with the ORDER BY clauses applied.
+
+        Raises:
+            HasNoAttributeException: If one of the columns does not exist on the table.
+        """
+        manager = self._statement_manager(table)
+        for order_by, asc in (orders_by or {}).items():
+            stmt = manager.order_by_condition(stmt=stmt, order_by=order_by, asc=asc)
+        return stmt
+
     def _add_limit_offset_condition(self, stmt, limit: int, page: int = None):
         """Add the LIMIT and OFFSET clauses to the statement for pagination.
 
@@ -475,31 +714,3 @@ class CrudMetadata:
                 offset = (page - 1) * limit
                 stmt = stmt.offset(offset)
         return stmt
-
-    def _eq_where(self, col: Column, condition, neq: bool = False):
-        """Build the single WHERE condition for one column.
-
-        The logic matches ``BaseHandler._handle``: an ``ARRAY`` column compared to a list
-        yields an overlap (``&&``), compared to a scalar an ``= ANY``; a list yields an
-        ``IN`` and a scalar an equality.
-
-        Args:
-            col (Column): Column the condition applies to.
-            condition: Value or list of values to compare.
-            neq (bool): If ``True``, negate the condition with ``NOT``. Default: ``False``.
-
-        Returns:
-            ColumnElement: SQLAlchemy boolean expression.
-        """
-        is_array = isinstance(col.type, ARRAY)
-        if is_array and isinstance(condition, list):
-            eq_where = col.op("&&")(type_coerce(condition, col.type))
-        elif isinstance(condition, list):
-            eq_where = col.in_(condition)
-        elif is_array:
-            eq_where = condition == col.any_()
-        else:
-            eq_where = col == condition
-        if neq:
-            eq_where = not_(eq_where)
-        return eq_where

general/interface/metadata/geom_metadata.py

@@ -101,8 +101,11 @@ class GeomMetadata(CrudMetadata):
         if intersection_area:
             stmt = stmt.add_columns(polygon_column.ST_Intersection(intersecting_geom).ST_Transform(3857).ST_Area().label("intersection_area"))
 
-        eq_where = [self._eq_where(table.c[column], condition) for column, condition in where.items()]
-        eq_where.extend([self._eq_where(table.c[column], condition, True) for column, condition in not_where.items()])
+        manager = self._statement_manager(table)
+        # ``conditions`` consuma le chiavi con ``pop``: il dizionario va copiato, altrimenti
+        # un chiamante che riusa i propri filtri li perde dopo la prima chiamata
+        eq_where = list(manager.conditions(where=dict(where)))
+        eq_where.extend(manager.conditions(neq=True, where=dict(not_where)))
 
         geom_condition = polygon_column.ST_Intersects(intersecting_geom)
 
@@ -174,7 +177,7 @@ class GeomMetadata(CrudMetadata):
             where = {}
 
         stmt = self._select(table, columns)
-        eq_where = [self._eq_where(table.c[column], condition) for column, condition in where.items()]
+        eq_where = list(self._statement_manager(table).conditions(where=dict(where)))
 
         geom_condition = self._geom_condition(geom=geom, geom_srid=geom_srid, polygon_column_srid=polygon_column_srid, buffer=tolerance)
         geom_condition = polygon_column.ST_Contains(geom_condition) if not contained else geom_condition.ST_Contains(polygon_column)

general/interface/mixin/__init__.py

@@ -0,0 +1,20 @@
+"""Domain mixins for the ORM entities.
+
+Each mixin adds a group of columns an entity would otherwise redeclare, and works on the
+write paths of the library without any change to the repositories: the timestamps come
+from ``server_default``/``onupdate``, the audit columns from a Python-side default reading
+the ``current_user`` context variable of ``general.context``.
+
+They are plain classes holding ``Column`` objects, so they are mixed in next to ``Base``
+with no ``declared_attr``.
+"""
+
+from .audit_mixin import *
+from .softdelete_mixin import *
+from .timestamp_mixin import *
+
+__all__ = [
+    "TimestampMixin",
+    "AuditMixin",
+    "SoftDeleteMixin",
+]

general/interface/mixin/audit_mixin.py

@@ -0,0 +1,34 @@
+__all__ = ["AuditMixin"]
+
+from sqlalchemy import Column, String
+
+from ...context import current_user
+
+
+class AuditMixin:
+    """Mixin recording which user created and last updated a row.
+
+    Meant to be mixed into a ``Base`` subclass together with the entity columns::
+
+        class Article(Base, AuditMixin):
+            __tablename__ = "article"
+            id = Column(Integer, primary_key=True)
+
+    Both values are read from the ``current_user`` context variable of ``general.context``,
+    which the consumer sets. The defaults are **Python-side**, evaluated at execution: they
+    therefore apply to every write path of the library, the bulk ``insert`` included, and
+    not to a raw SQL statement run outside it.
+
+    ``create_uid`` is written on insert and never touched again, because ``onupdate`` only
+    applies to ``write_uid``: an update changes who last touched the row without
+    rewriting who created it.
+
+    Attributes:
+        create_uid (Column): User the insert is attributed to. ``None`` when
+            ``current_user`` is unset.
+        write_uid (Column): User the last update through the library is attributed to. On
+            insert it holds the same value as ``create_uid``.
+    """
+
+    create_uid = Column(String, default=lambda: current_user.get(), nullable=True)
+    write_uid = Column(String, default=lambda: current_user.get(), onupdate=lambda: current_user.get(), nullable=True)

general/interface/mixin/softdelete_mixin.py

@@ -0,0 +1,43 @@
+__all__ = ["SoftDeleteMixin"]
+
+from sqlalchemy import Column, DateTime, Boolean, String
+
+from ...context import current_user
+
+
+class SoftDeleteMixin:
+    """Mixin adding the logical deletion instant to an entity.
+
+    Meant to be mixed into a ``Base`` subclass together with the entity columns::
+
+        class Article(Base, SoftDeleteMixin):
+            __tablename__ = "article"
+            id = Column(Integer, primary_key=True)
+
+    The columns alone change nothing: a row is deleted when ``deleted`` is true, and it is
+    ``SoftDeleteHandler`` — registered among the handlers of the repository — that keeps
+    those rows out of the queries. Without that handler the columns are inert and every row
+    stays visible.
+
+    ``deleted`` is nullable and filled by a Python-side default, so a row written in raw
+    SQL leaves it ``NULL``: the handler therefore filters on ``IS NOT true``, which keeps
+    both ``false`` and ``NULL``, and not on ``= false``, which would hide a live row.
+
+    This mixin does **not** turn ``CrudRepository.delete`` into a logical deletion: that
+    method still removes the row. Marking a row as deleted means writing the columns,
+    ``update(where={...}, deleted=True, delete_date=..., delete_uid=...)``, and restoring it
+    means writing ``deleted=False`` with ``include_deleted=True`` in the filters, so that
+    the handler lets the row through.
+
+    Attributes:
+        deleted (Column): Deletion flag. ``False`` on insert, ``True`` once the row is
+            logically deleted, ``NULL`` on the rows written outside SQLAlchemy.
+        delete_uid (Column): User the deletion is attributed to. Its default fires **on
+            insert**, so today it holds a value on live rows too: a deletion is an UPDATE
+            like any other, and there is no default that could fire only then.
+        delete_date (Column): Instant of the deletion, written by the caller.
+    """
+
+    deleted = Column(Boolean, default=False)
+    delete_uid = Column(String, default=lambda: current_user.get(), onupdate=lambda: current_user.get(), nullable=True)
+    delete_date = Column(DateTime, nullable=True, default=None)

general/interface/mixin/timestamp_mixin.py

@@ -0,0 +1,35 @@
+__all__ = ["TimestampMixin"]
+
+from sqlalchemy import Column, DateTime, func
+
+
+class TimestampMixin:
+    """Mixin adding the creation and last-update timestamps to an entity.
+
+    Meant to be mixed into a ``Base`` subclass, before or after it, since the columns are
+    plain ``Column`` objects and need no ``declared_attr``::
+
+        class Article(Base, TimestampMixin):
+            __tablename__ = "article"
+            id = Column(Integer, primary_key=True)
+
+    Both timestamps are timezone aware: on PostgreSQL they become
+    ``TIMESTAMP WITH TIME ZONE``, on the backends that ignore the flag the column is a
+    plain timestamp and the value is the one the database produces.
+
+    ``create_date`` is filled by a **server-side** default, so it is correct even for rows
+    inserted outside the library, by a migration or by hand. ``write_date`` is refreshed by
+    ``onupdate``, which SQLAlchemy adds to the UPDATE statement it builds: it therefore
+    covers ``CrudRepository.update`` and ``upsert``, and does **not** cover a raw SQL
+    UPDATE run outside the library — that would need a database trigger, which a mixin
+    cannot install.
+
+    Attributes:
+        create_date (Column): Insert instant, from the ``now()`` of the database. Not null.
+        write_date (Column): Instant of the last update through the library. Not null: on
+            insert it holds the creation instant, so the two are equal until the first
+            update.
+    """
+
+    create_date = Column(DateTime, server_default=func.now(), nullable=False)
+    write_date = Column(DateTime, server_default=func.now(), onupdate=func.now(), nullable=False)

general/interface/repository/crud_repository.py

@@ -2,23 +2,21 @@ __all__ = ["CrudRepository"]
 
 import hashlib
 import logging
-import math
 from functools import lru_cache
 from typing import Any, Type, Sequence, Optional, Mapping
 
 from pydantic import BaseModel, TypeAdapter
 from sqlalchemy import select, delete, update, insert, tuple_, Row, RowMapping, ColumnElement, Select, Insert, Update, Delete, func, ARRAY
 from sqlalchemy.engine.base import Engine
-from sqlalchemy.exc import DataError, IntegrityError, NoResultFound, OperationalError
 from sqlalchemy.inspection import inspect
 from sqlalchemy.orm import Session, load_only, defer
 from sqlalchemy.sql.functions import count
 
 from .handler.base_handler import BaseHandler
 from .handler.statement_manager import StatementManager
-from ...exception.crud_exceptions import HasNoAttributeException, EntityNotFoundException, ServiceUnavailableException, BadRequestException
+from ...exception.crud_exceptions import HasNoAttributeException, raise_http_exception
 from ...interface.base.declarative_base import Base
-from ...paginator_dto import PaginatorResponseModel
+from ...paginator_dto import PaginatorResponseModel, parse_pagination
 
 
 @lru_cache(maxsize=None)
@@ -39,6 +37,27 @@ def _list_adapter(model: Type[BaseModel]) -> TypeAdapter:
     return TypeAdapter(list[model])
 
 
+@lru_cache(maxsize=None)
+def _pk_attributes(entity: Type[Base]) -> tuple[str, ...]:
+    """Python attribute names of the primary key columns, in column order.
+
+    ``primary_key()`` returns ``Column`` objects, whose ``name`` and ``key`` are the
+    database name: on an entity declaring an explicit column name they differ from the
+    Python attribute, which is the name both the ORM entities and the Pydantic models
+    expose. The mapping goes through ``mapper.columns``, which is indexed by attribute
+    name and does not force ``configure_mappers()``.
+
+    Args:
+        entity (Type[Base]): ORM class to inspect.
+
+    Returns:
+        tuple[str, ...]: Attribute names of the primary key, in the same order as
+            ``entity.primary_key()``.
+    """
+    attribute_by_column = {column: name for name, column in inspect(entity).columns.items()}
+    return tuple(attribute_by_column.get(column, column.key) for column in entity.primary_key())
+
+
 @lru_cache(maxsize=None)
 def _reduced_model(entity: Type[Base], columns: frozenset[str]) -> Type[BaseModel]:
     """Build a model restricted to the given columns, once per combination.
@@ -160,15 +179,7 @@ class CrudRepository[Entity: Base | Type[Base]]:
         """
         session.close()
         logging.error(e)
-        match e:
-            case OperationalError():
-                raise ServiceUnavailableException()
-            case NoResultFound():
-                raise EntityNotFoundException()
-            case DataError() | IntegrityError():
-                raise BadRequestException()
-            case _:
-                raise e
+        raise_http_exception(e)
 
     def commit(self, session: Session):
         """Commit the session, handling the possible exceptions.
@@ -535,7 +546,7 @@ class CrudRepository[Entity: Base | Type[Base]]:
 
         # 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]
+        model_keys = [self._pk_key(model) 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.
@@ -544,7 +555,7 @@ class CrudRepository[Entity: Base | Type[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
+                existing[self._pk_key(entity)] = entity
 
         # Ripartizione insert/update in base alla presenza nella mappa.
         inserts = []
@@ -564,23 +575,25 @@ class CrudRepository[Entity: Base | Type[Base]]:
 
         return result
 
-    def _pk_key(self, obj: Type[BaseModel] | BaseModel | Base, pk_columns) -> tuple | None:
+    def _pk_key(self, obj: Type[BaseModel] | BaseModel | Base) -> tuple | None:
         """Extract the possibly composite primary key from a model or an entity.
 
         Reads the values of the primary key columns in order and returns them as a tuple,
-        usable both as a map key and for the ``tuple_(...).in_(...)`` filter.
+        usable both as a map key and for the ``tuple_(...).in_(...)`` filter. The values are
+        read by **Python attribute** name, the one both the ORM entities and the Pydantic
+        models expose, and a value counts as missing only when it is ``None``: a key equal
+        to ``0`` or to the empty string is a valid key, and treating it as missing made
+        ``upsert`` insert a row that already existed.
 
         Args:
             obj: Pydantic model or ORM entity to read the primary key from.
-            pk_columns: Columns making up the primary key, typically
-                ``self.entity.primary_key()``.
 
         Returns:
             tuple | None: Primary key values in column order, or ``None`` when at least one
-                value is missing.
+                value is ``None``, which marks the model as a candidate for the insert.
         """
-        values = tuple(getattr(obj, column.name, None) for column in pk_columns)
-        return values if all(values) else None
+        values = tuple(getattr(obj, attribute, None) for attribute in _pk_attributes(self.entity))
+        return values if all(value is not None for value in values) else None
 
     def count(self, session: Session = None, where: dict[str, Any] = None, **kwhere):
         """Count the records matching the given criteria.
@@ -731,12 +744,7 @@ class CrudRepository[Entity: Base | Type[Base]]:
         Returns:
             PaginatorResponseModel: Complete paginated response.
         """
-        limit = limit if limit else len(data)
-        order_by = next(iter(orders_by), None) if orders_by else None
-        asc = orders_by.get(order_by) if order_by is not None else None
-        tot_pages = math.ceil(count / limit) if count and limit > 0 else 1
-
-        return PaginatorResponseModel(limit=limit, page=page, order_by=order_by, asc=asc, tot_pages=tot_pages, orders_by=orders_by, data=data)
+        return parse_pagination(limit=limit, page=page, orders_by=orders_by, count=count, data=data)
 
     def distinct_pairs(self, key: str, value: str, session: Session = None, where: dict[str, Any] = None, **kwhere) -> list[Row] | None:
         """Return the distinct ``(key, value)`` pairs of the records matching ``where``.

general/interface/repository/handler/__init__.py

@@ -12,6 +12,7 @@ from .interval_handler import *
 from .json_handler import *
 from .json_ilike_handler import *
 from .or_handler import *
+from .soft_delete_handler import *
 from .statement_manager import *
 
 __all__ = [
@@ -22,5 +23,6 @@ __all__ = [
     "JsonILikeHandler",
     "OrHandler",
     "IntervalHandler",
+    "SoftDeleteHandler",
     "StatementManager",
 ]

general/interface/repository/handler/soft_delete_handler.py

@@ -0,0 +1,83 @@
+__all__ = ["SoftDeleteHandler"]
+
+from typing import Any
+
+from sqlalchemy import Column, ColumnElement
+from sqlalchemy.sql.base import ReadOnlyColumnCollection
+
+from .base_handler import BaseHandler
+
+
+class SoftDeleteHandler(BaseHandler):
+    """Handler keeping the logically deleted rows out of the queries.
+
+    Companion of ``SoftDeleteMixin``: it adds ``deleted IS NOT true`` to every statement
+    going through the pipeline, so ``find``, ``paging_find``, ``count``, ``update`` and
+    ``delete`` only see the live rows. Unlike the other specialized handlers the condition
+    does not come from a value of the ``where``: it is a policy, applied even when no
+    filter is passed at all.
+
+    The form of the condition is ``IS NOT true`` and not ``= false`` on purpose. The flag
+    is nullable and filled by a Python-side default, which SQLAlchemy applies to its own
+    statements but not to raw SQL: a row written by a migration or from a console leaves
+    the column ``NULL``, and ``deleted = false`` would evaluate to ``NULL`` on it, hiding a
+    live row. ``IS NOT true`` keeps both ``false`` and ``NULL``, and compiles on both
+    supported backends.
+
+    The alias in ``include_alias`` is the opt-out: a true value returns the deleted rows
+    too, which is what a restore or an audit view needs. The value is read as a boolean, so
+    ``False``, ``0`` and ``None`` all leave the filter in place — the alias is a switch, not
+    a value to compare, and this is the one handler where the library rule «only ``None``
+    means no filter» does not apply.
+
+    Attributes:
+        deleted_column (Column): Column holding the deletion flag, resolved at
+            initialization.
+        include_alias (str): Key of the ``where`` that disables the filter.
+    """
+    __slots__ = "deleted_column", "include_alias"
+    deleted_column: Column
+    include_alias: str
+
+    def __init__(self, columns: ReadOnlyColumnCollection[str, Column[Any]], deleted_column: str = "deleted", include_alias: str = "include_deleted"):
+        """Initialize the handler resolving the deletion column right away.
+
+        Args:
+            columns (ReadOnlyColumnCollection): Columns of the table.
+            deleted_column (str): Name of the column holding the deletion flag.
+                Default: ``"deleted"``.
+            include_alias (str): Key of the ``where`` disabling the filter.
+                Default: ``"include_deleted"``.
+
+        Raises:
+            KeyError: If ``deleted_column`` is not a column of the table. The resolution
+                happens here, so a wrong name fails at construction and not at the first
+                query.
+        """
+        super().__init__(columns)
+        self.deleted_column = self.columns[deleted_column]
+        self.include_alias = include_alias
+
+    def conditions(self, neq: bool = False, where: dict[str, Any] = None) -> list[ColumnElement[Any]]:
+        """Return ``deleted IS NOT true`` unless the alias asks for the deleted rows too.
+
+        The alias is always removed from the ``where``, even when it does not change the
+        outcome: a key left behind would reach ``BaseHandler``, which raises ``KeyError``
+        on a name that is not a column.
+
+        Args:
+            neq (bool): When ``True`` nothing is returned. The negation is applied to the
+                filters of the caller, and this condition is not one of them: negating it
+                would return **only** the deleted rows, the opposite of the policy. On the
+                spatial methods, which ask for the conditions twice — once positive and
+                once negated — this also avoids emitting the filter twice.
+            where (dict[str, Any]): Filters. The alias is removed in-place.
+
+        Returns:
+            list[ColumnElement]: One condition, or none when the deleted rows are wanted
+                or when ``neq`` is set.
+        """
+        include_deleted = where.pop(self.include_alias, None) if where is not None else None
+        if neq or include_deleted:
+            return []
+        return [self.deleted_column.isnot(True)]

general/paginator_dto.py

@@ -1,6 +1,7 @@
-__all__ = ["PaginatorRequestModel", "PaginatorResponseModel"]
+__all__ = ["PaginatorRequestModel", "PaginatorResponseModel", "parse_pagination"]
 
-from typing import Optional
+import math
+from typing import Any, Optional, Sequence
 
 from pydantic import Field
 
@@ -54,3 +55,31 @@ class PaginatorResponseModel[ResponseType](PaginatorBaseModel):
     tot_pages: int = Field(alias="pagineTotali")
     orders_by: Optional[dict[str, bool]] = Field(default=None, alias="campiOrdinamento")
     data: list[ResponseType]
+
+
+def parse_pagination(limit: int, page: int, orders_by: dict[str, bool], count: int, data: Sequence[Any]) -> PaginatorResponseModel:
+    """Build the ``PaginatorResponseModel`` from the pagination data.
+
+    Shared by the ORM and the metadata layer, so that the two produce the same response
+    shape from the same inputs. When ``limit`` is 0, meaning no limit, the length of the
+    data is used as the effective limit. The response carries the whole ``orders_by`` plus
+    its first pair as ``order_by``/``asc``, which are the fields the clients read as the
+    main ordering criterion; with an empty ``orders_by`` both stay ``None``, because no
+    ordering was applied.
+
+    Args:
+        limit (int): Number of items per page.
+        page (int): Current page.
+        orders_by (dict[str, bool]): Ordering applied, as ``{column: ascending}``.
+        count (int): Total number of filtered records.
+        data (Sequence): Rows of the current page.
+
+    Returns:
+        PaginatorResponseModel: Complete paginated response.
+    """
+    limit = limit if limit else len(data)
+    order_by = next(iter(orders_by), None) if orders_by else None
+    asc = orders_by.get(order_by) if order_by is not None else None
+    tot_pages = math.ceil(count / limit) if count and limit > 0 else 1
+
+    return PaginatorResponseModel(limit=limit, page=page, order_by=order_by, asc=asc, tot_pages=tot_pages, orders_by=orders_by, data=data)

{python_general_be_lib-0.9.1.dist-info → python_general_be_lib-0.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-general-be-lib
-Version: 0.9.1
+Version: 0.10.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.9.1.dist-info → python_general_be_lib-0.10.0.dist-info}/RECORD

@@ -1,24 +1,29 @@
 general/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+general/context.py,sha256=ArxisBIbmij72IWKQwBfJBhmAucUGlMnEPRQnYl1A6k,1165
 general/logger.py,sha256=P-7-BLtO1XC2m43wXrnJcTakr2iZBE0gUkMVppJ9exE,4506
-general/paginator_dto.py,sha256=ug2KJMPQRgxcwTu8-MvuLi7MwvmkHDG9cHwfp6EzqIg,2267
+general/paginator_dto.py,sha256=DB2hfcrckuEiHEIORLT4EgCcnX4AYYKGlHRr-l-Q1Cw,3741
 general/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-general/exception/__init__.py,sha256=3o5KaoCwA020aG0GIR0jOA4t_ibOBiji0xMxZx4uNug,745
+general/exception/__init__.py,sha256=MZpSDUKeopct7ZqMd1g4XlNS8sM9mmXIlHTIYPOhu9c,849
 general/exception/access_exceptions.py,sha256=tNIBjxM0-5iSOXDc7Il01eb36mEk-POQGVaHhCpG278,744
-general/exception/crud_exceptions.py,sha256=LGfQ8iTj9Sh8LVLId5HfSrc2UgH26CehKRT9aanZAiY,2950
+general/exception/crud_exceptions.py,sha256=JZs3dXBOp0dYZ5yfNBbMSd2xoLTCMxXxz1myt46Ql2g,4351
 general/exception/exception_interface.py,sha256=k7KreAYMwKPQQghkCissdu3ASZZqrRFWM1lAGzeR8sM,1294
 general/interface/__init__.py,sha256=G11sI1Oxtb-Z_-ORAuKS_Kkdwopt1uXmEXYtZEJYiLs,445
 general/interface/base/__init__.py,sha256=fA1hdSY5TX6k_UpvA0eAfYeNWkXY6fPrHBqZVIdf6PY,270
 general/interface/base/base_model.py,sha256=aIzrRZVUytmbgmEH1bya29rVFOm-Njinn_JXkgkBrr8,2575
-general/interface/base/declarative_base.py,sha256=dmzvJLEL6qO4zmwjxLWOcqQmutlDC3pwCfxe1UtKGEE,7180
+general/interface/base/declarative_base.py,sha256=4kT7gSHZufV514VG_r8vJm2irDZDYJaGc4L_nO_fTNA,8743
 general/interface/metadata/__init__.py,sha256=pXKYY4uO92eQI3gtuG4FKZbBi76gu-VJLxaAy-emeP8,474
-general/interface/metadata/crud_metadata.py,sha256=i6ldkyUqjHPerninf--sQlGyUm18FgzIBmDq55UYz0g,22819
-general/interface/metadata/geom_metadata.py,sha256=thfVc0hyKgkTFIQrRaX6khf_NbEHyEkc-zUA7nO8bI8,11918
+general/interface/metadata/crud_metadata.py,sha256=VG3qzYlH9j3nmfZql1cRejxmLHBS-GE03XW6ZNtacQI,33689
+general/interface/metadata/geom_metadata.py,sha256=gzeFkC9qyV_GXxtAaKmA9dka0DaC-gqk2sqo9KJkFxM,12042
+general/interface/mixin/__init__.py,sha256=M5-e6T_R63Utwh3_WcmoE3wanwIZjNjbgLYrrFlSpTA,659
+general/interface/mixin/audit_mixin.py,sha256=N2JDD9JxXDMeBqu0yAlhVWFOK3EeUA2b215hPvXytUU,1421
+general/interface/mixin/softdelete_mixin.py,sha256=526luzM4DBCorcq99kZ6BYqtQKKJCpnxX9rSEigfyIU,2148
+general/interface/mixin/timestamp_mixin.py,sha256=TMetFs3zgI7YanckFnfycpNGn-ZbptwweKdOxe125O0,1641
 general/interface/repository/__init__.py,sha256=eWoNy35LVu6sDrK5ju7VAeoclknKO0-yTgjVckJpi8s,321
-general/interface/repository/crud_repository.py,sha256=CH05WG6ZKkDpS5DEB_718AoRqJUS47CMXM65bI-1nCE,40032
+general/interface/repository/crud_repository.py,sha256=pA3zNvZuLa7Ddeq1j8vNjPNc4KFWAL1-RwEuyc5C0oE,40543
 general/interface/repository/geometry_repository.py,sha256=dB1AmZyyi5cWEzl-_4-2eOXXex-rQsa_cu6bl85wtNE,11252
 general/interface/repository/many_to_many_repository.py,sha256=wl-K0n-rwPvIDpa_LfoBq1iHUnC6QvSLm-uwyKA4taw,8574
 general/interface/repository/view_repository.py,sha256=wxDGw7kenuVrDd9nfh7-omw2m9Jex5WzF_lhEiqPoA0,7902
-general/interface/repository/handler/__init__.py,sha256=7EIi-ydRFK39MLyMqAHp6l7gO_g6vg1iOZzAQQDUz94,650
+general/interface/repository/handler/__init__.py,sha256=ZOJfvJennTeJjkl0z5a0kOO8G5nDvNXXYDJUIjbN1zY,710
 general/interface/repository/handler/base_handler.py,sha256=aVT6s60rsdZUqQlKWlUyuiGgVxzFLJCb7uztn859sL4,3363
 general/interface/repository/handler/handler.py,sha256=2ASmD8XkOLaE7-jCfTNwGHEwXOhBKEc_dfXpIYMuxN4,3221
 general/interface/repository/handler/ilike_handler.py,sha256=OM3klDlx7ixqWF7kklWj8kbgVY_5ZNitcQ0usGnQP_0,4015
@@ -26,9 +31,10 @@ general/interface/repository/handler/interval_handler.py,sha256=4TtEcpzUFZeyB-yi
 general/interface/repository/handler/json_handler.py,sha256=f_nGemsxTPJ3W0xkU99sCFA0EVo1xa8p803NyjcGJT4,4414
 general/interface/repository/handler/json_ilike_handler.py,sha256=icfA4dO8E_W_KUEG5HB1nLVI1jfjxzkG8ZJ-IaCd4kY,3530
 general/interface/repository/handler/or_handler.py,sha256=UOjIh77H4y-x434YGLYRfVIXKnod1M5XPiMf71V2JTg,3137
+general/interface/repository/handler/soft_delete_handler.py,sha256=1WD1n6q5plyJ0RDniJcEwNlic1WJqXvSlCj99VLc_3A,4100
 general/interface/repository/handler/statement_manager.py,sha256=dPG-HZy0jVM3Y4ZnCp2QPY4gLgt-rWSzOvY1_UmotcI,7333
-python_general_be_lib-0.9.1.dist-info/licenses/LICENSE,sha256=iUaO1XZyB9P3Tmog0OILuTisP6vXGe3QKz-4yRTxOFk,1069
-python_general_be_lib-0.9.1.dist-info/METADATA,sha256=J4CIjmhDsD6SN26tAfFUvtbd2eQOggjhucncPn6Sn6c,3409
-python_general_be_lib-0.9.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-python_general_be_lib-0.9.1.dist-info/top_level.txt,sha256=tTZePW8_CNUqSgKFd2SEH72ZbnhS0OYjRsgcv0ikSFY,8
-python_general_be_lib-0.9.1.dist-info/RECORD,,
+python_general_be_lib-0.10.0.dist-info/licenses/LICENSE,sha256=iUaO1XZyB9P3Tmog0OILuTisP6vXGe3QKz-4yRTxOFk,1069
+python_general_be_lib-0.10.0.dist-info/METADATA,sha256=yUNc1zJR-Nih7Iz9nVpD8jncus9MkL-fzihP8psvVfU,3410
+python_general_be_lib-0.10.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+python_general_be_lib-0.10.0.dist-info/top_level.txt,sha256=tTZePW8_CNUqSgKFd2SEH72ZbnhS0OYjRsgcv0ikSFY,8
+python_general_be_lib-0.10.0.dist-info/RECORD,,