pyarchinit-mini 2.8.0__tar.gz → 2.9.1__tar.gz

{pyarchinit_mini-2.8.0 → pyarchinit_mini-2.9.1}/CHANGELOG.md

@@ -1,3 +1,43 @@
+## 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)
+- **Toolbar consolidated**: removed duplicate `swimlane-toolbar` block. Single `Esporta` dropdown now contains yEd GraphML (.graphml), Heriverse/ATON JSON (.json), Graphviz DOT, PNG. `Importa` button accepts both .graphml and .json. The existing `group-by-selector` now uses the new vocabulary: Nessun raggruppamento / Area / Settore / Quadrato / Attività / Strutture (was: Period+Phase / Struttura / Attivita / Settore / Area / Ambient / Saggio / Quad-Par / No grouping).
+- **Edge labels italianized**: swimlane web + GraphML export now show `Copre`/`Coperto da`/`Taglia`/`Tagliato da`/`Riempie`/`Riempito da`/`Si appoggia a`/`Gli si appoggia`/`Uguale a`/`Si lega a`/`Anteriore a` (locale `it`) or `Covers`/`Covered by`/etc (locale `en`) instead of canonical `overlies`/`is_after`/`cuts`/etc. Canonical kept in `data.canonical` for JS class hooks.
+- **Inverse-edge dedup**: when both `A overlies B` and `B is_after A` exist (data redundancy), draw only the forward direction — no more overlapping labels at the same midpoint.
+- **Transitive reduction**: if A→B→C exists, A→C is no longer drawn (per-canonical, only for DAGs). Applied via `networkx.transitive_reduction`. Adarte fixture: 516 → 343 edges (clean Harris Matrix layout).
+- **Palette-driven frontend rendering**: cytoscape selectors `node[style]` and `edge[style]` now read `data.style.{shape,backgroundColor,borderColor,borderWidth,lineColor,…}` from the `/api/load` payload and apply them. US nodes finally appear with their palette colors/shapes (USM red border, USV octagonal, …) instead of default gray.
+- **GraphML export rewritten**: now produces the proper Harris Matrix Creator format via `pyarchinit_mini.graphml_io.yed_writer.write_extended_matrix_graphml` — TableNode wrapper with `<y:Rows>` per period/fase (colored backgrounds, rotated labels like "Periodo 1 - Fase 1"), nodes positioned inside their period row, palette styles, italianized edge labels. Previously the writer just appended nodes to the palette template without TableNode rows.
+
+### Internals
+- New `rapporti_codec.CANONICAL_TO_ITALIAN`/`CANONICAL_TO_ENGLISH`/`display_label(canonical, locale)` (moved from `graph_to_db.py`).
+- `s3d_projector._load_edges` post-process: inverse dedup + per-canonical `nx.transitive_reduction` (skipped for SYMMETRIC and cyclic graphs).
+- `s3d_to_cytoscape` edges now carry `data.label` (italian display) AND `data.canonical` (English canonical for JS hooks).
+- `graphml_writer.write_graphml` now bridges to the existing `yed_writer.write_extended_matrix_graphml` via a temp file.
+- `harris_creator_editor.js`: 2 new cytoscape selectors (`node[style]`, `edge[style]`) read palette properties from element data.
+- `editor.html`: removed `swimlane-toolbar` div + duplicate `group-by-select` + standalone `export-graphml-btn`/`export-dot-btn`/`export-png-btn` + `exportYedGraphml()` button; replaced with one unified `Esporta` dropdown + `Importa` button.
+
 ## 2.8.0 — 2026-05-19
 
 ### Added — EM Palette + Multi-Format Swimlane Round-Trip

{pyarchinit_mini-2.8.0/pyarchinit_mini.egg-info → pyarchinit_mini-2.9.1}/PKG-INFO

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

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

{pyarchinit_mini-2.8.0 → pyarchinit_mini-2.9.1}/pyarchinit_mini/graphproj/graph_to_db.py

@@ -15,6 +15,7 @@ from pyarchinit_mini.graphproj.rapporti_codec import (
     INVERSE_PAIRS,
     SYMMETRIC,
     Rapporto,
+    CANONICAL_TO_ITALIAN,
 )
 from pyarchinit_mini.graphproj.s3d_projector import ProjectedGraph, Node
 
@@ -22,22 +23,6 @@ from pyarchinit_mini.graphproj.s3d_projector import ProjectedGraph, Node
 logger = logging.getLogger(__name__)
 
 
-# Canonical → italian display label (used when serializing).
-CANONICAL_TO_ITALIAN: Dict[str, str] = {
-    "overlies": "Copre",
-    "is_after": "Coperto da",
-    "cuts": "Taglia",
-    "is_cut_by": "Tagliato da",
-    "fills": "Riempie",
-    "is_filled_by": "Riempito da",
-    "abuts": "Si appoggia a",
-    "is_abutted_by": "Gli si appoggia",
-    "has_same_time": "Uguale a",
-    "is_bonded_to": "Si lega a",
-    "is_before": "Anteriore a",
-}
-
-
 @dataclass
 class WriteResult:
     imported_us: int = 0

