mammoth-cli 2.0.88__tar.gz → 2.0.89__tar.gz

{mammoth_cli-2.0.88 → mammoth_cli-2.0.89}/PKG-INFO

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

{mammoth_cli-2.0.88 → mammoth_cli-2.0.89}/mammoth_cli/bundled_skill/mammoth-cli/references/operations.md

@@ -31,7 +31,12 @@ need no project and no stored credentials. `dataset list`, `folder list`, and
 `view list` call the live API, and `--project` scopes them to one
 project. `dataset find NAME` and `folder find NAME` search every project
 the credential can see (or one, with `--project`); they still need
-credentials because they call the live API.
+credentials because they call the live API. To find a dataset by name, run
+`dataset find NAME` (no project needed), or
+`dataset list --input '{"name": "NAME"}'` inside one project: a
+case-insensitive substring match over every page, returned as short rows
+(id, name, rows, cols) with `matched`. Do not page `dataset list` by hand;
+`limit` is at most 100.
 
 ```bash
 mammoth capability find "transform"

{mammoth_cli-2.0.88 → mammoth_cli-2.0.89}/mammoth_cli/commands/dataset.py

@@ -30,7 +30,12 @@ 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.services.listing import DATASET_LIST_FIELDS, dataset_summary, fit_budget
+from mammoth_cli.services.listing import (
+    DATASET_LIST_FIELDS,
+    dataset_summary,
+    fit_budget,
+    search_page,
+)
 
 HandlerResult = tuple[Any, dict[str, Any]]
 
@@ -198,12 +203,18 @@ def dataset_list(invocation: Invocation) -> HandlerResult:
     Every item carries its size, created/updated time, how its data arrived, and
     its column names and types (from the list route's stored ``stats``,
     ``sources`` and ``data_schema``), cut to fit the agent tool output cap.
-    ``full: true`` returns the raw ``{id, name}`` list instead.
+    ``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 {}
+    _validate_paging(document)
     kwargs: dict[str, Any] = {"project_id": project_id}
     _forward_optional(document, kwargs, ("limit", "offset", "sort"))
+    name = document.get("name")
+    if isinstance(name, str) and name.strip():
+        return _dataset_name_search(invocation, project_id, name.strip(), document)
     compact = not document.get("full")
     if compact:
         kwargs["fields"] = DATASET_LIST_FIELDS
@@ -214,6 +225,27 @@ def dataset_list(invocation: Invocation) -> HandlerResult:
     return data, _meta(invocation, auth.workspace_id, project_id)
 
 
+def _dataset_name_search(
+    invocation: Invocation, project_id: int, name: str, document: dict[str, Any]
+) -> HandlerResult:
+    """``dataset list`` with ``name``: every page is read here, then filtered by substring.
+
+    The list route only filters by exact name, so the substring match is local; the
+    reads are bounded by the SDK's ``max_pages``.
+    """
+    with open_service(invocation) as (service, auth):
+        data = service.call(
+            "mammoth.api.datasets.DatasetsAPI.list_all",
+            project_id=project_id,
+            sort=document.get("sort", "(created_at:desc)"),
+            fields=DATASET_LIST_FIELDS,
+        )
+    records = data.get("datasets", []) if isinstance(data, dict) else []
+    page = search_page(records, name, int(document.get("offset", 0)), document.get("limit"))
+    page["name"] = name
+    return page, _meta(invocation, auth.workspace_id, project_id)
+
+
 def _compact_dataset_list(data: Any, offset: int, sort: str | None) -> Any:
     """Summarise a dataset-list page and fit it to the tool output cap."""
     datasets = data.get("datasets") if isinstance(data, dict) else None
@@ -324,12 +356,8 @@ def dataset_data(invocation: Invocation) -> HandlerResult:
     return data, _meta(invocation, auth.workspace_id, project_id)
 
 
-def dataset_batch_data(invocation: Invocation) -> HandlerResult:
-    """Fetch data for a specific dataset batch."""
-    project_id = require_project(invocation)
-    dataset_id = _require_int_positional(invocation, "dataset id")
-    batch_id = _require_int_positional_at(invocation, 1, "batch id")
-    document = invocation.load_input() or {}
+def _validate_paging(document: dict[str, Any]) -> None:
+    """Refuse a ``limit`` outside 0..100 or a negative ``offset`` before any call is made."""
     for field, minimum, maximum in (("limit", 0, 100), ("offset", 0, None)):
         value = document.get(field)
         if value is not None and (
@@ -344,6 +372,15 @@ def dataset_batch_data(invocation: Invocation) -> HandlerResult:
                 message=f"'{field}' must be {bound}.",
                 exit_status=EXIT_USAGE,
             )
+
+
+def dataset_batch_data(invocation: Invocation) -> HandlerResult:
+    """Fetch data for a specific dataset batch."""
+    project_id = require_project(invocation)
+    dataset_id = _require_int_positional(invocation, "dataset id")
+    batch_id = _require_int_positional_at(invocation, 1, "batch id")
+    document = invocation.load_input() or {}
+    _validate_paging(document)
     kwargs: dict[str, Any] = {
         "dataset_id": dataset_id,
         "batch_id": batch_id,

{mammoth_cli-2.0.88 → mammoth_cli-2.0.89}/mammoth_cli/errors/envelope.py

@@ -223,6 +223,7 @@ def missing_project_error() -> CliError:
         recovery_commands=[
             "mammoth project list",
             "mammoth context project use PROJECT_ID",
+            "mammoth dataset find SUBSTRING",
         ],
     )
 

{mammoth_cli-2.0.88 → mammoth_cli-2.0.89}/mammoth_cli/services/command_contract.py

@@ -655,8 +655,12 @@ _S7_ADDITIONAL_INPUT_FIELDS: dict[str, tuple[FieldSpec, ...]] = {
     "view.data.query": (
         FieldSpec("text_date_format", required=False, annotation=str | None, default=None),
     ),
-    # ``full`` returns the raw ``{id, name}`` list instead of the summaries.
-    "dataset.list": (FieldSpec("full", required=False, annotation=bool, default=False),),
+    # ``full`` returns the raw ``{id, name}`` list instead of the summaries; ``name`` keeps
+    # only datasets whose name contains it (case-insensitive) and drops the column lists.
+    "dataset.list": (
+        FieldSpec("full", required=False, annotation=bool, default=False),
+        FieldSpec("name", required=False, annotation=str | None, default=None),
+    ),
     # ``view list`` records are trimmed to the brief shape; ``full`` keeps
     # them. ``dataset_offset`` resumes the no-DATASET_ID, every-dataset-in-
     # the-project walk (item G) at a later dataset index.

{mammoth_cli-2.0.88 → mammoth_cli-2.0.89}/mammoth_cli/services/listing.py

@@ -117,6 +117,39 @@ def dataset_summary(record: dict[str, Any]) -> dict[str, Any]:
     return {k: v for k, v in summary.items() if v is not None}
 
 
+def name_matches(records: list[dict[str, Any]], needle: str) -> list[dict[str, Any]]:
+    """Records whose name contains ``needle``, case-insensitively, in list order."""
+    lowered = needle.lower()
+    return [r for r in records if isinstance(r.get("name"), str) and lowered in r["name"].lower()]
+
+
+def _name_hit(record: dict[str, Any]) -> dict[str, Any]:
+    """One name-search row: identity and size only (no column list, so many rows fit)."""
+    stats = record.get("stats") if isinstance(record.get("stats"), dict) else {}
+    hit: dict[str, Any] = {
+        "id": record.get("id"),
+        "name": record.get("name"),
+        **_size(stats.get("row_count"), stats.get("column_count")),
+    }
+    if record.get("status") not in (None, "ready"):
+        hit["status"] = record["status"]
+    return {k: v for k, v in hit.items() if v is not None}
+
+
+def search_page(
+    records: list[dict[str, Any]], needle: str, offset: int, limit: int | None
+) -> dict[str, Any]:
+    """One page of a name search over ``records`` (paged over the matches, not the project)."""
+    matches = name_matches(records, needle)
+    end = None if limit is None else offset + limit
+    kept, _omitted = fit_budget([_name_hit(r) for r in matches[offset:end]])
+    result: dict[str, Any] = {"datasets": kept, "shown": len(kept), "matched": len(matches)}
+    if offset + len(kept) < len(matches):
+        result["more"] = True
+        result["next_offset"] = offset + len(kept)
+    return result
+
+
 def view_summary(
     view: dict[str, Any], dataset: dict[str, Any] | None, dataset_id: Any
 ) -> dict[str, Any]:

{mammoth_cli-2.0.88 → mammoth_cli-2.0.89}/pyproject.toml

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

{mammoth_cli-2.0.88 → mammoth_cli-2.0.89}/spec/manifests/commands/dataset.yaml

@@ -674,7 +674,10 @@ commands:
     time (updated is left out when it equals created), the source kind (file, connector, created in Mammoth,
     export of a view), and its column names with types, from the list route''s stored stats, sources and
     data_schema, cut to fit the agent tool output cap: more is true with next_offset when the page was
-    cut. full true returns the raw id and name list.'
+    cut. full true returns the raw id and name list. name (input field, a case-insensitive
+    substring) reads every page and returns only the matching datasets as short rows (id, name, rows,
+    cols; no column lists) with matched, and more with next_offset when cut; limit and offset then
+    page over the matches. limit must be at most 100. Without a project use dataset find NAME_SUBSTRING.'
   reviewed_by: primary
 - command_id: dataset.rename
   command_path: dataset rename