pyarchinit-mini 2.4.1__tar.gz → 2.4.3__tar.gz

{pyarchinit_mini-2.4.1 → pyarchinit_mini-2.4.3}/CHANGELOG.md

@@ -1,3 +1,47 @@
+## [2.4.3] - 2026-05-18
+
+### Fixed (IT)
+- `RowProvider` e `PeriodSyncService` ora usano lo schema reale di pyarchinit
+  per `period_table` (`periodo` / `fase` / `datazione` / `sito`) invece dello
+  schema ipotetico Spec 3-bis (`period_name` / `phase_name` / `start_date` /
+  `end_date`). Risolve l'HTTP 500 "la colonna 'period_name' non esiste"
+  visto in produzione su PostgreSQL `pyarchinit_v2`.
+- `period_table` viene ora filtrato per `sito` (con fallback a righe
+  cross-site se `sito` IS NULL/''). `start_date` / `end_date` numerici non
+  esistono in produzione: nella Row dataclass restano `None` e il sort è
+  alfabetico per `(periodo, fase)`. Le date numeriche passate da `+ New
+  Row` vengono serializzate nella colonna `datazione` come `start..end`.
+- Fixture sintetica `sqlite_volterra_30us_with_periods.db` e i test
+  associati (row_provider, period_sync, state_load, integration routes)
+  rigenerati con lo schema reale.
+
+### Fixed (EN)
+- `RowProvider` and `PeriodSyncService` now use pyarchinit's real
+  `period_table` schema (`periodo` / `fase` / `datazione` / `sito`).
+  Fixes the HTTP 500 "column 'period_name' does not exist" against the
+  production PostgreSQL DB.
+- Numeric `start_date` / `end_date` are no longer expected as columns; the
+  Row dataclass leaves them `None`, rows are sorted alphabetically by
+  `(periodo, fase)`, and date inputs from the editor are serialized into
+  the existing `datazione` text column as `start..end`.
+
+## [2.4.2] - 2026-05-18
+
+### Fixed (IT)
+- `_get_session()` (Spec 3-bis endpoints) ora acquisisce la sessione DB in modo
+  lazy via `get_db_session()` se nessun before_request hook ha pre-impostato
+  `g.db_session`. Risolve l'errore HTTP 500 "g.db_session not set" che
+  bloccava load / save / + Row / Export yEd su Adarte in 2.4.0-2.4.1.
+- Aggiunto `teardown_request` sul blueprint che rilascia la sessione lazy
+  alla fine della request.
+
+### Fixed (EN)
+- `_get_session()` now lazily opens a DB session via `get_db_session()` when no
+  before_request hook has bound one to `g.db_session`. Fixes the HTTP 500
+  "g.db_session not set" that broke load / save / + Row / Export on production
+  in 2.4.0-2.4.1.
+- Added `teardown_request` hook releasing the lazy session at request end.
+
 ## [2.4.1] - 2026-05-18
 
 ### Fixed (IT)

