mammoth-cli 2.2.92__tar.gz → 2.2.93__tar.gz

{mammoth_cli-2.2.92 → mammoth_cli-2.2.93}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mammoth-cli
-Version: 2.2.92
+Version: 2.2.93
 Summary: Command-line interface for the Mammoth Analytics platform
 Project-URL: homepage, https://mammoth.io
 Project-URL: repository, https://github.com/EdgeMetric/mammothsdk
@@ -18,7 +18,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.9,>=0.8.45
+Requires-Dist: mammoth-io<0.9,>=0.8.46
 Requires-Dist: platformdirs<5,>=4.10
 Requires-Dist: pydantic<3,>=2.12.5
 Requires-Dist: pyyaml<7,>=6

{mammoth_cli-2.2.92 → mammoth_cli-2.2.93}/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.2.92"
+__version__ = "2.2.93"
 
 # The versioned machine output envelope contract.
 SCHEMA_VERSION = 1

{mammoth_cli-2.2.92 → mammoth_cli-2.2.93}/mammoth_cli/bundled_skill/mammoth-cli/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: mammoth-cli
-version: 2.2.92
+version: 2.2.93
 description: "Use Mammoth Analytics from a terminal: install or authenticate the CLI, discover its live command contract, and safely manage projects, data, views, pipelines (join, merge, pivot, filter, clean), dashboards, exports, and handoffs."
 ---
 

{mammoth_cli-2.2.92 → mammoth_cli-2.2.93}/mammoth_cli/bundled_skill/mammoth-cli/references/capabilities.md

@@ -1,7 +1,7 @@
 # What is proven on release
 
 Generated from `docs/release-capability-matrix.json`; do not edit by hand.
-The CLI publishes 782 commands. 516 of them bind one of the 545 API operations in the matrix; the remainder are local commands (`schema`, `auth`, `doctor`, `log`, ...) or typed variants that share an operation (`view transform *` commands submit through `view.task.add`, except `rename-columns` and `sort`, which set view display properties through `view.update`). 262 bound commands ran once successfully on release, 1 are not supported there, and the rest are untried. Untried is not broken: discover the contract with `mammoth schema get COMMAND_ID`, run it, and treat the structured error envelope as the answer. Use an untried command normally: confirm a write with the user first, check its result with a read afterwards, and never refuse a command only because it is untried.
+The CLI publishes 785 commands. 516 of them bind one of the 545 API operations in the matrix; the remainder are local commands (`schema`, `auth`, `doctor`, `log`, ...) or typed variants that share an operation (`view transform *` commands submit through `view.task.add`, except `rename-columns` and `sort`, which set view display properties through `view.update`). 262 bound commands ran once successfully on release, 1 are not supported there, and the rest are untried. Untried is not broken: discover the contract with `mammoth schema get COMMAND_ID`, run it, and treat the structured error envelope as the answer. Use an untried command normally: confirm a write with the user first, check its result with a read afterwards, and never refuse a command only because it is untried.
 
 Status meanings:
 

{mammoth_cli-2.2.92 → mammoth_cli-2.2.93}/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 782; 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 785; 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:
 
@@ -56,7 +56,7 @@ Load only the applicable domain file:
 - [user](commands/user.md) — 8 published commands
 - [version](commands/version.md) — 1 published commands
 - [view-transform](commands/view-transform.md) — 35 published commands
-- [view](commands/view.md) — 106 published commands
+- [view](commands/view.md) — 109 published commands
 - [webhook](commands/webhook.md) — 7 published commands
 - [workflow](commands/workflow.md) — 23 published commands
 - [workspace](commands/workspace.md) — 33 published commands

{mammoth_cli-2.2.92 → mammoth_cli-2.2.93}/mammoth_cli/bundled_skill/mammoth-cli/references/commands/view.md

