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

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

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

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

{mostlyright_data-0.25.7 → 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.7 → mostlyright_data-0.25.9}/src/mostlyright/data_harness/thin/propose.py

@@ -2275,7 +2275,7 @@ def _dataset_conflict_remedy(refusal: ThinLaneError) -> str | None:
     return (
         "a Dataset of this name already exists in the workspace; if an earlier run of this bundle "
         'registered it, adopt it by id in dataset.json ({"dataset_id": "..."}) -- '
-        "mr-data list names the workspace's datasets -- or choose another name"
+        "mr-data dataset list names the workspace's datasets -- or choose another name"
     )
 
 

{mostlyright_data-0.25.7 → mostlyright_data-0.25.9}/src/mostlyright/data_harness/thin/recipe.py

@@ -51,17 +51,23 @@ from mostlyright.data_harness.thin.recipe_lint import lint_document, lint_refusa
 from mostlyright.data_harness.thin.session import StudioSession, open_studio_session
 from mostlyright.data_harness.thin.transport import ThinLaneError
 from mostlyright.data_harness.thin.v4 import identifier
-from mostlyright.data_harness.thin.v4_datasets import StudioV4DatasetClient, append_cell_body
+from mostlyright.data_harness.thin.v4_datasets import (
+    StudioV4DatasetClient,
+    append_cell_body,
+)
 from mostlyright.data_harness.thin.v4_narrative import v4_cell_receipt
+from mostlyright.data_harness.thin.v4_runs import StudioV4RunClient
+from mostlyright.data_harness.thin.v4_runs import start as start_run
 from mostlyright.data_harness.ux.credentials import resolve_cloud_credentials
 from mostlyright.data_harness.ux.plain_file import PlainFileRefusal, read_plain_file
 
 #: The one-line help both front doors print for this command.
-COMMAND_HELP = "register one recipe document and print the identifiers the server derived"
+COMMAND_HELP = "register one recipe document, or propose a revision that also starts one replay"
 
 REGISTER_SCHEMA = f"{THIN_SCHEMA_PREFIX}-recipe.v1"
 SHOW_SCHEMA = f"{THIN_SCHEMA_PREFIX}-recipe-read.v1"
 READINESS_SCHEMA = f"{THIN_SCHEMA_PREFIX}-recipe-readiness.v1"
+PROPOSE_SCHEMA = f"{THIN_SCHEMA_PREFIX}-recipe-propose.v1"
 
 #: The bound on the document. The same number the authoring lane bounded one of its six documents
 #: by -- four times the contract's own 262144-byte ceiling on a canonical recipe -- rather than a
@@ -126,6 +132,7 @@ UNREFRESHABLE_PLAN_TAIL = (
 #: `mr-data recipe show ID` is how a person says it out loud.
 SHOW = "show"
 READINESS = "readiness"
+PROPOSE = "propose"
 # Studio evaluates the exact persisted admission proof for each recipe revision. Keep this
 # inventory page small enough that a normal production workspace completes each bounded request
 # inside the thin client's request deadline, while preserving the established 40,000-item
@@ -148,15 +155,17 @@ def declare_arguments(parser: argparse.ArgumentParser) -> None:
         metavar="FILE",
         help=(
             "the recipe document to register, as a path to a JSON file; the word `show`, "
-            "followed by a recipe identifier, to read one back; or `readiness` to inventory "
-            "whether current tables may schedule a bounded incremental refresh"
+            "followed by a recipe identifier, to read one back; `readiness` to inventory "
+            "whether current tables may schedule a bounded incremental refresh; or `propose`, "
+            "followed by a recipe document path and `--sources-from RUN_ID`, to register a "
+            "revision and start exactly one retained-input replay (MCP `propose_revision`)"
         ),
     )
     parser.add_argument(
         "recipe_id",
         nargs="?",
         metavar="RECIPE_ID",
-        help="with `show`, the recipe to read back",
+        help="with `show`, the recipe to read back; with `propose`, the recipe document path",
     )
     parser.add_argument(
         "--no-lint",
@@ -171,6 +180,18 @@ def declare_arguments(parser: argparse.ArgumentParser) -> None:
         help="record that the user delegated the brief, in their own words, and register; this "
         "is how `you choose` or `just build it` is written onto the dataset as the answer it is",
     )
+    parser.add_argument(
+        "--sources-from",
+        dest="sources_from_run",
+        metavar="RUN_ID",
+        help="with `propose`, replay the retained raw inputs of this successful run; required, "
+        "and replay never becomes live",
+    )
+    parser.add_argument(
+        "--confirm",
+        action="store_true",
+        help="with `propose`, authorize the projected spend if the replay is held for one",
+    )
 
 
 #: The flags that describe a registration. ``show`` reads one back and neither can mean anything
