s3dgraphy 1.6.0.dev6__tar.gz → 1.6.0.dev7__tar.gz

{s3dgraphy-1.6.0.dev6/src/s3dgraphy.egg-info → s3dgraphy-1.6.0.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: s3dgraphy
-Version: 1.6.0.dev6
+Version: 1.6.0.dev7
 Summary: 3D Stratigraphic Graph Management Library for archaeological and heritage applications
 Author-email: Emanuel Demetrescu <emanuel.demetrescu@cnr.it>
 Maintainer-email: Emanuel Demetrescu <emanuel.demetrescu@cnr.it>

{s3dgraphy-1.6.0.dev6 → s3dgraphy-1.6.0.dev7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "s3dgraphy"
-version = "1.6.0.dev6"
+version = "1.6.0.dev7"
 description = "3D Stratigraphic Graph Management Library for archaeological and heritage applications"
 readme = "README.md"
 requires-python = ">=3.9"

{s3dgraphy-1.6.0.dev6 → s3dgraphy-1.6.0.dev7}/src/s3dgraphy/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.6.0.dev6"
+__version__ = "1.6.0.dev7"
 __datamodel_version__ = "1.5.5"  # s3Dgraphy connections datamodel version
 
 # s3Dgraphy/__init__.py

{s3dgraphy-1.6.0.dev6 → s3dgraphy-1.6.0.dev7}/src/s3dgraphy/exporter/graphml/canvas_generator.py

@@ -68,7 +68,7 @@ class CanvasGenerator:
         return root
 
     def _add_node_keys(self, root: ET.Element):
-        """Add key definitions for nodes (d4-d8)."""
+        """Add key definitions for nodes (d4-d8, d13)."""
         # d4: url
         key = ET.SubElement(root, '{http://graphml.graphdrawing.org/xmlns}key')
         key.set('attr.name', 'url')
@@ -104,6 +104,27 @@ class CanvasGenerator:
         key.set('for', 'node')
         key.set('id', 'd8')
 
+        # d13: physical_relationships (EM 1.6 per-node packed string)
+        #
+        # Per-node serialisation of the canonical physical stratigraphic
+        # edges, in the same list-of-lists Python-literal format used by
+        # the pyArchInit ``us_table.rapporti`` column. yEd reserves edges
+        # for the temporal Matrix layer, so the EM 1.6 palette surfaces
+        # these relationships as a per-node attribute instead — visible
+        # to humans editing the file in yEd, and byte-identical with the
+        # pyArchInit column when the graph between them is unmutated.
+        #
+        # The exporter writes this attribute on every stratigraphic node
+        # whose canonical edges include physical-stratigraphic types;
+        # the importer reads it only when the richer graph-level JSON
+        # side channel (``_s3d_physical_relations``) is absent. See
+        # ``s3dgraphy.sync.rapporti`` for the canonical vocabulary.
+        key = ET.SubElement(root, '{http://graphml.graphdrawing.org/xmlns}key')
+        key.set('attr.name', 'physical_relationships')
+        key.set('attr.type', 'string')
+        key.set('for', 'node')
+        key.set('id', 'd13')
+
     def _add_edge_keys(self, root: ET.Element):
         """Add key definitions for edges (d10-d12)."""
         # d10: edgegraphics (yfiles)

{s3dgraphy-1.6.0.dev6 → s3dgraphy-1.6.0.dev7}/src/s3dgraphy/exporter/graphml/graphml_exporter.py

@@ -142,6 +142,40 @@ class GraphMLExporter:
         # side channel restores all three on import.
         self._write_property_metadata_data(graph_elem, canvas)
 
+        # 1d. Snapshot per-US-node physical_relationships (the EM 1.6
+        # palette per-node packed string format, byte-identical with the
+        # pyArchInit ``us_table.rapporti`` column). Computed BEFORE the
+        # transitive reduction below so the canonical edges are still
+        # present; stashed for NodeGenerator to attach as ``<data
+        # key="d13">`` on each stratigraphic node. See
+        # ``s3dgraphy.sync.rapporti.serialize_rapporti_from_edges`` for
+        # the format and ``canvas_generator._add_node_keys`` (d13) for
+        # the key declaration.
+        try:
+            from ...sync.rapporti import serialize_rapporti_from_edges
+            # Pick the site name to stamp into the 4th column of each
+            # rapporto entry. Graph.__init__ stores the caller-supplied
+            # identifier on ``graph_id`` and leaves ``name`` empty by
+            # default, so ``graph_id`` is the most reliable signal in
+            # practice — but we still consult ``name`` / ``sito`` for
+            # consumers that populate them explicitly.
+            default_sito = (
+                getattr(self.graph, "graph_id", None)
+                or getattr(self.graph, "name", None)
+                or getattr(self.graph, "sito", None)
+                or ""
+            )
+            # ``name`` may be a dict in the s3dgraphy Graph schema; only
+            # str values are valid for the pyArchInit column.
+            if not isinstance(default_sito, str):
+                default_sito = ""
+            self._physical_relationships_by_node: Dict[str, list] = (
+                serialize_rapporti_from_edges(self.graph, default_sito))
+        except Exception as exc:  # pragma: no cover - defensive
+            print(f"  [physical_relationships] skipped serialization: "
+                  f"{exc}")
+            self._physical_relationships_by_node = {}
+
         # Allocate palette refids starting from 4 (1-3 are reserved for
         # SVG extractor/combiner/continuity emitted by CanvasGenerator).
         # Populated as AuthorNode / LicenseNode / EmbargoNode instances
@@ -150,7 +184,10 @@ class GraphMLExporter:
         self._next_palette_refid: int = 4
 
         # 2. Initialize generators
-        node_gen = NodeGenerator(self.node_registry, self.id_manager)
+        node_gen = NodeGenerator(
+            self.node_registry, self.id_manager,
+            physical_relationships_by_node=self._physical_relationships_by_node,
+        )
         group_gen = GroupNodeGenerator(self.node_registry, self.id_manager)
         edge_gen = EdgeGenerator(self.id_manager)
 

{s3dgraphy-1.6.0.dev6 → s3dgraphy-1.6.0.dev7}/src/s3dgraphy/exporter/graphml/node_generator.py

@@ -15,17 +15,30 @@ from .utils import IDManager, calculate_node_width, generate_uuid
 class NodeGenerator:
     """Generates GraphML XML for various node types."""
 
-    def __init__(self, registry: NodeRegistry, id_manager: IDManager):
+    def __init__(self, registry: NodeRegistry, id_manager: IDManager,
+                 physical_relationships_by_node: Optional[dict] = None):
         """
         Initialize node generator.
-        
+
         Args:
             registry: Node registry with visual properties
             id_manager: ID manager for nested IDs
+            physical_relationships_by_node: Optional pre-computed dict
+                mapping ``node_id`` → list of
+                ``[label, target_us, area, sito]`` entries (the
+                pyArchInit list-of-lists serialisation produced by
+                :func:`s3dgraphy.sync.rapporti.serialize_rapporti_from_edges`).
+                When provided, ``generate_stratigraphic_node`` emits a
+                ``<data key="d13">`` element with the Python-literal
+                ``repr`` of the entry list — the EM 1.6 palette format
+                for per-node physical relationships. Unknown / missing
+                node ids are silently ignored.
         """
         self.registry = registry
         self.id_manager = id_manager
         self.ns_y = 'http://www.yworks.com/xml/graphml'
+        self._physical_relationships_by_node = (
+            physical_relationships_by_node or {})
 
     def generate_stratigraphic_node(self, node, x: float = 100.0, y: float = 100.0,
                                     parent_id: Optional[str] = None) -> ET.Element:
@@ -72,7 +85,24 @@ class NodeGenerator:
         data_d7 = ET.SubElement(node_elem, '{http://graphml.graphdrawing.org/xmlns}data')
         data_d7.set('key', 'd7')
         data_d7.text = node_uuid
-        
+
+        # Add physical_relationships (d13) — EM 1.6 per-node packed
+        # string. The exporter pre-computes a dict ``node_id → list``
+        # using :func:`s3dgraphy.sync.rapporti.serialize_rapporti_from_edges`
+        # before the transitive reduction collapses canonical edges, and
+        # passes it in via ``__init__``. The on-disk format is the
+        # Python literal ``repr`` of the list-of-lists, byte-identical
+        # with the pyArchInit ``us_table.rapporti`` column when the
+        # graph between them is unmutated.
+        rapporti_entries = self._physical_relationships_by_node.get(
+            node_uuid)
+        if rapporti_entries:
+            data_d13 = ET.SubElement(
+                node_elem,
+                '{http://graphml.graphdrawing.org/xmlns}data')
+            data_d13.set('key', 'd13')
+            data_d13.text = repr(rapporti_entries)
+
         # Add nodegraphics (d6) - ShapeNode
         data_d6 = ET.SubElement(node_elem, '{http://graphml.graphdrawing.org/xmlns}data')
         data_d6.set('key', 'd6')

{s3dgraphy-1.6.0.dev6 → s3dgraphy-1.6.0.dev7}/src/s3dgraphy/importer/import_graphml.py

@@ -362,7 +362,17 @@ class GraphMLImporter:
         # exporter. Legacy files without the key are left untouched (the
         # reduced is_after / has_same_time set from parse_edges remains
         # in place). See module-level docstring for the rationale.
-        self._restore_physical_relations_from_side_channel(tree)
+        json_channel_applied = (
+            self._restore_physical_relations_from_side_channel(tree))
+
+        # Fallback for files NOT produced by the lossless exporter: read
+        # per-node ``physical_relationships`` (d13) packed strings — the
+        # EM 1.6 palette / pyArchInit-native list-of-lists format — and
+        # rebuild canonical edges from them. Skipped when the
+        # graph-level JSON side channel was present, since that's
+        # strictly richer (carries per-edge attributes and edge_ids).
+        if not json_channel_applied:
+            self._restore_physical_relations_from_node_attribute(tree)
 
         # Re-apply structured PropertyNode metadata (value /
         # property_type / units / attributes) from the
@@ -759,7 +769,7 @@ class GraphMLImporter:
                 
                 # print(f"Warning: Could not create edge {original_edge_id} - Source: {original_source_id} -> Target: {original_target_id}")
 
-    def _restore_physical_relations_from_side_channel(self, tree):
+    def _restore_physical_relations_from_side_channel(self, tree) -> bool:
         """Restore the original physical stratigraphic edges from the
         ``_s3d_physical_relations`` graph-level GraphML key, if present.
 
@@ -787,6 +797,13 @@ class GraphMLImporter:
         ``parse_edges`` / ``process_node_element``), the UUIDs round-trip
         directly. Unknown UUIDs are skipped with a warning so a partial
         graph still imports cleanly.
+
+        Returns:
+            ``True`` if the graph-level key was *declared* on the file
+            (regardless of payload size), ``False`` otherwise. Callers
+            use this to gate the per-node ``physical_relationships``
+            (d13) fallback: an authoritative JSON channel should not be
+            shadowed by the strictly poorer per-node packed string.
         """
         root = tree.getroot()
         ns = 'http://graphml.graphdrawing.org/xmlns'
@@ -803,8 +820,10 @@ class GraphMLImporter:
                 break
 
         if not side_channel_key_id:
-            # Legacy file: no key declared, nothing to restore.
-            return
+            # Legacy file: no key declared, nothing to restore. The
+            # per-node ``physical_relationships`` (d13) fallback may
+            # still apply — callers gate on the return value.
+            return False
 
         # 2) Find the graph-level <data> element carrying the payload.
         # We expect it directly under <graph id="G">. Scan all top-level
@@ -818,28 +837,34 @@ class GraphMLImporter:
                 side_channel_data = candidate
                 break
 
+        # From here on, the key was declared — the file was authored by
+        # the lossless exporter (or a tool that knows about it). Return
+        # True at every exit point so the per-node fallback stays out of
+        # the way; the JSON channel is authoritative.
         if side_channel_data is None or not (side_channel_data.text or "").strip():
-            # Key declared but no payload — treat as legacy.
-            return
+            # Key declared but no payload — treat as "no relations" but
+            # don't fall back to d13 (that would re-introduce stale data
+            # if the producer intentionally cleared the channel).
+            return True
 
         try:
             relations = json.loads(side_channel_data.text)
         except (ValueError, TypeError) as exc:
             print(f"[GraphML Parser] WARNING: could not parse "
                   f"{_S3D_PHYSICAL_RELATIONS_ATTR_NAME} payload: {exc}")
-            return
+            return True
 
         if not isinstance(relations, list):
             print(f"[GraphML Parser] WARNING: "
                   f"{_S3D_PHYSICAL_RELATIONS_ATTR_NAME} payload is not a "
                   f"list (got {type(relations).__name__}); ignoring")
-            return
+            return True
 
         if not relations:
             # Genuinely empty: drop reduced edges anyway, since the
             # exporter would not have written them either if the graph
             # had no physical relations. But to be safe, leave them.
-            return
+            return True
 
         # 3) Drop the reduced-physical edges produced by the export-side
         # transitive reduction. They are stale once we re-add the
@@ -913,6 +938,156 @@ class GraphMLImporter:
                  if skipped_missing else "")
               + (f", skipped {skipped_invalid} (invalid payload)"
                  if skipped_invalid else ""))
+        return True
+
+    def _restore_physical_relations_from_node_attribute(self, tree):
+        """Rebuild canonical physical-stratigraphic edges from per-node
+        ``physical_relationships`` (d13) packed strings.
+
+        This is the fallback for GraphML files NOT produced by the
+        s3dgraphy lossless exporter — e.g. files hand-authored in yEd
+        with the EM 1.6 palette, or files emitted by a pyArchInit-side
+        bridge that only fills the per-node attribute. The packed
+        string is the same list-of-lists Python-literal format used by
+        the pyArchInit ``us_table.rapporti`` column, so the GraphML ↔
+        pyArchInit transit is byte-identical when the graph between
+        them is unmutated.
+
+        Behaviour:
+          - For each ``<node>`` in the GraphML tree, look for a
+            ``<data>`` child whose key id resolves to the
+            ``physical_relationships`` (d13) declaration.
+          - Parse the string with
+            :func:`s3dgraphy.sync.rapporti.parse_rapporti`, which yields
+            canonical 5-tuples ``(edge_type, target_us, area, sito,
+            swap)``.
+          - Resolve target nodes by walking the imported graph's
+            nodes-by-name index; drop the reduced-physical edges (same
+            way the JSON channel does) before re-adding the canonical
+            ones so the in-memory graph isn't doubled up.
+
+        Called only when
+        :meth:`_restore_physical_relations_from_side_channel` reports
+        no graph-level JSON channel was present.
+        """
+        from ..sync.rapporti import parse_rapporti
+
+        root = tree.getroot()
+        ns = 'http://graphml.graphdrawing.org/xmlns'
+
+        # 1) Resolve the d13 key id from the file (don't assume "d13",
+        # since downstream tools may renumber keys on patch).
+        d13_key_id = None
+        for key_elem in root.findall(f'.//{{{ns}}}key'):
+            if (key_elem.attrib.get('attr.name')
+                    == 'physical_relationships'
+                    and key_elem.attrib.get('for') == 'node'):
+                d13_key_id = key_elem.attrib.get('id')
+                break
+
+        if not d13_key_id:
+            # Legacy file with no per-node packed string declaration —
+            # the reduced ``is_after`` edges from parse_edges stand.
+            return
+
+        # 2) Gather (source_node_id, raw_string) pairs by EMID. The
+        # GraphML node element's ``id`` is the nested layout id; the
+        # ``EMID`` (d7) data carries the s3dgraphy UUID, which is what
+        # the imported graph indexes by. parse_nodes has already
+        # populated the EMID slipback; reuse the same lookup pattern.
+        emid_key_id = None
+        for key_elem in root.findall(f'.//{{{ns}}}key'):
+            if (key_elem.attrib.get('attr.name') == 'EMID'
+                    and key_elem.attrib.get('for') == 'node'):
+                emid_key_id = key_elem.attrib.get('id')
+                break
+
+        per_node_raw: list[tuple[str, str]] = []
+        for node_elem in root.findall(f'.//{{{ns}}}node'):
+            d13 = node_elem.find(f'./{{{ns}}}data[@key="{d13_key_id}"]')
+            if d13 is None or not (d13.text or "").strip():
+                continue
+            emid = None
+            if emid_key_id:
+                emid_data = node_elem.find(
+                    f'./{{{ns}}}data[@key="{emid_key_id}"]')
+                if emid_data is not None and emid_data.text:
+                    emid = emid_data.text.strip()
+            if not emid:
+                # Fall back to the layout id — process_node_element
+                # uses it as the UUID when EMID is missing.
+                emid = node_elem.attrib.get('id')
+            if emid:
+                per_node_raw.append((emid, d13.text))
+
+        if not per_node_raw:
+            return
+
+        # 3) Build a name → list-of-nodes index for target resolution.
+        # parse_rapporti yields ``target_us`` as the bare unit number
+        # (no "US " prefix); match against the imported nodes' .name
+        # after applying the same strip the writer used.
+        from ..sync.rapporti import strip_us_prefix
+        nodes_by_name: dict = {}
+        for n in self.graph.nodes:
+            key = strip_us_prefix(getattr(n, "name", "") or "")
+            nodes_by_name.setdefault(key, []).append(n)
+
+        # 4) Drop the reduced physical edges (parse_edges produced
+        # them); the per-node packed strings carry the canonical set.
+        before = len(self.graph.edges)
+        self.graph.edges = [
+            e for e in self.graph.edges
+            if e.edge_type not in PHYSICAL_STRATIGRAPHIC_TYPES
+        ]
+        dropped = before - len(self.graph.edges)
+        if hasattr(self.graph, "_indices_dirty"):
+            self.graph._indices_dirty = True
+
+        restored = 0
+        skipped_missing = 0
+        skipped_invalid = 0
+        seen_edge_ids = {e.edge_id for e in self.graph.edges}
+        for source_uuid, raw in per_node_raw:
+            src_node = self.graph.find_node_by_id(source_uuid)
+            if src_node is None:
+                skipped_invalid += 1
+                continue
+            for (edge_type, target_us, _area, _sito, swap) in \
+                    parse_rapporti(raw):
+                candidates = nodes_by_name.get(target_us)
+                if not candidates:
+                    skipped_missing += 1
+                    continue
+                # No family-preference disambiguation here — the
+                # per-node fallback is by definition shallow (no
+                # PD/property targets); first match is fine.
+                tgt_node = candidates[0]
+                src, dst = ((tgt_node, src_node) if swap
+                            else (src_node, tgt_node))
+                edge_id = (f"rap_{src.node_id}_{dst.node_id}_"
+                           f"{edge_type}")
+                if edge_id in seen_edge_ids:
+                    continue
+                try:
+                    self.graph.add_edge(edge_id, src.node_id,
+                                        dst.node_id, edge_type)
+                except ValueError as exc:
+                    print(f"[GraphML Parser] WARNING: failed to restore "
+                          f"physical edge {src.node_id} "
+                          f"-[{edge_type}]-> {dst.node_id}: {exc}")
+                    skipped_invalid += 1
+                    continue
+                seen_edge_ids.add(edge_id)
+                restored += 1
+
+        print(f"[GraphML Parser] physical_relationships (d13): "
+              f"dropped {dropped} reduced edges, restored {restored} "
+              f"physical edges"
+              + (f", skipped {skipped_missing} (target unresolved)"
+                 if skipped_missing else "")
+              + (f", skipped {skipped_invalid} (invalid)"
+                 if skipped_invalid else ""))
 
     def _restore_property_metadata_from_side_channel(self, tree):
         """Reapply structured PropertyNode metadata from the