{pyarchinit_mini-2.4.1/pyarchinit_mini.egg-info → pyarchinit_mini-2.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyarchinit-mini
-Version: 2.4.1
+Version: 2.4.3
 Summary: Lightweight archaeological data management system with REST API, Web UI, Desktop GUI, CLI, multi-user authentication, real-time collaboration, analytics dashboard, PyArchInit import/export, Heriverse/ATON export integration, and 3D CRUD viewer
 Home-page: https://github.com/enzococca/pyarchinit-mini
 Author: PyArchInit Team

{pyarchinit_mini-2.4.1 → pyarchinit_mini-2.4.3}/pyarchinit_mini/__init__.py

@@ -23,7 +23,7 @@ Features:
 - Scalable and modular architecture
 """
 
-__version__ = "2.4.1"
+__version__ = "2.4.3"
 __author__ = "PyArchInit Team"
 __email__ = "enzo.ccc@gmail.com"
 

pyarchinit_mini-2.4.3/pyarchinit_mini/harris_swimlane/period_sync_service.py

@@ -0,0 +1,111 @@
+"""PeriodSyncService — interactive row creation upserts period_table.
+
+When user creates a new swimlane row in the editor, this service ensures
+a corresponding ``period_table`` entry exists. Uses the real pyarchinit
+schema: ``periodo`` / ``fase`` / ``datazione`` (NO numeric start/end columns).
+
+Caller-supplied ``start_date`` / ``end_date`` (ints) are stringified into
+``datazione`` as ``"start..end"`` when both provided, single year otherwise.
+On promote (``maybe_promote_fallback``), idempotency is on ``(periodo, fase)``.
+"""
+from __future__ import annotations
+
+from typing import Optional
+
+from sqlalchemy import text
+from sqlalchemy.orm import Session
+
+from .compound_layout import derive_row_id
+from .exceptions import PeriodSyncError
+from .row_provider import Row, PERIOD_COLORS
+
+
+def _format_datazione(start: Optional[int], end: Optional[int]) -> Optional[str]:
+    if start is None and end is None:
+        return None
+    if start is not None and end is not None:
+        return f"{start}..{end}"
+    return str(start if start is not None else end)
+
+
+class PeriodSyncService:
+    def __init__(self, session: Session, site: Optional[str] = None) -> None:
+        self.session = session
+        self.site = site
+
+    def upsert_row(self, period_name: str, phase_name: Optional[str] = None,
+                   start_date: Optional[int] = None,
+                   end_date: Optional[int] = None) -> Row:
+        if not period_name or not period_name.strip():
+            raise PeriodSyncError("period_name is required",
+                                   period_name=period_name, phase_name=phase_name)
+        if start_date is not None and end_date is not None and start_date > end_date:
+            raise PeriodSyncError(
+                "start_date must be <= end_date",
+                period_name=period_name, phase_name=phase_name,
+            )
+
+        existing = self.session.execute(text(
+            "SELECT id_period FROM period_table "
+            "WHERE periodo = :p AND "
+            "(fase = :ph OR (fase IS NULL AND :ph IS NULL))"
+        ), {"p": period_name, "ph": phase_name}).fetchone()
+
+        if existing is None:
+            self.session.execute(text(
+                "INSERT INTO period_table (sito, periodo, fase, datazione) "
+                "VALUES (:s, :p, :ph, :dz)"
+            ), {
+                "s": self.site,
+                "p": period_name,
+                "ph": phase_name,
+                "dz": _format_datazione(start_date, end_date),
+            })
+            self.session.commit()
+
+        row_id = derive_row_id(period_name, phase_name)
+        return Row(
+            row_id=row_id,
+            period_name=period_name,
+            phase_name=phase_name,
+            start_date=start_date,
+            end_date=end_date,
+            color=PERIOD_COLORS[0],
+            source="period_table",
+        )
+
+    def maybe_promote_fallback(self, site: str) -> int:
+        """Bulk-promote distinct (periodo_iniziale, fase_iniziale) values into
+        ``period_table``. Idempotent on ``(periodo, fase)``. Returns count promoted."""
+        # Bind site at promotion time so INSERTs land on the right row.
+        prev_site = self.site
+        self.site = site
+        try:
+            existing = {
+                (r[0], r[1])
+                for r in self.session.execute(text(
+                    "SELECT periodo, fase FROM period_table "
+                    "WHERE sito = :s OR sito IS NULL OR sito = ''"
+                ), {"s": site}).fetchall()
+            }
+            candidates = self.session.execute(text(
+                "SELECT DISTINCT periodo_iniziale, fase_iniziale "
+                "FROM periodizzazione_table WHERE sito = :s "
+                "UNION "
+                "SELECT DISTINCT periodo_iniziale, fase_iniziale "
+                "FROM us_table WHERE sito = :s"
+            ), {"s": site}).fetchall()
+            count = 0
+            for period, phase in candidates:
+                if not period:
+                    continue
+                if (period, phase) in existing:
+                    continue
+                try:
+                    self.upsert_row(period_name=period, phase_name=phase)
+                    count += 1
+                except PeriodSyncError:
+                    continue
+            return count
+        finally:
+            self.site = prev_site

{pyarchinit_mini-2.4.1 → pyarchinit_mini-2.4.3}/pyarchinit_mini/harris_swimlane/row_provider.py

@@ -55,18 +55,28 @@ class RowProvider:
         return None
 
     def _load_from_period_table(self) -> list[Row]:
+        """Load rows from ``period_table`` using the real pyarchinit schema.
+
+        pyarchinit's ``period_table`` ships with columns ``periodo`` /
+        ``fase`` / ``datazione`` / ``sito`` — there are no numeric
+        ``start_date`` / ``end_date`` columns, so we leave those as ``None``
+        and sort alphabetically. The ``sito`` column is filtered when
+        present (cross-site rows with NULL/empty ``sito`` are still kept,
+        matching legacy pyarchinit behaviour).
+        """
         # SQLite < 3.30 doesn't support NULLS LAST. Sort in Python for portability.
-        result = self.session.execute(text(
-            "SELECT period_name, phase_name, start_date, end_date "
-            "FROM period_table"
-        )).fetchall()
-        # Sort: by start_date DESC, NULL last; tiebreaker by period_name, phase_name
-        def sort_key(r):
-            start = r[2]
-            return (0 if start is not None else 1,
-                    -start if start is not None else 0,
-                    r[0] or "", r[1] or "")
-        sorted_result = sorted(result, key=sort_key)
+        result = self.session.execute(
+            text(
+                "SELECT periodo, fase, datazione "
+                "FROM period_table "
+                "WHERE sito = :sito OR sito IS NULL OR sito = ''"
+            ),
+            {"sito": self.site},
+        ).fetchall()
+        sorted_result = sorted(
+            (r for r in result if r[0]),
+            key=lambda r: (r[0] or "", r[1] or ""),
+        )
         out = []
         for i, r in enumerate(sorted_result):
             period = r[0]
@@ -76,8 +86,8 @@ class RowProvider:
                 row_id=row_id,
                 period_name=period,
                 phase_name=phase,
-                start_date=r[2],
-                end_date=r[3],
+                start_date=None,
+                end_date=None,
                 color=PERIOD_COLORS[i % len(PERIOD_COLORS)],
                 source="period_table",
             ))

{pyarchinit_mini-2.4.1 → pyarchinit_mini-2.4.3}/pyarchinit_mini/web_interface/harris_creator_routes.py

@@ -638,22 +638,42 @@ from pyarchinit_mini.harris_swimlane.exceptions import PeriodSyncError
 
 
 def _get_session():
-    """Get the request-bound SQLAlchemy session.
-
-    Requires the Flask app to set g.db_session in a before_request hook
-    (the production app does this; tests do too). Raises if not set —
-    fails loud rather than silently returning a context-manager generator
-    that downstream callers will treat as a Session.
+    """Get a request-scoped SQLAlchemy session for Spec 3-bis endpoints.
+
+    Reuses ``g.db_session`` if a before_request hook has set it. Otherwise
+    lazily opens one through the same path as ``get_db_session()`` and
+    binds it to ``g`` (the teardown_request hook below releases it). This
+    keeps the API contract simple — endpoints just call ``_get_session()``
+    and get a real ``Session`` back, whether or not the host app wires a
+    before_request hook (the production app in 2.4.x does not).
     """
     db = getattr(g, "db_session", None)
-    if db is None:
-        raise RuntimeError(
-            "g.db_session not set. The Flask app must set it in a "
-            "before_request hook before invoking Spec 3-bis endpoints."
-        )
+    if db is not None:
+        return db
+    cm = get_db_session()
+    db = cm.__enter__()
+    g.db_session = db
+    g._db_session_cm = cm
     return db
 
 
+@harris_creator_bp.teardown_request
+def _release_lazy_db_session(exc):  # noqa: ARG001 — exc is part of the signature
+    """Close any session that ``_get_session()`` opened lazily for this request."""
+    cm = getattr(g, "_db_session_cm", None)
+    if cm is None:
+        return
+    try:
+        cm.__exit__(type(exc) if exc else None, exc, getattr(exc, "__traceback__", None))
+    except Exception:
+        pass
+    finally:
+        try:
+            delattr(g, "_db_session_cm")
+        except AttributeError:
+            pass
+
+
 @harris_creator_bp.get("/api/swimlanes/<site>")
 def api_get_swimlanes(site: str):
     """List swimlane rows for the site."""
@@ -738,8 +758,7 @@ def api_save_state(site: str):
 
 @harris_creator_bp.post("/api/swimlanes/<site>")
 def api_create_row(site: str):
-    """Create a new swimlane row (upsert period_table). site param is for
-    URL consistency; period_table is currently cross-site."""
+    """Create a new swimlane row (upsert period_table for this site)."""
     payload = request.get_json(silent=True) or {}
     period_name = payload.get("period_name", "")
     phase_name = payload.get("phase_name") or None
@@ -747,7 +766,7 @@ def api_create_row(site: str):
     end_date = payload.get("end_date")
     try:
         session = _get_session()
-        svc = PeriodSyncService(session)
+        svc = PeriodSyncService(session, site=site)
         row = svc.upsert_row(
             period_name=period_name, phase_name=phase_name,
             start_date=start_date, end_date=end_date,

{pyarchinit_mini-2.4.1 → pyarchinit_mini-2.4.3/pyarchinit_mini.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyarchinit-mini
-Version: 2.4.1
+Version: 2.4.3
 Summary: Lightweight archaeological data management system with REST API, Web UI, Desktop GUI, CLI, multi-user authentication, real-time collaboration, analytics dashboard, PyArchInit import/export, Heriverse/ATON export integration, and 3D CRUD viewer
 Home-page: https://github.com/enzococca/pyarchinit-mini
 Author: PyArchInit Team

{pyarchinit_mini-2.4.1 → pyarchinit_mini-2.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyarchinit-mini"
-version = "2.4.1"
+version = "2.4.3"
 description = "Lightweight archaeological data management system with REST API, Web UI, Desktop GUI, CLI, multi-user authentication, real-time collaboration, analytics dashboard, PyArchInit import/export, Heriverse/ATON export integration, and 3D CRUD viewer"
 readme = "README.md"
 license = {text = "GPL-2.0"}

{pyarchinit_mini-2.4.1 → pyarchinit_mini-2.4.3}/tests/fixtures/_generate_harris_swimlane_synthetic.py

@@ -18,10 +18,11 @@ c = conn.cursor()
 c.executescript("""
 CREATE TABLE period_table (
     id_period INTEGER PRIMARY KEY AUTOINCREMENT,
-    period_name TEXT NOT NULL,
-    phase_name TEXT,
-    start_date INTEGER, end_date INTEGER,
-    description TEXT, chronology TEXT
+    sito TEXT,
+    periodo TEXT NOT NULL,
+    fase TEXT,
+    datazione TEXT,
+    descrizione TEXT
 );
 CREATE TABLE periodizzazione_table (
     id_periodizzazione INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -39,24 +40,24 @@ CREATE TABLE us_table (
 );
 """)
 
-# 5 (period, phase) rows
+# 5 (periodo, fase) rows on the production schema
 periods = [
-    ("Roman", "a", -27, 100),
-    ("Roman", "b", 100, 300),
-    ("Late Antiquity", "a", 300, 600),
-    ("Medieval", "a", 600, 1200),
-    ("Medieval", "b", 1200, 1500),
+    ("Roman", "a", "-27..100"),
+    ("Roman", "b", "100..300"),
+    ("Late Antiquity", "a", "300..600"),
+    ("Medieval", "a", "600..1200"),
+    ("Medieval", "b", "1200..1500"),
 ]
-for p, ph, sd, ed in periods:
+for p, ph, dz in periods:
     c.execute(
-        "INSERT INTO period_table (period_name, phase_name, start_date, end_date) VALUES (?,?,?,?)",
-        (p, ph, sd, ed),
+        "INSERT INTO period_table (sito, periodo, fase, datazione) VALUES (?,?,?,?)",
+        ("Volterra", p, ph, dz),
     )
 
 # 30 US distributed
 us_records = []
 for i in range(30):
-    period, phase, _, _ = periods[i % 5]
+    period, phase, _ = periods[i % 5]
     rapporti = f"copre {1000 + (i+1) % 30}" if i % 3 == 0 else ""
     us_records.append(
         ("Volterra", "A", 1000 + i, "US",
@@ -76,11 +77,11 @@ print(f"Wrote {DB} (30 US, 5 periods)")
 # Reference shape for SwimlaneState.load test
 cytoscape = {
     "rows": [
-        {"row_id": "row_medieval_b", "period_name": "Medieval", "phase_name": "b"},
-        {"row_id": "row_medieval_a", "period_name": "Medieval", "phase_name": "a"},
         {"row_id": "row_late-antiquity_a", "period_name": "Late Antiquity", "phase_name": "a"},
-        {"row_id": "row_roman_b", "period_name": "Roman", "phase_name": "b"},
+        {"row_id": "row_medieval_a", "period_name": "Medieval", "phase_name": "a"},
+        {"row_id": "row_medieval_b", "period_name": "Medieval", "phase_name": "b"},
         {"row_id": "row_roman_a", "period_name": "Roman", "phase_name": "a"},
+        {"row_id": "row_roman_b", "period_name": "Roman", "phase_name": "b"},
     ],
     "nodes_count": 30,
     "edges_count_at_least": 5,

{pyarchinit_mini-2.4.1 → pyarchinit_mini-2.4.3}/tests/integration/test_harris_swimlane_routes_create_row.py

@@ -9,12 +9,15 @@ from sqlalchemy.orm import sessionmaker
 def client_and_db(tmp_path):
     db = tmp_path / "rc.db"
     conn = sqlite3.connect(db)
+    # Real pyarchinit schema: periodo / fase / datazione / sito.
     conn.executescript("""
     CREATE TABLE period_table (
         id_period INTEGER PRIMARY KEY AUTOINCREMENT,
-        period_name TEXT NOT NULL, phase_name TEXT,
-        start_date INTEGER, end_date INTEGER,
-        description TEXT, chronology TEXT
+        sito TEXT,
+        periodo TEXT,
+        fase TEXT,
+        datazione TEXT,
+        descrizione TEXT
     );
     """)
     conn.commit()

pyarchinit_mini-2.4.3/tests/integration/test_harris_swimlane_routes_session_missing.py

@@ -0,0 +1,57 @@
+"""Verify _get_session() lazily acquires a session when g.db_session is not bound.
+
+Prior to 2.4.2, _get_session() raised RuntimeError when no before_request hook
+had set g.db_session — but no such hook exists in the production app, so every
+swimlane request 500'd. 2.4.2 lazy-acquires a session through the same path as
+get_db_session() and binds it to g for the duration of the request.
+"""
+import sqlite3
+
+import pytest
+from flask import Flask
+
+from pyarchinit_mini.web_interface.harris_creator_routes import harris_creator_bp
+
+
+@pytest.fixture
+def client_no_session(tmp_path, monkeypatch):
+    db_path = tmp_path / "swimlane_lazy.db"
+    # Pre-create the tables Spec 3-bis queries, matching the real pyarchinit
+    # production schema (periodo / fase / datazione, not period_name / phase_name).
+    conn = sqlite3.connect(db_path)
+    conn.executescript("""
+    CREATE TABLE period_table (
+        id_period INTEGER PRIMARY KEY,
+        sito TEXT, periodo TEXT, fase TEXT, datazione TEXT, descrizione TEXT
+    );
+    CREATE TABLE periodizzazione_table (
+        id_periodizzazione INTEGER PRIMARY KEY,
+        sito TEXT, area TEXT, us INTEGER,
+        periodo_iniziale TEXT, fase_iniziale TEXT,
+        periodo_finale TEXT, fase_finale TEXT
+    );
+    CREATE TABLE us_table (
+        id_us INTEGER PRIMARY KEY,
+        sito TEXT, us INTEGER, unita_tipo TEXT,
+        rapporti TEXT, node_uuid TEXT,
+        periodo_iniziale TEXT, fase_iniziale TEXT
+    );
+    """)
+    conn.commit()
+    conn.close()
+    monkeypatch.setenv("DATABASE_URL", f"sqlite:///{db_path}")
+    app = Flask(__name__)
+    app.config["TESTING"] = True
+    app.register_blueprint(harris_creator_bp)
+    # Deliberately NO before_request hook setting g.db_session — we rely on
+    # _get_session() lazy acquisition.
+    yield app.test_client()
+
+
+def test_swimlanes_endpoint_lazy_acquires_session(client_no_session):
+    """Without a pre-bound g.db_session, the endpoint should still answer 200
+    by lazily opening a fresh session via get_db_session()."""
+    r = client_no_session.get("/harris-creator/api/swimlanes/EmptySite")
+    assert r.status_code == 200, r.get_data(as_text=True)
+    body = r.get_json()
+    assert isinstance(body, list)

{pyarchinit_mini-2.4.1 → pyarchinit_mini-2.4.3}/tests/unit/test_harris_swimlane_period_sync.py

@@ -1,3 +1,4 @@
+"""Tests for PeriodSyncService against the real pyarchinit period_table schema."""
 import sqlite3
 import pytest
 
@@ -12,12 +13,14 @@ from pyarchinit_mini.harris_swimlane.exceptions import PeriodSyncError
 def session(tmp_path):
     db = tmp_path / "ps.db"
     conn = sqlite3.connect(db)
+    # Real pyarchinit schema: periodo / fase / datazione / sito.
     conn.execute("""CREATE TABLE period_table (
         id_period INTEGER PRIMARY KEY AUTOINCREMENT,
-        period_name TEXT NOT NULL,
-        phase_name TEXT,
-        start_date INTEGER, end_date INTEGER,
-        description TEXT, chronology TEXT
+        sito TEXT,
+        periodo TEXT,
+        fase TEXT,
+        datazione TEXT,
+        descrizione TEXT
     )""")
     conn.commit()
     conn.close()
@@ -29,50 +32,63 @@ def session(tmp_path):
 
 
 def test_upsert_row_creates_new_entry(session):
-    svc = PeriodSyncService(session)
+    svc = PeriodSyncService(session, site="Volterra")
     row = svc.upsert_row(period_name="P1", phase_name="a",
                          start_date=100, end_date=200)
     assert row.period_name == "P1"
     assert row.phase_name == "a"
     assert row.start_date == 100
     assert row.row_id == "row_p1_a"
+    datazione = session.execute(text(
+        "SELECT datazione FROM period_table WHERE periodo='P1' AND fase='a'"
+    )).scalar()
+    assert datazione == "100..200"
 
 
 def test_upsert_row_idempotent(session):
-    svc = PeriodSyncService(session)
+    svc = PeriodSyncService(session, site="Volterra")
     svc.upsert_row(period_name="P1", phase_name="a", start_date=100, end_date=200)
     svc.upsert_row(period_name="P1", phase_name="a", start_date=100, end_date=200)
     count = session.execute(text(
-        "SELECT COUNT(*) FROM period_table WHERE period_name='P1' AND phase_name='a'"
+        "SELECT COUNT(*) FROM period_table WHERE periodo='P1' AND fase='a'"
     )).scalar()
     assert count == 1
 
 
 def test_upsert_row_different_phase_creates_new(session):
-    svc = PeriodSyncService(session)
+    svc = PeriodSyncService(session, site="Volterra")
     svc.upsert_row(period_name="P1", phase_name="a")
     svc.upsert_row(period_name="P1", phase_name="b")
     count = session.execute(text(
-        "SELECT COUNT(*) FROM period_table WHERE period_name='P1'"
+        "SELECT COUNT(*) FROM period_table WHERE periodo='P1'"
     )).scalar()
     assert count == 2
 
 
 def test_upsert_row_empty_period_raises(session):
-    svc = PeriodSyncService(session)
+    svc = PeriodSyncService(session, site="Volterra")
     with pytest.raises(PeriodSyncError):
         svc.upsert_row(period_name="")
 
 
 def test_upsert_row_invalid_date_range_raises(session):
-    svc = PeriodSyncService(session)
+    svc = PeriodSyncService(session, site="Volterra")
     with pytest.raises(PeriodSyncError):
         svc.upsert_row(period_name="P1", phase_name="a",
                        start_date=200, end_date=100)
 
 
 def test_upsert_row_no_phase(session):
-    svc = PeriodSyncService(session)
+    svc = PeriodSyncService(session, site="Volterra")
     row = svc.upsert_row(period_name="Iron Age")
     assert row.phase_name is None
     assert row.row_id == "row_iron-age"
+
+
+def test_upsert_row_persists_sito(session):
+    svc = PeriodSyncService(session, site="Volterra")
+    svc.upsert_row(period_name="P1", phase_name="a")
+    sito = session.execute(text(
+        "SELECT sito FROM period_table WHERE periodo='P1'"
+    )).scalar()
+    assert sito == "Volterra"

{pyarchinit_mini-2.4.1 → pyarchinit_mini-2.4.3}/tests/unit/test_harris_swimlane_row_provider.py

@@ -8,18 +8,16 @@ from sqlalchemy.orm import sessionmaker
 from pyarchinit_mini.harris_swimlane.row_provider import Row, RowProvider
 
 
-@pytest.fixture
-def session_with_period_table(tmp_path):
-    db = tmp_path / "rp.db"
-    conn = sqlite3.connect(db)
+def _make_db_with_real_schema(db_path):
+    """Create the 3 tables matching the real pyarchinit schema used in prod."""
+    conn = sqlite3.connect(db_path)
     conn.execute("""CREATE TABLE period_table (
         id_period INTEGER PRIMARY KEY,
-        period_name TEXT NOT NULL,
-        phase_name TEXT,
-        start_date INTEGER,
-        end_date INTEGER,
-        description TEXT,
-        chronology TEXT
+        sito TEXT,
+        periodo TEXT,
+        fase TEXT,
+        datazione TEXT,
+        descrizione TEXT
     )""")
     conn.execute("""CREATE TABLE periodizzazione_table (
         id_periodizzazione INTEGER PRIMARY KEY,
@@ -32,14 +30,21 @@ def session_with_period_table(tmp_path):
         sito TEXT, us INTEGER,
         periodo_iniziale TEXT, fase_iniziale TEXT
     )""")
+    return conn
+
+
+@pytest.fixture
+def session_with_period_table(tmp_path):
+    db = tmp_path / "rp.db"
+    conn = _make_db_with_real_schema(db)
     rows = [
-        ("Roman Imperial", "early", -27, 100),
-        ("Roman Imperial", "late", 100, 476),
-        ("Medieval", "early", 476, 1000),
+        ("Volterra", "Roman Imperial", "early", "-27..100"),
+        ("Volterra", "Roman Imperial", "late", "100..476"),
+        ("Volterra", "Medieval", "early", "476..1000"),
     ]
     for r in rows:
         conn.execute(
-            "INSERT INTO period_table (period_name, phase_name, start_date, end_date) VALUES (?,?,?,?)",
+            "INSERT INTO period_table (sito, periodo, fase, datazione) VALUES (?,?,?,?)",
             r,
         )
     conn.commit()
@@ -54,22 +59,7 @@ def session_with_period_table(tmp_path):
 @pytest.fixture
 def session_fallback_only(tmp_path):
     db = tmp_path / "rp_fb.db"
-    conn = sqlite3.connect(db)
-    conn.execute("""CREATE TABLE period_table (
-        id_period INTEGER PRIMARY KEY, period_name TEXT, phase_name TEXT,
-        start_date INTEGER, end_date INTEGER, description TEXT, chronology TEXT
-    )""")
-    conn.execute("""CREATE TABLE periodizzazione_table (
-        id_periodizzazione INTEGER PRIMARY KEY,
-        sito TEXT, area TEXT, us INTEGER,
-        periodo_iniziale TEXT, fase_iniziale TEXT,
-        periodo_finale TEXT, fase_finale TEXT
-    )""")
-    conn.execute("""CREATE TABLE us_table (
-        id_us INTEGER PRIMARY KEY,
-        sito TEXT, us INTEGER,
-        periodo_iniziale TEXT, fase_iniziale TEXT
-    )""")
+    conn = _make_db_with_real_schema(db)
     pz = [
         ("Volterra", "A", 1, "Roman", "a", None, None),
         ("Volterra", "A", 2, "Medieval", "b", None, None),
@@ -89,13 +79,20 @@ def session_fallback_only(tmp_path):
     s.close()
 
 
-def test_list_rows_from_period_table_sorted_recent_first(session_with_period_table):
+def test_list_rows_from_period_table_sorted_alphabetically(session_with_period_table):
+    # Real period_table has no numeric start_date/end_date — we sort by
+    # (periodo, fase) alphabetically and leave numeric dates as None.
     rows = RowProvider(session_with_period_table, "Volterra").list_rows()
     assert len(rows) == 3
     assert rows[0].period_name == "Medieval"
+    assert rows[0].phase_name == "early"
     assert rows[1].period_name == "Roman Imperial"
-    assert rows[1].phase_name == "late"
-    assert rows[2].phase_name == "early"
+    assert rows[1].phase_name == "early"
+    assert rows[2].period_name == "Roman Imperial"
+    assert rows[2].phase_name == "late"
+    for r in rows:
+        assert r.start_date is None
+        assert r.end_date is None
 
 
 def test_list_rows_source_period_table(session_with_period_table):