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

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

@@ -1,3 +1,29 @@
+## 2.8.0 — 2026-05-19
+
+### Added — EM Palette + Multi-Format Swimlane Round-Trip
+- **EM palette is now the canonical style source** for swimlane rendering, GraphML export, and Heriverse/ATON JSON export. Palette loaded from `pyarchinit_mini/graphml_converter/templates/EM_palette.graphml` (3246-line canonical version) with `PaletteLoader` cache + SIGHUP hot-reload + fallback to minimal hardcoded defaults if missing.
+- **`SWIMLANE_PIPELINE=s3dgraphy|legacy` feature flag** (default `s3dgraphy`) with automatic legacy fallback on exception. Set to `legacy` to roll back instantly.
+- **New endpoints**:
+  - `GET /harris-creator/api/export/<site>/heriverse-json` — Heriverse/ATON JSON (single format).
+  - `POST /harris-creator/api/import/<site>/graphml` — yEd GraphML import that writes 4-tuple rapporti and inverses on BOTH involved US.
+  - `POST /harris-creator/api/import/<site>/json` — Heriverse JSON import (same write path).
+- **Standalone `/matrix-tools` page** for import/export operations (site picker + format radio + file uploader).
+- **Per-site export buttons** (GraphML, Heriverse) in sites list.
+- **Swimlane toolbar**: grouping dropdown (none/area/settore/quadrato/attività/strutture), export menu, import file picker.
+- **Bilingual rapporti parser**: reads both legacy 2-tuple `[rel, us]` and new 4-tuple `[rel, us, area, sito]`; always writes 4-tuple. Italian aliases include extras (`riempito da`, `si lega a`, `gli si appoggia`) absent from `vocab_it.json`.
+- **Automatic stub US creation** when import edges reference missing rows; counted in result.
+
+### Changed
+- Swimlane rows are now always periods (with "Periodo 1" fallback when `period_table` is empty or a US has no period match); the old `group_by=period_phase|struttura|...` registry collapses to a sub-grouping selector within rows. Legacy `group_by` values still work via the `legacy` pipeline.
+- `/api/load/<site>` response includes a `style` dict per node and edge, derived from the EM palette (shape, fill color, border color, line style, arrow heads).
+
+### Internals
+- New modules: `pyarchinit_mini/em_palette/` (loader, styles), `pyarchinit_mini/graphproj/` (rapporti_codec, s3d_projector, s3d_to_cytoscape, graph_to_db, heriverse_parser, graphml_reader, graphml_writer).
+- New tests: 13 test files across `tests/unit/` and `tests/integration/`, plus a regression fixture (`tests/fixtures/adarte_regression_dump.sql`) anonymized from `Rimini_RN_2020_21_Museo_Fellini` (100 US, 516 edges, 8 distinct canonical labels validated end-to-end).
+
+### Migration notes
+- The `patch_pyarchinit_post_upgrade.py` post-upgrade script's Section 27 (`swimlane.row_provider_schema`) and Section 28 (`swimlane.build_edges_literal`) still apply, but their fixes are now native to the s3dgraphy pipeline. After this upgrade, Sections 27/28 are no-ops if the legacy file no longer has the markers.
+
 ## [2.7.1] - 2026-05-19
 
 ### Fixed (IT)

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

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

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

pyarchinit_mini-2.8.0/pyarchinit_mini/em_palette/__init__.py

@@ -0,0 +1,11 @@
+"""EM (Extended Matrix) palette: style source of truth for US nodes and stratigraphic edges."""
+from .loader import PaletteLoader, get_palette, install_sighup_reload
+from .styles import NodeStyle, EdgeStyle
+
+__all__ = [
+    "PaletteLoader",
+    "get_palette",
+    "install_sighup_reload",
+    "NodeStyle",
+    "EdgeStyle",
+]

pyarchinit_mini-2.8.0/pyarchinit_mini/em_palette/loader.py

