python-general-be-lib 0.1.0__py3-none-any.whl

general/exception/access_exceptions.py

@@ -0,0 +1,11 @@
+from .exception_interface import ExceptionInterface
+
+
+class ForbiddenException(ExceptionInterface):
+    status_code = 403
+    default_message = "Risorsa non accessibile da questo utente"
+
+
+class UnauthorizedException(ExceptionInterface):
+    status_code = 401
+    default_message = "Non autorizzato"

general/exception/crud_exceptions.py

@@ -0,0 +1,37 @@
+from .exception_interface import ExceptionInterface
+
+
+class BadRequestException(ExceptionInterface):
+    status_code = 400
+    default_message = "Richiesta non corretta"
+
+
+class EntityNotFoundException(ExceptionInterface):
+    status_code = 404
+    default_message = "Dato non trovato"
+
+
+class ServiceUnavailableException(ExceptionInterface):
+    status_code = 503
+    default_message = "Servizio momentaneamente non disponibile, riprovare più tardi"
+
+
+class UnprocessableEntityException(ExceptionInterface):
+    status_code = 422
+    default_message = "Entità non processabile"
+
+
+class HasNoAttributeException(ExceptionInterface):
+    status_code = 400
+    default_message = "Richiesta non corretta"
+
+    def __init__(self, attr: str = ""):
+        if attr:
+            super().__init__(custom_message=f"Attributo {attr} non presente", )
+        else:
+            super().__init__(custom_message="Alcuni attributi non sono presenti per questa entità", )
+
+
+class InternalServerException(ExceptionInterface):
+    status_code = 500
+    default_message = "Impossibile gestire la richiesta al momento"

general/exception/exception_interface.py

@@ -0,0 +1,10 @@
+from fastapi import HTTPException
+
+
+class ExceptionInterface(HTTPException):
+    status_code: int
+    default_message: str
+
+    def __init__(self, custom_message: str = None):
+        detail = f"{self.default_message} - {custom_message}" if custom_message else self.default_message
+        super().__init__(status_code=self.status_code, detail=detail)

general/interface/base/__init__.py

@@ -0,0 +1,2 @@
+from .base_model import *
+from .declarative_base import *

general/interface/base/base_model.py

@@ -0,0 +1,27 @@
+__all__ = ["ExtBaseModel", "CamelExtBaseModel"]
+
+from pydantic import BaseModel, ConfigDict
+from pydantic.alias_generators import to_camel
+
+
+class ConfigModel(BaseModel):
+    model_config = ConfigDict(from_attributes=True, populate_by_name=True, arbitrary_types_allowed=True, validate_default=True)
+
+
+class CamelConfigModel(ConfigModel):
+    model_config = ConfigDict(alias_generator=to_camel)
+
+    @classmethod
+    def get_attr_by_alias(cls, alias: str) -> str:
+        for name, field in cls.model_fields.items():
+            if field.alias == alias:
+                return name
+        return alias
+
+
+class ExtBaseModel(ConfigModel):
+    pass
+
+
+class CamelExtBaseModel(CamelConfigModel):
+    pass

general/interface/base/declarative_base.py

@@ -0,0 +1,57 @@
+__all__ = ["Base", "retrieve_mapper_entity", "retrieve_mapper_from_table"]
+
+from typing import Optional, Any
+
+from geoalchemy2 import Geometry, WKBElement
+from pydantic import create_model
+from sqlalchemy.inspection import inspect
+from sqlalchemy.orm import Mapper, as_declarative
+
+
+@as_declarative()
+class Base:
+
+    @classmethod
+    def to_pydantic(cls, model_name: str = None, full_optional: bool = False, default_values: dict[str, Any] = None, **create_model_kwargs):
+        if not default_values:
+            default_values = dict()
+        mapper: Mapper = inspect(cls)
+        model_name = f"{cls.__name__}Model" if not model_name else model_name
+        fields = dict()
+        field_values = {col.name: None if full_optional else ... for col in mapper.columns}
+        field_values.update(default_values)
+        for col in mapper.columns:
+            field_name = col.name
+            if isinstance(col.type, Geometry):
+                field_type = Optional[WKBElement] if col.nullable or full_optional else WKBElement
+            else:
+                field_type = Optional[col.type.python_type] if col.nullable or full_optional else col.type.python_type
+            fields[field_name] = (field_type, field_values[field_name])
+        return create_model(model_name, **create_model_kwargs, **fields)
+
+    @classmethod
+    def columns(cls):
+        return cls.__table__.c
+
+    @classmethod
+    def columns_names(cls):
+        return [col.name for col in cls.__table__.c]
+
+    @classmethod
+    def primary_key(cls):
+        return cls.__table__.primary_key.columns.values()
+
+    def to_dict(self):
+        return {key: getattr(self, key) for key in self.__class__.columns_names()}
+
+
+def retrieve_mapper_entity(entity_name: str):
+    for mapper in Base.__subclasses__():
+        if mapper.__name__ == entity_name:
+            return mapper
+
+
+def retrieve_mapper_from_table(table_name: str):
+    for mapper in Base.__subclasses__():
+        if mapper.__tablename__ == table_name:
+            return mapper

general/interface/metadata/crud_metadata.py

