s3dgraphy 1.6.0.dev30__tar.gz → 1.6.0.dev32__tar.gz

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "s3dgraphy"
-version = "1.6.0.dev30"
+version = "1.6.0.dev32"
 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.dev32}/src/s3dgraphy/__init__.py

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

{s3dgraphy-1.6.0.dev30 → s3dgraphy-1.6.0.dev32}/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 ONE graph — the one whose nodes it positions, else the
+active one (or 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
@@ -62,7 +77,7 @@ import json
 import os
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, Iterable, List, Optional, Tuple
 
 from . import crdt
 from .graph import Graph
@@ -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,63 @@ 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],
+                    node_ids: Optional[Dict[str, Iterable[str]]] = None,
+                    ) -> 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 ONE graph 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. That graph is the one whose nodes
+       the layout positions (``node_ids``, most positions wins) — NOT simply the
+       active one: an old file kept the layout of the graph laid out LAST, which
+       may be a seed that is not the active graph (San Pietro, dev.17: the seed's
+       three positions went to the real graph, which then saved them as its own
+       and was never laid out). Ties, a layout with no positions, or no
+       ``node_ids`` → the ACTIVE graph, or the only one;
+    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]
+    elif file_layout and node_ids:
+        placed = set((file_layout.get("positions") or {}).keys())
+        counts = {gid: len(placed & set(node_ids.get(gid) or ()))
+                  for gid in graph_ids if gid not in own}
+        best = max(counts.values(), default=0)
+        if best > 0 and counts.get(heir, 0) < best:
+            heir = next(gid for gid in graph_ids if counts.get(gid, 0) == best)
+    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 +352,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 +363,22 @@ 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]] = {}
+    node_ids: Dict[str, List[str]] = {}
     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 +403,11 @@ def parse_container(doc: Dict[str, Any], *,
             container.corpus = graph
         else:
             container.graphs[graph.graph_id] = graph
+            node_ids[graph.graph_id] = [
+                str(n.get("id")) for n in (section.get("nodes") or [])
+                if isinstance(n, dict) and n.get("id") is not None]
+            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 +419,12 @@ 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,
+        node_ids)
+    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 +456,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 +491,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 +979,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.dev32/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.dev32
 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.dev32}/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.dev32/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

{s3dgraphy-1.6.0.dev30 → s3dgraphy-1.6.0.dev32}/tests/test_release.py

@@ -627,3 +627,113 @@ def test_a_long_wait_says_the_jobs_and_their_step(world):
     assert "linux        done ✓" in out
     # not a terminal: a new line per change of state, not one per look
     assert out.count(f"▸ 2 · publish.yml for v{D}") <= 3
+
+
+# ── the confirmations count down (E.D., 3 Oct 2026) ──────────────────────────
+#
+# On a FAKE TERMINAL (a pty: `isatty()` is true and keys arrive one at a time,
+# as from a person): no key → yes at zero; «n» → stop; Enter → yes at once.
+
+def _release_module():
+    import importlib.util
+    spec = importlib.util.spec_from_file_location("em_release", RELEASE)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+@pytest.fixture
+def terminal():
+    pty = pytest.importorskip("pty")  # noqa: F841 — POSIX only, like the countdown
+    import io
+    master, slave = os.openpty()
+    stdin = os.fdopen(slave, "rb", buffering=0)
+    out = io.StringIO()
+    yield master, stdin, out
+    stdin.close()
+    os.close(master)
+
+
+def test_the_countdown_says_yes_at_zero(terminal):
+    import time
+    master, stdin, out = terminal
+    R = _release_module()
+    t0 = time.monotonic()
+    assert R.countdown_confirm("Push these 3 repositories?", 1, stdin=stdin, stdout=out) is True
+    assert time.monotonic() - t0 >= 0.9
+    said = out.getvalue()
+    assert "Push these 3 repositories? [Y/n] — yes in 1 s (n to stop)" in said
+    assert "yes (no answer in 1 s)" in said
+    assert "\r" in said                         # the same line, rewritten
+
+
+def _press(master, key, after=0.3):
+    """a key, pressed while the question is counting (not before: those are thrown away)"""
+    import threading
+    threading.Timer(after, lambda: os.write(master, key)).start()
+
+
+def test_the_countdown_stops_on_n(terminal):
+    master, stdin, out = terminal
+    R = _release_module()
+    _press(master, b"n")
+    assert R.countdown_confirm("Commit EMStudio?", 10, stdin=stdin, stdout=out) is False
+    assert out.getvalue().rstrip().endswith("— no\033[K")
+
+
+def test_the_countdown_goes_at_once_on_enter(terminal):
+    import time
+    master, stdin, out = terminal
+    R = _release_module()
+    _press(master, b"\n")
+    t0 = time.monotonic()
+    assert R.countdown_confirm("Commit EMStudio?", 10, stdin=stdin, stdout=out) is True
+    assert time.monotonic() - t0 < 1.5
+    assert "— yes\033[K" in out.getvalue()
+
+
+def test_the_countdown_gives_the_terminal_back(terminal):
+    import termios
+    master, stdin, out = terminal
+    R = _release_module()
+    before = termios.tcgetattr(stdin.fileno())
+    _press(master, b"y")
+    R.countdown_confirm("Go on?", 10, stdin=stdin, stdout=out)
+    after = termios.tcgetattr(stdin.fileno())
+    # PENDIN is the KERNEL's («input to reprint»), set by itself after a mode change
+    pendin = getattr(termios, "PENDIN", 0)
+    before[3] &= ~pendin
+    after[3] &= ~pendin
+    assert after == before
+
+
+def test_a_key_pressed_before_the_question_is_not_an_answer(terminal):
+    master, stdin, out = terminal
+    R = _release_module()
+    os.write(master, b"n")          # typed ahead, before anything was asked
+    assert R.countdown_confirm("Go on?", 1, stdin=stdin, stdout=out) is True
+    assert "yes (no answer in 1 s)" in out.getvalue()
+
+
+def test_the_seconds_come_from_the_environment(monkeypatch):
+    R = _release_module()
+    monkeypatch.delenv("EM_RELEASE_CONFIRM_SECONDS", raising=False)
+    assert R.confirm_seconds() == 10
+    monkeypatch.setenv("EM_RELEASE_CONFIRM_SECONDS", "3")
+    assert R.confirm_seconds() == 3
+    monkeypatch.setenv("EM_RELEASE_CONFIRM_SECONDS", "0")
+    assert R.confirm_seconds() == 0
+    monkeypatch.setenv("EM_RELEASE_CONFIRM_SECONDS", "dieci")
+    assert R.confirm_seconds() == 10
+
+
+def test_without_a_terminal_and_without_yes_nobody_says_yes(monkeypatch, capsys):
+    import io
+    R = _release_module()
+    c = R.Ctx(V, None, False, False, False)
+    monkeypatch.setattr(sys, "stdin", io.StringIO(""))      # not a tty, nothing on it
+    assert c.ask("Push these 3 repositories?") is False
+    assert "stdin is not a terminal" in capsys.readouterr().out
+    monkeypatch.setattr(sys, "stdin", io.StringIO("y\n"))   # a pipe that answers: as before
+    assert c.ask("Push these 3 repositories?") is True
+    assert R.Ctx(V, None, False, False, True).ask("anything?") is True   # --yes