mammoth-cli 2.2.62__tar.gz → 2.2.63__tar.gz

{mammoth_cli-2.2.62 → mammoth_cli-2.2.63}/PKG-INFO

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

{mammoth_cli-2.2.62 → mammoth_cli-2.2.63}/mammoth_cli/app.py

@@ -1343,7 +1343,7 @@ _ROOT_LEAF_HELP: dict[str, str] = {
     ),
     "resolve": (
         "Say what NAME refers to: a dataset, a view or a project, with ids and projects."
-        "\n\nExample: mammoth resolve uqa-w29-ren"
+        "\n\nExample: mammoth resolve uqa-w29-ren\n\nInput fields: all_projects (bool)"
     ),
     "upgrade": (
         "Upgrade the mammoth CLI to the latest (or a specified) version from PyPI."

{mammoth_cli-2.2.62 → mammoth_cli-2.2.63}/mammoth_cli/commands/connector.py

@@ -145,26 +145,23 @@ def connector_get(invocation: Invocation) -> HandlerResult:
     return data, _meta(invocation, auth.workspace_id, resolved_project(invocation))
 
 
-#: ``availability`` a premium connector gets when it is not yet added to the
-#: workspace -- distinct from an ordinary connector nobody has added yet.
-_PREMIUM_NOT_ENABLED = "premium_not_enabled"
+#: ``availability`` a connector gets when the server says this workspace's plan
+#: does not include it.
+_NOT_IN_PLAN = "not_in_plan"
 
 
-_PREMIUM_NOT_ENABLED_NOTE = (
-    "Premium connector, not enabled in this workspace: Mammoth sales must enable"
-    " it before it can be connected. Tell the user so and offer to contact sales."
-)
+_NOT_IN_PLAN_NOTE = "Not included in this workspace's plan. Mammoth sales can enable it."
 
 
-def _with_premium_availability(data: Any) -> Any:
-    """Mark each premium, not-yet-added connector with why it cannot be connected.
+def _with_plan_availability(data: Any) -> Any:
+    """Mark each connector the server reports unavailable to this workspace.
 
-    ``is_premium``/``is_added`` alone said a connector could not be connected
-    but never why: a premium connector must be enabled by Mammoth sales
-    before this workspace can use it, unlike an ordinary connector nobody has
-    added yet. Without this, an agent that reads ``connector list`` can route
-    a user to sales but never explain why (T2-WPP-W7). ``ConnectorsAPI.list``
-    returns a list, which stays a list.
+    The server's ``is_available`` is the same plan check that gates creating a
+    connection. ``is_premium``/``is_added`` cannot stand in for it: ``is_added``
+    only says a legacy integration row exists, so a premium connector the plan
+    does include read as "not enabled". A response without ``is_available`` (an
+    older server) is left unmarked. ``ConnectorsAPI.list`` returns a list, which
+    stays a list.
     """
     if not isinstance(data, list):
         return data
@@ -172,10 +169,10 @@ def _with_premium_availability(data: Any) -> Any:
         (
             {
                 **item,
-                "availability": _PREMIUM_NOT_ENABLED,
-                "availability_note": _PREMIUM_NOT_ENABLED_NOTE,
+                "availability": _NOT_IN_PLAN,
+                "availability_note": _NOT_IN_PLAN_NOTE,
             }
-            if isinstance(item, dict) and item.get("is_premium") and not item.get("is_added")
+            if isinstance(item, dict) and item.get("is_available") is False
             else item
         )
         for item in data
@@ -187,7 +184,7 @@ def connector_list(invocation: Invocation) -> HandlerResult:
     with open_service(invocation) as (service, auth):
         data = service.call(_symbol(invocation))
     return (
-        _with_premium_availability(data),
+        _with_plan_availability(data),
         _meta(invocation, auth.workspace_id, resolved_project(invocation)),
     )
 

{mammoth_cli-2.2.62 → mammoth_cli-2.2.63}/mammoth_cli/commands/dataset.py

@@ -10,6 +10,7 @@ seam to the public SDK method named by the command's reviewed manifest
 
 from __future__ import annotations
 
+from collections.abc import Callable
 from typing import Any, Protocol
 
 from mammoth_cli.errors.envelope import (
@@ -358,6 +359,44 @@ def _tag_scope(matches: list[dict[str, Any]], project_id: int) -> list[dict[str,
     return [{**m, "in_project": m.get("project_id") == project_id} for m in matches]
 
 
+def all_projects_requested(invocation: Invocation) -> bool:
+    """Whether ``--input '{"all_projects": true}'`` asks for matches outside the project."""
+    value = (invocation.load_input() or {}).get("all_projects", False)
+    if not isinstance(value, bool):
+        raise CliError(
+            code=CODE_INVALID_ARGUMENT,
+            message="all_projects must be true or false.",
+            exit_status=EXIT_USAGE,
+        )
+    return value
+
+
+def narrow_to_project(
+    rows: list[dict[str, Any]], is_exact: Callable[[dict[str, Any]], bool]
+) -> tuple[list[dict[str, Any]], int]:
+    """``(rows, dropped)``: only the project's own rows when one of them is an exact match.
+
+    The name already is in the project the call runs under, so the same name in
+    every other project is noise that reads as an ambiguity to ask the user about.
+    Rows must carry ``in_project``. With no exact match in the project, all rows
+    stay: the name may live elsewhere. ``dropped`` counts the rows left out.
+    """
+    own = [r for r in rows if r.get("in_project")]
+    if not any(is_exact(r) for r in own):
+        return rows, 0
+    return own, len(rows) - len(own)
+
+
+def elsewhere_note(dropped: int) -> str:
+    """Says how many matches in other projects were left out, and how to list them."""
+    if not dropped:
+        return ""
+    return (
+        f"{dropped} more match(es) in other projects are not listed: "
+        """--input '{"all_projects": true}' lists them."""
+    )
+
+
 def _find_scoped(
     service: Any,
     needle: str,
@@ -384,11 +423,14 @@ def dataset_find(invocation: Invocation) -> HandlerResult:
     carrying its ``project_id`` and ``project_name``: the in-product agent runs
     every call under the project the user last opened, which is often not the one
     the named dataset is in, so it states where the name is instead of asking the
-    user to switch. Does not require an active project.
+    user to switch. When the project holds an exact match, only the project's own
+    matches are returned and ``elsewhere`` counts the rest; ``--input
+    '{"all_projects": true}'`` returns them all. Does not require an active project.
     """
     name_substring = _require_string_positional(invocation, "name substring")
     needle = name_substring.lower()
     skipped: list[dict[str, Any]] = []
+    dropped = 0
     with open_service(invocation) as (service, auth):
         visible = _visible_projects(service)
         cut = False
@@ -396,6 +438,10 @@ def dataset_find(invocation: Invocation) -> HandlerResult:
             matches, projects, cut = _find_scoped(
                 service, needle, visible, invocation.project, skipped
             )
+            if not all_projects_requested(invocation):
+                matches, dropped = narrow_to_project(
+                    matches, lambda m: str(m.get("name", "")).lower() == needle
+                )
         else:
             projects = visible
             holding, cut = _projects_holding(service, needle, visible)
@@ -412,6 +458,9 @@ def dataset_find(invocation: Invocation) -> HandlerResult:
     if skipped:
         result["projects_skipped"] = skipped
     notes = [ambiguity_note(len(matches), name_substring)]
+    if dropped:
+        result["elsewhere"] = dropped
+        notes.append(elsewhere_note(dropped))
     if cut:
         result["truncated"] = True
         notes.append(search_cut_note("datasets"))

{mammoth_cli-2.2.62 → mammoth_cli-2.2.63}/mammoth_cli/commands/resolve.py

@@ -14,6 +14,9 @@ from typing import Any
 from mammoth_cli.commands.dataset import (
     _require_string_positional,
     _visible_projects,
+    all_projects_requested,
+    elsewhere_note,
+    narrow_to_project,
     search_cut_note,
     search_hits,
 )
@@ -99,10 +102,11 @@ def kinds_note(name: str, rows: list[dict[str, Any]]) -> str:
 def resolve(invocation: Invocation) -> HandlerResult:
     """Say what NAME refers to: a dataset, a view or a project, with ids and projects.
 
-    Read-only. NAME is a case-insensitive substring and the only argument; the
-    command has no options besides the global ``--project``, which only marks
-    each match ``in_project`` (matches elsewhere are always returned). Searches
-    every project the credential can see. Does not require an active project.
+    Read-only. NAME is a case-insensitive substring. Searches every project the
+    credential can see and marks each match ``in_project`` under ``--project``.
+    When the project holds an exact match, only the project's own matches are
+    returned and ``elsewhere`` counts the rest; ``--input '{"all_projects": true}'``
+    returns them all. Does not require an active project.
     """
     name = _require_string_positional(invocation, "name")
     cut = False
@@ -118,7 +122,13 @@ def resolve(invocation: Invocation) -> HandlerResult:
             "project_id": invocation.project,
         }
     rows = resolve_matches(name, projects, hits, invocation.project)
