s3dgraphy 1.6.0.dev39__tar.gz → 1.6.0.dev40__tar.gz

{s3dgraphy-1.6.0.dev39/src/s3dgraphy.egg-info → s3dgraphy-1.6.0.dev40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: s3dgraphy
-Version: 1.6.0.dev39
+Version: 1.6.0.dev40
 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.dev39 → s3dgraphy-1.6.0.dev40}/pyproject.toml

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

{s3dgraphy-1.6.0.dev39 → s3dgraphy-1.6.0.dev40}/src/s3dgraphy/__init__.py

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

{s3dgraphy-1.6.0.dev39 → s3dgraphy-1.6.0.dev40}/src/s3dgraphy/exporter/graphml/graphml_exporter.py

@@ -7,6 +7,7 @@ a single TableNode swimlane (matching yEd reference structure).
 """
 
 import json
+import logging
 
 from lxml import etree as ET
 from typing import List, Dict
@@ -17,6 +18,12 @@ from .group_node_generator import GroupNodeGenerator
 from .edge_generator import EdgeGenerator
 from .utils import IDManager, generate_uuid
 
+#: Everything the export used to print — progress, the per-pass counts, the
+#: summary — goes here (#27): a server exporting GraphML must not find thirty
+#: lines on its stdout. The progress is DEBUG, the summary INFO, a cycle or a
+#: skipped side channel a WARNING.
+logger = logging.getLogger(__name__)
+
 
 # Physical stratigraphic relations preserved as a graph-level GraphML
 # side-channel BEFORE transitive reduction collapses everything into the
@@ -73,7 +80,7 @@ class GraphMLExporter:
                 ``injected_by`` / ``_aux_overrides`` tags so the enrichment
                 layer becomes graph-native.
         """
