mostlyright-data 0.22.0__tar.gz → 0.22.1__tar.gz

{mostlyright_data-0.22.0 → mostlyright_data-0.22.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mostlyright-data
-Version: 0.22.0
+Version: 0.22.1
 Summary: Mostly Right hosted CLI for reviewed datasets
 Project-URL: Homepage, https://mostlyright.md/
 Project-URL: Documentation, https://mostlyright.md/docs/guides/cli/

{mostlyright_data-0.22.0 → mostlyright_data-0.22.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mostlyright-data"
-version = "0.22.0"
+version = "0.22.1"
 description = "Mostly Right hosted CLI for reviewed datasets"
 readme = "README.md"
 requires-python = ">=3.11"

{mostlyright_data-0.22.0 → mostlyright_data-0.22.1}/src/mostlyright/data_harness/thin/v4_artifacts.py

@@ -277,9 +277,10 @@ class StudioV4ArtifactClient(StudioV4RunClient):
         ⚠ THE ONE ROUTE THAT REACHES A PART ANOTHER RUN SEALED. A version is a manifest over
         parts and the parts may come from many runs, so ``GET /v4/runs/{run_id}/artifacts``
         answers about one run's contribution and never about the whole table. This route is
-        addressed by the version the run's OWN manifest names -- the coordinate is sealed inside
-        the artifact this command already fetched -- so nothing here resolves a live pointer or
-        asks whether the version is one anybody published.
+        addressed by the physical table and version identifiers on that public run. A sealed
+        manifest selects and verifies the parts, but legacy manifests can contain logical
+        identifiers that cannot address this route; nothing here resolves a live pointer or asks
+        whether the version is one anybody published.
         """
 
         body: dict[str, Any] = {"limit": PART_SESSION_PAGE_LIMIT}
@@ -548,19 +549,17 @@ def download(
     """``mr-data download RUN``: this run's artifacts, on this computer, each digest checked.
 
     ⚠ NOTHING ON THIS COMMAND'S OWN PATH ASKS WHETHER THE RUN MAY BE READ. The listing is fetched,
-    a session is minted per artifact and the bytes are verified; the run record is never read on
-    the way to the answer, so there is no place a status, a version or an approval could be
-    consulted even by accident. That is REQ-H407's sentence made structural rather than promised.
-
-    ⚠ AND THE SCOPE OF THAT SENTENCE IS THIS PATH, WHICH SAYING SO NARROWS RATHER THAN WEAKENS.
-    After the answer is printed, ``thin.router`` makes one best-effort progress report, and for
-    this command -- which holds a run identifier and nothing else -- that report reads
-    ``GET /v4/runs/{run_id}`` to learn which dataset page to write on. It happens AFTER the
-    download has been decided, executed and rendered, on its own bounded budget, and it cannot
-    reach anything this command did or printed: nothing on the way to the artifacts consults the
-    run record, which is the property REQ-H407 is about. A docstring claiming the record is never
-    read at all would be false the first time somebody grepped for the route, and a false absolute
-    is worse than a scoped true one.
+    a session is minted per artifact and the bytes are verified. A multipart version with retained
+    parts additionally reads the run's public table and version identifiers solely to address the
+    version-part session route; it never reads the status, approval, or promotion to decide whether
+    bytes may be read. That is REQ-H407's sentence made structural rather than promised.
+
+    ⚠ THE RUN RECORD'S NARROW ROLE IS TO ADDRESS, NEVER TO ADMIT. A manifest is a sealed logical
+    document and historical producers can put logical table identifiers in it. Studio's public
+    version-part route is addressed by the physical identifiers on the run record instead. Those
+    values are used only after the manifest identified retained parts that need signed sessions;
+    every fetched byte is still checked against the manifest's part digest. A status, approval, or
+    promotion value is neither read nor used as a predicate.
 
     ⚠ A TABLE VERSION ARRIVES WHOLE OR NOT AT ALL. The run listing answers about the parts THIS
     run sealed, and a version composed over several refreshes names parts earlier runs sealed; a
@@ -629,7 +628,7 @@ def _version_parts(
     sealed = {str(row.get("digest")): row for row in listing if row.get("kind") == "table_part"}
     repeated = Counter(part.part_key for part in manifest.parts)
     outstanding = tuple(part for part in manifest.parts if part.part_id not in sealed)
-    minted = _part_sessions(client, manifest, outstanding)
+    minted = _part_sessions(client, run_id, manifest, outstanding)
     written: list[dict[str, Any]] = []
     for part in manifest.parts:
         destination = output / _part_destination(part, repeated=repeated[part.part_key] > 1)
@@ -660,19 +659,20 @@ def _part_destination(part: Any, *, repeated: bool) -> Path:
 
 
 def _part_sessions(
-    client: StudioV4ArtifactClient, manifest: Any, outstanding: Sequence[Any]
+    client: StudioV4ArtifactClient, run_id: str, manifest: Any, outstanding: Sequence[Any]
 ) -> dict[str, dict[str, Any]]:
     """One signed read per part this run did not seal, or a refusal naming how many are missing."""
 
     if not outstanding:
         return {}
+    public_run = StudioV4RunClient(client.session, transport=client.transport).run(run_id)
+    table_id = _run_identifier(public_run, "table_id")
+    version_id = _run_identifier(public_run, "table_version_id")
     wanted = {part.part_id for part in outstanding}
     minted: dict[str, dict[str, Any]] = {}
     cursor: str | None = None
     for _page in range(MAX_PART_SESSION_PAGES):
-        page = client.version_part_sessions(
-            manifest.table_id, manifest.table_version_id, cursor=cursor
-        )
+        page = client.version_part_sessions(table_id, version_id, cursor=cursor)
         entries = page.get("parts")
         if not isinstance(entries, list):
             raise ThinLaneError(
@@ -701,6 +701,18 @@ def _part_sessions(
     return minted
 
 
+def _run_identifier(run: Mapping[str, Any], field: str) -> str:
+    """One public physical version coordinate, never a lifecycle predicate."""
+
+    value = run.get(field)
+    if not isinstance(value, str) or not value:
+        raise ThinLaneError(
+            "THIN_RESPONSE_INVALID",
+            f"the run's public {field} is absent while retained table parts need signed reads",
+        )
+    return identifier(value, f"run {field}")
+
+
 def _fetch_version_part(
     client: StudioV4ArtifactClient,
     part: Any,