pyarchinit-mini 2.9.0__tar.gz → 2.9.2__tar.gz

{pyarchinit_mini-2.9.0 → pyarchinit_mini-2.9.2}/CHANGELOG.md

@@ -1,3 +1,25 @@
+## 2.9.1 — 2026-05-19
+
+### Fixed — Harris Matrix proper rendering (post-2.9.0 feedback)
+- **Edge direction normalized to forward**: was reading "Coperto da" / "Tagliato da" etc. on the swimlane. Harris convention is recent→ancient with forward labels. Now every inverse canonical (`is_after`, `is_cut_by`, `is_filled_by`, `is_abutted_by`) is auto-swapped to its forward (`overlies`/`cuts`/`fills`/`abuts`) with source/target reversed. User reads "Copre" / "Taglia" / "Riempie" / "Si appoggia a".
+- **Arrows now visible**: was missing because cytoscape's `data(style.targetArrowShape)` dot-notation accessor didn't resolve nested objects. All palette/edge fields flattened into top-level data keys (`shape`, `bgcolor`, `bordercolor`, `linecolor`, `arrowtarget`, …). Selectors `node[shape]`, `edge[linecolor]` etc. now match reliably.
+- **Palette node styling visible**: USM/USD/USV/SF/VSF/TSU now appear with their palette shape + colors (was plain gray rectangles). Same flattening fix.
+- **Period rows as compound swimlanes**: every US node is a child of its `period_row_N` compound parent (visible as a horizontal lane on the canvas with label "Periodo X — Fase Y — Datazione"). Sub-groupings (area/settore/quadrato/attivita/strutture) nest INSIDE period rows as sub-clusters.
+- **Symmetric edges without arrows**: `has_same_time` / `is_bonded_to` now render as solid lines, no arrow heads, thicker stroke for visibility.
+- **Vertical layout**: dagre `rankDir: "TB"` (top-to-bottom) — newer US on top, older on bottom.
+- **Cuts dashed**: `cuts` edges get `line-style: dashed` (Harris convention).
+
+### Fixed — Vocabulary corrections
+- `vocab_it.json` had `"tagliato da"` mapping to `is_after` (wrong) — corrected to `is_cut_by`.
+- `_IT_EXTRAS` had `"riempito da"` → `"is_after"` (wrong) — corrected to `is_filled_by`.
+- `_IT_EXTRAS` had `"gli si appoggia"` → `"is_before"` (wrong) — corrected to `is_abutted_by`.
+
+### Internals
+- New constant `rapporti_codec.REVERSE_TO_FORWARD: Dict[str, str]` lookup.
+- `s3d_projector._load_edges` normalizes inverse direction before dedup.
+- `s3d_to_cytoscape.to_cytoscape` emits flat data fields + ALWAYS-on period row compounds (even with `group_by=none`).
+- `harris_creator_editor.js` rebuilt cytoscape style selectors against flat data; layout switched to `rankDir: "TB"`.
+
 ## 2.9.0 — 2026-05-19
 
 ### Fixed — Swimlane UI/UX cleanup (post-2.8.0 feedback)

{pyarchinit_mini-2.9.0/pyarchinit_mini.egg-info → pyarchinit_mini-2.9.2}/PKG-INFO

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

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

{pyarchinit_mini-2.9.0 → pyarchinit_mini-2.9.2}/pyarchinit_mini/graphproj/rapporti_codec.py

@@ -13,6 +13,15 @@ import logging
 from dataclasses import dataclass
 from typing import Dict, List, Optional
 
+# Inverse canonicals that must be converted to their forward counterpart by
+# swapping source and target.  Only directional (non-symmetric) inverses.
+REVERSE_TO_FORWARD: Dict[str, str] = {
+    "is_after": "overlies",
+    "is_cut_by": "cuts",
+    "is_filled_by": "fills",
+    "is_abutted_by": "abuts",
+}
+
 
 logger = logging.getLogger(__name__)
 
@@ -36,14 +45,18 @@ INVERSE_PAIRS: Dict[str, str] = {
 # Italian aliases that are NOT in vocab_it.json (observed in live Adarte data
 # on Rimini_RN_2020_21_Museo_Fellini).
 _IT_EXTRAS: Dict[str, str] = {
-    "riempito da": "is_after",
+    # Inverse directional aliases (will be swapped to forward by REVERSE_TO_FORWARD)
+    "riempito da": "is_filled_by",   # was wrongly "is_after" — fixed
+    "tagliato da": "is_cut_by",      # was missing
+    "coperto da": "is_after",        # explicit fallback in case EdgeRegistry misses it
+    # Symmetric / other
     "si lega a": "is_bonded_to",
     "si lega_a": "is_bonded_to",
     "connesso a": "is_bonded_to",
     "connesso_a": "is_bonded_to",
     "anteriore a": "is_before",
     "posteriore a": "is_after",
-    "gli si appoggia": "is_before",
+    "gli si appoggia": "is_abutted_by",  # was "is_before" — fixed to proper inverse
 }
 
 # Canonical → italian display label (for swimlane web + GraphML edge labels).

{pyarchinit_mini-2.9.0 → pyarchinit_mini-2.9.2}/pyarchinit_mini/graphproj/s3d_projector.py

@@ -18,7 +18,7 @@ from typing import Dict, List, Optional
 from sqlalchemy import text
 from sqlalchemy.orm import Session
 
-from pyarchinit_mini.graphproj.rapporti_codec import parse_rapporti, SYMMETRIC, INVERSE_PAIRS
+from pyarchinit_mini.graphproj.rapporti_codec import parse_rapporti, SYMMETRIC, INVERSE_PAIRS, REVERSE_TO_FORWARD
 
 
 logger = logging.getLogger(__name__)
@@ -217,17 +217,26 @@ class S3DProjector:
             if src_id is None:
                 continue
             for rap in parse_rapporti(rapp_raw, current_site=site):
+                canonical = rap.canonical
                 tgt_id = us_index.get(rap.target_us)
                 if tgt_id is None:
                     continue
-                if rap.canonical in SYMMETRIC:
-                    key = (rap.canonical, tuple(sorted((src_id, tgt_id))))
+                # Normalize inverse → forward + swap source/target so only
+                # forward canonicals (overlies, cuts, fills, abuts) appear in
+                # graph.edges.  Symmetric edges are never swapped.
+                if canonical in REVERSE_TO_FORWARD:
+                    canonical = REVERSE_TO_FORWARD[canonical]
+                    src_id, tgt_id = tgt_id, src_id
+                if canonical in SYMMETRIC:
+                    key = (canonical, tuple(sorted((src_id, tgt_id))))
                 else:
-                    key = (rap.canonical, src_id, tgt_id)
+                    key = (canonical, src_id, tgt_id)
                 if key in seen:
                     continue
                 seen.add(key)
-                graph.edges.append(Edge(source_id=src_id, target_id=tgt_id, canonical=rap.canonical))
+                graph.edges.append(Edge(source_id=src_id, target_id=tgt_id, canonical=canonical))
+                # Reset src_id to the original for the next iteration
+                src_id = us_index.get(str(us_num))
 
         # === Step A: Inverse dedup — drop the redundant inverse direction ===
         # E.g., if (overlies, A→B) exists, drop (is_after, B→A).

pyarchinit_mini-2.9.2/pyarchinit_mini/graphproj/s3d_to_cytoscape.py

@@ -0,0 +1,134 @@
+"""Translate a ProjectedGraph into cytoscape.js JSON with palette-derived styles.
+
+Changes from 2.9.0:
+- Palette fields are FLAT top-level data keys (shape, bgcolor, bordercolor …)
+  instead of a nested ``style`` object.  Cytoscape's ``data()`` accessor does
+  not reliably traverse nested objects, so ``data(style.shape)`` silently
+  returns nothing.
+- Period rows are ALWAYS emitted as compound parents (regardless of group_by)
+  so the UI always shows horizontal swimlanes.
+- When group_by != "none", sub-cluster compounds are nested INSIDE their period
+  row compound (cytoscape supports nested compounds).
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, List, Tuple
+
+from pyarchinit_mini.em_palette import get_palette
+from pyarchinit_mini.graphproj.rapporti_codec import display_label, SYMMETRIC
+from pyarchinit_mini.graphproj.s3d_projector import ProjectedGraph
+
+
+def to_cytoscape(graph: ProjectedGraph) -> Dict[str, Any]:
+    palette = get_palette()
+    out_nodes: List[Dict[str, Any]] = []
+    out_edges: List[Dict[str, Any]] = []
+
+    # ── Fix C: ALWAYS emit period row compound parents first ─────────────────
+    for r in graph.rows:
+        label = r.label
+        if r.datazione:
+            label = f"{r.label} — {r.datazione}"
+        out_nodes.append({
+            "data": {
+                "id": r.row_id,
+                "label": label,
+                "compound": True,
+                "is_period_row": True,
+                "is_fallback": r.is_fallback,
+            },
+        })
+
+    # ── Fix D: sub-cluster compounds nested inside period rows ───────────────
+    # Indexed by (row_id, sub_group) → cluster node id
+    parent_ids: Dict[Tuple[str, str], str] = {}
+    if graph.group_by != "none":
+        for n in graph.nodes:
+            if n.sub_group is None:
+                continue
+            key = (n.row_id, n.sub_group)
+            if key not in parent_ids:
+                cluster_id = f"cluster_{n.row_id}_{n.sub_group}"
+                parent_ids[key] = cluster_id
+                out_nodes.append({
+                    "data": {
+                        "id": cluster_id,
+                        "label": n.sub_group,
+                        "row": n.row_id,
+                        "compound": True,
+                        "is_period_row": False,
+                        # Nested inside the period row
+                        "parent": n.row_id,
+                    },
+                })
+
+    # ── Fix B: flat palette fields on US nodes ────────────────────────────────
+    for n in graph.nodes:
+        ns = palette.get_node_style(n.unit_type)
+
+        # Determine the immediate parent for this node
+        if graph.group_by != "none" and n.sub_group is not None:
+            immediate_parent = parent_ids.get((n.row_id, n.sub_group), n.row_id)
+        else:
+            immediate_parent = n.row_id
+
+        node_obj: Dict[str, Any] = {
+            "data": {
+                "id": n.node_id,
+                "label": n.us,
+                "us": n.us,
+                "area": n.area,
+                "unit_type": n.unit_type,
+                "description": n.description,
+                "row": n.row_id,
+                "parent": immediate_parent,
+                # ── Flat palette fields (Fix B) ──
+                "shape": ns.shape,
+                "bgcolor": ns.fill_color,
+                "bordercolor": ns.border_color,
+                "borderwidth": ns.border_width,
+                "borderstyle": ns.border_style,
+                "fontcolor": ns.font_color,
+                "fontsize": ns.font_size,
+            },
+        }
+        out_nodes.append(node_obj)
+
+    # ── Fix B: flat palette fields on edges ──────────────────────────────────
+    for e in graph.edges:
+        es = palette.get_edge_style(e.canonical)
+        is_symmetric = e.canonical in SYMMETRIC
+        out_edges.append({
+            "data": {
+                "id": f"{e.source_id}__{e.canonical}__{e.target_id}",
+                "source": e.source_id,
+                "target": e.target_id,
+                "label": display_label(e.canonical, locale="it"),
+                "canonical": e.canonical,
+                # ── Flat palette fields (Fix B) ──
+                "linecolor": es.line_color,
+                "linewidth": es.line_width,
+                "linestyle": es.line_style,
+                "arrowtarget": "none" if is_symmetric else es.arrow_target,
+                "arrowsource": es.arrow_source,
+                "is_dashed": "true" if e.canonical == "cuts" else "false",
+            },
+        })
+
+    return {
+        "site": graph.site,
+        "group_by": graph.group_by,
+        "rows": [
+            {
+                "row_id": r.row_id,
+                "label": r.label,
+                "periodo": r.periodo,
+                "fase": r.fase,
+                "datazione": r.datazione,
+                "is_fallback": r.is_fallback,
+            }
+            for r in graph.rows
+        ],
+        "nodes": out_nodes,
+        "edges": out_edges,
+    }

{pyarchinit_mini-2.9.0 → pyarchinit_mini-2.9.2}/pyarchinit_mini/vocab/translations/vocab_it.json

@@ -19,10 +19,14 @@
   },
   "edge_type_aliases": {
     "overlies": ["copre"],
-    "is_after": ["coperto da", "coperta da", "tagliato da", "tagliata da"],
+    "is_after": ["coperto da", "coperta da"],
+    "is_cut_by": ["tagliato da", "tagliata da"],
+    "is_filled_by": ["riempito da", "riempita da"],
+    "is_abutted_by": ["gli si appoggia"],
     "cuts": ["taglia"],
     "fills": ["riempie"],
     "abuts": ["si appoggia a", "si appoggia"],
+    "is_bonded_to": ["si lega a", "si lega_a", "connesso a", "connesso_a"],
     "has_same_time": ["uguale a"]
   }
 }

{pyarchinit_mini-2.9.0 → pyarchinit_mini-2.9.2}/pyarchinit_mini/web_interface/app.py

@@ -3991,6 +3991,16 @@ def create_app():
             db_conn = DatabaseConnection.from_url(new_db_url)
             db_manager = DatabaseManager(db_conn)
 
+            # Auto-apply schema migrations on the new DB so missing columns
+            # (e.g. node_uuid added in 2.8.x) get created without a manual
+            # `pyarchinit-mini-migrate-vocab` step. Failures are logged but
+            # do not abort the switch — read-only users will still see data
+            # they have access to, and admins can re-run the CLI migration.
+            try:
+                db_manager.run_migrations()
+            except Exception as mig_err:
+                print(f"[DATABASE SWITCH] Migration warning on {connection_name}: {mig_err}")
+
             # Reinitialize ALL services with new database manager
             global site_service, us_service, inventario_service, thesaurus_service
             global user_service, analytics_service, relationship_sync_service, datazione_service

{pyarchinit_mini-2.9.0 → pyarchinit_mini-2.9.2}/pyarchinit_mini/web_interface/harris_creator_routes.py

@@ -728,14 +728,41 @@ def api_get_swimlanes(site: str):
 
 @harris_creator_bp.get("/api/load/<site>")
 def api_load_state(site: str):
-    """Load full editor state (rows + nodes + edges) as Cytoscape JSON."""
-    # TODO(Spec-4): consider returning 404 when site is genuinely not in the
-    # DB (no site_table row), versus 200 + empty state when site exists but
-    # has no US yet. Spec §7.1 mentions 404 for site_not_found — current
-    # behavior returns 200 + empty.
-    group_by = request.args.get("group_by", "period_phase")
+    """Load full editor state (rows + nodes + edges) as Cytoscape JSON.
+
+    Pipeline selection honours SWIMLANE_PIPELINE env var:
+      - "s3dgraphy" (default): S3DProjector → flat palette fields (Fix B/C/D)
+      - "legacy": SwimlaneState.load → nested style dict (backward compat)
+    """
+    pipeline = os.environ.get("SWIMLANE_PIPELINE", "s3dgraphy").lower()
     try:
         session = _get_session()
+
+        if pipeline == "s3dgraphy":
+            # ── New pipeline: S3DProjector + flat-palette to_cytoscape ──────
+            from pyarchinit_mini.graphproj.s3d_projector import (
+                S3DProjector, VALID_GROUP_BY as S3D_VALID,
+            )
+            from pyarchinit_mini.graphproj.s3d_to_cytoscape import to_cytoscape
+
+            group_by = request.args.get("group_by", "none")
+            s3d_group_by = group_by if group_by in S3D_VALID else "none"
+            projected = S3DProjector.from_site(session, site, group_by=s3d_group_by)
+            cyto = to_cytoscape(projected)
+            # Wrap nodes/edges in the envelope renderSwimlaneState expects:
+            # each element is {data: {...}} (no nested style key — flat fields
+            # are already in data).  Pending changes not relevant for this path.
+            return jsonify({
+                "site": cyto["site"],
+                "group_by": cyto["group_by"],
+                "rows": cyto["rows"],
+                "nodes": cyto["nodes"],
+                "edges": cyto["edges"],
+                "pending_changes": {"us_updates": [], "us_inserts": [], "us_deletes": []},
+            }), 200
+
+        # ── Legacy pipeline ──────────────────────────────────────────────────
+        group_by = request.args.get("group_by", "period_phase")
         state = SwimlaneState.load(session, site, group_by=group_by)
         return jsonify({
             "site": state.site,

{pyarchinit_mini-2.9.0 → pyarchinit_mini-2.9.2}/pyarchinit_mini/web_interface/static/js/harris_creator_editor.js

@@ -320,29 +320,82 @@ function initCytoscape() {
                     'target-arrow-shape': 'none'
                 }
             },
-            // Palette-driven styles: applied when node/edge carries a `style` data object
-            // from the /api/load response (overrides defaults above).
+            // Palette-driven node styling — flat data keys (Fix B/E).
+            // Overrides the generic defaults above for US nodes loaded from /api/load.
             {
-                selector: 'node[style]',
+                selector: 'node[shape]',
+                style: {
+                    'shape': 'data(shape)',
+                    'background-color': 'data(bgcolor)',
+                    'border-color': 'data(bordercolor)',
+                    'border-width': 'data(borderwidth)',
+                    'border-style': 'data(borderstyle)',
+                    'color': 'data(fontcolor)',
+                    'font-size': 'data(fontsize)',
+                }
+            },
+            // Period row swimlanes (Fix C/E)
+            {
+                selector: 'node[?is_period_row]',
+                style: {
+                    'shape': 'roundrectangle',
+                    'background-color': '#F5F5F5',
+                    'background-opacity': 0.3,
+                    'border-color': '#9E9E9E',
+                    'border-width': 1,
+                    'label': 'data(label)',
+                    'text-valign': 'top',
+                    'text-halign': 'left',
+                    'text-margin-x': 10,
+                    'text-margin-y': 5,
+                    'font-size': 14,
+                    'font-weight': 'bold',
+                    'padding': 30,
+                }
+            },
+            // Sub-cluster compounds nested inside period rows (Fix D/E)
+            {
+                selector: 'node[?compound][!is_period_row]',
                 style: {
-                    'shape': 'data(style.shape)',
-                    'background-color': 'data(style.backgroundColor)',
-                    'border-color': 'data(style.borderColor)',
-                    'border-width': 'data(style.borderWidth)',
-                    'border-style': 'data(style.lineStyle)',
-                    'color': 'data(style.fontColor)',
-                    'font-size': 'data(style.fontSize)',
+                    'shape': 'roundrectangle',
+                    'background-color': '#FAFAFA',
+                    'background-opacity': 0.5,
+                    'border-color': '#BDBDBD',
+                    'border-width': 1,
+                    'border-style': 'dashed',
+                    'label': 'data(label)',
+                    'text-valign': 'top',
+                    'font-size': 11,
+                    'padding': 10,
+                }
+            },
+            // Palette-driven edge styling — flat data keys (Fix B/E)
+            {
+                selector: 'edge[linecolor]',
+                style: {
+                    'line-color': 'data(linecolor)',
+                    'width': 'data(linewidth)',
+                    'line-style': 'data(linestyle)',
+                    'target-arrow-shape': 'data(arrowtarget)',
+                    'source-arrow-shape': 'data(arrowsource)',
+                    'target-arrow-color': 'data(linecolor)',
+                }
+            },
+            // Dashed cuts override (Fix E)
+            {
+                selector: 'edge[is_dashed = "true"]',
+                style: {
+                    'line-style': 'dashed',
                 }
             },
+            // Symmetric edges — no arrows, double thickness (Fix E)
             {
-                selector: 'edge[style]',
+                selector: 'edge[canonical = "has_same_time"], edge[canonical = "is_bonded_to"]',
                 style: {
-                    'line-color': 'data(style.lineColor)',
-                    'width': 'data(style.lineWidth)',
-                    'line-style': 'data(style.lineStyle)',
-                    'target-arrow-shape': 'data(style.targetArrowShape)',
-                    'source-arrow-shape': 'data(style.sourceArrowShape)',
-                    'target-arrow-color': 'data(style.lineColor)',
+                    'target-arrow-shape': 'none',
+                    'source-arrow-shape': 'none',
+                    'line-style': 'solid',
+                    'width': 3,
                 }
             }
         ],

{pyarchinit_mini-2.9.0 → pyarchinit_mini-2.9.2}/pyarchinit_mini/web_interface/templates/harris_creator/editor.html

@@ -581,36 +581,57 @@ function renderSwimlaneState(state) {
     // Clear existing elements
     cy.elements().remove();
 
-    const swimlaneNodes = state.nodes.filter(el => el.data.is_swimlane);
-    const usNodes = state.nodes.filter(el => !el.data.is_swimlane);
+    // Fix G: split nodes into period row compounds, sub-cluster compounds, and US leaves.
+    // Period rows (is_period_row=true) come from new pipeline; legacy swimlane nodes
+    // (is_swimlane=true) are supported for backward compat.
+    const periodRowNodes = state.nodes.filter(el => el.data.is_period_row);
+    const clusterNodes   = state.nodes.filter(el => el.data.compound && !el.data.is_period_row && !el.data.is_swimlane);
+    const legacySwimNodes= state.nodes.filter(el => el.data.is_swimlane);
+    const usNodes        = state.nodes.filter(el => !el.data.compound && !el.data.is_swimlane);
+
+    // 1. Period row compound parents first (Fix C/G)
+    if (periodRowNodes.length > 0) {
+        cy.add(periodRowNodes.map(el => ({
+            group: 'nodes',
+            data: el.data,   // full data object — includes is_period_row, label, etc.
+        })));
+    }
 
-    // Add compound parents first (swimlanes)
-    if (swimlaneNodes.length > 0) {
-        cy.add(swimlaneNodes.map(el => ({
+    // 2. Legacy swimlane nodes (backward compat)
+    if (legacySwimNodes.length > 0) {
+        cy.add(legacySwimNodes.map(el => ({
             group: 'nodes',
             data: el.data,
             classes: 'swimlane',
         })));
     }
 
-    // Add US children with parent — pass palette style so cytoscape data(style.*) selectors apply
+    // 3. Sub-cluster compounds nested inside period rows (Fix D/G)
+    if (clusterNodes.length > 0) {
+        cy.add(clusterNodes.map(el => ({
+            group: 'nodes',
+            data: el.data,
+        })));
+    }
+
+    // 4. US leaf nodes — full data object carries flat palette fields (Fix B/G)
     if (usNodes.length > 0) {
         cy.add(usNodes.map(el => ({
             group: 'nodes',
-            data: { ...el.data, style: el.style || undefined },
+            data: el.data,
             position: el.position || undefined,
         })));
     }
 
-    // Add edges — pass palette style for line-color, line-style, arrow-shape etc.
+    // 5. Edges — full data object carries flat palette fields (Fix B/G)
     if (state.edges && state.edges.length > 0) {
         cy.add(state.edges.map(el => ({
             group: 'edges',
-            data: { ...el.data, style: el.style || undefined },
+            data: el.data,
         })));
     }
 
-    // Apply swimlane styling on the parent compound nodes
+    // Apply legacy swimlane styling for backward compat
     cy.nodes('.swimlane').forEach(n => {
         const color = n.data('color') || '#EEEEEE';
         n.style({
@@ -627,17 +648,20 @@ 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.
+    // Run dagre layout TB (recent → ancient, top-to-bottom) — Fix F.
+    // rankDir: 'TB' gives the classic Harris convention: most recent strata
+    // at the top, oldest at the bottom, with arrows pointing downward.
     try {
         cy.layout({
             name: 'dagre',
-            rankDir: 'LR',
+            rankDir: 'TB',
+            ranker: 'longest-path',
             nodeSep: 50,
+            edgeSep: 20,
             rankSep: 80,
-            fit: false,
+            animate: false,
+            fit: true,
+            padding: 30,
         }).run();
     } catch (e) {
         console.warn('dagre layout failed, falling back to grid:', e);

{pyarchinit_mini-2.9.0 → pyarchinit_mini-2.9.2/pyarchinit_mini.egg-info}/PKG-INFO

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

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

@@ -41,38 +41,51 @@ def client(tmp_path, monkeypatch):
 
 
 def test_api_load_returns_palette_styled_nodes(client):
+    """US nodes carry flat palette fields in data (Fix B); no nested style dict."""
     r = client.get("/harris-creator/api/load/S")
     assert r.status_code == 200, r.data[:300]
     body = r.get_json()
     assert "nodes" in body and "edges" in body
-    assert len(body["nodes"]) >= 2
-    node = body["nodes"][0]
-    assert "style" in node
-    assert isinstance(node["style"], dict)
-    assert "shape" in node["style"]
-    assert "backgroundColor" in node["style"]
+    # Period row compound + 2 US nodes = at least 3 total
+    us_nodes = [n for n in body["nodes"] if n["data"].get("us")]
+    assert len(us_nodes) >= 2
+    node = us_nodes[0]
+    # Flat palette keys in data (Fix B)
+    assert "shape" in node["data"], f"Expected flat 'shape' in data, got keys: {list(node['data'].keys())}"
+    assert "bgcolor" in node["data"]
+    assert node["data"]["bgcolor"].startswith("#")
+    # No nested style dict
+    assert "style" not in node, "flat-field contract: no nested 'style' key on node"
 
 
-def test_api_load_emits_edges_with_style(client):
+def test_api_load_emits_edges_with_flat_fields(client):
+    """Edges carry flat palette fields in data (Fix B); direction normalized to forward."""
     r = client.get("/harris-creator/api/load/S")
     assert r.status_code == 200
     body = r.get_json()
     assert len(body["edges"]) >= 1
     e = body["edges"][0]
-    # Edge labels are italianized for the swimlane UI (locale=it); canonical kept in data.canonical
-    assert e["data"]["label"] in {"Copre", "Coperto da"}
-    assert e["data"]["canonical"] in {"overlies", "is_after"}
-    assert "style" in e
-    assert isinstance(e["style"], dict)
-    assert "lineColor" in e["style"]
+    # After Fix A, only forward canonicals: 'Copre' / 'overlies'
+    assert e["data"]["label"] == "Copre", f"Expected 'Copre', got {e['data']['label']!r}"
+    assert e["data"]["canonical"] == "overlies", f"Expected 'overlies', got {e['data']['canonical']!r}"
+    # Flat palette keys in data (Fix B)
+    assert "linecolor" in e["data"], f"Expected flat 'linecolor' in data, got keys: {list(e['data'].keys())}"
+    assert "arrowtarget" in e["data"]
+    # No nested style dict
+    assert "style" not in e, "flat-field contract: no nested 'style' key on edge"
 
 
 def test_api_load_with_group_by_area_yields_compound_parents(client):
+    """Period row + sub-cluster compounds present when group_by=area (Fix C/D)."""
     r = client.get("/harris-creator/api/load/S?group_by=area")
     assert r.status_code == 200
     body = r.get_json()
-    parents = [n for n in body["nodes"] if n["data"].get("compound")]
-    assert len(parents) >= 1
+    # At minimum: 1 period-row compound always present (Fix C)
+    period_rows = [n for n in body["nodes"] if n["data"].get("is_period_row")]
+    assert len(period_rows) >= 1
+    # With group_by=area and US in area 'A', also a sub-cluster compound
+    all_compounds = [n for n in body["nodes"] if n["data"].get("compound")]
+    assert len(all_compounds) >= 1
 
 
 def test_api_load_unknown_site_returns_empty(client):

{pyarchinit_mini-2.9.0 → pyarchinit_mini-2.9.2}/tests/unit/test_rapporti_codec.py

@@ -43,9 +43,11 @@ def test_parse_italian_extras_resolve():
         current_site="S",
     )
     cans = [r.canonical for r in items]
-    assert "is_after" in cans          # riempito da
+    # "Riempito da" is the inverse of "fills" → is_filled_by (not is_after)
+    assert "is_filled_by" in cans      # riempito da — corrected from old wrong mapping
     assert "is_bonded_to" in cans      # si lega a
-    assert "is_before" in cans         # gli si appoggia
+    # "Gli si appoggia" is the inverse of "abuts" → is_abutted_by (not is_before)
+    assert "is_abutted_by" in cans     # gli si appoggia — corrected from old wrong mapping
 
 
 def test_parse_unknown_label_yields_none():