python-general-be-lib 0.1.0__tar.gz

python_general_be_lib-0.1.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1 @@
+# python-general-be-lib

python_general_be_lib-0.1.0/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"

python_general_be_lib-0.1.0/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"

python_general_be_lib-0.1.0/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)

python_general_be_lib-0.1.0/general/interface/base/__init__.py

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

python_general_be_lib-0.1.0/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

python_general_be_lib-0.1.0/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

python_general_be_lib-0.1.0/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

python_general_be_lib-0.1.0/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

python_general_be_lib-0.1.0/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 *