pushmetrics-cli 0.1.0__py3-none-any.whl

pm/models/reports.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict
+
+
+class Report(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    id: Optional[int] = None
+    uid: Optional[str] = None
+    name: Optional[str] = None
+    type: Optional[str] = None
+    created_on: Optional[str] = None
+    workflow_enabled: Optional[bool] = None

pm/models/roles.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from typing import Any, List, Optional
+
+from pydantic import BaseModel, ConfigDict
+
+
+class Role(BaseModel):
+    """Workspace role.
+
+    Backend exposes ``id`` (integer, used by main_role PUTs), ``uid``
+    (hashid, used by assign/revoke endpoints), and ``name``. The three
+    main roles are ``Admin``/``User``/``Guest``; everything else listed
+    is treated as a group (per ``security/models.py:MainRoles``).
+    """
+    model_config = ConfigDict(extra="allow")
+
+    id: Optional[int] = None
+    uid: Optional[str] = None
+    name: Optional[str] = None
+    statistics: Optional[Any] = None
+    users_list: Optional[List[Any]] = None

pm/models/runs.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict
+
+
+class Run(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    id: Optional[int] = None
+    uid: Optional[str] = None
+    name: Optional[str] = None
+    status: Optional[str] = None
+    flow_run_id: Optional[str] = None
+    parent_id: Optional[int] = None
+    start_time: Optional[str] = None
+    end_time: Optional[str] = None
+    created_on_utc: Optional[str] = None
+    re_run_count: Optional[int] = None
+
+
+class RunLog(BaseModel):
+    """A single execution log line from a noteflow run.
+
+    Mirrors ``NoteflowRunLogRestApi`` list_columns — the timestamp, the
+    rendered message, the run linkage keys, and ``effective_level`` (the
+    backend-normalised log level). Extra fields are tolerated via
+    ``extra='allow'``.
+    """
+    model_config = ConfigDict(extra="allow")
+
+    uid: Optional[str] = None
+    created_on: Optional[str] = None
+    message: Optional[str] = None
+    flow_run_id: Optional[str] = None
+    noteflow_run_id: Optional[int] = None
+    task_run_id: Optional[str] = None
+    effective_level: Optional[str] = None
+
+
+class RunTaskResult(BaseModel):
+    """Per-block (per-task) execution result inside a noteflow run.
+
+    Mirrors the backend ``task_to_result`` payload — ``block_uid``,
+    ``status``, ``results_key``, and the parent run ``uid``. Other
+    fields (block_type, timing, error) may appear depending on source
+    and are kept via ``extra='allow'``.
+    """
+    model_config = ConfigDict(extra="allow")
+
+    block_uid: Optional[str] = None
+    status: Optional[str] = None
+    results_key: Optional[str] = None
+    uid: Optional[str] = None
+    error: Optional[Any] = None

pm/models/saved_blocks.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict
+
+
+class SavedBlock(BaseModel):
+    """Template wrapper around a block, with a parameter schema for reuse."""
+    model_config = ConfigDict(extra="allow")
+
+    uid: Optional[str] = None
+    block_id: Optional[int] = None
+    block: Optional[Any] = None  # nested block object (uid, name, type, content_json)
+    parameters_schema: Optional[Any] = None

pm/models/users.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from typing import List, Optional, Union
+
+from pydantic import BaseModel, ConfigDict
+
+# Re-exported from ``pm.models.roles`` so ``pm.models.users.Role`` and
+# ``pm.models.roles.Role`` are the same class — previously this file
+# defined its own slimmer ``Role`` which silently dropped fields like
+# ``uid`` whenever a role was deserialised through ``User.roles``.
+from pm.models.roles import Role
+
+
+class User(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    id: Optional[int] = None
+    uid: Optional[str] = None
+    first_name: Optional[str] = None
+    last_name: Optional[str] = None
+    username: Optional[str] = None
+    email: Optional[str] = None
+    avatar: Optional[str] = None
+    # Backend may serialize these as nested objects (GET list/show), as
+    # bare strings, or — on the POST add response — as bare integer
+    # IDs (FAB serialises FK lists as ids in add_model_schema.dump).
+    main_role: Optional[Union[Role, str, int]] = None
+    roles: Optional[List[Union[Role, str, int]]] = None
+    last_login: Optional[str] = None
+    login_count: Optional[int] = None
+    mfa_enabled: Optional[bool] = None
+    created_on: Optional[str] = None
+    accepted_terms_on: Optional[str] = None
+    current_workspace_id: Optional[int] = None
+    current_workspace_uid: Optional[str] = None
+    current_workspace_name: Optional[str] = None

pm/models/webhooks.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from typing import Any, Optional, Union
+
+from pydantic import BaseModel, ConfigDict
+
+
+class Webhook(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    id: Optional[int] = None
+    uid: Optional[str] = None
+    token: Optional[str] = None
+    active: Optional[bool] = None
+    # `details` / `recipients` / `slack_recipients` are JSON-stringified on
+    # input; backend also returns parsed *_json variants. Accept anything.
+    details: Optional[Union[str, dict, list]] = None
+    details_json: Optional[Any] = None
+    recipients: Optional[Union[str, list]] = None
+    recipients_json: Optional[Any] = None
+    slack_recipients: Optional[Union[str, list]] = None
+    slack_recipients_json: Optional[Any] = None
+    report_id: Optional[int] = None

pm/models/workspaces.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict
+
+
+class Workspace(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    id: Optional[int] = None
+    uid: Optional[str] = None
+    name: Optional[str] = None
+    # `is_active` is injected by the list endpoint when comparing against the
+    # caller's session — only present on `GET /workspace/`, not on `current`.
+    is_active: Optional[bool] = None

pm/output.py

@@ -0,0 +1,92 @@
+"""Output rendering helpers — JSON mode vs human-readable columns.
+
+Accepts both Pydantic models and plain dicts/lists transparently. Models are
+converted via `model_dump()` for both JSON serialization and column extraction,
+so command code can pass either form without caring.
+"""
+from __future__ import annotations
+
+import json
+import sys
+from typing import Any, Iterable, List, Sequence
+
+
+def _to_jsonable(value: Any) -> Any:
+    if hasattr(value, "model_dump"):
+        return value.model_dump()
+    return value
+
+
+def _to_dict(row: Any) -> Any:
+    if hasattr(row, "model_dump"):
+        return row.model_dump()
+    return row
+
+
+def emit(data: Any, *, json_output: bool, columns: Sequence[tuple] = ()) -> None:
+    """Print `data` to stdout.
+
+    - In JSON mode: dumps `data` directly (Pydantic models converted via `model_dump`).
+    - Otherwise, if `data` is a list and `columns` is provided, prints a table
+      where each column is `(header, key_or_callable)`. Each row is converted
+      to a dict before extraction so attribute-style models are transparent.
+    - Otherwise prints a `key: value` listing for dicts/models, or json-dumps
+      as fallback.
+    """
+    if json_output:
+        if isinstance(data, list):
+            data = [_to_jsonable(d) for d in data]
+        else:
+            data = _to_jsonable(data)
+        json.dump(data, sys.stdout, indent=2, default=str)
+        sys.stdout.write("\n")
+        return
+
+    if isinstance(data, list) and columns:
+        _print_table(data, columns)
+        return
+
+    data = _to_dict(data)
+    if isinstance(data, dict):
+        for key, value in data.items():
+            print(f"{key}: {_scalar(value)}")
+        return
+
+    json.dump(data, sys.stdout, indent=2, default=str)
+    sys.stdout.write("\n")
+
+
+def _scalar(value: Any) -> str:
+    """Render one ``key: value`` cell: nested dicts/lists as compact JSON
+    (never a Python repr with single quotes), None as empty."""
+    if value is None:
+        return ""
+    if isinstance(value, (dict, list)):
+        return json.dumps(_to_jsonable(value), default=str, separators=(",", ":"))
+    return str(value)
+
+
+def _print_table(rows: Iterable[Any], columns: Sequence[tuple]) -> None:
+    rows = [_to_dict(r) for r in rows]
+    headers = [c[0] for c in columns]
+
+    def _extract(row: dict, key: Any) -> str:
+        if row is None:
+            return ""
+        value = key(row) if callable(key) else row.get(key, "")
+        return "" if value is None else str(value)
+
+    string_rows: List[List[str]] = [
+        [_extract(row, col[1]) for col in columns] for row in rows
+    ]
+
+    widths = [len(h) for h in headers]
+    for row in string_rows:
+        for i, cell in enumerate(row):
+            widths[i] = max(widths[i], len(cell))
+
+    fmt = "  ".join(f"{{:<{w}}}" for w in widths)
+    print(fmt.format(*headers))
+    print(fmt.format(*["-" * w for w in widths]))
+    for row in string_rows:
+        print(fmt.format(*row))

pm/types.py

@@ -0,0 +1,130 @@
+"""Block-type canonicalization with did-you-mean errors (pm-tool plan §2.7).
+
+Resolution order:
+1. Exact match against ``CANONICAL_TYPES``.
+2. Explicit alias dict (``TYPE_ALIASES``) — case-insensitive lookup.
+3. Ambiguous inputs (``AMBIGUOUS_INPUTS``) — refuse to guess; surface
+   the candidate list as ``did_you_mean``.
+4. Fuzzy fallback via stdlib ``difflib.get_close_matches`` (Ratcliff /
+   Obershelp similarity; cutoff=0.6). Garbage input returns no
+   suggestions and still errors — no false positives.
+
+Single source of truth: every block type pm-tool surfaces lives in
+``CANONICAL_TYPES``. Adding a new type is data, not code — the
+canonicalizer picks it up automatically and the fuzzy matcher includes
+it in suggestions.
+"""
+from __future__ import annotations
+
+import difflib
+
+from pm.errors import PMError
+
+
+# Block types pm-tool surfaces. Singular; matches `block.type` values
+# in the backend (block_tools / block_runner).
+CANONICAL_TYPES: frozenset[str] = frozenset({
+    "sql",
+    "email",
+    "slack",
+    "sftp",
+    "plotly",
+    "metrics_view",
+    "explore",
+    "agent_skill",
+    "agent_memory",
+    "tableau",
+    # The backend stores Google Slides blocks as `google_slides` (see
+    # `prefect/queryme/noteflow/template_block/google_slides.py`). The
+    # user-facing CLI group is `pm slides` but the persisted block.type is
+    # `google_slides`; `slides` is a TYPE_ALIAS so `--type slides` still
+    # canonicalizes correctly.
+    "google_slides",
+})
+
+
+# Explicit silent aliases — common mismatches we know about. The key is
+# what the user (or LLM) might pass; the value is the canonical type.
+# Case-insensitive lookup is applied on top of this dict.
+TYPE_ALIASES: dict[str, str] = {
+    "SQL": "sql",
+    "sql_query": "sql",
+    "query": "sql",
+    "plot": "plotly",
+    "chart": "plotly",
+    "plotly_chart": "plotly",
+    "metrics": "metrics_view",
+    "metric_view": "metrics_view",
+    "metric": "metrics_view",
+    # Google Slides canonical form mirrors the backend block.type
+    "slides": "google_slides",
+    "google-slides": "google_slides",
+}
+
+
+# Strings we deliberately refuse to canonicalize — multiple plausible
+# resolutions, so we error with the candidate list rather than guess.
+AMBIGUOUS_INPUTS: dict[str, list[str]] = {
+    "view": ["metrics_view", "saved_view"],
+}
+
+
+# difflib cutoff. 0.6 catches single-char typos and case-different spellings
+# but rejects unrelated inputs. Empirically the right balance for short
+# block-type names (most are 3–13 chars).
+_FUZZY_CUTOFF = 0.6
+_FUZZY_MAX_SUGGESTIONS = 3
+
+
+def canonicalize_type(raw: str) -> str:
+    """Return the canonical block-type name for ``raw``. Raises
+    :class:`pm.errors.PMError` with ``error_code='unknown_block_type'`` if
+    no canonical form is reachable; the error carries ``did_you_mean``
+    suggestions when fuzzy matching finds plausible candidates.
+    """
+    # Layer 1: exact match against the canonical set
+    if raw in CANONICAL_TYPES:
+        return raw
+
+    # Layer 2: explicit aliases (exact + case-insensitive)
+    if raw in TYPE_ALIASES:
+        return TYPE_ALIASES[raw]
+    lowered = raw.lower()
+    for alias, canonical in TYPE_ALIASES.items():
+        if alias.lower() == lowered:
+            return canonical
+
+    # Layer 3: ambiguous strings — refuse to guess
+    if raw in AMBIGUOUS_INPUTS:
+        raise PMError(
+            error_code="unknown_block_type",
+            message=f"Ambiguous type {raw!r}: multiple candidates",
+            received=raw,
+            did_you_mean=AMBIGUOUS_INPUTS[raw],
+            allowed=sorted(CANONICAL_TYPES),
+            help="pm help block",
+        )
+
+    # Layer 4: fuzzy fallback — match against canonical types AND aliases,
+    # then map alias hits to their canonical form so the suggestions the
+    # agent sees are always real block types.
+    candidates = sorted(CANONICAL_TYPES | set(TYPE_ALIASES))
+    matches = difflib.get_close_matches(
+        raw,
+        candidates,
+        n=_FUZZY_MAX_SUGGESTIONS,
+        cutoff=_FUZZY_CUTOFF,
+    )
+    suggestions: list[str] = []
+    for m in matches:
+        canonical = TYPE_ALIASES.get(m, m)
+        if canonical not in suggestions:
+            suggestions.append(canonical)
+    raise PMError(
+        error_code="unknown_block_type",
+        message=f"Unknown type {raw!r}",
+        received=raw,
+        did_you_mean=suggestions,
+        allowed=sorted(CANONICAL_TYPES),
+        help="pm help block",
+    )