mammoth-cli 2.2.22__tar.gz → 2.2.23__tar.gz

{mammoth_cli-2.2.22 → mammoth_cli-2.2.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mammoth-cli
-Version: 2.2.22
+Version: 2.2.23
 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.22 → mammoth_cli-2.2.23}/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.22"
+__version__ = "2.2.23"
 
 # The versioned machine output envelope contract.
 SCHEMA_VERSION = 1

{mammoth_cli-2.2.22 → mammoth_cli-2.2.23}/mammoth_cli/commands/dataset.py

@@ -810,6 +810,8 @@ def dataset_create(invocation: Invocation) -> HandlerResult:
     assert document is not None
     _forward_optional(document, kwargs, ("folder_resource_id",))
     with open_service(invocation) as (service, auth):
+        if invocation.dry_run:
+            _predict_final_name(invocation, service, dataset_spec, project_id)
         data = service.call(_symbol(invocation), **kwargs)
         # ``datasets.create`` returns a bare job handle and never waits. Block on
         # it here (honoring ``--job-timeout``) so the command reports a finished
@@ -845,6 +847,71 @@ def _created_dataset(handle: Any, settled: Any) -> dict[str, Any]:
     return result
 
 
+#: Pages (of 100) read to predict a final name; past it the answer is "a suffix may be added".
+_NAME_PROBE_PAGES = 20
+
+
+def _requested_name(dataset_spec: object) -> str | None:
+    """The name the caller asked for: ``ds_name`` (clone, cloud) or ``name`` (sketch)."""
+    if not isinstance(dataset_spec, dict):
+        return None
+    for key in ("ds_name", "name"):
+        if isinstance(dataset_spec.get(key), str) and dataset_spec[key]:
+            return str(dataset_spec[key])
+    return None
+
+
+def _project_dataset_names(service: _SdkCaller, project_id: int) -> tuple[set[str], bool]:
+    """Every dataset name in the project and whether all of them were read."""
+    names: set[str] = set()
+    for page in range(_NAME_PROBE_PAGES):
+        data = service.call(
+            "mammoth.api.datasets.DatasetsAPI.list",
+            project_id=project_id,
+            limit=100,
+            offset=page * 100,
+        )
+        rows = data.get("datasets", []) if isinstance(data, dict) else []
+        names.update(r["name"] for r in rows if isinstance(r, dict) and "name" in r)
+        if len(rows) < 100:
+            return names, True
+    return names, False
+
+
+def _name_impact(requested: str, names: set[str], complete: bool) -> dict[str, Any]:
+    """The dry-run prediction for ``requested`` against the project's dataset ``names``."""
+    if requested not in names:
+        free: dict[str, Any] = {"requested_name": requested, "name_taken": False}
+        if complete:
+            return {**free, "final_name": requested}
+        return {**free, "note": "Not all datasets were read; a numeric suffix is added if taken."}
+    impact: dict[str, Any] = {"requested_name": requested, "name_taken": True}
+    if not complete:
+        impact["note"] = f"'{requested}' is taken; a numeric suffix will be added to the name."
+        return impact
+    suffix = next(i for i in range(2, len(names) + 3) if f"{requested} {i}" not in names)
+    impact["final_name"] = f"{requested} {suffix}"
+    impact["note"] = (
+        f"'{requested}' is taken; the dataset will be named '{impact['final_name']}'. "
+        "Ask the user whether to use a different name."
+    )
+    return impact
+
+
+def _predict_final_name(
+    invocation: Invocation, service: _SdkCaller, dataset_spec: object, project_id: int
+) -> None:
+    """Dry run: say whether the requested name is taken and what the server will name it.
+
+    The server (``Datasource.get_unique_name``) tries ``name``, ``name 2``, ``name 3``...
+    against the project's live dataset names, so the answer is computed the same way.
+    """
+    requested = _requested_name(dataset_spec)
+    if requested is not None:
+        names, complete = _project_dataset_names(service, project_id)
+        object.__setattr__(invocation, "predicted_impact", _name_impact(requested, names, complete))
+
+
 def _add_final_name(
     service: _SdkCaller, result: dict[str, Any], dataset_spec: object, project_id: int
 ) -> None:
