pyarchinit-mini 2.4.2__tar.gz → 2.4.4__tar.gz

{pyarchinit_mini-2.4.2 → pyarchinit_mini-2.4.4}/CHANGELOG.md

@@ -1,3 +1,72 @@
+## [2.4.4] - 2026-05-18
+
+### Fixed (IT)
+- Nodi US dell'editor swimlane ora hanno `data.color` (risolto via
+  `VocabProvider.get_visual_style().fill_color`). Stop ai warning Cytoscape
+  "no mapping for property background-color with data field color".
+- Edge stratigrafici deduplicati: `_build_edges` ora ignora le coppie
+  doppie `(source, target, edge_name)` e tratta gli inversi `overlies` /
+  `is_after` come la stessa relazione (un solo arco invece di due).
+- Editor lancia un layout `dagre` dopo `cy.add()` + `cy.fit()`, così gli US
+  si distribuiscono dentro le row e gli archi diventano visibili.
+
+### Added (IT)
+- Modelli SQLAlchemy `US`, `InventarioMateriali`, `Periodizzazione` ora
+  definiscono la colonna `node_uuid = Column(String(36))`. Un DB nuovo
+  creato via `Base.metadata.create_all()` nasce con la colonna corretta.
+- `DatabaseMigrations.migrate_all_tables()` chiama automaticamente le 3
+  migration di Spec 1 (`_2026_05_node_uuid_schema`, `_node_uuid_backfill`,
+  `_vocab_alignment`) idempotentemente. Conseguenza: i DB esistenti
+  (SQLite o PostgreSQL) vengono aggiornati al primo avvio del web —
+  nessun bisogno di lanciare manualmente `pyarchinit-mini-migrate-vocab`.
+
+### Fixed (EN)
+- US nodes in the swimlane editor now carry `data.color`, resolved through
+  `VocabProvider.get_visual_style().fill_color`. Eliminates Cytoscape
+  warnings about missing color mapping.
+- Stratigraphic edges deduplicated: `_build_edges` ignores duplicate
+  `(source, target, edge_name)` triples and treats `overlies` / `is_after`
+  inverse pairs as the same edge (one arrow, not two).
+- Editor runs a `dagre` layout after `cy.add()` plus a `cy.fit()` so US
+  children spread inside their swimlane row and edges become visible.
+
+### Added (EN)
+- SQLAlchemy models `US`, `InventarioMateriali`, `Periodizzazione` now
+  declare `node_uuid = Column(String(36))`. New DBs created via
+  `Base.metadata.create_all()` have the column from the start.
+- `DatabaseMigrations.migrate_all_tables()` now invokes the 3 Spec 1
+  migrations (`node_uuid_schema`, `node_uuid_backfill`, `vocab_alignment`)
+  idempotently. Existing SQLite or PostgreSQL DBs get auto-upgraded on
+  the first web startup — no need to run `pyarchinit-mini-migrate-vocab`
+  by hand.
+
+## [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)

{pyarchinit_mini-2.4.2/pyarchinit_mini.egg-info → pyarchinit_mini-2.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyarchinit-mini
-Version: 2.4.2
+Version: 2.4.4
 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.2 → pyarchinit_mini-2.4.4}/pyarchinit_mini/__init__.py

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

{pyarchinit_mini-2.4.2 → pyarchinit_mini-2.4.4}/pyarchinit_mini/database/migrations/__init__.py

@@ -803,6 +803,14 @@ class DatabaseMigrations:
             except Exception as e:
                 logger.warning(f"TMA thesaurus trigger failed: {e}")
 
+            # Spec 1 (node_uuid + vocab alignment) — auto-applied so fresh
+            # installs and upgraded existing DBs both get the swimlane editor
+            # working without a manual `pyarchinit-mini-migrate-vocab` step.
+            try:
+                total_migrations += self._migrate_spec1_node_uuid_and_vocab()
+            except Exception as e:
+                logger.warning(f"Spec 1 node_uuid/vocab migration failed: {e}")
+
             logger.info(f"All migrations completed. Total migrations applied: {total_migrations}")
             return total_migrations
 
@@ -810,6 +818,37 @@ class DatabaseMigrations:
             logger.error(f"Error during database migrations: {e}")
             raise
 
+    def _migrate_spec1_node_uuid_and_vocab(self) -> int:
+        """Apply Spec 1 migrations idempotently: node_uuid schema, backfill,
+        vocab alignment (USVA/USVB→USVs, USVC→USVn). Each underlying script
+        is a no-op when nothing needs changing, so this is safe to call on
+        every startup."""
+        import importlib
+
+        pkg = "pyarchinit_mini.database.migrations"
+        scripts = [
+            f"{pkg}._2026_05_node_uuid_schema",
+            f"{pkg}._2026_05_node_uuid_backfill",
+            f"{pkg}._2026_05_vocab_alignment",
+        ]
+        url = str(self.connection.engine.url)
+        applied = 0
+        for mod_path in scripts:
+            try:
+                mod = importlib.import_module(mod_path)
+                report = mod.run(url, dry_run=False)
+                status = getattr(report, "status", "ok")
+                if status == "ok":
+                    rows = getattr(report, "rows_updated", None)
+                    tables = getattr(report, "tables_changed", None)
+                    mappings = getattr(report, "mappings", None)
+                    if rows or tables or mappings:
+                        applied += 1
+                        logger.info(f"{mod_path}: {tables or rows or mappings}")
+            except Exception as e:
+                logger.warning(f"{mod_path} failed: {e}")
+        return applied
+
     def get_table_info(self, table_name: str) -> Dict[str, Any]:
         """Get information about a table structure"""
         try:

pyarchinit_mini-2.4.4/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.2 → pyarchinit_mini-2.4.4}/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.2 → pyarchinit_mini-2.4.4}/pyarchinit_mini/harris_swimlane/swimlane_state.py

@@ -52,6 +52,27 @@ class SwimlaneState:
         provider = RowProvider(session, site)
         rows = provider.list_rows()
 
