s3dgraphy 1.6.0.dev105__tar.gz → 1.6.0.dev106__tar.gz

{s3dgraphy-1.6.0.dev105/src/s3dgraphy.egg-info → s3dgraphy-1.6.0.dev106}/PKG-INFO

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

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

{s3dgraphy-1.6.0.dev105 → s3dgraphy-1.6.0.dev106}/src/s3dgraphy/JSON_config/s3Dgraphy_node_datamodel.json

@@ -1160,7 +1160,8 @@
           "properties": {
             "name": "P1_is_identified_by",
             "description": "P3_has_note",
-            "frame": {"kind": "node_element", "em_json": "data.frame", "rdf": null, "same_as": "ResourceNode.properties.frame", "note": "1.6.38: the frame of the container's alternative (a tileset of the whole survey) when it is said on the container: {crs, shift, note, source}, as ResourceNode.frame. The resource's own frame wins."}
+            "frame": {"kind": "node_element", "em_json": "data.frame", "rdf": null, "same_as": "ResourceNode.properties.frame", "note": "1.6.38: the frame of the container's alternative (a tileset of the whole survey) when it is said on the container: {crs, shift, note, source}, as ResourceNode.frame. The resource's own frame wins."},
+            "active_alternative": {"kind": "node_element", "em_json": "data.active_alternative", "rdf": null, "values": {"<use> | <target> | *": "container | members"}, "note": "MICRO-ASSETS-LIVELLI (E.D., 13 Nov 2026), proposed: which alternative the container lights, kept in the graph so every reader gives the same answer. Inside a container the meshes (its members) and the tileset of the whole (its own alternative, hatted by the container with has_linked_resource) are alternatives of each other: one is seen, or the other. The map goes from a use (heriverse, web, realtime…) or a target of EMStudio's Archive › Assets (mobile, web, desk) to «container» (the tileset) or «members» (the models, each with its version); «*» for every use not named. No key: the rule of resources.alternatives.choose_alternative (the tileset where it declares the use or fits the target's band). Written by resources.alternatives.set_active_alternative; read by choose_alternative and by asset_list (the budget counts only the alternative lit; the meshes a lit tileset covers get no proposal of reduction). A choice of presentation, not a fact of the survey: it belongs to the container as its frame does, and says nothing of the epochs, which stay on the members."}
           }
         }
       }

{s3dgraphy-1.6.0.dev105 → s3dgraphy-1.6.0.dev106}/src/s3dgraphy/__init__.py

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

{s3dgraphy-1.6.0.dev105 → s3dgraphy-1.6.0.dev106}/src/s3dgraphy/resources/alternatives.py

@@ -549,12 +549,16 @@ def alternative_sets(graph, *, bounds: Optional[Dict[str, Any]] = None,
                            f"{len(epochs(hat_id))} epochs ({', '.join(name(x) for x in epochs(hat_id))}): "
                            f"an alternative does not cross epochs",
                 "cure": "one sub-container per epoch, each with its own alternative"})
-        return {"hat": hat_id, "hat_kind": kind, "name": name(hat_id),
-                "node_type": str(getattr(node, "node_type", "") or ""),
-                "epochs": epochs(hat_id), "assets": assets, "alternatives": alts,
-                "reasons": reasons, "members": members,
-                "covers": covers if kind == "container" else [hat_id],
-                "coverage": coverage, "parent": parent}
+        out = {"hat": hat_id, "hat_kind": kind, "name": name(hat_id),
+               "node_type": str(getattr(node, "node_type", "") or ""),
+               "epochs": epochs(hat_id), "assets": assets, "alternatives": alts,
+               "reasons": reasons, "members": members,
+               "covers": covers if kind == "container" else [hat_id],
+               "coverage": coverage, "parent": parent}
+        if kind == "container":
+            # MICRO-ASSETS-LIVELLI · the choice written in the graph, by use
+            out["active"] = active_choices(graph, hat_id)
+        return out
 
     seen: set = set()
     top: List[Dict[str, Any]] = []
@@ -665,6 +669,10 @@ def choose_alternative(aset: Dict[str, Any], use: Any,
     from .versions import choose_version
     uses = [use] if isinstance(use, str) else list(use or [])
     hat = aset.get("hat")
+    if force is None and aset.get("hat_kind") == "container":
+        # MICRO-ASSETS-LIVELLI (E.D., 13 Nov 2026) · the choice the graph
+        # keeps for these uses (:func:`set_active_alternative`) is the hand's
+        force = active_of(aset.get("active") or {}, uses)
     if aset.get("hat_kind") != "container":
         ch = choose_version(aset.get("alternatives") or [], uses, prefer_level)
         if ch is None:
@@ -701,3 +709,185 @@ def choose_alternative(aset: Dict[str, Any], use: Any,
     if out["use"] is None:
         out["note"] = f"no version for {', '.join(uses) or 'no use'}: the members, each with its master"
     return out
+
+
+# ── MICRO-ASSETS-LIVELLI · the active alternative, kept in the graph ─────────
+#
+# E.D., 13 Nov 2026: inside a container the meshes and the tileset are, by
+# default, ALTERNATIVES of each other — one is seen, or the other. The person
+# may change the one lit for a use, and the choice is written in the graph,
+# where every reader (EMStudio, EM Tools, Heriverse) finds the same answer: a
+# property of the CONTAINER, ``data.active_alternative`` (node datamodel,
+# RepresentationModelNodeGroup.properties.active_alternative), a map from a
+# use — or a target of Archive › Assets (``mobile``, ``web``, ``desk``) — to
+# ``"container"`` (its own alternative, the tileset) or ``"members"`` (the
+# models, each with its version); ``"*"`` for every use not named. No key: the
+# rule of :func:`choose_alternative` (the tileset when it declares the use).
+
+ACTIVE_KEY = "active_alternative"
+ACTIVE_WHICH = ("container", "members")
+
+
+def active_choices(graph, group_id: str) -> Dict[str, str]:
+    """The choices a container keeps, ``{use: "container" | "members"}``
+    (only well-formed entries)."""
+    node = _node(graph, group_id)
+    raw = _data(node).get(ACTIVE_KEY) if node is not None else None
+    if not isinstance(raw, dict):
+        return {}
+    return {str(k): str(v) for k, v in raw.items() if v in ACTIVE_WHICH}
+
+
+def active_of(choices: Dict[str, str], uses: Iterable[str]) -> Optional[str]:
+    """The choice for these uses: the first use named, else ``"*"``, else
+    None (the rule decides)."""
+    for u in list(uses or []):
+        if u in choices:
+            return choices[u]
+    return choices.get("*")
+
+
+def set_active_alternative(graph, group_id: str, which: Optional[str],
+                           use: str = "*") -> Dict[str, Any]:
+    """Write which alternative a container lights for ``use`` (``"*"``: every
+    use not named): ``"container"`` (its own alternative, the tileset) or
+    ``"members"`` (its models); ``None`` takes the choice away (the rule
+    decides again). Idempotent. → ``{group, use, which, choices}``."""
+    node = _node(graph, group_id)
+    if getattr(node, "node_type", "") != GROUP_NODE_TYPE:
+        raise ValueError(f"{group_id!r} is not an RM container")
+    if which is not None and which not in ACTIVE_WHICH:
+        raise ValueError(f"which is one of {ACTIVE_WHICH} or None, not {which!r}")
+    d = _data(node)
+    choices = active_choices(graph, group_id)
+    if which is None:
+        choices.pop(str(use), None)
+    else:
+        choices[str(use)] = which
+    if choices:
+        d[ACTIVE_KEY] = choices
+    else:
+        d.pop(ACTIVE_KEY, None)
+    return {"group": group_id, "use": use, "which": which, "choices": dict(choices)}
+
+
+# ── MICRO-ASSETS-LIVELLI · the containers by hand (Archive › Assets) ─────────
+#
+# A row dragged onto a container, a container made from a selection: the
+# graph's own gestures, so that EMStudio's page carries no rule of its own.
+# Membership is m:n (E.D. 23 Oct 2026); the file on disk never moves — the
+# graph changes, not the tree of folders.
+
+def put_in_container(graph, node_id: str, group_id: str, *,
+                     move_from: Optional[str] = None) -> Dict[str, Any]:
+    """``node_id`` (a model or a container) becomes a MEMBER of ``group_id``
+    (``is_in_representation_model_group``). With ``move_from`` it leaves that
+    container (a move); without, it is added and keeps the others (m:n).
+    A container cannot enter itself nor one of its own members. Idempotent.
+    → ``{node, group, added, left}``."""
+    group = _node(graph, group_id)
+    if getattr(group, "node_type", "") != GROUP_NODE_TYPE:
+        raise ValueError(f"{group_id!r} is not an RM container")
+    node = _node(graph, node_id)
+    if node is None:
+        raise ValueError(f"{node_id!r} is not a node of this graph")
+    if node_id == group_id or (getattr(node, "node_type", "") == GROUP_NODE_TYPE
+                               and group_id in _inside(graph, node_id)):
+        raise ValueError(f"{getattr(node, 'name', node_id)!r} cannot enter a container it holds")
+    left = []
+    if move_from and move_from != group_id:
+        for e in list(graph.edges):
+            if e.edge_type == EDGE_MEMBER and e.edge_source == node_id and e.edge_target == move_from:
+                graph.remove_edge(e.edge_id)
+                left.append(move_from)
+    added = group_id not in containers_of(graph, node_id)
+    if added:
+        graph.add_edge(f"{node_id}_{EDGE_MEMBER}_{group_id}", node_id, group_id, EDGE_MEMBER)
+    return {"node": node_id, "group": group_id, "added": added, "left": left}
+
+
+def _inside(graph, group_id: str) -> List[str]:
+    """Every container under ``group_id`` (its sub-containers, deep)."""
+    out, todo = [], [group_id]
+    while todo:
+        g = todo.pop()
+        for m in members_of(graph, g):
+            if getattr(_node(graph, m), "node_type", "") == GROUP_NODE_TYPE and m not in out:
+                out.append(m)
+                todo.append(m)
+    return out
+
+
+def create_container(graph, label: str, *, epoch_id: Optional[str] = None,
+                     document_id: Optional[str] = None,
+                     members: Sequence[str] = (), group_id: Optional[str] = None) -> Dict[str, Any]:
+    """A new RM container named ``label``: its epoch reaches it with
+    ``has_representation_model`` (EpochNode → container, admitted by the
+    connections datamodel; :func:`container_own_epochs` reads it — the
+    «default» epochs, the members keep theirs), the Document that publishes it
+    the same (Document → container, as «Survey 2015» under D.01), and
+    ``members`` put in it (added: m:n). The id follows :func:`group_id_for`
+    (from the document when given), ``-2``… when taken.
+    → ``{group_id, created, members}``."""
+    from ..nodes.group_node import RepresentationModelNodeGroup
+    label = str(label or "").strip()
+    if not label:
+        raise ValueError("a container needs a name")
+    for ref, kind in ((epoch_id, "EpochNode"), (document_id, None)):
+        if ref and _node(graph, ref) is None:
+            raise ValueError(f"{ref!r} is not a node of this graph")
+        if ref and kind and getattr(_node(graph, ref), "node_type", "") != kind:
+            raise ValueError(f"{ref!r} is not an epoch")
+    gid = group_id or group_id_for(label, document_id or "")
+    base, n = gid, 2
+    while _node(graph, gid) is not None:
+        gid = f"{base}-{n}"
+        n += 1
+    graph.add_node(RepresentationModelNodeGroup(node_id=gid, name=label, description=""))
+    for src in (epoch_id, document_id):
+        if src:
+            graph.add_edge(f"{src}_has_representation_model_{gid}", src, gid,
+                           "has_representation_model")
+    put = [m for m in members if put_in_container(graph, m, gid)["added"]]
+    return {"group_id": gid, "created": True, "members": put}
+
+
+def rename_container(graph, group_id: str, label: str) -> Dict[str, Any]:
+    """A container's name (its id stays)."""
+    node = _node(graph, group_id)
+    if getattr(node, "node_type", "") != GROUP_NODE_TYPE:
+        raise ValueError(f"{group_id!r} is not an RM container")
+    label = str(label or "").strip()
+    if not label:
+        raise ValueError("a container needs a name")
+    old = node.name
+    node.name = label
+    return {"group": group_id, "old": old, "name": label}
+
+
+def empty_container(graph, group_id: str) -> Dict[str, Any]:
+    """Every member leaves the container (their other containers, epochs and
+    documents stay); its own alternative (``has_linked_resource``) stays
+    with it. → ``{group, left}``."""
+    if getattr(_node(graph, group_id), "node_type", "") != GROUP_NODE_TYPE:
+        raise ValueError(f"{group_id!r} is not an RM container")
+    left = []
+    for e in list(graph.edges):
+        if e.edge_type == EDGE_MEMBER and e.edge_target == group_id:
+            graph.remove_edge(e.edge_id)
+            left.append(e.edge_source)
+    return {"group": group_id, "left": left}
+
+
+def remove_container(graph, group_id: str) -> Dict[str, Any]:
+    """An EMPTY container goes, with its edges (its epochs, its document, the
+    container it is in). One with members, or with an alternative of its own,
+    is refused: empty it first, or move its alternative."""
+    if getattr(_node(graph, group_id), "node_type", "") != GROUP_NODE_TYPE:
+        raise ValueError(f"{group_id!r} is not an RM container")
+    if members_of(graph, group_id):
+        raise ValueError("the container is not empty: empty it first")
+    if any(e.edge_type == EDGE_HAT and e.edge_source == group_id for e in graph.edges):
+        raise ValueError("the container has an alternative of its own: move it to another first")
+    graph.remove_node(group_id)
+    return {"group": group_id, "removed": True}

{s3dgraphy-1.6.0.dev105 → s3dgraphy-1.6.0.dev106}/src/s3dgraphy/resources/asset_list.py

@@ -393,7 +393,19 @@ def cover_by_tilesets(graph, assets: List[Dict[str, Any]]) -> Dict[str, int]:
     («serve per epoca: il tileset non si divide»), or a mesh is cited alone in
     a narrative. Where the tileset does not fit, the meshes keep their
     proposal and say why the tileset does not cover them yet. → the meshes
-    covered per target."""
+    covered per target.
+
+    MICRO-ASSETS-LIVELLI (E.D., 13 Nov 2026) · meshes and tileset are
+    ALTERNATIVES of each other: the container's choice kept in the graph
+    (:func:`.alternatives.set_active_alternative`, by target, by use or
+    ``*``) wins over the rule — ``container`` covers the meshes even where
+    the tileset is out of its band or the meshes lie in several epochs (said
+    in their why), ``members`` switches the tileset off for that target (state
+    ``na``, ``off_by_choice``) and leaves the meshes their proposals. Each
+    container row says, per target, the alternative lit (``alternative``:
+    ``{active, chosen}``). A member WITHOUT an epoch is not «another epoch»:
+    only the members that have epochs are compared."""
+    from .alternatives import active_choices, active_of
     cited = None
     n = {k: 0 for k in STREAMED}
     for c in assets:
@@ -401,26 +413,50 @@ def cover_by_tilesets(graph, assets: List[Dict[str, Any]]) -> Dict[str, int]:
             continue
         tv = next((v for v in c["versions"] if v["tileset"] and v["id"] in
                    {c["targets"][k]["loads"] for k in STREAMED}), None)
+        if tv is None:
+            tv = next((v for v in c["versions"] if v["tileset"]), None)
         if tv is None:
             continue
         members = [a for a in assets if a is not c and a["kind"] == "rm"
                    and any(x["id"] == c["id"] for x in a["containers"])]
+        choices = active_choices(graph, c["id"])
+        c["alternative"] = {}
         if not members:
             continue
         if cited is None:
             cited = _cited_alone(graph)
-        epochs = {tuple(sorted(a["epochs"])) for a in members}
+        epochs = {tuple(sorted(a["epochs"])) for a in members if a["epochs"]}
         by_epoch = len(epochs) > 1
-        for a in members:
-            alone = ("serve per epoca: il tileset non si divide" if by_epoch else
-                     f"usata da sola nella narrazione «{cited[a['id']]}»: il tileset non si divide"
-                     if a["id"] in cited else "")
-            for k in STREAMED:
-                tc, cell = c["targets"][k], a["targets"][k]
+        for k in STREAMED:
+            chosen = active_of(choices, [k, *TARGETS[k]["uses"]])
+            tc = c["targets"][k]
+            if chosen == "members":
+                c["alternative"][k] = {"active": "members", "chosen": True}
+                if tc["state"] != "na":
+                    for v in c["versions"]:
+                        if k in v["loaded_by"]:
+                            v["loaded_by"].remove(k)
+                    say = "spento: per questo uso sono scelte le mesh del contenitore"
+                    c["targets"][k] = {**tc, "state": "na", "why": say, "off_by_choice": True,
+                                       "proposal": {"tool": "keep", "triangles": None, "texture": None,
+                                                    "ktx2": False, "why": say}}
+                for a in members:
+                    cell = a["targets"][k]
+                    if cell["state"] != "na":
+                        cell["tileset_of"] = {"id": c["id"], "name": c["name"], "state": "na"}
+                continue
+            lit = chosen == "container" or tc["state"] == "ok"
+            c["alternative"][k] = {"active": "container" if lit else "members", "chosen": chosen is not None}
+            for a in members:
+                alone = ("" if chosen == "container" else
+                         "serve per epoca: il tileset non si divide" if by_epoch else
+                         f"usata da sola nella narrazione «{cited[a['id']]}»: il tileset non si divide"
+                         if a["id"] in cited else "")
+                cell = a["targets"][k]
                 if cell["state"] == "na":
                     continue
                 cell["tileset_of"] = {"id": c["id"], "name": c["name"], "state": tc["state"]}
-                if tc["state"] != "ok":
+                if not lit:
                     cell["why"] = f"{cell['why']} (il tileset di {c['name']} non la copre: {tc['why']})"
                     continue
                 if alone:
@@ -429,14 +465,16 @@ def cover_by_tilesets(graph, assets: List[Dict[str, Any]]) -> Dict[str, int]:
                     cell["proposal"] = {**cell["proposal"], "why": f"{alone} — {cell['proposal']['why']}"}
                     continue
                 say = f"coperta dal tileset di {c['name']}"
+                if chosen == "container":
+                    say += " (scelto nel grafo)"
                 for v in a["versions"]:
                     if k in v["loaded_by"]:
                         v["loaded_by"].remove(k)
                 a["targets"][k] = {"state": "na", "loads": cell["loads"], "why": say,
                                    "covered_by": {"id": c["id"], "name": c["name"], "version": tv["id"]},
                                    "tileset_of": cell["tileset_of"],
-                                   "proposal": {"tool": "keep", "triangles": None, "texture": None, "ktx2": False,
-                                                "why": say}}
+                                   "proposal": {"tool": "keep", "triangles": None, "texture": None,
+                                                "ktx2": False, "why": say}}
                 n[k] += 1
     return n
 

{s3dgraphy-1.6.0.dev105 → s3dgraphy-1.6.0.dev106}/src/s3dgraphy/resources/use_profiles.py

@@ -1484,6 +1484,42 @@ def list_versions(folder: str, model: Optional[str] = None, *, measure: bool = T
     return out
 
 
+IMAGE_EXTS = (".png", ".jpg", ".jpeg", ".ktx2", ".webp", ".basis", ".tga", ".tif", ".tiff", ".exr")
+
+
+def version_files(entry: str) -> Dict[str, Any]:
+    """Every file that goes with ONE version, wherever it is (MICRO-ASSETS-
+    LIVELLI, E.D. 13 Nov 2026: the versions the graph cites, not only those in
+    a ``versions/`` folder): the ``.glb``/``.stl`` itself, or a ``.gltf`` with
+    its ``.bin`` and textures — the whole folder when the glTF sits in a
+    folder named as a version (``<model>@<level>…/``) — and its stamp and
+    hints beside it. → ``{entry, path, files, bytes, images}`` (``images``:
+    the texture files among ``files``, what a removal may keep when another
+    geometry uses them). A file that cannot be read is listed alone."""
+    entry = os.path.abspath(entry)
+    path = entry
+    parent = os.path.dirname(entry)
+    files: List[str] = [entry]
+    if entry.lower().endswith(".gltf") and parse_version_name(os.path.basename(parent)) is not None:
+        path = parent
+        for root, _dirs, fs in os.walk(parent):
+            files += [os.path.join(root, f) for f in fs]
+    elif entry.lower().endswith(".gltf"):
+        try:
+            files += list(measure_gltf(entry)["files"])
+        except (OSError, ValueError, KeyError, IndexError, struct.error):
+            pass
+    side = sidecars(entry)
+    if path != entry:
+        outer = sidecars(path)
+        side = {k: side[k] or outer[k] for k in side}
+    files += [f for f in side.values() if f]
+    files = sorted(set(os.path.abspath(f) for f in files if os.path.exists(f)))
+    return {"entry": entry, "path": path, "files": files,
+            "bytes": sum(os.path.getsize(f) for f in files if os.path.isfile(f)),
+            "images": [f for f in files if f.lower().endswith(IMAGE_EXTS)]}
+
+
 def stl_triangles(path: str) -> Optional[int]:
     """The triangles of an STL: a binary one says it in its header, an ASCII
     one counts its ``facet`` lines. None when it cannot be read."""

{s3dgraphy-1.6.0.dev105 → s3dgraphy-1.6.0.dev106/src/s3dgraphy.egg-info}/PKG-INFO

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

@@ -443,6 +443,7 @@ tests/test_api_surface.py
 tests/test_asset_dtc_protocol.py
 tests/test_asset_list.py
 tests/test_asset_versions.py
+tests/test_assets_livelli.py
 tests/test_aton_shapes.py
 tests/test_attach_only.py
 tests/test_authority_projection.py

s3dgraphy-1.6.0.dev106/tests/test_assets_livelli.py

@@ -0,0 +1,140 @@
+"""MICRO-ASSETS-LIVELLI (E.D., 13 Nov 2026) · meshes and tileset as
+alternatives in a container, the choice kept in the graph, and the
+containers by hand (a row dragged onto a container, a container made from a
+selection)."""
+
+import pytest
+
+from s3dgraphy.nodes.epoch_node import EpochNode
+from s3dgraphy.resources import alternatives as ALT
+from s3dgraphy.resources import asset_list as AL
+
+from tests.test_tileset_fit import _study_with_members
+
+FITS = {"tiles": 1, "read": 1, "per_tile": [[10, 64]], "max_triangles": 10, "max_texture_side": 64}
+BIG = {"tiles": 2, "read": 2, "per_tile": [[9000, 1024], [9000, 512]], "max_triangles": 9000, "max_texture_side": 1024}
+
+
+def _by_name(g, st):
+    return {x["name"]: x for x in AL.asset_list(g, tiles=lambda e: st)["assets"]}
+
+
+def test_a_member_without_epoch_is_not_another_epoch():
+    # Templu Mare v9, Survey2015: nine meshes in «XX sec» and one RMSF with no
+    # epoch — the tileset covered none of them («serve per epoca»)
+    g, _t = _study_with_members()
+    g.add_node(EpochNode(node_id="e1", name="XX sec", start_time=1900, end_time=2000))
+    g.add_edge("x1", "e1", "rm_rb1", "has_representation_model")
+    a = _by_name(g, FITS)
+    assert a["rm_rb1"]["epochs"] == ["XX sec"] and a["rm_rb2"]["epochs"] == []
+    for m in ("rm_rb1", "rm_rb2"):
+        assert a[m]["targets"]["web"]["covered_by"]["name"] == "Survey2015"
+    assert a["Survey2015"]["alternative"]["web"] == {"active": "container", "chosen": False}
+
+
+def test_the_choice_in_the_graph_lights_the_members_or_the_tileset():
+    g, _t = _study_with_members()
+    out = ALT.set_active_alternative(g, "grp", "members", use="web")
+    assert out["choices"] == {"web": "members"}
+    assert g.find_node_by_id("grp").data[ALT.ACTIVE_KEY] == {"web": "members"}
+    a = _by_name(g, FITS)
+    web = a["Survey2015"]["targets"]["web"]
+    assert web["state"] == "na" and web["off_by_choice"] and "web" not in a["Survey2015"]["versions"][-1]["loaded_by"]
+    assert a["Survey2015"]["alternative"]["web"] == {"active": "members", "chosen": True}
+    assert not a["rm_rb1"]["targets"]["web"].get("covered_by")
+    # the other targets keep the rule
+    assert a["rm_rb1"]["targets"]["desk"]["covered_by"]
+    # «container» for every use: covers even where the tileset is over the band
+    ALT.set_active_alternative(g, "grp", None, use="web")
+    ALT.set_active_alternative(g, "grp", "container")
+    a = _by_name(g, BIG)
+    assert a["Survey2015"]["targets"]["mobile"]["state"] == "todo"
+    cell = a["rm_rb1"]["targets"]["mobile"]
+    assert cell["covered_by"] and cell["why"].endswith("(scelto nel grafo)")
+    assert a["Survey2015"]["alternative"]["mobile"] == {"active": "container", "chosen": True}
+    # taken away: the rule again, and no key left on the node
+    ALT.set_active_alternative(g, "grp", None)
+    assert ALT.ACTIVE_KEY not in g.find_node_by_id("grp").data
+    with pytest.raises(ValueError):
+        ALT.set_active_alternative(g, "grp", "both")
+    with pytest.raises(ValueError):
+        ALT.set_active_alternative(g, "rm_rb1", "members")
+
+
+def test_choose_alternative_reads_the_graphs_choice():
+    g, _t = _study_with_members()
+    ALT.set_active_alternative(g, "grp", "members", use="heriverse")
+    s = ALT.find_set(ALT.alternative_sets(g), "grp")
+    assert s["active"] == {"heriverse": "members"}
+    assert ALT.choose_alternative(s, ["heriverse"])["level"] == "members"
+    assert ALT.choose_alternative(s, ["heriverse"], force="container")["level"] == "container"
+
+
+def test_put_in_container_adds_or_moves_and_refuses_a_loop():
+    g, _t = _study_with_members()
+    made = ALT.create_container(g, "Fase 2013", members=["rm_rb1"])
+    gid = made["group_id"]
+    assert gid == "rmgroup_Fase_2013" and made["members"] == ["rm_rb1"]
+    assert sorted(ALT.containers_of(g, "rm_rb1")) == sorted(["grp", gid])      # m:n: added
+    out = ALT.put_in_container(g, "rm_rb2", gid, move_from="grp")
+    assert out["added"] and out["left"] == ["grp"] and ALT.containers_of(g, "rm_rb2") == [gid]
+    assert not ALT.put_in_container(g, "rm_rb2", gid)["added"]                  # idempotent
+    ALT.put_in_container(g, gid, "grp")
+    with pytest.raises(ValueError):
+        ALT.put_in_container(g, "grp", gid)                                     # grp holds gid
+    with pytest.raises(ValueError):
+        ALT.put_in_container(g, gid, gid)
+
+
+def test_create_with_epoch_and_document_rename_empty_remove():
+    from s3dgraphy.nodes.document_node import DocumentNode
+    g, _t = _study_with_members()
+    g.add_node(EpochNode(node_id="e13", name="2013", start_time=2013, end_time=2013))
+    g.add_node(DocumentNode(node_id="D.09", name="D.09", description=""))
+    gid = ALT.create_container(g, "Rilievo 2013", epoch_id="e13", document_id="D.09")["group_id"]
+    assert gid == "D.09_rmgroup"
+    assert ALT.container_own_epochs(g, gid) == ["e13"]
+    assert any(e.edge_type == "has_representation_model" and e.edge_source == "D.09" and e.edge_target == gid
+               for e in g.edges)
+    assert ALT.create_container(g, "Rilievo 2013", document_id="D.09")["group_id"] == "D.09_rmgroup-2"
+    with pytest.raises(ValueError):
+        ALT.create_container(g, "x", epoch_id="D.09")
+    ALT.rename_container(g, gid, "Rilievo 2013 (Maxar)")
+    assert g.find_node_by_id(gid).name == "Rilievo 2013 (Maxar)"
+    ALT.put_in_container(g, "rm_rb1", gid)
+    with pytest.raises(ValueError):
+        ALT.remove_container(g, gid)
+    assert ALT.empty_container(g, gid)["left"] == ["rm_rb1"]
+    assert ALT.containers_of(g, "rm_rb1") == ["grp"]
+    ALT.remove_container(g, gid)
+    assert g.find_node_by_id(gid) is None
+    assert not any(gid in (e.edge_source, e.edge_target) for e in g.edges)
+    # a container with an alternative of its own is not removed even empty
+    ALT.empty_container(g, "grp")
+    with pytest.raises(ValueError):
+        ALT.remove_container(g, "grp")
+
+
+def test_version_files_wherever_the_version_is(tmp_path):
+    # MICRO-ASSETS-LIVELLI p.1 · a version the graph cites in the project's RM
+    # folder (not in versions/): the glb with its stamp and hints; a glTF in a
+    # folder named as a version: the whole folder, its images apart
+    from s3dgraphy.resources import use_profiles as UP
+    glb = tmp_path / "ME_EST_L_LOD1@lod2-mobile_ar.glb"
+    glb.write_bytes(b"glTF")
+    (tmp_path / "ME_EST_L_LOD1@lod2-mobile_ar.glb.stamp.json").write_text("{}")
+    (tmp_path / "ME_EST_L_LOD1@lod2-mobile_ar.glb.hints.json").write_text("{}")
+    (tmp_path / "other@lod2-mobile_ar.glb").write_bytes(b"glTF")
+    r = UP.version_files(str(glb))
+    assert [p.rsplit("/", 1)[1] for p in r["files"]] == [
+        "ME_EST_L_LOD1@lod2-mobile_ar.glb", "ME_EST_L_LOD1@lod2-mobile_ar.glb.hints.json",
+        "ME_EST_L_LOD1@lod2-mobile_ar.glb.stamp.json"]
+    assert r["images"] == [] and r["bytes"] == 8
+    d = tmp_path / "ME_EST_L_LOD1@lod0-aton-heriverse-fcdcf422"
+    d.mkdir()
+    (d / "ME_EST_L_LOD1.gltf").write_text('{"asset": {"version": "2.0"}}')
+    (d / "ME_EST_L_LOD1.bin").write_bytes(b"\0" * 4)
+    (d / "T_OB_EST_L_LOD1.jpg").write_bytes(b"\xff\xd8")
+    r = UP.version_files(str(d / "ME_EST_L_LOD1.gltf"))
+    assert r["path"] == str(d) and len(r["files"]) == 3
+    assert [p.rsplit("/", 1)[1] for p in r["images"]] == ["T_OB_EST_L_LOD1.jpg"]