s3dgraphy 1.6.0.dev30__tar.gz → 1.6.0.dev31__tar.gz

{s3dgraphy-1.6.0.dev30/src/s3dgraphy.egg-info → s3dgraphy-1.6.0.dev31}/PKG-INFO

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

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

{s3dgraphy-1.6.0.dev30 → s3dgraphy-1.6.0.dev31}/src/s3dgraphy/__init__.py

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

{s3dgraphy-1.6.0.dev30 → s3dgraphy-1.6.0.dev31}/src/s3dgraphy/container.py

@@ -9,9 +9,24 @@ The decision (E.D., 2026-08-13): **an em.json/emj is always a container**::
         "shelf":      { ... em_collection: "ShelfGraph" },
         "dtc":        { ... em_collection: "DTCCorpus" }
       },
-      "active_graph_id": "<graph id>"
+      "active_graph_id": "<graph id>",
+      "layout": { ...the active graph's layout, a copy... }
     }
 
+**One layout per graph (2026-10-02).** Each member carries its own arrangement
+INSIDE its section, ``graphs.<id>.layout`` (positions, lanes, canvas, folded
+groups — the single-graph ``layout`` object, unchanged). The file-level
+``layout`` stays, written as a COPY of the active graph's, for whoever reads only
+that (Heriverse, the files written before today). Reading:
+``graphs.<id>.layout`` when the member has one; otherwise the file-level
+``layout`` goes to the ACTIVE graph only (or to the only one); the other graphs
+of an old file have no arrangement and are laid out afresh, which the reader
+says once. Until today the file had ONE layout for every graph, and whichever
+graph was saved first gave it away: measured on San Pietro, the layout in the
+file was an empty seed's and the real graph had lost every position.
+``EMStudio/frontend/src/container.ts`` applies the same rule, and the shared
+fixture ``tests/fixtures/container-layout-parity.json`` keeps the two equal.
+
 A study is one or more graphs plus its shelf and its **documentation** (the DTC
 corpus, 2026-08-17: acquisitions, transformations and the resources they are
 about — a forest that shares its leaves, and ontologically not a matrix); a
@@ -70,6 +85,9 @@ from .graph import Graph
 #: The key that makes a document a container.
 GRAPHS_KEY = "graphs"
 
+#: Where a member keeps its own arrangement: ``graphs.<id>.layout``.
+LAYOUT_KEY = "layout"
+
 #: The conventional member id of the project shelf. Any id works — the marker
 #: (`graph.data["em_collection"] == "ShelfGraph"`) is what identifies it — but
 #: this is the one Heriverse uses, so writing it keeps the two aligned.
@@ -154,8 +172,15 @@ def content_digest(doc: Dict[str, Any]) -> str:
     """
     import hashlib
 
+    # a member's own layout is arrangement, not content: moving a box inside
+    # one graph of a project is no more a revision than it was at file level
+    graphs = {
+        gid: ({k: v for k, v in section.items() if k != LAYOUT_KEY}
+              if isinstance(section, dict) else section)
+        for gid, section in (doc.get(GRAPHS_KEY) or {}).items()
+    }
     payload = {
-        GRAPHS_KEY: doc.get(GRAPHS_KEY) or {},
+        GRAPHS_KEY: graphs,
         "active_graph_id": doc.get("active_graph_id"),
     }
     blob = json.dumps(payload, sort_keys=True, ensure_ascii=False,
@@ -185,7 +210,13 @@ class Container:
     corpus: Optional[Graph] = None
     active_graph_id: Optional[str] = None
     header: Dict[str, Any] = field(default_factory=dict)
+    #: The ACTIVE graph's layout, for a caller that has one graph and one
+    #: arrangement (``export_emjson``). Used only for the active graph, and only
+    #: when ``layouts`` has no entry for it — it is never given to another graph.
     layout: Dict[str, Any] = field(default_factory=dict)
+    #: One layout per graph id (``graphs.<id>.layout`` in the file). A graph with
+    #: no entry has no arrangement and is laid out afresh by whoever draws it.
+    layouts: Dict[str, Dict[str, Any]] = field(default_factory=dict)
     #: P3 · which revision of the work this is (None = never versioned; the
     #: first write gives it a v1 rather than pretending it always had one)
     version: Optional[ProjectVersion] = None
@@ -202,6 +233,21 @@ class Container:
         """A container-of-one — the shape a legacy file opens as."""
         return len(self.graphs) == 1
 
+    def layout_of(self, graph_id: Optional[str]) -> Optional[Dict[str, Any]]:
+        """The layout of ONE graph, or None when it has none.
+
+        `layouts` first; the convenience `layout` only for the active graph. A
+        graph is never handed another graph's arrangement — that was the bug.
+        """
+        if graph_id is None:
+            return None
+        if graph_id in self.layouts:
+            return self.layouts[graph_id]
+        active = self.active_graph_id or next(iter(self.graphs), None)
+        if graph_id == active and self.layout:
+            return self.layout
+        return None
+
 
 def is_container(doc: Any) -> bool:
     """True when the document carries the `graphs` map.
