s3dgraphy 1.6.0.dev89__tar.gz → 1.6.0.dev90__tar.gz

{s3dgraphy-1.6.0.dev89/src/s3dgraphy.egg-info → s3dgraphy-1.6.0.dev90}/PKG-INFO

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

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

{s3dgraphy-1.6.0.dev89 → s3dgraphy-1.6.0.dev90}/src/s3dgraphy/__init__.py

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

{s3dgraphy-1.6.0.dev89 → s3dgraphy-1.6.0.dev90}/src/s3dgraphy/api.py

@@ -3159,8 +3159,10 @@ def add_version(graph: Graph, master_id: str, *, level: Optional[str] = None,
     from a ``lodK``); ``use`` a list of :data:`resources.versions.USES`;
     ``measures`` the numbers of :data:`resources.versions.LOD_MEASURES` (D1).
     Idempotent per (asset, level); other bytes at a level are refused (revise
-    the version instead). Returns ``{version_id, process_id, created, asset_id,
-    level, lod_level, use, measures, purpose, warnings}``."""
+    the version instead). ``profile`` and ``use_params`` (MICRO-VERSIONI-PER-
+    USO): a version made for a use, named by it (``mobile-webxr-2k``), never a
+    level. Returns ``{version_id, process_id, created, asset_id, level,
+    lod_level, use, measures, purpose, profile, use_params, warnings}``."""
     from .resources.versions import add_version as _add
     before = _ids(graph)
     out = _add(graph, master_id, level=level, purpose=purpose, **kwargs)

{s3dgraphy-1.6.0.dev89 → s3dgraphy-1.6.0.dev90}/src/s3dgraphy/project_tree.py

@@ -240,6 +240,12 @@ def variant_name(model: str, lod: str, destination: str, ext: str = ".glb") -> s
             stem = stem[: -len(known)]
             break
     lod = str(lod).strip().lower()
+    # MICRO-VERSIONI-PER-USO (E.D., 2 Nov 2026) · a variant made for a use is
+    # named by it: ``lod`` a use's name (``mobile-webxr-2k``) →
+    # ``<model>@mobile-webxr-2k.glb``, the destination already in it
+    from .resources.use_profiles import parse_use_tag
+    if parse_use_tag(lod):
+        return f"{stem}{VARIANT_SEP}{lod}{ext}"
     if lod and not lod.startswith("lod"):
         lod = f"lod{lod}"
     dest = str(destination).strip().lower().replace(" ", "-")

{s3dgraphy-1.6.0.dev89 → s3dgraphy-1.6.0.dev90}/src/s3dgraphy/resources/asset_list.py

@@ -176,8 +176,13 @@ def _version(graph, entry: Dict[str, Any], summary: Dict[str, Any], *, states, m
     return {"id": entry["id"], "name": summary.get("name") or entry.get("name") or "",
             "asset_id": entry.get("asset_id"), "master": bool(entry.get("master")),
             "level": summary.get("level") or "", "lod_level": summary.get("lod_level") or "",
-            "level_say": TILESET_SAY if summary.get("tileset") else level_say(entry),
+            "level_say": TILESET_SAY if summary.get("tileset") else level_say(
+                entry, summary.get("triangles"), summary.get("texture_side")),
             "use": list(entry.get("use") or []),
+            # MICRO-VERSIONI-PER-USO · the profile it was made for («» for a
+            # rung of a LOD chain) and its numbers: the row says it by its use
+            "profile": str(entry.get("profile") or ""), "by_use": bool(entry.get("by_use")),
+            "use_params": dict(entry.get("use_params") or {}),
             "url": summary.get("url") or "", "checksum": summary.get("checksum") or "",
             "stamped": bool(summary.get("checksum")),
             "size_bytes": summary.get("size_bytes"), "triangles": summary.get("triangles"),

{s3dgraphy-1.6.0.dev89 → s3dgraphy-1.6.0.dev90}/src/s3dgraphy/resources/graph_compose.py

@@ -448,6 +448,13 @@ def level_key(entry: Dict[str, Any]) -> tuple:
     import re
     if entry.get("master"):
         return ("master", "")
+    # MICRO-VERSIONI-PER-USO · a version made for a use is the asset AND the
+    # use: another number of the same use (mobile 2k after mobile 10k, or the
+    # «lod1-mobile» of before) is the same version made again — the later wins
+    from .versions import entry_profile
+    pid = entry_profile(entry)
+    if pid:
+        return ("use", pid)
     lvl = str(entry.get("level") or entry.get("lod_level") or "").strip().lower()
     if re.match(r"^manual-\d{4}-\d{2}-\d{2}(?:-\d+)?$", lvl):
         lvl = "manual"
@@ -459,11 +466,27 @@ def level_key(entry: Dict[str, Any]) -> tuple:
     return (lvl, prof)
 
 
-def level_say(entry: Dict[str, Any]) -> str:
-    """«lod1 · webXR», «master», «manual-2026-10-31 · desktop realtime»."""
+def level_say(entry: Dict[str, Any], triangles: Optional[float] = None,
+              texture_side: Optional[int] = None) -> str:
+    """«mobile webXR · 10k tri · 512 px» (a version made for a use, also one
+    of before named ``lod1-mobile``: MICRO-VERSIONI-PER-USO, E.D. 2 Nov 2026),
+    «catena LOD 2» (a rung of a LOD chain), «master», «manual-2026-10-31 ·
+    desktop realtime». The numbers: ``triangles`` and ``texture_side`` when the
+    caller measured them, else the use's own (``use_params``) or its name's."""
     if entry.get("master"):
         return "master"
+    from .use_profiles import chain_say, is_chain_level, parse_use_tag, use_say
+    from .versions import entry_profile
+    pid = entry_profile(entry)
+    if pid:
+        up = entry.get("use_params") or {}
+        tag = parse_use_tag(entry.get("level")) or {}
+        tri = triangles if triangles is not None else up.get("triangles", tag.get("triangles"))
+        side = texture_side or up.get("texture_side_px") or up.get("texture_side")
+        return use_say(pid, tri, side)
     lvl = str(entry.get("level") or entry.get("lod_level") or "") or "?"
+    if is_chain_level(lvl):
+        return chain_say(lvl)
     prof = level_key(entry)[1]
     if prof:
         try:

{s3dgraphy-1.6.0.dev89 → s3dgraphy-1.6.0.dev90}/src/s3dgraphy/resources/use_profiles.py

@@ -1221,21 +1221,145 @@ DESTINATIONS = tuple(sorted({v["destination"] for v in PROFILES.values()}, key=l
                             reverse=True))
 
 
-def version_file_name(model: str, level: str, prof: Any, packaging: Optional[str] = None) -> str:
-    """The canonical name: ``<model>@<level>-<destination>.glb`` (or ``.gltf``,
-    or ``.stl`` for a print)."""
+# ── MICRO-VERSIONI-PER-USO (E.D., 2 Nov 2026) ─────────────────────────────
+#
+# «lod0 / lod1» on a version made FOR A USE misleads: a LOD is a rung of a
+# chain made as such (3DSC's LOD generator, «catena LOD»). A version made for
+# a use is named BY ITS USE and its numbers — ``<model>@<use>[-<tri>k].glb``
+# (``Column_light1@mobile-webxr-2k.glb``) — and there may be several of one
+# use (one for the web on a desktop between the full one and the mobile one).
+# The names of before (``<model>@lod1-mobile.glb``) are still read, and said
+# by their use (:func:`parse_version_name` gives ``use`` for both).
+
+#: The USE of a profile in a file name: its id with hyphens.
+USE_SLUGS: Dict[str, str] = {k.replace("_", "-"): k for k in PROFILES}
+_SLUG_ALT = "|".join(re.escape(s) for s in sorted(USE_SLUGS, key=len, reverse=True))
+#: ``<model>@<use>[-<n>k][-<k>]`` (+ ``-<hex8>`` for a glTF folder)
+USE_VERSION_NAME = re.compile(rf"^(?P<model>.+)@(?P<use>{_SLUG_ALT})(?:-(?P<kilo>\d+(?:\.\d+)?)k)?"
+                              r"(?:-(?P<n>\d{1,3}))?(?:-(?P<hex>[0-9a-f]{8}))?"
+                              r"(?P<ext>\.glb|\.gltf|\.stl)?$")
+#: What a row says of a profile (E.D.'s words: «webXR / Heriverse»).
+USE_SAY_IT = {"desktop_realtime": "desktop realtime", "webxr": "webXR / Heriverse",
+              "mobile_webxr": "mobile webXR", "archive": "archivio",
+              "preview": "anteprima", "render_offline": "rendering offline",
+              "print_3d": "stampa 3D"}
+
+
+def use_slug(prof: Any) -> str:
+    """``mobile_webxr`` (or a use, a destination, a profile dict) → ``mobile-webxr``."""
+    p = prof if isinstance(prof, dict) else profile(prof)
+    return str(p["id"] if "id" in p else next(k for k, v in PROFILES.items() if v is p or v == p)
+               ).replace("_", "-")
+
+
+def kilo(triangles: Optional[float]) -> str:
+    """Triangles in a name: ``2000`` → ``2k``, ``53_412`` → ``53k``, ``1500`` →
+    ``1.5k`` (one decimal below 10 k), ``""`` when not given."""
+    if triangles in (None, "") or float(triangles) <= 0:
+        return ""
+    k = float(triangles) / 1000.0
+    if k < 10 and round(k, 1) != round(k):
+        return f"{round(k, 1):g}k"
+    return f"{max(1, int(round(k)))}k"
+
+
+def use_tag(prof: Any, triangles: Optional[float] = None, n: Optional[int] = None) -> str:
+    """The name of a version made for a use: ``mobile-webxr`` ``-2k`` (its
+    triangles, when the use asks a number) ``-2`` (a second one beside the
+    first with the same name: «Nuova accanto»). It is also its LEVEL in the
+    graph (:func:`s3dgraphy.resources.versions.add_version`: the level is the
+    version's name and the key of its id) — never ``lodN``."""
+    out = use_slug(prof)
+    k = kilo(triangles)
+    if k:
+        out += f"-{k}"
+    if n and int(n) > 1:
+        out += f"-{int(n)}"
+    return out
+
+
+def parse_use_tag(tag: Any) -> Optional[Dict[str, Any]]:
+    """``mobile-webxr-2k`` → ``{use, profile, triangles, n}``; None when the
+    text is not a use's name (``lod1``, ``manual-…``)."""
+    m = re.match(rf"^(?P<use>{_SLUG_ALT})(?:-(?P<kilo>\d+(?:\.\d+)?)k)?(?:-(?P<n>\d{{1,3}}))?$",
+                 str(tag or "").strip().lower())
+    if not m:
+        return None
+    return {"use": m.group("use"), "profile": USE_SLUGS[m.group("use")],
+            "triangles": int(round(float(m.group("kilo")) * 1000)) if m.group("kilo") else None,
+            "n": int(m.group("n")) if m.group("n") else 1}
+
+
+def is_chain_level(level: Any) -> bool:
+    """``lod0``… — a rung of a LOD chain (the only place «LOD n» is said)."""
+    return bool(re.match(r"^lod\d+$", str(level or "").strip().lower()))
+
+
+def use_say(prof: Any, triangles: Optional[float] = None, texture_side: Optional[int] = None) -> str:
+    """«mobile webXR · 10k tri · 512 px», «webXR / Heriverse · 53k tri»."""
+    try:
+        p = profile(prof) if not isinstance(prof, dict) else prof
+        pid = p.get("id") or ""
+        out = USE_SAY_IT.get(pid) or p.get("label_it") or pid
+    except ValueError:
+        out = str(prof)
+    if triangles and float(triangles) > 0:
+        out += f" · {int(triangles) if float(triangles) < 1000 else kilo(triangles)} tri"
+    if texture_side:
+        out += f" · {int(texture_side)} px"
+    return out
+
+
+def chain_say(level: Any) -> str:
+    """``lod3`` → «catena LOD 3»."""
+    m = re.match(r"^lod(\d+)$", str(level or "").strip().lower())
+    return f"catena LOD {m.group(1)}" if m else str(level or "")
+
+
+def use_version_name(model: str, prof: Any, triangles: Optional[float] = None,
+                     packaging: Optional[str] = None, n: Optional[int] = None) -> str:
+    """``<model>@<use>[-<tri>k][-<n>].glb`` (``.gltf``, ``.stl``)."""
+    return version_file_name(model, use_tag(prof, triangles, n), prof, packaging)
+
+
+def version_file_name(model: str, level: Optional[str], prof: Any, packaging: Optional[str] = None,
+                      *, triangles: Optional[float] = None) -> str:
+    """The canonical name. A version for a use (``level`` empty, or a use's
+    name from :func:`use_tag`): ``<model>@<use>[-<tri>k].glb``; a rung of a
+    LOD chain (``lodN``) or a name given by hand: ``<model>@<level>-<destination>.glb``
+    as before (or ``.gltf``, or ``.stl`` for a print)."""
     p = prof if isinstance(prof, dict) else profile(prof)
     pk = packaging or p.get("packaging") or "glb"
     safe = re.sub(r"[^\w.\-]+", "_", str(model)).strip("_") or "model"
     ext = {"gltf_separate": "gltf", "stl": "stl"}.get(pk, "glb")
+    if not level:
+        level = use_tag(p if "id" in p else prof, triangles)
+    if parse_use_tag(level):
+        return f"{safe}@{level}.{ext}"
     return f"{safe}@{level}-{p['destination']}.{ext}"
 
 
 def parse_version_name(name: str) -> Optional[Dict[str, str]]:
-    """``Column_light1@lod1-realtime-web.glb`` → ``{model, level, destination,
-    profile, ext}`` (``profile`` the first destination tag that names one,
-    ``""`` when none); None when the name is not a version's."""
+    """``Column_light1@mobile-webxr-2k.glb`` → ``{model, level: "mobile-webxr-2k",
+    destination, profile: "mobile_webxr", ext, use: "mobile-webxr", triangles:
+    2000, n: 1, by_use: True}``; a name of before, ``Column_light1@lod1-realtime-
+    web.glb`` → the same keys, ``level`` ``lod1``, ``by_use`` False, ``use`` its
+    profile's (``profile`` the first destination tag that names one, ``""``
+    when none); None when the name is not a version's."""
     base = os.path.basename(str(name))
+    u = USE_VERSION_NAME.match(base) if not MANUAL_VERSION_NAME.match(base) else None
+    if u and not (u.group("hex") and u.group("ext")):
+        # MICRO-VERSIONI-PER-USO · named by its use
+        pid = USE_SLUGS[u.group("use")]
+        tag = base[len(u.group("model")) + 1:]
+        if u.group("ext"):
+            tag = tag[: -len(u.group("ext"))]
+        if u.group("hex"):
+            tag = tag[: -9]
+        return {"model": u.group("model"), "level": tag, "destination": PROFILES[pid]["destination"],
+                "profile": pid, "ext": (u.group("ext") or "").lstrip("."), "use": u.group("use"),
+                "triangles": int(round(float(u.group("kilo")) * 1000)) if u.group("kilo") else None,
+                "n": int(u.group("n")) if u.group("n") else 1, "by_use": True}
     m = MANUAL_VERSION_NAME.match(base) or VERSION_NAME.match(base)
     if not m:
         return None
@@ -1251,8 +1375,12 @@ def parse_version_name(name: str) -> Optional[Dict[str, str]]:
     for d in DESTINATIONS:
         if rest == d or rest.startswith(d + "-") or rest.endswith("-" + d):
             prof = prof or USE_TO_PROFILE.get(d, "")
+    # a name of before (``lod1-mobile``) is said by its use too: ``use`` is
+    # its profile's, ``by_use`` False (its level stays what the name says)
     return {"model": m.group("model"), "level": m.group("level"), "destination": rest,
-            "profile": prof, "ext": (m.group("ext") or "").lstrip(".")}
+            "profile": prof, "ext": (m.group("ext") or "").lstrip("."),
+            "use": prof.replace("_", "-") if prof else "", "triangles": None, "n": 1,
+            "by_use": False}
 
 
 HINTS_SUFFIX = ".hints.json"

{s3dgraphy-1.6.0.dev89 → s3dgraphy-1.6.0.dev90}/src/s3dgraphy/resources/versions.py

@@ -257,6 +257,18 @@ def _entry(graph, res_id: str, *, level, purpose, process_id, master: bool,
             "revisions": chain}
 
 
+def _use_fields(entry: Dict[str, Any], params: Dict[str, Any], pdata: Dict[str, Any]) -> None:
+    """MICRO-VERSIONI-PER-USO · ``profile``, ``use_params``, ``by_use`` (made
+    for a use: said by its use, not by a level) and ``made_at`` (its step's
+    date) on an entry of :func:`versions_of`."""
+    entry["profile"] = str(params.get("profile") or "")
+    entry["use_params"] = dict(params.get("use_params") or {})
+    entry["profile"] = entry_profile(entry)
+    entry["by_use"] = bool(entry["profile"])
+    entry["made_at"] = str(pdata.get("modified_at") or pdata.get("created_at")
+                           or pdata.get("at") or "")
+
+
 def _current(graph, res_id: str) -> str:
     try:
         return revisions_of(graph, res_id)[-1]
@@ -269,7 +281,9 @@ def versions_of(graph, asset_id: str) -> List[Dict[str, Any]]:
 
     Each entry: ``{id, name, level, lod_level, use, measures, primitives,
     purpose, master, process_id, checksum, url, residency, media_type,
-    size_bytes, revisions}``. ``id`` is the CURRENT revision of the version; ``revisions``
+    size_bytes, revisions, profile, use_params, by_use, made_at}`` (the last
+    four: MICRO-VERSIONI-PER-USO — the profile it was made for, ``""`` for a
+    rung of a LOD chain; :func:`use_versions` groups them by use). ``id`` is the CURRENT revision of the version; ``revisions``
     its chain, oldest first. ``level`` is the name given; ``lod_level`` the
     COMPUTED level (None for the master, D1). The versions of a version (a LOD1
     made from LOD0) are listed too. The master's ``level`` is the