@@ -0,0 +1,179 @@
+__all__ = ["CrudMetadata"]
+
+import logging
+from typing import Optional, Any, Type, Iterable, Sequence
+
+from pydantic import BaseModel
+from sqlalchemy import MetaData, Engine, Column, Table, inspect, Connection, select, RowMapping, CursorResult, not_
+
+from ...exception.crud_exceptions import HasNoAttributeException
+
+
+class CrudMetadata:
+    __slots__ = "schema", "metadata", "engine", "engine_inspection"
+
+    @property
+    def open_connection(self):
+        return self.engine.connect()
+
+    def __init__(self, engine: Engine, schema_name: str = None, reflect: bool = True):
+        self.schema = schema_name
+        self.metadata = MetaData(schema_name) if schema_name else MetaData()
+        self.engine = engine
+        self.engine_inspection = inspect(self.engine)
+        if reflect:
+            self.metadata.reflect(bind=self.engine, schema=schema_name)
+
+    # ---------------------------
+
+    def _handle_exception(self, connection: Connection, e: Exception, to_raise: bool = True):
+        connection.close()
+        logging.error(e)
+        if to_raise:
+            raise e
+
+    def commit(self, connection: Connection):
+        try:
+            connection.commit()
+        except Exception as e:
+            self._handle_exception(connection, e)
+
+    def has_columns(self, *columns: Iterable[str], table: Table):
+        return all([column in [c.key for c in table.c] for column in columns])
+
+    def _select(self, table: Table, columns: list[str] = None):
+        try:
+            stmt = table.select() if not columns else select(*[table.c[column] for column in columns])
+        except:
+            raise HasNoAttributeException()
+        return stmt
+
+    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):
+        if keep_open:
+            return result
+        else:
+            if commit:
+                self.commit(connection=connection)
+            result = result if parsing_model is None else [parsing_model(**r) for r in result]
+            connection.close()
+        return result
+
+    def create_table(self, name: str, columns: Iterable[Column], **kwargs):
+        table = Table(name=name, metadata=self.metadata, *columns, **kwargs)
+        table.create(self.engine)
+
+    def drop_table(self, name: str):
+        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):
+        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)
+        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):
+        if where is None:
+            where = kwhere if kwhere else {}
+        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_limit_offset_condition(stmt, limit)
+        return self.execute(connection=connection, stmt=stmt, mapping=True)
+
+    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):
+        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)
+        values_condition = values if values else []
+        values_condition.extend([model.model_dump(exclude_none=True) for model in models]) if models else values_condition
+        result = self._insert(table=table, connection=connection, values=values_condition, returning=returning)
+        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):
+        if values:
+            stmt = table.insert().values(values)
+            stmt = stmt if not returning else stmt.returning()
+            return self.execute(connection=connection, stmt=stmt, mapping=True)
+        else:
+            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):
+        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._update(table=table, connection=connection, where=where, returning=returning, **kwargs)
+        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):
+        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 = stmt.values(**kwargs)
+        stmt = stmt if not returning else stmt.returning()
+        return self.execute(connection=connection, stmt=stmt, mapping=True)
+
+    def delete(self, from_table: str, connection: Connection = None, where: dict[str, Any] = None, **kwhere):
+        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)
+        num_rows = self._delete(table=table, connection=connection, where=where, **kwhere)
+        if not num_rows or keep_open:
+            return num_rows
+        else:
+            self.commit(connection)
+        connection.close()
+        return num_rows
+
+    def _delete(self, table: Table, connection: Connection, where: dict[str, Any] = None, **kwhere):
+        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()])
+        return self.execute(connection=connection, stmt=stmt).rowcount
+
+    # --------------
+
+    def execute(self, connection: Connection, stmt, mapping: bool = False):
+        try:
+            result = connection.execute(stmt)
+        except Exception as e:
+            self._handle_exception(connection, e)
+        else:
+            if mapping:
+                result = result.mappings().all()
+            return result
+
+    def _get_table(self, name: str):
+        if self.schema is not None:
+            table_name = name if name.startswith(f"{self.schema}.") else f"{self.schema}.{name}"
+        else:
+            table_name = name
+        return self.metadata.tables.get(table_name)
+
+    def get_table(self, name: str) -> Optional[Table]:
+        table = self._get_table(name=name)
+        if table is None:
+            table = Table(name, self.metadata, schema=self.schema, autoload_with=self.engine)
+        return table
+
+    def has_table(self, name: str):
+        return self.engine_inspection.has_table(name, self.schema)
+
+    def _add_limit_offset_condition(self, stmt, limit: int, page: int = None):
+        if limit and limit > 0:
+            stmt = stmt.limit(limit)
+            if page and page > 0:
+                offset = (page - 1) * limit
+                stmt = stmt.offset(offset)
+        return stmt
+
+    def _eq_where(self, col: Column, condition, neq: bool = False):
+        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)
+        return eq_where

general/interface/metadata/geom_metadata.py

@@ -0,0 +1,88 @@
+__all__ = ["GeomMetadata"]
+
+from typing import Any, Type
+
+from geoalchemy2 import WKBElement
+from pydantic import BaseModel
+from sqlalchemy import Connection, Table, Column
+
+from .crud_metadata import CrudMetadata
+
+
+class GeomMetadata(CrudMetadata):
+
+    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):
+
+        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)
+        polygon_column = table.c[polygon_column_name]
+        result = self._intersects(table=table, connection=connection, polygon_column=polygon_column, polygon_column_srid=polygon_column_srid, geom=geom, tolerance=tolerance, where=where, not_where=not_where,
+                                  columns=columns, limit=limit, geom_srid=geom_srid, intersection=intersection, intersection_area=intersection_area)
+        return self._return(connection=connection, result=result, keep_open=keep_open, commit=False, parsing_model=parsing_model)
+
+    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):
+        if where is None:
+            where = {}
+        if not_where is None:
+            not_where = {}
+
+        stmt = self._select(table, columns)
+
+        intersecting_geom = self._geom_condition(geom=geom, geom_srid=geom_srid, polygon_column_srid=polygon_column_srid, buffer=tolerance)
+
+        if intersection:
+            stmt = stmt.add_columns(polygon_column.ST_Intersection(intersecting_geom).label("intersection"))
+        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()])
+
+        geom_condition = polygon_column.ST_Intersects(intersecting_geom)
+
+        eq_where.append(geom_condition)
+
+        stmt = stmt.where(*eq_where)
+
+        stmt = self._add_limit_offset_condition(stmt, limit)
+        return self.execute(connection=connection, stmt=stmt, mapping=True)
+
+    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):
+
+        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)
+        polygon_column = table.c[polygon_column_name]
+        result = self._contains(table=table, connection=connection, polygon_column=polygon_column, polygon_column_srid=polygon_column_srid, geom=geom, tolerance=tolerance, where=where, contained=contained,
+                                columns=columns, limit=limit, geom_srid=geom_srid)
+        return self._return(connection=connection, result=result, keep_open=keep_open, commit=False, parsing_model=parsing_model)
+
+    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):
+        if columns is None:
+            columns = []
+        if where is None:
+            where = {}
+
+        stmt = self._select(table, columns)
+        eq_where = [self._eq_where(table.c[column], condition) for column, condition in where.items()]
+
+        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)
+
+        eq_where.append(geom_condition)
+
+        stmt = stmt.where(*eq_where)
+        stmt = self._add_limit_offset_condition(stmt, limit)
+        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):
+        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
+
+        return geom_condition

general/interface/repository/__init__.py

@@ -0,0 +1,4 @@
+from .crud_repository import *
+from .geometry_repository import *
+from .many_to_many_repository import *
+from .view_repository import *

general/interface/repository/crud_repository.py

@@ -0,0 +1,272 @@
+__all__ = ["CrudRepository"]
+
+import logging
+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.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 ...exception.crud_exceptions import HasNoAttributeException, EntityNotFoundException, ServiceUnavailableException, BadRequestException
+from ...interface.base.declarative_base import Base
+from ...paginator_dto import PaginatorResponseModel
+
+
+class CrudRepository[Entity: Base | Type[Base]]:
+    __slots__ = "model", "entity", "engine", "columns", "handler", "relationship_attributes"
+
+    model: Type[BaseModel] | BaseModel
+    entity: Entity
+    engine: Type[Engine] | Engine
+    handler: Type[BaseHandler] | BaseHandler
+
+    @property
+    def open_session(self):
+        return Session(self.engine)
+
+    def __init__(self, entity: Entity, model: Type[BaseModel] | BaseModel, engine: Type[Engine] | Engine, handler_class: Type[BaseHandler] | BaseHandler = None) -> None:
+        self.entity = entity
+        self.model = model
+        self.engine = engine
+        self.columns = self.entity.columns()
+
+        self.handler = handler_class(self.columns) if handler_class else BaseHandler(self.columns)
+
+    # -------------------------
+
+    def _handle_exception(self, session: Session, e: Exception):
+        session.close()
+        logging.error(e)
+        match e:
+            case OperationalError():
+                raise ServiceUnavailableException()
+            case NoResultFound():
+                raise EntityNotFoundException()
+            case DataError() | IntegrityError():
+                raise BadRequestException()
+            case _:
+                raise e
+
+    def commit(self, session: Session):
+        try:
+            session.commit()
+        except Exception as e:
+            self._handle_exception(session, e)
+
+    def _entity_has_columns(self, *columns: Iterable[str], entity: Type[Base] | Base = None):
+        return all([column in entity.columns_names() for column in columns])
+
+    def _select(self, entity: Type[Base] | Base, columns: list[str] = None, exclude_columns: list[str] = None):
+        try:
+            stmt = select(entity)
+            if columns:
+                relationship_attributes = set(entity.__mapper__.relationships.keys())
+                entity_columns = {column for column in columns if column not in relationship_attributes}
+                stmt = stmt.options(load_only(*[getattr(self.entity, column) for column in entity_columns]))
+            if exclude_columns:
+                stmt = stmt.options(defer(*[getattr(self.entity, column) for column in exclude_columns]))
+        except AttributeError:
+            raise HasNoAttributeException()
+        return stmt
+
+    def _return(self, session: Session, entities: Sequence[Row] | Sequence[Row | RowMapping | Type[Base]], keep_open: bool = False,
+                commit: bool = True, parsing_model: Type[BaseModel] | BaseModel = None) -> list[Entity] | list[BaseModel]:
+        if keep_open:
+            return entities
+        else:
+            if commit:
+                self.commit(session=session)
+            return_model = parsing_model or self.model
+            models = [return_model.model_validate(entity) for entity in entities]
+            session.close()
+        return models
+
+    def create(self):
+        if not inspect(self.engine).has_table(table_name=self.entity.__table__.name, schema=self.entity.__table__.schema):
+            try:
+                self.entity.__table__.create(self.engine)
+            except Exception as e:
+                logging.error(f"{self.entity.__table__.name} creation error - {repr(e)}")
+        else:
+            pass
+
+    def find(self, session: Session = None, where: dict[str, Any] = None, columns: list[str] = None, exclude_columns: list[str] = None, limit: int = 0, parsing_model: Type[BaseModel] = None, **kwhere) -> list[Entity]:
+        keep_open = False if session is None else True
+        session = self.open_session if session is None else session
+        entities = self._find(session=session, where=where, columns=columns, exclude_columns=exclude_columns, limit=limit, **kwhere)
+        return self._return(session=session, entities=entities, keep_open=keep_open, commit=False, parsing_model=parsing_model)
+
+    def _find(self, session: Session, where: dict[str, Any] = None, columns: list[str] = None, exclude_columns: list[str] = None, limit: int = 0, **kwhere):
+        if where is None:
+            where = kwhere if kwhere else {}
+        stmt = self._select(entity=self.entity, columns=columns, exclude_columns=exclude_columns)
+        stmt = self.handler.prepare_statement(stmt=stmt, **where)
+        stmt = self.handler.limit_offset_condition(stmt=stmt, limit=limit)
+        return self.execute(session, stmt)
+
+    def insert(self, session: Session = None, models: list[Type[BaseModel] | BaseModel] = None, returning: bool = True, parsing_model: Type[BaseModel] | BaseModel = None) -> list[Entity]:
+        keep_open = False if session is None else True
+        session = self.open_session if session is None else session
+        entities = self._insert(session=session, models=models, returning=returning)
+        return self._return(session=session, entities=entities, keep_open=keep_open, commit=True, parsing_model=parsing_model)
+
+    def _insert(self, session: Session, models: list[Type[BaseModel] | BaseModel] = None, returning: bool = True):
+        if models is None:
+            models = []
+        values = [model.model_dump(exclude_none=True) for model in models]
+        if values:
+            stmt = insert(self.entity)
+            stmt = stmt if not returning else stmt.returning(self.entity)
+            return self.execute(session=session, stmt=stmt, values=values)
+        else:
+            return []
+
+    def add(self, session: Session = None, entities: list[Type[Base]] = None, parsing_model: Type[BaseModel] | BaseModel = None):
+        keep_open = False if session is None else True
+        session = self.open_session if session is None else session
+        try:
+            session.add_all(entities)
+        except Exception as e:
+            self._handle_exception(session, e)
+        return self._return(session=session, entities=entities, keep_open=keep_open, commit=True, parsing_model=parsing_model)
+
+    def update(self, session: Session = None, where: dict[str, Any] = None, returning: bool = True, parsing_model: Type[BaseModel] | BaseModel = None, **kwargs) -> list[Entity]:
+        keep_open = False if session is None else True
+        session = self.open_session if session is None else session
+        entities = self._update(session=session, where=where, returning=returning, **kwargs)
+        return self._return(session=session, entities=entities, keep_open=keep_open, commit=True, parsing_model=parsing_model)
+
+    def _update(self, session: Session, where: dict[str, Any] = None, returning: bool = True, **kwargs):
+        if where is None:
+            where = {}
+        stmt = update(self.entity)
+        stmt = self.handler.prepare_statement(stmt=stmt, **where)
+
+        stmt = stmt.values(**kwargs)
+        stmt = stmt if not returning else stmt.returning(self.entity)
+        return self.execute(session, stmt)
+
+    def delete(self, session: Session = None, where: dict[str, Any] = None, **kwhere) -> int:
+        keep_open = False if session is None else True
+        session = self.open_session if session is None else session
+        num_rows = self._delete(session=session, where=where, **kwhere)
+        if not num_rows or keep_open:
+            return num_rows
+        else:
+            self.commit(session)
+        session.close()
+        return num_rows
+
+    def _delete(self, session: Session, where: dict[str, Any] = None, **kwhere):
+        if where is None:
+            where = kwhere if kwhere else {}
+        stmt = delete(self.entity)
+        stmt = self.handler.prepare_statement(stmt=stmt, **where)
+        try:
+            result = session.execute(stmt)
+        except Exception as e:
+            self._handle_exception(session, e)
+        else:
+            return result.rowcount
+
+    def upsert(self, session: Session = None, models: list[Type[BaseModel] | BaseModel] = None, parsing_model: Type[BaseModel] | BaseModel = None) -> list[Entity]:
+        keep_open = False if session is None else True
+        session = self.open_session if session is None else session
+        entities = self._upsert(session=session, models=models)
+        return self._return(session=session, entities=entities, keep_open=keep_open, commit=True, parsing_model=parsing_model)
+
+    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
+            else:
+                updates[i] = session.get(self.entity, pks)
+        inserts = [models[i] for i in range(len(models)) if i not in updates.keys()]
+
+        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())
+
+        return result
+
+    def count(self, session: Session = None, where: dict[str, Any] = None, **kwhere):
+        keep_open = False if session is None else True
+        session = self.open_session if session is None else session
+        count_ = self._count(session=session, where=where, **kwhere)
+        if keep_open:
+            pass
+        else:
+            session.close()
+        return count_
+
+    def _count(self, session: Session, where: dict[str, Any] = None, **kwhere):
+        pk = self.entity.primary_key()[0]
+        if where is None:
+            where = kwhere if kwhere else {}
+        stmt = select(count(pk))
+        stmt = self.handler.prepare_statement(stmt=stmt, **where)
+        result = session.execute(stmt).all()[0]
+        return result[0]
+
+    def _preconf_count(self, session: Session, where: Optional[ColumnElement[Any]]):
+        pk = self.entity.primary_key()[0]
+        stmt = select(count(pk))
+
+        stmt = stmt.where(where)
+        result = session.execute(stmt).all()[0]
+        return result[0]
+
+    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]:
+        keep_open = False if session is None else True
+        session = self.open_session if session is None else session
+        paginated = self._paging_find(session=session, where=where, columns=columns, exclude_columns=exclude_columns, limit=limit, page=page, order_by=order_by, asc=asc, **kwhere)
+        if not keep_open:
+            paginated.data = [parsing_model.model_validate(entity) for entity in paginated.data] if parsing_model else [self.model.model_validate(entity) for entity in paginated.data]
+            session.close()
+        return paginated
+
+    def _paging_find(self, session: Session, 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, **kwhere):
+        if where is None:
+            where = kwhere if kwhere else {}
+        stmt = self._select(entity=self.entity, columns=columns, exclude_columns=exclude_columns)
+        stmt = self.handler.prepare_statement(stmt=stmt, **where)
+
+        row_numbers = self._preconf_count(session=session, where=stmt.whereclause)
+
+        stmt = self.handler.limit_offset_condition(stmt=stmt, limit=limit, page=page)
+        if order_by:
+            stmt = self.handler.order_by_condition(stmt=stmt, order_by=order_by, asc=asc)
+
+        entities = self.execute(session, stmt)
+        return self.parse_pagination(limit=limit, page=page, order_by=order_by, count=row_numbers, asc=asc, data=entities)
+
+    def parse_pagination(self, limit: int, page: int, order_by: str, asc: bool, count: int, data: Sequence[Row] | Sequence[Row | RowMapping] | Sequence[RowMapping]) -> PaginatorResponseModel:
+        limit = limit if limit else len(data)
+        order_by = order_by if order_by else self.entity.primary_key()[0].name
+        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, data=data)
+
+    def execute(self, session: Session, stmt: Select | Insert | Update | Delete, values: Sequence[Mapping[str, Any]] | Mapping[str, Any] = None):
+        try:
+            result = session.execute(statement=stmt, params=values)
+        except Exception as e:
+            self._handle_exception(session, e)
+        else:
+            rows = result.scalars().all()
+            return rows

general/interface/repository/geometry_repository.py

@@ -0,0 +1,103 @@
+__all__ = ["GeometryRepository"]
+
+from typing import Any, Type
+
+from geoalchemy2 import WKBElement, Geometry
+from pydantic import BaseModel
+from sqlalchemy import literal_column, Column
+from sqlalchemy.orm import Session
+
+from .crud_repository import CrudRepository
+from ..base import Base
+
+
+class GeometryRepository[Entity: Base | Type[Base]](CrudRepository[Entity]):
+    __slots__ = "geom_column"
+    geom_column: Column[Geometry]
+
+    @property
+    def geom_srid(self):
+        return self.geom_column.type.srid
+
+    def intersects(self, geom: WKBElement, session: Session = None, tolerance: float = 0.0, columns: list[str] = None, exclude_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) -> list[Entity]:
+
+        keep_open = False if session is None else True
+        session = self.open_session if session is None else session
+        entities = self._intersects(session=session, geom=geom, tolerance=tolerance, where=where, not_where=not_where, columns=columns, exclude_columns=exclude_columns, limit=limit, geom_srid=geom_srid)
+        return self._return(session=session, entities=entities, keep_open=keep_open, commit=False, parsing_model=parsing_model)
+
+    def _intersects(self, session: Session, geom: WKBElement, tolerance: float = 0.0, columns: list[str] = None, exclude_columns: list[str] = None, where: dict[str, Any] = None, not_where: dict[str, Any] = None,
+                    limit: int = 0, geom_srid: int = 4326):
+        if where is None:
+            where = {}
+        if not_where is None:
+            not_where = {}
+
+        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)
+
+        stmt = self.handler.prepare_statement(stmt=stmt, **where)
+        stmt = self.handler.prepare_statement(stmt=stmt, neq=True, **not_where)
+
+        stmt = stmt.where(self.geom_column.ST_Intersects(intersecting_geom))
+        stmt = self.handler.limit_offset_condition(stmt=stmt, limit=limit)
+
+        return self.execute(session, stmt)
+
+    def contains(self, geom: WKBElement, session: Session = None, tolerance: float = 0.0, columns: list[str] = None, exclude_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) -> list[Entity]:
+
+        keep_open = False if session is None else True
+        session = self.open_session if session is None else session
+        entities = self._contains(session=session, geom=geom, tolerance=tolerance, where=where, contained=contained, columns=columns, exclude_columns=exclude_columns, limit=limit, geom_srid=geom_srid)
+        return self._return(session=session, entities=entities, keep_open=keep_open, commit=False, parsing_model=parsing_model)
+
+    def _contains(self, session: Session, geom: WKBElement, tolerance: float = 0.0, columns: list[str] = None, exclude_columns: list[str] = None, where: dict[str, Any] = None, limit: int = 0, contained: bool = False,
+                  geom_srid: int = 4326):
+        if where is None:
+            where = {}
+
+        stmt = self._select(entity=self.entity, columns=columns, exclude_columns=exclude_columns)
+        stmt = self.handler.prepare_statement(stmt=stmt, **where)
+
+        geom_condition = self._geom_condition(geom=geom, geom_srid=geom_srid, buffer=tolerance)
+        geom_condition = self.geom_column.ST_Contains(geom_condition) if not contained else geom_condition.ST_Contains(self.geom_column)
+
+        stmt = stmt.where(geom_condition)
+
+        stmt = self.handler.limit_offset_condition(stmt=stmt, limit=limit)
+        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]:
+        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)
+        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):
+        if where is None:
+            where = {}
+        stmt = self._select(entity=self.entity, columns=columns, exclude_columns=exclude_columns)
+
+        geom_condition = self._geom_condition(geom=geom, geom_srid=geom_srid)
+
+        distance_col = self.geom_column.ST_Distance(geom_condition).label("distance")
+
+        if distance:
+            stmt = stmt.add_columns(distance_col)
+
+        stmt = self.handler.prepare_statement(stmt=stmt, **where)
+        stmt = stmt.order_by(literal_column("distance"))
+        stmt = self.handler.limit_offset_condition(stmt=stmt, limit=limit)
+
+        rows = self.execute(session, stmt)
+        return rows
+
+    def _geom_condition(self, geom: WKBElement, geom_srid: int = 4326, buffer: float = 0):
+        geom_condition = geom.ST_Transform(self.geom_srid) if geom_srid != self.geom_srid else geom
+        geom_condition = geom_condition.ST_Buffer(buffer) if buffer else geom_condition
+
+        return geom_condition

general/interface/repository/handler/__init__.py

@@ -0,0 +1,2 @@
+from .base_handler import *
+from .ilike_handler import *

general/interface/repository/handler/base_handler.py

@@ -0,0 +1,40 @@
+__all__ = ["BaseHandler"]
+
+from typing import Any
+
+from sqlalchemy import Select, Update, Delete, Column, not_
+from sqlalchemy.sql.base import ReadOnlyColumnCollection
+
+from ....exception.crud_exceptions import HasNoAttributeException
+
+
+class BaseHandler:
+    __slots__ = "columns"
+
+    def __init__(self, columns: ReadOnlyColumnCollection[str, Column[Any]]):
+        self.columns = columns
+
+    def prepare_statement(self, stmt: Select | Update | Delete, neq: bool = False, **where):
+        stmt = stmt.where(*[self.handle(column=self.columns[column], condition=condition, neq=neq) for column, condition in where.items()])
+        return stmt
+
+    def order_by_condition(self, stmt: Select, order_by: str, asc: bool):
+        try:
+            stmt = stmt.order_by(self.columns[order_by].asc()) if asc else stmt.order_by(self.columns[order_by].desc())
+        except KeyError:
+            raise HasNoAttributeException(order_by)
+        return stmt
+
+    def limit_offset_condition(self, stmt: Select, limit: int, page: int = None):
+        if limit and limit > 0:
+            stmt = stmt.limit(limit)
+            if page and page > 0:
+                offset = (page - 1) * limit
+                stmt = stmt.offset(offset)
+        return stmt
+
+    def handle(self, column: Column, condition: Any, neq: bool = False):
+        eq_where = column.in_(condition) if isinstance(condition, list) else column == condition if str(column.type) != "ARRAY" else condition == column.any_()
+        if neq:
+            eq_where = not_(eq_where)
+        return eq_where

general/interface/repository/handler/ilike_handler.py

@@ -0,0 +1,38 @@
+__all__ = ["ILikeHandler"]
+
+from typing import Any
+
+from sqlalchemy import Column, Select, Update, Delete, or_
+from sqlalchemy.sql.base import ReadOnlyColumnCollection
+
+from .base_handler import BaseHandler
+
+
+class ILikeHandler(BaseHandler):
+    __slots__ = "ilike_aliases", "ilike_attributes"
+    ilike_aliases: list[str]
+    ilike_attributes: list[str]
+
+    def __init__(self, columns: ReadOnlyColumnCollection[str, Column[Any]], ilike_aliases: list[str] = None, ilike_attributes: list[str] = None):
+        self.columns = columns
+        self.ilike_aliases = ilike_aliases if not ilike_aliases else []
+        self.ilike_attributes = ilike_attributes if not ilike_attributes else []
+
+    def prepare_statement(self, stmt: Select | Update | Delete, **where):
+        ilike_values = self.retrieve_ilike_values(where)
+        ilike_conditions = [self._ilike_condition(ilike_value) for _, ilike_value in ilike_values]
+
+        stmt = super().prepare_statement(stmt=stmt, **where)
+        stmt = stmt.where(*ilike_conditions)
+        return stmt
+
+    def _ilike_condition(self, condition):
+        return or_(*[self.columns[col].ilike(f'%{condition}%') for col in self.ilike_attributes])
+
+    def retrieve_ilike_values(self, where: dict[str, Any]):
+        ilike_values = []
+        for alias in self.ilike_aliases:
+            condition = where.pop(alias, None)
+            if condition:
+                ilike_values.append((alias, condition))
+        return ilike_values

general/interface/repository/handler/interval_handler.py

@@ -0,0 +1,34 @@
+from typing import Any
+
+from sqlalchemy import Column, Select, Update, Delete, or_
+from sqlalchemy.sql.base import ReadOnlyColumnCollection
+
+from .base_handler import BaseHandler
+
+
+class IntervalHandler(BaseHandler):
+    __slots__ = "from_", "to_", "inf_is_none"
+    from_: Any
+    to_: Any
+    inf_is_none: bool
+
+    def __init__(self, columns: ReadOnlyColumnCollection[str, Column[Any]], from_: Any = None, to_: Any = None, inf_is_none: bool = None):
+        self.columns = columns
+        self.from_ = from_
+        self.to_ = to_
+        self.inf_is_none = inf_is_none
+
+    def prepare_statement(self, stmt: Select | Update | Delete, **where):
+
+        from_condition = where.pop(self.from_, None)
+        to_condition = where.pop(self.from_, None)
+
+        stmt = super().prepare_statement(stmt=stmt, **where)
+        if from_condition:
+            stmt = stmt.where(self.columns[self.from_] >= from_condition)
+        if to_condition:
+            condition = self.columns[self.to_] <= to_condition
+            if self.inf_is_none:
+                condition = or_(condition, self.columns[self.to_] == None)
+            stmt = stmt.where(condition)
+        return stmt

general/interface/repository/many_to_many_repository.py

@@ -0,0 +1,101 @@
+__all__ = ["ManyToManyRepository"]
+
+from typing import Type, Any
+
+from pydantic import BaseModel
+from sqlalchemy.orm import Session
+
+from .crud_repository import CrudRepository
+from ...interface.base import Base
+
+
+class ManyToManyRepository[Entity: Base | Type[Base]](CrudRepository[Entity]):
+
+    def diff_upsert_from_parent(self, session: Session, parent: Type[Base], children: list[Type[BaseModel]], relationship_attribute: str, child_fks: dict[str, Any], child_pk: str = "id") -> list[Entity]:
+        ids = {getattr(child, child_pk) for child in children if getattr(child, child_pk)}
+        for child in getattr(parent, relationship_attribute):
+            if getattr(child, child_pk) not in ids:
+                session.delete(child)
+
+        for model in children:
+            for key, value in child_fks.items():
+                setattr(model, key, value)
+
+        entities = self.upsert(session=session, models=children)
+
+        return entities
+
+    def diff_update_from_parent(self, session: Session, parent: Type[Base], children: list[Type[BaseModel]], relationship_attribute: str) -> list[Entity]:
+        relationship_children = getattr(parent, relationship_attribute)
+        current_size = len(relationship_children)
+        size_updating = len(children)
+        diff = size_updating - current_size
+
+        if diff > 0:
+            self._apply_updates(entities=relationship_children, models=children, count=current_size)
+            entities = self.insert(session=session, models=children[current_size:])
+            entities.extend(relationship_children)
+        elif diff < 0:
+            self._apply_updates(entities=relationship_children, models=children, count=size_updating)
+            for cp in relationship_children[size_updating:]:
+                session.delete(cp)
+            entities = relationship_children[:size_updating]
+        else:
+            self._apply_updates(entities=relationship_children, models=children, count=current_size)
+            entities = relationship_children
+        return entities
+
+    def diff_update_left_right(self, session: Session, parent: Type[Base], children: list[Type[BaseModel]], relationship_attribute: str, left_fks: dict[str, Any], right_fks: list[str]) -> list[Entity]:
+        """
+
+        :param session:
+        :param parent:
+        :param children:
+        :param relationship_attribute:
+        :param left_fks: attributi da aggiornare sui figli da inserire
+        :param right_fks: attributi da aggiornare sui figli già presenti
+        :return:
+        """
+        size_new = len(children)
+
+        relationship_children = getattr(parent, relationship_attribute)
+
+        size = len(relationship_children)
+        entities = []
+        if size_new < size:
+            for r_child in relationship_children[size_new:]:
+                session.delete(r_child)
+        elif size < size_new:
+            for i in range(size, size_new):
+                for key, value in left_fks.items():
+                    setattr(children[i], key, value)
+            entities = self.insert(session=session, models=children[size:size_new])
+            size_new = size
+        for i in range(size_new):
+            for key in right_fks:
+                setattr(relationship_children[i], key, getattr(children[i], key))
+        entities.extend(relationship_children[:size_new])
+        return entities
+
+    def diff_update(self, session: Session, entities: list[Type[Base]], models: list[Type[BaseModel]]) -> list[Entity]:
+        current_size = len(entities)
+        new_size = len(models)
+
+        diff = new_size - current_size
+
+        if diff > 0:
+            self._apply_updates(entities=entities, models=models, count=current_size)
+            entities.extend(self.insert(session=session, models=models[current_size:]))
+        elif diff < 0:
+            self._apply_updates(entities=entities, models=models, count=new_size)
+            for entity in entities[new_size:]:
+                session.delete(entity)
+            entities = entities[:new_size]
+        else:
+            self._apply_updates(entities=entities, models=models, count=current_size)
+        return entities
+
+    def _apply_updates(self, entities: list[Type[Base]], models: list[Type[BaseModel]], count: int):
+        for i in range(count):
+            for attr, value in models[i].model_dump(exclude_none=True).items():
+                setattr(entities[i], attr, value)

