impreza-cli 0.3.0__py3-none-any.whl

impreza_cli/commands/catalog.py

@@ -0,0 +1,270 @@
+"""``impreza catalog`` subcommand surface — Phase 2.3.
+
+Three verbs reading from :class:`impreza.resources.catalog.CatalogResource`:
+
+* ``impreza catalog products [--group X] [--type T]``
+* ``impreza catalog product-groups``
+* ``impreza catalog tlds [--filter .com,.net,...]``
+
+The catalog is reference data — values change only when staff edit
+Impreza Account, not as a side effect of customer activity. These commands are
+the discovery layer customers use before placing orders (Phase 3).
+
+VPS-Cloud catalog (sizes / locations) is deliberately deferred —
+the underlying Cloud backend endpoints exist but return a deeply-
+nested provider-specific shape that warrants its own focused pass
+once Phase 3 ordering creates real demand for it.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import typer
+from impreza.exceptions import ApiError
+from impreza.models.product import Product
+from impreza.models.tld import TldPricing
+
+from ..output import OutputFormat, print_table
+from ..sdk import make_client_or_exit
+from ..state import from_typer_context, resolve_output
+from ._helpers import exit_on_api_error as _exit_on_api_error
+
+app = typer.Typer(
+    name="catalog",
+    help="Browse the product catalog, product groups, and TLD pricing.",
+    no_args_is_help=True,
+)
+
+
+# ── catalog products ─────────────────────────────────────────────────
+
+
+def _cheapest_cycle(product: Product) -> str:
+    """Format the cheapest billing cycle as a single-cell table value
+    (``monthly: 5.00``). Returns ``"-"`` for products with no
+    pricing configured (free or quote-only)."""
+    if not product.pricing:
+        return "-"
+    cycle, price = min(
+        product.pricing.items(),
+        key=lambda kv: kv[1].price,
+    )
+    return f"{cycle}: {price.price:.2f}"
+
+
+@app.command("products")
+def products(
+    typer_ctx: typer.Context,
+    group: str | None = typer.Option(
+        None,
+        "--group",
+        "-g",
+        help="Filter by product group name (case-insensitive substring match upstream).",
+    ),
+    type_: str | None = typer.Option(
+        None,
+        "--type",
+        "-t",
+        help=(
+            "Filter by product type. One of: hostingaccount, "
+            "reselleraccount, server, other."
+        ),
+    ),
+    output: OutputFormat | None = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Output format. Overrides the global --output flag.",
+        case_sensitive=False,
+    ),
+) -> None:
+    """List products in the catalog with their cheapest cycle price.
+
+    Wraps ``GET /products``. Table mode shows id / name / group /
+    type / currency / cheapest-cycle. JSON / YAML modes emit the full
+    Product model (including the per-cycle pricing dict) so callers
+    can pick out a specific cycle for ordering.
+    """
+    state = from_typer_context(typer_ctx)
+    fmt = resolve_output(state, output)
+
+    with make_client_or_exit(state) as client:
+        try:
+            items = client.catalog.products(group=group, type=type_)
+        except ApiError as exc:
+            _exit_on_api_error(exc)
+
+    if not items:
+        if group or type_:
+            filters = []
+            if group:
+                filters.append(f"group={group!r}")
+            if type_:
+                filters.append(f"type={type_!r}")
+            typer.echo(f"No products match the filter: {', '.join(filters)}.")
+        else:
+            typer.echo("No products in the catalog yet.")
+        return
+
+    if fmt is OutputFormat.TABLE:
+        rows: list[dict[str, Any]] = [
+            {
+                "id": p.id,
+                "name": p.name,
+                "group": p.group,
+                "type": p.type,
+                "currency": p.currency,
+                "cheapest": _cheapest_cycle(p),
+            }
+            for p in items
+        ]
+        print_table(
+            f"Products ({len(rows)})",
+            rows,
+            columns=["id", "name", "group", "type", "currency", "cheapest"],
+            fmt=fmt,
+        )
+    else:
+        # JSON / YAML: emit the full model — by_alias=False, so callers
+        # see Python attribute names (`register_prices` etc.). The
+        # Pydantic dump preserves the per-cycle pricing dict so callers
+        # can pick a specific cycle for ordering.
+        rows = [p.model_dump() for p in items]
+        print_table("Products", rows, fmt=fmt)
+
+
+# ── catalog product-groups ───────────────────────────────────────────
+
+
+@app.command("product-groups")
+def product_groups(
+    typer_ctx: typer.Context,
+    output: OutputFormat | None = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Output format. Overrides the global --output flag.",
+        case_sensitive=False,
+    ),
+) -> None:
+    """List product groups with the count of products in each.
+
+    Wraps ``GET /products/groups``. Useful before
+    ``impreza catalog products --group <name>`` to find the right
+    filter value.
+    """
+    state = from_typer_context(typer_ctx)
+    fmt = resolve_output(state, output)
+
+    with make_client_or_exit(state) as client:
+        try:
+            groups = client.catalog.product_groups()
+        except ApiError as exc:
+            _exit_on_api_error(exc)
+
+    if not groups:
+        typer.echo("No product groups defined yet.")
+        return
+
+    rows = [
+        {"id": g.id, "name": g.name, "product_count": g.product_count}
+        for g in groups
+    ]
+    print_table(
+        f"Product groups ({len(rows)})",
+        rows,
+        columns=["id", "name", "product_count"],
+        fmt=fmt,
+    )
+
+
+# ── catalog tlds ─────────────────────────────────────────────────────
+
+
+def _year_1_price(prices: dict[str, float]) -> float | None:
+    """Pull out the 1-year price from a ``{"1": x, "2": y}`` map.
+    Returns None when 1-year isn't offered (some registrars require
+    multi-year minimums)."""
+    raw = prices.get("1")
+    return float(raw) if raw is not None else None
+
+
+@app.command("tlds")
+def tlds(
+    typer_ctx: typer.Context,
+    filter_: str | None = typer.Option(
+        None,
+        "--filter",
+        "-f",
+        help=(
+            "Comma-separated list of TLDs (e.g. '.com,.net,.io'). "
+            "Without a filter, the full TLD catalog is returned."
+        ),
+    ),
+    output: OutputFormat | None = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Output format. Overrides the global --output flag.",
+        case_sensitive=False,
+    ),
+) -> None:
+    """List domain TLD pricing.
+
+    Wraps ``GET /domains/pricing``. Table mode shows tld / currency /
+    1-year register / 1-year renew / cheapest-overall. JSON / YAML
+    emit the full :class:`TldPricing` model with per-year pricing
+    dicts for both register and renew.
+    """
+    state = from_typer_context(typer_ctx)
+    fmt = resolve_output(state, output)
+
+    with make_client_or_exit(state) as client:
+        try:
+            items: list[TldPricing] = client.catalog.tlds(filter=filter_)
+        except ApiError as exc:
+            _exit_on_api_error(exc)
+
+    if not items:
+        msg = (
+            f"No TLDs match the filter: {filter_!r}."
+            if filter_
+            else "No TLDs in the catalog yet."
+        )
+        typer.echo(msg)
+        return
+
+    if fmt is OutputFormat.TABLE:
+        rows: list[dict[str, Any]] = []
+        for t in items:
+            reg_1y = _year_1_price(t.register_prices)
+            ren_1y = _year_1_price(t.renew_prices)
+            rows.append(
+                {
+                    "tld": t.tld,
+                    "currency": t.currency,
+                    "register_1y": f"{reg_1y:.2f}" if reg_1y is not None else "-",
+                    "renew_1y": f"{ren_1y:.2f}" if ren_1y is not None else "-",
+                    "cheapest": (
+                        f"{t.cheapest:.2f}" if t.cheapest is not None else "-"
+                    ),
+                    "min_years": t.min_years,
+                }
+            )
+        print_table(
+            f"TLDs ({len(rows)})",
+            rows,
+            columns=[
+                "tld",
+                "currency",
+                "register_1y",
+                "renew_1y",
+                "cheapest",
+                "min_years",
+            ],
+            fmt=fmt,
+        )
+    else:
+        rows = [t.model_dump(by_alias=True) for t in items]
+        print_table("TLDs", rows, fmt=fmt)

impreza_cli/commands/context.py

@@ -0,0 +1,232 @@
+"""``impreza context`` subcommand surface.
+
+Five operations:
+
+* ``impreza context create <name> --key ... --secret ... [--base-url ...]
+  [--default-output table|json|yaml] [--overwrite]``
+* ``impreza context use <name>``
+* ``impreza context list``
+* ``impreza context current``
+* ``impreza context delete <name> [--yes]``
+
+The first context created becomes the default automatically. Names
+must match ``[A-Za-z0-9_-]{1,50}`` (so they never need quoting in
+shell commands).
+
+The config file lives at ``$XDG_CONFIG_HOME/impreza/config.toml``
+(Linux), ``~/Library/Application Support/impreza/config.toml`` (macOS),
+or ``%APPDATA%\\impreza\\config.toml`` (Windows). Override with
+``IMPREZA_CONFIG=/path/to/config.toml`` for tests or alternate
+layouts.
+
+Errors render as red ``Error:`` lines on stderr and exit non-zero so
+scripts can detect failure cleanly. Stdout stays reserved for the
+success output.
+"""
+
+from __future__ import annotations
+
+import typer
+
+from ..config import (
+    Config,
+    ConfigError,
+    ContextAlreadyExists,
+    ContextNotFound,
+    InvalidContextName,
+    NoActiveContext,
+    NoContextsConfigured,
+)
+from ..output import OutputFormat, error, info, print_dict, print_table, success
+from ..state import from_typer_context, resolve_output
+
+app = typer.Typer(
+    name="context",
+    help="Manage local CLI contexts (named credential sets).",
+    no_args_is_help=True,
+)
+
+
+# ── helpers ───────────────────────────────────────────────────────────
+
+
+def _exit_on_config_error(exc: ConfigError) -> None:
+    """Print a friendly message and exit 1. Used by every command's
+    top-level error handler so error formatting stays consistent."""
+    error(str(exc))
+    raise typer.Exit(code=1)
+
+
+def _mask_secret(value: str) -> str:
+    """Render a secret string as ``imp_abc...xyz`` (first/last 4 chars
+    of the suffix; never the middle). Used in human-readable output
+    to confirm "yes the right key is loaded" without leaking it."""
+    if len(value) <= 12:
+        return "[dim]<short>[/]"
+    return f"{value[:8]}…{value[-4:]}"
+
+
+# ── commands ──────────────────────────────────────────────────────────
+
+
+@app.command("create")
+def create(
+    name: str = typer.Argument(..., help="Context name (alphanumeric, '-', '_')."),
+    key: str = typer.Option(..., "--key", "-k", help="API key (`imp_...`)."),
+    secret: str = typer.Option(
+        ..., "--secret", "-s", help="API secret (64 hex chars).",
+    ),
+    base_url: str | None = typer.Option(
+        None,
+        "--base-url",
+        help="Optional API base URL override (defaults to "
+        "https://api.imprezahost.com/v1).",
+    ),
+    default_output: OutputFormat | None = typer.Option(
+        None,
+        "--default-output",
+        help="Optional default output format for this context.",
+        case_sensitive=False,
+    ),
+    overwrite: bool = typer.Option(
+        False,
+        "--overwrite",
+        help="Replace an existing context with the same name.",
+    ),
+) -> None:
+    """Create a new context. The first one created is auto-set as
+    the default."""
+    cfg = Config.load()
+    try:
+        ctx = cfg.add_context(
+            name,
+            api_key=key,
+            api_secret=secret,
+            base_url=base_url,
+            default_output=default_output.value if default_output else None,
+            overwrite=overwrite,
+        )
+    except (ContextAlreadyExists, InvalidContextName) as exc:
+        _exit_on_config_error(exc)
+    cfg.save()
+
+    is_default = cfg.default_context == name
+    success(
+        f"Context {ctx.name!r} created"
+        + (" and set as default." if is_default else ".")
+    )
+
+
+@app.command("use")
+def use(
+    name: str = typer.Argument(..., help="Context name to switch to."),
+) -> None:
+    """Set the default context."""
+    cfg = Config.load()
+    try:
+        cfg.use_context(name)
+    except ContextNotFound as exc:
+        _exit_on_config_error(exc)
+    cfg.save()
+    success(f"Now using context {name!r}.")
+
+
+@app.command("list")
+def list_contexts(
+    typer_ctx: typer.Context,
+    output: OutputFormat | None = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Output format. Overrides the global --output flag for this command.",
+        case_sensitive=False,
+    ),
+) -> None:
+    """List all configured contexts with their masked credentials."""
+    fmt = resolve_output(from_typer_context(typer_ctx), output)
+    cfg = Config.load()
+    rows = [
+        {
+            "name": ctx.name,
+            "default": cfg.default_context == ctx.name,
+            "api_key": _mask_secret(ctx.api_key)
+            if fmt is OutputFormat.TABLE
+            else ctx.api_key,
+            "base_url": ctx.base_url,
+            "default_output": ctx.default_output,
+        }
+        for ctx in (cfg.contexts[name] for name in cfg.list_contexts())
+    ]
+    if not rows:
+        typer.echo("No contexts configured. Run `impreza context create <name>`.")
+        return
+    print_table(
+        "Contexts",
+        rows,
+        columns=["name", "default", "api_key", "base_url", "default_output"],
+        fmt=fmt,
+    )
+
+
+@app.command("current")
+def current(
+    typer_ctx: typer.Context,
+    output: OutputFormat | None = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Output format. Overrides the global --output flag for this command.",
+        case_sensitive=False,
+    ),
+) -> None:
+    """Show the active (default) context's metadata. Exits non-zero
+    when no contexts are configured or no default is set."""
+    fmt = resolve_output(from_typer_context(typer_ctx), output)
+    cfg = Config.load()
+    try:
+        ctx = cfg.get_context()
+    except (NoContextsConfigured, NoActiveContext, ContextNotFound) as exc:
+        _exit_on_config_error(exc)
+
+    print_dict(
+        "Current context",
+        {
+            "name": ctx.name,
+            "api_key": _mask_secret(ctx.api_key)
+            if fmt is OutputFormat.TABLE
+            else ctx.api_key,
+            "base_url": ctx.base_url or "<default>",
+            "default_output": ctx.default_output or "<inherit>",
+        },
+        fmt=fmt,
+    )
+
+
+@app.command("delete")
+def delete(
+    name: str = typer.Argument(..., help="Context name to delete."),
+    yes: bool = typer.Option(
+        False,
+        "--yes",
+        "-y",
+        help="Skip the interactive confirmation prompt.",
+    ),
+) -> None:
+    """Delete a context. Prompts for confirmation unless ``--yes``."""
+    cfg = Config.load()
+    if name not in cfg.contexts:
+        _exit_on_config_error(ContextNotFound(f"Context {name!r} does not exist."))
+
+    if not yes and not typer.confirm(f"Delete context {name!r}?", default=False):
+        typer.echo("Cancelled.")
+        raise typer.Exit(code=0)
+
+    was_default = cfg.default_context == name
+    cfg.remove_context(name)
+    cfg.save()
+
+    success(f"Context {name!r} deleted.")
+    if was_default and cfg.contexts:
+        info(
+            "  (no default context now — pick one with `impreza context use <name>`.)"
+        )