@@ -0,0 +1,171 @@
+"""EM palette GraphML parser with caching and hot-reload.
+
+The palette is a yEd-flavoured GraphML document where each <node> represents
+one canonical US type (USM, USD, USV, SF, VSF, TSU, USVn) and each <edge>
+represents one canonical stratigraphic relation (overlies, cuts, fills, abuts,
+has_same_time, is_after, is_before, is_bonded_to).
+
+Unit type and canonical relation are identified by the text content of
+<y:NodeLabel> and <y:EdgeLabel> respectively.
+"""
+from __future__ import annotations
+
+import logging
+import signal
+import threading
+import xml.etree.ElementTree as ET
+from pathlib import Path
+from typing import Dict, Optional
+
+from .styles import NodeStyle, EdgeStyle
+
+
+logger = logging.getLogger(__name__)
+
+NS = {
+    "g": "http://graphml.graphdrawing.org/xmlns",
+    "y": "http://www.yworks.com/xml/graphml",
+}
+
+DEFAULT_PALETTE_PATH = (
+    Path(__file__).parent.parent
+    / "graphml_converter" / "templates" / "EM_palette.graphml"
+)
+
+
+class PaletteLoader:
+    def __init__(
+        self,
+        palette_path: Optional[Path] = None,
+        *,
+        allow_fallback: bool = True,
+    ) -> None:
+        self.palette_path = palette_path or DEFAULT_PALETTE_PATH
+        self.allow_fallback = allow_fallback
+        self._node_cache: Dict[str, NodeStyle] = {}
+        self._edge_cache: Dict[str, EdgeStyle] = {}
+        self._loaded = False
+        self._lock = threading.Lock()
+
+    def _load(self) -> None:
+        with self._lock:
+            if self._loaded:
+                return
+            try:
+                tree = ET.parse(self.palette_path)
+            except (FileNotFoundError, ET.ParseError) as exc:
+                if self.allow_fallback:
+                    logger.warning(
+                        "Palette load failed (%s); using hardcoded fallbacks.", exc,
+                    )
+                    self._loaded = True
+                    return
+                raise
+            root = tree.getroot()
+            for node_el in root.iter(f"{{{NS['g']}}}node"):
+                style = self._parse_node(node_el)
+                if style is not None:
+                    self._node_cache[style.unit_type] = style
+            for edge_el in root.iter(f"{{{NS['g']}}}edge"):
+                style = self._parse_edge(edge_el)
+                if style is not None:
+                    self._edge_cache[style.canonical_name] = style
+            self._loaded = True
+
+    def _parse_node(self, node_el: ET.Element) -> Optional[NodeStyle]:
+        shape_node = node_el.find(f".//{{{NS['y']}}}ShapeNode")
+        if shape_node is None:
+            return None
+        label = shape_node.find(f".//{{{NS['y']}}}NodeLabel")
+        if label is None or not (label.text and label.text.strip()):
+            return None
+        unit_type = label.text.strip()
+        shape_el = shape_node.find(f"{{{NS['y']}}}Shape")
+        shape = shape_el.attrib.get("type", "rectangle") if shape_el is not None else "rectangle"
+        fill_el = shape_node.find(f"{{{NS['y']}}}Fill")
+        fill_color = fill_el.attrib.get("color", "#FFFFFF") if fill_el is not None else "#FFFFFF"
+        border_el = shape_node.find(f"{{{NS['y']}}}BorderStyle")
+        if border_el is not None:
+            border_color = border_el.attrib.get("color", "#000000")
+            border_width = float(border_el.attrib.get("width", "1.0"))
+            border_style = border_el.attrib.get("type", "line")
+        else:
+            border_color = "#000000"
+            border_width = 1.0
+            border_style = "line"
+        font_color = label.attrib.get("textColor", "#000000")
+        font_size = int(label.attrib.get("fontSize", "12"))
+        return NodeStyle(
+            unit_type=unit_type,
+            shape=shape,
+            fill_color=fill_color,
+            border_color=border_color,
+            border_width=border_width,
+            border_style=border_style,
+            font_color=font_color,
+            font_size=font_size,
+        )
+
+    def _parse_edge(self, edge_el: ET.Element) -> Optional[EdgeStyle]:
+        line_el = edge_el.find(f".//{{{NS['y']}}}LineStyle")
+        label_el = edge_el.find(f".//{{{NS['y']}}}EdgeLabel")
+        arrow_el = edge_el.find(f".//{{{NS['y']}}}Arrows")
+        if label_el is None or not (label_el.text and label_el.text.strip()):
+            return None
+        canonical = label_el.text.strip().lower().replace(" ", "_")
+        if not canonical:
+            return None
+        if line_el is not None:
+            line_color = line_el.attrib.get("color", "#000000")
+            line_width = float(line_el.attrib.get("width", "1.0"))
+            line_style = line_el.attrib.get("type", "line")
+        else:
+            line_color = "#000000"
+            line_width = 1.0
+            line_style = "line"
+        if arrow_el is not None:
+            arrow_target = arrow_el.attrib.get("target", "standard")
+            arrow_source = arrow_el.attrib.get("source", "none")
+        else:
+            arrow_target = "standard"
+            arrow_source = "none"
+        return EdgeStyle(
+            canonical_name=canonical,
+            line_color=line_color,
+            line_width=line_width,
+            line_style=line_style,
+            arrow_target=arrow_target,
+            arrow_source=arrow_source,
+        )
+
+    def get_node_style(self, unit_type: str) -> NodeStyle:
+        self._load()
+        return self._node_cache.get(unit_type, NodeStyle(unit_type=unit_type))
+
+    def get_edge_style(self, canonical_name: str) -> EdgeStyle:
+        self._load()
+        return self._edge_cache.get(canonical_name, EdgeStyle(canonical_name=canonical_name))
+
+    def reload(self) -> None:
+        with self._lock:
+            self._node_cache.clear()
+            self._edge_cache.clear()
+            self._loaded = False
+        self._load()
+
+
+_singleton: Optional[PaletteLoader] = None
+
+
+def get_palette() -> PaletteLoader:
+    global _singleton
+    if _singleton is None:
+        _singleton = PaletteLoader()
+    return _singleton
+
+
+def install_sighup_reload() -> None:
+    def _handler(_signum, _frame):
+        logger.info("SIGHUP received: reloading EM palette")
+        get_palette().reload()
+    signal.signal(signal.SIGHUP, _handler)

pyarchinit_mini-2.8.0/pyarchinit_mini/em_palette/styles.py

@@ -0,0 +1,27 @@
+"""Dataclasses for palette-derived rendering styles."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class NodeStyle:
+    unit_type: str
+    shape: str = "rectangle"  # rectangle, ellipse, roundrectangle, parallelogram, hexagon, octagon
+    fill_color: str = "#FFFFFF"
+    border_color: str = "#000000"
+    border_width: float = 1.0
+    border_style: str = "line"  # line, dashed, dotted
+    font_color: str = "#000000"
+    font_size: int = 12
+    label_placement: str = "center"
+
+
+@dataclass(frozen=True)
+class EdgeStyle:
+    canonical_name: str
+    line_color: str = "#000000"
+    line_width: float = 1.0
+    line_style: str = "line"  # line, dashed, dotted
+    arrow_source: str = "none"
+    arrow_target: str = "standard"