pyarchinit_mini-2.9.1/pyarchinit_mini/graphproj/graphml_writer.py

@@ -0,0 +1,143 @@
+"""yEd-flavoured GraphML writer producing the EM Harris Matrix Creator format.
+
+Strategy (Approach A): thin bridge from ProjectedGraph to the canonical
+graphml_io.yed_writer.write_extended_matrix_graphml which already produces the
+proper TableNode / swimlane format consumed by yEd Desktop.
+
+Output:
+  - Standalone GraphML (no palette template merging)
+  - ONE group node with <y:TableNode YED_TABLE_NODE> containing one <y:Row>
+    per period row from the ProjectedGraph
+  - US nodes positioned inside their row's y-range
+  - Edges with italianized labels (Copre, Taglia, …) via rapporti_codec
+"""
+from __future__ import annotations
+
+import tempfile
+import os
+from pathlib import Path
+from typing import Optional
+
+from pyarchinit_mini.graphproj.s3d_projector import ProjectedGraph
+from pyarchinit_mini.graphproj.rapporti_codec import display_label, CANONICAL_TO_ITALIAN
+
+
+def write_graphml(graph: ProjectedGraph, *, palette_path: Optional[Path] = None) -> bytes:
+    """Render the projected graph as yEd-compatible GraphML bytes.
+
+    palette_path is accepted for backward-compatible call-sites but is ignored —
+    the new output is a standalone TableNode document, not a palette extension.
+    """
+    from pyarchinit_mini.harris_swimlane.swimlane_state import CytoscapeElement
+    from pyarchinit_mini.harris_swimlane.row_provider import Row as LegacyRow, PERIOD_COLORS
+
+    # ------------------------------------------------------------------
+    # 1. Convert ProjectedGraph.rows → legacy Row objects
+    # ------------------------------------------------------------------
+    rows: list[LegacyRow] = []
+    for i, r in enumerate(graph.rows):
+        rows.append(LegacyRow(
+            row_id=r.row_id,
+            period_name=r.periodo or r.label,
+            phase_name=r.fase,
+            start_date=None,
+            end_date=None,
+            color=PERIOD_COLORS[i % len(PERIOD_COLORS)],
+            source="period_table" if not r.is_fallback else "fallback",
+        ))
+
+    # ------------------------------------------------------------------
+    # 2. Convert ProjectedGraph.nodes → CytoscapeElement list
+    # ------------------------------------------------------------------
+    # Build a lookup: row_id → index so we can calculate y positions
+    row_index = {r.row_id: i for i, r in enumerate(graph.rows)}
+    row_height = 200
+    node_h, node_w = 30.0, 80.0
+    # Track column (x) per row so nodes in the same row are spread horizontally
+    col_counter: dict[str, int] = {}
+
+    nodes: list[CytoscapeElement] = []
+    for n in graph.nodes:
+        ri = row_index.get(n.row_id, 0)
+        col = col_counter.get(n.row_id, 0)
+        col_counter[n.row_id] = col + 1
+        x = col * (node_w + 20) + 30
+        y = ri * row_height + (row_height / 2 - node_h / 2)
+
+        nodes.append(CytoscapeElement(
+            data={
+                "id": n.node_id,
+                "us": n.us,
+                "us_number": n.us,
+                "area": n.area or "",
+                "unit_type": n.unit_type or "US",
+                "description": n.description or "",
+                "row": n.row_id,
+                "label": str(n.us),
+            },
+            position={"x": x, "y": y},
+        ))
+
+    # ------------------------------------------------------------------
+    # 3. Convert ProjectedGraph.edges → CytoscapeElement list with italian labels
+    # ------------------------------------------------------------------
+    edges: list[CytoscapeElement] = []
+    for e in graph.edges:
+        italian = display_label(e.canonical, locale="it")
+        edges.append(CytoscapeElement(
+            data={
+                "id": f"{e.source_id}__{e.canonical}__{e.target_id}",
+                "source": e.source_id,
+                "target": e.target_id,
+                "label": italian,
+                "canonical": e.canonical,
+                "relationship": CANONICAL_TO_ITALIAN.get(e.canonical, e.canonical),
+            },
+        ))
+
+    # ------------------------------------------------------------------
+    # 4. Build a minimal state-like object the legacy writer accepts
+    # ------------------------------------------------------------------
+    class _State:
+        def __init__(self):
+            self.site = graph.site
+            self.group_by = graph.group_by
+            self.rows = rows
+            self.nodes = nodes
+            self.edges = edges
+            self.pending_changes = {}
+
+    state = _State()
+
+    # ------------------------------------------------------------------
+    # 5. Call the canonical writer and return bytes
+    # ------------------------------------------------------------------
+    from pyarchinit_mini.graphml_io.yed_writer import write_extended_matrix_graphml
+
+    epochs: list[dict] = []
+    # Populate epochs from rows that have dating information
+    for r in graph.rows:
+        if r.datazione:
+            epochs.append({
+                "row_id": r.row_id,
+                "periodo": r.periodo,
+                "fase": r.fase,
+                "datazione": r.datazione,
+            })
+
+    with tempfile.NamedTemporaryFile(suffix=".graphml", delete=False) as tmp:
+        tmp_path = tmp.name
+    try:
+        write_extended_matrix_graphml(
+            state,
+            site_meta={"sito": graph.site},
+            epochs=epochs,
+            out=Path(tmp_path),
+        )
+        with open(tmp_path, "rb") as f:
+            return f.read()
+    finally:
+        try:
+            os.unlink(tmp_path)
+        except OSError:
+            pass

