commoncompute 0.3.0__tar.gz → 0.4.0__tar.gz

{commoncompute-0.3.0 → commoncompute-0.4.0}/.gitignore

@@ -3,6 +3,7 @@ node_modules/
 dist/
 coverage/
 .wrangler/
+.wrangler.drifted-backup-*/
 .pytest_cache/
 __pycache__/
 *.pyc
@@ -36,3 +37,6 @@ apps/web/.playwright/
 # Local scratch — never tracked (internal notes, draft reviews)
 tmp/
 .venv
+
+# Device reliability reset snapshots (rollback data, never tracked)
+scripts/.reliability-snapshots/

{commoncompute-0.3.0 → commoncompute-0.4.0}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Common Compute, Inc.
+Copyright (c) 2026 Common Compute LLC
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{commoncompute-0.3.0 → commoncompute-0.4.0}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: commoncompute
-Version: 0.3.0
+Version: 0.4.0
 Summary: Official Python SDK for Common Compute — the batch AI bill you shouldn't be paying.
 Project-URL: Homepage, https://commoncompute.ai
 Project-URL: Documentation, https://commoncompute.ai/docs
-Project-URL: Source, https://github.com/Ikaikaalika/commoncomputeai
+Project-URL: Source, https://github.com/commoncompute/sdk
 Project-URL: Changelog, https://commoncompute.ai/changelog
 Author-email: Common Compute <support@commoncompute.ai>
 License: MIT

{commoncompute-0.3.0 → commoncompute-0.4.0}/commoncompute/__init__.py

@@ -30,7 +30,7 @@ in the catalog — the API declines them with `workload_not_available`
 # `commoncompute.__version__` at import time for the User-Agent header,
 # and the previous ordering (`__version__` defined at the bottom) made
 # every clean install of the SDK fail with a circular ImportError.
