mostlyright-data 0.25.8__tar.gz → 0.25.9__tar.gz

{mostlyright_data-0.25.8 → mostlyright_data-0.25.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mostlyright-data
-Version: 0.25.8
+Version: 0.25.9
 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.25.8 → mostlyright_data-0.25.9}/pyproject.toml

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

{mostlyright_data-0.25.8 → mostlyright_data-0.25.9}/src/mostlyright/data_harness/canonical.py

@@ -34,7 +34,9 @@ def parse_json(value: str | bytes | bytearray | memoryview) -> Any:
     return _parse(value, fractions="reject")
 
 
-def parse_foreign_json(value: str | bytes | bytearray | memoryview) -> Any:
+def parse_foreign_json(
+    value: str | bytes | bytearray | memoryview, *, max_members: int = MAX_CANONICAL_MEMBERS
+) -> Any:
     """Parse a third-party document with the same hardening, but accept fractional numbers.
 
     The Harness data model is integer-only, and :func:`parse_json` enforces that because every
@@ -54,12 +56,20 @@ def parse_foreign_json(value: str | bytes | bytearray | memoryview) -> Any:
     a parser but can never be sealed, digested or written into a canonical document. That is the
     boundary this pair of functions draws: read what the world publishes, write only what the model
     admits.
+
+    ``max_members`` raises the member ceiling for one document whose size a route already bounds,
+    such as a table manifest listing thousands of parts.
     """
 
-    return _parse(value, fractions="accept")
+    return _parse(value, fractions="accept", max_members=max_members)
 
 
-def _parse(value: str | bytes | bytearray | memoryview, *, fractions: str) -> Any:
+def _parse(
+    value: str | bytes | bytearray | memoryview,
+    *,
+    fractions: str,
+    max_members: int = MAX_CANONICAL_MEMBERS,
+) -> Any:
     if isinstance(value, str):
         text = value
     elif isinstance(value, (bytes, bytearray, memoryview)):
@@ -106,6 +116,7 @@ def _parse(value: str | bytes | bytearray | memoryview, *, fractions: str) -> An
         depth=0,
         members=[0],
         accept_fractions=accept_fractions,
+        max_members=max_members,
     )
 
 
@@ -171,6 +182,7 @@ def _normalize_json(
     depth: int,
     members: list[int],
     accept_fractions: bool = False,
+    max_members: int = MAX_CANONICAL_MEMBERS,
 ) -> Any:
     if depth > MAX_CANONICAL_DEPTH:
         raise CanonicalJSONError(
@@ -179,11 +191,11 @@ def _normalize_json(
             f"nesting exceeds {MAX_CANONICAL_DEPTH} levels",
         )
     members[0] += 1
-    if members[0] > MAX_CANONICAL_MEMBERS:
+    if members[0] > max_members:
         raise CanonicalJSONError(
             "JSON_MEMBERS",
             path,
-            f"value exceeds {MAX_CANONICAL_MEMBERS} members",
+            f"value exceeds {max_members} members",
         )
 
     if value is None or type(value) is bool:
@@ -236,6 +248,7 @@ def _normalize_json(
                 depth=depth + 1,
                 members=members,
                 accept_fractions=accept_fractions,
+                max_members=max_members,
             )
         return result
     if isinstance(value, (list, tuple)):
@@ -246,6 +259,7 @@ def _normalize_json(
                 depth=depth + 1,
                 members=members,
                 accept_fractions=accept_fractions,
+                max_members=max_members,
             )
             for index, item in enumerate(value)
         ]

{mostlyright_data-0.25.8 → mostlyright_data-0.25.9}/src/mostlyright/data_harness/thin/runs.py

