s3dgraphy 1.6.0.dev54__tar.gz → 1.6.0.dev56__tar.gz

{s3dgraphy-1.6.0.dev54/src/s3dgraphy.egg-info → s3dgraphy-1.6.0.dev56}/PKG-INFO

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

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

{s3dgraphy-1.6.0.dev54 → s3dgraphy-1.6.0.dev56}/src/s3dgraphy/JSON_config/em_visual_rules.json

@@ -1,6 +1,6 @@
 {
   "formal_language": "EM",
-  "version": "1.6.34",
+  "version": "1.6.35",
   "_note_material_vs_qualia_color": [
     "DUE COSE DIVERSE CHE SI CHIAMANO ENTRAMBE color. Non confonderle: e gia successo.",
     "1) QUI, in node_styles.<tipo>.style.material.rgba_color — il COLORE DEL MATERIALE BLENDER del proxy 3D, in float LINEARI. UNA sola chiave: `rgba_color`. Fino a S8 il file ne usava due (`color` sui 13 tipi stratigrafici, `rgba_color` sugli altri) e get_material_color() ne leggeva una sola, restituendo None per 21 tipi su 38; ora sono unificate e la vecchia `color` e letta solo come tolleranza verso file scritti prima. Un tipo che non diventa mai una mesh NON ha material affatto (i contenitori di gruppo, e da S7 i dieci nodi che rendono per icona): per loro get_material_color() torna None, ed e corretto.",
@@ -9,6 +9,7 @@
     "In breve: qui si decide di che colore DISEGNARE una US; li si registra di che colore ERA."
   ],
   "_changelog": {
+    "1.6.35": "RM AND PROXY AMONG THE COMPUTED INSTANCES (MICRO lo spazio 3D, E.D. 11 Oct 2026). New block threed_instances: the proxy of a unit (geometry property → has_semantic_shape → SemanticShape) is drawn in the paradata group of the property, beside it; a representation model is drawn in the paradata group of each epoch that has it (has_representation_model, directly or through an epoch property), with the number of its epochs («×N»). A view: nothing in em.json or RDF. Read by s3dgraphy.paradata_view.threed_instances and units_without_3d.",
     "1.6.34": "THE AUTHOR AS AN INSTANCE (MICRO le entità spaziotemporali, decided by E.D. 10 Oct 2026: documents, authors and units are spatiotemporal entities, and an author «si istanzia come avviene con i documenti»). paradata_instances gains `authorship`: the author of a reader of the group (the extractor, or the combiner and the extractors it combines) reached by has_author, when the author is not itself a member of the group, is drawn inside the group as an INSTANCE of kind `author`, with the badge of the epoch where the author begins (has_first_epoch). Still a view: nothing is written in em.json or RDF. s3dgraphy.paradata_view.view_instances reads it.",
     "1.6.32": "THE GLYPHS OF THE 3D OBJECTS (MICRO «grafo reattivo», G9, 9 Oct 2026; drawings approved by E.D. on 6 Oct, APPROVATE.md). representation_model, representation_model_doc (the checkered picture seen three-quarters, with its frame's depth and a shadow on the ground: an image PLACED in 3D space) and representation_model_sf replace the three identical Font Awesome cubes of src/2D/ and join `2d_render_glyph_types.types`; proxy, tileset, container (the RM container, RepresentationModelNodeGroup) and the four versions version:gltf / version:mesh / version:tiles / version:scene are new files, resolved from the node's DATA by the new table `2d_render_glyph_types.data_glyphs` (keyed like dtc:<kind>; its rule is written in its _comment, measured on Templu Mare v2). All ten in the DTC frame (circle r 41.14, viewBox 87.12) with the 2×2 checker of the EMtools icons: the checker colours are `accent`, never recoloured; black `ink`, white `paper`, the grey of the picture's frame `ground`, the shadow `halo`. NEW in the layer format: `frame: true` marks the layers of the frame circle (its `paper` fill and its `ink` stroke), and the entry's `frameless_box` is the box of everything else — below 24 px a consumer may skip the frame and fit that box instead (docs/drawing-a-glyph.md §5). Additive: no existing glyph changed.",
     "1.6.31": "THE CHOICES OF DEV29, CONFIRMED (E.D., 2 Oct 2026, on the dev29 report, D5). dtc_kinds.process.texturing is projection AND baking of the photographs onto the mesh, one act, one kind; the baking of levels of detail in Blender stays lod_generation, an act of its own. The «until E.D. says otherwise» of 1.6.30 is gone from the description. Text only: no kind, glyph or label changed.",
@@ -6239,6 +6240,30 @@
       }
     }
   },
+  "threed_instances": {
+    "_comment": "1.6.35 (MICRO lo spazio 3D, E.D. 11 Oct 2026: «nel grafo, la presenza del 3D visibile accanto alle unità e alle epoche»). The representation models and the proxies join the computed instances, and like them they are a VIEW: nothing is written in em.json or RDF. PROXY: the property of type `geometry` of a unit reaches by `has_semantic_shape` the SemanticShape (the proxy, its glb a `proxy_model` resource by `has_linked_resource`); the view draws the shape in the paradata group of the property — its own `is_in_paradata_nodegroup`, else the group of its original owner (`has_paradata_nodegroup`) — BESIDE the property. RM: an epoch reaches its model by `has_representation_model`, directly or through one of its properties (both read; the data measured on 16 Oct 2026 carry only the direct edge); the view draws the model in the epoch's paradata group, and when the same model is in N epochs every instance carries N («×N»). With no group, `place` is the owner itself (the unit, the epoch). The reference implementation is s3dgraphy.paradata_view.threed_instances; units_without_3d answers which units have a proxy, a geometry without payload, or none.",
+    "proxy": {
+      "kind": "proxy",
+      "owner_edge": "has_property",
+      "property_type": "geometry",
+      "shape_edge": "has_semantic_shape",
+      "file_edge": "has_linked_resource",
+      "file_types": ["proxy_model"],
+      "membership": "is_in_paradata_nodegroup",
+      "group_edge": "has_paradata_nodegroup",
+      "beside": "property"
+    },
+    "representation_model": {
+      "kind": "rm",
+      "holders": ["EpochNode"],
+      "edge": "has_representation_model",
+      "via_property": "has_property",
+      "masters": ["RepresentationModelNode", "RepresentationModelDocNode", "RepresentationModelSpecialFindNode"],
+      "group_edge": "has_paradata_nodegroup",
+      "count_word": "×{n}"
+    },
+    "id": "{master}##{place}"
+  },
   "dtc_kinds": {
     "_comment": "DATA-DRIVEN, EXPANDABLE per-kind vocabulary for the DTC substrate profile (ECHOES). Mirrors the Master-Document axis vocabularies above (document_roles/content_natures): the three base kinds (input/process/output) each list specific kinds seeded from the 2017 DTC palette. Adding a new kind (e.g. audio, spectroscopy) is a JSON entry here (+ a glyph) — NOT a code change; the DTC node classes validate against these keys via s3dgraphy.utils.get_dtc_kinds(). `glyph` names the 2017 DTC SVG (wired in the later glyph/visual-manager slice; recorded here as data only).",
     "input": {

{s3dgraphy-1.6.0.dev54 → s3dgraphy-1.6.0.dev56}/src/s3dgraphy/__init__.py

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

{s3dgraphy-1.6.0.dev54 → s3dgraphy-1.6.0.dev56}/src/s3dgraphy/api.py

@@ -342,6 +342,24 @@ def view_instances(graph: Graph, group_id: str) -> List[Dict[str, Any]]:
     return _view(graph, group_id)
 
 
+def threed_instances(graph: Graph) -> List[Dict[str, Any]]:
+    """The proxies and the representation models as the view draws them
+    (em_visual_rules 1.6.35, ``threed_instances``): the proxy of a unit in the
+    paradata group of its geometry property, beside it; a model in the paradata
+    group of each epoch that has it, with the number of its epochs. Computed,
+    never stored; see :func:`s3dgraphy.paradata_view.threed_instances`."""
+    from .paradata_view import threed_instances as _view
+    return _view(graph)
+
+
+def units_without_3d(graph: Graph) -> Dict[str, List[str]]:
+    """``{with, empty, none, without}``: the units with a proxy, with an empty
+    geometry property, with none, and the last two together — see
+    :func:`s3dgraphy.paradata_view.units_without_3d`."""
+    from .paradata_view import units_without_3d as _units
+    return _units(graph)
+
+
 def dependents_of(graph: Graph, node_id: str) -> List[Dict[str, Any]]:
     """Who leans on a unit, a property or a document, in cascade: ``[{id,
     name, node_type, kind, via, depth, owner, owner_name}]`` — what an
@@ -3069,7 +3087,8 @@ def resolve_file(entry: Dict[str, Any], **kwargs) -> Dict[str, Any]:
 
 
 # ── a study into a room, from a folder (MICRO-ROOM-IMPORT, 15 Oct 2026) ──────
-def room_import(em_json: str, *, node: str, room: str, title: Optional[str] = None,
+def room_import(em_json: Optional[str] = None, *, node: str, room: str,
+                title: Optional[str] = None,
                 base_dir: Optional[str] = None, visibility: str = "restricted",
                 token: Optional[str] = None, dry_run: bool = False,
                 pack_tilesets: Optional[str] = None, **kwargs) -> Dict[str, Any]:
@@ -3079,8 +3098,11 @@ def room_import(em_json: str, *, node: str, room: str, title: Optional[str] = No
     hosted keeping their path, the graph is seated last as operations, then
     ``study-access``. ``dry_run``: the plan only, nothing written.
     ``pack_tilesets="3tz"``: a tileset folder goes up as one canonical
-    ``.3tz``. → the report. The one engine of the three doors (the command,
-    EMStudio, EM Tools); see :mod:`s3dgraphy.room_import`."""
+    ``.3tz``. ``container=`` (a study held in memory) with ``base_dirs=``
+    instead of the path; the person's choices as ``per_group``/``per_batch``/
+    ``per_item``, ``move``, ``lots``; ``before_seed`` for what a client adds
+    before the graph is seated. → the report. The one engine of the three
+    doors (the command, EMStudio, EM Tools); see :mod:`s3dgraphy.room_import`."""
     from .room_import import room_import as _run
     return _run(em_json, node=node, room=room, title=title, base_dir=base_dir,
                 visibility=visibility, token=token, dry_run=dry_run,

{s3dgraphy-1.6.0.dev54 → s3dgraphy-1.6.0.dev56}/src/s3dgraphy/paradata_view.py

@@ -241,3 +241,230 @@ def all_view_instances(graph) -> Dict[str, List[Dict[str, Any]]]:
             if recs:
                 out[n.node_id] = recs
     return out
+
+
+# ── 1.6.35 · the 3D among the computed instances ─────────────────────────────
+#
+# MICRO lo spazio 3D (E.D., 11 Oct 2026): «nel grafo, la presenza del 3D visibile
+# accanto alle unità e alle epoche». The proxy of a unit and the representation
+# model of an epoch are drawn as instances, like a document read from outside:
+# still a view, nothing written. The rule is `em_visual_rules.json` →
+# `threed_instances`.
+
+
+@lru_cache(maxsize=1)
+def threed_rule() -> Dict[str, Any]:
+    """The ``threed_instances`` block of ``em_visual_rules.json``."""
+    from .nodes.base_node import load_json_mapping
+    rules = load_json_mapping("em_visual_rules.json") or {}
+    return dict(rules.get("threed_instances") or {})
+
+
+def threed_instance_id(master_id: str, place_id: str) -> str:
+    """The id every client gives the 3D instance of ``master_id`` drawn in
+    ``place_id`` (a paradata group, else the owner itself)."""
+    pattern = threed_rule().get("id") or "{master}##{place}"
+    return pattern.format(master=master_id, place=place_id)
+
+
+def _out(graph, node_id: str, edge_type: str) -> List[str]:
+    return [e.edge_target for e in graph.edges
+            if e.edge_source == node_id and e.edge_type == edge_type and _live(e)]
+
+
+def _inn(graph, node_id: str, edge_type: str) -> List[str]:
+    return [e.edge_source for e in graph.edges
+            if e.edge_target == node_id and e.edge_type == edge_type and _live(e)]
+
+
+def _property_type(node) -> str:
+    data = getattr(node, "data", None) or {}
+    return str(getattr(node, "property_type", None) or data.get("property_type") or "")
+
+
+def _proxy_payload(graph, shape, spec: Dict[str, Any]) -> Dict[str, Any]:
+    """What a shape carries: its ``proxy_model`` resources, its hulls and spheres."""
+    types = set(spec.get("file_types") or ["proxy_model"])
+    files = []
+    for rid in _out(graph, shape.node_id, spec.get("file_edge") or "has_linked_resource"):
+        res = graph.find_node_by_id(rid)
+        data = getattr(res, "data", None) or {}
+        if res is None or _removed(res) or getattr(res, "node_type", None) != "resource":
+            continue
+        if types & {data.get("url_type"), data.get("resource_type")}:
+            files.append(rid)
+    data = getattr(shape, "data", None) or {}
+    hulls = bool(data.get("convexshapes") or getattr(shape, "convexshapes", None))
+    spheres = bool(data.get("spheres") or getattr(shape, "spheres", None))
+    return {"files": files, "hulls": hulls or spheres}
+
+
+def _place(graph, owner_id: str, prop_id: Optional[str], spec: Dict[str, Any]) -> Optional[str]:
+    """The paradata group a 3D instance is drawn in: the property's own group,
+    else the group of the owner (``has_paradata_nodegroup``)."""
+    if prop_id:
+        for g in _out(graph, prop_id, spec.get("membership") or "is_in_paradata_nodegroup"):
+            node = graph.find_node_by_id(g)
+            if node is not None and not _removed(node):
+                return g
+    for g in _out(graph, owner_id, spec.get("group_edge") or "has_paradata_nodegroup"):
+        node = graph.find_node_by_id(g)
+        if node is not None and not _removed(node):
+            return g
+    return None
+
+
+def _units(graph):
+    from .nodes.stratigraphic_node import ContinuityNode, StratigraphicNode
+    return [n for n in graph.nodes if isinstance(n, StratigraphicNode)
+            and not isinstance(n, ContinuityNode) and not _removed(n)]
+
+
+def proxy_instances(graph) -> List[Dict[str, Any]]:
+    """The proxies of the units, as instances::
+
+        {id, kind: "proxy", master, node_type, name, owner, owner_kind: "unit",
+         owner_name, beside, group, place, files, empty, removed}
+
+    ``master`` the SemanticShape; ``beside`` the geometry property it hangs
+    from; ``group`` the paradata group it is drawn in (None when the unit has
+    none: ``place`` is then the unit); ``files`` its ``proxy_model``
+    resources; ``empty`` when the shape carries neither a file nor hulls.
+    """
+    from .ownership import original_owner
+    spec = dict(threed_rule().get("proxy") or {})
+    owner_edge = spec.get("owner_edge") or "has_property"
+    ptype = spec.get("property_type") or "geometry"
+    shape_edge = spec.get("shape_edge") or "has_semantic_shape"
+    out: List[Dict[str, Any]] = []
+    seen = set()
+    for unit in _units(graph):
+        for pid in _out(graph, unit.node_id, owner_edge):
+            prop = graph.find_node_by_id(pid)
+            if prop is None or _removed(prop) or _property_type(prop) != ptype:
+                continue
+            # a property inherited by a second unit is drawn once, by its owner
+            owner = original_owner(graph, pid) or unit.node_id
+            if owner != unit.node_id:
+                continue
+            for sid in _out(graph, pid, shape_edge):
+                shape = graph.find_node_by_id(sid)
+                if shape is None or (pid, sid) in seen:
+                    continue
+                seen.add((pid, sid))
+                payload = _proxy_payload(graph, shape, spec)
+                group = _place(graph, unit.node_id, pid, spec)
+                place = group or unit.node_id
+                out.append({
+                    "id": threed_instance_id(sid, place), "kind": spec.get("kind") or "proxy",
+                    "master": sid, "node_type": getattr(shape, "node_type", None),
+                    "name": getattr(shape, "name", sid),
+                    "owner": unit.node_id, "owner_kind": "unit",
+                    "owner_name": getattr(unit, "name", unit.node_id),
+                    "beside": pid, "group": group, "place": place,
+                    "files": payload["files"],
+                    "empty": not payload["files"] and not payload["hulls"],
+                    "removed": _removed(shape)})
+    return out
+
+
+def rm_instances(graph) -> List[Dict[str, Any]]:
+    """The representation models of the epochs, as instances::
+
+        {id, kind: "rm", master, node_type, name, owner, owner_kind: "epoch",
+         owner_name, via, group, place, epochs, count, count_label, removed}
+
+    One per (model, epoch). ``via`` the epoch property the link passes
+    through (None when the epoch reaches the model directly); ``epochs`` every
+    epoch the model is in, ``count`` how many, ``count_label`` the rule's word
+    («×3») when there are more than one.
+    """
+    spec = dict(threed_rule().get("representation_model") or {})
+    holders = spec.get("holders") or ["EpochNode"]
+    edge = spec.get("edge") or "has_representation_model"
+    via_prop = spec.get("via_property") or "has_property"
+    masters = spec.get("masters") or ["RepresentationModelNode", "RepresentationModelDocNode",
+                                      "RepresentationModelSpecialFindNode"]
+    word = spec.get("count_word") or "×{n}"
+    links: Dict[str, List[Dict[str, Any]]] = {}
+    order: List[str] = []
+    for holder in graph.nodes:
+        if _removed(holder) or _class_of(holder, holders) is None:
+            continue
+        reached = [(rm, None) for rm in _out(graph, holder.node_id, edge)]
+        for pid in _out(graph, holder.node_id, via_prop):
+            prop = graph.find_node_by_id(pid)
+            if prop is not None and not _removed(prop):
+                reached += [(rm, pid) for rm in _out(graph, pid, edge)]
+        for rm_id, via in reached:
+            rm = graph.find_node_by_id(rm_id)
+            if rm is None or _class_of(rm, masters) is None:
+                continue
+            mine = links.setdefault(rm_id, [])
+            if any(x["owner"] == holder.node_id for x in mine):
+                continue
+            if rm_id not in order:
+                order.append(rm_id)
+            mine.append({"owner": holder.node_id, "via": via})
+    out: List[Dict[str, Any]] = []
+    for rm_id in order:
+        rm = graph.find_node_by_id(rm_id)
+        epochs = [x["owner"] for x in links[rm_id]]
+        n = len(epochs)
+        for x in links[rm_id]:
+            epoch = graph.find_node_by_id(x["owner"])
+            group = _place(graph, x["owner"], x["via"], spec)
+            place = group or x["owner"]
+            out.append({
+                "id": threed_instance_id(rm_id, place), "kind": spec.get("kind") or "rm",
+                "master": rm_id, "node_type": getattr(rm, "node_type", None),
+                "name": getattr(rm, "name", rm_id),
+                "owner": x["owner"], "owner_kind": "epoch",
+                "owner_name": getattr(epoch, "name", x["owner"]),
+                "via": x["via"], "group": group, "place": place,
+                "epochs": list(epochs), "count": n,
+                "count_label": word.format(n=n) if n > 1 else None,
+                "removed": _removed(rm)})
+    return out
+
+
+def threed_instances(graph) -> List[Dict[str, Any]]:
+    """The proxies and the representation models, as the view draws them:
+    :func:`proxy_instances` then :func:`rm_instances`. Pure."""
+    return proxy_instances(graph) + rm_instances(graph)
+
+
+def units_without_3d(graph) -> Dict[str, List[str]]:
+    """Which units have a 3D proxy, and which do not::
+
+        {"with": [...], "empty": [...], "none": [...], "without": [...]}
+
+    ``with`` a geometry property whose shape carries a file or hulls;
+    ``empty`` a geometry property and nothing in it (no shape, or a shape
+    with neither file nor hulls); ``none`` no geometry property at all;
+    ``without`` = ``empty`` + ``none``, the units a proxy can be given to.
+    Continuity nodes are not units to model.
+    """
+    spec = dict(threed_rule().get("proxy") or {})
+    owner_edge = spec.get("owner_edge") or "has_property"
+    ptype = spec.get("property_type") or "geometry"
+    shape_edge = spec.get("shape_edge") or "has_semantic_shape"
+    res: Dict[str, List[str]] = {"with": [], "empty": [], "none": [], "without": []}
+    for unit in _units(graph):
+        props = [graph.find_node_by_id(p) for p in _out(graph, unit.node_id, owner_edge)]
+        props = [p for p in props if p is not None and not _removed(p) and _property_type(p) == ptype]
+        if not props:
+            res["none"].append(unit.node_id)
+            continue
+        full = False
+        for p in props:
+            for sid in _out(graph, p.node_id, shape_edge):
+                shape = graph.find_node_by_id(sid)
+                if shape is None or _removed(shape):
+                    continue
+                pay = _proxy_payload(graph, shape, spec)
+                if pay["files"] or pay["hulls"]:
+                    full = True
+        res["with" if full else "empty"].append(unit.node_id)
+    res["without"] = res["empty"] + res["none"]
+    return res

{s3dgraphy-1.6.0.dev54 → s3dgraphy-1.6.0.dev56}/src/s3dgraphy/room_import/__init__.py

@@ -52,13 +52,23 @@ written by dtcstamp (s3Dgraphy stays a reader), a sibling representation
 (`dtc_derived_from` the folder, a DTC step `packing` with its stamp); the
 folder stays as a reference. See :mod:`.pack`.
 
+A CLIENT WITH A DIALOG (EM Tools' «Bring into a room») calls the two halves:
+:func:`prepare` (the room, then the plan, from the study it holds in memory:
+`container=`, `base_dirs=`), shows the rows, and :func:`execute` with the
+person's choices (:func:`apply_choices` per group / batch / item, `move` for
+«Move here», the confirmed `lots`) and its hook for what only the client can
+make (`before_seed`: EM Tools publishes the scene's models there, so they are
+in the one seeding).
+
 Defaults to confirm (E.D.): the name `room_import` / `room-import`, a new
 room's visibility `restricted`.
 """
 
-from .engine import (JOURNAL_NAME, Interrupted, Journal, make_plan, markdown,
-                     room_import, summarise_plan)
+from .engine import (JOURNAL_NAME, Interrupted, Journal, apply_choices,
+                     birth_sections, execute, make_plan, markdown, plan_report,
+                     prepare, room_import, summarise_plan)
 from .errors import RoomError
 
-__all__ = ["JOURNAL_NAME", "Interrupted", "Journal", "RoomError", "make_plan",
-           "markdown", "room_import", "summarise_plan"]
+__all__ = ["JOURNAL_NAME", "Interrupted", "Journal", "RoomError", "apply_choices",
+           "birth_sections", "execute", "make_plan", "markdown", "plan_report",
+           "prepare", "room_import", "summarise_plan"]