lxw-cli 0.1.0__py3-none-any.whl

lxw_cli/__init__.py

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

lxw_cli/__main__.py

@@ -0,0 +1,4 @@
+from lxw_cli.cli import app
+
+if __name__ == "__main__":
+    app()

lxw_cli/cli.py

@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+import typer
+
+from lxw_cli import __version__
+from lxw_cli.commands import (
+    articles,
+    contacts,
+    delivery_notes,
+    invoices,
+    orders,
+    quotations,
+    vouchers,
+)
+from lxw_cli.commands import (
+    mcp as mcp_cmd,
+)
+from lxw_cli.config import load_config_interactive
+from lxw_cli.core import services
+from lxw_cli.core.client import LexwareClient
+from lxw_cli.core.errors import LexwareAPIError, LexwareError
+from lxw_cli.output import OutputFormat, err_console, render, working
+
+app = typer.Typer(
+    name="lxw",
+    help=(
+        "CLI für die Lexware Office API (https://developers.lexware.io/).\n\n"
+        "Liest Rechnungen, Kontakte, Belege, Artikel, Angebote und Lieferscheine "
+        "und legt Drafts/Stammdaten an. Globale Ausgabe-Optionen (--json, --csv, "
+        "--output) stehen vor dem Befehl; Detailhilfe je Befehl mit "
+        "'lxw <befehl> <unterbefehl> --help'."
+    ),
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+    pretty_exceptions_show_locals=False,
+    epilog="""\
+[bold cyan]Beispiele[/bold cyan]
+
+Auth-Test (Firmenprofil): [green]lxw profile[/green]
+
+Offene Rechnungen: [green]lxw invoices list --status open[/green]
+
+Artikel suchen: [green]lxw articles list --search schraube[/green]
+
+Kunden als CSV: [green]lxw --csv -o kunden.csv contacts list --customer --all[/green]
+
+Claude-Integration einrichten: [green]lxw mcp install-claude[/green]
+""",
+)
+
+
+@dataclass
+class AppState:
+    output_format: OutputFormat
+    output_path: Path | None
+    _client: LexwareClient | None = None
+
+    @property
+    def client(self) -> LexwareClient:
+        if self._client is None:
+            try:
+                config = load_config_interactive()
+            except LexwareError as exc:
+                err_console.print(f"[red]Fehler:[/red] {exc}")
+                raise typer.Exit(code=2) from exc
+            self._client = LexwareClient(config)
+        return self._client
+
+    def close(self) -> None:
+        if self._client is not None:
+            self._client.close()
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"lxw-cli {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    json_out: bool = typer.Option(
+        False, "--json", help="JSON statt Tabelle ausgeben.", rich_help_panel="Output"
+    ),
+    csv_out: bool = typer.Option(
+        False, "--csv", help="CSV statt Tabelle ausgeben.", rich_help_panel="Output"
+    ),
+    output: Path | None = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="In Datei schreiben statt auf stdout.",
+        rich_help_panel="Output",
+    ),
+    _version: bool = typer.Option(
+        False,
+        "--version",
+        "-V",
+        callback=_version_callback,
+        is_eager=True,
+        help="Version anzeigen und beenden.",
+    ),
+) -> None:
+    if json_out and csv_out:
+        raise typer.BadParameter("--json und --csv schließen sich gegenseitig aus.")
+    fmt = (
+        OutputFormat.JSON
+        if json_out
+        else OutputFormat.CSV
+        if csv_out
+        else OutputFormat.TABLE
+    )
+
+    state = AppState(output_format=fmt, output_path=output)
+    ctx.obj = state
+    ctx.call_on_close(state.close)
+
+
+@app.command("profile")
+def profile_cmd(ctx: typer.Context) -> None:
+    """Firmenprofil abrufen (Auth-Test)."""
+    state: AppState = ctx.obj
+    with working("Lade Firmenprofil …"):
+        data = services.get_profile(state.client)
+    render(data, state.output_format, output_path=state.output_path)
+
+
+@app.command("version")
+def version_cmd() -> None:
+    """Version anzeigen."""
+    typer.echo(__version__)
+
+
+app.add_typer(
+    invoices.app,
+    name="invoices",
+    help="Rechnungen: list/get/pdf/create-draft. Listen mit --status/--number/--all.",
+)
+app.add_typer(
+    contacts.app,
+    name="contacts",
+    help="Kontakte: list/get/create. Nur Kunden/Lieferanten mit --customer/--vendor.",
+)
+app.add_typer(
+    vouchers.app,
+    name="vouchers",
+    help="Belege: list/get/create-draft. Listen mit --type/--status/--number, --all.",
+)
+app.add_typer(
+    articles.app,
+    name="articles",
+    help="Artikel: list/get/create. Volltextsuche mit 'list --search/-q'.",
+)
+app.add_typer(
+    quotations.app, name="quotations", help="Angebote: list/get/pdf/create-draft, --all."
+)
+app.add_typer(
+    orders.app,
+    name="orders",
+    help="Aufträge (Auftragsbestätigungen): list/get/pdf/create-draft, --all.",
+)
+app.add_typer(
+    delivery_notes.app,
+    name="delivery-notes",
+    help="Lieferscheine: list/get/pdf/create-draft, --all.",
+)
+app.add_typer(mcp_cmd.app, name="mcp", help="MCP-Server-Integration für Claude.")
+
+
+def _wants_tui(argv: list[str], *, stdin_tty: bool, stdout_tty: bool) -> bool:
+    """Decide whether the bare `lxw` invocation should open the TUI.
+
+    Only when there are no subcommands/arguments AND we're on a real interactive
+    terminal (both stdin and stdout). With arguments it's the CLI; when stdout
+    isn't a TTY (piping, scripting) it stays the CLI (Typer prints help) — never
+    the TUI, never an error.
+    """
+    return len(argv) <= 1 and stdin_tty and stdout_tty
+
+
+def _run() -> None:  # pragma: no cover
+    if _wants_tui(
+        sys.argv, stdin_tty=sys.stdin.isatty(), stdout_tty=sys.stdout.isatty()
+    ):
+        from lxw_cli.tui.app import run as run_tui
+
+        run_tui()
+        return
+    try:
+        app()
+    except LexwareAPIError as exc:
+        err_console.print(f"[red]API-Fehler:[/red] {exc}")
+        if isinstance(exc.body, dict) and exc.body:
+            err_console.print(exc.body)
+        raise SystemExit(1) from exc
+    except LexwareError as exc:
+        err_console.print(f"[red]Fehler:[/red] {exc}")
+        raise SystemExit(1) from exc
+
+
+if __name__ == "__main__":  # pragma: no cover
+    _run()

lxw_cli/commands/_common.py

@@ -0,0 +1,40 @@
+"""CLI glue shared by the command modules.
+
+The UI-agnostic logic lives in :mod:`lxw_cli.core`. This module keeps only
+the Typer-coupled helpers (``state``, ``load_json_arg``) and the archived-footer
+display string.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import typer
+
+if TYPE_CHECKING:
+    from lxw_cli.cli import AppState
+
+# Footer hint shown when archived records are filtered out by default.
+ARCHIVED_HINT = "ohne archivierte (--include-archived zeigt alle)"
+
+
+def state(ctx: typer.Context) -> AppState:
+    return ctx.obj
+
+
+def load_json_arg(value: str) -> Any:
+    """Load a JSON value either inline or from @path."""
+    if value.startswith("@"):
+        path = Path(value[1:]).expanduser()
+        try:
+            return json.loads(path.read_text(encoding="utf-8"))
+        except FileNotFoundError as exc:
+            raise typer.BadParameter(f"Datei nicht gefunden: {path}") from exc
+        except json.JSONDecodeError as exc:
+            raise typer.BadParameter(f"Ungültiges JSON in {path}: {exc}") from exc
+    try:
+        return json.loads(value)
+    except json.JSONDecodeError as exc:
+        raise typer.BadParameter(f"Ungültiges JSON: {exc}") from exc

lxw_cli/commands/articles.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import typer
+
+from lxw_cli.commands._common import load_json_arg, state
+from lxw_cli.core import services
+from lxw_cli.output import print_count, render, working
+
+app = typer.Typer(no_args_is_help=True)
+
+LIST_COLUMNS = ["id", "type", "title", "articleNumber", "gtin", "unitName"]
+
+
+@app.command(
+    "list",
+    epilog="""\
+[bold cyan]Beispiele[/bold cyan]
+
+Volltextsuche nach Bezeichnung: [green]lxw articles list --search schraube[/green]
+
+Teil-Artikelnummer: [green]lxw articles list -q SCH-[/green]
+
+Exakte Artikelnummer (schnell): [green]lxw articles list --number SCH-001[/green]
+
+Nur Dienstleistungen, alle: [green]lxw articles list --type service --all[/green]
+""",
+)
+def list_articles(
+    ctx: typer.Context,
+    limit: int = typer.Option(
+        25, "--limit", "-n", help="Maximale Anzahl Einträge (0 = alle)."
+    ),
+    fetch_all: bool = typer.Option(
+        False, "--all", "-a", help="Alle Treffer laden (überschreibt --limit)."
+    ),
+    search: str | None = typer.Option(
+        None,
+        "--search",
+        "-q",
+        help="Freitext in Bezeichnung, Beschreibung und Artikelnummer (Teiltreffer).",
+    ),
+    article_type: str | None = typer.Option(None, "--type", help="product|service"),
+    article_number: str | None = typer.Option(
+        None, "--number", help="Exakte Artikelnummer (serverseitig)."
+    ),
+    gtin: str | None = typer.Option(None, "--gtin", help="Exakte GTIN/EAN (serverseitig)."),
+) -> None:
+    """Artikel auflisten.
+
+    Zeigt standardmäßig bis zu 25 Artikel (--all bzw. --limit 0 lädt alle).
+    Die Lexware-API filtert nur exakt: --number (Artikelnummer), --gtin und
+    --type (product|service).
+
+    Für eine unscharfe Suche gibt es --search/-q: durchsucht clientseitig
+    Bezeichnung, Beschreibung und Artikelnummer nach Teiltreffern (Groß-/
+    Kleinschreibung egal) und zeigt am Ende die Trefferzahl.
+    """
+    s = state(ctx)
+    with working("Suche Artikel …" if search else "Lade Artikel …"):
+        result = services.list_articles(
+            s.client,
+            search=search,
+            article_type=article_type,
+            article_number=article_number,
+            gtin=gtin,
+            limit=limit,
+            fetch_all=fetch_all,
+        )
+    render(result.items, s.output_format, columns=LIST_COLUMNS, output_path=s.output_path)
+    if result.search:
+        # Client-side search: the API total counts all articles, not matches.
+        print_count(len(result.items), noun="Treffer")
+    else:
+        print_count(len(result.items), result.total, noun="Artikel")
+
+
+@app.command("get")
+def get_article(ctx: typer.Context, article_id: str) -> None:
+    """Einen Artikel im Detail abrufen."""
+    s = state(ctx)
+    with working("Lade Artikel …"):
+        data = services.get_article(s.client, article_id)
+    render(data, s.output_format, output_path=s.output_path)
+
+
+@app.command(
+    "create",
+    epilog="""\
+[bold cyan]Beispiele[/bold cyan]
+
+Aus Datei: [green]lxw articles create --body @artikel.json[/green]
+
+Inline-Minimal: [green]lxw articles create --body '{"type":"SERVICE","title":"…"}'[/green]
+""",
+)
+def create(
+    ctx: typer.Context,
+    body: str = typer.Option(..., "--body", help="JSON-Body inline oder @datei.json."),
+) -> None:
+    """Neuen Artikel anlegen (Stammdaten, kein Draft).
+
+    Erwartet den JSON-Body der Lexware-API — inline oder als @pfad.json
+    (type PRODUCT|SERVICE, title, unitName, price …). Schema siehe
+    https://developers.lexware.io/docs/.
+    """
+    s = state(ctx)
+    payload = load_json_arg(body)
+    with working("Lege Artikel an …"):
+        result = services.create_article(s.client, payload)
+    render(result, s.output_format, output_path=s.output_path)

lxw_cli/commands/contacts.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+
+from typing import Any
+
+import typer
+
+from lxw_cli.commands._common import load_json_arg, state
+from lxw_cli.core import services
+from lxw_cli.output import OutputFormat, err_console, print_count, render, working
+
+app = typer.Typer(no_args_is_help=True)
+
+LIST_COLUMNS = ["id", "name", "role", "number", "email", "archived"]
+
+
+@app.command(
+    "list",
+    epilog="""\
+[bold cyan]Beispiele[/bold cyan]
+
+Nur Kunden: [green]lxw contacts list --customer[/green]
+
+Nur Lieferanten: [green]lxw contacts list --vendor[/green]
+
+Nach Name suchen: [green]lxw contacts list --name Müller[/green]
+
+Getrennt nach Rolle: [green]lxw contacts list --grouped[/green]
+
+Inkl. archivierte (CSV): [green]lxw --csv contacts list --all --include-archived[/green]
+""",
+)
+def list_contacts(
+    ctx: typer.Context,
+    limit: int = typer.Option(
+        25, "--limit", "-n", help="Maximale Anzahl Einträge (0 = alle)."
+    ),
+    fetch_all: bool = typer.Option(
+        False, "--all", "-a", help="Alle Treffer laden (überschreibt --limit)."
+    ),
+    name: str | None = typer.Option(None, "--name", help="Filter nach Name (min. 3 Zeichen)."),
+    email: str | None = typer.Option(None, "--email", help="Filter nach E-Mail (min. 3 Zeichen)."),
+    number: str | None = typer.Option(None, "--number", help="Kunden-/Lieferantennummer."),
+    customer: bool = typer.Option(False, "--customer", help="Nur Kunden."),
+    vendor: bool = typer.Option(False, "--vendor", help="Nur Lieferanten."),
+    grouped: bool = typer.Option(
+        False,
+        "--grouped/--flat",
+        help="Tabelle nach Kunden/Lieferanten gruppieren (Standard: aus).",
+    ),
+    include_archived: bool = typer.Option(
+        False,
+        "--include-archived",
+        help="Auch archivierte Kontakte anzeigen (Standard: ausgeblendet).",
+    ),
+) -> None:
+    """Kontakte auflisten.
+
+    Zeigt standardmäßig bis zu 25 Kontakte als eine zusammenhängende Liste
+    (--all bzw. --limit 0 lädt alle). Filtern nach Name/E-Mail (je min. 3
+    Zeichen), Nummer oder Rolle: --customer zeigt nur Kunden, --vendor nur
+    Lieferanten.
+
+    Mit --grouped wird die Tabelle in zwei Abschnitte geteilt (zuerst Kunden,
+    dann Lieferanten, je mit passender Nummer). Archivierte Kontakte sind
+    standardmäßig ausgeblendet; --include-archived zeigt sie. JSON/CSV sind
+    immer eine flache Liste mit role-Spalte.
+    """
+    s = state(ctx)
+    with working("Lade Kontakte …"):
+        result = services.list_contacts(
+            s.client,
+            name=name,
+            email=email,
+            number=number,
+            customer=customer,
+            vendor=vendor,
+            include_archived=include_archived,
+            limit=limit,
+            fetch_all=fetch_all,
+        )
+    raw = result.items
+
+    if grouped and s.output_format is OutputFormat.TABLE:
+        _render_grouped(raw)
+    else:
+        items = [_flatten_contact(c) for c in raw]
+        render(items, s.output_format, columns=LIST_COLUMNS, output_path=s.output_path)
+
+    if include_archived:
+        print_count(len(raw), result.total, noun="Kontakte")
+    elif result.exhausted:
+        suffix = f" ({result.hidden} archivierte ausgeblendet)" if result.hidden else ""
+        err_console.print(
+            f"[dim]→ {len(raw)} von {len(raw)} aktiven Kontakten{suffix}[/dim]"
+        )
+    else:
+        err_console.print(
+            f"[dim]→ {len(raw)} aktive Kontakte angezeigt "
+            "(archivierte ausgeblendet · --all für Gesamtzahl, "
+            "--include-archived zeigt alle)[/dim]"
+        )
+
+
+def _render_grouped(raw: list[Any]) -> None:
+    """Render contacts as separate Kunden / Lieferanten tables.
+
+    A contact with both roles appears in both tables (its `role` column shows
+    'customer+vendor'), and each table shows the number for its own role.
+    Contacts without any role land in a trailing 'Ohne Rolle' table.
+    """
+    sections = (("Kunden", "customer"), ("Lieferanten", "vendor"))
+    rendered = False
+    for title, role in sections:
+        rows = [
+            _flatten_contact(c, number_role=role)
+            for c in raw
+            if role in (c.get("roles") or {})
+        ]
+        if rows:
+            render(rows, OutputFormat.TABLE, columns=LIST_COLUMNS, title=title)
+            rendered = True
+    others = [_flatten_contact(c) for c in raw if not (c.get("roles") or {})]
+    if others:
+        render(others, OutputFormat.TABLE, columns=LIST_COLUMNS, title="Ohne Rolle")
+        rendered = True
+    if not rendered:
+        render([], OutputFormat.TABLE, columns=LIST_COLUMNS)
+
+
+@app.command("get")
+def get_contact(ctx: typer.Context, contact_id: str) -> None:
+    """Einen Kontakt im Detail abrufen."""
+    s = state(ctx)
+    with working("Lade Kontakt …"):
+        data = services.get_contact(s.client, contact_id)
+    render(data, s.output_format, output_path=s.output_path)
+
+
+@app.command(
+    "create",
+    epilog="""\
+[bold cyan]Beispiele[/bold cyan]
+
+Kunde aus Datei: [green]lxw contacts create --body @kunde.json[/green]
+
+Lieferant aus Datei: [green]lxw contacts create --body @lieferant.json[/green]
+""",
+)
+def create(
+    ctx: typer.Context,
+    body: str = typer.Option(..., "--body", help="JSON-Body inline oder @datei.json."),
+) -> None:
+    """Neuen Kontakt anlegen (Stammdaten, kein Draft).
+
+    Erwartet den JSON-Body der Lexware-API — inline oder als @pfad.json. Mit
+    'roles' wird die Rolle gesetzt: {"customer":{}} und/oder {"vendor":{}}.
+    Minimal: {"roles":{"customer":{}},"company":{"name":"…"}}.
+    """
+    s = state(ctx)
+    payload = load_json_arg(body)
+    with working("Lege Kontakt an …"):
+        result = services.create_contact(s.client, payload)
+    render(result, s.output_format, output_path=s.output_path)
+
+
+def _flatten_contact(
+    c: dict[str, Any], number_role: str | None = None
+) -> dict[str, Any]:
+    """Project nested contact fields into a flat row for table/CSV display.
+
+    `number_role` ('customer' or 'vendor') picks which role's number to show —
+    used by the grouped view so the Lieferanten table shows vendor numbers and
+    the Kunden table shows customer numbers. When None, the customer number is
+    preferred, then the vendor number.
+    """
+    company = c.get("company") or {}
+    person = c.get("person") or {}
+    roles = c.get("roles") or {}
+    emails = (c.get("emailAddresses") or {}).get("business") or []
+
+    if company.get("name"):
+        name = company["name"]
+    elif person:
+        name = " ".join(
+            p for p in (person.get("firstName"), person.get("lastName")) if p
+        ).strip()
+    else:
+        name = ""
+
+    if "customer" in roles and "vendor" in roles:
+        role = "customer+vendor"
+    elif "customer" in roles:
+        role = "customer"
+    elif "vendor" in roles:
+        role = "vendor"
+    else:
+        role = ""
+
+    if number_role is not None:
+        number = (roles.get(number_role) or {}).get("number") or ""
+    else:
+        number = (
+            (roles.get("customer") or {}).get("number")
+            or (roles.get("vendor") or {}).get("number")
+            or ""
+        )
+
+    return {
+        "id": c.get("id"),
+        "name": name,
+        "role": role,
+        "number": number,
+        "email": emails[0] if emails else "",
+        "archived": c.get("archived"),
+    }

lxw_cli/commands/delivery_notes.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from lxw_cli.commands._common import ARCHIVED_HINT, load_json_arg, state
+from lxw_cli.core import services
+from lxw_cli.core.constants import DEFAULT_VOUCHER_STATUSES
+from lxw_cli.output import print_count, render, working, write_binary
+
+app = typer.Typer(no_args_is_help=True)
+
+LIST_COLUMNS = [
+    "id",
+    "voucherNumber",
+    "voucherDate",
+    "voucherStatus",
+    "contactName",
+]
+
+
+@app.command(
+    "list",
+    epilog="""\
+[bold cyan]Beispiele[/bold cyan]
+
+Alle Lieferscheine: [green]lxw delivery-notes list --all[/green]
+
+Als CSV exportieren: [green]lxw --csv -o lieferscheine.csv delivery-notes list --all[/green]
+
+Inkl. archivierte: [green]lxw delivery-notes list --include-archived[/green]
+""",
+)
+def list_delivery_notes(
+    ctx: typer.Context,
+    limit: int = typer.Option(
+        25, "--limit", "-n", help="Maximale Anzahl Einträge (0 = alle)."
+    ),
+    fetch_all: bool = typer.Option(
+        False, "--all", "-a", help="Alle Treffer laden (überschreibt --limit)."
+    ),
+    voucher_status: str = typer.Option(
+        DEFAULT_VOUCHER_STATUSES,
+        "--status",
+        help="Komma-separiert (z.B. draft,open,paid).",
+    ),
+    include_archived: bool = typer.Option(
+        False,
+        "--include-archived",
+        help="Auch archivierte Lieferscheine anzeigen (Standard: ausgeblendet).",
+    ),
+) -> None:
+    """Lieferscheine auflisten (über /v1/voucherlist).
+
+    Standardmäßig bis zu 25 Lieferscheine (--all bzw. --limit 0 lädt alle),
+    filterbar nach Status. Archivierte sind standardmäßig ausgeblendet;
+    --include-archived zeigt sie. get/pdf akzeptieren UUID oder Nummer.
+    """
+    s = state(ctx)
+    with working("Lade Lieferscheine …"):
+        result = services.list_delivery_notes(
+            s.client,
+            status=voucher_status,
+            include_archived=include_archived,
+            limit=limit,
+            fetch_all=fetch_all,
+        )
+    render(result.items, s.output_format, columns=LIST_COLUMNS, output_path=s.output_path)
+    note = None if include_archived else ARCHIVED_HINT
+    print_count(len(result.items), result.total, noun="Lieferscheine", note=note)
+
+
+@app.command("get")
+def get_delivery_note(
+    ctx: typer.Context,
+    delivery_note: str = typer.Argument(..., help="UUID oder Lieferschein-Nummer."),
+) -> None:
+    """Einen Lieferschein im Detail abrufen. Akzeptiert UUID oder Nummer."""
+    s = state(ctx)
+    with working("Lade Lieferschein …"):
+        data = services.get_delivery_note(s.client, delivery_note)
+    render(data, s.output_format, output_path=s.output_path)
+
+
+@app.command("pdf")
+def download_pdf(
+    ctx: typer.Context,
+    delivery_note: str = typer.Argument(..., help="UUID oder Lieferschein-Nummer."),
+    output: Path | None = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Ziel-Datei oder -Verzeichnis (Standard: aktuelles Verzeichnis).",
+    ),
+) -> None:
+    """PDF eines Lieferscheins herunterladen. Akzeptiert UUID oder Nummer."""
+    s = state(ctx)
+    with working("Lade PDF …"):
+        data = services.download_delivery_note_pdf(s.client, delivery_note)
+    write_binary(data, output, default_name=f"deliverynote-{delivery_note}.pdf")
+
+
+@app.command("create-draft")
+def create_draft(
+    ctx: typer.Context,
+    body: str = typer.Option(..., "--body", help="JSON-Body inline oder @datei.json."),
+) -> None:
+    """Neuen Lieferschein als Draft anlegen."""
+    s = state(ctx)
+    payload = load_json_arg(body)
+    with working("Lege Lieferschein an …"):
+        result = services.create_delivery_note(s.client, payload)
+    render(result, s.output_format, output_path=s.output_path)