@@ -28,6 +28,7 @@ from urllib.parse import urlencode
 from uuid import UUID
 
 from mostlyright.data_harness.canonical import (
+    MAX_CANONICAL_MEMBERS,
     CanonicalJSONError,
     canonical_json_bytes,
     parse_foreign_json,
@@ -235,6 +236,8 @@ class StudioApiClient:
         expected: tuple[int, ...],
         shape: type = dict,
         response_headers: dict[str, str] | None = None,
+        maximum: int = MAX_JSON_RESPONSE_BYTES,
+        max_members: int = MAX_CANONICAL_MEMBERS,
     ) -> Any:
         headers = {
             "Accept": "application/json",
@@ -250,7 +253,7 @@ class StudioApiClient:
         url = f"{self._session.studio_base_url}{path}{_query_string(query)}"
         try:
             status, raw, answered_headers = self._transport.request(
-                method, url, headers, raw_body, MAX_JSON_RESPONSE_BYTES
+                method, url, headers, raw_body, maximum
             )
             if response_headers is not None:
                 response_headers.update(answered_headers)
@@ -270,7 +273,7 @@ class StudioApiClient:
             # "Studio did not answer with an object". Nothing read here can be sealed either way:
             # `canonical_json_bytes` still refuses a float, so a value parsed here can be shown
             # and can never reach a digest.
-            parsed = parse_foreign_json(raw)
+            parsed = parse_foreign_json(raw, max_members=max_members)
         except CanonicalJSONError:
             parsed = None
         if status not in expected:

{mostlyright_data-0.25.8 → mostlyright_data-0.25.9}/src/mostlyright/data_harness/thin/v4_artifacts.py

@@ -155,10 +155,10 @@ CHECK_SCOPE_VERSION = "version"
 #: arrives before a byte is fetched.
 MAX_READ_ARTIFACT_BYTES = 8 * 1024 * 1024
 
-#: Studio caps an artifact page at two hundred and pages with ``X-Next-Cursor``. A run produces at
-#: most a handful of artifacts, so a second page is already a surprise; the ceiling is here so a
-#: server answering with an endless cursor is a refusal rather than an endless loop.
-MAX_ARTIFACT_PAGES = 8
+#: Studio caps an artifact page at two hundred and pages with ``X-Next-Cursor``. A version may name
+#: 4,096 parts beside its manifest, receipt and profile, which is twenty-one pages; the ceiling
+#: leaves room above that so an endless cursor is a refusal rather than an endless loop.
+MAX_ARTIFACT_PAGES = 32
 
 #: How many signed part reads one page of the version route is asked for. The command's own
 #: maximum, so the fewest pages are spent on the widest version.
@@ -394,9 +394,16 @@ def _listing(client: StudioV4ArtifactClient, run_id: str) -> list[dict[str, Any]
     for _page in range(MAX_ARTIFACT_PAGES):
         headers: dict[str, str] = {}
         rows.extend(client.artifacts(run_id, cursor=cursor, response_headers=headers))
-        cursor = headers.get("X-Next-Cursor") or headers.get("x-next-cursor")
-        if not cursor:
+        following = headers.get("X-Next-Cursor") or headers.get("x-next-cursor")
+        if not following:
             return rows
+        # The cursor is the last artifact id of the page and the listing is ordered by it.
+        if cursor is not None and following <= cursor:
+            raise ThinLaneError(
+                "THIN_RESPONSE_INVALID",
+                "this run's artifact listing answered with a cursor that did not advance",
+            )
+        cursor = following
     raise ThinLaneError(
         "THIN_RESPONSE_INVALID",
         f"this run's artifact listing did not end within {MAX_ARTIFACT_PAGES} pages",

{mostlyright_data-0.25.8 → mostlyright_data-0.25.9}/src/mostlyright/data_harness/thin/v4_query.py

@@ -52,7 +52,7 @@ from mostlyright.data_harness.thin.session import (
     open_studio_session,
     team_dashboard_url,
 )
-from mostlyright.data_harness.thin.transport import ThinLaneError
+from mostlyright.data_harness.thin.transport import ThinLaneError, UrlLibTransport
 from mostlyright.data_harness.thin.v4 import (
     GET_RECIPE_PATH,
     GET_RUN_PATH,
@@ -103,6 +103,12 @@ QUERY_POLL_MAX_SECONDS = 2.0
 #: has been minted -- the reason every early refusal in this repository exists.
 MAX_STATEMENT_BYTES = 64 * 1024
 
+#: The per-request clock for this command. Studio signs a read for every selected part before the
+#: submit answers, which has taken over a minute on a wide version. A submit that outlives the
+#: shared thirty-second clock still lands, queued behind a session this command has already
+#: closed, and times out there; every identical submit after it replays that failure.
+QUERY_REQUEST_TIMEOUT_SECONDS = 150.0
+
 #: The header Studio stamps on a repeated submit. Without reading it, two identical invocations
 #: are indistinguishable from two executions, and an agent would believe it had spent twice.
 IDEMPOTENT_REPLAY_HEADER = "Idempotent-Replay"
@@ -371,7 +377,9 @@ def _session(args: argparse.Namespace) -> StudioSession:
 
 
 def _client(args: argparse.Namespace) -> StudioV4QueryClient:
-    return StudioV4QueryClient(_session(args))
+    return StudioV4QueryClient(
+        _session(args), transport=UrlLibTransport(timeout=QUERY_REQUEST_TIMEOUT_SECONDS)
+    )
 
 
 # --------------------------------------------------------------------------------------------
@@ -725,7 +733,12 @@ def _settled(
     }
     state = record.get("state")
     if state == "failed":
-        raise _settled_refusal(record, query_id)
+        refusal = _settled_refusal(record, query_id)
+        if replayed:
+            code = refusal.studio_code  # type: ignore[attr-defined]
+            refusal = ThinLaneError(refusal.code, f"{refusal.detail}. {_replayed_failure(record)}")
+            refusal.studio_code = code  # type: ignore[attr-defined]
+        raise refusal
     if state != "succeeded":
         return {
             **head,
@@ -761,6 +774,18 @@ def _settled(
     return payload
 
 
+def _replayed_failure(record: Mapping[str, Any]) -> str:
+    """Why an identical question keeps failing, and how to get it executed again."""
+
+    settled = record.get("settled_at")
+    when = f" at {settled}" if isinstance(settled, str) and settled else ""
+    return (
+        f"This is the answer Studio recorded{when} for an earlier identical query, replayed "
+        "rather than executed again. Studio answers this statement, row limit and range with "
+        "that record every time, so change one of them to have it run again"
+    )
+
+
 class _WarmSession:
     """The research session this command opened so a worker would exist to ask, and its close.
 

{mostlyright_data-0.25.8 → mostlyright_data-0.25.9}/src/mostlyright/data_harness/thin/v4_tables.py

@@ -182,6 +182,12 @@ PARTS_SCHEMA = f"{THIN_SCHEMA_PREFIX}-v4-table-parts.v1"
 #: re-spelled, so a listing is never shorter than a version the format admits.
 MAX_LISTED_PARTS = MAX_PARTS_PER_VERSION
 
+#: The manifest route answers with the whole part list, so its ceilings are sized for the widest
+#: version the format admits rather than for an ordinary control-plane answer. A part with bounds
+#: on sixteen fields is about two kilobytes and a hundred and thirty members.
+MAX_MANIFEST_RESPONSE_BYTES = 32 * 1024 * 1024
+MAX_MANIFEST_RESPONSE_MEMBERS = MAX_LISTED_PARTS * 160
+
 #: The two acts ``mr-data table`` carries beside the state read, as words a person types in front
 #: of the table identifier: ``mr-data table rename TABLE --name NAME``.
 #:
@@ -502,6 +508,8 @@ class StudioV4TableClient(StudioV4Client):
             "GET",
             TABLE_VERSION_MANIFEST_PATH.format(table_id=table_id, table_version_id=version),
             expected=(200,),
+            maximum=MAX_MANIFEST_RESPONSE_BYTES,
+            max_members=MAX_MANIFEST_RESPONSE_MEMBERS,
         )
 
     def reschedule_table(self, table_id: str, body: Mapping[str, Any]) -> dict[str, Any]: