pushmetrics-cli 0.1.1__tar.gz → 0.2.0__tar.gz

{pushmetrics_cli-0.1.1 → pushmetrics_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pushmetrics-cli
-Version: 0.1.1
+Version: 0.2.0
 Summary: Command-line interface for PushMetrics
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown

pushmetrics_cli-0.2.0/pm/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

{pushmetrics_cli-0.1.1 → pushmetrics_cli-0.2.0}/pm/cli.py

@@ -24,6 +24,7 @@ from pm.config import (
 )
 from pm.errors import describe_api_error
 from pm.output import emit
+from pm.user_agent import CLIENT_ENV_VAR, client_name
 
 _cli_logger = logging.getLogger("pm.cli")
 
@@ -194,6 +195,9 @@ def config_list(ctx: click.Context) -> None:
             ("PM_AUTH0_DOMAIN", os.environ.get("PM_AUTH0_DOMAIN")),
             ("PM_AUTH0_CLIENT_ID", os.environ.get("PM_AUTH0_CLIENT_ID")),
             ("PM_CONFIG_HOME", os.environ.get("PM_CONFIG_HOME")),
+            # Not a profile setting, but it changes what pm sends: the
+            # User-Agent's client= names the calling tool.
+            (CLIENT_ENV_VAR, os.environ.get(CLIENT_ENV_VAR)),
         )
         if value
     }
@@ -230,7 +234,11 @@ def config_list(ctx: click.Context) -> None:
         click.echo("")
         click.echo("Active env-var overrides (apply to all profiles):")
         for var, value in env_overrides.items():
-            click.echo(f"  {var}={value}")
+            line = f"  {var}={value}"
+            if var == CLIENT_ENV_VAR and client_name() != value:
+                # pm normalises the value; show what the server receives.
+                line += f" (sent as client={client_name()})"
+            click.echo(line)
 
 
 from pm.commands.auth import login, logout, whoami
@@ -246,6 +254,8 @@ from pm.commands.integrations import integrations as integrations_group
 from pm.commands.metrics_view import metrics_view as metrics_view_group
 from pm.commands.organizations import organizations as organizations_group
 from pm.commands.recipient import recipient as recipient_group
+from pm.commands.deliverability import deliverability as deliverability_group
+from pm.commands.schedule import schedule as schedule_group
 from pm.commands.reports import reports as reports_group
 from pm.commands.roles import roles as roles_group
 from pm.commands.runs import runs as runs_group
@@ -284,6 +294,8 @@ cli.add_command(webhooks_group, name="webhook")
 cli.add_command(favorites_group, name="favorite")
 cli.add_command(organizations_group, name="organization")
 cli.add_command(recipient_group)
+cli.add_command(deliverability_group)
+cli.add_command(schedule_group)
 cli.add_command(roles_group, name="role")
 cli.add_command(saved_blocks_group, name="saved-block")
 

{pushmetrics_cli-0.1.1 → pushmetrics_cli-0.2.0}/pm/client/__init__.py

@@ -14,6 +14,7 @@ from pm.auth.session import PMSession
 from pm.client.access_tokens import AccessTokensClient
 from pm.client.blocks import BlocksClient
 from pm.client.databases import DatabasesClient
+from pm.client.deliverability import DeliverabilityClient
 from pm.client.favorites import FavoritesClient
 from pm.client.folders import FoldersClient
 from pm.client.integrations import IntegrationsClient
@@ -23,6 +24,7 @@ from pm.client.reports import ReportsClient
 from pm.client.roles import RolesClient
 from pm.client.runs import RunsClient
 from pm.client.saved_blocks import SavedBlocksClient
+from pm.client.schedules import SchedulesClient
 from pm.client.tableau import TableauClient
 from pm.client.users import UsersClient
 from pm.client.webhooks import WebhooksClient
@@ -50,8 +52,10 @@ class PMClient:
         self.favorites = FavoritesClient(session)
         self.organizations = OrganizationsClient(session)
         self.recipients = RecipientsClient(session)
+        self.deliverability = DeliverabilityClient(session)
         self.roles = RolesClient(session)
         self.saved_blocks = SavedBlocksClient(session)
+        self.schedules = SchedulesClient(session)
         self.blocks = BlocksClient(session)
         self.tableau = TableauClient(session)
         self.access_tokens = AccessTokensClient(session)

{pushmetrics_cli-0.1.1 → pushmetrics_cli-0.2.0}/pm/client/blocks.py

@@ -56,6 +56,7 @@ SCRATCH_ROUTING_FIELD: Dict[str, str] = {
     "slack": "integration_id",
     "sftp": "integration_id",
     "tableau": "integration_id",
+    "power_bi": "integration_id",
     "webhook": "integration_id",
     "google_slides": "integration_id",
 }

pushmetrics_cli-0.2.0/pm/client/deliverability.py

@@ -0,0 +1,37 @@
+"""Email deliverability API client: wraps ``/api/v1/recipient/deliverability*``.
+
+Amazon SES keeps one suppression list per sending account; the server scopes
+it to this workspace by matching only the workspace's own recipients, users
+and email blocks (``superset/pushmetrics/views/recipient/api.py``). The client
+returns the response bodies as they are; the command layer renders them.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from pm.client.base import raise_for_status
+
+
+class DeliverabilityClient:
+    base_path = "/api/v1/recipient/deliverability"
+
+    def __init__(self, session):
+        self.session = session
+
+    def list(self) -> Dict[str, Any]:
+        """``{result: [blocked rows], count, enabled}``."""
+        resp = self.session.get(self.base_path)
+        raise_for_status(resp)
+        return resp.json() if resp.content else {}
+
+    def events(self, email: str) -> Dict[str, Any]:
+        """``{result: [events, newest first], state}`` for one address."""
+        resp = self.session.get(f"{self.base_path}/events", params={"email": email})
+        raise_for_status(resp)
+        return resp.json() if resp.content else {}
+
+    def unblock(self, email: str) -> Dict[str, Any]:
+        """``{result: state}``. Admin-only, enforced by the server."""
+        resp = self.session.post(f"{self.base_path}/unblock", json={"email": email})
+        raise_for_status(resp)
+        return resp.json() if resp.content else {}

pushmetrics_cli-0.2.0/pm/client/schedules.py

@@ -0,0 +1,49 @@
+"""Schedules API client: wraps ``/api/v1/workflow`` (a "workflow" in the API,
+a "schedule" everywhere a person reads it).
+
+``superset/pushmetrics/views/workflow/api.py``: list/get return the same
+record (``show_columns = list_columns``, report name and uid nested under
+``report``); POST takes ``report_id`` (the integer id, which the command layer
+resolves from a report uid); PUT takes ``rrule`` and ``active``; ``POST
+/<uid>/run`` dispatches the run as a background task and returns no run uid.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from pm.client.base import _unwrap_result, raise_for_status
+
+
+class SchedulesClient:
+    base_path = "/api/v1/workflow"
+
+    def __init__(self, session):
+        self.session = session
+
+    def list(self, report_id: Optional[int] = None) -> List[Dict[str, Any]]:
+        params = {"q": "(page_size:-1)"}
+        if report_id is not None:
+            params["q"] = f"(filters:!((col:report_id,opr:eq,value:{int(report_id)})),page_size:-1)"
+        resp = self.session.get(f"{self.base_path}/", params=params)
+        raise_for_status(resp)
+        raw = _unwrap_result(resp.json(), default=[])
+        return raw if isinstance(raw, list) else [raw]
+
+    def get(self, uid: str) -> Dict[str, Any]:
+        resp = self.session.get(f"{self.base_path}/{uid}")
+        raise_for_status(resp)
+        return _unwrap_result(resp.json(), default={}) or {}
+
+    def create(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """The add response carries only add_columns; callers re-read with get."""
+        resp = self.session.post(f"{self.base_path}/", json=data)
+        raise_for_status(resp)
+        return _unwrap_result(resp.json(), default={}) or {}
+
+    def update(self, uid: str, data: Dict[str, Any]) -> None:
+        resp = self.session.put(f"{self.base_path}/{uid}", json=data)
+        raise_for_status(resp)
+
+    def run(self, uid: str) -> None:
+        resp = self.session.post(f"{self.base_path}/{uid}/run")
+        raise_for_status(resp)

{pushmetrics_cli-0.1.1 → pushmetrics_cli-0.2.0}/pm/commands/_helpers.py

@@ -2,14 +2,30 @@
 from __future__ import annotations
 
 import json
+import re
+import sys
 from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Union
 
 import click
 
 from pm.client.base import PMApiError
+from pm.output import _safe_text
 
 YES_HELP = "Skip the confirmation prompt. Required when stdin is not a terminal."
 
+_FRACTION = re.compile(r"\.\d+(?=([+-]\d{2}:?\d{2}|Z)?$)")
+
+
+def iso_seconds(value: Optional[str]) -> str:
+    """An ISO timestamp without microseconds; blank when empty."""
+    return _FRACTION.sub("", value) if value else ""
+
+
+def stdin_is_terminal() -> bool:
+    """Whether a person can answer a prompt. Commands that need --yes off a
+    terminal check this BEFORE prompting, so a piped "y" cannot pass."""
+    return sys.stdin.isatty()
+
 
 def json_option(f):
     """Per-command ``--json`` so both ``pm --json report list`` and
@@ -123,7 +139,7 @@ def peek_name(fetch: Callable[[], Any], *fields: str) -> Optional[str]:
 
 def confirm_delete(noun: str, uid: str, name: Optional[str] = None, *, note: str = "") -> None:
     """``Delete <noun> 'name' (uid)? [y/N]`` — abort on anything but yes."""
-    label = f"{name!r} ({uid})" if name else uid
+    label = f"{_safe_text(name)!r} ({uid})" if name else uid
     tail = f" {note}" if note else ""
     click.confirm(f"Delete {noun} {label}?{tail}", abort=True)
 

{pushmetrics_cli-0.1.1 → pushmetrics_cli-0.2.0}/pm/commands/auth.py

@@ -13,7 +13,7 @@ from pm.auth.session import PMSession
 from pm.client import PMClient
 from pm.client.base import PMApiError
 from pm.commands._helpers import info, json_option
-from pm.output import emit
+from pm.output import _safe_text, emit
 
 
 def _read_token(ctx: click.Context) -> str:
@@ -122,9 +122,9 @@ def login(ctx: click.Context, no_browser: bool, use_token: bool) -> None:
     info(ctx, "")
     info(
         ctx,
-        f"Open this URL on any device:    {device_payload.verification_uri_complete}",
+        _safe_text(f"Open this URL on any device:    {device_payload.verification_uri_complete}"),
     )
-    info(ctx, f"Verify it shows the user code:  {device_payload.user_code}")
+    info(ctx, _safe_text(f"Verify it shows the user code:  {device_payload.user_code}"))
     info(ctx, "Waiting for authorization...")
 
     try:

{pushmetrics_cli-0.1.1 → pushmetrics_cli-0.2.0}/pm/commands/db.py

@@ -8,7 +8,7 @@ import click
 from pm._alias import AliasedGroup
 from pm.client import PMClient
 from pm.commands._helpers import json_option, limit_option, name_filter_option, select_rows
-from pm.output import emit
+from pm.output import _safe_lines, _safe_text, emit
 
 
 @click.group(name="db", cls=AliasedGroup, aliases={"ls": "list"})
@@ -120,7 +120,7 @@ def describe(ctx: click.Context, db_ref: str, schema: str, table: str) -> None:
 
     click.echo(f"Table: {schema}.{table}")
     if meta.get("comment"):
-        click.echo(f"Comment: {meta['comment']}")
+        click.echo(_safe_lines(f"Comment: {meta['comment']}"))
 
     cols = meta.get("columns") or []
     if cols:
@@ -148,7 +148,7 @@ def describe(ctx: click.Context, db_ref: str, schema: str, table: str) -> None:
             ref_cols = ", ".join(fk.get("referred_columns") or [])
             ref_schema = fk.get("referred_schema") or ""
             ref_full = f"{ref_schema}.{ref_table}" if ref_schema else ref_table
-            click.echo(f"  ({src}) -> {ref_full}({ref_cols})")
+            click.echo(_safe_text(f"  ({src}) -> {ref_full}({ref_cols})"))
 
 
 @db.command(name="select-star")
@@ -178,7 +178,7 @@ def select_star(
     if json_output:
         emit({"sql": sql}, json_output=True)
         return
-    click.echo(sql)
+    click.echo(_safe_lines(sql))
 
 
 @db.command(name="exists")
@@ -209,7 +209,7 @@ def exists(ctx: click.Context, db_ref: str, schema: str, table: str) -> None:
         return
     kind = info.get("type") or "-"
     resolved = info.get("resolved_name") or "-"
-    click.echo(f"exists={info.get('exists')} type={kind} resolved={resolved}")
+    click.echo(_safe_text(f"exists={info.get('exists')} type={kind} resolved={resolved}"))
     if not info.get("exists"):
         ctx.exit(1)
 
@@ -246,11 +246,11 @@ def functions(ctx: click.Context, db_ref: str, filter_: str, limit: int) -> None
 
     note = result.get("note")
     if note:
-        click.echo(f"Note: {note}")
+        click.echo(_safe_lines(f"Note: {note}"))
         return
 
     for name in result.get("functions") or []:
-        click.echo(name)
+        click.echo(_safe_text(str(name)))
     total = result.get("total", 0)
     count = result.get("count", 0)
     if total and count < total:

pushmetrics_cli-0.2.0/pm/commands/deliverability.py

@@ -0,0 +1,182 @@
+"""`pm deliverability`: email addresses Amazon SES blocks for this workspace.
+
+A thin wrapper over the Recipient API's deliverability routes
+(``superset/pushmetrics/views/recipient/api.py``, ``/recipient/deliverability``,
+``/deliverability/events``, ``/deliverability/unblock``). Labels mirror the web
+app's (``frontend/src/shared/services/emailDeliverabilityApi.ts``) so both say
+the same thing about the same address.
+
+Verbs: list, events EMAIL, unblock EMAIL. ``unblock`` is admin-only; the
+server enforces that (a 403 for anyone else), the CLI only words the refusal.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+import click
+
+from pm._alias import AliasedGroup
+from pm.client import PMClient
+from pm.client.base import PMApiError
+from pm.commands._helpers import info, json_option, yes_option
+from pm.commands._helpers import iso_seconds as _iso
+from pm.commands._helpers import stdin_is_terminal as _stdin_is_terminal
+from pm.errors import describe_api_error
+from pm.output import emit
+
+# Same words as the web app (emailDeliverabilityApi.ts / EmailDeliverability.tsx).
+REASON_LABEL = {"BOUNCE": "Bounced", "COMPLAINT": "Marked as spam"}
+EVENT_LABEL = {
+    "bounce": "Bounced",
+    "complaint": "Marked as spam",
+    "suppressed_drop": "Email dropped (address blocked)",
+    "suppressed": "Blocked by the email provider",
+    "cleared": "Unblocked",
+}
+SOURCE_LABEL = {
+    "manual": "by an admin",
+    "invite": "by inviting the user",
+    "recipient_edit": "by saving the recipient",
+    "retry": "by the automatic retry",
+    "ses_list": "in the email provider",
+    "ses_event": "by the email provider",
+}
+USED_AS_LABEL = {"recipient": "recipient", "user": "user", "block": "email block"}
+
+NOT_CONFIGURED = "Email deliverability is not configured on this deployment."
+EMAIL_HELP = "Email address this workspace sends to."
+
+
+def _api_failure(exc: PMApiError, hint: str) -> click.ClickException:
+    """The API line as describe_api_error writes it (``failed: NNN`` kept,
+    redacted), with this command's own next action as the hint."""
+    first_line = describe_api_error(exc, group="deliverability").split("\n", 1)[0]
+    return click.ClickException(f"{first_line}\nHint: {hint}")
+
+
+_NOT_IN_WORKSPACE = (
+    "That address is not one this workspace sends to (a recipient, user or "
+    "email block). `pm deliverability list` shows the blocked ones."
+)
+
+
+@click.group(name="deliverability", cls=AliasedGroup, aliases={"ls": "list"})
+def deliverability() -> None:
+    """Email deliverability: addresses the email provider blocks.
+
+    Amazon SES stops sending to an address after a hard bounce or a spam
+    complaint. These commands show which addresses this workspace sends to
+    are blocked, why, and let an admin unblock one.
+    """
+
+
+_LIST_COLUMNS = [
+    ("EMAIL", "email"),
+    ("STATUS", "status"),
+    ("REASON", lambda r: REASON_LABEL.get(r.get("reason") or "", "Blocked")),
+    ("BLOCKED_SINCE", lambda r: _iso(r.get("blocked_since"))),
+    ("USED_AS", lambda r: ", ".join(USED_AS_LABEL.get(u, u) for u in r.get("used_as") or [])),
+    ("REPORTS", lambda r: ", ".join(rep.get("name") or rep.get("uid") or "" for rep in r.get("reports") or [])),
+]
+
+
+@deliverability.command(name="list")
+@json_option
+@click.pass_context
+def list_cmd(ctx: click.Context) -> None:
+    """List the addresses this workspace sends to that are blocked.
+
+    Each row says why (bounced or marked as spam), since when, where the
+    address is used and which reports send to it. --json prints the full rows.
+    Fails if email deliverability is not configured on this deployment.
+    """
+    client = PMClient.from_profile(ctx.obj["profile"])
+    body = client.deliverability.list()
+    client.persist()
+    rows: List[Dict[str, Any]] = body.get("result") or []
+    if body.get("enabled") is False:
+        # Nothing is tracked: the command cannot answer, so it fails (exit 1,
+        # also under --quiet and --json). An empty table or [] would wrongly
+        # read as "nothing blocked". Same state as unblock's 503.
+        raise click.ClickException(NOT_CONFIGURED)
+    emit(rows, json_output=ctx.obj["json"], columns=_LIST_COLUMNS)
+
+
+def _event_label(event: Dict[str, Any]) -> str:
+    label = EVENT_LABEL.get(event.get("event_type") or "", event.get("event_type") or "")
+    if event.get("event_type") == "cleared" and event.get("source") in SOURCE_LABEL:
+        label = f"{label} {SOURCE_LABEL[event['source']]}"
+    return label
+
+
+_EVENT_COLUMNS = [
+    ("WHEN", lambda e: _iso(e.get("occurred_at"))),
+    ("EVENT", _event_label),
+    ("DETAIL", lambda e: e.get("diagnostic") or e.get("sub_type") or ""),
+]
+
+
+@deliverability.command(name="events")
+@click.argument("email", metavar="EMAIL")
+@json_option
+@click.pass_context
+def events(ctx: click.Context, email: str) -> None:
+    """Show the bounce, complaint and unblock history of one address.
+
+    Newest event last, up to the latest 20.
+
+    EMAIL: Email address this workspace sends to.
+    """
+    client = PMClient.from_profile(ctx.obj["profile"])
+    try:
+        body = client.deliverability.events(email)
+    except PMApiError as exc:
+        if exc.status == 404:
+            raise _api_failure(exc, _NOT_IN_WORKSPACE)
+        raise
+    client.persist()
+    # The server sends newest first; a log reads oldest to newest.
+    rows = list(reversed(body.get("result") or []))
+    emit(rows, json_output=ctx.obj["json"], columns=_EVENT_COLUMNS)
+
+
+@deliverability.command(name="unblock")
+@click.argument("email", metavar="EMAIL")
+@yes_option
+@json_option
+@click.pass_context
+def unblock(ctx: click.Context, email: str, yes: bool) -> None:
+    """Unblock an address so this workspace's email reaches it again.
+
+    Admins only. The address gets mail again from the next send; if it still
+    bounces or the person marks a message as spam, the email provider blocks
+    it again.
+
+    EMAIL: Email address this workspace sends to.
+    """
+    if not yes:
+        # Checked before the prompt, so a piped "y" cannot pass for a person.
+        if not _stdin_is_terminal():
+            raise click.ClickException(
+                "Not unblocked: pm deliverability unblock needs --yes when stdin is not a terminal."
+            )
+        click.confirm(f"Unblock {email}?", abort=True)
+    client = PMClient.from_profile(ctx.obj["profile"])
+    try:
+        body = client.deliverability.unblock(email)
+    except PMApiError as exc:
+        if exc.status == 403:
+            raise _api_failure(exc, "Unblocking an address needs an admin role in this workspace.")
+        if exc.status == 404:
+            raise _api_failure(exc, _NOT_IN_WORKSPACE)
+        if exc.status == 503:
+            # The server's sentence is the whole story ("Email deliverability
+            # is not configured on this deployment."); the generic 5xx hint
+            # ("retry in a minute") would be wrong, retrying cannot help.
+            raise click.ClickException(describe_api_error(exc, group="deliverability").split("\n", 1)[0])
+        raise
+    client.persist()
+    if ctx.obj["json"]:
+        emit(body.get("result") or {"email": email}, json_output=True)
+        return
+    info(ctx, f"Unblocked {email}. The next email to it will be sent.")

{pushmetrics_cli-0.1.1 → pushmetrics_cli-0.2.0}/pm/commands/help.py

@@ -373,6 +373,34 @@ _GROUP_PAGES: Dict[str, Dict] = {
         ),
         "summary": "Recipients (delivery-target CRM).",
     },
