openrunner-sdk 2.24.0__tar.gz → 2.24.2__tar.gz

{openrunner_sdk-2.24.0 → openrunner_sdk-2.24.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrunner-sdk
-Version: 2.24.0
+Version: 2.24.2
 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.24.0 → openrunner_sdk-2.24.2}/openrunner/__init__.py

@@ -121,7 +121,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.24.0"
+__version__ = "2.24.2"
 
 logger = logging.getLogger("openrunner")
 

{openrunner_sdk-2.24.0 → openrunner_sdk-2.24.2}/openrunner/api_client.py

@@ -89,7 +89,7 @@ class APIClient:
 
     def _request(self, method: str, path: str, **kwargs) -> httpx.Response:
         """Make an HTTP request with automatic retry on transient failures."""
-        return _retry_request(getattr(self._client, method), path, **kwargs)
+        return _retry_request(getattr(self._client, method.lower()), path, **kwargs)
 
     def create_run(self, data: dict[str, Any]) -> dict[str, Any] | None:
         """POST /runs -- create a new run on the server.

{openrunner_sdk-2.24.0 → openrunner_sdk-2.24.2}/openrunner/cli.py

@@ -3294,6 +3294,22 @@ def patent_scan(
             click.echo("Error: --project required or set in .openrunner/settings.json", err=True)
             sys.exit(1)
 
+    # Resolve project name → UUID if needed
+    project_id = project
+    if project and api_key and not dry_run:
+        try:
+            _client = APIClient(api_key=api_key, base_url=base_url)
+            _resp = _client._request("get", "/projects")
+            if _resp.status_code == 200:
+                for p in _resp.json():
+                    org = p.get("org_name", "")
+                    name = p.get("name", "")
+                    if f"{org}/{name}" == project or name == project:
+                        project_id = p["id"]
+                        break
+        except Exception:
+            pass  # fall back to using project as-is
+
     # Determine commits to scan
     if commit:
         commits = [commit]
@@ -3350,12 +3366,12 @@ def patent_scan(
                 click.echo(f"    CPC: {', '.join(la.cpc_classes)}")
 
         # Upload
-        if not dry_run and api_key and project:
+        if not dry_run and api_key and project_id:
             try:
                 client = APIClient(api_key=api_key, base_url=base_url)
                 resp = client._request(
-                    "POST",
-                    f"/projects/{project}/patent-lab/entries",
+                    "post",
+                    f"/projects/{project_id}/patent-lab/entries",
                     json=result.to_api_payload(),
                 )
                 if resp.status_code == 201:
@@ -3395,6 +3411,21 @@ def patent_lab(project: str | None, min_score: int, status: str | None, limit: i
         sys.exit(1)
 
     client = APIClient(api_key=api_key, base_url=base_url)
+
+    # Resolve project name → UUID
+    project_id = project
+    try:
+        _resp = client._request("get", "/projects")
+        if _resp.status_code == 200:
+            for p in _resp.json():
+                org = p.get("org_name", "")
+                name = p.get("name", "")
+                if f"{org}/{name}" == project or name == project:
+                    project_id = p["id"]
+                    break
+    except Exception:
+        pass
+
     params: dict = {"limit": limit}
     if min_score:
         params["min_score"] = min_score
@@ -3403,8 +3434,8 @@ def patent_lab(project: str | None, min_score: int, status: str | None, limit: i
 
     try:
         resp = client._request(
-            "GET",
-            f"/projects/{project}/patent-lab/entries",
+            "get",
+            f"/projects/{project_id}/patent-lab/entries",
             params=params,
         )
         data = resp.json()

openrunner_sdk-2.24.2/openrunner/integration/skypilot.py

@@ -0,0 +1,447 @@
+"""SkyPilot integration for OpenRunner.
+
+Launch training jobs on any cloud with automatic cost tracking,
+spot recovery awareness, and experiment run linking.
+
+SkyPilot (Apache 2.0) provides multi-cloud GPU orchestration.
+This integration wraps sky.launch() to auto-inject OpenRunner
+env vars and map $SKYPILOT_TASK_ID to run IDs for unified
+tracking across spot preemptions.
+
+Usage:
+    import openrunner
+    from openrunner.integration.skypilot import launch, managed_job
+
+    # Launch a training job on cheapest available GPU
+    cluster = launch(
+        task_yaml="train.yaml",
+        project="my-project",
+        name="gpt-finetune",
+        gpus="A100:4",
+        use_spot=True,
+    )
+
+    # Or use managed jobs (auto-recovery on preemption)
+    job = managed_job(
+        task_yaml="train.yaml",
+        project="my-project",
+        name="long-training",
+        gpus="A100:8",
+    )
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger("openrunner.skypilot")
+
+
+def _check_skypilot() -> None:
+    """Verify SkyPilot is installed."""
+    try:
+        import sky  # noqa: F401
+    except ImportError:
+        raise ImportError(
+            "SkyPilot is not installed. Install with: "
+            "pip install 'skypilot[aws]' or pip install 'skypilot[gcp]' etc."
+        )
+
+
+def _get_openrunner_envs(project: str | None = None) -> dict[str, str]:
+    """Build env vars to inject into SkyPilot tasks for OpenRunner tracking."""
+    from openrunner.settings import SDKSettings
+
+    settings = SDKSettings()
+    envs: dict[str, str] = {}
+
+    # API key
+    if settings.api_key:
+        envs["OPENRUNNER_API_KEY"] = settings.api_key
+    elif os.environ.get("OPENRUNNER_API_KEY"):
+        envs["OPENRUNNER_API_KEY"] = os.environ["OPENRUNNER_API_KEY"]
+
+    # Base URL
+    if settings.base_url:
+        envs["OPENRUNNER_BASE_URL"] = settings.base_url
+
+    # Project
+    if project:
+        envs["OPENRUNNER_PROJECT"] = project
+    elif settings.project:
+        envs["OPENRUNNER_PROJECT"] = settings.project
+
+    return envs
+
+
+def _inject_envs_into_yaml(yaml_path: str, envs: dict[str, str]) -> str:
+    """Read a SkyPilot YAML, inject envs, return path to modified YAML."""
+    import yaml as pyyaml
+
+    with open(yaml_path) as f:
+        task = pyyaml.safe_load(f)
+
+    existing = task.get("envs", {}) or {}
+    existing.update(envs)
+
+    # Add setup command to install openrunner-sdk if not present
+    setup = task.get("setup", "") or ""
+    if "openrunner" not in setup:
+        setup = "pip install openrunner-sdk > /dev/null 2>&1\n" + setup
+        task["setup"] = setup
+
+    task["envs"] = existing
+
+    # Write to temp file
+    tmp = tempfile.NamedTemporaryFile(
+        mode="w", suffix=".yaml", prefix="openrunner-sky-",
+        delete=False,
+    )
+    pyyaml.dump(task, tmp, default_flow_style=False)
+    tmp.close()
+    return tmp.name
+
+
+def launch(
+    task_yaml: str,
+    *,
+    project: str | None = None,
+    name: str | None = None,
+    cluster: str | None = None,
+    gpus: str | None = None,
+    use_spot: bool = False,
+    idle_minutes: int | None = 10,
+    down: bool = False,
+    env: dict[str, str] | None = None,
+    dryrun: bool = False,
+) -> dict[str, Any]:
+    """Launch a SkyPilot task with OpenRunner tracking auto-configured.
+
+    Injects OPENRUNNER_API_KEY, OPENRUNNER_BASE_URL, and OPENRUNNER_PROJECT
+    into the task's environment. The training script should use
+    $SKYPILOT_TASK_ID as the run name for unified tracking across
+    spot recovery attempts.
+
+    Args:
+        task_yaml: Path to SkyPilot task YAML file.
+        project: OpenRunner project name (auto-detected if not set).
+        name: Cluster name (auto-generated if not set).
+        cluster: Existing cluster to reuse.
+        gpus: GPU spec override (e.g., "A100:4", "H100:8").
+        use_spot: Use spot/preemptible instances.
+        idle_minutes: Auto-stop after N idle minutes (None to disable).
+        down: Tear down cluster after job finishes.
+        env: Additional environment variables.
+        dryrun: If True, print the command without executing.
+
+    Returns:
+        Dict with cluster_name, status, and job info.
+    """
+    _check_skypilot()
+
+    # Build env vars
+    envs = _get_openrunner_envs(project)
+    if env:
+        envs.update(env)
+
+    # Add spot recovery hint
+    envs["OPENRUNNER_SPOT_RECOVERY"] = "1" if use_spot else "0"
+
+    # Inject into YAML
+    modified_yaml = _inject_envs_into_yaml(task_yaml, envs)
+
+    try:
+        import sky
+
+        task = sky.Task.from_yaml(modified_yaml)
+
+        if gpus:
+            task.set_resources(sky.Resources(accelerators=gpus, use_spot=use_spot))
+        elif use_spot:
+            resources = task.resources
+            if resources:
+                res = list(resources)[0]
+                task.set_resources(res.copy(use_spot=True))
+
+        if dryrun:
+            logger.info("Dryrun: would launch %s with envs: %s", task_yaml, list(envs.keys()))
+            return {"status": "dryrun", "yaml": modified_yaml, "envs": list(envs.keys())}
+
+        cluster_name = cluster or name
+        kwargs: dict[str, Any] = {}
+        if cluster_name:
+            kwargs["cluster_name"] = cluster_name
+        if idle_minutes is not None:
+            kwargs["idle_minutes_to_autostop"] = idle_minutes
+        if down:
+            kwargs["down"] = True
+
+        request_id = sky.launch(task, **kwargs)
+
+        result = {
+            "status": "launched",
+            "cluster_name": cluster_name,
+            "request_id": str(request_id) if request_id else None,
+            "use_spot": use_spot,
+            "envs_injected": list(envs.keys()),
+        }
+        logger.info("SkyPilot launch: %s", result)
+        return result
+
+    finally:
+        # Cleanup temp file
+        try:
+            os.unlink(modified_yaml)
+        except OSError:
+            pass
+
+
+def managed_job(
+    task_yaml: str,
+    *,
+    project: str | None = None,
+    name: str | None = None,
+    gpus: str | None = None,
+    env: dict[str, str] | None = None,
+    dryrun: bool = False,
+) -> dict[str, Any]:
+    """Submit a SkyPilot managed job with auto-recovery and OpenRunner tracking.
+
+    Managed jobs automatically recover from spot preemptions and hardware
+    failures. Use $SKYPILOT_TASK_ID in your training script as the
+    OpenRunner run name to unify metrics across recovery attempts.
+
+    Example training script:
+        import os, openrunner
+        run = openrunner.init(
+            project=os.environ.get("OPENRUNNER_PROJECT", "default"),
+            name=os.environ.get("SKYPILOT_TASK_ID", "local"),
+            resume="allow",  # Resume from checkpoint on recovery
+        )
+    """
+    _check_skypilot()
+
+    envs = _get_openrunner_envs(project)
+    envs["OPENRUNNER_SPOT_RECOVERY"] = "1"
+    if env:
+        envs.update(env)
+
+    modified_yaml = _inject_envs_into_yaml(task_yaml, envs)
+
+    try:
+        import sky
+
+        task = sky.Task.from_yaml(modified_yaml)
+
+        if gpus:
+            task.set_resources(sky.Resources(accelerators=gpus, use_spot=True))
+
+        if dryrun:
+            logger.info("Dryrun: would submit managed job %s", task_yaml)
+            return {"status": "dryrun", "yaml": modified_yaml}
+
+        kwargs: dict[str, Any] = {}
+        if name:
+            kwargs["name"] = name
+
+        request_id = sky.jobs.launch(task, **kwargs)
+
+        result = {
+            "status": "submitted",
+            "name": name,
+            "request_id": str(request_id) if request_id else None,
+            "envs_injected": list(envs.keys()),
+        }
+        logger.info("SkyPilot managed job: %s", result)
+        return result
+
+    finally:
+        try:
+            os.unlink(modified_yaml)
+        except OSError:
+            pass
+
+
+def get_cluster_cost(cluster_name: str) -> dict[str, Any] | None:
+    """Query SkyPilot for cluster cost information.
+
+    Returns estimated cost data from the cluster's lifecycle.
+    """
+    try:
+        import sky
+        status = sky.status(cluster_names=[cluster_name])
+        if not status:
+            return None
+
+        info = status[0]
+        return {
+            "cluster_name": cluster_name,
+            "cloud": str(info.get("cloud", "")),
+            "instance_type": str(info.get("instance_type", "")),
+            "accelerators": str(info.get("accelerators", "")),
+            "use_spot": info.get("use_spot", False),
+            "region": str(info.get("region", "")),
+            "status": str(info.get("status", "")),
+            "launched_at": str(info.get("launched_at", "")),
+            "last_use": str(info.get("last_use", "")),
+        }
+    except Exception as e:
+        logger.warning("Failed to get cluster cost for %s: %s", cluster_name, e)
+        return None
+
+
+def launch_with_catalog(
+    task_yaml: str,
+    *,
+    org_id: str,
+    table: str = "utterances",
+    filter: str = "",
+    export_format: str = "jsonl",
+    limit: int = 0,
+    mount_path: str = "/mnt/catalog",
+    project: str | None = None,
+    gpus: str | None = None,
+    use_spot: bool = False,
+    env: dict[str, str] | None = None,
+    dryrun: bool = False,
+) -> dict[str, Any]:
+    """Launch a SkyPilot task with OpenRunner catalog data auto-mounted.
+
+    Queries the catalog API for the storage connection, then injects
+    file_mounts and catalog env vars into the SkyPilot YAML. The
+    training script can access catalog data at mount_path.
+
+    Example:
+        from openrunner.integration.skypilot import launch_with_catalog
+
+        launch_with_catalog(
+            "train.yaml",
+            org_id="my-org-uuid",
+            table="utterances",
+            filter="primary_language = 'en' AND duration_s > 1.0",
+            gpus="A100:4",
+            use_spot=True,
+        )
+
+    The training script should:
+    1. Read the manifest at /tmp/manifest.jsonl (exported via CLI)
+    2. Or directly access /mnt/catalog/ for raw LanceDB data
+    3. Use $SKYPILOT_TASK_ID as the OpenRunner run name
+    """
+    _check_skypilot()
+
+    from openrunner.api_client import APIClient
+    from openrunner.settings import SDKSettings
+
+    settings = SDKSettings()
+    client = APIClient(
+        base_url=settings.base_url or "https://openrun.gladia.io/api/v1",
+        api_key=settings.api_key or "",
+    )
+
+    # Fetch catalog connection info from the API
+    try:
+        resp = client._session.get(
+            f"{client._base_url}/organizations/{org_id}/catalog/status",
+        )
+        resp.raise_for_status()
+        status = resp.json()
+    except Exception as e:
+        logger.error("Failed to fetch catalog status: %s", e)
+        raise RuntimeError(f"Cannot access catalog for org {org_id}: {e}")
+    finally:
+        client.close()
+
+    if not status.get("configured"):
+        raise RuntimeError("No catalog storage connection configured for this organization")
+
+    bucket = status["bucket"]
+    prefix = status.get("prefix", "")
+    endpoint = status.get("endpoint", "")
+
+    # Build S3 source for file_mounts
+    s3_source = f"s3://{bucket}"
+    if prefix:
+        s3_source += f"/{prefix}"
+
+    # Inject catalog env vars + file_mounts into YAML
+    import yaml as pyyaml
+
+    with open(task_yaml) as f:
+        task = pyyaml.safe_load(f)
+
+    # Add file_mounts
+    mounts = task.get("file_mounts", {}) or {}
+    mounts[mount_path] = {"source": s3_source, "mode": "MOUNT"}
+    task["file_mounts"] = mounts
+
+    # Add catalog env vars
+    existing_envs = task.get("envs", {}) or {}
+    existing_envs.update({
+        "CATALOG_TABLE": table,
+        "CATALOG_FILTER": filter,
+        "CATALOG_FORMAT": export_format,
+        "CATALOG_LIMIT": str(limit) if limit else "0",
+        "CATALOG_S3_ENDPOINT": endpoint,
+        "CATALOG_S3_BUCKET": bucket,
+        "CATALOG_S3_PREFIX": prefix,
+    })
+    task["envs"] = existing_envs
+
+    # Write modified YAML
+    tmp = tempfile.NamedTemporaryFile(
+        mode="w", suffix=".yaml", prefix="openrunner-catalog-sky-",
+        delete=False,
+    )
+    pyyaml.dump(task, tmp, default_flow_style=False)
+    tmp.close()
+
+    # Delegate to regular launch
+    try:
+        return launch(
+            tmp.name,
+            project=project,
+            gpus=gpus,
+            use_spot=use_spot,
+            env=env,
+            dryrun=dryrun,
+        )
+    finally:
+        try:
+            os.unlink(tmp.name)
+        except OSError:
+            pass
+
+
+def list_gpu_prices(accelerator: str = "A100") -> list[dict[str, Any]]:
+    """List GPU prices across clouds using SkyPilot's catalog.
+
+    Returns sorted list of (cloud, instance, region, price) for the
+    given accelerator type.
+    """
+    try:
+        import sky
+        gpus = sky.show_gpus(accelerator, return_data=True)
+        if not gpus:
+            return []
+        return [
+            {
+                "cloud": str(row.get("Cloud", "")),
+                "instance": str(row.get("Instance", "")),
+                "accelerator": str(row.get("Accelerator", "")),
+                "count": row.get("Count", 1),
+                "region": str(row.get("Region", "")),
+                "price_per_hour": row.get("Price", 0.0),
+                "spot_price": row.get("Spot Price", None),
+            }
+            for row in gpus
+        ]
+    except Exception as e:
+        logger.warning("Failed to list GPU prices: %s", e)
+        return []

{openrunner_sdk-2.24.0 → openrunner_sdk-2.24.2}/openrunner/mcp_server.py

@@ -517,6 +517,41 @@ def create_server():
                     "required": ["idea"],
                 },
             ),
+            Tool(
+                name="openrunner_patent_agent",
+                description=(
+                    "Run a Claude Code agent on a patent lab entry SERVER-SIDE. "
+                    "The server spawns a Claude Code agent with patent-creator MCP tools "
+                    "to perform deep patent analysis. Tasks: analyze (patentability + prior art), "
+                    "draft-claims, prior-art (comprehensive search), full-disclosure, "
+                    "review (USPTO compliance). Results are stored in the patent lab entry."
+                ),
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "entry_id": {
+                            "type": "string",
+                            "description": "Patent lab entry UUID to analyze",
+                        },
+                        "task": {
+                            "type": "string",
+                            "description": "Task: analyze, draft-claims, prior-art, full-disclosure, review",
+                            "enum": ["analyze", "draft-claims", "prior-art", "full-disclosure", "review"],
+                            "default": "analyze",
+                        },
+                        "project": {
+                            "type": "string",
+                            "description": "Project name (format: org/project)",
+                        },
+                        "max_budget_usd": {
+                            "type": "number",
+                            "description": "Max budget for agent run in USD (default: 2.0)",
+                            "default": 2.0,
+                        },
+                    },
+                    "required": ["entry_id"],
+                },
+            ),
             Tool(
                 name="openrunner_patent_report",
                 description=(
@@ -621,6 +656,8 @@ def create_server():
                 result = await _tool_patent_lab_list(arguments)
             elif name == "openrunner_patent_analyze":
                 result = await _tool_patent_analyze(arguments)
+            elif name == "openrunner_patent_agent":
+                result = await _tool_patent_agent(arguments)
             elif name == "openrunner_patent_report":
                 result = await _tool_patent_report(arguments)
             else:
@@ -1829,6 +1866,48 @@ def _text_similarity(text1: str, text2: str) -> float:
     return len(intersection) / len(union)
 
 
+async def _tool_patent_agent(arguments: dict) -> str:
+    """Run a Claude Code agent on a patent entry via server API."""
+    project = arguments.get("project") or _resolve_project()
+    if not project:
+        return "No project specified."
+
+    entry_id = arguments.get("entry_id")
+    if not entry_id:
+        return "entry_id is required."
+
+    task = arguments.get("task", "analyze")
+    max_budget = arguments.get("max_budget_usd", 2.0)
+
+    project_id = await _resolve_project_id(project)
+    if not project_id:
+        return f"Project '{project}' not found."
+
+    try:
+        resp = await _api_post(
+            f"/projects/{project_id}/patent-lab/entries/{entry_id}/agent",
+            data={
+                "task": task,
+                "max_budget_usd": max_budget,
+            },
+        )
+        status = resp.get("status", "unknown")
+        output = resp.get("output", "")
+        cost = resp.get("cost_usd", 0)
+        duration = resp.get("duration_ms", 0)
+
+        return (
+            f"Patent agent completed.\n"
+            f"  Task: {task}\n"
+            f"  Status: {status}\n"
+            f"  Cost: ${cost:.4f}\n"
+            f"  Duration: {duration}ms\n"
+            f"  Output:\n{output[:1500]}"
+        )
+    except Exception as e:
+        return f"Error running patent agent: {e}"
+
+
 async def _tool_patent_report(arguments: dict) -> str:
     """Create a patent report memo via API."""
     project = arguments.get("project") or _resolve_project()

{openrunner_sdk-2.24.0 → openrunner_sdk-2.24.2}/pyproject.toml

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