openrunner-sdk 2.37.8__tar.gz → 2.37.9__tar.gz

{openrunner_sdk-2.37.8 → openrunner_sdk-2.37.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrunner-sdk
-Version: 2.37.8
+Version: 2.37.9
 Summary: OpenRunner SDK - W&B-compatible ML experiment tracking client
 Project-URL: Homepage, https://github.com/jqueguiner/openrunner
 Project-URL: Repository, https://github.com/jqueguiner/openrunner

{openrunner_sdk-2.37.8 → openrunner_sdk-2.37.9}/openrunner/__init__.py

@@ -181,7 +181,7 @@ launch.from_run = _launch_from_run  # type: ignore[attr-defined]
 # openrunner.trace.patch_openai() syntax
 trace.patch_openai = _patch_openai  # type: ignore[attr-defined]
 
-__version__ = "2.37.8"
+__version__ = "2.37.9"
 
 logger = logging.getLogger("openrunner")
 

{openrunner_sdk-2.37.8 → openrunner_sdk-2.37.9}/openrunner/api_client.py

@@ -429,6 +429,114 @@ class APIClient:
             logger.warning("list_projects failed: %s", e)
             return []
 
+    # -- Deployments + project images ---------------------------------------
+
+    def list_project_images(self, project_id: str) -> list[dict[str, Any]]:
+        """GET /projects/{id}/images -- images linked to a project (deploy gate)."""
+        try:
+            r = self._request("get", f"/projects/{project_id}/images")
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.warning("list_project_images failed: %s", e)
+            return []
+
+    def link_project_image(
+        self,
+        project_id: str,
+        image: str,
+        registry_id: str | None = None,
+        repository: str | None = None,
+        tag: str | None = None,
+    ) -> dict[str, Any] | None:
+        """POST /projects/{id}/images -- link a deployable image to a project."""
+        try:
+            body: dict[str, Any] = {"image": image}
+            if registry_id:
+                body["registry_id"] = registry_id
+            if repository:
+                body["repository"] = repository
+            if tag:
+                body["tag"] = tag
+            r = self._request("post", f"/projects/{project_id}/images", json=body)
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.warning("link_project_image failed: %s", e)
+            return None
+
+    def list_deployments(self, project_id: str) -> list[dict[str, Any]]:
+        """GET /projects/{id}/deployments -- list a project's GPU deployments."""
+        try:
+            r = self._request("get", f"/projects/{project_id}/deployments")
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.warning("list_deployments failed: %s", e)
+            return []
+
+    def create_deployment(
+        self, project_id: str, body: dict[str, Any]
+    ) -> dict[str, Any] | None:
+        """POST /projects/{id}/deployments -- create a serverless GPU deployment.
+
+        ``body`` keys: name, image, provider, gpu_type, gpu_count, min_nodes,
+        max_nodes, scale_metric?, scale_target?, container_port. The image must
+        already be linked to the project.
+        """
+        try:
+            r = self._request("post", f"/projects/{project_id}/deployments", json=body)
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.warning("create_deployment failed: %s", e)
+            return None
+
+    def scale_deployment(
+        self, project_id: str, deployment_id: str, desired_nodes: int
+    ) -> dict[str, Any] | None:
+        """POST /projects/{id}/deployments/{dep}/scale -- set desired replicas."""
+        try:
+            r = self._request(
+                "post",
+                f"/projects/{project_id}/deployments/{deployment_id}/scale",
+                json={"desired_nodes": desired_nodes},
+            )
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.warning("scale_deployment failed: %s", e)
+            return None
+
+    def delete_deployment(
+        self, project_id: str, deployment_id: str
+    ) -> dict[str, Any] | None:
+        """DELETE /projects/{id}/deployments/{dep} -- tear down a deployment."""
+        try:
+            r = self._request(
+                "delete", f"/projects/{project_id}/deployments/{deployment_id}"
+            )
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.warning("delete_deployment failed: %s", e)
+            return None
+
+    def deployment_replicas(
+        self, project_id: str, deployment_id: str
+    ) -> list[dict[str, Any]]:
+        """GET /projects/{id}/deployments/{dep}/replicas -- a deployment's pods."""
+        try:
+            r = self._request(
+                "get",
+                f"/projects/{project_id}/deployments/{deployment_id}/replicas",
+            )
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.warning("deployment_replicas failed: %s", e)
+            return []
+
     def list_runs(self, project_id: str) -> list[dict[str, Any]]:
         """GET /projects/{project_id}/runs -- list runs in a project.
 

{openrunner_sdk-2.37.8 → openrunner_sdk-2.37.9}/openrunner/cli.py

@@ -4450,5 +4450,184 @@ def drift_ask_cmd(question, project) -> None:
         click.echo("No answer (LLM provider may be unconfigured).")
         return
     click.echo(f"[{r.get('action')}] {r.get('interpretation')}")
+
+
+# ---------------------------------------------------------------------------
+# deploy group — vendor-agnostic serverless GPU deployments
+# ---------------------------------------------------------------------------
+
+
+def _project_org(client, pid: str) -> str | None:
+    """Best-effort resolve a project's org id (for the GPU price lookup)."""
+    try:
+        r = client._request("get", f"/projects/{pid}")
+        r.raise_for_status()
+        return r.json().get("org_id")
+    except Exception:
+        return None
+
+
+@main.group("deploy")
+def deploy_group() -> None:
+    """Serverless GPU deployments (link image, pick GPU, deploy, scale)."""
+    pass
+
+
+@deploy_group.command("images")
+@click.option("--project", "-p", default=None, help="Project org/name or UUID")
+def deploy_images(project) -> None:
+    """List images linked to a project (the deploy gate)."""
+    client, pid = _drift_client_project(project)
+    imgs = client.list_project_images(pid)
+    client.close()
+    if not imgs:
+        click.echo("No linked images. Link one: openrunner deploy link IMAGE -p ORG/NAME")
+        return
+    for i in imgs:
+        click.echo(f"- {i['image']}  (tag={i.get('tag') or 'latest'}, digest={(i.get('digest') or '-')[:19]})")
+
+
+@deploy_group.command("link")
+@click.argument("image")
+@click.option("--project", "-p", default=None, help="Project org/name or UUID")
+@click.option("--registry-id", default=None, help="Connected registry UUID (private pull)")
+def deploy_link(image, project, registry_id) -> None:
+    """Link a deployable image to a project."""
+    client, pid = _drift_client_project(project)
+    rec = client.link_project_image(pid, image, registry_id=registry_id)
+    client.close()
+    if not rec:
+        click.echo("Error: failed to link image.", err=True)
+        raise SystemExit(1)
+    click.echo(f"Linked {rec['image']} — Deploy is now active for this project.")
+
+
+@deploy_group.command("gpus")
+@click.option("--project", "-p", default=None, help="Project org/name or UUID")
+@click.option("--provider", default="runpod", help="Filter by provider (default: runpod)")
+def deploy_gpus(project, provider) -> None:
+    """List deployable GPU offers (provider · GPU · VRAM · price) for recommendations."""
+    client, pid = _drift_client_project(project)
+    org = _project_org(client, pid)
+    if not org:
+        client.close()
+        click.echo("Error: could not resolve org for prices.", err=True)
+        raise SystemExit(1)
+    try:
+        r = client._request("get", "/gpu/prices", params={"org_id": org})
+        r.raise_for_status()
+        offers = r.json()
+    except Exception as e:
+        client.close()
+        click.echo(f"Error fetching prices: {e}", err=True)
+        raise SystemExit(1)
+    client.close()
+    seen = set()
+    for o in offers:
+        if provider and o.get("provider") != provider:
+            continue
+        key = (o.get("provider"), o.get("gpu_type_normalized"))
+        if key in seen:
+            continue
+        seen.add(key)
+        click.echo(
+            f"- {o.get('provider')} · {o.get('gpu_type_normalized')} · "
+            f"{o.get('gpu_memory_gb')}GB · ${o.get('price_per_hour')}/hr"
+        )
+
+
+@deploy_group.command("create")
+@click.option("--project", "-p", default=None, help="Project org/name or UUID")
+@click.option("--name", "-n", required=True, help="Deployment name")
+@click.option("--image", required=True, help="Image (must be linked to the project)")
+@click.option("--provider", default="runpod", help="Provider (RunPod supported today)")
+@click.option("--gpu", required=True, help="GPU type, e.g. A100_80GB")
+@click.option("--gpu-count", default=1, type=int, help="GPUs per replica")
+@click.option("--min", "min_nodes", default=1, type=int, help="Min replicas")
+@click.option("--max", "max_nodes", default=1, type=int, help="Max replicas")
+@click.option("--metric", default=None, type=click.Choice(["gpu_util", "request_rate", "inflight"]), help="Autoscale metric")
+@click.option("--target", default=None, type=float, help="Autoscale target for --metric")
+@click.option("--port", default=8000, type=int, help="Container port")
+def deploy_create(project, name, image, provider, gpu, gpu_count, min_nodes, max_nodes, metric, target, port) -> None:
+    """Create a serverless GPU deployment for a linked image."""
+    client, pid = _drift_client_project(project)
+    body = {
+        "name": name, "image": image, "provider": provider, "gpu_type": gpu,
+        "gpu_count": gpu_count, "min_nodes": min_nodes, "max_nodes": max_nodes,
+        "container_port": port,
+    }
+    if metric:
+        body["scale_metric"] = metric
+    if target is not None:
+        body["scale_target"] = target
+    dep = client.create_deployment(pid, body)
+    client.close()
+    if not dep:
+        click.echo("Error: failed to create deployment (is the image linked? provider supported?).", err=True)
+        raise SystemExit(1)
+    click.echo(f"Created deployment {dep['name']} [{dep['id']}] status={dep['status']} "
+               f"desired={dep['desired_nodes']} (min {dep['min_nodes']} / max {dep['max_nodes']}).")
+
+
+@deploy_group.command("ls")
+@click.option("--project", "-p", default=None, help="Project org/name or UUID")
+def deploy_ls(project) -> None:
+    """List a project's deployments."""
+    client, pid = _drift_client_project(project)
+    deps = client.list_deployments(pid)
+    client.close()
+    if not deps:
+        click.echo("No deployments.")
+        return
+    for d in deps:
+        click.echo(
+            f"- {d['name']} [{d['id']}] {d['status']} · {d['provider']}/{d['gpu_type']}×{d['gpu_count']} "
+            f"· {d['desired_nodes']}/{d['max_nodes']} desired · {d['image']}"
+        )
+
+
+@deploy_group.command("scale")
+@click.argument("deployment_id")
+@click.option("--project", "-p", default=None, help="Project org/name or UUID")
+@click.option("--to", "desired", required=True, type=int, help="Desired replica count")
+def deploy_scale(deployment_id, project, desired) -> None:
+    """Set a deployment's desired replica count (clamped to [min,max])."""
+    client, pid = _drift_client_project(project)
+    d = client.scale_deployment(pid, deployment_id, desired)
+    client.close()
+    if not d:
+        click.echo("Error: scale failed.", err=True)
+        raise SystemExit(1)
+    click.echo(f"{d['name']} → desired={d['desired_nodes']} status={d['status']}")
+
+
+@deploy_group.command("replicas")
+@click.argument("deployment_id")
+@click.option("--project", "-p", default=None, help="Project org/name or UUID")
+def deploy_replicas(deployment_id, project) -> None:
+    """List a deployment's replica pods."""
+    client, pid = _drift_client_project(project)
+    reps = client.deployment_replicas(pid, deployment_id)
+    client.close()
+    if not reps:
+        click.echo("No replicas.")
+        return
+    for r in reps:
+        host = f"{r.get('ssh_host')}:{r.get('ssh_port')}" if r.get("ssh_host") else "-"
+        click.echo(f"- #{r.get('replica_index')} {r['status']} {host}")
+
+
+@deploy_group.command("rm")
+@click.argument("deployment_id")
+@click.option("--project", "-p", default=None, help="Project org/name or UUID")
+def deploy_rm(deployment_id, project) -> None:
+    """Tear down a deployment (terminates all replicas)."""
+    client, pid = _drift_client_project(project)
+    d = client.delete_deployment(pid, deployment_id)
+    client.close()
+    if not d:
+        click.echo("Error: delete failed.", err=True)
+        raise SystemExit(1)
+    click.echo(f"Deployment {d['name']} deleted (replicas terminating).")
     import json as _json
     click.echo(_json.dumps(r.get("data", {}), indent=2)[:2000])

{openrunner_sdk-2.37.8 → openrunner_sdk-2.37.9}/openrunner/install_commands.py

@@ -2799,6 +2799,77 @@ AFTER the response is produced, insert a wrapped `record_inference(...)`:
 """
 
 
+DEPLOY_CMD = """---
+name: {prefix}deploy
+description: Interactively deploy a project's model image on serverless GPUs -- reads the model card's measured results to RECOMMEND a GPU (VRAM headroom) + platform (price/availability), asks you to confirm platform + GPU, sets replica bounds/autoscale, creates the deployment and watches it roll out
+argument-hint: "[project org/name] [--image REF] [--name NAME]"
+allowed-tools:
+  - Bash
+  - Read
+  - Grep
+  - Glob
+  - AskUserQuestion
+---
+
+Deploy a model image on governed, autoscaled GPUs -- with a GPU/platform
+**recommendation grounded in the model card's measured results**, then an
+interactive confirm. Never guess sizing; read real numbers.
+
+## Step 1 -- project + a deployable image
+- Resolve the project (arg `org/name`, else `openrunner` config / ask).
+- `openrunner deploy images -p ORG/NAME`. If none linked: take `--image REF`
+  (or ask), then `openrunner deploy link REF -p ORG/NAME` (add `--registry-id`
+  for a private image). A project needs >=1 linked image before it can deploy.
+
+## Step 2 -- read the model card's MEASURED results (drives the recommendation)
+Pull the model card + run summary and extract, with numbers only:
+- parameter count / model size on disk, and serving **precision** (fp16/bf16/int8/
+  fp8) -- from the card or the run `config`/`summary`.
+- measured **peak VRAM** at inference, **throughput** (req/s or tok/s), **latency**
+  (p50/p95), and the **batch size** they were measured at.
+- Use MCP when available (`mcp__openrunner__openrunner_search_papers` /
+  model-card tools / `openrunner_get_run_metrics`); else read the card markdown /
+  repo reports. If a figure is missing, say so -- do NOT invent it; estimate VRAM
+  as `params x bytes/param x ~1.2 overhead` and LABEL it an estimate.
+
+## Step 3 -- recommend a GPU + platform
+- `openrunner deploy gpus -p ORG/NAME` lists offers (provider · GPU · VRAM · $/hr).
+- Recommend the **cheapest GPU whose VRAM comfortably fits** measured/estimated
+  peak VRAM with headroom (>=20-30%% for activations/batch growth); prefer the
+  provider with the best price and availability. Note when a bigger GPU is needed
+  for the target batch/throughput, or when int8/fp8 lets a smaller GPU fit.
+- Summarise the reasoning in 2-3 lines (VRAM need vs GPU VRAM, $/hr, why).
+
+## Step 4 -- confirm platform + GPU (interactive)
+Use AskUserQuestion with the recommendation FIRST and marked "(Recommended)":
+- **Platform**: the supported providers (RunPod today; others are pricing-only).
+- **GPU**: 3-4 offers spanning the recommendation +/- one size, each labelled with
+  VRAM + $/hr so the trade-off is visible.
+Then ask replica bounds + autoscale:
+- **min / max replicas** (min 0 = scale-to-zero: cheap + spiky, but cold start ~
+  minutes; min 1 = always warm).
+- **autoscale**: manual, or a metric (`gpu_util` / `request_rate` / `inflight`)
+  with a target.
+
+## Step 5 -- create + watch
+- `openrunner deploy create -p ORG/NAME --name NAME --image REF --provider P
+  --gpu GPU [--gpu-count N] --min MIN --max MAX [--metric M --target T]`.
+- Poll `openrunner deploy ls -p ORG/NAME` + `openrunner deploy replicas <id>
+  -p ORG/NAME` until replicas are running; report status + the endpoint URL when
+  the router assigns one. Scale later with `openrunner deploy scale <id> --to N`.
+
+## Guardrails
+- Ground every sizing number in the card/run; label anything estimated. Never
+  fabricate VRAM/throughput.
+- Deploying spends real money at the provider -- show the picked GPU + $/hr and
+  CONFIRM before `create`. Mention scale-to-zero to cap idle cost.
+- Fit VRAM with headroom; warn if the recommendation is tight for the target
+  batch.
+- RunPod is the only real provisioning adapter today; other providers are
+  pricing-only -- say so if picked.
+"""
+
+
 BUILD_API_CMD = """---
 name: {prefix}build-api
 description: Scaffold a production inference API for a model in THIS repo -- FastAPI /predict + /health, typed request/response, Dockerfile (pushable via the OpenRunner registry), env config, and optional baked-in drift monitoring; ready to deploy on governed GPUs
@@ -2899,6 +2970,7 @@ def install_claude_code() -> list[str]:
         "drift.md": DRIFT_CMD,
         "drift-install.md": DRIFT_INSTALL_CMD,
         "build-api.md": BUILD_API_CMD,
+        "deploy.md": DEPLOY_CMD,
     }
 
     files = []
@@ -3104,6 +3176,7 @@ def _install_all_commands_to_dir(cmd_dir: Path, prefix: str = "openrunner:") ->
         "drift.md": DRIFT_CMD,
         "drift-install.md": DRIFT_INSTALL_CMD,
         "build-api.md": BUILD_API_CMD,
+        "deploy.md": DEPLOY_CMD,
     }
 
     files = []

{openrunner_sdk-2.37.8 → openrunner_sdk-2.37.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "openrunner-sdk"
-version = "2.37.8"
+version = "2.37.9"
 description = "OpenRunner SDK - W&B-compatible ML experiment tracking client"
 readme = "README.md"
 license = {text = "MIT"}