+    dropped = 0
+    if invocation.project is not None and not all_projects_requested(invocation):
+        rows, dropped = narrow_to_project(rows, lambda r: r["exact"])
     result: dict[str, Any] = {"name": name, "matches": rows, "note": kinds_note(name, rows)}
+    if dropped:
+        result["elsewhere"] = dropped
+        result["note"] += " " + elsewhere_note(dropped)
     if cut:
         result["truncated"] = True
         result["note"] += " " + search_cut_note("datasets or views")

{mammoth_cli-2.2.62 → mammoth_cli-2.2.63}/mammoth_cli/services/command_contract.py

@@ -250,6 +250,8 @@ _PILOT_ADAPTER_INPUTS: dict[str, frozenset[str]] = {
 _LOCAL_CONTRACT_FIELDS: dict[str, tuple[FieldSpec, ...]] = {
     "project.ensure": (FieldSpec("name", required=False, annotation=str),),
     "doctor": (FieldSpec("wait", required=False, annotation=int, default=0),),
+    "resolve": (FieldSpec("all_projects", required=False, annotation=bool, default=False),),
+    "dataset.find": (FieldSpec("all_projects", required=False, annotation=bool, default=False),),
     "schema.get": (FieldSpec("full", required=False, annotation=bool, default=False),),
     "schema.list": (
         FieldSpec("family", required=False, annotation=str | None, default=None),

{mammoth_cli-2.2.62 → mammoth_cli-2.2.63}/pyproject.toml

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