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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mammoth-cli
-Version: 2.2.90
+Version: 2.2.92
 Summary: Command-line interface for the Mammoth Analytics platform
 Project-URL: homepage, https://mammoth.io
 Project-URL: repository, https://github.com/EdgeMetric/mammothsdk

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

{mammoth_cli-2.2.90 → mammoth_cli-2.2.92}/mammoth_cli/app.py

@@ -428,6 +428,29 @@ def _global_option_flags() -> tuple[frozenset[str], frozenset[str]]:
     return frozenset(every), frozenset(valued)
 
 
+def missing_argument_hint(tokens: Sequence[str]) -> str:
+    """The command's usage line and runnable example, for a ``missing_argument`` error.
+
+    The command is the longest run of leading words that names one; with none, the
+    generic pointer to the schema.
+    """
+    generic = "Check the command schema with 'mammoth schema get'."
+    path_to_command, _ = _command_tree()
+    words = [token for token in tokens if not token.startswith("-")]
+    for length in range(len(words), 0, -1):
+        command_id = path_to_command.get(tuple(words[:length]))
+        if command_id is None:
+            continue
+        slots = " ".join(
+            spec.metavar if spec.required else f"[{spec.metavar}]"
+            for spec in resolve_positionals(command_id)
+        )
+        usage = " ".join(part for part in ("mammoth", *words[:length], slots) if part)
+        example = (command_by_id(command_id) or {}).get("agent_example")
+        return f"Usage: {usage}." + (f" Example: {example}" if example else "")
+    return generic
+
+
 def _corrected_command(tokens: Sequence[str]) -> str | None:
     """Rebuild an invocation with leading global options moved after the command.
 
@@ -747,7 +770,7 @@ class _EnvelopeGroup(TyperGroup):
                         code="missing_argument",
                         message=error_message,
                         exit_status=EXIT_USAGE,
-                        hint="Check the command schema with 'mammoth schema get'.",
+                        hint=missing_argument_hint(tokens),
                     )
                 elif isinstance(error, _typer_click_exceptions.NoSuchOption):
                     option = getattr(error, "option_name", None) or "unknown"
@@ -779,6 +802,8 @@ class _EnvelopeGroup(TyperGroup):
             executor.emit_error(report, machine=True)
         elif report is None:
             error.show()
+            if is_missing_parameter:
+                typer.echo(missing_argument_hint(tokens), err=True)
         else:
             # A no-subcommand error arrives with the help text already on
             # screen, so repeating "run --help" below it would be noise.

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

@@ -1,6 +1,6 @@
 ---
 name: mammoth-cli
-version: 2.2.90
+version: 2.2.92
 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.90 → mammoth_cli-2.2.92}/mammoth_cli/bundled_skill/mammoth-cli/references/operations.md

@@ -98,8 +98,10 @@ When several transforms go on the same view in a row (for example filter, sort,
 limit-rows), send them in one `view transform batch VIEW_ID --input '{"steps": [{"op":
 "filter", "input": {...}}, ...]}'` instead of one command each: the pipeline runs once and
 one verified outcome comes back (`row_check`, and `tasks` with each new task's status).
-Each `input` is what that `view transform` command takes. A step cannot use a column an
-earlier step of the batch creates: run those steps first. If a task fails, the batch's tasks
+Each `input` is what that `view transform` command takes. A step can use the columns an
+earlier step adds (`split`, `copy-columns`, or the `new_column` of `substring`, `extract-date`,
+`increment-date`). `split`, `unnest` and `pivot` can be
+batch steps too; `unnest` and `pivot` replace the view's columns, so they go last (and no `sort` step before them). If a task fails, the batch's tasks
 are removed and the error names `steps[i]`.
 
 Prefer a typed `view transform <operation>` command. Its schema is the

{mammoth_cli-2.2.90 → mammoth_cli-2.2.92}/mammoth_cli/commands/browse.py

@@ -17,6 +17,7 @@ from mammoth_cli.errors.envelope import (
     CODE_INVALID_ARGUMENT,
     CODE_MISSING_ARGUMENT,
     CODE_MISSING_FIELD,
+    CODE_RESOURCE_NOT_FOUND,
     CODE_SDK_SYMBOL_UNRESOLVED,
     EXIT_USAGE,
     CliError,
@@ -28,6 +29,31 @@ from mammoth_cli.services.folder_ids import FolderIds
 
 HandlerResult = tuple[Any, dict[str, Any]]
 
+#: The route's resource types are datasource, dataview, label, file_object, report and webhook;
+#: these are the names a caller reaches for instead.
+_RESOURCE_TYPE_ALIASES = {"dataset": "datasource", "folder": "label"}
+
+
+def canonical_resource_type(value: str) -> str:
+    """``value`` (one type, or several joined by commas) with each alias as the route's name."""
+    return ",".join(
+        _RESOURCE_TYPE_ALIASES.get(part.strip(), part.strip()) for part in value.split(",")
+    )
+
+
+def ancestors_needs_a_folder(error: CliError) -> CliError:
+    """``error`` (the 404 for an id that is no folder) as a message saying what to pass."""
+    return CliError(
+        code=error.code,
+        message="browse ancestors needs a FOLDER id; this id is not a folder.",
+        exit_status=error.exit_status,
+        hint=(
+            "A dataset or view has no ancestors of its own: run `mammoth browse resource "
+            "dataset ID` (or `dataview ID`) and pass the parent_resource_id it returns."
+        ),
+        details=error.details,
+    )
+
 
 def _symbol(invocation: Invocation) -> str:
     """Return the reviewed backing SDK symbol for this command."""