+        # Resolve unit_type → fill_color via VocabProvider once per request so
+        # the editor's `'background-color': data(color)` style renders properly.
+        try:
+            from pyarchinit_mini.vocab.provider import VocabProvider
+            _vocab = VocabProvider.instance()
+            _color_cache: dict[str, str] = {}
+
+            def _color_for(ut: str) -> str:
+                if ut in _color_cache:
+                    return _color_cache[ut]
+                try:
+                    style = _vocab.get_visual_style(ut)
+                    c = getattr(style, "fill_color", None) or "#CCCCCC"
+                except Exception:
+                    c = "#CCCCCC"
+                _color_cache[ut] = c
+                return c
+        except Exception:
+            def _color_for(ut: str) -> str:
+                return "#CCCCCC"
+
         # Load US records for site
         us_rows = session.execute(text(
             "SELECT id_us, sito, area, us, unita_tipo, rapporti, node_uuid, "
@@ -89,6 +110,7 @@ class SwimlaneState:
                     "label": f"{unita_tipo}{us_num}",
                     "parent": parent_row_id,
                     "unit_type": unita_tipo,
+                    "color": _color_for(unita_tipo),
                     "period": periodo,
                     "phase": fase,
                     "us": us_num,
@@ -124,15 +146,33 @@ class SwimlaneState:
 
     @staticmethod
     def _build_edges(us_rows, us_num_to_node_id: dict) -> list[CytoscapeElement]:
-        """Parse rapporti for each US via EdgeRegistry (Spec 1)."""
+        """Parse rapporti for each US via EdgeRegistry, deduplicating canonical
+        triples ``(source, target, edge_name)``.
+
+        pyarchinit stores stratigraphic relationships from both sides
+        (``A copre B`` on row A AND ``B coperto da A`` on row B). Both tokens
+        resolve to the same canonical edge ``A overlies B`` — without
+        deduplication the editor renders the same arrow twice.
+
+        Symmetric edge types (``has_same_time``) are deduped on the
+        unordered pair so the bidirectional view doesn't show 2 lines.
+        """
         try:
             from pyarchinit_mini.graphproj.edge_registry import EdgeRegistry
             registry = EdgeRegistry()
         except Exception:
             return []
 
+        # Edges where direction is meaningless (twins).
+        SYMMETRIC = {"has_same_time"}
+        # Edges that are inverses of each other (A overlies B ≡ B is_after A
+        # in stratigraphic Harris semantics). When pyarchinit stores both
+        # sides on different US rows, the editor must show one arrow, not two.
+        INVERSE_PAIRS = {"overlies": "is_after", "is_after": "overlies"}
+
         edges: list[CytoscapeElement] = []
         edge_counter = 0
+        seen: set[tuple] = set()
 
         for r in us_rows:
             us_num = r[3]
@@ -157,6 +197,22 @@ class SwimlaneState:
                 target_node_id = us_num_to_node_id.get(target_int)
                 if target_node_id is None:
                     continue
+
+                if edge_name in SYMMETRIC:
+                    key = (edge_name, tuple(sorted((source_node_id, target_node_id))))
+                else:
+                    key = (edge_name, source_node_id, target_node_id)
+                if key in seen:
+                    continue
+                # Check the inverse pair (overlies vs is_after) under the same
+                # source/target pair — they represent the same edge.
+                inverse_name = INVERSE_PAIRS.get(edge_name)
+                if inverse_name is not None:
+                    inverse_key = (inverse_name, target_node_id, source_node_id)
+                    if inverse_key in seen:
+                        continue
+                seen.add(key)
+
                 edge_counter += 1
                 edges.append(CytoscapeElement(data={
                     "id": f"e{edge_counter}",

{pyarchinit_mini-2.4.2 → pyarchinit_mini-2.4.4}/pyarchinit_mini/models/harris_matrix.py

@@ -92,7 +92,10 @@ class Periodizzazione(BaseModel):
     # Confidence and notes
     affidabilita = Column(String(50))       # 'alta', 'media', 'bassa'
     note = Column(Text)
-    
+
+    # Spec 1: stable node identity for s3dgraphy/EM graph round-trip
+    node_uuid = Column(String(36))
+
     # Relationships
     site_ref = relationship("Site", foreign_keys=[sito])
     initial_period = relationship("Period", foreign_keys=[period_id_initial])

{pyarchinit_mini-2.4.2 → pyarchinit_mini-2.4.4}/pyarchinit_mini/models/inventario_materiali.py

@@ -97,6 +97,9 @@ class InventarioMateriali(BaseModel):
     photo_id = Column(Text)
     drawing_id = Column(Text)
 
+    # Spec 1: stable node identity for s3dgraphy/EM graph round-trip
+    node_uuid = Column(String(36))
+
     # Relationships
     site_ref = relationship("Site", foreign_keys=[sito],
                            primaryjoin="InventarioMateriali.sito == Site.sito")

{pyarchinit_mini-2.4.2 → pyarchinit_mini-2.4.4}/pyarchinit_mini/models/us.py

@@ -196,8 +196,11 @@ class US(BaseModel):
     rapporti2 = Column(Text)
     doc_usv = Column(Text)
 
+    # Spec 1: stable node identity for s3dgraphy/EM graph round-trip
+    node_uuid = Column(String(36))
+
     # Relationships
-    site_ref = relationship("Site", foreign_keys=[sito], 
+    site_ref = relationship("Site", foreign_keys=[sito],
                            primaryjoin="US.sito == Site.sito")
     
     def __repr__(self):

{pyarchinit_mini-2.4.2 → pyarchinit_mini-2.4.4}/pyarchinit_mini/web_interface/harris_creator_routes.py

@@ -758,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
@@ -767,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.2 → pyarchinit_mini-2.4.4}/pyarchinit_mini/web_interface/templates/harris_creator/editor.html

@@ -519,6 +519,25 @@ function renderSwimlaneState(state) {
         });
     });
 
+    // Run dagre layout inside each swimlane row so US nodes spread out
+    // horizontally and stratigraphic edges become visible. Without a layout
+    // pass, all US children of a row get stacked at the row's centroid and
+    // the edges collapse into invisible zero-length segments.
+    try {
+        cy.layout({
+            name: 'dagre',
+            rankDir: 'LR',
+            nodeSep: 50,
+            rankSep: 80,
+            fit: false,
+        }).run();
+    } catch (e) {
+        console.warn('dagre layout failed, falling back to grid:', e);
+        cy.layout({name: 'grid'}).run();
+    }
+    // Fit viewport so the user actually sees the rows + nodes + edges.
+    cy.fit(undefined, 30);
+
     // Save state references for later use
     window._currentSite = state.site;
     window._pendingChanges = state.pending_changes || {

{pyarchinit_mini-2.4.2 → pyarchinit_mini-2.4.4/pyarchinit_mini.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyarchinit-mini
-Version: 2.4.2
+Version: 2.4.4
 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.2 → pyarchinit_mini-2.4.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyarchinit-mini"
-version = "2.4.2"
+version = "2.4.4"
 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.2 → pyarchinit_mini-2.4.4}/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.2 → pyarchinit_mini-2.4.4}/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.2 → pyarchinit_mini-2.4.4}/tests/integration/test_harris_swimlane_routes_session_missing.py

@@ -5,21 +5,41 @@ 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 sqlalchemy import create_engine
 
-from pyarchinit_mini.models.base import Base
 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"
-    db_url = f"sqlite:///{db_path}"
-    # Pre-create the schema so lazy session has tables to query.
-    Base.metadata.create_all(create_engine(db_url))
-    monkeypatch.setenv("DATABASE_URL", db_url)
+    # 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)