openrunner-sdk 2.40.0__tar.gz → 2.41.0__tar.gz

{openrunner_sdk-2.40.0 → openrunner_sdk-2.41.0}/PKG-INFO

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

{openrunner_sdk-2.40.0 → openrunner_sdk-2.41.0}/openrunner/cli.py

@@ -4244,8 +4244,8 @@ def gpu_run(command, provider, gpu, gpu_count, image, disk_gb, env, ssh_keys, pr
     """
     from openrunner.gpu.runner import run_governed_sync, run_on_gpu_sync
 
-    if provider not in ("forge", "modal") and not gpu:
-        click.echo("Error: --gpu is required (except for forge/modal).", err=True)
+    if provider not in ("forge", "modal", "ovhai") and not gpu:
+        click.echo("Error: --gpu is required (except for forge/modal/ovhai).", err=True)
         raise SystemExit(1)
 
     settings = _load_settings()
@@ -4294,6 +4294,24 @@ def gpu_run(command, provider, gpu, gpu_count, image, disk_gb, env, ssh_keys, pr
     # injected server-side (the token never touches this machine). COMMAND is the
     # App script. A caller who explicitly supplies the token via -e (FORGE_TOKEN /
     # MODAL_TOKEN_SECRET) opts into running the engine client locally instead.
+    # OVH AI Training — governed managed batch job, submitted server-side with the
+    # org's OVH credential (keys never leave the API). COMMAND runs in --image on
+    # --gpu-count GPUs; data comes from OpenRunner (no OVH object-storage volumes).
+    if provider == "ovhai":
+        if image == "pytorch/pytorch:2.4.0-cuda12.4-cudnn9-runtime":
+            click.echo("Error: --image is required for ovhai (the training image).", err=True)
+            raise SystemExit(1)
+        from openrunner.gpu.runner import run_ovh_training_sync
+        try:
+            result = run_ovh_training_sync(
+                command=command, image=image, gpu=gpu_count, project=project,
+                emit=lambda m: click.echo(m),
+            )
+        except Exception as exc:  # noqa: BLE001
+            click.echo(f"gpu run failed: {exc}", err=True)
+            raise SystemExit(1)
+        raise SystemExit(result["exit_code"])
+
     if provider in ("forge", "modal"):
         _DEFAULT_IMAGE = "pytorch/pytorch:2.4.0-cuda12.4-cudnn9-runtime"
         local_tok = env_dict.get("FORGE_TOKEN") if provider == "forge" else env_dict.get("MODAL_TOKEN_SECRET")

{openrunner_sdk-2.40.0 → openrunner_sdk-2.41.0}/openrunner/gpu/api_integration.py

@@ -408,6 +408,30 @@ class GpuAPIClient:
             logger.warning("get_job failed: %s", e)
             return None
 
+    def ovh_training_run_stream(
+        self, *, image: str, command: str, gpu: int = 1, name: str | None = None,
+        project_id: str | None = None,
+    ):
+        """POST /api/v1/gpu/ai-training/run and YIELD the job's log lines. The
+        server runs `ovhai job run` with the org's stored user/password (never
+        sent here) and streams logs. A ``__ENGINE_EXIT__ <code>`` line ends it."""
+        org = self.org_id()
+        body: dict[str, Any] = {"image": image, "command": command, "gpu": gpu}
+        if name:
+            body["name"] = name
+        if project_id:
+            body["project_id"] = project_id
+        with self._client.stream(
+            "POST", "/gpu/ai-training/run", params={"org_id": org}, json=body,
+        ) as r:
+            if r.status_code >= 400:
+                r.read()
+                yield f"[openrunner] server error {r.status_code}: {r.text[:300]}"
+                yield "__ENGINE_EXIT__ 1"
+                return
+            for line in r.iter_lines():
+                yield line
+
     # ------------------------------------------------------------------
     # Lifecycle
     # ------------------------------------------------------------------

{openrunner_sdk-2.40.0 → openrunner_sdk-2.41.0}/openrunner/gpu/runner.py

@@ -526,6 +526,42 @@ def run_engine_job_sync(
                 "`openrunner runner start` on a box in this org (needs Docker).")
 
 
+def run_ovh_training_sync(
+    *,
+    command: str,
+    image: str,
+    gpu: int = 1,
+    project: str | None = None,
+    name: str | None = None,
+    emit: Callable[[str], None] | None = None,
+) -> dict[str, Any]:
+    """Governed OVH AI Training run — SERVER-SIDE. The API runs `ovhai job run`
+    on the engine-executor with the org's stored user/password (never on this
+    machine) and streams the job's logs. COMMAND runs in IMAGE on `gpu` GPUs. Data
+    comes from OpenRunner (no OVH object-storage volumes). Returns {"exit_code"}."""
+    from openrunner.gpu import _get_api_client
+
+    say = emit or (lambda m: print(m, flush=True))
+    client = _get_api_client()
+    if client is None:
+        raise RuntimeError("Not logged in. Run 'openrunner login' first.")
+
+    say(f"[openrunner] launching OVH AI Training (image={image}, gpu={gpu}) "
+        "server-side — OVH user/password stays in OpenRunner ...")
+    exit_code = 1
+    for line in client.ovh_training_run_stream(
+        image=image, command=command, gpu=gpu, name=name, project_id=project,
+    ):
+        if line.startswith("__ENGINE_EXIT__"):
+            try:
+                exit_code = int(line.split()[1])
+            except Exception:
+                exit_code = 1
+            continue
+        say(line.rstrip("\n"))
+    return {"exit_code": exit_code}
+
+
 def run_engine_serverside_sync(
     *,
     provider: str,

{openrunner_sdk-2.40.0 → openrunner_sdk-2.41.0}/openrunner/install_commands.py

@@ -3599,6 +3599,15 @@ mentions a "distant GPU":
   SCRIPT (GPU is declared in `@app.function(gpu=...)`, so no `--gpu`), the Run
   auto-terminates when the function returns. Don't hunt for an SSH host/runner.
   For native Forge use, the `forge-deploy` skill covers install/auth/write/run.
+- OVHcloud **AI Training** (managed GPU batch jobs): governed, run SERVER-SIDE
+  via the `ovhai` CLI on the engine-executor using the org's stored OVH
+  **user/password** (an OpenStack user with the AI Training Operator +
+  ObjectStore operator roles) -- the password never reaches the client. Store it
+  in Settings (provider `ovhai`: username + password), then run:
+  `openrunner gpu run --provider ovhai --image <img> --gpu-count N "<train cmd>"`
+  -- COMMAND runs in the image on N GPUs; the job's logs stream back; it
+  auto-stops when the command exits. **Do NOT use OVH object-storage `--volume`
+  mounts** -- data comes from OpenRunner (datasets/artifacts).
 - Provider keys are stored encrypted with `openrunner gpu credentials add`
   (e.g. `--provider forge --api-key fg_..`); list/kill pods with
   `openrunner gpu ls` / `openrunner gpu terminate`. Governed compute -- the key

{openrunner_sdk-2.40.0 → openrunner_sdk-2.41.0}/pyproject.toml

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

openrunner_sdk-2.41.0/tests/test_gpu/test_ovh_training.py

@@ -0,0 +1,29 @@
+"""SDK OVH AI Training governed run — streams the server's job logs."""
+from __future__ import annotations
+from unittest.mock import patch
+from openrunner.gpu import runner as R
+
+
+class _Fake:
+    def __init__(self, lines): self.args=None; self._lines=lines
+    def ovh_training_run_stream(self, **kwargs):
+        self.args=kwargs
+        yield from self._lines
+
+
+def test_ovh_training_streams_and_parses_exit():
+    fake=_Fake(["epoch 1","epoch 2","__ENGINE_EXIT__ 0"])
+    out=[]
+    with patch("openrunner.gpu._get_api_client", return_value=fake):
+        res=R.run_ovh_training_sync(command="python train.py",
+                                    image="ovhcom/ai-training-pytorch", gpu=2, emit=out.append)
+    assert res=={"exit_code":0}
+    assert fake.args["image"]=="ovhcom/ai-training-pytorch" and fake.args["gpu"]==2
+    assert fake.args["command"]=="python train.py"
+    assert any("epoch 2" in l for l in out) and not any("__ENGINE_EXIT__" in l for l in out)
+
+
+def test_ovh_training_nonzero_exit():
+    with patch("openrunner.gpu._get_api_client", return_value=_Fake(["boom","__ENGINE_EXIT__ 4"])):
+        res=R.run_ovh_training_sync(command="x", image="i", emit=lambda _l:None)
+    assert res["exit_code"]==4