@@ -213,7 +239,8 @@ def browse_resource(invocation: Invocation) -> HandlerResult:
         )
     with open_service(invocation) as (service, auth):
         folders = FolderIds(service)
-        if str(resource_type) == "label":
+        resource_type = canonical_resource_type(str(resource_type))
+        if resource_type == "label":
             object_id = folders.label(project_id, int(object_id))
         data = service.call(
             _symbol(invocation),
@@ -230,7 +257,14 @@ def browse_ancestors(invocation: Invocation) -> HandlerResult:
     project_id = require_project(invocation)
     resource_id = _require_int_positional(invocation, "resource id")
     with open_service(invocation) as (service, auth):
-        found = service.call(_symbol(invocation), resource_id=resource_id, project_id=project_id)
+        try:
+            found = service.call(
+                _symbol(invocation), resource_id=resource_id, project_id=project_id
+            )
+        except CliError as exc:
+            if exc.code != CODE_RESOURCE_NOT_FOUND:
+                raise
+            raise ancestors_needs_a_folder(exc) from exc
         data = FolderIds(service).open_data(found, project_id)
     return data, _meta(invocation, auth.workspace_id, project_id)
 
@@ -238,7 +272,8 @@ def browse_ancestors(invocation: Invocation) -> HandlerResult:
 def browse_search(invocation: Invocation) -> HandlerResult:
     """Search resources across every project of the workspace (resources v2).
 
-    ``resource_type`` ``dataset`` means the route's ``datasource``. Each dataset hit
+    ``resource_type`` ``dataset`` means the route's ``datasource``, ``folder`` its ``label``.
+    Each dataset hit
     carries ``dataset_id`` and each view hit ``view_id``: pass those, never the tree ``id``.
     """
     document = invocation.load_input() or {}
@@ -246,6 +281,8 @@ def browse_search(invocation: Invocation) -> HandlerResult:
     _forward_optional(
         document, kwargs, ("search", "resource_type", "cursor", "limit", "sort", "fields")
     )
+    if isinstance(kwargs.get("resource_type"), str):
+        kwargs["resource_type"] = canonical_resource_type(kwargs["resource_type"])
     with open_service(invocation) as (service, auth):
         data = FolderIds(service).open_data(service.call(_symbol(invocation), **kwargs), None)
     return _with_object_ids(data), _meta(invocation, auth.workspace_id, None)

{mammoth_cli-2.2.90 → mammoth_cli-2.2.92}/mammoth_cli/commands/dashboard.py

@@ -618,10 +618,13 @@ def dashboard_share(invocation: Invocation) -> HandlerResult:
     assert document is not None
     _forward_optional(document, kwargs, ("users",))
     with open_service(invocation) as (service, auth):
+        was_published = _was_published(service, dashboard_id)
+        if not was_published:
+            refuse_viewer_share_before_publish(dashboard_id, type_of_auth, kwargs.get("users"))
         unpublished = (
             " (not published yet: sharing alone does not publish it; run dashboard action "
             'with {"action":"publish-presentation"} to publish)'
-            if not _was_published(service, dashboard_id)
+            if not was_published
             else ""
         )
         enforce_confirmation(
@@ -638,6 +641,33 @@ def dashboard_share(invocation: Invocation) -> HandlerResult:
     return data, _meta(invocation, auth.workspace_id)
 
 
+def refuse_viewer_share_before_publish(
+    dashboard_id: int, type_of_auth: str, users: list[dict[str, Any]] | None
+) -> None:
+    """Refuse, as the server does, a ``mammoth`` share that gives viewer access before a publish.
+
+    The server (``_apply_mammoth_recipients``) refuses the whole request when any user is
+    shared as a viewer (the default role) and the board has no published version.
+    """
+    if type_of_auth != "mammoth":
+        return
+    for user in users or []:
+        shared = user.get("shared", True)
+        shared = shared.lower() in ("true", "1", "yes", "on") if isinstance(shared, str) else shared
+        if shared and user.get("role") != "dashboard_editor":
+            raise CliError(
+                code="dashboard_not_published",
+                message=f"Dashboard {dashboard_id} is not published; viewers cannot be invited.",
+                exit_status=EXIT_USAGE,
+                hint=(
+                    "Publish it first: mammoth dashboard action "
+                    f'{dashboard_id} --input \'{{"action": "publish-presentation"}}\' --yes, '
+                    "then share. Or share only users with role dashboard_editor."
+                ),
+                details={"dashboard_id": dashboard_id},
+            )
+
+
 def _share_readback(service: Any, dashboard_id: int) -> dict[str, Any]:
     """The board's share state as ``dashboard get`` reports it after a share."""
     board = _dump_model(service.call(_DASHBOARD_GET, dashboard_id=dashboard_id))

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

@@ -35,7 +35,7 @@ from mammoth_cli.runtime.confirm import (
 )
 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
+from mammoth_cli.runtime.session import open_service, require_project, resolved_project
 from mammoth_cli.services.delete_check import ensure_deleted, find_dependents
 from mammoth_cli.services.field_enums import DATA_PULL_FILE_VALUES, allowed_values_text
 from mammoth_cli.services.listing import (
@@ -761,17 +761,22 @@ def dataset_list(invocation: Invocation) -> HandlerResult:
     datasets" never needs paging: read ``total`` with the first page's newest names.
     For a list of names (e.g. "which files can I see?") pass ``names: true``: ONE call
     returns up to 500 bare ``{id, name}`` rows, newest first, with ``total`` and ``more``.
+    With no project set it returns ``{project_id, project_name, id, name}`` rows from every
+    project the caller can open, from one workspace search (the newest 500 at most).
     ``full: true`` returns the raw ``{id, name}`` list instead. ``name`` keeps only datasets
     whose name contains it (case-insensitive) across every page, as short rows without
     column lists; ``limit``/``offset`` then page over the matches.
     """
-    project_id = require_project(invocation)
     document = invocation.load_input() or {}
+    name = document.get("name")
+    wants_names = document.get("names") and not (isinstance(name, str) and name.strip())
+    if wants_names and resolved_project(invocation) is None:
+        return _dataset_names_everywhere(invocation)
+    project_id = require_project(invocation)
     _validate_paging(document)
     kwargs: dict[str, Any] = {"project_id": project_id}
     _forward_optional(document, kwargs, ("limit", "offset", "sort"))
-    name = document.get("name")
-    if document.get("names") and not (isinstance(name, str) and name.strip()):
+    if wants_names:
         return _dataset_names(invocation, project_id, document)
     if isinstance(name, str) and name.strip():
         return _dataset_name_search(invocation, project_id, name.strip(), document)
@@ -817,6 +822,42 @@ def _dataset_names(
     return result, _meta(invocation, auth.workspace_id, project_id)
 
 
+def _dataset_names_everywhere(invocation: Invocation) -> HandlerResult:
+    """``dataset list`` with ``names`` and no project: the names of every reachable project.
+
+    One workspace search (100 hits a page, the route's cap) lists the datasets of the
+    projects the caller can open, under the same access rules as ``project list``; one
+    ``project list`` read supplies the project names. Capped at ``_SEARCH_PAGES`` pages.
+    """
+    with open_service(invocation) as (service, auth):
+        hits, cut = search_hits(service, "datasource", "", fields="minimal")
+        names = {p.get("id"): p.get("name") for p in _visible_projects(service)}
+    rows = [
+        {
+            "project_id": hit["project_id"],
+            "project_name": names[hit["project_id"]],
+            "id": hit["object_id"],
+            "name": hit.get("name"),
+        }
+        for hit in hits
+        if hit.get("project_id") in names
+    ]
+    kept, _cut = fit_budget(rows[:NAMES_MAX_ROWS], budget=NAMES_DATA_BUDGET)
+    result: dict[str, Any] = {
+        "datasets": kept,
+        "shown": len(kept),
+        "total": len(rows),
+        "projects": len({row["project_id"] for row in rows}),
+    }
+    if cut or len(kept) < len(rows):
+        result["more"] = True
+        result["note"] = (
+            f"Only the newest {len(kept)} names were read; pass --project to list one "
+            "project's names, or name to find one."
+        )
+    return result, _meta(invocation, auth.workspace_id, None)
+
+
 def _dataset_total(service: Any, project_id: int, page: dict[str, Any], offset: int) -> int:
     """The project's whole dataset count. The list route sends none, so a page that
     is the last one counts itself; otherwise the ids are read once, here, in one call."""

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

@@ -689,7 +689,7 @@
   "view.transform.increment-date": "Increment a date column. 'column'/'delta' required.",
   "view.transform.join": "Join another view. 'foreign_view'/'join_type'/'on'/'select' required.",
   "view.transform.json-extract": "Extract fields from a JSON column. 'column' is required.",
-  "view.transform.limit-rows": "Limit the row count. 'n' is required.",
+  "view.transform.limit-rows": "Limit the row count. 'n' (or its alias 'limit') is required.",
   "view.transform.lookup": "Look up values from another view. 'source'/'lookup_view_id'/'key'/",
   "view.transform.math": "Evaluate a math expression into a column. 'expression' is required.",
   "view.transform.pivot": "Pivot with aggregations. 'group_by'/'aggregations' required.",

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

@@ -68,7 +68,7 @@ from mammoth_cli.runtime.confirm import POLICY_PROMPT_OR_YES, enforce_confirmati
 from mammoth_cli.runtime.dryrun import DryRunStop
 from mammoth_cli.runtime.invocation import Invocation
 from mammoth_cli.runtime.session import open_service, resolved_project
-from mammoth_cli.runtime.strict import validate_input_fields
+from mammoth_cli.runtime.strict import apply_input_aliases, validate_input_fields
 from mammoth_cli.runtime.verify import export_stamps, export_stamps_read
 from mammoth_cli.services.column_type_guard import (
     DATE,
@@ -80,8 +80,9 @@ from mammoth_cli.services.column_type_guard import (
 from mammoth_cli.services.command_contract import bind_command_inputs, resolve_command_contract
 from mammoth_cli.services.conditions import CONDITION_KWARG, compile_condition
 from mammoth_cli.services.delete_check import ensure_deleted
-from mammoth_cli.services.field_enums import BATCH_OPS, allowed_values_text
+from mammoth_cli.services.field_enums import BATCH_LAST_OPS, BATCH_OPS, allowed_values_text
 from mammoth_cli.services.input_fields import TASK_COUNT_FIELD
+from mammoth_cli.services.poll import poll_delays
 from mammoth_cli.services.read_memo import prefetch
 from mammoth_cli.services.sql_check import check_sql_binds
 from mammoth_cli.services.suggest import nearest_one
@@ -484,16 +485,27 @@ def _dispatch_view(
             data = {key: value for key, value in data.items() if key != "message"}
             data["status"] = "done"
             data["draft_applied"] = True
+        settled = _settled_write(service, data) if dataset_id is not None else None
+        if settled is not None:
+            _forget_reads(service)  # the state read-back must see the view as the write left it
         if after is not None and dataset_id is not None:
-            run, run_error = (
-                wait_for_added_task_run(service, int(dataset_id), view_id, task_ids_before)
-                if task_ids_before is not None and not _is_staged(data)
-                else (None, None)
-            )
+            if settled is not None:
+                run: dict[str, Any] | None = {
+                    "task_id": settled["task_id"],
+                    "transform_status": settled["task_run_status"],
+                }
+                run_error = None
+            else:
+                run, run_error = (
+                    wait_for_added_task_run(service, int(dataset_id), view_id, task_ids_before)
+                    if task_ids_before is not None and not _is_staged(data)
+                    else (None, None)
+                )
             reject_unrun_task_with_reference_errors(service, view_id, dataset_id, run_error)
             sdk_ready = sdk_saw_pipeline_ready(data)
             data = after(service, int(dataset_id), state, data)
-            _flag_unsettled_pipeline(service, int(dataset_id), view_id, data, sdk_ready)
+            if settled is None:
+                _flag_unsettled_pipeline(service, int(dataset_id), view_id, data, sdk_ready)
             if isinstance(data, dict) and run is not None:
                 data["run"] = run
                 if run_error is not None:
@@ -508,8 +520,12 @@ def _dispatch_view(
             # recomputing and read back no row_count at all; wait for it to
             # settle (bounded) before trusting this one. A staged draft never
             # ran the pipeline, so there is nothing to wait for or read.
-            rows_after, pipeline_error = wait_for_view_row_count(
-                service, int(dataset_id), view_id, invocation.project, write_result=data
+            rows_after, pipeline_error = (
+                (settled["row_count"], None)
+                if settled is not None
+                else wait_for_view_row_count(
+                    service, int(dataset_id), view_id, invocation.project, write_result=data
+                )
             )
             data["row_check"] = {"rows_before": rows_before, "rows_after": rows_after}
             if reduces_rows and not invocation.standing_noop:
@@ -547,6 +563,8 @@ _RUN_FAILED_STATUSES = _RUN_OVER_STATUSES - {_RUN_DONE_STATUS}
 #: Bounded wait for the run of a task just added: it starts after the add returns.
 _RUN_ATTEMPTS = 40
 _RUN_RETRY_S = 0.5
+#: Most seconds the wait for a task's run sleeps in all.
+_RUN_WAIT_S = _RUN_ATTEMPTS * _RUN_RETRY_S
 
 
 def _tasks(service: Any, dataset_id: int, view_id: int) -> list[dict[str, Any]]:
@@ -603,7 +621,7 @@ def wait_for_added_task_run(
     else the pipeline_error that keeps the write from reading verified.
     """
     run: dict[str, Any] = {}
-    for _ in range(_RUN_ATTEMPTS):
+    for delay in poll_delays(_RUN_WAIT_S, _RUN_RETRY_S):
         added = [
             task
             for task in _tasks(service, dataset_id, view_id)
@@ -621,7 +639,7 @@ def wait_for_added_task_run(
                 "task_id": run["task_id"],
                 "transform_status": status,
             }
-        time.sleep(_RUN_RETRY_S)
+        time.sleep(delay)
     return run, {
         "execution_state": UNFINISHED_STATE,
         "task_id": run.get("task_id"),
@@ -632,6 +650,44 @@ def wait_for_added_task_run(
     }
 
 
+def clean_write_result(job_response: Any) -> dict[str, Any] | None:
+    """The ``write_result`` of a run job when it says the write ran and settled cleanly.
+
+    A newer server adds it to the run job's response. ``None`` (read the task, the
+    pipeline and the row count as before) when it is absent, or says anything but a
+    finished task on a ``ready`` pipeline with a row count: those reads name the failure.
+    """
+    result = job_response.get("write_result") if isinstance(job_response, dict) else None
+    if (
+        isinstance(result, dict)
+        and result.get("task_id") is not None
+        and result.get("task_run_status") == _RUN_DONE_STATUS
+        and result.get("pipeline_state") == "ready"
+        and result.get("row_count") is not None
+    ):
+        return result
+    return None
+
+
+def _settled_write(service: Any, data: Any) -> dict[str, Any] | None:
+    """The clean ``write_result`` of the run job a write names (``future_id``), read once."""
+    future_id = data.get("future_id") if isinstance(data, dict) else None
+    if not isinstance(future_id, int) or _is_staged(data):
+        return None
+    try:
+        job = service.wait_if_job({"future_id": future_id})
+    except CliError:
+        return None  # the reads that follow report the failed or unfinished job
+    return clean_write_result(job)
+
+
+def _forget_reads(service: Any) -> None:
+    """Drop the reads made ahead of a write (see :mod:`mammoth_cli.services.read_memo`)."""
+    memo = getattr(service, "memo", None)
+    if memo is not None:
+        memo.clear()
+
+
 def _is_staged(data: Any) -> bool:
     """Whether a write only staged its step in a draft, so no run is to be waited on."""
     return isinstance(data, dict) and data.get("status") == "staged"
@@ -2059,7 +2115,7 @@ def view_transform_json_extract(invocation: Invocation) -> HandlerResult:
 
 
 def view_transform_limit_rows(invocation: Invocation) -> HandlerResult:
-    """Limit the row count. ``n`` is required."""
+    """Limit the row count. ``n`` (or its alias ``limit``) is required."""
     view_id = _view_id(invocation)
     document = invocation.load_input()
     _require_field(document, "n")
@@ -2079,7 +2135,10 @@ def view_transform_rename_columns(invocation: Invocation) -> HandlerResult:
 
 
 def view_transform_sort(invocation: Invocation) -> HandlerResult:
-    """Set the view's row order (a display setting, not a task). ``order_by`` is required."""
+    """Set the view's row order (a display setting, not a task). ``order_by`` is required.
+
+    ``sort_by`` is accepted as its alias.
+    """
     view_id = _view_id(invocation)
     document = invocation.load_input()
     _require_field(document, "order_by")
@@ -2342,9 +2401,9 @@ _TASK_DELETE_SYMBOL = "mammoth.api.pipeline.PipelineAPI.delete_task"
 CODE_BATCH_STEP_FAILED = "batch_step_failed"
 CODE_UNKNOWN_COLUMN = "unknown_column"
 _BATCH_COLUMN_HINT = (
-    "A batch is built against the view's columns as they are now, so a step cannot use a "
-    "column an earlier step of the same batch creates. Run the steps that create columns "
-    "first (their own `view transform` command or a batch), then batch the rest."
+    "A batch is built against the view's columns plus the ones the earlier steps of the batch "
+    "add (split, copy-columns, and any new_column of substring, extract-date, increment-date). "
+    "A column in neither is unknown: check its name, or run the step that creates it first."
 )
 
 
@@ -2357,6 +2416,9 @@ class _BatchPlan:
     task_steps: list[tuple[int, str]] = dataclass_field(default_factory=list)
     #: The bound ``sort`` inputs, applied after the tasks have run.
     sorts: list[dict[str, Any]] = dataclass_field(default_factory=list)
+    #: The columns the tasks add; the sort is built after they ran but on metadata that may not
+    #: list them yet.
+    created: list[dict[str, str]] = dataclass_field(default_factory=list)
 
 
 def _batch_steps(document: dict[str, Any] | None) -> list[dict[str, Any]]:
@@ -2386,7 +2448,7 @@ def _batch_steps(document: dict[str, Any] | None) -> list[dict[str, Any]]:
                 exit_status=EXIT_USAGE,
                 hint=(
                     f"Allowed ops: {allowed_values_text(_BATCH_OPS)}. Run any other "
-                    "transform (pivot, join, math, ...) as its own `view transform` command."
+                    "transform (join, math, ...) as its own `view transform` command."
                 ),
                 details={
                     "step": index,
@@ -2395,6 +2457,32 @@ def _batch_steps(document: dict[str, Any] | None) -> list[dict[str, Any]]:
                     "did_you_mean": near,
                 },
             )
+        if step["op"] == _BATCH_SORT_OP and any(
+            isinstance(later, dict) and later.get("op") in BATCH_LAST_OPS
+            for later in steps[index + 1 :]
+        ):
+            raise CliError(
+                code=CODE_INVALID_ARGUMENT,
+                message=(
+                    f"steps[{index}] (sort) comes before a step that replaces the view's columns, "
+                    "so its columns would no longer exist when the sort is applied."
+                ),
+                exit_status=EXIT_USAGE,
+                hint="Run the sort after the batch, as its own `view transform sort` command.",
+                details={"step": index, "op": _BATCH_SORT_OP},
+            )
+        if step["op"] in BATCH_LAST_OPS and index != len(steps) - 1:
+            raise CliError(
+                code=CODE_INVALID_ARGUMENT,
+                message=(
+                    f"steps[{index}] ({step['op']}) replaces the view's columns, so it must be "
+                    "the last step of a batch."
+                ),
+                exit_status=EXIT_USAGE,
+                hint=f"Move steps[{index}] to the end, or run the steps after it as their own "
+                "`view transform` commands.",
+                details={"step": index, "op": step["op"]},
+            )
     return steps
 
 
@@ -2412,17 +2500,34 @@ def _step_error(index: int, op: str, error: CliError) -> CliError:
     )
 
 
+def _created_columns(task_spec: dict[str, Any]) -> list[dict[str, str]]:
+    """The ``{COLUMN, TYPE, INTERNAL_NAME}`` columns a built task adds, from its ``AS`` outputs.
+
+    ``AS`` is one column (substring, extract-date, increment-date), a list of them (split) or
+    sits on each item of the task's list (copy-columns).
+    """
+    columns: list[dict[str, str]] = []
+    for body in task_spec.values():
+        for item in body if isinstance(body, list) else [body]:
+            made = item.get("AS") if isinstance(item, dict) else None
+            if made is not None:
+                columns.extend(made if isinstance(made, list) else [made])
+    return columns
+
+
 def _build_batch(
     invocation: Invocation, service: Any, view_id: int, dataset_id: int, steps: list[dict[str, Any]]
 ) -> _BatchPlan:
     """Bind and build every step against the view's current columns; send nothing."""
     plan = _BatchPlan()
+    created = plan.created
     for index, step in enumerate(steps):
         op = step["op"]
         command_id = f"view.transform.{op}"
         contract = resolve_command_contract(command_id)
         assert contract is not None
         try:
+            apply_input_aliases(command_id, step["input"])
             for spec in contract.fields:
                 if spec.required:
                     _require_field(step["input"], spec.name)
@@ -2438,7 +2543,12 @@ def _build_batch(
         method = str((command_by_id(command_id) or {})["sdk_symbol"]).rsplit(".", 1)[-1]
         try:
             built = service.call_view(
-                view_id, method, dataset_id=dataset_id, build_only=True, **kwargs
+                view_id,
+                method,
+                dataset_id=dataset_id,
+                build_only=True,
+                added_columns=created,
+                **kwargs,
             )
         except CliError as exc:
             raise _step_error(index, op, exc) from exc
@@ -2446,6 +2556,7 @@ def _build_batch(
             plan.sorts.append(kwargs)
         else:
             plan.specs.append(built["task_spec"])
+            created.extend(_created_columns(built["task_spec"]))
             plan.task_steps.append((index, op))
     return plan
 
@@ -2461,7 +2572,7 @@ def wait_for_added_tasks_run(
     ``count`` may be listed.
     """
     runs: list[dict[str, Any]] = []
-    for _ in range(_RUN_ATTEMPTS):
+    for delay in poll_delays(_RUN_WAIT_S, _RUN_RETRY_S):
         added = sorted(
             (t for t in _tasks(service, dataset_id, view_id) if t.get("id") not in task_ids_before),
             key=lambda task: task.get("id") or 0,
@@ -2475,7 +2586,7 @@ def wait_for_added_tasks_run(
             return runs
         if len(runs) >= count and all(status == _RUN_DONE_STATUS for status in statuses):
             return runs
-        time.sleep(_RUN_RETRY_S)
+        time.sleep(delay)
     return runs
 
 
@@ -2591,7 +2702,11 @@ def _apply_batch(
     try:
         for kwargs in plan.sorts:
             data["sort"] = service.call_view(
-                view_id, _SORT_METHOD, dataset_id=dataset_id, **kwargs
+                view_id,
+                _SORT_METHOD,
+                dataset_id=dataset_id,
+                added_columns=plan.created,
+                **kwargs,
             )["sort"]
     except CliError as exc:
         raise _batch_failure(service, dataset_id, view_id, task_ids_before, plan, exc) from exc

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

@@ -37,6 +37,7 @@ CODE_INVALID_ARGUMENT = "invalid_argument"
 CODE_UPLOAD_REFUSED = "upload_refused"
 CODE_INVALID_ARGUMENTS = "invalid_arguments"
 CODE_INVALID_CONFIG_VALUE = "invalid_config_value"
+CODE_INVALID_INPUT = "invalid_input"
 CODE_INVALID_INPUT_DOCUMENT = "invalid_input_document"
 CODE_INVALID_INPUT_FORMAT = "invalid_input_format"
 CODE_INVALID_WORKSPACE_ID = "invalid_workspace_id"
@@ -147,6 +148,8 @@ ERROR_SUMMARIES: dict[str, str] = {
     "invalid_config_value": _S_SETUP,
     "invalid_credentials": "The sign-in details weren't accepted.",
     "invalid_input_document": _S_BAD_INPUT,
+    "invalid_input": _S_BAD_INPUT,
+    "dashboard_not_published": "The dashboard has to be published before viewers can be invited.",
     "invalid_input_encoding": _S_BAD_INPUT,
     "invalid_input_field_type": _S_BAD_INPUT,
     "invalid_input_format": _S_BAD_INPUT,