-__version__ = "0.3.0"
+__version__ = "0.4.0"
 
 from .client import Client, AsyncClient
 from .errors import (
@@ -51,6 +51,7 @@ from .errors import (
 )
 from .models import Job, Quote, Receipt, TaskResult, AccountTier, SpendSummary
 from .connect import connect, login
+from .billing import add_card
 from . import aws_batch  # noqa: E402  (intentional re-export)
 
 __all__ = [
@@ -58,6 +59,7 @@ __all__ = [
     "AsyncClient",
     "connect",
     "login",
+    "add_card",
     "CommonComputeError",
     "AuthenticationError",
     "PermissionDeniedError",

{commoncompute-0.3.0 → commoncompute-0.4.0}/commoncompute/_async_client.py

@@ -278,8 +278,10 @@ class _KeysAsync:
     async def list(self) -> list[dict[str, Any]]:
         return (await self._t.request("GET", "/v1/me/keys")).get("keys", [])
 
-    async def create(self, *, name: str, mode: str = "live", scopes: "Optional[Sequence[str]]" = None) -> dict[str, Any]:
+    async def create(self, *, name: str, mode: str = "live", scopes: "Optional[Sequence[str]]" = None, password: "Optional[str]" = None) -> dict[str, Any]:
         body: dict[str, Any] = {"name": name, "mode": mode}
+        if password:
+            body["password"] = password
         if scopes:
             body["scopes"] = scopes
         return await self._t.request("POST", "/v1/me/keys", json_body=body)
@@ -295,6 +297,21 @@ class _BillingAsync:
     async def balance(self) -> dict[str, Any]:
         return await self._t.request("GET", "/v1/billing/balance")
 
+    async def credits(self) -> dict[str, Any]:
+        """Prepaid credit balance, held amounts, and auto-reload settings —
+        ``GET /v1/billing/credits``. Mirrors ``Client.billing.credits()``."""
+        return await self._t.request("GET", "/v1/billing/credits")
+
+    async def buy_credits(self, *, amount_cents: int, idempotency_key: str | None = None) -> dict[str, Any]:
+        """Charge the saved card for credits. Mirrors ``Client.billing.buy_credits()``
+        — needs an API key carrying the ``billing`` scope."""
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return await self._t.request(
+            "POST", "/v1/billing/credits",
+            json_body={"amount_cents": amount_cents},
+            headers=headers,
+        )
+
     async def history(self, *, limit: int = 50) -> list[dict[str, Any]]:
         return (await self._t.request("GET", "/v1/billing/history", params={"limit": limit})).get("entries", [])
 

{commoncompute-0.3.0 → commoncompute-0.4.0}/commoncompute/_generated_workloads.py

@@ -1,7 +1,10 @@
-# @generated by packages/workloads/codegen/emit-sdk-workloads.ts — DO NOT EDIT.
-# Regenerate:  npx tsx packages/workloads/codegen/emit-sdk-workloads.ts
-# Source of truth: packages/workloads (the shared catalog). CI fails if this
-# file drifts from the catalog (see tests/unit/workloads-parity.test.ts).
+# @generated from Common Compute's internal workload catalog — DO NOT EDIT.
+#
+# This file is emitted by an internal codegen step and is not regenerable from
+# this repository. Edits here will be overwritten; the catalog is the source of
+# truth and drift is caught before release.
+#
+# Contains workload IDs and image-name routing heuristics only.
 from __future__ import annotations
 
 # Every workload id in the catalog. Used to decide whether a jobDefinition head

{commoncompute-0.3.0 → commoncompute-0.4.0}/commoncompute/aws_batch.py

@@ -103,11 +103,10 @@ def _to_iso(ms: Optional[int]) -> Optional[str]:
 # Heuristic: anything containing one of these workload ids gets routed
 # directly. Otherwise we default to ``coreml_embed`` (the most common
 # batch workload migrated from AWS Batch + bge-* embeddings pipelines).
-# Workload identity comes from the generated catalog mirror so this shim
-# resolves jobDefinitions identically to the wire shim (apps/aws-shim) and the
-# Node SDK. The previous hand-maintained set had drifted to 12 of the catalog's
-# 24 workloads. Regenerate with:
-#   npx tsx packages/workloads/codegen/emit-sdk-workloads.ts
+# Workload identity comes from the generated catalog mirror
+# (``_generated_workloads.py``) so this shim resolves jobDefinitions
+# identically to the server side and to the Node SDK, instead of drifting
+# from a hand-maintained list.
 from ._generated_workloads import IMAGE_PATTERNS as _IMAGE_PATTERN_SOURCES
 from ._generated_workloads import KNOWN_WORKLOAD_IDS as _KNOWN_WORKLOADS
 
@@ -403,7 +402,7 @@ class BatchClient:
         """Mirror AWS describe_jobs — returns ``{"jobs": [...]}``.
 
         Just-submitted jobs may not be queryable for ~100ms while the
-        underlying D1 row propagates across the worker's read replicas.
+        underlying row propagates across the backing datastore's read replicas.
         We absorb a single 404 by retrying once after 250ms, which is
         enough to mask the eventual-consistency window in practice."""
         out: list[dict[str, Any]] = []

commoncompute-0.4.0/commoncompute/billing.py

@@ -0,0 +1,124 @@
+"""Attach a payment card from a script or notebook.
+
+``commoncompute.add_card()`` opens the dashboard billing page, waits for the
+card to actually land server-side, and returns the resulting payment-method
+summary::
+
+    import commoncompute as cc
+    cc.connect()      # one-time: get a key
+    cc.add_card()     # one-time: attach a card
+    cc.Client().submit(...)
+
+WHY THE BROWSER. The card number has to reach Stripe directly. Accepting it
+here would put the number in this process's memory, its traceback frames, and
+whatever notebook checkpoint happens to capture the cell — and would drag the
+user's machine into PCI scope for no benefit at all. So this function never
+sees a card; it opens the page where Stripe's own iframe collects one.
+
+WHY IT POLLS. The card is saved by the ``setup_intent.succeeded`` webhook, not
+by the browser form submitting. Returning as soon as the browser opens would
+report success for a card that may never arrive. Polling the read-only summary
+means a returned value is the server agreeing the card exists.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+import webbrowser
+from typing import Any, Callable, Optional
+
+from .errors import CommonComputeError
+
+DEFAULT_BASE_URL = "https://api.commoncompute.ai"
+POLL_INTERVAL_S = 3.0
+
+
+def dashboard_url_for(api_base: str, path: str = "/app/billing") -> str:
+    """Map an API base URL to the matching dashboard URL.
+
+    `api.` is stripped because that is the only difference between the two
+    hostnames in every environment we run, so a staging key opens the staging
+    dashboard rather than production's. CC_DASHBOARD_URL overrides outright,
+    for local dev where the two aren't related by prefix at all.
+    """
+    override = os.environ.get("CC_DASHBOARD_URL")
+    if override:
+        return f"{override.rstrip('/')}{path}"
+    return f"{api_base.rstrip('/').replace('://api.', '://', 1)}{path}"
+
+
+def add_card(
+    *,
+    client: Any = None,
+    open_browser: bool = True,
+    timeout: float = 600.0,
+    quiet: bool = False,
+    _sleep: Callable[[float], None] = time.sleep,
+) -> dict[str, Any]:
+    """Attach a payment card to the account this machine is logged in as.
+
+    Opens the browser to the dashboard billing page (or prints the URL when
+    ``open_browser=False``), then blocks until the saved card appears.
+
+    Returns the payment-method summary — ``{"has_card": True, "brand": ...,
+    "last4": ...}``. Returns immediately if a card is already on file, or if
+    the account is billing-exempt and doesn't need one.
+
+    Raises :class:`CommonComputeError` if no card appears before ``timeout``.
+    """
+    from .client import Client  # local import: avoids a cycle at module load
+
+    c = client or Client()
+
+    def say(msg: str) -> None:
+        if not quiet:
+            print(msg)
+
+    summary = c.billing.balance()
+    if summary.get("has_card"):
+        say(f"Card already on file — {describe_card(summary)}")
+        return summary
+    if summary.get("billing_exempt"):
+        say("This account is billing-exempt — no card needed.")
+        return summary
+
+    url = dashboard_url_for(c._transport._base_url)
+    say("Add your card in the browser — it goes straight to Stripe, not through this process.")
+    say(f"  Open: {url}")
+    if open_browser:
+        try:
+            webbrowser.open(url)
+        except Exception:
+            pass  # headless; the printed URL is the fallback
+
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        _sleep(POLL_INTERVAL_S)
+        try:
+            summary = c.billing.balance()
+        except Exception:
+            continue  # transient — the user is mid-flow; keep waiting
+        if summary.get("has_card"):
+            say(f"✓ Card saved — {describe_card(summary)}")
+            return summary
+
+    raise CommonComputeError(
+        f"No card appeared within {timeout:.0f}s. If you did add one, it may still be "
+        "processing — check client.billing.balance()."
+    )
+
+
+def describe_card(summary: dict[str, Any]) -> str:
+    """Human label for a payment-method summary.
+
+    Distinguishes "no card" from "card whose details Stripe couldn't be asked
+    for" — the API degrades to has_card without brand/last4 when Stripe is
+    unreachable, and calling that "none" would contradict the submit gate.
+    """
+    if summary.get("last4"):
+        brand = (summary.get("brand") or "card").capitalize()
+        return f"{brand} ••••{summary['last4']}"
+    if summary.get("has_card"):
+        return "on file (details unavailable)"
+    return "none"

{commoncompute-0.3.0 → commoncompute-0.4.0}/commoncompute/cli.py

@@ -56,10 +56,14 @@ 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, get, and export job receipts.")
 config_app = typer.Typer(no_args_is_help=True, help="Local CLI/SDK configuration (base_url, org, credentials).")
+billing_app = typer.Typer(no_args_is_help=True, help="Payment method and credit balance.")
+credits_app = typer.Typer(no_args_is_help=True, help="Buy and inspect prepaid credits.")
 app.add_typer(jobs_app, name="jobs")
 app.add_typer(keys_app, name="keys")
 app.add_typer(receipts_app, name="receipts")
 app.add_typer(config_app, name="config")
+app.add_typer(billing_app, name="billing")
+app.add_typer(credits_app, name="credits")
 
 console = Console()
 err_console = Console(stderr=True, style="red")
@@ -112,6 +116,39 @@ def _fmt_usd(cents: int) -> str:
     return f"${cents / 100:,.2f}"
 
 
+def _stdin_is_tty() -> bool:
+    """Is there a human who can answer a prompt?
+
+    Its own function so a test can drive both branches — CliRunner replaces
+    sys.stdin, so patching sys.stdin.isatty directly doesn't reach the code
+    under test, and the untested branch here is the one that charges a card.
+    """
+    try:
+        return sys.stdin.isatty()
+    except Exception:
+        return False  # detached stdin — treat as non-interactive
+
+
+def _dashboard_url(client: Client, path: str) -> str:
+    """Map the API base URL to the matching dashboard URL.
+
+    The card itself is entered in a browser, never here — Stripe must receive
+    the number directly, and routing it through this process would drag the
+    user's machine into PCI scope for no benefit. So the CLI's job is to open
+    the right page and then watch for the result.
+
+    Derived from the transport's base_url rather than hardcoded so `config set
+    base_url` and CC_BASE_URL keep pointing at the matching dashboard: staging
+    API → staging dashboard. `api.` is stripped because that is the only
+    difference between the two hostnames in every environment we run.
+    """
+    override = os.environ.get("CC_DASHBOARD_URL")
+    base = (override or client._transport._base_url).rstrip("/")
+    if not override:
+        base = base.replace("://api.", "://", 1)
+    return f"{base}{path}"
+
+
 def _print_err(e: Exception) -> None:
     err_console.print(f"[bold red]Error:[/bold red] {e}")
 
@@ -267,6 +304,174 @@ def balance(as_json: bool = typer.Option(False, "--json", help="Raw JSON output.
     console.print(table)
 
 
+# ─── billing ────────────────────────────────────────────────────────────
+#
+# The card number never passes through this process. `billing add-card` opens
+# the dashboard, where Stripe's own iframe collects it, and then polls a
+# read-only endpoint until the saved card shows up. That split is why these
+# commands need no new API surface and no new permission: GET
+# /v1/billing/balance and /v1/billing/credits already accept an API key
+# (`requireAuth`), while everything that *mutates* billing stays JWT-only and
+# happens in the browser session.
+
+@billing_app.command("status")
+def billing_status(as_json: bool = typer.Option(False, "--json", help="Raw JSON output.")) -> None:
+    """Show the saved card and credit balance."""
+    c = _client()
+    try:
+        card = c.balance()
+        credits = c.billing.credits()
+    except Exception as e:
+        _print_err(e); raise typer.Exit(1)
+    if _emit({**credits, "payment_method": card}, as_json):
+        return
+
+    table = Table(show_header=False, box=None)
+    table.add_row("Payment method", _describe_card(card))
+    table.add_row("Credits", _fmt_usd(credits.get("balance_cents", 0)))
+    held = credits.get("held_cents")
+    if held:
+        table.add_row("Held for running jobs", _fmt_usd(held))
+    if credits.get("auto_reload_enabled"):
+        table.add_row("Auto-reload", f"on — {_fmt_usd(credits.get('auto_reload_amount_cents', 0))}")
+    console.print(table)
+
+    if card.get("billing_exempt"):
+        console.print("\n[dim]This account is billing-exempt — jobs run without a card.[/dim]")
+    elif not card.get("has_card"):
+        console.print("\nNo card yet. Run [bold]commoncompute billing add-card[/bold].")
+
+
+def _describe_card(card: dict) -> str:
+    if card.get("last4"):
+        brand = (card.get("brand") or "card").capitalize()
+        return f"{brand} ••••{card['last4']}"
+    if card.get("has_card"):
+        # Stripe was unreachable when the summary was built; the submit gate
+        # still works, so report the card rather than implying there isn't one.
+        return "on file (details unavailable)"
+    return "none"
+
+
+@billing_app.command("add-card")
+def billing_add_card(
+    no_browser: bool = typer.Option(False, "--no-browser", help="Print the URL instead of opening it."),
+    timeout: float = typer.Option(600.0, "--timeout", help="Seconds to wait for the card to appear."),
+) -> None:
+    """Add a payment card (opens the browser; the card is entered on Stripe's form)."""
+    c = _client()
+    try:
+        card = c.balance()
+    except Exception as e:
+        _print_err(e); raise typer.Exit(1)
+
+    if card.get("has_card"):
+        console.print(f"[green]✓[/green] Card already on file — {_describe_card(card)}")
+        console.print("[dim]Replace it from the dashboard billing page.[/dim]")
+        return
+    if card.get("billing_exempt"):
+        console.print("This account is billing-exempt — no card needed to submit jobs.")
+        return
+
+    url = _dashboard_url(c, "/app/billing")
+    console.print("Add your card in the browser — it goes straight to Stripe, not through this CLI.")
+    console.print(f"  Open: [bold]{url}[/bold]\n")
+    if not no_browser:
+        try:
+            webbrowser.open(url)
+        except Exception:
+            pass  # headless box; the printed URL is the fallback
+
+    # Poll the read-only summary. The webhook (setup_intent.succeeded) is what
+    # actually saves the card, so success here means the card really landed
+    # server-side — not merely that the browser form looked happy.
+    deadline = time.time() + timeout
+    try:
+        with console.status("Waiting for the card…"):
+            while time.time() < deadline:
+                time.sleep(3)
+                try:
+                    card = c.balance()
+                except Exception:
+                    continue  # transient; keep waiting until the deadline
+                if card.get("has_card"):
+                    console.print(f"[green]✓[/green] Card saved — {_describe_card(card)}")
+                    console.print("Next: [bold]commoncompute billing status[/bold]")
+                    return
+    except KeyboardInterrupt:
+        console.print("\nStopped waiting. The card is saved if you finished in the browser;")
+        console.print("check with [bold]commoncompute billing status[/bold].")
+        raise typer.Exit(1)
+
+    err_console.print(
+        f"Timed out after {timeout:.0f}s without seeing a card.\n"
+        "If you did add one, check `commoncompute billing status` — the webhook may still be in flight."
+    )
+    raise typer.Exit(1)
+
+
+@credits_app.command("buy")
+def credits_buy(
+    amount: float = typer.Argument(..., help="Dollars of credit to buy, e.g. 20."),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip the confirmation prompt."),
+    as_json: bool = typer.Option(False, "--json", help="Raw JSON output."),
+) -> None:
+    """Charge your saved card for credits.
+
+    Needs a key with the `billing` scope — tick "Also let it buy credits" when
+    you run `commoncompute login`. Without it you'll get a clear 403.
+    """
+    c = _client()
+    amount_cents = int(round(amount * 100))
+
+    # Confirm before charging. This is the one CLI command that moves money, so
+    # a mistyped argument is a real charge rather than a failed request.
+    #
+    # When there's no tty we REFUSE rather than assuming consent. Skipping the
+    # prompt because nobody can answer it turns "couldn't ask" into "went
+    # ahead" — a cron job or a stray script would charge the card silently. A
+    # caller that means it passes --yes.
+    if not yes:
+        if _stdin_is_tty():
+            typer.confirm(f"Charge your saved card {_fmt_usd(amount_cents)}?", abort=True)
+        else:
+            err_console.print(
+                f"Refusing to charge {_fmt_usd(amount_cents)} without confirmation.\n"
+                "This isn't an interactive shell, so there's nobody to ask — "
+                "pass [bold]--yes[/bold] if you meant it."
+            )
+            raise typer.Exit(2)
+
+    try:
+        res = c.billing.buy_credits(amount_cents=amount_cents)
+    except Exception as e:
+        _print_err(e)
+        # The API distinguishes these; each needs a different action from the
+        # user, so don't flatten them into "purchase failed".
+        text = str(e)
+        if "insufficient_scope" in text or "billing\" scope" in text:
+            err_console.print(
+                "\nThis key can't buy credits. Re-run [bold]commoncompute login[/bold] and tick\n"
+                '"Also let it buy credits" on the approval page, or buy from the dashboard.'
+            )
+        elif "no_payment_method" in text:
+            err_console.print("\nNo card on file. Run [bold]commoncompute billing add-card[/bold] first.")
+        raise typer.Exit(1)
+
+    if _emit(res, as_json):
+        return
+    console.print(
+        f"[green]✓[/green] Added {_fmt_usd(res.get('purchased_cents', amount_cents))} — "
+        f"balance {_fmt_usd(res.get('available_cents', 0))}"
+    )
+
+
+@credits_app.command("status")
+def credits_status(as_json: bool = typer.Option(False, "--json", help="Raw JSON output.")) -> None:
+    """Show the credit balance (alias of `billing status`)."""
+    billing_status(as_json=as_json)
+
+
 @app.command()
 def usage(
     start: Optional[str] = typer.Option(None, "--start", help="Window start, YYYY-MM-DD (default: 30 days ago)."),
@@ -435,10 +640,46 @@ def _wait_job(client: Client, job_id: str, timeout: float, *, quiet: bool):
         return client.wait(job_id, timeout=timeout, on_progress=_tick)
 
 
+def _parse_payload_arg(payload: str) -> object:
+    """Resolve --payload: @- (stdin), @path or bare path (file), or inline JSON.
+
+    The help has always said "path to JSON payload file", but the code only
+    honoured that with an @ prefix — a bare path fell through to json.loads()
+    and died with a raw JSONDecodeError traceback. Accept the documented
+    form, keep both @ forms, and turn every failure into a clean CLI error.
+    """
+    try:
+        if payload == "@-":
+            return json.load(sys.stdin)
+        if payload.startswith("@"):
+            return json.loads(Path(payload[1:]).read_text())
+        p = Path(payload)
+        if p.exists():
+            return json.loads(p.read_text())
+        # Not a file on disk — treat as inline JSON. A path-like string that
+        # simply doesn't exist gets a hint instead of a JSON parse error.
+        try:
+            return json.loads(payload)
+        except json.JSONDecodeError:
+            if payload.endswith(".json") or "/" in payload:
+                err_console.print(f"[red]Error:[/red] payload file not found: {payload}")
+            else:
+                err_console.print(f"[red]Error:[/red] --payload is not a file, not valid inline JSON: {payload!r}")
+            raise typer.Exit(2)
+    except typer.Exit:
+        raise
+    except json.JSONDecodeError as e:
+        err_console.print(f"[red]Error:[/red] invalid JSON in payload ({e.msg} at line {e.lineno}, column {e.colno})")
+        raise typer.Exit(2)
+    except OSError as e:
+        err_console.print(f"[red]Error:[/red] cannot read payload: {e}")
+        raise typer.Exit(2)
+
+
 @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."),
+    payload: Optional[str] = typer.Option(None, "--payload", "-f", help="Path to a JSON payload file, @- for stdin, or an inline JSON string."),
     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."),
@@ -448,12 +689,7 @@ def submit(
     """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)
+        body = _parse_payload_arg(payload)
     c = _client()
     try:
         job = c.jobs.submit(workload, payload=body, model_id=model, priority=priority)

{commoncompute-0.3.0 → commoncompute-0.4.0}/commoncompute/client.py

@@ -263,10 +263,28 @@ class _KeysSync:
     def list(self) -> list[dict[str, Any]]:
         return self._t.request("GET", "/v1/me/keys").get("keys", [])
 
-    def create(self, *, name: str, mode: str = "live", scopes: "Optional[Sequence[str]]" = None) -> dict[str, Any]:
+    def create(
+        self,
+        *,
+        name: str,
+        mode: str = "live",
+        scopes: "Optional[Sequence[str]]" = None,
+        password: "Optional[str]" = None,
+    ) -> dict[str, Any]:
+        """Create an API key.
+
+        Requires a signed-in *session* plus the account password. An API key
+        cannot create another API key (the server returns 403
+        ``api_key_cannot_mint``) — otherwise revoking a leaked key would not
+        revoke the keys it had spawned. Since this SDK normally authenticates
+        with an API key, most callers should create keys in the dashboard at
+        /app/api-keys instead.
+        """
         body: dict[str, Any] = {"name": name, "mode": mode}
         if scopes:
             body["scopes"] = scopes
+        if password:
+            body["password"] = password
         return self._t.request("POST", "/v1/me/keys", json_body=body)
 
     def revoke(self, key_id: str) -> None:
@@ -280,6 +298,32 @@ class _BillingSync:
     def balance(self) -> dict[str, Any]:
         return self._t.request("GET", "/v1/billing/balance")
 
+    def credits(self) -> dict[str, Any]:
+        """Prepaid credit balance, what's held against in-flight jobs, and
+        auto-reload settings — ``GET /v1/billing/credits``.
+
+        Read-only, so an API key is enough. Buying credits is a separate,
+        JWT-only operation done from the dashboard.
+        """
+        return self._t.request("GET", "/v1/billing/credits")
+
+    def buy_credits(self, *, amount_cents: int, idempotency_key: str | None = None) -> dict[str, Any]:
+        """Charge the saved card for credits — ``POST /v1/billing/credits``.
+
+        Needs an API key carrying the ``billing`` scope, which is granted only
+        by ticking "Also let it buy credits" during ``commoncompute login``.
+        A stock key raises with ``insufficient_scope``.
+
+        Pass ``idempotency_key`` to make a retry safe: the same key never
+        charges twice.
+        """
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self._t.request(
+            "POST", "/v1/billing/credits",
+            json_body={"amount_cents": amount_cents},
+            headers=headers,
+        )
+
     def history(self, *, limit: int = 50) -> list[dict[str, Any]]:
         return self._t.request("GET", "/v1/billing/history", params={"limit": limit}).get("entries", [])
 

{commoncompute-0.3.0 → commoncompute-0.4.0}/commoncompute/tasks.py

@@ -27,12 +27,31 @@ from .models import Job, Quote, Receipt, TaskResult
 
 FileInput = Union[str, Path, bytes, io.BufferedReader]
 
+# Schemes recognised as "this is a URI, not a local path". Only https:// can
+# actually be fetched: the provider's download gate hard-rejects every other
+# scheme (TrustedDownload.swift — "only https"), and http:// specifically is
+# refused because a job input must not travel in the clear.
+#
+# The others stay in this tuple ON PURPOSE. Dropping them would make an s3://
+# URI fall through to the local-path branch and raise a confusing
+# "No such file: s3://bucket/key"; keeping them lets _file_payload reject the
+# scheme by name, at submit time, instead of the job dispatching and failing
+# on someone's Mac minutes later (2026-08-01 audit — the SDKs documented all
+# five schemes and only one ever worked).
 _URI_SCHEMES = ("http://", "https://", "s3://", "r2://", "gs://")
+_FETCHABLE_URI_SCHEMES = ("https://",)
 
 
 def _file_payload(f: FileInput, *, allowed_suffixes: Optional[Sequence[str]] = None) -> dict:
     """Normalise a file input into the job-payload contract."""
     if isinstance(f, str) and f.startswith(_URI_SCHEMES):
+        if not f.startswith(_FETCHABLE_URI_SCHEMES):
+            scheme = f.split("://", 1)[0]
+            raise UnsupportedFormatError(
+                f"{scheme}:// inputs are not supported — providers can only fetch https:// URLs. "
+                f"Pass a local path (the file is uploaded for you) or a presigned https:// URL.",
+                code="unsupported_input_scheme",
+            )
         return {"input_uri": f}
     if isinstance(f, (str, Path)):
         p = Path(f)
@@ -367,6 +386,14 @@ class Video(_TaskBase):
         max_spend_usd: Optional[float] = None,
         dry_run: bool = False,
     ) -> Union[Job, Quote]:
+        """Transcode a video with VideoToolbox hardware encoders.
+
+        ``output_format`` selects the codec (``"h264"`` / ``"hevc"`` /
+        ``"prores"``); ``codec=`` overrides it if both are given.
+        ``resolution`` is not yet implemented server-side — a job that sets
+        it fails fast with a clear error instead of silently encoding at
+        the source's native size.
+        """
         workload_id, payload, units, model_id = _transcode_request(
             input, output_format, resolution=resolution, codec=codec, output_minutes=output_minutes,
         )

{commoncompute-0.3.0 → commoncompute-0.4.0}/pyproject.toml

@@ -38,7 +38,7 @@ dependencies = [
 [project.urls]
 Homepage = "https://commoncompute.ai"
 Documentation = "https://commoncompute.ai/docs"
-Source = "https://github.com/Ikaikaalika/commoncomputeai"
+Source = "https://github.com/commoncompute/sdk"
 Changelog = "https://commoncompute.ai/changelog"
 
 [project.scripts]