mostlyright-data 0.29.5__tar.gz → 0.29.7__tar.gz

{mostlyright_data-0.29.5 → mostlyright_data-0.29.7}/PKG-INFO

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

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

{mostlyright_data-0.29.5 → mostlyright_data-0.29.7}/skills/mr-data-build/references/5-draft-one-recipe-document-one-call.md

@@ -455,11 +455,12 @@ from the accepted subset — `Cel`, `ug/m3`, `km/h`, `hPa`, `{count}` and the re
 out in [Units](https://mostlyright.md/docs/reference/units/). Write the code rather than a name:
 `ug/m3` composes and `microgram_per_cubic_meter` does not.
 
-**Nothing resolves the code, so there is no `UNIT_*` refusal to lean on.** The recipe schema bounds
-the length of `unit` and nothing else; registration checks only that `units[].column` names a
-declared column and answers `422 RECIPE_DOCUMENT_INCOHERENT` at `/units/N/column` when it does not;
-the run never reads `units` at all. A code outside the subset therefore costs nothing at build time
-and costs every reader afterwards, and a column declared in metres that holds feet is caught by
+**Registration resolves the code and reads no data.** The recipe schema bounds the length of
+`unit`; registration then checks that `units[].column` names a declared column, answering
+`422 RECIPE_DOCUMENT_INCOHERENT` at `/units/N/column` when it does not, and resolves each
+`units[].unit` against the subset, answering the same code at `/units/N/unit` when it cannot.
+`mr-data recipe` does not resolve the code locally, so that refusal arrives from registration. The
+run does not read `units`, so a column declared in metres that holds feet is caught by
 nothing. Convert in the statement, then declare the unit of what the column ends up holding. Leave a
 column out of `units` rather than declare something approximate — a density, a rate, anything whose
 unit is genuinely new. `none` is not a unit and does not become one. Remember that the two

{mostlyright_data-0.29.5 → mostlyright_data-0.29.7}/skills/mr-data-build/references/making-a-table-incremental.md

@@ -105,8 +105,9 @@ Studio records the answer as one classification per source:
 | a `window` carrying a `request` | `window` | `acquire_incremental` |
 | none of those | `resync_only` | `resync_required` |
 
-The rows are in Studio's precedence order, and the first match wins. A source that states both
-`closed: true` and a request window is `closed`, and its window is never read. One `resync_only`
+The rows are in Studio's precedence order, and the first match wins. A source may not state both
+`closed: true` and a request window: registration refuses that pair with
+`422 RECIPE_DOCUMENT_INCOHERENT` at `/sources/N/closed`. One `resync_only`
 source makes the whole table resync-only, however truthful its siblings are. Say which sources you
 left `resync_only` and why, because a recipe that never asked the question registers the same way
 as one that did.
@@ -318,10 +319,12 @@ call:
 
 - `parameter` is declared with `required: true`. `{id}` is the whole of one `static_query` value
   and appears nowhere else.
-- `key_column` is a column the pinned Reader declares. The worker splits the answer back to
-  members by that column.
-- `batch` refuses a POST, a `body_template`, a `platform` credential and
-  `pages.max_unavailable_members` above 0. The preflight names each before anything is sent.
+- `key_column` is a column the pinned Reader decodes to: one of its `columns[]`, or the
+  `record_key_column` of a `json.tabular` 1.3.0 pin reading `records_from: object_values`. The
+  worker splits the answer back to members by that column.
+- `batch` refuses a POST, a `body_template` and a `platform` credential. The preflight names
+  each before anything is sent. `pages.max_unavailable_members` above 0 is for Studio to answer
+  at registration, which admits it when its engine counts a batch's unavailable members.
 - Member ids and saved answers do not change, so turning `batch` on keeps every paid answer.
 - `absent: "failed"` fails a member the answer does not name, so the next run asks again. The
   default, `empty`, records it with no rows.

{mostlyright_data-0.29.5 → mostlyright_data-0.29.7}/skills/mr-data-build/references/sources.md

@@ -239,7 +239,7 @@ at 0 there is no second attempt, so the first answer too large fails the run. Ra
 
 If the API takes a list of ids in one query parameter, add `request.batch` and send up to 100
 members in one call. It keeps every member id and saved answer. It refuses a POST, a
-`body_template`, a `platform` credential and a failure budget above 0.
+`body_template` and a `platform` credential.
 [`batch`](making-a-table-incremental.md#batch-many-rows-in-one-request) has the grammar.
 
 A collection whose calls are paid for is sized from evidence, not from its ceiling. Run

{mostlyright_data-0.29.5 → mostlyright_data-0.29.7}/src/mostlyright/data_harness/thin/fast_features.py

@@ -178,15 +178,8 @@ def _batch(sources: list[Mapping[str, Any]]) -> dict[str, Any]:
         if isinstance(request.get("batch"), Mapping):
             used.append(name)
             continue
-        pages = _mapping(collection.get("pages"))
-        tolerated = pages.get("max_unavailable_members")
         platform = _mapping(source.get("connector")).get("credential_mode") == "platform"
-        if (
-            request.get("method") == "POST"
-            or "body_template" in request
-            or platform
-            or (type(tolerated) is int and tolerated > 0)
-        ):
+        if request.get("method") == "POST" or "body_template" in request or platform:
             refused.append(name)
         else:
             open_to.append(name)
@@ -205,8 +198,8 @@ def _batch(sources: list[Mapping[str, Any]]) -> dict[str, Any]:
         return _entry(
             BATCH,
             NOT_APPLICABLE,
-            f"{', '.join(refused)} is a POST, a body_template, a platform credential or a "
-            "failure budget above 0, and batch refuses each",
+            f"{', '.join(refused)} is a POST, a body_template or a platform credential, and "
+            "batch refuses each",
             sources=refused,
         )
     return _entry(BATCH, NOT_APPLICABLE, "no source sends one request per upstream row")

{mostlyright_data-0.29.5 → mostlyright_data-0.29.7}/src/mostlyright/data_harness/thin/recipe_lint.py

@@ -944,7 +944,12 @@ def _request_placeholder_sites(request: Mapping[str, Any], at: str) -> list[tupl
 
 
 def _reader_columns(connector: Any) -> set[str] | None:
-    """The column names the connector's pinned Reader declares, or ``None`` when unreadable."""
+    """The column names the connector's pinned Reader decodes to, or ``None`` when unreadable.
+
+    Options that state ``records_from: object_values`` with a ``record_key_column`` decode that
+    key column too (``json.tabular`` 1.3.0), as Studio's ``reader_pin_columns`` reads them. Which
+    Reader versions may state those options is left to Studio.
+    """
 
     parameters = connector.get("parameters") if isinstance(connector, Mapping) else None
     for parameter in parameters if isinstance(parameters, list) else ():
@@ -956,11 +961,15 @@ def _reader_columns(connector: Any) -> set[str] | None:
             columns = options.get("columns") if isinstance(options, Mapping) else None
             if not isinstance(columns, list):
                 return None
-            return {
+            names = {
                 entry["name"]
                 for entry in columns
                 if isinstance(entry, Mapping) and isinstance(entry.get("name"), str)
             }
+            key = options.get("record_key_column")
+            if options.get("records_from") == "object_values" and isinstance(key, str):
+                names.add(key)
+            return names
     return None
 
 
@@ -970,8 +979,11 @@ def _row_request_batch_coherence(sources: Any) -> list[Finding]:
     Studio's ``_row_request_batch_details``, restated. The batched parameter is declared with
     ``required: true``, and ``{parameter}`` is the whole of one ``static_query`` value and appears
     nowhere else. The request is a GET with no ``body_template``. The source uses no ``platform``
-    credential, and ``pages.max_unavailable_members`` is 0 or absent. ``key_column`` is a column
-    the pinned Reader declares.
+    credential. ``key_column`` is a column the pinned Reader decodes to.
+
+    ``pages.max_unavailable_members`` above 0 is NOT judged here. Studio admits it beside
+    ``batch`` when its pinned engine counts a batch's unavailable members, and this client cannot
+    see which engine is pinned, so registration answers that one.
     """
 
     if not isinstance(sources, list):
@@ -1005,17 +1017,6 @@ def _row_request_batch_coherence(sources: Any) -> list[Finding]:
                     "request cannot use",
                 )
             )
-        pages = source["collection"].get("pages")
-        tolerated = pages.get("max_unavailable_members") if isinstance(pages, Mapping) else None
-        if type(tolerated) is int and tolerated > 0:
-            findings.append(
-                Finding(
-                    DOCUMENT_INCOHERENT,
-                    f"{base}/pages/max_unavailable_members",
-                    f"is {tolerated}, and a batched request records no unavailable members, so "
-                    "this must be 0",
-                )
-            )
         name = batch.get("parameter")
         if isinstance(name, str):
             parameters = request.get("parameters")