@@ -299,6 +313,7 @@ def versions_of(graph, asset_id: str) -> List[Dict[str, Any]]:
                            process_id=proc.node_id, master=False,
                            origin=out.node_id)
             entry["use"] = _uses_of(params, _data(_node(graph, entry["id"])))
+            _use_fields(entry, params, _data(proc))
             kids.append(entry)
             # a version of a version: its own versions are the asset's too
             kids.extend(_descendants(graph, out.node_id))
@@ -306,6 +321,7 @@ def versions_of(graph, asset_id: str) -> List[Dict[str, Any]]:
     out = [_entry(graph, _current(graph, asset), level=master_level, purpose="",
                   process_id=None, master=True, origin=asset)]
     out[0]["use"] = []
+    out[0].update(profile="", use_params={}, by_use=False, made_at="")
     seen = set()
     unique = []
     for k in kids:
@@ -340,6 +356,7 @@ def _descendants(graph, res_id: str) -> List[Dict[str, Any]]:
                                process_id=proc.node_id, master=False,
                                origin=child.node_id)
                 entry["use"] = _uses_of(params, _data(_node(graph, entry["id"])))
+                _use_fields(entry, params, _data(proc))
                 out.append(entry)
                 out.extend(_descendants(graph, child.node_id))
     return out
