openrunner-sdk 2.37.28__tar.gz → 2.37.30__tar.gz

{openrunner_sdk-2.37.28 → openrunner_sdk-2.37.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrunner-sdk
-Version: 2.37.28
+Version: 2.37.30
 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.28 → openrunner_sdk-2.37.30}/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.28"
+__version__ = "2.37.30"
 
 logger = logging.getLogger("openrunner")
 

{openrunner_sdk-2.37.28 → openrunner_sdk-2.37.30}/openrunner/cli.py

@@ -57,6 +57,64 @@ def _auto_install_commands() -> None:
         pass  # never crash on auto-install
 
 
+# ---------------------------------------------------------------------------
+# Update awareness — know when a newer SDK is on PyPI
+# ---------------------------------------------------------------------------
+
+_PYPI_JSON = "https://pypi.org/pypi/openrunner-sdk/json"
+
+
+def _latest_pypi_version(timeout: float = 3.0) -> str | None:
+    """Return the latest openrunner-sdk version on PyPI, or None on any failure.
+    Never raises — update awareness must never break a command."""
+    try:
+        import urllib.request
+
+        with urllib.request.urlopen(_PYPI_JSON, timeout=timeout) as r:
+            import json as _json
+            return _json.load(r).get("info", {}).get("version")
+    except Exception:
+        return None
+
+
+def _version_tuple(v: str) -> tuple:
+    out = []
+    for part in str(v).split("."):
+        num = "".join(c for c in part if c.isdigit())
+        out.append(int(num) if num else 0)
+    return tuple(out)
+
+
+def check_for_update(force: bool = False, cache_hours: float = 24.0) -> dict:
+    """Compare the installed SDK to the latest on PyPI.
+
+    Returns {installed, latest, update_available}. Caches the PyPI answer in
+    ~/.openrunner/.update_check (mtime-based) so it hits the network at most once
+    per cache window unless force=True.
+    """
+    from openrunner import __version__ as installed
+    cache = _settings_dir() / ".update_check"
+    latest = None
+    if not force:
+        try:
+            import os as _os
+            import time as _time
+            if cache.exists() and (_time.time() - _os.path.getmtime(cache)) < cache_hours * 3600:
+                latest = cache.read_text().strip() or None
+        except Exception:
+            latest = None
+    if latest is None:
+        latest = _latest_pypi_version()
+        if latest:
+            try:
+                cache.parent.mkdir(parents=True, exist_ok=True)
+                cache.write_text(latest)
+            except Exception:
+                pass
+    avail = bool(latest) and _version_tuple(latest) > _version_tuple(installed)
+    return {"installed": installed, "latest": latest, "update_available": avail}
+
+
 # ---------------------------------------------------------------------------
 # Settings helpers
 # ---------------------------------------------------------------------------
@@ -2980,6 +3038,23 @@ def install_commands(tools: tuple) -> None:
     click.echo("  Or: openrunner mcp install")
 
 
+@main.command("version")
+@click.option("--check", is_flag=True, help="Also check PyPI for a newer release")
+def version_cmd(check: bool) -> None:
+    """Show the installed SDK version (and whether an update is available)."""
+    from openrunner import __version__
+    if not check:
+        click.echo(__version__)
+        return
+    info = check_for_update(force=True)
+    click.echo(f"installed: {info['installed']}")
+    click.echo(f"latest:    {info.get('latest') or '(unknown — offline?)'}")
+    if info["update_available"]:
+        click.echo("Update available. Run: openrunner update")
+    elif info.get("latest"):
+        click.echo("Up to date.")
+
+
 @main.command("update")
 @click.option("--pre", is_flag=True, help="Include pre-releases")
 @click.option("--no-reinstall", is_flag=True, help="Only upgrade the package; skip reinstalling slash commands")
@@ -2995,7 +3070,13 @@ def update_cmd(pre: bool, no_reinstall: bool) -> None:
 
     from openrunner import __version__ as _cur
 
-    click.echo(f"Current openrunner-sdk: {_cur}")
+    info = check_for_update(force=True)
+    latest = info.get("latest")
+    click.echo(f"Current openrunner-sdk: {_cur}" + (f" — latest: {latest}" if latest else ""))
+    if latest and not info["update_available"]:
+        click.echo("Already up to date.")
+        if no_reinstall:
+            return
     cmd = [sys.executable, "-m", "pip", "install", "--upgrade", "--no-cache-dir"]
     if pre:
         cmd.append("--pre")

{openrunner_sdk-2.37.28 → openrunner_sdk-2.37.30}/openrunner/install_commands.py

@@ -434,12 +434,21 @@ Report result to user.
 
 UPDATE_CMD = """---
 name: {prefix}update
-description: Update OpenRunner SDK and reinstall all commands
+description: Check for + install the latest OpenRunner SDK and reinstall all commands (skills + MCP)
 allowed-tools:
   - Bash
 ---
 
-Upgrade openrunner-sdk and reinstall slash commands:
+First CHECK whether a newer release exists, then upgrade if so. The SDK is
+update-aware: `openrunner version --check` compares the installed version to PyPI,
+and the `openrunner_check_update` MCP tool does the same for an assistant.
+
+```bash
+openrunner version --check 2>/dev/null || true
+```
+
+If it says "Up to date", stop and tell the user. If an update is available (or
+the check couldn't run), upgrade openrunner-sdk and reinstall slash commands:
 
 ```bash
 pip install --upgrade --no-cache-dir openrunner-sdk 2>&1 | tail -3 && python3 -c "
@@ -2400,8 +2409,11 @@ in the web UI, or ask an org admin. Then ask the user for their provider API key
 openrunner gpu credentials add --org ORG_ID --provider runpod --api-key PROVIDER_KEY
 ```
 
-Only **RunPod** supports fully server-side provisioning today. Vast.ai, Lambda,
-etc. have stored keys used for **pricing**; launch those via their own tooling.
+Server-side provisioning adapters: **RunPod, Vast.ai, OVH** (self-enroll, no SSH)
+and **Lambda** (SSH — no boot hook). AWS/GCP have no native launch — provision the
+box yourself then `openrunner runner enroll --cloud-init` (user-data /
+startup-script). OVH's stored key is a JSON blob (app_key/secret/consumer_key/
+service_name); Lambda's is `{{api_key, ssh_key_names[]}}`.
 
 ## Step 3 -- Pick GPU, image, command
 
@@ -3082,8 +3094,9 @@ Gather the real options (don't hardcode):
 - **Cloud offers**: `openrunner deploy gpus -p ORG/NAME` (or the GPU prices
   endpoint) -> provider - GPU - VRAM - $/hr, for providers the org has a stored
   credential for (`openrunner gpu credentials ls`).
-- Note which providers have a **server-side adapter** (RunPod today) vs
-  pricing-only, and which registered hosts are `active`.
+- Note which providers have a **provisioning adapter** (RunPod, Vast.ai, OVH via
+  `runner launch`/`gpu run`; Lambda via `gpu run`, SSH) vs enroll-only (AWS/GCP →
+  `runner enroll --cloud-init`), and which registered hosts/runners are `active`.
 
 ## Step 2 -- interpret the NL request (map intent -> concrete target)
 From the user's phrasing, resolve a single target + shape:
@@ -3152,8 +3165,9 @@ directly SSH-reachable** (`publicIp:22`): SSH is only via the **proxy**
   it rather than leaving it billing.
 - Ground VRAM/fit claims in the model card; label estimates.
 - SSH-less by default: reach for the RUNNER model (A) unless a host has verified
-  direct SSH. Only RunPod has a server-side cloud adapter; others are
-  pricing-only (need a client-side key via -e).
+  direct SSH. Provisioning adapters: RunPod / Vast.ai / OVH (`runner launch`,
+  self-enroll, no SSH) and Lambda (`gpu run`, SSH — no boot hook). AWS/GCP have no
+  native launch -> `runner enroll --cloud-init` (user-data / startup-script).
 """
 
 
@@ -3200,7 +3214,8 @@ Pull the model card + run summary and extract, with numbers only:
 
 ## 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).
+- **Platform**: providers with a provisioning adapter (RunPod, Vast.ai, OVH,
+  Lambda). AWS/GCP are pricing/enroll-only for deployments.
 - **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:
@@ -3223,8 +3238,8 @@ Then ask replica bounds + autoscale:
   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.
+- Provisioning adapters: RunPod, Vast.ai, OVH, Lambda. AWS/GCP have no native
+  deploy adapter -- say so if picked.
 """
 
 

{openrunner_sdk-2.37.28 → openrunner_sdk-2.37.30}/openrunner/mcp_server.py

@@ -1428,6 +1428,17 @@ def create_server():
                     "required": ["org"],
                 },
             ),
+            Tool(
+                name="openrunner_check_update",
+                description=(
+                    "Check whether a newer openrunner-sdk is available on PyPI vs the "
+                    "installed version. Returns installed + latest + whether an update is "
+                    "available, and the command to run (`openrunner update`). Call this "
+                    "when the user asks to update OpenRunner or whether they're on the "
+                    "latest version — then, if they confirm, run `openrunner update`."
+                ),
+                inputSchema={"type": "object", "properties": {}, "required": []},
+            ),
         ]
 
     @server.call_tool()
@@ -1534,6 +1545,8 @@ def create_server():
                 result = await _tool_submit_job(arguments)
             elif name == "openrunner_list_jobs":
                 result = await _tool_list_jobs(arguments)
+            elif name == "openrunner_check_update":
+                result = await _tool_check_update(arguments)
             else:
                 result = f"Unknown tool: {name}"
         except RuntimeError as e:
@@ -4299,3 +4312,34 @@ async def _tool_list_jobs(args: dict) -> str:
         for j in rows[:30]
     ]
     return "Jobs:\n" + "\n".join(lines)
+
+
+async def _tool_check_update(args: dict) -> str:
+    """Report installed vs latest openrunner-sdk on PyPI (no network via the API —
+    queries PyPI directly)."""
+    from openrunner import __version__ as installed
+
+    latest = None
+    try:
+        import urllib.request
+
+        def _fetch():
+            with urllib.request.urlopen("https://pypi.org/pypi/openrunner-sdk/json", timeout=5) as r:
+                import json as _json
+                return _json.load(r).get("info", {}).get("version")
+
+        import asyncio as _asyncio
+        latest = await _asyncio.to_thread(_fetch)
+    except Exception as e:
+        return f"installed: {installed}\nCould not reach PyPI to check latest ({e})."
+
+    def _vt(v):
+        return tuple(int("".join(c for c in p if c.isdigit()) or 0) for p in str(v).split("."))
+
+    avail = bool(latest) and _vt(latest) > _vt(installed)
+    if avail:
+        return (f"installed: {installed}\nlatest: {latest}\nUPDATE AVAILABLE.\n"
+                "To update: run `openrunner update` in the terminal (upgrades the SDK "
+                "+ reinstalls the /openrunner slash commands). Ask the user to confirm, "
+                "then run it.")
+    return f"installed: {installed}\nlatest: {latest}\nUp to date."

{openrunner_sdk-2.37.28 → openrunner_sdk-2.37.30}/pyproject.toml

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