+    "schedule": {
+        "verbs": {
+            "list":   "Schedules. [--report <uid>].",
+            "get":    "Show one. <uid>.",
+            "create": "--report <uid> --rrule '<DTSTART RRULE>' [--name <n>]. Prints uid.",
+            "update": "Change the rule. <uid> --rrule '<DTSTART RRULE>'.",
+            "run":    "Run now; delivers to all its destinations. <uid> --yes (needed off a terminal).",
+            "pause":  "Stop it running. <uid>.",
+            "resume": "Start it again. <uid>.",
+        },
+        "example": (
+            "  pm schedule list --report <report_uid> --json\n"
+            "  pm schedule pause <uid>"
+        ),
+        "summary": "Schedules: when a report runs on its own.",
+    },
+    "deliverability": {
+        "verbs": {
+            "list":    "Blocked addresses this workspace sends to, with reason and reports.",
+            "events":  "History of one address, newest last. <email>.",
+            "unblock": "Unblock an address (admins only). <email> [--yes].",
+        },
+        "example": (
+            "  pm deliverability list --json\n"
+            "  pm deliverability unblock alice@example.com --yes"
+        ),
+        "summary": "Email addresses the email provider blocks.",
+    },
     "integration": {
         "verbs": {
             "list": "Workspace integrations (Tableau / Slack / Email / SFTP / GCP / S3 / Slides etc.). [--name <text>] [--type <t>] [--limit <n>].",

{pushmetrics_cli-0.1.1 → pushmetrics_cli-0.2.0}/pm/commands/reports.py

@@ -22,7 +22,7 @@ from pm.commands._helpers import (
     name_filter_option,
     select_rows,
 )
-from pm.output import emit
+from pm.output import _safe_lines, _safe_text, emit
 
 
 @click.group(name="reports", cls=AliasedGroup, aliases={"ls": "list"})
@@ -163,6 +163,7 @@ def yaml_(ctx: click.Context, uid: str) -> None:
     client = PMClient.from_profile(profile)
     yaml_text = client.reports.yaml(uid)
     client.persist()
+    yaml_text = _safe_lines(yaml_text)
     # Write directly to avoid emit's trailing newline (YAML already has one).
     sys.stdout.write(yaml_text)
     if not yaml_text.endswith("\n"):
@@ -285,21 +286,21 @@ def apply(
             return
         summary = result.get("summary") or {}
         for k, v in summary.items():
-            click.echo(f"  {k}: {v}")
+            click.echo(_safe_text(f"  {k}: {v}"))
         diff = result.get("yaml_diff", "")
         if diff:
             click.echo("")
-            click.echo(diff)
+            click.echo(_safe_lines(diff))
         return
 
     res_uid = result.get("uid", "")
     res_name = result.get("name", "")
-    click.echo(f"{action}: {res_uid}  {res_name}")
+    click.echo(_safe_text(f"{action}: {res_uid}  {res_name}"))
     warn = result.get("warning_duplicate_uids")
     if warn:
         click.echo(
             f"  warning: {len(warn)} existing report(s) with the same name in this workspace: "
-            + ", ".join(warn)
+            + _safe_text(", ".join(str(w) for w in warn))
             + "  -- use `pm report apply ... --uid <one>` to update instead."
         )
 

{pushmetrics_cli-0.1.1 → pushmetrics_cli-0.2.0}/pm/commands/roles.py

@@ -9,7 +9,7 @@ from pm._alias import AliasedGroup
 from pm.client import PMClient
 from pm.client.roles import MAIN_ROLE_NAMES
 from pm.commands._helpers import json_option, limit_option, name_filter_option, select_rows
-from pm.output import emit
+from pm.output import _safe_text, emit
 
 
 @click.group(name="roles", cls=AliasedGroup, aliases={"ls": "list"})
@@ -74,7 +74,7 @@ def assign(ctx: click.Context, role_ref: str, user_uids: tuple) -> None:
         return
     role_info = result.get("role") if isinstance(result, dict) else None
     role_name = (role_info or {}).get("name", role_ref)
-    click.echo(f"Assigned {len(user_uids)} user(s) to role {role_name!r}.", err=True)
+    click.echo(f"Assigned {len(user_uids)} user(s) to role {_safe_text(str(role_name))!r}.", err=True)
 
 
 @roles.command(name="revoke")
@@ -99,4 +99,4 @@ def revoke(ctx: click.Context, role_ref: str, user_uids: tuple) -> None:
         return
     role_info = result.get("role") if isinstance(result, dict) else None
     role_name = (role_info or {}).get("name", role_ref)
-    click.echo(f"Removed {len(user_uids)} user(s) from role {role_name!r}.", err=True)
+    click.echo(f"Removed {len(user_uids)} user(s) from role {_safe_text(str(role_name))!r}.", err=True)