@@ -638,9 +655,24 @@ def add_version(graph, master_id: str, *, level: Optional[str] = None, purpose:
                 version_id: Optional[str] = None,
                 author: Optional[str] = None,
                 at: Optional[str] = None,
-                revise: bool = False) -> Dict[str, Any]:
+                revise: bool = False,
+                profile: Optional[str] = None,
+                use_params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
     """A new version of the asset ``master_id`` at ``level``, for ``purpose``.
 
+    MICRO-VERSIONI-PER-USO (E.D., 2 Nov 2026) · a version made FOR A USE is
+    named by its use, not by a level: ``profile`` (a profile of
+    :mod:`.use_profiles`, or a use or destination that names one) and its
+    ``use_params`` (``triangles``, ``texture_side_px``, ``texture_format``…).
+    Its ``level`` — the name and the key of its id — is then the use's name
+    (:func:`.use_profiles.use_tag`: ``mobile-webxr-2k``) unless one is given,
+    so a mobile version beside a web one is ANOTHER version, never a revision
+    of it; the same use with the same numbers and other bytes is revised as
+    before. Both go in the step's ``parameters`` (``profile``,
+    ``use_params``), beside ``level`` and ``purpose``: nothing new on the
+    resource, its ``use`` list (what Heriverse reads) as before. ``lodN``
+    stays for the rungs of a LOD chain.
+
     Writes the version resource (kind of the master, ``tier: distribution``,
     ``files`` as :func:`add_resource` takes them) and the ``lod_generation``
     step from the master to it. Idempotent: the id is derived from (asset,
@@ -667,6 +699,10 @@ def add_version(graph, master_id: str, *, level: Optional[str] = None, purpose:
     master = _node(graph, master_id)
     if master is None or not _is_resource(master):
         raise ValueError(f"{master_id!r} is not a resource of this graph")
+    prof_id, uparams = _use_of(profile, use_params)
+    if prof_id and not level:
+        from .use_profiles import use_tag
+        level = use_tag(prof_id, uparams.get("triangles"))
     uses = check_use(use if use is not None else ([purpose] if purpose in USES else None))
     measured = check_measures(measures)
     # D1 · the level, when nobody names it, is the computed one: a version of
@@ -724,6 +760,10 @@ def add_version(graph, master_id: str, *, level: Optional[str] = None, purpose:
         params["purpose"] = str(purpose)
     if master_level:
         params["source_level"] = str(master_level).strip()
+    if prof_id:
+        params["profile"] = prof_id
+        if uparams:
+            params["use_params"] = uparams
     step = declare_derivation(
         graph, output=vid, inputs=[master_id], dtc_kind=DTC_KIND,
         process_id=str(uuid.uuid5(_NS, f"lod_generation|{vid}")),
@@ -734,7 +774,79 @@ def add_version(graph, master_id: str, *, level: Optional[str] = None, purpose:
             "created": created, "asset_id": asset, "level": lvl,
             "lod_level": lod_level_of(graph, vid), "use": uses,
             "measures": measured, "revises": revises,
-            "purpose": str(purpose or ""), "warnings": step["warnings"]}
+            "purpose": str(purpose or ""), "profile": prof_id or "",
+            "use_params": uparams, "warnings": step["warnings"]}
+
+
+def _use_of(profile: Optional[str], use_params: Optional[Dict[str, Any]]):
+    """``(profile id, use_params)`` checked: the profile one of
+    :data:`.use_profiles.PROFILES` (a use or destination naming one is
+    taken), the numbers non-negative (``texture_format`` a word)."""
+    if not profile:
+        return "", dict(use_params or {})
+    from .use_profiles import profile as _profile
+    pid = _profile(str(profile))["id"]
+    out: Dict[str, Any] = {}
+    for k, v in (use_params or {}).items():
+        if v is None or v == "":
+            continue
+        if k in ("texture_format", "compression", "packaging"):
+            out[k] = str(v)
+            continue
+        if isinstance(v, bool) or not isinstance(v, (int, float)) or v < 0:
+            raise ValueError(f"use_params.{k} must be a non-negative number, got {v!r}")
+        out[k] = int(v) if float(v).is_integer() else v
+    return pid, out
+
+
+def entry_profile(entry: Dict[str, Any]) -> str:
+    """The profile a version was made for: its step's ``profile``, else the
+    one its level's name says (``mobile-webxr-2k``); for a version of before
+    (``lod1`` for ``mobile``, by EMStudio's «Ottimizza» or «Prepara per un
+    uso») the profile whose DESTINATION its ``purpose`` is (``mobile``,
+    ``aton-heriverse``, ``realtime``…). ``""`` for the master and for a rung of
+    a LOD chain made as such (no profile; a purpose that is only a use, as
+    ``web``, does not make one)."""
+    if entry.get("master"):
+        return ""
+    if entry.get("profile"):
+        return str(entry["profile"])
+    from .use_profiles import PROFILES, parse_use_tag
+    tag = parse_use_tag(entry.get("level"))
+    if tag:
+        return tag["profile"]
+    purpose = str(entry.get("purpose") or "")
+    pid = next((k for k, v in PROFILES.items() if purpose and v["destination"] == purpose), "")
+    if pid:
+        return pid
+    # its file named by EMStudio or EM Tools: ``podio@lod1-mobile.glb``
+    from .use_profiles import parse_version_name
+    url = str(entry.get("url") or "").replace("\\", "/").rstrip("/")
+    name = url.rsplit("/", 1)[-1]
+    parsed = parse_version_name(name) if "@" in name else None
+    if parsed is None and "@" in url:
+        # a glTF in a folder of its own: ``podio@lod0-aton-heriverse/podio.gltf``
+        parsed = parse_version_name(url.rsplit("/", 2)[-2]) if url.count("/") else None
+    return (parsed or {}).get("profile") or ""
+
+
+def use_versions(entries: Sequence[Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
+    """The versions of an asset BY USE (MICRO-VERSIONI-PER-USO): ``{profile:
+    {latest, others}}`` — for «Aggiorna», the coverage and «the last version»
+    the identity is the asset and the use; with several of one use (other
+    numbers) the most recent wins (its step's date, else the later in the
+    list) and the others stay listed."""
+    out: Dict[str, Dict[str, Any]] = {}
+    for i, e in enumerate(entries):
+        pid = entry_profile(e)
+        if not pid:
+            continue
+        out.setdefault(pid, {"all": []})["all"].append((str(e.get("made_at") or ""), i, e))
+    for pid, g in out.items():
+        ranked = sorted(g.pop("all"), key=lambda x: (x[0], x[1]))
+        g["latest"] = ranked[-1][2]
+        g["others"] = [x[2] for x in ranked[:-1]]
+    return out
 
 
 def planned_version(graph, master_id: str, *, level: Optional[str] = None,

{s3dgraphy-1.6.0.dev89 → s3dgraphy-1.6.0.dev90/src/s3dgraphy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: s3dgraphy
-Version: 1.6.0.dev89
+Version: 1.6.0.dev90
 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.dev89 → s3dgraphy-1.6.0.dev90}/tests/test_asset_versions.py

@@ -239,3 +239,77 @@ def test_a_version_made_again_with_another_recipe_is_its_revision():
     again = api.add_version(g, "podio", use=["aton", "heriverse"], packaging="file_set",
                             files=_gltf_set(), revise=True)
     assert again["version_id"] == out["version_id"] and len(g.nodes) == n
+
+
+# ── MICRO-VERSIONI-PER-USO (E.D., 2 Nov 2026): a version for a use is the
+#    asset AND the use, never a level ──
+
+def _glb(c):
+    return [{"path": f"versions/x{c}.glb", "checksum": "sha256:" + c * 64,
+             "media_type": "model/gltf-binary"}]
+
+
+def test_a_mobile_version_beside_a_web_one_is_another_version_not_a_revision():
+    """Templu Mare, 1 Nov: Column_entrance1's lod1-mobile became a REVISION of
+    its lod1 for the web («manca la base mobile»). By use, it is a version."""
+    g = _podio()
+    web = api.add_version(g, "podio", level="lod1", purpose="aton-heriverse", use=["heriverse"],
+                          files=_glb("a"))
+    mob = api.add_version(g, "podio", profile="mobile_webxr", use_params={"triangles": 10_000},
+                          use=["mobile_ar"], purpose="mobile", files=_glb("b"))
+    assert mob["level"] == "mobile-webxr-10k" and mob["revises"] is None and mob["created"]
+    assert mob["version_id"] != web["version_id"] and mob["profile"] == "mobile_webxr"
+    proc = g.find_node_by_id(mob["process_id"])
+    assert proc.data["parameters"]["profile"] == "mobile_webxr"
+    assert proc.data["parameters"]["use_params"] == {"triangles": 10_000}
+    # Heriverse reads `use`, as before
+    assert g.find_node_by_id(mob["version_id"]).data["use"] == ["mobile_ar"]
+    rows = {r["id"]: r for r in api.versions_of(g, "podio")}
+    assert rows[mob["version_id"]]["by_use"] and rows[mob["version_id"]]["use_params"] == {"triangles": 10_000}
+    # the one of before (lod1 for aton-heriverse) is said by its use too
+    assert rows[web["version_id"]]["profile"] == "webxr" and rows[web["version_id"]]["by_use"]
+
+
+def test_several_of_one_use_the_latest_wins_the_others_stay_listed():
+    from s3dgraphy.resources.versions import use_versions
+    g = _podio()
+    ten = api.add_version(g, "podio", profile="mobile_webxr", use_params={"triangles": 10_000},
+                          files=_glb("c"), at="2026-11-01T10:00:00Z")
+    two = api.add_version(g, "podio", profile="mobile_webxr", use_params={"triangles": 2_000},
+                          files=_glb("d"), at="2026-11-02T07:00:00Z")
+    assert ten["version_id"] != two["version_id"]
+    by = use_versions(api.versions_of(g, "podio"))
+    assert by["mobile_webxr"]["latest"]["id"] == two["version_id"]
+    assert [e["id"] for e in by["mobile_webxr"]["others"]] == [ten["version_id"]]
+    # «Aggiorna»: the same asset and use is the same version made again
+    from s3dgraphy.resources.graph_compose import level_key, level_say
+    rows = {r["id"]: r for r in api.versions_of(g, "podio")}
+    assert level_key(rows[ten["version_id"]]) == level_key(rows[two["version_id"]]) == ("use", "mobile_webxr")
+    assert level_say(rows[two["version_id"]]) == "mobile webXR · 2k tri"
+    assert level_say(rows[two["version_id"]], 1980, 512) == "mobile webXR · 2k tri · 512 px"
+
+
+def test_the_same_use_and_numbers_with_other_bytes_is_revised():
+    g = _podio()
+    one = api.add_version(g, "podio", profile="mobile_webxr", use_params={"triangles": 2_000}, files=_glb("e"))
+    with pytest.raises(ValueError, match="replace its file"):
+        api.add_version(g, "podio", profile="mobile_webxr", use_params={"triangles": 2_000}, files=_glb("f"))
+    again = api.add_version(g, "podio", profile="mobile_webxr", use_params={"triangles": 2_000},
+                            files=_glb("f"), revise=True)
+    assert again["revises"] == one["version_id"]
+    # «Nuova accanto»: a second one with the same numbers, named -2
+    beside = api.add_version(g, "podio", profile="mobile_webxr", level="mobile-webxr-2k-2", files=_glb("9"))
+    assert beside["revises"] is None and beside["level"] == "mobile-webxr-2k-2"
+
+
+def test_a_lod_chain_is_said_as_a_chain_and_a_bad_profile_refused():
+    from s3dgraphy.resources.graph_compose import level_say
+    g = _podio()
+    _three(g)   # LOD1 for «web», LOD2 for «preview»: hand-made, no profile
+    rows = [r for r in api.versions_of(g, "podio") if not r["master"]]
+    assert rows[0]["profile"] == "" and not rows[0]["by_use"]
+    chain = api.add_version(g, "podio", level="lod3", files=_glb("7"))
+    r = next(x for x in api.versions_of(g, "podio") if x["id"] == chain["version_id"])
+    assert level_say(r) == "catena LOD 3"
+    with pytest.raises(ValueError, match="not a profile"):
+        api.add_version(g, "podio", profile="hologram", files=_glb("8"))

{s3dgraphy-1.6.0.dev89 → s3dgraphy-1.6.0.dev90}/tests/test_consolida_2.py

@@ -220,7 +220,8 @@ def test_the_mobile_base_is_another_level_not_an_update():
                     at="2026-10-30T10:00:00Z")
     tags = G.graph_tags(g, "rm_podio", {**api.versions_of(g, "podio")[1], "asset_id": "podio"})
     st = G.update_status(g, tags)
-    assert st["state"] == "aligned" and st["others"][0]["level_say"] == "lod1 · mobile webXR"
+    # MICRO-VERSIONI-PER-USO: a version for a use is said by its use, not by a level
+    assert st["state"] == "aligned" and st["others"][0]["level_say"] == "mobile webXR"
     assert G.level_key({"level": "manual-2026-10-31-2", "use": ["realtime"]}) == ("manual", "desktop_realtime")
 
 

{s3dgraphy-1.6.0.dev89 → s3dgraphy-1.6.0.dev90}/tests/test_use_profiles.py

@@ -347,7 +347,9 @@ def test_names_of_the_versions():
     assert UP.version_file_name("Col", "lod0", "print_3d") == "Col@lod0-print.stl"
     p = UP.parse_version_name("Column_light1@lod1-realtime-web.glb")
     assert p == {"model": "Column_light1", "level": "lod1", "destination": "realtime-web",
-                 "profile": "desktop_realtime", "ext": "glb"}
+                 "profile": "desktop_realtime", "ext": "glb",
+                 # MICRO-VERSIONI-PER-USO: a name of before is said by its use
+                 "use": "desktop-realtime", "triangles": None, "n": 1, "by_use": False}
     assert UP.parse_version_name("PODIO@lod0-heriverse-1a2b3c4d")["destination"] == "heriverse"
     assert UP.parse_version_name("PODIO@lod0-aton-heriverse.glb")["profile"] == "webxr"
     assert UP.parse_version_name("PODIO@lod1-web.glb")["profile"] == "webxr"
@@ -451,3 +453,54 @@ def test_measure_gltf_gives_each_node_its_box(tmp_path):
     assert boxes[0] == [[0, 0, 0], [1, 0, 1]] and boxes[1][0][0] == 10
     d = UP.diagnose(m["objects"], m["textures"], "webxr")
     assert d["totals"]["extent_m"] == 11.0
+
+
+# ── MICRO-VERSIONI-PER-USO (E.D., 2 Nov 2026): versions named by their use ──
+
+def test_a_version_for_a_use_is_named_by_its_use():
+    assert UP.use_version_name("Column_light1", "mobile_webxr", 2000) == "Column_light1@mobile-webxr-2k.glb"
+    assert UP.use_version_name("Column_light1", "webxr", 53_412) == "Column_light1@webxr-53k.gltf"
+    assert UP.use_version_name("C", "mobile_webxr", 1500) == "C@mobile-webxr-1.5k.glb"
+    assert UP.use_version_name("C", "desktop_realtime") == "C@desktop-realtime.glb"
+    assert UP.use_version_name("C", "mobile", 2000, n=2) == "C@mobile-webxr-2k-2.glb"
+    # version_file_name: an empty level or a use's name → the use's form
+    assert UP.version_file_name("C", None, "mobile_webxr", triangles=10_000) == "C@mobile-webxr-10k.glb"
+    assert UP.version_file_name("C", "mobile-webxr-10k", "mobile_webxr") == "C@mobile-webxr-10k.glb"
+    # a rung of a LOD chain keeps its form
+    assert UP.version_file_name("C", "lod3", "webxr") == "C@lod3-aton-heriverse.gltf"
+
+
+def test_names_by_use_are_read_back():
+    p = UP.parse_version_name("Column_light1@mobile-webxr-2k.glb")
+    assert p == {"model": "Column_light1", "level": "mobile-webxr-2k", "destination": "mobile",
+                 "profile": "mobile_webxr", "ext": "glb", "use": "mobile-webxr",
+                 "triangles": 2000, "n": 1, "by_use": True}
+    assert UP.parse_version_name("C@mobile-webxr-2k-2.glb")["n"] == 2
+    g = UP.parse_version_name("C@webxr-53k-0a1b2c3d")
+    assert (g["level"], g["profile"], g["ext"]) == ("webxr-53k", "webxr", "")
+    assert UP.parse_version_name("C@print-3d.stl")["profile"] == "print_3d"
+    # the names of before: said by their use, not by their level
+    old = UP.parse_version_name("Column_entrance1@lod1-mobile.glb")
+    assert (old["use"], old["profile"], old["by_use"], old["level"]) == ("mobile-webxr", "mobile_webxr", False, "lod1")
+    assert UP.parse_use_tag("lod1") is None and UP.parse_use_tag("mobile-webxr-2k")["triangles"] == 2000
+
+
+def test_what_a_row_says():
+    assert UP.use_say("mobile_webxr", 10_000, 512) == "mobile webXR · 10k tri · 512 px"
+    assert UP.use_say("webxr", 53_000) == "webXR / Heriverse · 53k tri"
+    assert UP.chain_say("lod4") == "catena LOD 4"
+    assert UP.kilo(None) == "" and UP.kilo(999) == "1k" and UP.kilo(2400) == "2.4k" and UP.kilo(694_000) == "694k"
+
+
+def test_versions_listed_by_use(tmp_path):
+    for n in ("A@mobile-webxr-2k.glb", "A@lod1-aton-heriverse.glb"):
+        (tmp_path / n).write_bytes(b"x")
+    rows = {r["name"]: r for r in UP.list_versions(str(tmp_path), measure=False)}
+    assert rows["A@mobile-webxr-2k.glb"]["by_use"] and rows["A@mobile-webxr-2k.glb"]["profile"] == "mobile_webxr"
+    assert rows["A@lod1-aton-heriverse.glb"]["use"] == "webxr"
+
+
+def test_a_gltfpack_variant_for_a_use_is_named_by_it():
+    from s3dgraphy.project_tree import variant_name
+    assert variant_name("SM_X.glb", "mobile-webxr-2k", "mobile") == "SM_X@mobile-webxr-2k.glb"
+    assert variant_name("SM_X.glb", "lod4", "web") == "SM_X@lod4-web.glb"   # a LOD chain's rung, as before