@@ -181,6 +202,13 @@ _REGISTER_ONLY_FLAGS: tuple[tuple[str, str], ...] = (
     ("delegated", "--delegated"),
 )
 
+#: Flags that belong only to ``propose``. A plain registration (or show/readiness) that carries
+#: one is refused by name rather than silently dropped -- same construction as _REGISTER_ONLY_FLAGS.
+_PROPOSE_ONLY_FLAGS: tuple[tuple[str, str], ...] = (
+    ("sources_from_run", "--sources-from"),
+    ("confirm", "--confirm"),
+)
+
 
 def _session(args: argparse.Namespace) -> StudioSession:
     return open_studio_session(resolve_cloud_credentials())
@@ -1159,6 +1187,163 @@ def readiness(
     }
 
 
+def propose(
+    args: argparse.Namespace,
+    *,
+    client: StudioV4DatasetClient | None = None,
+    run_client: StudioV4RunClient | None = None,
+) -> dict[str, Any]:
+    """``mr-data recipe propose FILE --sources-from RUN``: register + start one replay.
+
+    Mirrors cloud MCP ``propose_revision``: the revision is durable even when the retained-input
+    replay is held for spend confirmation or refused. Validate ``--sources-from`` before
+    registration so a bad run id never leaves an orphan revision. A non-held replay refusal
+    returns ``revision_registered_replay_not_started`` with the immutable coordinates; a held
+    replay returns outer status ``held`` (exit 2) so a script does not treat spend-gate as success.
+    """
+
+    document_path = getattr(args, "recipe_id", None)
+    if not isinstance(document_path, str) or not document_path:
+        raise ThinLaneError(
+            "THIN_REQUEST_INVALID",
+            "mr-data recipe propose needs the recipe document path after the word propose",
+        )
+    sources_raw = getattr(args, "sources_from_run", None)
+    if not isinstance(sources_raw, str) or not sources_raw:
+        raise ThinLaneError(
+            "THIN_REQUEST_INVALID",
+            "mr-data recipe propose needs --sources-from RUN_ID naming the "
+            "retained inputs to replay",
+        )
+    # Validate before register — a bad identifier must not leave a durable revision behind.
+    sources_from = identifier(sources_raw, "source run identifier")
+
+    register_args = argparse.Namespace(**vars(args))
+    register_args.target = document_path
+    register_args.recipe_id = None
+    registration = register(register_args, client=client)
+
+    coordinates = {
+        "recipe_id": registration["recipe_id"],
+        "recipe_digest": registration["recipe_digest"],
+        "dataset_id": registration["dataset_id"],
+        "table_id": registration["table_id"],
+        "source_ids": registration["source_ids"],
+    }
+
+    run_args = argparse.Namespace(
+        recipe=registration["recipe_id"],
+        digest=registration["recipe_digest"],
+        mode="replay",
+        sources_from_run=sources_from,
+        max_rows=None,
+        max_source_bytes=None,
+        window=None,
+        resource_class=None,
+        progressive=False,
+        resume_capture_run_id=None,
+        confirm=bool(getattr(args, "confirm", False)),
+        confirm_held=None,
+        cancel=None,
+        retry=None,
+        approve_full=None,
+    )
+    try:
+        replay = start_run(run_args, client=run_client)
+    except ThinLaneError as refusal:
+        payload: dict[str, Any] = {
+            "schema_version": PROPOSE_SCHEMA,
+            "status": "revision_registered_replay_not_started",
+            "lane": "hosted",
+            **coordinates,
+            "sources_from_run": sources_from,
+            "refusal": {"code": refusal.code, "detail": refusal.detail},
+            "idempotent_by": registration.get("idempotent_by", "recipe_digest"),
+            "brief": registration["brief"],
+            "next": (
+                "The recipe revision was registered, but its retained-input replay did not "
+                "start. Keep these immutable coordinates and correct the replay precondition "
+                "before proposing again."
+            ),
+        }
+        _copy_registration_extras(registration, payload)
+        return payload
+
+    if replay.get("status") == "run_awaiting_confirmation":
+        held: dict[str, Any] = {
+            "schema_version": PROPOSE_SCHEMA,
+            "status": "held",
+            "lane": "hosted",
+            **coordinates,
+            "sources_from_run": sources_from,
+            "mode": "replay",
+            "idempotent_by": registration.get("idempotent_by", "recipe_digest"),
+            "brief": registration["brief"],
+            "replay": replay,
+            "next": (
+                "Show the projected cost to the user, then call "
+                f"`{replay.get('confirm_command', 'mr-data run --confirm …')}` only if they "
+                "agree. The replay produces repair evidence only; no full run is approved."
+            ),
+        }
+        for key in (
+            "run_id",
+            "projected_bytes",
+            "projected_runtime_s",
+            "projected_cost",
+            "confirm_command",
+            "build_scope",
+        ):
+            if key in replay:
+                held[key] = replay[key]
+        if "run_id" in held:
+            held["replay_run_id"] = held["run_id"]
+        _copy_registration_extras(registration, held)
+        return held
+
+    payload = {
+        "schema_version": PROPOSE_SCHEMA,
+        "status": "recipe_proposed",
+        "lane": "hosted",
+        **coordinates,
+        "sources_from_run": sources_from,
+        "replay": replay,
+        "idempotent_by": registration.get("idempotent_by", "recipe_digest"),
+        "brief": registration["brief"],
+    }
+    run_body = replay.get("run") if isinstance(replay.get("run"), Mapping) else None
+    if isinstance(run_body, Mapping) and isinstance(run_body.get("run_id"), str):
+        payload["replay_run_id"] = run_body["run_id"]
+    _copy_registration_extras(registration, payload)
+    return payload
+
+
+def _copy_registration_extras(
+    registration: Mapping[str, Any], payload: dict[str, Any]
+) -> None:
+    """Carry optional register fields onto a propose receipt without inventing them."""
+
+    for key in (
+        "warnings",
+        "columns_without_description",
+        "sources_without_continuation",
+        "delegation_cell",
+    ):
+        if key in registration:
+            payload[key] = registration[key]
+
+
+def propose_exit_code(payload: Mapping[str, Any]) -> int:
+    """Held or failed replay after a durable register is a gate, not a successful propose."""
+
+    status = payload.get("status")
+    if status in {"held", "revision_registered_replay_not_started"}:
+        return 2
+    return 0
+
+
+
+
 def recipe(
     args: argparse.Namespace, *, client: StudioV4DatasetClient | None = None
 ) -> dict[str, Any]:
@@ -1174,7 +1359,7 @@ def recipe(
     if args.target in {SHOW, READINESS}:
         given = [
             flag
-            for destination, flag in _REGISTER_ONLY_FLAGS
+            for destination, flag in (*_REGISTER_ONLY_FLAGS, *_PROPOSE_ONLY_FLAGS)
             if getattr(args, destination, None) not in (None, False)
         ]
         if given:
@@ -1191,12 +1376,25 @@ def recipe(
                 "mr-data recipe readiness takes no recipe identifier",
             )
         return readiness(args, client=client)
+    if args.target == PROPOSE:
+        return propose(args, client=client)
+    propose_only = [
+        flag
+        for destination, flag in _PROPOSE_ONLY_FLAGS
+        if getattr(args, destination, None) not in (None, False)
+    ]
+    if propose_only:
+        raise ThinLaneError(
+            "THIN_REQUEST_INVALID",
+            f"{', '.join(propose_only)} belong to mr-data recipe propose, not to a plain "
+            "registration; say `propose` before the document path, or drop the flag",
+        )
     if args.recipe_id:
         raise ThinLaneError(
             "THIN_REQUEST_INVALID",
             f"mr-data recipe takes one document to register, `show` and a recipe identifier, "
-            f"or `readiness`; "
-            f"{args.target!r} is neither",
+            f"`readiness`, or `propose` and a document path; "
+            f"{args.target!r} is none of those",
         )
     return register(args, client=client)
 
@@ -1210,6 +1408,8 @@ __all__ = [
     "NAMED_UNCONTINUED_SOURCES",
     "NAMED_UNDESCRIBED_COLUMNS",
     "NDJSON_SOURCE_BYTE_CEILING",
+    "PROPOSE",
+    "PROPOSE_SCHEMA",
     "READER_SOURCE_BYTE_CEILING",
     "READINESS",
     "READINESS_PAGE_SIZE",
@@ -1226,6 +1426,7 @@ __all__ = [
     "columns_without_description",
     "continuation_warnings",
     "declare_arguments",
+    "propose",
     "read_document",
     "readiness",
     "recipe",

{mostlyright_data-0.25.7 → mostlyright_data-0.25.9}/src/mostlyright/data_harness/thin/router.py

@@ -131,6 +131,12 @@ HOSTED_SUMMARY = dict(
         ("reader", "ask Studio to normalize reader options for a family and version"),
         ("source", "queue or read one bounded source inspection"),
         ("catalog", "ask the sealed public-source catalogue what might answer a question"),
+        (
+            "public",
+            "read the public dataset catalogue anonymously "
+            "(search, show, tables, schema, sample)",
+        ),
+        ("connected", "list or connect public datasets for this workspace (device key)"),
         ("stream", "record a public wss venue and name the recording a build reads"),
         ("keys", "store a source credential by name, name the stored ones, and withdraw one"),
         ("open", "hand this terminal's session to the browser as a single-use address"),
@@ -152,6 +158,7 @@ HOSTED_SUMMARY = dict(
         ("demote", "ask Studio to withdraw the live pointer from one table or many"),
         ("watch", "stream one run's live progress, resuming across stream cuts"),
         ("download", "bring one run's artifacts back here, each one's digest checked"),
+        ("artifacts", "list what one run sealed, without fetching bytes"),
         ("receipt", "print the record one run sealed about how it was built"),
         ("checks", "report how each check the recipe declared came out for one run"),
         ("note", "write one cell of this run's decision record, or list what is written"),
@@ -263,6 +270,7 @@ def _hosted_parser() -> argparse.ArgumentParser:
     from mostlyright.data_harness.thin import recipe as recipe_module
     from mostlyright.data_harness.thin import (
         v4_artifacts,
+        v4_connected,
         v4_connections,
         v4_dataset_covers,
         v4_datasets,
@@ -299,6 +307,13 @@ def _hosted_parser() -> argparse.ArgumentParser:
 
     v4_catalog.declare_arguments(_add("catalog"))
 
+    from mostlyright.data_harness.thin import v4_public
+
+    v4_public.declare_arguments(_add("public"))
+
+
+    v4_connected.declare_arguments(_add("connected"))
+
     # ------------------------------------------------------------------------------------
     # The source whose bytes do not exist until somebody records them
     # ------------------------------------------------------------------------------------
@@ -404,11 +419,13 @@ def _handlers() -> dict[str, Callable[[argparse.Namespace], dict[str, Any]]]:
         stream_venue,
         v4_artifacts,
         v4_catalog,
+        v4_connected,
         v4_connections,
         v4_dataset_covers,
         v4_datasets,
         v4_handoff,
         v4_narrative,
+        v4_public,
         v4_query,
         v4_reader,
         v4_runs,
@@ -442,6 +459,8 @@ def _handlers() -> dict[str, Callable[[argparse.Namespace], dict[str, Any]]]:
         # around the command rather than around its one verb, because the verb is a
         # positional and the module is where a second one would land.
         "catalog": v4_catalog.catalog,
+        "public": v4_public.public,
+        "connected": v4_connected.connected,
         # The venue lane. One name over eight verbs, because registering a document,
         # admitting it, probing it, capturing it, subscribing to it and reading back what
         # any of those produced are steps of one act -- and eight top-level names would be
@@ -453,6 +472,7 @@ def _handlers() -> dict[str, Callable[[argparse.Namespace], dict[str, Any]]]:
         "watch": v4_stream.watch,
         "status": v4_runs.status,
         "download": v4_artifacts.download,
+        "artifacts": v4_artifacts.artifacts,
         "verify": v4_artifacts.verify,
         "receipt": v4_artifacts.receipt,
         "checks": v4_artifacts.checks,
@@ -488,8 +508,10 @@ def _exit_codes() -> dict[str, Callable[[dict[str, Any]], int]]:
     """
 
     from mostlyright.data_harness.thin import probe as probe_module
+    from mostlyright.data_harness.thin import recipe as recipe_module
     from mostlyright.data_harness.thin import (
         v4_artifacts,
+        v4_connected,
         v4_datasets,
         v4_query,
         v4_runs,
@@ -508,6 +530,8 @@ def _exit_codes() -> dict[str, Callable[[dict[str, Any]], int]]:
         "table": v4_tables.lifecycle_exit_code,
         "demote": v4_tables.lifecycle_exit_code,
         "dataset": v4_datasets.dataset_exit_code,
+        "recipe": recipe_module.propose_exit_code,
+        "connected": v4_connected.connected_exit_code,
     }
 
 

{mostlyright_data-0.25.7 → 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.7 → mostlyright_data-0.25.9}/src/mostlyright/data_harness/thin/session.py

@@ -63,6 +63,10 @@ CLOUD_SESSION_HANDOFF_PATH = "/api/cli/session-handoffs"
 #: this client sends a mode and renders what came back rather than deciding any part of it.
 CLOUD_DATASET_ACCESS_PATH = "/api/cli/datasets/{dataset_id}/access"
 
+# Workspace dataset directory for agents (`mr-data dataset list`), same facts MCP's
+# `list_my_datasets` reads from Cloud's own table.
+CLOUD_DATASETS_LIST_PATH = "/api/cli/datasets"
+
 # Projection repair after a Studio metadata write, without a publication mutation.
 CLOUD_DATASET_IDENTITY_PATH = "/api/cli/datasets/{dataset_id}/identity"
 
@@ -530,6 +534,7 @@ class CloudClient:
 
 __all__ = [
     "CLOUD_APPROVAL_DASHBOARD_PATH",
+    "CLOUD_DATASETS_LIST_PATH",
     "CLOUD_DATASET_ACCESS_PATH",
     "CLOUD_DATASET_DASHBOARD_PATH",
     "CLOUD_DATASET_RUN_QUERY_KEY",