@@ -873,8 +940,8 @@ def _add_final_name(
     if not isinstance(name, str):
         return
     result["name"] = name
-    requested = dataset_spec.get("name") if isinstance(dataset_spec, dict) else None
-    if isinstance(requested, str) and requested != name:
+    requested = _requested_name(dataset_spec)
+    if requested is not None and requested != name:
         result["requested_name"] = requested
         result["note"] = f"The name '{requested}' was taken, so the dataset is named '{name}'."
 

{mammoth_cli-2.2.22 → mammoth_cli-2.2.23}/mammoth_cli/commands/view_ops.py

@@ -61,6 +61,7 @@ from mammoth_cli.runtime.session import open_service, resolved_project
 from mammoth_cli.services.command_contract import bind_command_inputs
 from mammoth_cli.services.conditions import CONDITION_KWARG
 from mammoth_cli.services.input_fields import TASK_COUNT_FIELD
+from mammoth_cli.services.sql_check import check_sql_binds
 from mammoth_cli.services.write_impact import (
     ImpactRead,
     Measure,
@@ -923,7 +924,30 @@ def view_transform_add_sql(invocation: Invocation) -> HandlerResult:
     _require_field(document, "query")
     assert document is not None
     kwargs = _bind_transform_inputs(invocation, document)
-    return _dispatch_view(invocation, view_id, "add_sql", **kwargs)
+    return _dispatch_view(
+        invocation, view_id, "add_sql", prepare=_sql_binding_check(invocation, view_id), **kwargs
+    )
+
+
+def _sql_binding_check(
+    invocation: Invocation, view_id: int
+) -> Callable[[Any, int, dict[str, Any]], Any]:
+    """A ``prepare`` hook: a dry run fails with ``would_fail`` when the SQL names a column
+    the step cannot bind (see :mod:`mammoth_cli.services.sql_check`). A real run is unchanged."""
+
+    def check(service: Any, dataset_id: int, kwargs: dict[str, Any]) -> Any:
+        if invocation.dry_run:
+            view = service.call(
+                _DATAVIEW_GET_SYMBOL,
+                dataset_id=dataset_id,
+                dataview_id=view_id,
+                project_id=resolved_project(invocation),
+            )
+            if isinstance(view, dict):
+                check_sql_binds(str(kwargs.get("query", "")), view)
+        return None
+
+    return check
 
 
 def view_transform_ai(invocation: Invocation) -> HandlerResult:

{mammoth_cli-2.2.22 → mammoth_cli-2.2.23}/mammoth_cli/errors/envelope.py

@@ -56,6 +56,7 @@ CODE_JOB_FAILED = "job_failed"
 CODE_INTERRUPTED = "interrupted"
 CODE_UNSUPPORTED_CONTRACT = "unsupported_contract"
 CODE_NO_OP = "no_op"
+CODE_WOULD_FAIL = "would_fail"
 
 # User-safe, one-line summaries shown to the customer instead of the model-facing
 # ``message``/``hint``. Plain language only: no command names, ids, field names
@@ -173,6 +174,7 @@ ERROR_SUMMARIES: dict[str, str] = {
     "upgrade_failed": "The update didn't complete.",
     "usage_error": _S_BAD_REQUEST,
     "view_in_draft": "This view is still a draft and can't be used yet.",
+    "would_fail": "This step would fail when it runs, so it was not added.",
 }
 
 #: Shown for a code with no entry (a runtime backstop only; the exhaustiveness

mammoth_cli-2.2.23/mammoth_cli/services/sql_check.py

@@ -0,0 +1,87 @@
+"""Check a SQL step's column names against what it will bind to, before it is added.
+
+``FROM "view:<id>"`` binds to the names the pipeline produced (the ``metadata`` of the
+view's latest data), not to a display-only rename (``display_properties.COLUMN_NAMES``),
+which ``view get`` shows. A query naming the renamed column is accepted by the CLI and
+fails in the backend's DuckDB with a Binder Error, so a dry run says so first.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Mapping
+
+from mammoth_cli.errors.envelope import CODE_WOULD_FAIL, EXIT_USAGE, CliError
+
+_STRING = re.compile(r"'(?:[^']|'')*'")
+_QUOTED = re.compile(r'"((?:[^"]|"")+)"')
+_ALIAS = re.compile(r'\bAS\s+("(?:[^"]|"")+"|\w+)|("(?:[^"]|"")+"|\w+)\s+AS\s*\(', re.IGNORECASE)
+_TABLE = re.compile(r'\b(?:FROM|JOIN)\s+("(?:[^"]|"")+")', re.IGNORECASE)
+_VIEW_REF = re.compile(r"view:\d+")
+
+
+def _unquote(name: str) -> str:
+    return name[1:-1].replace('""', '"') if name.startswith('"') else name
+
+
+def _declared(query: str) -> set[str]:
+    """Names the query itself introduces (aliases, CTEs) or reads as a table."""
+    aliases = {_unquote(a or b) for a, b in _ALIAS.findall(query)}
+    tables = {_unquote(t) for t in _TABLE.findall(query)}
+    return {name.casefold() for name in aliases | tables}
+
+
+def _identifiers(query: str, renamed: Mapping[str, str]) -> list[str]:
+    """Quoted identifiers, plus any bare word that is a renamed column's new name."""
+    found = [m for m in _QUOTED.findall(query) if not _VIEW_REF.fullmatch(m)]
+    words = {w.casefold() for w in re.findall(r"\w+", _QUOTED.sub(" ", query))}
+    found += [new for new in renamed if new.casefold() in words]
+    return list(dict.fromkeys(name.replace('""', '"') for name in found))
+
+
+def _renames(view: Mapping[str, object]) -> dict[str, str]:
+    """``{new name: pipeline name}`` for each display-only rename of the view."""
+    display = view.get("display_properties")
+    names = display.get("COLUMN_NAMES") if isinstance(display, dict) else None
+    metadata = view.get("metadata")
+    if not isinstance(names, dict) or not isinstance(metadata, list):
+        return {}
+    by_internal = {c.get("internal_name"): c.get("display_name") for c in metadata}
+    return {new: by_internal[i] for i, new in names.items() if by_internal.get(i)}
+
+
+def check_sql_binds(query: str, view: Mapping[str, object]) -> None:
+    """Raise ``would_fail`` when ``query`` names a column the step cannot bind.
+
+    Args:
+        query: The step's SQL.
+        view: The raw ``dataview get`` record (its ``metadata`` is the bindable schema).
+
+    Raises:
+        CliError: ``would_fail``, with the unknown name and the candidate columns.
+    """
+    metadata = view.get("metadata")
+    rows = metadata if isinstance(metadata, list) else []
+    columns = [
+        str(c["display_name"]) for c in rows if isinstance(c, dict) and c.get("display_name")
+    ]
+    if not columns:
+        return
+    renamed = _renames(view)
+    text = _STRING.sub("''", query)
+    known = {c.casefold() for c in columns} | _declared(text)
+    for name in _identifiers(text, renamed):
+        if name.casefold() not in known:
+            raise _unbound(name, columns, renamed.get(name))
+
+
+def _unbound(name: str, columns: list[str], was: str | None) -> CliError:
+    hint = f'Use "{was}": "{name}" is only a display name for it.' if was else None
+    return CliError(
+        code=CODE_WOULD_FAIL,
+        message=f'Referenced column "{name}" not found. Candidate bindings: '
+        + ", ".join(f'"{c}"' for c in columns),
+        exit_status=EXIT_USAGE,
+        hint=hint or "Use one of the candidate columns; nothing was added.",
+        details={"unknown_column": name, "candidate_columns": columns},
+    )

{mammoth_cli-2.2.22 → mammoth_cli-2.2.23}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mammoth-cli"
-version = "2.2.22"
+version = "2.2.23"
 description = "Command-line interface for the Mammoth Analytics platform"
 authors = [{name = "Mammoth Analytics", email = "support@mammoth.io"}]
 readme = "README.md"