@@ -231,6 +277,49 @@ def is_dtc_corpus_member(graph_section: Any) -> bool:
     return is_dtc_corpus(graph_section)
 
 
+def resolve_layouts(graph_ids: List[str],
+                    own: Dict[str, Dict[str, Any]],
+                    file_layout: Dict[str, Any],
+                    active_graph_id: Optional[str],
+                    ) -> Tuple[Dict[str, Dict[str, Any]], List[str]]:
+    """Which layout each graph of a file gets, and which ones get none.
+
+    THE reading rule, the same as ``container.ts::resolveLayouts``:
+
+    1. a member that carries ``graphs.<id>.layout`` keeps its own;
+    2. otherwise the file-level ``layout`` goes to the ACTIVE graph — or to the
+       only one — and to no other: in a file written before per-graph layouts it
+       was the arrangement of one graph, and giving it to the rest was the bug;
+    3. the remaining graphs get nothing and are laid out afresh. They are
+       returned as ``fresh`` only for an OLD file — one with a layout to give and
+       no member carrying its own: there, a graph's positions may have been lost
+       to another's, and that is worth saying once. In a file written with
+       per-graph layouts a graph without one simply has none (never laid out),
+       and saying so at every open would be noise.
+    """
+    layouts: Dict[str, Dict[str, Any]] = {}
+    fresh: List[str] = []
+    heir = active_graph_id if active_graph_id in graph_ids else (
+        graph_ids[0] if graph_ids else None)
+    if len(graph_ids) == 1:
+        heir = graph_ids[0]
+    for gid in graph_ids:
+        if gid in own:
+            layouts[gid] = own[gid]
+        elif gid == heir and file_layout:
+            layouts[gid] = file_layout
+        elif file_layout and not own:
+            fresh.append(gid)
+    return layouts, fresh
+
+
+def layout_fresh_warning(fresh: List[str]) -> str:
+    """The one sentence about the graphs of an old file that had no layout."""
+    return (f"{len(fresh)} graph(s) of this file carry no layout of their own "
+            f"(written before per-graph layouts): laid out afresh — "
+            f"{', '.join(fresh)}")
+
+
 def parse_container(doc: Dict[str, Any], *,
                     project_root: Optional[str] = None) -> Tuple[Container, List[str]]:
     """Read a container OR a legacy single-graph document.
@@ -249,7 +338,8 @@ def parse_container(doc: Dict[str, Any], *,
         raise EmJsonImportError("not an em.json document")
 
     header = dict(doc.get("header") or {})
-    layout = dict(doc.get("layout") or {})
+    file_layout = doc.get(LAYOUT_KEY)
+    file_layout = dict(file_layout) if isinstance(file_layout, dict) else {}
 
     if not is_container(doc):
         # LEGACY single-graph: read it with the reader that has always read it,
@@ -259,18 +349,21 @@ def parse_container(doc: Dict[str, Any], *,
             graphs={graph.graph_id: graph},
             active_graph_id=graph.graph_id,
             header=header,
-            layout=layout,
+            layouts={graph.graph_id: file_layout} if file_layout else {},
             version=ProjectVersion.from_dict(doc.get(VERSION_KEY)),
         )
         return container, list(graph_warnings)
 
-    container = Container(header=header, layout=layout,
+    container = Container(header=header,
                           version=ProjectVersion.from_dict(doc.get(VERSION_KEY)))
+    own_layouts: Dict[str, Dict[str, Any]] = {}
     members = doc[GRAPHS_KEY]
     for member_id, section in members.items():
         if not isinstance(section, dict):
             warnings.append(f"container member '{member_id}' is not a graph; skipped")
             continue
+        own = section.get(LAYOUT_KEY)
+        section = {k: v for k, v in section.items() if k != LAYOUT_KEY}
         # Each member is parsed by the SAME single-graph reader, by handing it a
         # one-graph document. The alternative — a second parser for members —
         # would be a second place for the em.json semantics to live.
@@ -295,6 +388,8 @@ def parse_container(doc: Dict[str, Any], *,
             container.corpus = graph
         else:
             container.graphs[graph.graph_id] = graph
+            if isinstance(own, dict):
+                own_layouts[graph.graph_id] = dict(own)
 
     active = doc.get("active_graph_id")
     if isinstance(active, str) and active in container.graphs:
@@ -306,6 +401,11 @@ def parse_container(doc: Dict[str, Any], *,
                 f"falling back to the first graph")
         container.active_graph_id = next(iter(container.graphs), None)
 
+    container.layouts, fresh = resolve_layouts(
+        list(container.graphs), own_layouts, file_layout, container.active_graph_id)
+    if fresh:
+        warnings.append(layout_fresh_warning(fresh))
+
     if not container.graphs and (container.shelf is not None
                                  or container.corpus is not None):
         held = " and ".join(
@@ -337,6 +437,9 @@ def build_container(container: Container) -> Dict[str, Any]:
     graphs: Dict[str, Any] = {}
     for graph_id, graph in container.graphs.items():
         graphs[graph_id] = _member_section(graph)
+        own = container.layout_of(graph_id)
+        if own:
+            graphs[graph_id][LAYOUT_KEY] = own
     if container.shelf is not None:
         shelf_id = container.shelf.graph_id or SHELF_MEMBER_ID
         graphs[shelf_id] = _member_section(container.shelf)
@@ -369,8 +472,10 @@ def build_container(container: Container) -> Dict[str, Any]:
     active = container.active_graph_id or next(iter(container.graphs), None)
     if active:
         doc["active_graph_id"] = active
-    if container.layout:
-        doc["layout"] = container.layout
+    # the file-level copy, for whoever reads only that: the ACTIVE graph's
+    active_layout = container.layout_of(active)
+    if active_layout:
+        doc[LAYOUT_KEY] = active_layout
     if container.version is not None:
         doc[VERSION_KEY] = container.version.as_dict()
     return doc
@@ -855,6 +960,10 @@ def merge_into_container(container: Container, other: Container) -> MergeReport:
             report.merged_graphs.append(graph_id)
         else:
             container.graphs[graph_id] = incoming
+            # …with its own arrangement: a graph that arrives whole arrives laid out
+            theirs = other.layout_of(graph_id)
+            if theirs:
+                container.layouts[graph_id] = theirs
             report.added_graphs.append(graph_id)
             report.added_nodes += len(list(incoming.nodes))
             report.added_edges += len(list(incoming.edges))

{s3dgraphy-1.6.0.dev30 → s3dgraphy-1.6.0.dev31/src/s3dgraphy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: s3dgraphy
-Version: 1.6.0.dev30
+Version: 1.6.0.dev31
 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.dev30 → s3dgraphy-1.6.0.dev31}/src/s3dgraphy.egg-info/SOURCES.txt

@@ -370,6 +370,7 @@ tests/test_composite_node_name.py
 tests/test_connection_resolver.py
 tests/test_consumer_drift.py
 tests/test_container.py
+tests/test_container_layouts.py
 tests/test_containment_tpq.py
 tests/test_contract.py
 tests/test_contract_consumer.py

s3dgraphy-1.6.0.dev31/tests/test_container_layouts.py

@@ -0,0 +1,63 @@
+"""One layout per graph in the em.json container (MICRO-OGNI-FILE-I-SUOI-GRAFI, F4).
+
+The cases live in `tests/fixtures/container-layout-parity.json`, and EMStudio's
+`check-container.mjs` reads a byte copy of the same file: the two readers and the
+two writers of the container are held to ONE rule, case by case.
+"""
+
+import json
+import pathlib
+
+import pytest
+
+from s3dgraphy.container import (build_container, content_digest,
+                                 parse_container)
+
+FIXTURE = pathlib.Path(__file__).parent / "fixtures" / "container-layout-parity.json"
+CASES = json.loads(FIXTURE.read_text(encoding="utf-8"))["cases"]
+
+
+@pytest.mark.parametrize("case", CASES, ids=[c["name"] for c in CASES])
+def test_reading_gives_each_graph_its_own_layout(case):
+    container, warnings = parse_container(json.loads(json.dumps(case["doc"])))
+    assert container.layouts == case["expect"]["layouts"]
+    fresh = [w for w in warnings if "laid out afresh" in w]
+    if case["expect"]["fresh"]:
+        assert len(fresh) == 1, "said ONCE, not once per graph"
+        for gid in case["expect"]["fresh"]:
+            assert gid in fresh[0]
+    else:
+        assert fresh == []
+
+
+@pytest.mark.parametrize("case", CASES, ids=[c["name"] for c in CASES])
+def test_writing_puts_each_layout_in_its_section(case):
+    container, _ = parse_container(json.loads(json.dumps(case["doc"])))
+    doc = build_container(container)
+    for gid, want in case["built"]["members"].items():
+        assert doc["graphs"][gid].get("layout") == want, gid
+    assert doc.get("layout") == case["built"]["layout"]
+    # …and the round trip reads back what it wrote, with nothing left to say
+    again, warnings = parse_container(json.loads(json.dumps(doc)))
+    want_layouts = {g: l for g, l in case["built"]["members"].items() if l}
+    assert again.layouts == want_layouts
+    assert not [w for w in warnings if "laid out afresh" in w]
+
+
+def test_moving_a_box_in_one_graph_is_not_a_new_version():
+    case = next(c for c in CASES if c["name"].startswith("new container"))
+    container, _ = parse_container(json.loads(json.dumps(case["doc"])))
+    first = content_digest(build_container(container))
+    container.layouts["a"] = {"positions": {"US1": {"x": 500, "y": 9, "w": 90, "h": 30}}}
+    assert content_digest(build_container(container)) == first
+
+
+def test_the_convenience_layout_never_reaches_another_graph():
+    """`Container.layout` (what `export_emjson` sets) is the ACTIVE graph's."""
+    case = next(c for c in CASES if c["name"].startswith("no layout anywhere"))
+    container, _ = parse_container(json.loads(json.dumps(case["doc"])))
+    container.layout = {"positions": {"US1": {"x": 1, "y": 1, "w": 90, "h": 30}}}
+    doc = build_container(container)
+    assert doc["graphs"]["a"]["layout"] == container.layout
+    assert "layout" not in doc["graphs"]["b"]
+    assert doc["layout"] == container.layout