{pyarchinit_mini-2.8.0 → pyarchinit_mini-2.9.1}/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,16 +45,58 @@ 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).
+CANONICAL_TO_ITALIAN: Dict[str, str] = {
+    "overlies": "Copre",
+    "is_after": "Coperto da",
+    "cuts": "Taglia",
+    "is_cut_by": "Tagliato da",
+    "fills": "Riempie",
+    "is_filled_by": "Riempito da",
+    "abuts": "Si appoggia a",
+    "is_abutted_by": "Gli si appoggia",
+    "has_same_time": "Uguale a",
+    "is_bonded_to": "Si lega a",
+    "is_before": "Anteriore a",
+}
+
+# Canonical → english display label.
+CANONICAL_TO_ENGLISH: Dict[str, str] = {
+    "overlies": "Covers",
+    "is_after": "Covered by",
+    "cuts": "Cuts",
+    "is_cut_by": "Cut by",
+    "fills": "Fills",
+    "is_filled_by": "Filled by",
+    "abuts": "Leans on",
+    "is_abutted_by": "Leant on by",
+    "has_same_time": "Same as",
+    "is_bonded_to": "Bonded to",
+    "is_before": "Before",
+}
+
+
+def display_label(canonical: str, locale: str = "it") -> str:
+    """Return the localized display label for a canonical relation name."""
+    if locale.lower().startswith("en"):
+        return CANONICAL_TO_ENGLISH.get(canonical, canonical)
+    return CANONICAL_TO_ITALIAN.get(canonical, canonical)
+
+
 # English fallbacks (Al-Khutm-style data).
 _EN_TO_CANONICAL: Dict[str, str] = {
     "covers": "overlies",

{pyarchinit_mini-2.8.0 → pyarchinit_mini-2.9.1}/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
+from pyarchinit_mini.graphproj.rapporti_codec import parse_rapporti, SYMMETRIC, INVERSE_PAIRS, REVERSE_TO_FORWARD
 
 
 logger = logging.getLogger(__name__)
@@ -217,14 +217,70 @@ 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).
+        forward_keys: set = set()
+        for e in graph.edges:
+            if e.canonical in SYMMETRIC:
+                continue
+            forward_keys.add((e.canonical, e.source_id, e.target_id))
+        kept: List[Edge] = []
+        for e in graph.edges:
+            if e.canonical in SYMMETRIC:
+                kept.append(e)
+                continue
+            inv = INVERSE_PAIRS.get(e.canonical)
+            # If the forward counterpart of this inverse is already in the set, drop it
+            if inv is not None and (inv, e.target_id, e.source_id) in forward_keys:
+                if e.canonical > inv:
+                    continue  # drop; the lexicographically-first orientation wins
+            kept.append(e)
+        graph.edges = kept
+
+        # === Step B: Transitive reduction per canonical type ===
+        # If A→B and B→C exist under the same canonical, drop A→C.
+        try:
+            import networkx as nx
+            reduced: List[Edge] = []
+            by_canon: Dict[str, List[Edge]] = {}
+            for e in graph.edges:
+                by_canon.setdefault(e.canonical, []).append(e)
+            for canon, edges in by_canon.items():
+                if canon in SYMMETRIC:
+                    reduced.extend(edges)
+                    continue
+                dg = nx.DiGraph()
+                for ed in edges:
+                    dg.add_edge(ed.source_id, ed.target_id)
+                try:
+                    tr = nx.transitive_reduction(dg)
+                    keep_set = set(tr.edges())
+                    for ed in edges:
+                        if (ed.source_id, ed.target_id) in keep_set:
+                            reduced.append(ed)
+                except nx.NetworkXError:
+                    reduced.extend(edges)
+            graph.edges = reduced
+        except ImportError:
+            pass  # networkx not available; skip reduction

pyarchinit_mini-2.9.1/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.8.0 → pyarchinit_mini-2.9.1}/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"]
   }
 }