general/interface/repository/view_repository.py

@@ -0,0 +1,57 @@
+__all__ = ["ViewRepository"]
+
+import logging
+from time import time
+from typing import Type
+
+from geoalchemy2 import Geometry
+from sqlalchemy import text
+
+from .crud_repository import CrudRepository
+from ..base import Base
+
+
+class ViewRepository[Entity: Base | Type[Base]](CrudRepository[Entity]):
+    select_stmt: str
+    materialized: bool = False
+
+    @property
+    def view_name(self):
+        return f"{self.entity.__table_args__['schema']}.{self.entity.__tablename__}"
+
+    def create(self, drop_before: bool = False, visualizer_db_role: str = None):
+        logging.info(f"Creating view {self.view_name}")
+        start = time()
+        stmts = []
+
+        try:
+            if drop_before:
+                drop_stmt = f"drop materialized view if exists {self.view_name} cascade;" if self.materialized else f"drop view if exists {self.view_name} cascade;"
+                stmts.append(drop_stmt)
+            create_stmt = f"create materialized view if not exists {self.view_name} as {self.select_stmt};" if self.materialized else f"create or replace view {self.view_name} as {self.select_stmt};"
+            stmts.append(create_stmt)
+            if self.materialized:
+                unique_id_index = f"create unique index on {self.view_name} ({self.entity.primary_key()[0].name});"
+                stmts.append(unique_id_index)
+            if visualizer_db_role and any([isinstance(col.type, Geometry) for col in self.entity.columns()]):
+                grant_visualized = f"grant select on table {self.view_name} to {visualizer_db_role}"
+                stmts.append(grant_visualized)
+
+            with self.open_session as session:
+                for stmt in stmts:
+                    session.execute(text(stmt))
+                    session.flush()
+                session.commit()
+            logging.info(f"Created {self.view_name} in {time() - start}")
+        except Exception as e:
+            logging.error(f"{self.entity.__table__.name} creation error - {repr(e)}")
+
+    def refresh_materialized_view(self, concurrently: bool = True):
+        logging.info(f"Refreshing {self.view_name}")
+        start = time()
+        stmt_str = f"refresh materialized view concurrently {self.view_name}" if concurrently else f"refresh materialized view {self.view_name}"
+        stmt = text(stmt_str)
+        with self.open_session as session:
+            session.execute(stmt)
+            session.commit()
+        logging.info(f"Refreshed {self.view_name} in {time() - start}")

general/log_config.ini

@@ -0,0 +1,21 @@
+[loggers]
+keys = root
+
+[handlers]
+keys = logconsole
+
+[formatters]
+keys = logformatter
+
+[logger_root]
+level = INFO
+handlers = logconsole
+
+[formatter_logformatter]
+format = [%(asctime)s] %(levelname)s - %(message)s
+
+[handler_logconsole]
+class = handlers.logging.StreamHandler
+level = INFO
+args = ()
+formatter = logformatter

general/logger.py

@@ -0,0 +1,54 @@
+import logging
+import logging.config
+from datetime import datetime
+from time import time
+
+from fastapi import HTTPException
+
+from .exception.crud_exceptions import InternalServerException
+
+__all__ = ["init_logger", "log"]
+
+COLOR = {
+    "HEADER": "\033[95m",
+    "BLUE": "\033[94m",
+    "GREEN": "\033[92m",
+    "RED": "\033[91m",
+    "ENDC": "\033[0m",
+}
+
+color = COLOR['BLUE']
+end_color = COLOR['ENDC']
+exc_color = COLOR['RED']
+
+
+class EndpointFilter(logging.Filter):
+    def __init__(self, endpoint: str = '', *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.endpoint = endpoint
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        return record.getMessage().find(self.endpoint) == -1
+
+
+def init_logger(*filtering_endpoints: str):
+    logging.config.fileConfig(fname="./general/log_config.ini", disable_existing_loggers=True)
+    logging.info("Logger setted up")
+    [logging.getLogger("uvicorn.access").addFilter(EndpointFilter(filtering_endpoint)) for filtering_endpoint in filtering_endpoints]
+
+
+def log(func):
+    def wrapper(*args, **kwargs):
+        func_name = f"{func.__name__}"
+        start = time()
+        logging.info(f"[{datetime.now().strftime('%Y-%m-%d %H:%M')}] {color} {func_name} {end_color}| args: {args} | kwargs: {kwargs}")
+        try:
+            result = func(*args, **kwargs)
+        except Exception as e:
+            logging.exception(f"[{datetime.now().strftime('%Y-%m-%d %H:%M')}] Exception {exc_color} {func_name} {end_color}: {repr(e)}")
+            raise e.with_traceback(None) if isinstance(e, HTTPException) else InternalServerException(repr(e))
+        else:
+            logging.info(f"{color} {func_name} {end_color} completed in {time() - start} seconds")
+        return result
+
+    return wrapper

general/paginator_dto.py

@@ -0,0 +1,23 @@
+__all__ = ["PaginatorRequestModel", "PaginatorResponseModel"]
+
+from typing import Optional
+
+from pydantic import Field
+
+from .interface.base.base_model import ExtBaseModel
+
+
+class PaginatorBaseModel(ExtBaseModel):
+    page: int = Field(alias="numeroPagina")
+    limit: Optional[int] = Field(default=None, alias="numeroElementi")
+    order_by: Optional[str] = Field(default=None, alias="campoOrdinamento")
+    asc: bool = Field(alias="crescente")
+
+
+class PaginatorRequestModel(PaginatorBaseModel):
+    pass
+
+
+class PaginatorResponseModel[ResponseType](PaginatorBaseModel):
+    tot_pages: int = Field(alias="pagineTotali")
+    data: list[ResponseType]

python_general_be_lib-0.1.0.dist-info/METADATA

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: python-general-be-lib
+Version: 0.1.0
+Summary: General purpose backend library — SQLAlchemy CRUD/Geometry repositories, FastAPI exceptions, Pydantic base models, logger utilities.
+Author-email: Andrea Di Placido <a.diplacido@arpes.it>, "Arpes S.r.l." <it.admin@arpes.it>
+License: MIT
+Project-URL: Homepage, https://github.com/Arpes-IS/python-general-be-lib
+Project-URL: Repository, https://github.com/Arpes-IS/python-general-be-lib
+Keywords: backend,sqlalchemy,fastapi,pydantic,repository,crud,geoalchemy2
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Database
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: sqlalchemy>=2.0.0
+Requires-Dist: geoalchemy2>=0.14.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+Dynamic: requires-python
+
+# python-general-be-lib

python_general_be_lib-0.1.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+general/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+general/log_config.ini,sha256=-uFliGt3D0PYauup7XGJ-B87JF1AvkiS8IakwubNYs8,321
+general/logger.py,sha256=WAghhs-qU3mkN7GFQxHWXv8_iTWltX8z645pp0vYEwU,1776
+general/paginator_dto.py,sha256=5goyGpg5SPAkDaw8yVXmpWB-9M5vlXBD-Tt_GIuKJCc,650
+general/exception/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+general/exception/access_exceptions.py,sha256=8AV4_gybcdA7mTpA2XiZdl9rRGx08QCjHpBGv60EL4I,300
+general/exception/crud_exceptions.py,sha256=c-VlatTPjEp7FWzA7rDByqfMqsEOworJqqfUJ3s0Z2w,1101
+general/exception/exception_interface.py,sha256=T4bq8jwZ1YFpGlP60TxbvhkcyIrfsjcw5I6Xlxvzjig,352
+general/interface/base/__init__.py,sha256=SDlTi28M8rzJ9yiKefo5l7V3K109LnnBHW-SuZ-5JtM,58
+general/interface/base/base_model.py,sha256=kRJPFxmX55DMjrd7CD6GbW7j9-V1vS6sCjw_RVn72cY,700
+general/interface/base/declarative_base.py,sha256=n6XqkL7UHUwYfI7lJ9MhOJ85E9yn1Uc6GiKIKziju9c,2014
+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/repository/__init__.py,sha256=EcRukwf61Ua-9-JfM_ingVv1wXNRV8HBrrWwjj8m23w,136
+general/interface/repository/crud_repository.py,sha256=OR0mlVnoUvRDuxTwvNTEHvmUfgW8aHVuASxVe-RSm70,13577
+general/interface/repository/geometry_repository.py,sha256=Rfmmzlt_U5iai0syS28jMxFpgfsJLO2im0AAiphXwXg,5756
+general/interface/repository/many_to_many_repository.py,sha256=66EOFWdt7iKYmDI-f9MqQRKV1kuiL7NwJts0extL81g,4410
+general/interface/repository/view_repository.py,sha256=amohSpucY20R6IE5ZSi1OpgzkLostZKxfI56eJOP4NY,2482
+general/interface/repository/handler/__init__.py,sha256=sJK6s-siQisHdz8Z3Ymeid4mSyuXt8ysQC6b0cE44OI,57
+general/interface/repository/handler/base_handler.py,sha256=cmi2TOfuMX-CRmBaLzNnC9k-Pua8wd3zLlnByUIGX10,1555
+general/interface/repository/handler/ilike_handler.py,sha256=dDXSsQR7cROh5azT3lt6zOTvNiD_r17_19NE1EQwOrE,1471
+general/interface/repository/handler/interval_handler.py,sha256=c_Ovh_q_M_A7etE4RuW-uNZFXw774_v4pTNsF1joe4A,1173
+python_general_be_lib-0.1.0.dist-info/licenses/LICENSE,sha256=iUaO1XZyB9P3Tmog0OILuTisP6vXGe3QKz-4yRTxOFk,1069
+python_general_be_lib-0.1.0.dist-info/METADATA,sha256=kDs3MuObw93NClCJM22Ot3B3mgff-wzopuC0JkfSyHY,1384
+python_general_be_lib-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+python_general_be_lib-0.1.0.dist-info/top_level.txt,sha256=tTZePW8_CNUqSgKFd2SEH72ZbnhS0OYjRsgcv0ikSFY,8
+python_general_be_lib-0.1.0.dist-info/RECORD,,

python_general_be_lib-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

python_general_be_lib-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Arpes S.r.l.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

python_general_be_lib-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+general