python-general-be-lib 0.10.0__tar.gz → 0.10.0.post2__tar.gz

{python_general_be_lib-0.10.0 → python_general_be_lib-0.10.0.post2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-general-be-lib
-Version: 0.10.0
+Version: 0.10.0.post2
 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.10.0.post2/general/interface/mixin/timestamp_mixin.py

@@ -0,0 +1,42 @@
+__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.
+
+    Both timestamps carry **two** defaults, and both are needed. ``server_default`` is a
+    DDL clause: it ends up in the ``CREATE TABLE`` and covers the rows inserted outside the
+    library, by a migration or by hand — but only on the tables the library creates
+    afterwards. On a table that already exists the column has no such clause, and since
+    SQLAlchemy omits a ``server_default`` column from the INSERT expecting the database to
+    fill it, the write would fail on the ``NOT NULL``. The ``default`` is what covers that
+    case: being a SQL expression it is rendered inline in the INSERT, so the value comes
+    from the database clock either way, and no DDL is required.
+
+    ``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, default=func.now(), server_default=func.now(), nullable=False)
+    write_date = Column(DateTime, default=func.now(), server_default=func.now(), onupdate=func.now(), nullable=False)

{python_general_be_lib-0.10.0 → python_general_be_lib-0.10.0.post2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-general-be-lib"
-version = "0.10.0"
+version = "0.10.0-2"
 description = "General purpose backend library — SQLAlchemy CRUD/Geometry repositories, FastAPI exceptions, Pydantic base models, logger utilities."
 readme = "README.md"
 license = { text = "MIT" }

{python_general_be_lib-0.10.0 → python_general_be_lib-0.10.0.post2}/python_general_be_lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-general-be-lib
-Version: 0.10.0
+Version: 0.10.0.post2
 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.10.0 → python_general_be_lib-0.10.0.post2}/tests/test_mixin.py