@@ -122,6 +122,16 @@ Result: `ViewCheckpointUpdateResult`; mutation `benign_mutation`, confirmation `
 
 Status on release: ran once on CLI 2.0.18 — fixture-lifecycle sweep 2026-09-19: exit 0 on release with CLI 2.0.18. First attempt sending a full AddCheckpointSpec body (matching create's shape) failed with invalid_input_field_type; update actually needs body.patches[] (CheckpointPatches/CheckPointPatch…
 
+### `view.column.format.set`
+
+Run: `mammoth view column format set`. Exact input fields: `mammoth schema get view.column.format.set`.
+
+Example: `mammoth view column format set 123 --input '{"formats": {"Admitted": {"date_format": "%d-%b-%Y"}, "Revenue": {"decimal_spec": 2}}, "dataset_id": 456}'`. Placeholders are illustrative; resolve IDs and input from observed reads.
+
+Result: `ViewColumnFormatSetResult`; mutation `benign_mutation`, confirmation `none`, wait policy `not_async`.
+
+Status on release: untried; no live run recorded.
+
 ### `view.compare`
 
 Run: `mammoth view compare`. Exact input fields: `mammoth schema get view.compare`.
@@ -162,6 +172,16 @@ Result: `ViewConditionalFormatListResult`; mutation `read`, confirmation `none`,
 
 Status on release: ran once on CLI 2.0.17 — re-verification 2026-09-18 (2.0.16 fixes): exit 0 on release with CLI 2.0.17. With SDK 0.7.9 the one existing rule is returned as [{rule_id, cf_type, FORMAT, CONDITION, ...}]; with SDK 0.7.8 the same call returned [] (mapping keyed by rule id was discarded).…
 
+### `view.conditional-format.replace`
+
+Run: `mammoth view conditional-format replace`. Exact input fields: `mammoth schema get view.conditional-format.replace`.
+
+Example: `mammoth view conditional-format replace 123 456 --input '{"columns": ["Q1", "Q2", "Q3"], "operator": "<", "value": 55, "color": "red"}' --yes`. Illustrative only: append `--yes` after observing an owned target.
+
+Result: `ViewConditionalFormatReplaceResult`; mutation `destructive`, confirmation `prompt_or_yes`, wait policy `not_async`.
+
+Status on release: untried; no live run recorded.
+
 ### `view.conditional-format.update`
 
 Run: `mammoth view conditional-format update`. Exact input fields: `mammoth schema get view.conditional-format.update`.
@@ -546,6 +566,16 @@ Result: `ViewExportDeleteResult`; mutation `external_effect`, confirmation `yes_
 
 Status on release: ran once on CLI 2.0.14 — write sweep 2026-09-18: exit 0 on release with CLI 2.0.14. Deleted export 2 -> {future_id:null,status:deleted,trigger_id:2}. Single invocation only.
 
+### `view.export.download`
+
+Run: `mammoth view export download`. Exact input fields: `mammoth schema get view.export.download`.
+
+Example: `mammoth view export download 123`. Placeholders are illustrative; resolve IDs and input from observed reads.
+
+Result: `ViewExportDownloadResult`; mutation `benign_mutation`, confirmation `none`, wait policy `always_wait`.
+
+Status on release: untried; no live run recorded.
+
 ### `view.export.elasticsearch`
 
 Run: `mammoth view export elasticsearch`. Exact input fields: `mammoth schema get view.export.elasticsearch`.

{mammoth_cli-2.2.92 → mammoth_cli-2.2.93}/mammoth_cli/bundled_skill/mammoth-cli/references/recipes/transforms.md

@@ -86,6 +86,14 @@ A TEXT column that writes numbers with a decimal comma (`1.234,5`) converts with
 defaults to the other mark). `view data profile` lists such a column under
 `summary.mixed_number_format` when its values mix notations.
 
+A TEXT column of dates converts with `"to":"DATE"` and, on the same `conversions` entry,
+`"input_formats":["DD/MM/YYYY","YYYY-MM-DD"]` (every layout the column mixes),
+`"output_format":"DD-Mon-YYYY"` (how it displays) and
+`"input_format_preference":"uk"` or `"us"` (which way `03/04/2024` reads). Formats are
+Postgres date patterns.
+`view column format set` changes only how a DATE or number column
+shows, never its values.
+
 In a math `expression`, write a multi-word display name bare (`Quantity * Unit
 Price`) or quoted (`Quantity * \"Unit Price\"` inside the JSON string).
 

{mammoth_cli-2.2.92 → mammoth_cli-2.2.93}/mammoth_cli/commands/dataset.py

@@ -1077,6 +1077,45 @@ def _validate_paging(document: dict[str, Any]) -> None:
             )
 
 
+def _batch_column_ids(
+    service: Any, dataset_id: int, project_id: int, columns: str | list[str]
+) -> str:
+    """The comma-separated column ids the batch-data route wants, from names or ids."""
+    response = service.call(_DATASET_GET_SYMBOL, dataset_id=dataset_id, project_id=project_id)
+    dataset = response.get("dataset", response) if isinstance(response, dict) else {}
+    schema = dataset.get("data_schema") if isinstance(dataset, dict) else None
+    return resolve_batch_columns(schema, dataset_id, columns)
+
+
+def resolve_batch_columns(schema: Any, dataset_id: int, columns: str | list[str]) -> str:
+    """Column ids, comma-separated, for names or ids in ``columns`` (a list or one string).
+
+    The batch-data route refuses display names with a bare "invalid columns"; the dataset
+    schema maps each ``c_name`` to its ``c_id``. An id passes through; a name the schema
+    lacks is refused with the names it has.
+    """
+    if not isinstance(schema, list):
+        raise CliError(
+            code=CODE_API_ERROR,
+            message=f"Could not read dataset {dataset_id}'s columns to resolve 'columns'.",
+            exit_status=EXIT_API,
+        )
+    wanted = [n.strip() for n in columns.split(",")] if isinstance(columns, str) else columns
+    ids = {c["c_id"] for c in schema if isinstance(c, dict) and "c_id" in c}
+    by_name = {c["c_name"]: c["c_id"] for c in schema if isinstance(c, dict) and "c_name" in c}
+    resolved = [name if name in ids else by_name.get(name) for name in wanted]
+    missing = [name for name, found in zip(wanted, resolved, strict=True) if found is None]
+    if missing:
+        raise CliError(
+            code="unknown_column",
+            message=f"Column(s) not in dataset {dataset_id}: {', '.join(missing)}.",
+            exit_status=EXIT_USAGE,
+            hint="Use column names or ids from `mammoth dataset get`.",
+            details={"columns": missing, "available": sorted(by_name)},
+        )
+    return ",".join(str(found) for found in resolved)
+
+
 def dataset_batch_data(invocation: Invocation) -> HandlerResult:
     """Fetch data for a specific dataset batch."""
     project_id = require_project(invocation)
@@ -1091,6 +1130,9 @@ def dataset_batch_data(invocation: Invocation) -> HandlerResult:
     }
     _forward_optional(document, kwargs, ("columns", "limit", "offset", "timeout", "poll_interval"))
     with open_service(invocation) as (service, auth):
+        if kwargs.get("columns"):
+            columns = kwargs["columns"]
+            kwargs["columns"] = _batch_column_ids(service, dataset_id, project_id, columns)
         data = service.call(_symbol(invocation), **kwargs)
     return data, _meta(invocation, auth.workspace_id, project_id)
 

{mammoth_cli-2.2.92 → mammoth_cli-2.2.93}/mammoth_cli/commands/help_summaries.json

@@ -583,10 +583,12 @@
   "view.checkpoint.get": "Get one checkpoint by id.",
   "view.checkpoint.list": "List checkpoints on a dataview, with optional filters from '--input'.",
   "view.checkpoint.update": "Update one checkpoint by id. 'body' is required.",
+  "view.column.format.set": "Set how columns display (date or number format; a view display setting, not a task).",
   "view.compare": "Compare dataviews pairwise: rows, column differences and checksums (read-only).",
   "view.conditional-format.create": "Colour cells in many columns by one threshold in a single command (columns + operator + value + color): each cell is judged by its own value. applies_to=row colours whole rows when any/all of the columns match.",
   "view.conditional-format.delete-all": "Delete a conditional-format rule on a dataview. Prompt or '--yes'.",
   "view.conditional-format.list": "List conditional-format rules on a dataview.",
+  "view.conditional-format.replace": "Replace every conditional-format rule on a view with new ones in one call.",
   "view.conditional-format.update": "Update a conditional-format rule on a dataview. 'rule' is required.",
   "view.create": "Create a view from a dataset. Dataset id is positional; name/clone_from optional.",
   "view.data-check.create": "Create a data check on a dataview. 'body' is required.",
@@ -625,6 +627,7 @@
   "view.export.csv": "Export a dataview to a local CSV file.",
   "view.export.dataset": "Run one of the SDK's typed 'View.export' destination helpers.",
   "view.export.delete": "Delete one export by id. Always requires '--yes'.",
+  "view.export.download": "Download a dataview to a local file as csv, xlsx, json, ndjson, xml, yaml or parquet.",
   "view.export.elasticsearch": "Run one of the SDK's typed 'View.export' destination helpers.",
   "view.export.email": "Run one of the SDK's typed 'View.export' destination helpers.",
   "view.export.ftp": "Run one of the SDK's typed 'View.export' destination helpers.",

{mammoth_cli-2.2.92 → mammoth_cli-2.2.93}/mammoth_cli/commands/registry.py

@@ -885,6 +885,9 @@ _TARGETS: dict[str, str] = {
         "mammoth_cli.commands.view:view_conditional_format_delete_all"
     ),
     "view.conditional-format.list": "mammoth_cli.commands.view:view_conditional_format_list",
+    "view.conditional-format.replace": (
+        "mammoth_cli.commands.view:view_conditional_format_replace"
+    ),
     "view.conditional-format.update": "mammoth_cli.commands.view:view_conditional_format_update",
     "view.checkpoint.create": "mammoth_cli.commands.view:view_checkpoint_create",
     "view.checkpoint.delete": "mammoth_cli.commands.view:view_checkpoint_delete",
@@ -924,6 +927,7 @@ _TARGETS: dict[str, str] = {
     "view.task.update": "mammoth_cli.commands.view:view_task_update",
     "view.export.create": "mammoth_cli.commands.view:view_export_create",
     "view.export.csv": "mammoth_cli.commands.view:view_export_csv",
+    "view.export.download": "mammoth_cli.commands.view:view_export_download",
     "view.export.delete": "mammoth_cli.commands.view:view_export_delete",
     "view.export.get": "mammoth_cli.commands.view:view_export_get",
     "view.export.list": "mammoth_cli.commands.view:view_export_list",
@@ -1005,6 +1009,7 @@ _TARGETS: dict[str, str] = {
     "view.transform.generate-sql": "mammoth_cli.commands.view_ops:view_transform_generate_sql",
     "view.transform.increment-date": "mammoth_cli.commands.view_ops:view_transform_increment_date",
     "view.transform.join": "mammoth_cli.commands.view_ops:view_transform_join",
+    "view.column.format.set": "mammoth_cli.commands.view_ops:view_column_format_set",
     "view.transform.json-extract": "mammoth_cli.commands.view_ops:view_transform_json_extract",
     "view.transform.limit-rows": "mammoth_cli.commands.view_ops:view_transform_limit_rows",
     "view.transform.lookup": "mammoth_cli.commands.view_ops:view_transform_lookup",

{mammoth_cli-2.2.92 → mammoth_cli-2.2.93}/mammoth_cli/commands/schema.py

@@ -224,6 +224,10 @@ _COMMAND_DISCOVERY_PURPOSES = {
     "file.delete": "delete remove uploaded source file csv",
     "file.list": "list show uploaded source files csv",
     "view.export.csv": "export download local CSV file artifact",
+    "view.export.download": (
+        "export download local file artifact xlsx excel json ndjson xml yaml parquet "
+        "file type format"
+    ),
     "view.export.dataset": (
         "send copy branch out create save the result rows into a new project from an "
         "existing append appending union stack monthly rows across datasets views "
@@ -431,6 +435,15 @@ _COMMAND_DISCOVERY_PURPOSES = {
     "view.transform.rename-columns": (
         "rename column columns header headers relabel change column name names title"
     ),
+    "view.column.format.set": (
+        "format display column date format number format decimals decimal places currency "
+        "symbol percent percentage thousands separator show dates as how values look grid "
+        "date display"
+    ),
+    "view.conditional-format.replace": (
+        "replace redo reset change all conditional formatting rules highlight colour color "
+        "existing rules in one call"
+    ),
     "view.transform.replace": "find replace substitute text value in columns",
     "view.transform.set-values": (
         "set values assign overwrite blank empty default where condition label "
@@ -952,7 +965,8 @@ IN_PLACE_RECIPE = (
     "EDITS THE GIVEN VIEW IN PLACE: this adds a step to the view and changes that view "
     "and its dataset's output. To make a NEW dataset and leave the source untouched: "
     "`mammoth view create SOURCE_DATASET_ID` (working view), do the steps on that working "
-    "view, then `mammoth view export dataset WORKING_VIEW_ID` (add dataset_name only if the user named it)."
+    "view, then `mammoth view export dataset WORKING_VIEW_ID` "
+    "(add dataset_name only if the user named it)."
 )
 _IN_PLACE_KEYWORDS = (
     "new dataset create make in place edits given view working view source untouched"
@@ -1183,17 +1197,53 @@ def _accepted_fields(record: dict[str, Any]) -> list[dict[str, Any]] | None:
     ]
 
 
+_INLINE_SCHEMA_MAX_CHARS = 3000
+#: A restrictions note (where a nested input shape often lives) is inlined up to this long.
+_INLINE_NOTES_MAX_CHARS = 700
+
+
 def _compact_accepted_fields(record: dict[str, Any]) -> list[dict[str, Any]] | None:
-    """``_accepted_fields`` without the per-field JSON Schema.
+    """``_accepted_fields`` with a nested JSON Schema only where the type name is not enough.
 
     A find result inlines this for its top matches: enough to compose a call
-    (name, type, required, enum) without the nested-schema detail ``schema
-    get`` returns.
+    (name, type, required, enum) without a follow-up ``schema get``. A
+    non-scalar field (e.g. convert-type's ``conversions``) also carries its
+    JSON Schema, unless that would be larger than ``_INLINE_SCHEMA_MAX_CHARS``.
     """
     fields = _accepted_fields(record)
     if fields is None:
         return None
-    return [{key: field[key] for key in ("name", "type", "required", "enum")} for field in fields]
+    compact: list[dict[str, Any]] = []
+    for field in fields:
+        item = {key: field[key] for key in ("name", "type", "required", "enum")}
+        schema = field.get("schema")
+        if (
+            schema is not None
+            and not _is_scalar_field_schema(schema)
+            and len(json.dumps(schema, default=str)) <= _INLINE_SCHEMA_MAX_CHARS
+        ):
+            item["schema"] = schema
+        compact.append(item)
+    return compact
+
+
+def input_contract(command_id: str) -> dict[str, Any] | None:
+    """The input shape a rejected call should have used: fields (with nested shapes) and an example.
+
+    Attached to input-validation errors so the caller can correct the call
+    without a ``schema get`` round trip. ``None`` for a command with no
+    manifest record or no accepted fields.
+    """
+    record = command_by_id(command_id)
+    if record is None:
+        return None
+    fields = _compact_accepted_fields(record)
+    if fields is None:
+        return None
+    contract: dict[str, Any] = {"command_id": command_id, "accepted_fields": fields}
+    if record.get("agent_example"):
+        contract["agent_example"] = record["agent_example"]
+    return contract
 
 
 def _externally_supplied_fields(command_id: str) -> frozenset[str]:
@@ -2215,6 +2265,10 @@ def _inline_call_detail(entries: list[dict[str, Any]]) -> None:
             entry["accepted_fields"] = fields
         if record.get("agent_example"):
             entry["agent_example"] = record["agent_example"]
+        notes = record.get("known_restrictions")
+        if isinstance(notes, str) and notes:
+            cut = notes[:_INLINE_NOTES_MAX_CHARS]
+            entry["known_restrictions"] = cut + ("..." if len(notes) > len(cut) else "")
 
 
 def _inline_picks(page: list[dict[str, Any]], offset: int) -> list[dict[str, Any]]:

{mammoth_cli-2.2.92 → mammoth_cli-2.2.93}/mammoth_cli/commands/view.py

@@ -1446,6 +1446,7 @@ def view_data_get(invocation: Invocation) -> HandlerResult:
         )
     page_size = _DATA_PAGE_ROWS if whole_view else kwargs["limit"]
     data = _trim_rows(data, limit, page_size)
+    data = keep_columns(data, document.get("columns"))
     if document.get("sequence") is None:
         # The view's row count is its latest step's; a read at an earlier step differs.
         data = _with_paging_total(data, meta)
@@ -1467,6 +1468,34 @@ def _page_offset(value: Any) -> int:
     return offset
 
 
+def keep_columns(data: Any, columns: list[str] | None) -> Any:
+    """Keep only ``columns`` (display names) in a data page's rows and column header.
+
+    A name the page does not have is refused with the names it does have, so a typo
+    never reads as an empty column.
+    """
+    if columns is None or not isinstance(data, dict):
+        return data
+    rows = data.get(_ROWS_KEY)
+    if not isinstance(rows, list):
+        return data
+    first = rows[0] if rows else None
+    available = list(first) if isinstance(first, dict) else list(data.get(_COLUMNS_KEY) or [])
+    missing = [name for name in columns if name not in available]
+    if missing:
+        raise CliError(
+            code="unknown_column",
+            message=f"Column(s) not in the view: {', '.join(missing)}.",
+            exit_status=EXIT_USAGE,
+            hint="Use column display names from this view.",
+            details={"columns": missing, "available": available},
+        )
+    kept = {**data, _ROWS_KEY: DataRows([{c: row[c] for c in columns} for row in rows])}
+    if isinstance(data.get(_COLUMNS_KEY), list):
+        kept[_COLUMNS_KEY] = list(columns)
+    return kept
+
+
 def _with_cli_paging(
     data: Any,
     invocation: Invocation,
@@ -2816,6 +2845,47 @@ def view_conditional_format_create(invocation: Invocation) -> HandlerResult:
     project_id = require_project(invocation)
     dataview_id = _require_int_positional_at(invocation, 0, "view id")
     document = invocation.load_input() or {}
+    has_typed = _cf_check_document(document)
+    with open_service(invocation) as (service, auth):
+        dataset_id = _resolve_dataset_id(service, invocation, dataview_id, document)
+        rules = _cf_rules_for_document(
+            service, document, has_typed, (dataset_id, dataview_id, project_id)
+        )
+        data = _create_cf_rules(service, invocation, rules, (dataset_id, dataview_id, project_id))
+    return data, _meta(invocation, auth.workspace_id, project_id)
+
+
+def view_conditional_format_replace(invocation: Invocation) -> HandlerResult:
+    """Replace every conditional-format rule on a view with new ones in one call.
+
+    Takes the input of ``view conditional-format create`` (typed fields or a raw ``rule``);
+    the old rules are deleted and the new ones created. Prompt or ``--yes``.
+    """
+    project_id = require_project(invocation)
+    dataview_id = _require_int_positional_at(invocation, 0, "view id")
+    document = invocation.load_input() or {}
+    has_typed = _cf_check_document(document)
+    with open_service(invocation) as (service, auth):
+        dataset_id = _resolve_dataset_id(service, invocation, dataview_id, document)
+        scope = (dataset_id, dataview_id, project_id)
+        rules = _cf_rules_for_document(service, document, has_typed, scope)
+        enforce_confirmation(
+            invocation,
+            policy=POLICY_PROMPT_OR_YES,
+            action=f"replace all conditional-format rules on view {dataview_id}",
+        )
+        data = service.call(
+            _symbol(invocation),
+            dataset_id=dataset_id,
+            dataview_id=dataview_id,
+            rules=rules,
+            project_id=project_id,
+        )
+    return data, _meta(invocation, auth.workspace_id, project_id)
+
+
+def _cf_check_document(document: dict[str, Any]) -> bool:
+    """Whether the input uses the typed fields; refuses mixing them with ``rule`` or neither."""
     has_typed = any(field in document for field in cf_rules.TYPED_FIELDS)
     if "rule" in document and has_typed:
         raise CliError(
@@ -2825,17 +2895,20 @@ def view_conditional_format_create(invocation: Invocation) -> HandlerResult:
         )
     if "rule" not in document and not has_typed:
         _require_field(document, "rule")
-    with open_service(invocation) as (service, auth):
-        dataset_id = _resolve_dataset_id(service, invocation, dataview_id, document)
-        if has_typed:
-            metadata = _dataview_metadata(service, dataset_id, dataview_id, project_id)
-            column_map, column_types = _column_maps(metadata)
-            rules = cf_rules.build_rules(document, column_map, column_types)
-        else:
-            cf_rules.validate_rule(document["rule"])
-            rules = [document["rule"]]
-        data = _create_cf_rules(service, invocation, rules, (dataset_id, dataview_id, project_id))
-    return data, _meta(invocation, auth.workspace_id, project_id)
+    return has_typed
+
+
+def _cf_rules_for_document(
+    service: Any, document: dict[str, Any], has_typed: bool, scope: tuple[Any, ...]
+) -> list[dict[str, Any]]:
+    """The rule bodies an input document stands for (typed fields build one rule per column)."""
+    dataset_id, dataview_id, project_id = scope
+    if has_typed:
+        metadata = _dataview_metadata(service, dataset_id, dataview_id, project_id)
+        column_map, column_types = _column_maps(metadata)
+        return cf_rules.build_rules(document, column_map, column_types)
+    cf_rules.validate_rule(document["rule"])
+    return [document["rule"]]
 
 
 def _cf_sequence(rule: Any) -> int:
@@ -3992,18 +4065,42 @@ def view_export_csv(invocation: Invocation) -> HandlerResult:
     signed download URL is returned instead so the host can hand it to its
     user. ``output_path`` is refused in that case.
     """
+    return _download_dataview(
+        invocation, "mammoth.api.exports.ExportsAPI.to_csv_url", ("output_path", "timeout")
+    )
+
+
+def view_export_download(invocation: Invocation) -> HandlerResult:
+    """Download a dataview to a local file as csv, xlsx, json, ndjson, xml, yaml or parquet.
+
+    Same as ``view export csv`` otherwise: ``--input '{"format": "xlsx", "output_path":
+    "out.xlsx"}'``; the default name carries the format's extension; an existing file is not
+    replaced unless ``--overwrite``; embedded, the signed download URL is returned instead.
+    """
+    return _download_dataview(
+        invocation,
+        "mammoth.api.exports.ExportsAPI.to_file_url",
+        ("output_path", "file_type", "timeout"),
+    )
+
+
+def _download_dataview(
+    invocation: Invocation, embedded_symbol: str, fields: tuple[str, ...]
+) -> HandlerResult:
+    """Shared body of ``view export csv`` and ``view export download``."""
     dataview_id = _require_int_positional_at(invocation, 0, "dataview id")
     document = invocation.load_input() or {}
     if embedded.active():
-        return _view_export_csv_embedded(invocation, dataview_id, document)
+        return _view_export_csv_embedded(invocation, dataview_id, document, embedded_symbol)
     kwargs: dict[str, Any] = {"dataview_id": dataview_id}
-    _forward_optional(document, kwargs, ("output_path", "timeout", "dataset_id"))
+    _forward_optional(document, kwargs, (*fields, "dataset_id"))
     with open_service(invocation) as (service, auth):
         _require_exact_parent(service, invocation, dataview_id, kwargs)
         # The SDK's own default name needs the parent dataset, which is known here.
         target = kwargs.get("output_path")
         if target is None and kwargs.get(_DATASET_ID_FIELD) is not None:
-            target = f"dataview_{kwargs[_DATASET_ID_FIELD]}_{dataview_id}_export.csv"
+            extension = str(kwargs.get("file_type") or "csv").strip().lower().lstrip(".")
+            target = f"dataview_{kwargs[_DATASET_ID_FIELD]}_{dataview_id}_export.{extension}"
         if target is not None:
             refuse_existing_file(invocation, target)
         data = service.call(_symbol(invocation), **kwargs)
@@ -4013,9 +4110,9 @@ def view_export_csv(invocation: Invocation) -> HandlerResult:
 
 
 def _view_export_csv_embedded(
-    invocation: Invocation, dataview_id: int, document: dict[str, Any]
+    invocation: Invocation, dataview_id: int, document: dict[str, Any], symbol: str
 ) -> HandlerResult:
-    """``view.export.csv`` for an embedded call: never writes a local file."""
+    """A download for an embedded call: never writes a local file."""
     if "output_path" in document:
         raise CliError(
             code=CODE_UNSUPPORTED_CONTRACT,
@@ -4024,9 +4121,9 @@ def _view_export_csv_embedded(
             hint="Drop output_path -- an embedded call returns a download_url instead.",
         )
     kwargs: dict[str, Any] = {"dataview_id": dataview_id}
-    _forward_optional(document, kwargs, ("timeout", "dataset_id"))
+    _forward_optional(document, kwargs, ("file_type", "timeout", "dataset_id"))
     with open_service(invocation) as (service, auth):
-        data = service.call("mammoth.api.exports.ExportsAPI.to_csv_url", **kwargs)
+        data = service.call(symbol, **kwargs)
     return {"download_url": data["url"]}, _meta(invocation, auth.workspace_id, None)
 
 

{mammoth_cli-2.2.92 → mammoth_cli-2.2.93}/mammoth_cli/commands/view_ops.py

@@ -2134,6 +2134,16 @@ def view_transform_rename_columns(invocation: Invocation) -> HandlerResult:
     return _dispatch_view(invocation, view_id, "rename_columns", **kwargs)
 
 
+def view_column_format_set(invocation: Invocation) -> HandlerResult:
+    """Set how columns display (date or number format; a view display setting, not a task)."""
+    view_id = _view_id(invocation)
+    document = invocation.load_input()
+    _require_field(document, "formats")
+    assert document is not None
+    kwargs = _bind_transform_inputs(invocation, document)
+    return _dispatch_view(invocation, view_id, "set_column_format", **kwargs)
+
+
 def view_transform_sort(invocation: Invocation) -> HandlerResult:
     """Set the view's row order (a display setting, not a task). ``order_by`` is required.
 
@@ -2175,7 +2185,7 @@ def view_transform_math(invocation: Invocation) -> HandlerResult:
 def _math_into_column(
     invocation: Invocation, view_id: int, document: dict[str, Any], **dispatch: Any
 ) -> HandlerResult:
-    """The math write for a ``view transform math`` input ``document``, with its blank-input note."""
+    """The math write for a ``view transform math`` input ``document``, with its blank note."""
     kwargs = _bind_transform_inputs(invocation, document, "view.transform.math")
     blanks: dict[str, int] = {}
 

{mammoth_cli-2.2.92 → mammoth_cli-2.2.93}/mammoth_cli/errors/envelope.py

@@ -297,7 +297,10 @@ def missing_project_error() -> CliError:
             code="project_required",
             message="No project is set for this command.",
             exit_status=EXIT_USAGE,
-            hint="Pass --project PROJECT_ID.",
+            hint=(
+                "This environment has no default project. Run `mammoth project list`, then "
+                "repeat the command with --project PROJECT_ID."
+            ),
             recovery_commands=["mammoth project list", "mammoth dataset find SUBSTRING"],
         )
     return CliError(

{mammoth_cli-2.2.92 → mammoth_cli-2.2.93}/mammoth_cli/runtime/executor.py

@@ -128,6 +128,34 @@ def _validate_output(output: str) -> None:
         )
 
 
+#: Error codes that mean "the --input document was wrong": the envelope then
+#: carries the command's input contract so the next call needs no ``schema get``.
+_INPUT_REJECTION_CODES = frozenset(
+    {
+        "unknown_input_field",
+        "invalid_input_field_type",
+        "missing_field",
+        "invalid_input",
+        "invalid_input_document",
+        "invalid_arguments",
+        "invalid_condition",
+        "invalid_condition_value",
+        "invalid_rule",
+    }
+)
+
+
+def _attach_input_contract(error: CliError, command_id: str) -> None:
+    """Add ``details["input_contract"]`` to an input-validation error, once."""
+    if error.code not in _INPUT_REJECTION_CODES or "input_contract" in error.details:
+        return
+    from mammoth_cli.commands.schema import input_contract
+
+    contract = input_contract(command_id)
+    if contract is not None:
+        error.details["input_contract"] = contract
+
+
 def _with_pin_checked(error: CliError, invocation: Invocation | None) -> CliError:
     """Make a 403's "project-limited token" hint true for this token (one lookup, 403 only)."""
     if invocation is None:
@@ -297,6 +325,7 @@ def run(
     run_log = _open_run_log(command_id, invocation)
 
     def fail(error: CliError, cause: BaseException | None = None) -> None:
+        _attach_input_contract(error, command_id)
         if run_log is not None:
             error.log_ref = run_log.ref
             run_log.finish(error.exit_status, error_code=error.code, exception=cause)