commoncompute 0.1.0__py3-none-any.whl

commoncompute/cli.py

@@ -0,0 +1,474 @@
+"""`cc` command-line interface.
+
+Installed as ``cc`` and ``commoncompute`` via the pyproject entry point.
+Uses Typer for argparsing + Rich for pretty output. Reads credentials
+from (in order): ``--api-key`` flag, ``CC_API_KEY`` env var, or the
+config file at ``~/.config/commoncompute/credentials`` (a single line).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import webbrowser
+from pathlib import Path
+from typing import Optional
+
+try:
+    import typer
+    from rich.console import Console
+    from rich.table import Table
+    from rich.panel import Panel
+except ImportError:  # CLI deps are the [cli] extra, not core deps
+    print(
+        "The `cc` CLI needs the cli extra: pip install \"commoncompute[cli]\"",
+        file=sys.stderr,
+    )
+    raise SystemExit(2)
+
+from .client import Client
+from .errors import CommonComputeError
+
+app = typer.Typer(
+    name="cc",
+    add_completion=False,
+    no_args_is_help=True,
+    help="Common Compute CLI — submit jobs, check spend, manage keys.",
+    rich_markup_mode="rich",
+)
+jobs_app = typer.Typer(no_args_is_help=True, help="Inspect and submit jobs.")
+keys_app = typer.Typer(no_args_is_help=True, help="Manage API keys.")
+receipts_app = typer.Typer(no_args_is_help=True, help="List, verify, and export job receipts.")
+app.add_typer(jobs_app, name="jobs")
+app.add_typer(keys_app, name="keys")
+app.add_typer(receipts_app, name="receipts")
+
+console = Console()
+err_console = Console(stderr=True, style="red")
+
+CONFIG_DIR = Path(os.environ.get("CC_CONFIG_DIR") or (Path.home() / ".config" / "commoncompute"))
+CREDENTIALS_FILE = CONFIG_DIR / "credentials"
+
+
+def _load_api_key(override: Optional[str] = None) -> Optional[str]:
+    if override:
+        return override
+    env = os.environ.get("CC_API_KEY")
+    if env:
+        return env
+    if CREDENTIALS_FILE.exists():
+        return CREDENTIALS_FILE.read_text().strip() or None
+    return None
+
+
+def _client(api_key: Optional[str] = None) -> Client:
+    key = _load_api_key(api_key)
+    if not key:
+        err_console.print("No API key found. Run [bold]cc login[/bold] or set [bold]CC_API_KEY[/bold].")
+        raise typer.Exit(2)
+    try:
+        return Client(api_key=key)
+    except CommonComputeError as e:
+        err_console.print(str(e))
+        raise typer.Exit(2)
+
+
+def _fmt_usd(cents: int) -> str:
+    return f"${cents / 100:,.2f}"
+
+
+def _print_err(e: Exception) -> None:
+    err_console.print(f"[bold red]Error:[/bold red] {e}")
+
+
+# ─── login / config ─────────────────────────────────────────────────────
+
+@app.command()
+def login(
+    api_key: Optional[str] = typer.Option(None, "--api-key", "-k", help="Paste a cc_live_… or cc_test_… key instead of using the browser."),
+    no_browser: bool = typer.Option(False, "--no-browser", help="Print the approval URL instead of opening the browser."),
+) -> None:
+    """Connect this machine to your account (opens the browser to approve).
+
+    Pass --api-key to paste an existing key instead.
+    """
+    if api_key:
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        CREDENTIALS_FILE.write_text(api_key + "\n")
+        CREDENTIALS_FILE.chmod(0o600)
+        console.print(f"[green]✓[/green] Saved credentials to {CREDENTIALS_FILE}")
+        return
+
+    from .connect import connect as _connect
+
+    try:
+        _connect(open_browser=not no_browser)
+    except KeyboardInterrupt:
+        err_console.print("Login aborted.")
+        raise typer.Exit(1)
+    except CommonComputeError as e:
+        _print_err(e)
+        raise typer.Exit(1)
+
+
+@app.command()
+def logout() -> None:
+    """Remove the stored API key."""
+    if CREDENTIALS_FILE.exists():
+        CREDENTIALS_FILE.unlink()
+        console.print(f"[green]✓[/green] Removed {CREDENTIALS_FILE}")
+    else:
+        console.print("Nothing to remove.")
+
+
+@app.command()
+def whoami() -> None:
+    """Show the account behind the current API key."""
+    c = _client()
+    try:
+        me = c.me()
+    except Exception as e:
+        _print_err(e); raise typer.Exit(1)
+    console.print(Panel.fit(
+        f"[bold]{me.get('full_name') or me.get('email')}[/bold]\n"
+        f"[dim]{me.get('email')}[/dim]\n"
+        f"role={me.get('role', '?')}  verified={bool(me.get('email_verified_at'))}",
+        title="whoami",
+    ))
+
+
+# ─── balance / usage ────────────────────────────────────────────────────
+
+@app.command()
+def balance() -> None:
+    """Show the current workspace balance."""
+    c = _client()
+    try:
+        bal = c.balance()
+    except Exception as e:
+        _print_err(e); raise typer.Exit(1)
+    table = Table(show_header=False, box=None)
+    if "has_card" in bal:
+        # Cash-only billing: the endpoint reports card-on-file state.
+        card = f"{bal.get('brand') or 'card'} ••••{bal.get('last4')}" if bal.get("last4") else ("on file" if bal.get("has_card") else "none")
+        table.add_row("Payment method", card)
+        table.add_row("Can submit jobs", "yes" if bal.get("can_submit_jobs") else "no — add a card")
+    else:  # legacy prepaid shape
+        table.add_row("Balance", _fmt_usd(bal.get("balance_cents", 0)))
+        table.add_row("Total topped up", _fmt_usd(bal.get("lifetime_topup_cents", 0)))
+        table.add_row("Total spent", _fmt_usd(bal.get("lifetime_spend_cents", 0)))
+    console.print(table)
+
+
+@app.command()
+def workloads() -> None:
+    """List the available workloads."""
+    c = _client()
+    try:
+        items = c.workloads.list()
+    except Exception as e:
+        _print_err(e); raise typer.Exit(1)
+    t = Table("ID", "Label", "Family", "Status", title="Workloads")
+    for w in items:
+        t.add_row(w.get("id", "?"), w.get("label", ""), w.get("family", ""), w.get("status", ""))
+    console.print(t)
+
+
+@app.command()
+def models(workload: Optional[str] = typer.Option(None, "--workload", "-w", help="Filter by workload id.")) -> None:
+    """List models, optionally filtered by workload."""
+    c = _client()
+    try:
+        items = c.models.list(workload_id=workload)
+    except Exception as e:
+        _print_err(e); raise typer.Exit(1)
+    t = Table("ID", "Label", "Workload", "Min memory", title="Models")
+    for m in items:
+        mem = m.get("minMemoryGb") or m.get("min_memory_gb")
+        t.add_row(m.get("id", "?"), m.get("label", ""), m.get("workloadId", m.get("workload_id", "")), f"{mem} GB" if mem else "—")
+    console.print(t)
+
+
+# ─── quote / submit ─────────────────────────────────────────────────────
+
+@app.command()
+def quote(
+    workload: str = typer.Argument(..., help="Workload id, e.g. coreml_embed."),
+    units: float = typer.Option(1, "--units", "-u"),
+    priority: str = typer.Option("standard", "--priority", "-p"),
+    model: Optional[str] = typer.Option(None, "--model", "-m"),
+) -> None:
+    """Get a price estimate without submitting."""
+    c = _client()
+    try:
+        q = c.jobs.quote(workload, units=units, priority=priority, model_id=model)
+    except Exception as e:
+        _print_err(e); raise typer.Exit(1)
+    console.print(Panel.fit(
+        f"[bold]${q.get('estimated_usd', 0):.4f}[/bold]\n"
+        f"[dim]{units} units · {priority}  ·  ~{q.get('estimated_latency_s', 0):.1f}s[/dim]",
+        title=f"{workload} quote",
+    ))
+
+
+@app.command()
+def submit(
+    workload: str = typer.Argument(..., help="Workload id."),
+    payload: Optional[str] = typer.Option(None, "--payload", "-f", help="Path to JSON payload file, or @- for stdin."),
+    model: Optional[str] = typer.Option(None, "--model", "-m"),
+    priority: str = typer.Option("standard", "--priority", "-p"),
+    wait: bool = typer.Option(False, "--wait", help="Block until the job finishes."),
+) -> None:
+    """Submit a native Common Compute job."""
+    body: object = None
+    if payload:
+        if payload == "@-":
+            body = json.load(sys.stdin)
+        elif payload.startswith("@"):
+            body = json.loads(Path(payload[1:]).read_text())
+        else:
+            body = json.loads(payload)
+    c = _client()
+    try:
+        job = c.jobs.submit(workload, payload=body, model_id=model, priority=priority)
+    except Exception as e:
+        _print_err(e); raise typer.Exit(1)
+    console.print(f"[green]✓[/green] queued  id=[bold]{job['id']}[/bold]  state={job.get('state')}")
+    if wait:
+        try:
+            final = c.jobs.wait(job["id"])
+        except Exception as e:
+            _print_err(e); raise typer.Exit(1)
+        console.print(f"[green]✓[/green] {final.get('state')} in ~{final.get('duration_seconds', 0):.1f}s")
+        console.print_json(data=final)
+
+
+# ─── jobs ───────────────────────────────────────────────────────────────
+
+@jobs_app.command("list")
+def jobs_list(
+    limit: int = typer.Option(25, "--limit", "-n", help="How many recent jobs to show."),
+    as_json: bool = typer.Option(False, "--json", help="Raw JSON output."),
+) -> None:
+    """List your recent submissions (newest first)."""
+    c = _client()
+    try:
+        raw = c._transport.request("GET", "/v1/me/submissions", params={"limit": limit})
+    except Exception as e:
+        _print_err(e); raise typer.Exit(1)
+    rows = raw.get("submissions") or raw.get("jobs") or raw.get("tasks") or []
+    if as_json:
+        console.print_json(data=rows)
+        return
+    table = Table(box=None, header_style="bold")
+    for col in ("id", "workload", "state", "created"):
+        table.add_column(col)
+    for r in rows:
+        table.add_row(
+            str(r.get("id", ""))[:12],
+            str(r.get("type") or r.get("workload_id") or ""),
+            str(r.get("state", "")),
+            str(r.get("created_at", "")),
+        )
+    console.print(table)
+
+
+@jobs_app.command("get")
+def jobs_get(task_id: str) -> None:
+    """Fetch a job by id."""
+    c = _client()
+    try:
+        job = c.jobs.get(task_id)
+    except Exception as e:
+        _print_err(e); raise typer.Exit(1)
+    console.print_json(data=job)
+
+
+@jobs_app.command("wait")
+def jobs_wait(task_id: str, timeout: float = typer.Option(300, "--timeout", "-t")) -> None:
+    """Poll a job until it reaches a terminal state."""
+    c = _client()
+    try:
+        final = c.jobs.wait(task_id, timeout=timeout)
+    except Exception as e:
+        _print_err(e); raise typer.Exit(1)
+    console.print_json(data=final)
+
+
+@jobs_app.command("download")
+def jobs_download(task_id: str, out: Optional[str] = typer.Option(None, "--out", "-o")) -> None:
+    """Download a job's result. With --out, writes to disk; otherwise stdout."""
+    c = _client()
+    try:
+        result = c.jobs.download(task_id, dest=out)
+    except Exception as e:
+        _print_err(e); raise typer.Exit(1)
+    if isinstance(result, Path):
+        console.print(f"[green]✓[/green] wrote {result}")
+    else:
+        sys.stdout.buffer.write(result)
+
+
+# ─── receipts ───────────────────────────────────────────────────────────
+
+@receipts_app.command("list")
+def receipts_list(limit: int = typer.Option(50, "--limit", "-n")) -> None:
+    """List receipts for completed jobs."""
+    c = _client()
+    try:
+        rows = c.receipts.list(limit=limit)
+    except Exception as e:
+        _print_err(e); raise typer.Exit(1)
+    table = Table(box=None, header_style="bold")
+    for col in ("job", "cost", "provider", "timestamp"):
+        table.add_column(col)
+    for r in rows:
+        table.add_row(
+            r.job_id[:12],
+            f"${r.cost_usd:.4f}" if r.cost_usd is not None else "—",
+            (r.provider_id or "—")[:12],
+            r.timestamp or "—",
+        )
+    console.print(table)
+
+
+@receipts_app.command("export")
+def receipts_export(
+    fmt: str = typer.Option("csv", "--format", "-f", help="csv or json"),
+    out: Optional[str] = typer.Option(None, "--out", "-o", help="Write to file instead of stdout."),
+    limit: int = typer.Option(1000, "--limit", "-n"),
+) -> None:
+    """Export receipts as CSV or JSON."""
+    c = _client()
+    try:
+        blob = c.receipts.export(format=fmt, limit=limit)
+    except Exception as e:
+        _print_err(e); raise typer.Exit(1)
+    if out:
+        Path(out).write_text(blob)
+        console.print(f"[green]✓[/green] wrote {out}")
+    else:
+        sys.stdout.write(blob)
+
+
+@app.command()
+def estimate(
+    workload: str = typer.Argument(..., help="Workload id, e.g. vision_ocr"),
+    units: float = typer.Option(1, "--units", "-u", help="Billing units (see /v1/workloads for the unit)."),
+    priority: str = typer.Option("batch", "--priority", "-p"),
+    model: Optional[str] = typer.Option(None, "--model", "-m"),
+) -> None:
+    """Price + ETA for a job without executing it (dry run)."""
+    c = _client()
+    try:
+        q = c.jobs.quote(workload, units=units, priority=priority, model_id=model)
+    except Exception as e:
+        _print_err(e); raise typer.Exit(1)
+    console.print(
+        Panel.fit(
+            f"[bold]${q.get('estimated_usd', 0):.4f}[/bold] "
+            f"({q.get('unit_price_usd', 0)} per unit × {units})\n"
+            f"ETA ~{q.get('estimated_latency_s', 0):.1f}s · priority {q.get('priority', priority)}",
+            title=workload,
+        )
+    )
+
+
+# ─── keys ───────────────────────────────────────────────────────────────
+
+@keys_app.command("list")
+def keys_list() -> None:
+    c = _client()
+    try:
+        keys = c.keys.list()
+    except Exception as e:
+        _print_err(e); raise typer.Exit(1)
+    t = Table("Prefix", "Name", "Mode", "Created", "Last used", title="API keys")
+    for k in keys:
+        t.add_row(
+            k.get("prefix", "?"),
+            k.get("name") or "—",
+            k.get("mode", "live"),
+            str(k.get("created_at", "")),
+            str(k.get("last_used_at", "—") or "—"),
+        )
+    console.print(t)
+
+
+@keys_app.command("create")
+def keys_create(
+    name: str = typer.Option(..., "--name", "-n"),
+    mode: str = typer.Option("live", "--mode", help="live or test"),
+) -> None:
+    c = _client()
+    try:
+        created = c.keys.create(name=name, mode=mode)
+    except Exception as e:
+        _print_err(e); raise typer.Exit(1)
+    full = created.get("key") or created.get("full_key")
+    if full:
+        console.print(Panel(
+            f"[bold yellow]Copy this key now — it will not be shown again.[/bold yellow]\n\n[bold]{full}[/bold]",
+            title=f"new key · {name}",
+        ))
+    else:
+        console.print_json(data=created)
+
+
+@keys_app.command("revoke")
+def keys_revoke(key_id: str) -> None:
+    c = _client()
+    try:
+        c.keys.revoke(key_id)
+    except Exception as e:
+        _print_err(e); raise typer.Exit(1)
+    console.print(f"[green]✓[/green] revoked {key_id}")
+
+
+# ─── chat / embed ───────────────────────────────────────────────────────
+
+@app.command()
+def chat(
+    prompt: str = typer.Argument(..., help="Your message."),
+    model: str = typer.Option("qwen-2.5-7b-instruct", "--model", "-m"),
+    stream: bool = typer.Option(True, "--stream/--no-stream"),
+) -> None:
+    """Send a one-shot chat message to a model."""
+    c = _client()
+    try:
+        if stream:
+            for chunk in c.chat.stream(model=model, messages=[{"role": "user", "content": prompt}]):
+                delta = chunk.get("choices", [{}])[0].get("delta", {}).get("content", "") or ""
+                sys.stdout.write(delta)
+                sys.stdout.flush()
+            sys.stdout.write("\n")
+        else:
+            reply = c.chat.create(model=model, messages=[{"role": "user", "content": prompt}])
+            print(reply["choices"][0]["message"]["content"])
+    except Exception as e:
+        _print_err(e); raise typer.Exit(1)
+
+
+@app.command()
+def embed(text: str = typer.Argument(...), model: Optional[str] = typer.Option(None, "--model", "-m")) -> None:
+    """Generate an embedding for a single string (prints the vector length)."""
+    c = _client()
+    try:
+        res = c.embeddings.create(input=text, model=model)
+    except Exception as e:
+        _print_err(e); raise typer.Exit(1)
+    vec = res.get("data", [{}])[0].get("embedding", [])
+    console.print(f"[green]✓[/green] dims={len(vec)}  model={res.get('model')}  tokens={res.get('usage', {}).get('total_tokens', '?')}")
+
+
+@app.command()
+def playground() -> None:
+    """Open the web playground."""
+    url = os.environ.get("CC_WEB_BASE", "https://commoncompute.ai") + "/app/playground"
+    webbrowser.open(url)
+    console.print(f"Opened {url}")
+
+
+if __name__ == "__main__":
+    app()