@@ -144,6 +144,41 @@ def test_una_riga_inserita_fuori_dalla_libreria_ha_i_timestamp(repo, sqlite_engi
 # ------------------------------------------------------------------------ update
 
 
+def test_i_timestamp_funzionano_su_una_tabella_gia_esistente(sqlite_engine: Engine) -> None:
+    """Regressione: ``server_default`` da solo non basta su una tabella preesistente.
+
+    ``server_default`` è una clausola **DDL**: finisce nel ``CREATE TABLE`` e riguarda solo
+    le tabelle che la libreria crea dopo l'aggiunta del mixin. Su una tabella che esiste
+    già la colonna non ha quel ``DEFAULT``, e siccome SQLAlchemy **omette** dall'INSERT le
+    colonne con un ``server_default`` — aspettandosi che le riempia il database — la
+    scrittura falliva sul ``NOT NULL``, cioè con un 400.
+
+    Il rimedio è il secondo default, quello Python-side: essendo un'espressione SQL viene
+    reso **inline nell'INSERT**, quindi il valore arriva dall'orologio del database senza
+    dipendere dal DDL. I due default coesistono e coprono casi diversi.
+    """
+    with sqlite_engine.begin() as connessione:
+        connessione.exec_driver_sql("drop table if exists articolo_preesistente")
+        connessione.exec_driver_sql("""create table articolo_preesistente (
+            id integer primary key, titolo varchar(100),
+            create_date datetime not null, write_date datetime not null,
+            create_uid varchar, write_uid varchar)""")
+
+    class ArticoloPreesistente(Base, TimestampMixin, AuditMixin):
+        __tablename__ = "articolo_preesistente"
+
+        id = Column(Integer, primary_key=True, autoincrement=False)
+        titolo = Column(String(100))
+
+    repository = CrudRepository(entity=ArticoloPreesistente, model=ArticoloModel, engine=sqlite_engine)
+    repository.insert(models=[ArticoloModel(id=1, titolo="su tabella vecchia")])
+
+    with sqlite_engine.connect() as connessione:
+        valori = dict(connessione.execute(select(ArticoloPreesistente.__table__)).mappings().first())
+    assert valori["create_date"] is not None
+    assert valori["create_date"] == valori["write_date"]
+
+
 def test_l_update_aggiorna_solo_i_campi_di_ultima_modifica(repo, sqlite_engine: Engine) -> None:
     """``onupdate`` tocca ``updated_*`` e lascia ``created_*`` come sono.
 

{python_general_be_lib-0.10.0 → python_general_be_lib-0.10.0.post2}/tests/test_retrieve_mapper.py

@@ -59,7 +59,7 @@ class EntitaDietroAstratta(BaseAstratta):
     id = Column(Integer, primary_key=True)
 
 
-class Veicolo(Base):
+class VeicoloRetrieve(Base):
     """Radice di una gerarchia a tabella singola."""
 
     __tablename__ = "veicolo_retrieve"
@@ -70,7 +70,7 @@ class Veicolo(Base):
     __mapper_args__ = {"polymorphic_on": tipo, "polymorphic_identity": "veicolo"}
 
 
-class AutocarroRetrieve(Veicolo):
+class AutocarroRetrieve(VeicoloRetrieve):
     """Sottoclasse sulla **stessa** tabella del padre."""
 
     portata = Column(Integer)
@@ -81,13 +81,33 @@ class AutocarroRetrieve(Veicolo):
 # --------------------------------------------------- ricerca per nome di classe
 
 
+@pytest.fixture(autouse=True)
+def _nomi_non_ambigui():
+    """Fallisce subito se un altro modulo registra un'entità con gli stessi nomi.
+
+    Questo modulo cerca **per nome di classe**, che non è unico in un registry, e
+    ``Base.registry.mappers`` è un ``frozenset``: l'ordine di iterazione dipende
+    dall'identità degli oggetti e quindi cambia fra esecuzioni. Un omonimo renderebbe
+    questi test **intermittenti**, che è il modo peggiore di fallire. È già successo due
+    volte, con ``Autocarro`` e con ``Veicolo`` di ``test_to_dict.py``.
+    """
+    nostri = {"EntitaConMixin", "EntitaDietroAstratta", "AutocarroRetrieve", "VeicoloRetrieve"}
+    conteggio = {}
+    for mapper in Base.registry.mappers:
+        nome = mapper.class_.__name__
+        if nome in nostri:
+            conteggio[nome] = conteggio.get(nome, 0) + 1
+    doppioni = [nome for nome, quante in conteggio.items() if quante > 1]
+    assert not doppioni, f"nomi ambigui nel registry, rinominare le classi di prova: {doppioni}"
+
+
 @pytest.mark.parametrize(
     "nome, attesa",
     [
         ("EntitaConMixin", EntitaConMixin),
         ("EntitaDietroAstratta", EntitaDietroAstratta),
         ("AutocarroRetrieve", AutocarroRetrieve),
-        ("Veicolo", Veicolo),
+        ("VeicoloRetrieve", VeicoloRetrieve),
     ],
     ids=["con_mixin", "dietro_base_astratta", "tabella_singola", "radice"],
 )
@@ -148,12 +168,12 @@ def test_una_base_astratta_nel_progetto_non_rompe_piu_la_ricerca() -> None:
 def test_su_tabella_singola_restituisce_la_radice() -> None:
     """Più classi condividono la tabella: la risposta deve essere deterministica.
 
-    ``Veicolo`` e ``AutocarroRetrieve`` corrispondono entrambe a ``veicolo_retrieve``, e
+    ``VeicoloRetrieve`` e ``AutocarroRetrieve`` corrispondono entrambe a ``veicolo_retrieve``, e
     ``Base.registry.mappers`` è un ``frozenset``: restituire la prima trovata dipenderebbe
     dall'ordine di iterazione, stabile entro un processo ma non garantito fra processi.
     La radice della gerarchia è la risposta stabile, e quasi sempre quella cercata.
     """
-    assert retrieve_mapper_from_table("veicolo_retrieve") is Veicolo
+    assert retrieve_mapper_from_table("veicolo_retrieve") is VeicoloRetrieve
 
 
 # ---------------------------------------------------------- nessun effetto collaterale

python_general_be_lib-0.10.0/general/interface/mixin/timestamp_mixin.py

@@ -1,35 +0,0 @@
-__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)