-        print(f"Starting GraphML export to {output_path} "
+        logger.debug(f"Starting GraphML export to {output_path} "
               f"({'BAKE' if persist_auxiliary else 'volatile'} mode)")
 
         # Apply the Hybrid-C policy BEFORE generating XML so every
@@ -84,7 +91,7 @@ class GraphMLExporter:
         if persist_auxiliary:
             bake_report = clear_aux_tags(self.graph)
             if bake_report["injected_cleared"] or bake_report["overrides_cleared"]:
-                print(f"  [bake] cleared {bake_report['injected_cleared']} "
+                logger.debug(f"  [bake] cleared {bake_report['injected_cleared']} "
                       f"injected_by tags, {bake_report['overrides_cleared']} "
                       f"_aux_overrides entries")
         else:
@@ -92,13 +99,13 @@ class GraphMLExporter:
             # then drop injected children.
             rev_report = apply_override_reversal_policy(self.graph)
             if any(rev_report.values()):
-                print(f"  [volatile] attribute overrides: "
+                logger.debug(f"  [volatile] attribute overrides: "
                       f"{rev_report['reverted']} reverted, "
                       f"{rev_report['kept']} kept (user re-edited), "
                       f"{rev_report['unseen']} unseen (kept)")
             strip_report = strip_injected_content(self.graph)
             if strip_report["nodes"] or strip_report["edges"]:
-                print(f"  [volatile] stripped {strip_report['nodes']} "
+                logger.debug(f"  [volatile] stripped {strip_report['nodes']} "
                       f"injected nodes and {strip_report['edges']} edges")
 
         # GraphML is a DISSEMINATION surface: a tombstone must not be hidden
@@ -113,7 +120,7 @@ class GraphMLExporter:
         from ...dissemination import live_view
         self.graph, hidden = live_view(self.graph, surface="graphml")
         if hidden.total:
-            print(f"  [dissemination] left out {hidden.nodes} removed nodes, "
+            logger.debug(f"  [dissemination] left out {hidden.nodes} removed nodes, "
                   f"{hidden.edges} removed edges and {hidden.dangling} edges "
                   f"dangling on them")
 
@@ -129,10 +136,10 @@ class GraphMLExporter:
             materialize_continuity)
         mat_report = materialize_continuity(self.graph)
         if mat_report["swept"]:
-            print(f"  [materialize] swept {mat_report['swept']} stale "
+            logger.debug(f"  [materialize] swept {mat_report['swept']} stale "
                   f"synthetic items from a prior run")
         if mat_report["nodes"]:
-            print(f"  [materialize] injected {mat_report['nodes']} BR "
+            logger.debug(f"  [materialize] injected {mat_report['nodes']} BR "
                   f"diamonds + {mat_report['edges']} edges "
                   f"(skipped {mat_report['skipped_user_authored']} "
                   f"nodes with user-authored BR)")
@@ -188,7 +195,7 @@ class GraphMLExporter:
             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: "
+            logger.warning(f"  [physical_relationships] skipped serialization: "
                   f"{exc}")
             self._physical_relationships_by_node = {}
 
@@ -209,7 +216,7 @@ class GraphMLExporter:
 
         # 3. TEMPORAL INFERENCE: derive minimal temporal edges from topological relations
         # Must be done BEFORE generating XML so we know positions and edges
-        print("Deriving temporal edges from topological relations...")
+        logger.debug("Deriving temporal edges from topological relations...")
         from ...temporal.inference_engine import TemporalInferenceEngine
         from ...nodes.epoch_node import EpochNode
         from ...nodes.stratigraphic_node import StratigraphicNode
@@ -227,7 +234,7 @@ class GraphMLExporter:
                 minimal_edges = engine.transitive_reduction(temporal_edges)
             except ValueError as e:
                 warning_msg = f"Temporal cycle detected: {str(e).splitlines()[0]}"
-                print(f"  ⚠️ {warning_msg}")
+                logger.warning(warning_msg)
                 self.graph.add_warning(warning_msg)
                 minimal_edges = temporal_edges  # fallback: use unreduced
 
@@ -310,7 +317,7 @@ class GraphMLExporter:
 
         positions = {}
         if epoch_nodes:
-            print(f"Generating epoch swimlanes ({len(epoch_nodes)} epochs)...")
+            logger.debug(f"Generating epoch swimlanes ({len(epoch_nodes)} epochs)...")
             from .epoch_generator import EpochSwimlanesGenerator
             epoch_gen = EpochSwimlanesGenerator()
 
@@ -425,7 +432,7 @@ class GraphMLExporter:
             activity_graph_of[aid] = act_xml.find(
                 './/{http://graphml.graphdrawing.org/xmlns}graph')
         if activity_members_present:
-            print(f"Generating {len(activity_members_present)} activity "
+            logger.debug(f"Generating {len(activity_members_present)} activity "
                   f"group(s)...")
 
         def _slot_for(node_id):
@@ -443,7 +450,7 @@ class GraphMLExporter:
         # those groups) are skipped here, but ALL stratigraphic nodes are
         # still collected in ``stratigraphic_nodes`` so PD-group building
         # below sees them (a member or container may carry properties).
-        print(f"Generating {len(strat_nodes)} stratigraphic nodes inside swimlane...")
+        logger.debug(f"Generating {len(strat_nodes)} stratigraphic nodes inside swimlane...")
         stratigraphic_nodes = []
         for i, node in enumerate(strat_nodes):
             stratigraphic_nodes.append(node)
@@ -468,7 +475,7 @@ class GraphMLExporter:
         # description; the importer re-creates the stratigraphic node and
         # the child->container is_part_of edges from this structure.
         if container_ids:
-            print(f"Generating {len(container_ids)} is_part_of "
+            logger.debug(f"Generating {len(container_ids)} is_part_of "
                   f"container(s) with {len(member_ids)} member(s)...")
         for cid, members in container_members.items():
             container = strat_by_id[cid]
@@ -492,7 +499,7 @@ class GraphMLExporter:
                 container_graph.append(member_xml)
 
         # 7. Build and generate ParadataNodeGroups INSIDE the swimlane
-        print("Building ParadataNodeGroups...")
+        logger.debug("Building ParadataNodeGroups...")
         paradata_groups = self._build_paradata_groups(stratigraphic_nodes)
 
         internal_edge_total = 0
@@ -753,7 +760,7 @@ class GraphMLExporter:
             # the group at load time.
 
         # 8. Generate US → ParadataNodeGroup dashed edges
-        print("Generating US→ParadataNodeGroup edges...")
+        logger.debug("Generating US→ParadataNodeGroup edges...")
         for group_data in paradata_groups:
             us_node = group_data['us_node']
             group_uuid = group_data.get('group_uuid', '')
@@ -769,7 +776,7 @@ class GraphMLExporter:
         is_after_count = sum(1 for e in export_edges if e.edge_type == 'is_after')
         same_time_count = sum(1 for e in export_edges if e.edge_type == 'has_same_time')
         pd_count = sum(1 for e in export_edges if e.edge_type == 'has_paradata_nodegroup')
-        print(f"Generating {len(export_edges)} edges ({is_after_count} is_after, "
+        logger.debug(f"Generating {len(export_edges)} edges ({is_after_count} is_after, "
               f"{same_time_count} has_same_time, {pd_count} has_paradata_nodegroup, "
               f"{internal_edge_total} internal PD edges)...")
 
@@ -792,7 +799,7 @@ class GraphMLExporter:
         root.append(resources)
 
         # 12. Write file
-        print(f"Writing GraphML to {output_path}...")
+        logger.debug(f"Writing GraphML to {output_path}...")
         tree = ET.ElementTree(root)
         tree.write(output_path, encoding='UTF-8', xml_declaration=True, pretty_print=True)
 
@@ -805,19 +812,19 @@ class GraphMLExporter:
             dematerialize_continuity)
         dem_report = dematerialize_continuity(self.graph)
         if dem_report["nodes"] or dem_report["edges"]:
-            print(f"  [dematerialize] cleaned up "
+            logger.debug(f"  [dematerialize] cleaned up "
                   f"{dem_report['nodes']} synthetic BR nodes and "
                   f"{dem_report['edges']} edges")
 
-        print(f"GraphML export completed successfully!")
-        print(f"  - Stratigraphic nodes: {len(stratigraphic_nodes)}")
-        print(f"  - Epoch nodes: {len(epoch_nodes)}")
-        print(f"  - Temporal edges (is_after): {is_after_count}")
-        print(f"  - Same-time edges: {same_time_count}")
-        print(f"  - US→PD edges: {pd_count}")
-        print(f"  - Total edges exported: {len(export_edges)}")
-        print(f"  - Internal PD edges: {internal_edge_total}")
-        print(f"  - ParadataGroups: {len(paradata_groups)}")
+        logger.info(f"GraphML export completed successfully!")
+        logger.info(f"  - Stratigraphic nodes: {len(stratigraphic_nodes)}")
+        logger.info(f"  - Epoch nodes: {len(epoch_nodes)}")
+        logger.info(f"  - Temporal edges (is_after): {is_after_count}")
+        logger.info(f"  - Same-time edges: {same_time_count}")
+        logger.info(f"  - US→PD edges: {pd_count}")
+        logger.info(f"  - Total edges exported: {len(export_edges)}")
+        logger.info(f"  - Internal PD edges: {internal_edge_total}")
+        logger.info(f"  - ParadataGroups: {len(paradata_groups)}")
 
     def _write_physical_relations_data(self, graph_elem: ET.Element,
                                        canvas: CanvasGenerator) -> int:
@@ -878,7 +885,7 @@ class GraphMLExporter:
                                separators=(",", ":"))
 
         if physical_relations:
-            print(f"  [lossless] preserved {len(physical_relations)} "
+            logger.debug(f"  [lossless] preserved {len(physical_relations)} "
                   f"physical stratigraphic relations in "
                   f"{canvas.PHYSICAL_RELATIONS_ATTR_NAME}")
         return len(physical_relations)
@@ -936,7 +943,7 @@ class GraphMLExporter:
                                 ensure_ascii=False,
                                 separators=(",", ":"))
         if property_map:
-            print(f"  [lossless] preserved structured metadata for "
+            logger.debug(f"  [lossless] preserved structured metadata for "
                   f"{len(property_map)} PropertyNode(s) in "
                   f"{canvas.PROPERTY_METADATA_ATTR_NAME}")
         return len(property_map)
@@ -1123,15 +1130,14 @@ class GraphMLExporter:
         from ...utils.utils import get_base_name
         from ...edges.connections_loader import get_connections_datamodel
         datamodel = get_connections_datamodel()
-        node_map = {n.node_id: n for n in self.graph.nodes}
         relations: dict = {}
-        for edge in self.graph.edges:
-            if edge.edge_source != us_node.node_id:
-                continue
+        # the node's outgoing edges, in list order, from the index: this ran
+        # once per US over every node and every edge (#27)
+        for edge in self.graph.indices.edges_by_source.get(us_node.node_id, []):
             edge_type = (datamodel.normalize_edge_name(
                 edge.edge_type, prefer_canonical=False) or edge.edge_type)
             if edge_type in self._TOPO_EDGE_TYPES:
-                target = node_map.get(edge.edge_target)
+                target = self.graph.find_node_by_id(edge.edge_target)
                 if target:
                     name = get_base_name(target.name) or target.name
                     names = relations.setdefault(edge_type, [])
@@ -1582,10 +1588,9 @@ class GraphMLExporter:
                 continue
 
             target_epoch = None
-            for edge in self.graph.edges:
-                if (edge.edge_source == node.node_id
-                        and edge.edge_type == "has_first_epoch"
-                        and edge.edge_target in epoch_ids):
+            for edge in self.graph.indices.edges_by_source_type.get(
+                    (node.node_id, "has_first_epoch"), []):
+                if edge.edge_target in epoch_ids:
                     target_epoch = id_to_node.get(edge.edge_target)
                     break
             if target_epoch is None:
@@ -1617,7 +1622,8 @@ class GraphMLExporter:
                 local_copies[tgt.node_id] = local
                 image_nodes_list.append(local)
 
-            for edge in self.graph.edges:
+            # the SL_PD's own edges, in list order (`_edges_of`), not all
+            for edge in self._edges_of(node.node_id):
                 # Path A: SL_PD outgoing edges to the paradata image.
                 if edge.edge_source == node.node_id:
                     accepted = edge_to_class.get(edge.edge_type)
@@ -1637,7 +1643,7 @@ class GraphMLExporter:
             # SL_PD via ``is_in_paradata_nodegroup``.
             prop_nodes_list: List = []
             seen_props: set = set()
-            for edge in self.graph.edges:
+            for edge in self._edges_of(node.node_id):
                 candidate = None
                 if (edge.edge_source == node.node_id
                         and edge.edge_type == "has_property"):
@@ -1666,6 +1672,17 @@ class GraphMLExporter:
 
         return groups
 
+    def _edges_of(self, node_id):
+        """The edges with `node_id` at either end, each once, in the order of
+        ``self.graph.edges``: a loop over them sees what a loop over the whole
+        list filtered on the node sees."""
+        ix = self.graph.indices
+        outgoing = ix.edges_by_source.get(node_id, [])
+        incoming = ix.edges_by_target.get(node_id, [])
+        both = {id(e): e for e in outgoing}
+        both.update((id(e), e) for e in incoming)
+        return sorted(both.values(), key=lambda e: ix.edge_seq[id(e)])
+
     def _collect_paradata_image_attachments(self, chains, local_doc_copies,
                                             us_node=None):
         """
@@ -1709,16 +1726,16 @@ class GraphMLExporter:
         image_attachments: List = []
         seen_attachments: set = set()
 
-        id_to_node = {n.node_id: n for n in self.graph.nodes}
+        # by id and by source from the graph's indices: this ran once per PD
+        # group over every node and, per chain element, every edge (#27)
+        edges_by_source = self.graph.indices.edges_by_source
 
         def _collect(source_local, original_uuid):
-            for e in self.graph.edges:
-                if e.edge_source != original_uuid:
-                    continue
+            for e in edges_by_source.get(original_uuid, []):
                 accepted = edge_type_classes.get(e.edge_type)
                 if accepted is None:
                     continue
-                tgt = id_to_node.get(e.edge_target)
+                tgt = self.graph.find_node_by_id(e.edge_target)
                 if tgt is None or not isinstance(tgt, accepted):
                     continue
                 pair = (source_local.node_id, tgt.node_id)

{s3dgraphy-1.6.0.dev39 → s3dgraphy-1.6.0.dev40}/src/s3dgraphy/exporter/graphml/node_registry.py

@@ -13,6 +13,7 @@ documented in ``PALETTE_AUDIT.md`` (Variante A).
 """
 
 import json
+import logging
 import os
 import re
 import warnings
@@ -21,6 +22,8 @@ from typing import Dict, Tuple, Optional, List
 from lxml import etree as ET
 from dataclasses import dataclass
 
+logger = logging.getLogger(__name__)
+
 
 class S3DgraphyPaletteWarning(UserWarning):
     """Raised when the palette template contains stencils that cannot be
@@ -135,7 +138,7 @@ class NodeRegistry:
             with resource.open('r', encoding='utf-8') as f:
                 data = json.load(f)
         except (FileNotFoundError, ModuleNotFoundError) as e:
-            print(f"[s3dgraphy] Warning: Node datamodel not found: {type(e).__name__}: {e}")
+            logger.warning("Node datamodel not found: %s: %s", type(e).__name__, e)
             self.datamodel = {}
             return
 
@@ -314,7 +317,7 @@ class NodeRegistry:
                 text_color=text_color
             )
         except Exception as e:
-            print(f"Warning: Error extracting visual properties: {e}")
+            logger.warning("Error extracting visual properties: %s", e)
             return None
 
     def get_visual_properties(self, node_type: str) -> Optional[NodeVisualProperties]: