mammoth-cli 2.0.82__tar.gz → 2.0.83__tar.gz

{mammoth_cli-2.0.82 → mammoth_cli-2.0.83}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mammoth-cli
-Version: 2.0.82
+Version: 2.0.83
 Summary: Command-line interface for the Mammoth Analytics platform
 Project-URL: homepage, https://mammoth.io
 Project-URL: repository, https://github.com/EdgeMetric/mammothsdk
@@ -17,7 +17,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: <3.15,>=3.12
 Requires-Dist: jsonschema>=4.20
 Requires-Dist: keyring<26,>=25.7
-Requires-Dist: mammoth-io<0.8,>=0.7.36
+Requires-Dist: mammoth-io<0.8,>=0.7.37
 Requires-Dist: platformdirs<5,>=4.10
 Requires-Dist: pydantic<3,>=2.12.5
 Requires-Dist: pyyaml<7,>=6

{mammoth_cli-2.0.82 → mammoth_cli-2.0.83}/mammoth_cli/__init__.py

@@ -6,7 +6,7 @@ not implement a second HTTP client and does not call private SDK members.
 
 from __future__ import annotations
 
-__version__ = "2.0.82"
+__version__ = "2.0.83"
 
 # The versioned machine output envelope contract.
 SCHEMA_VERSION = 1

{mammoth_cli-2.0.82 → mammoth_cli-2.0.83}/mammoth_cli/app.py

@@ -42,6 +42,8 @@ from mammoth_cli.output.policy import (
     resolve_output,
 )
 from mammoth_cli.runtime import executor, validate
+from mammoth_cli.runtime.dataset_health import with_dataset_health
+from mammoth_cli.runtime.new_data import with_new_data_path
 from mammoth_cli.runtime.invocation import Invocation
 from mammoth_cli.runtime.state import with_state
 from mammoth_cli.runtime.strict import validate_extra_args
@@ -826,7 +828,7 @@ def _execute(invocation: Invocation) -> None:
         if invocation.dry_run:
             return _dry_run(handler, invocation)
         data, meta = handler(invocation)
-        return _apply_verify(invocation, data), meta
+        return with_new_data_path(with_dataset_health(_apply_verify(invocation, data))), meta
 
     executor.run(
         invocation.command_id,

{mammoth_cli-2.0.82 → mammoth_cli-2.0.83}/mammoth_cli/bundled_skill/mammoth-cli/references/command-index.md

@@ -1,6 +1,6 @@
 # Published CLI command catalog
 
-This generated catalog is a lookup table for every command in the published CLI manifest, currently 573; each entry carries its release status line. It is a command-contract index, not an assertion that every backend/OpenAPI operation has a CLI binding. For an exact local CLI contract, run `mammoth schema get COMMAND_ID`; `mammoth capability list` is an API-binding inventory and can omit typed/local CLI routes. For focused workflows, read the [recipes index](recipes/index.md). Sensitive structured input must come from a private file or pipe; never put secrets in literal argv.
+This generated catalog is a lookup table for every command in the published CLI manifest, currently 574; each entry carries its release status line. It is a command-contract index, not an assertion that every backend/OpenAPI operation has a CLI binding. For an exact local CLI contract, run `mammoth schema get COMMAND_ID`; `mammoth capability list` is an API-binding inventory and can omit typed/local CLI routes. For focused workflows, read the [recipes index](recipes/index.md). Sensitive structured input must come from a private file or pipe; never put secrets in literal argv.
 
 Load only the applicable domain file:
 
@@ -24,7 +24,7 @@ Load only the applicable domain file:
 - [dashboard-qa](commands/dashboard-qa.md) — 13 published commands
 - [dashboard](commands/dashboard.md) — 100 published commands
 - [data-app](commands/data-app.md) — 12 published commands
-- [dataset](commands/dataset.md) — 17 published commands
+- [dataset](commands/dataset.md) — 18 published commands
 - [doctor](commands/doctor.md) — 1 published commands
 - [external-key](commands/external-key.md) — 4 published commands
 - [file](commands/file.md) — 9 published commands

{mammoth_cli-2.0.82 → mammoth_cli-2.0.83}/mammoth_cli/bundled_skill/mammoth-cli/references/commands/dataset.md

@@ -12,6 +12,16 @@ Result: `DatasetBatchDataResult`; mutation `read`, confirmation `none`, wait pol
 
 Status on release: ran once on CLI 1.1.11 — Published PyPI CLI 1.1.11 / SDK 0.7.1 batch-data read succeeded for an ID observed from retained dataset 29; bounded 50-row page. One observed-ID chain and page; not Full.
 
+### `dataset.broken-rows.list`
+
+Run: `mammoth dataset broken-rows list`. Exact input fields: `mammoth schema get dataset.broken-rows.list`.
+
+Example: `mammoth dataset broken-rows list 123`. Placeholders are illustrative; resolve IDs and input from observed reads.
+
+Result: `DatasetBrokenRowsListResult`; mutation `read`, confirmation `none`, wait policy `not_async`.
+
+Status on release: untried; no live run recorded.
+
 ### `dataset.bulk-delete`
 
 Run: `mammoth dataset bulk-delete`. Exact input fields: `mammoth schema get dataset.bulk-delete`.

{mammoth_cli-2.0.82 → mammoth_cli-2.0.83}/mammoth_cli/commands/dataset.py

@@ -28,6 +28,7 @@ from mammoth_cli.runtime.confirm import (
     enforce_confirmation,
 )
 from mammoth_cli.runtime.invocation import Invocation
+from mammoth_cli.runtime.new_data import with_file_upload_path
 from mammoth_cli.runtime.session import open_service, require_project
 
 HandlerResult = tuple[Any, dict[str, Any]]
@@ -322,6 +323,17 @@ def dataset_batch_data(invocation: Invocation) -> HandlerResult:
 
 def dataset_file_settings(invocation: Invocation) -> HandlerResult:
     """Get file settings (delimiter, header, dates, ...) for a dataset."""
+    data, meta = _read_dataset(invocation)
+    return with_file_upload_path(data, _require_int_positional(invocation, "dataset id")), meta
+
+
+def dataset_broken_rows(invocation: Invocation) -> HandlerResult:
+    """List the lines of a dataset's uploaded file that could not be parsed."""
+    return _read_dataset(invocation)
+
+
+def _read_dataset(invocation: Invocation) -> HandlerResult:
+    """Call this command's SDK read with the DATASET_ID positional."""
     project_id = require_project(invocation)
     dataset_id = _require_int_positional(invocation, "dataset id")
     if dataset_id <= 0:

{mammoth_cli-2.0.82 → mammoth_cli-2.0.83}/mammoth_cli/commands/registry.py

@@ -314,6 +314,7 @@ HANDLERS: dict[str, Handler] = {
     "dataset.file-settings.get": dataset_cmd.dataset_file_settings,
     "dataset.file-settings.update": dataset_cmd.dataset_file_settings_update,
     "dataset.file-settings.undo": dataset_cmd.dataset_file_settings_undo,
+    "dataset.broken-rows.list": dataset_cmd.dataset_broken_rows,
     "dataset.create": dataset_cmd.dataset_create,
     "dataset.create-from-pdf": dataset_cmd.dataset_create_from_pdf,
     "dataset.rename": dataset_cmd.dataset_rename,

{mammoth_cli-2.0.82 → mammoth_cli-2.0.83}/mammoth_cli/commands/schema.py

@@ -1402,7 +1402,9 @@ def _schema_common(record: dict[str, Any]) -> dict[str, Any]:
     contract_level = (
         "opaque_expert"
         if record["command_id"] in _OPAQUE_EXPERT_COMMANDS
-        else "partially_typed" if opaque_fields else "typed"
+        else "partially_typed"
+        if opaque_fields
+        else "typed"
     )
     return {
         "positionals": _positionals(record["command_id"]),
@@ -1558,6 +1560,13 @@ def _inline_call_detail(entries: list[dict[str, Any]]) -> None:
             entry["agent_example"] = record["agent_example"]
 
 
+#: How to drill down from a find: a family's full command list, or every family.
+_BROWSE_NEXT = (
+    "mammoth schema list FAMILY lists every command in a family; mammoth schema list "
+    "lists the families"
+)
+
+
 def find_schemas(
     query: str,
     *,
@@ -1747,9 +1756,17 @@ def find_schemas(
             if result["suggestions"]
             else _NO_MATCH_HINT_NO_SUGGESTIONS
         )
+    result["browse"] = _browse(page or result.get("suggestions", []))
     return result
 
 
+def _browse(entries: list[dict[str, Any]]) -> dict[str, Any]:
+    """The families behind *entries* and how to list each one in full: a keyword
+    find surfaces one way to do a thing, its family holds the siblings."""
+    families = list(dict.fromkeys(entry["command_path"].split()[0] for entry in entries))
+    return {"families": families, "next": _BROWSE_NEXT}
+
+
 def get_schema(command_id: str) -> dict[str, Any] | None:
     record = command_by_id(command_id)
     if record is None or record.get("disposition") == "alias":

{mammoth_cli-2.0.82 → mammoth_cli-2.0.83}/mammoth_cli/commands/view.py

@@ -2073,13 +2073,16 @@ def view_pipeline_rerun(invocation: Invocation) -> HandlerResult:
     kwargs: dict[str, Any] = {"dataview_id": dataview_id}
     _forward_optional(document, kwargs, ("from_sequence", "dataset_id"))
     with open_service(invocation) as (service, auth):
-        data = service.call(_symbol(invocation), **kwargs)
         dataset_id = kwargs.get("dataset_id")
         if dataset_id is None:
             dataset_id = _resolve_dataset_id_for_settle(
                 service, invocation, dataview_id, document, 1
             )
-        data = _settle_async_view_write(service, dataset_id, dataview_id, invocation.project, data)
+        before = _rows_before(service, dataset_id, dataview_id, invocation.project)
+        data = service.call(_symbol(invocation), **kwargs)
+        data = _settle_async_view_write(
+            service, dataset_id, dataview_id, invocation.project, data, before
+        )
     return data, _meta(invocation, auth.workspace_id, None)
 
 
@@ -2133,13 +2136,16 @@ def view_task_delete(invocation: Invocation) -> HandlerResult:
     kwargs: dict[str, Any] = {"dataview_id": dataview_id, "task_id": task_id}
     _forward_optional(document, kwargs, ("dataset_id",))
     with open_service(invocation) as (service, auth):
-        data = service.call(_symbol(invocation), **kwargs)
         dataset_id = kwargs.get("dataset_id")
         if dataset_id is None:
             dataset_id = _resolve_dataset_id_for_settle(
                 service, invocation, dataview_id, document, 2
             )
-        data = _settle_async_view_write(service, dataset_id, dataview_id, invocation.project, data)
+        before = _rows_before(service, dataset_id, dataview_id, invocation.project)
+        data = service.call(_symbol(invocation), **kwargs)
+        data = _settle_async_view_write(
+            service, dataset_id, dataview_id, invocation.project, data, before
+        )
     return data, _meta(invocation, auth.workspace_id, None)
 
 
@@ -2193,13 +2199,16 @@ def view_task_update(invocation: Invocation) -> HandlerResult:
     assert document is not None
     _forward_optional(document, kwargs, ("dataset_id",))
     with open_service(invocation) as (service, auth):
-        data = service.call(_symbol(invocation), **kwargs)
         dataset_id = kwargs.get("dataset_id")
         if dataset_id is None:
             dataset_id = _resolve_dataset_id_for_settle(
                 service, invocation, dataview_id, document, 2
             )
-        data = _settle_async_view_write(service, dataset_id, dataview_id, invocation.project, data)
+        before = _rows_before(service, dataset_id, dataview_id, invocation.project)
+        data = service.call(_symbol(invocation), **kwargs)
+        data = _settle_async_view_write(
+            service, dataset_id, dataview_id, invocation.project, data, before
+        )
     return data, _meta(invocation, auth.workspace_id, None)
 
 
@@ -2509,6 +2518,33 @@ _SPECIAL_EXPORT_COMMON_FIELDS = frozenset(
 )
 
 
+def _reject_export_into_draft(service: Any, dataview_id: int, dataset_id: int) -> None:
+    """Refuse a dataset export on a view whose changes are held in a draft.
+
+    With auto-run off the view keeps new pipeline changes in a draft, so the
+    export would only be staged and write nothing; the SDK then waits out its
+    whole timeout for a write that cannot happen (eval T1-O-11).
+    """
+    pipeline = service.call(_PIPELINE_GET_SYMBOL, dataview_id=dataview_id, dataset_id=dataset_id)
+    draft_mode = pipeline.get("draft_mode") if isinstance(pipeline, dict) else None
+    if draft_mode in (None, "off"):
+        return
+    raise CliError(
+        code="view_in_draft",
+        message=(
+            f"View {dataview_id} holds its changes in a draft (auto-run is off), so an "
+            "export added now would be staged and write nothing."
+        ),
+        exit_status=EXIT_USAGE,
+        hint=(
+            f"Turn auto-run on with mammoth view draft auto-run {dataview_id} --input "
+            "'{\"enabled\": true}', add the export, then turn auto-run off again if the "
+            f"dataset should only update when asked (mammoth view pipeline rerun {dataview_id})."
+        ),
+        details={"dataview_id": dataview_id, "draft_mode": draft_mode},
+    )
+
+
 def view_export_specialized(invocation: Invocation) -> HandlerResult:
     """Run one of the SDK's typed ``View.export`` destination helpers."""
     route = _SPECIAL_EXPORTS.get(invocation.command_id)
@@ -2596,6 +2632,8 @@ def view_export_specialized(invocation: Invocation) -> HandlerResult:
                 ),
                 details={"dataset_id": dataset_id, "target_ds_id": int(target_ds_id)},
             )
+        if is_dataset_route:
+            _reject_export_into_draft(service, dataview_id, dataset_id)
         target_view_before = None
         target_only_columns: list[str] = []
         if target_ds_id is not None:
@@ -2999,8 +3037,30 @@ def _row_count_now(service: Any, dataset_id: int, view_id: int, project_id: int
     return info.get("row_count") if isinstance(info, dict) else None
 
 
+def _rows_before(
+    service: Any, dataset_id: Any, view_id: int, project_id: int | None
+) -> dict[str, Any] | None:
+    """The view's row count read BEFORE an async write is sent.
+
+    Read after the call, a small view may already have recomputed, so the
+    "before" would be the new count and a real change would look like none.
+    None when the parent dataset is unknown (the settle step is skipped then).
+    """
+    if dataset_id is None:
+        return None
+    try:
+        return {"rows_before": _row_count_now(service, int(dataset_id), view_id, project_id)}
+    except CliError as exc:
+        return {"rows_before": None, "rows_before_error": f"{type(exc).__name__}: {exc}"}
+
+
 def _settle_async_view_write(
-    service: Any, dataset_id: Any, view_id: int, project_id: int | None, data: Any
+    service: Any,
+    dataset_id: Any,
+    view_id: int,
+    project_id: int | None,
+    data: Any,
+    before: dict[str, Any] | None,
 ) -> Any:
     """Turn an async view write's immediate response into a final one.
 
@@ -3017,12 +3077,7 @@ def _settle_async_view_write(
     if dataset_id is None or not isinstance(data, dict):
         return data
     dataset_id = int(dataset_id)
-    try:
-        row_check: dict[str, Any] = {
-            "rows_before": _row_count_now(service, dataset_id, view_id, project_id)
-        }
-    except CliError as exc:
-        row_check = {"rows_before": None, "rows_before_error": f"{type(exc).__name__}: {exc}"}
+    row_check: dict[str, Any] = dict(before or {"rows_before": None})
     rows_after, pipeline_error = wait_for_view_row_count(service, dataset_id, view_id, project_id)
     row_check["rows_after"] = rows_after
     data = {**data, "row_check": row_check}

{mammoth_cli-2.0.82 → mammoth_cli-2.0.83}/mammoth_cli/commands/view_ops.py

@@ -674,6 +674,23 @@ def _require_clone_from_same_dataset(service: Any, clone_from: int, dataset_id:
         )
 
 
+_DASHBOARDS_LIST_SYMBOL = "mammoth.api.dashboards.DashboardsAPI.list"
+
+
+def _with_dashboards(service: Any, view_id: int, record: Any) -> Any:
+    """Add the dashboards built on this view, so a user on the view's page who
+    says "this board" is understood (eval T1-D-22); unchanged when none."""
+    if not isinstance(record, dict):
+        return record
+    boards = service.call(_DASHBOARDS_LIST_SYMBOL)
+    built_on = [
+        {"id": board.get("id"), "title": board.get("title")}
+        for board in (boards if isinstance(boards, list) else [])
+        if isinstance(board, dict) and view_id in (board.get("sources") or [])
+    ]
+    return {**record, "dashboards": built_on} if built_on else record
+
+
 def view_get(invocation: Invocation) -> HandlerResult:
     """Get one view by id, optionally scoped to an exact dataset parent."""
     view_id = _view_id(invocation)
@@ -699,7 +716,8 @@ def view_get(invocation: Invocation) -> HandlerResult:
         with open_service(invocation) as (service, auth):
             data = service.call("mammoth.api.dataviews.DataviewsAPI.get", **kwargs)
             parents.remember(_profile_name(invocation), auth.workspace_id, {view_id: dataset_id})
-        data = apply_column_renames(data) if document.get("fields") else brief_view_record(data)
+            data = apply_column_renames(data) if document.get("fields") else brief_view_record(data)
+            data = _with_dashboards(service, view_id, data)
         return data, _meta(invocation, auth.workspace_id)
     context: dict[str, Any] = {"view_id": view_id}
     if dataset_id is not None:
@@ -718,12 +736,13 @@ def view_get(invocation: Invocation) -> HandlerResult:
         data = service.call(_symbol(invocation), **kwargs)
         payload = _view_payload(data)
         parents.remember_records(_profile_name(invocation), auth.workspace_id, payload)
-    if not document.get("fields"):
-        # The discovery path returns the standard record; trim it to the same
-        # brief shape the exact path asks the server for.
-        payload = brief_view_record(payload)
-    else:
-        payload = apply_column_renames(payload)
+        if not document.get("fields"):
+            # The discovery path returns the standard record; trim it to the same
+            # brief shape the exact path asks the server for.
+            payload = brief_view_record(payload)
+        else:
+            payload = apply_column_renames(payload)
+        payload = _with_dashboards(service, view_id, payload)
     return payload, _meta(invocation, auth.workspace_id)
 
 

mammoth_cli-2.0.83/mammoth_cli/runtime/dataset_health.py

@@ -0,0 +1,62 @@
+"""Dataset health, stated wherever a dataset appears in a result.
+
+A dataset's ``status`` can say it did not load cleanly, but a bare status word
+reads as fine to an agent that is looking for rows. :func:`with_dataset_health`
+turns each such status into a ``dataset_health`` entry that says what it means
+and which command fixes it. It runs on every result, read or write, and never
+makes a request.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import Any
+
+#: Status to (what it means, which command to run first) -- ``{id}`` is filled in.
+_UNHEALTHY: dict[str, tuple[str, str]] = {
+    "has_unstructured_data": (
+        "Some rows of this file could not be split into columns, so they are held "
+        "apart and the dataset may have few or no usable rows. The usual cause is "
+        "the wrong delimiter or quote character.",
+        "mammoth dataset broken-rows list {id} shows the rows and why each does "
+        "not fit; then mammoth dataset file-settings get {id} and mammoth dataset "
+        "file-settings update {id} with the right delimiter or quote character",
+    ),
+}
+#: Nesting to search: a result, a listing inside it, a record in the listing.
+_MAX_DEPTH = 3
+
+
+def with_dataset_health(data: Any) -> Any:
+    """Return ``data`` with a ``dataset_health`` list when any dataset in it is
+    unhealthy; anything else is returned unchanged."""
+    if not isinstance(data, dict):
+        return data
+    health = [_entry(record) for record in _unhealthy(data, 0)]
+    if not health:
+        return data
+    return {**data, "dataset_health": health}
+
+
+def _unhealthy(value: Any, depth: int) -> Iterator[dict[str, Any]]:
+    if depth > _MAX_DEPTH:
+        return
+    if isinstance(value, dict):
+        if value.get("status") in _UNHEALTHY and isinstance(value.get("id"), int):
+            yield value
+        for child in value.values():
+            yield from _unhealthy(child, depth + 1)
+    elif isinstance(value, list):
+        for child in value:
+            yield from _unhealthy(child, depth + 1)
+
+
+def _entry(record: dict[str, Any]) -> dict[str, Any]:
+    detail, fix = _UNHEALTHY[record["status"]]
+    return {
+        "dataset_id": record["id"],
+        "name": record.get("name"),
+        "status": record["status"],
+        "detail": detail,
+        "fix": fix.format(id=record["id"]),
+    }

mammoth_cli-2.0.83/mammoth_cli/runtime/new_data.py

@@ -0,0 +1,86 @@
+"""How new data reaches a dataset, stated wherever such a dataset appears.
+
+A dataset made from an uploaded file reads as a one-time snapshot, so an agent
+asked for a recurring report concludes nothing new will ever arrive; the next
+file appends to it as a new batch and its views re-run. A dataset written by a
+view's export reads as a standalone copy, so an agent cannot tell what writes it
+or what deleting it takes with it. :func:`with_new_data_path`
+states either path; it never makes a request.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import Any
+
+_FROM_FILE = (
+    "Made from an uploaded file; the next period's file joins this dataset as a "
+    "new batch with mammoth file upload FILE --input '{{\"append_to_ds_id\": {id}}}'. "
+    "Its views re-run on the added rows, so a scheduled automation on a view "
+    "sends the updated data without anyone rebuilding the pipeline."
+)
+_FROM_EXPORT = (
+    "Written by export {export_id} in view {view_id}'s pipeline, which fills it "
+    "again on every run of that view. Deleting this dataset also removes that "
+    "export; to keep the dataset but stop the updates, run mammoth view export "
+    "delete {view_id} {export_id}."
+)
+#: Nesting to search: a result, a listing inside it, a record in the listing.
+_MAX_DEPTH = 3
+
+
+def with_new_data_path(data: Any) -> Any:
+    """Return ``data`` with a ``new_data`` list when any dataset in it was made
+    from an uploaded file or is written by a view's export; anything else is
+    returned unchanged."""
+    if not isinstance(data, dict):
+        return data
+    paths = [
+        {"dataset_id": record["id"], "name": record.get("name"), "how": how}
+        for record, how in _fed_datasets(data, 0)
+    ]
+    if not paths:
+        return data
+    return {**data, "new_data": paths}
+
+
+def with_file_upload_path(data: Any, dataset_id: int) -> Any:
+    """Return file settings with a ``new_data`` entry: settings with a delimiter
+    exist only for a parsed upload, which the next period's file can join."""
+    info = data.get("info") if isinstance(data, dict) else None
+    if not isinstance(info, dict) or not info.get("delimiter"):
+        return data
+    how = _FROM_FILE.format(id=dataset_id)
+    return {**data, "new_data": [{"dataset_id": dataset_id, "name": None, "how": how}]}
+
+
+def _fed_datasets(value: Any, depth: int) -> Iterator[tuple[dict[str, Any], str]]:
+    if depth > _MAX_DEPTH:
+        return
+    if isinstance(value, dict):
+        how = _how(value)
+        if how is not None:
+            yield value, how
+        for child in value.values():
+            yield from _fed_datasets(child, depth + 1)
+    elif isinstance(value, list):
+        for child in value:
+            yield from _fed_datasets(child, depth + 1)
+
+
+def _how(record: dict[str, Any]) -> str | None:
+    if not isinstance(record.get("id"), int):
+        return None
+    info = record.get("additional_info")
+    if (
+        isinstance(info, dict)
+        and isinstance(info.get("DATAVIEW_ID"), int)
+        and isinstance(info.get("TRIGGER_ID"), int)
+    ):
+        return _FROM_EXPORT.format(view_id=info["DATAVIEW_ID"], export_id=info["TRIGGER_ID"])
+    sources = record.get("sources")
+    if isinstance(sources, list) and any(
+        isinstance(s, dict) and s.get("type") == "file" for s in sources
+    ):
+        return _FROM_FILE.format(id=record["id"])
+    return None

{mammoth_cli-2.0.82 → mammoth_cli-2.0.83}/mammoth_cli/runtime/verify.py

@@ -22,6 +22,11 @@ JOIN_MATCH_RATE_THRESHOLD = 0.8
 #: view write can carry that runs a pipeline -- the only kind that can leave a
 #: downstream export referencing something the write just changed or removed.
 _VIEW_PIPELINE_MUTATION_CLASS = "reversible_pipeline"
+#: Pipeline writes outside that class that can still drop or rename a column
+#: a saved export reads: deleting a step, renaming, editing the pipeline.
+_EXPORT_BREAKING_COMMANDS = frozenset(
+    {"view.task.delete", "view.transform.rename-columns", "view.pipeline.edit"}
+)
 
 _VIEW_EXPORT_LIST_COMMAND = "view.export.list"
 
@@ -336,11 +341,14 @@ def _apply_downstream_export_check(verify: dict[str, Any], invocation: Invocatio
 
 
 def _pipeline_view_id(invocation: Invocation) -> int | None:
-    """The view id a ``reversible_pipeline`` write acted on, or None otherwise."""
+    """The view id a write that can break an export acted on, or None otherwise."""
     from mammoth_cli.manifest.loader import command_by_id
 
     record = command_by_id(invocation.command_id) or {}
-    if record.get("mutation_class") != _VIEW_PIPELINE_MUTATION_CLASS:
+    if (
+        record.get("mutation_class") != _VIEW_PIPELINE_MUTATION_CLASS
+        and invocation.command_id not in _EXPORT_BREAKING_COMMANDS
+    ):
         return None
     for name in ("view_id", "dataview_id"):
         value = invocation.positional(name)

{mammoth_cli-2.0.82 → mammoth_cli-2.0.83}/mammoth_cli/services/conditions.py

@@ -101,6 +101,11 @@ def compile_condition(spec: Any) -> _ConditionResult:
     if not isinstance(spec, dict):
         raise _invalid("A condition must be a mapping.")
 
+    compound = [key for key in ("and", "or", "not") if key in spec]
+    if compound and len(spec) != 1:
+        raise _invalid(
+            f"'{compound[0]}' must be the condition's only key; nest the others inside it."
+        )
     if "and" in spec or "or" in spec:
         key = "and" if "and" in spec else "or"
         branches = spec[key]

{mammoth_cli-2.0.82 → mammoth_cli-2.0.83}/mammoth_cli/services/data_quality.py

@@ -23,6 +23,8 @@ _MIN_VALUES = 3
 _MAX_EXAMPLES = 3
 #: Most groups of variant spellings to name in one warning.
 _MAX_VARIANT_GROUPS = 5
+#: Above this many distinct labels a column is not a set of names to compare pairwise.
+_MAX_LABELS_COMPARED = 200
 
 _NUMBER = re.compile(r"^[-+]?[$€£]?\s*\d[\d,]*(\.\d+)?\s*%?$|^[-+]?[$€£]?\s*\.\d+\s*%?$")
 #: Punctuation is normalised to a space, not dropped, so "Pepsi,Cola" and
@@ -144,6 +146,74 @@ def _variant_spellings_warning(
     }
 
 
+def _parse_date(value: Any) -> datetime | None:
+    text = str(value).strip()[:19]
+    for fmt in _DATE_FORMATS:
+        try:
+            return datetime.strptime(text, fmt)
+        except ValueError:
+            continue
+    return None
+
+
+def _date_spans(
+    rows: list[Mapping[str, Any]], column: str, date_column: str
+) -> dict[str, tuple[datetime, datetime]]:
+    """Each label's first and last date, over rows where both parse."""
+    spans: dict[str, tuple[datetime, datetime]] = {}
+    for row in rows:
+        label, day = row.get(column), _parse_date(row.get(date_column))
+        if _blank(label) or day is None:
+            continue
+        first, last = spans.get(str(label), (day, day))
+        spans[str(label)] = (min(first, day), max(last, day))
+    return spans
+
+
+def _renamed_label_warning(
+    rows: list[Mapping[str, Any]],
+    column: str,
+    date_column: str,
+    view_id: int | None,
+) -> dict[str, Any] | None:
+    """A label that stops before a longer label starting with its words begins
+    reads as one thing renamed ("Riverside" -> "Riverside Mall"): left apart, its
+    figures split and a period comparison shows a false drop and a false newcomer.
+    """
+    spans = _date_spans(rows, column, date_column)
+    if len(spans) > _MAX_LABELS_COMPARED:
+        return None
+    words = {label: _spelling_key(label).split() for label in spans}
+    pairs = [
+        (old, new)
+        for old in spans
+        for new in spans
+        if 0 < len(words[old]) < len(words[new])
+        and words[new][: len(words[old])] == words[old]
+        and spans[old][1] < spans[new][0]
+    ]
+    if not pairs:
+        return None
+    shown = pairs[:_MAX_VARIANT_GROUPS]
+    examples = "; ".join(
+        f"{old!r} last on {spans[old][1]:%Y-%m-%d}, {new!r} first on {spans[new][0]:%Y-%m-%d}"
+        for old, new in shown
+    )
+    mapping = [{"search": [old], "replace": new} for old, new in shown]
+    return {
+        "column": column,
+        "issue": "renamed_label",
+        "detail": (
+            f"These labels never share a date and the later one starts with the earlier "
+            f"one's words, so each reads as one {column} renamed: {examples}. Left apart, "
+            "its figures split across two names and a period comparison shows a drop "
+            "and a new entry that are the same thing; confirm, then unify them."
+        ),
+        "fix": _bulk_replace_hint(view_id, column, mapping),
+        "rows_checked": len(rows),
+    }
+
+
 def _duplicate_rows_warning(
     rows: list[Mapping[str, Any]],
     view_id: int | None,
@@ -246,7 +316,7 @@ def column_warnings(
     Returns:
         One record per finding: ``column``, ``issue``
         (``numbers_stored_as_text``, ``dates_stored_as_text``,
-        ``variant_spellings``, ``blank_values`` or the table-level
+        ``variant_spellings``, ``renamed_label``, ``blank_values`` or the table-level
         ``duplicate_rows``), ``detail`` and, where one command fixes it,
         ``fix``. Counts are over the rows given (``rows_checked`` on each
         record).
@@ -306,6 +376,17 @@ def column_warnings(
             variant_warning = _variant_spellings_warning(column, texts, view_id, checked)
             if variant_warning is not None:
                 warnings.append(variant_warning)
+            date_column = next(
+                (name for name, kind in column_types.items() if str(kind).upper() == "DATE"),
+                None,
+            )
+            renamed = (
+                _renamed_label_warning(materialised, column, date_column, view_id)
+                if date_column is not None
+                else None
+            )
+            if renamed is not None:
+                warnings.append(renamed)
         if blanks:
             remove_fix = None
             if figures == [column] and view_id is not None and dataset_id is not None: