openrunner-sdk 2.37.32__tar.gz → 2.37.34__tar.gz

{openrunner_sdk-2.37.32 → openrunner_sdk-2.37.34}/PKG-INFO

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

{openrunner_sdk-2.37.32 → openrunner_sdk-2.37.34}/openrunner/cli.py

@@ -4825,6 +4825,57 @@ def deploy_rm(deployment_id, project) -> None:
     click.echo(f"Deployment {d['name']} deleted (replicas terminating).")
 
 
+@deploy_group.command("call")
+@click.argument("deployment_id")
+@click.argument("path", default="")
+@click.option("--project", "-p", default=None, help="Project org/name or UUID")
+@click.option("--method", "-X", default="POST", help="HTTP method (default POST)")
+@click.option("--data", "-d", default=None, help="Request body (string). '@file' reads a file.")
+@click.option("--header", "-H", "headers", multiple=True, help="Extra header 'K: V' (repeatable)")
+def deploy_call(deployment_id, path, project, method, data, headers) -> None:
+    """Call a deployment's HTTP endpoint via the governed router (LB across live
+    replicas). PATH is appended to the deployment's proxy base, e.g. 'predict'.
+
+    Example:
+      openrunner deploy call <id> predict -p ORG/NAME -d '{"text":"hi"}'
+    """
+    settings = _load_settings()
+    api_key = settings.get("api_key")
+    base_url = settings.get("base_url", "http://localhost:8000").rstrip("/")
+    if not api_key:
+        click.echo("Error: Not logged in.", err=True); raise SystemExit(1)
+    _c = APIClient(base_url=base_url, api_key=api_key)
+    proj = project or settings.get("project")
+    pid = proj
+    if proj and ("/" in proj or "-" not in proj):
+        want = proj.split("/")[-1].lower()
+        m = next((p for p in _c.list_projects()
+                  if str(p.get("slug", "")).lower() == want or str(p.get("name", "")).lower() == want), None)
+        if m:
+            pid = m["id"]
+    _c.close()
+    if data and data.startswith("@"):
+        data = Path(data[1:]).read_text()
+    hdrs = {"Authorization": f"Bearer {api_key}"}
+    for h in headers:
+        if ":" in h:
+            k, v = h.split(":", 1)
+            hdrs[k.strip()] = v.strip()
+    if data and not any(k.lower() == "content-type" for k in hdrs):
+        hdrs["Content-Type"] = "application/json"
+    url = f"{base_url}/api/v1/projects/{pid}/deployments/{deployment_id}/proxy/{path.lstrip('/')}"
+    import httpx
+    try:
+        r = httpx.request(method.upper(), url, headers=hdrs, content=data, timeout=300.0)
+    except Exception as e:
+        click.echo(f"call failed: {e}", err=True); raise SystemExit(1)
+    if r.status_code == 503:
+        click.echo("503 — no live replica yet (still starting or scaled to zero).", err=True)
+        raise SystemExit(1)
+    click.echo(r.text)
+    raise SystemExit(0 if r.status_code < 400 else 1)
+
+
 # ---------------------------------------------------------------------------
 # register / hosts — self-hosted (BYO) GPU compute hosts
 # ---------------------------------------------------------------------------
@@ -5578,3 +5629,73 @@ def session_close(name, org, runner_id) -> None:
     client = _plain_client(); org_id = _resolve_org_id(client, org)
     st, out = _run_on_runner(client, org_id, runner_id, f"tmux kill-session -t {name} && echo 'closed {name}'"); client.close()
     click.echo(out.rstrip() if out else st)
+
+
+@session_group.command("watch")
+@click.argument("name")
+@_sess_common
+@click.option("--interval", default=1.0, type=float, help="Seconds between pane captures")
+def session_watch(name, org, runner_id, interval) -> None:
+    """Live-tail a session's pane (repeated capture, redraw). Ctrl-C to stop.
+
+    Near-real-time view without a persistent connection — polls the pane at
+    --interval. For a true real-time TTY use the pod's --web browser terminal.
+    """
+    import time as _time
+
+    if not _SESSION_RE.match(name):
+        click.echo("Invalid session name.", err=True); raise SystemExit(1)
+    client = _plain_client(); org_id = _resolve_org_id(client, org)
+    click.echo(f"Watching session '{name}' (every {interval}s) — Ctrl-C to stop.")
+    last = None
+    try:
+        while True:
+            st, out = _run_on_runner(client, org_id, runner_id, f"tmux capture-pane -t {name} -p")
+            if out != last:
+                click.clear()
+                click.echo(f"[{name} @ runner {runner_id[:8]}]")
+                click.echo(out.rstrip() if out else st)
+                last = out
+            _time.sleep(max(0.3, interval))
+    except KeyboardInterrupt:
+        click.echo("\nStopped watching.")
+    finally:
+        client.close()
+
+
+@session_group.command("shell")
+@click.argument("name")
+@_sess_common
+@click.option("--wait", default=0.6, type=float, help="Seconds to wait before capturing after each command")
+def session_shell(name, org, runner_id, wait) -> None:
+    """Interactive REPL against a session: type a command, see the pane, repeat.
+
+    A human-friendly loop over send+read (no persistent connection). Latency is
+    roughly the runner poll interval per command. Type 'exit' or Ctrl-D to leave
+    (the tmux session keeps running — use `session close` to kill it).
+    """
+    import time as _time
+
+    if not _SESSION_RE.match(name):
+        click.echo("Invalid session name.", err=True); raise SystemExit(1)
+    client = _plain_client(); org_id = _resolve_org_id(client, org)
+    # Ensure the session exists.
+    _run_on_runner(client, org_id, runner_id,
+                   f"tmux has-session -t {name} 2>/dev/null || tmux new-session -d -s {name}")
+    click.echo(f"Interactive shell on session '{name}' (runner {runner_id[:8]}). "
+               "'exit' or Ctrl-D to leave (session stays alive).")
+    try:
+        while True:
+            try:
+                line = click.prompt(f"{name}", prompt_suffix="$ ")
+            except (EOFError, click.exceptions.Abort):
+                break
+            if line.strip() in ("exit", "quit"):
+                break
+            cmd = (f"T=$(printf %s {_b64(line)} | base64 -d); tmux send-keys -t {name} \"$T\" Enter; "
+                   f"sleep {max(0.0, wait)}; tmux capture-pane -t {name} -p")
+            st, out = _run_on_runner(client, org_id, runner_id, cmd)
+            click.echo(out.rstrip() if out else st)
+    finally:
+        client.close()
+    click.echo("Left shell (session still running).")

{openrunner_sdk-2.37.32 → openrunner_sdk-2.37.34}/openrunner/install_commands.py

@@ -2936,8 +2936,12 @@ Target ONE pod with `--runner RID` (from `runner ls` / `runner launch`):
     openrunner session send  s1 'python train.py' --org ORG --runner RID
     openrunner session read  s1 --org ORG --runner RID        # current pane
     openrunner session ls    --org ORG --runner RID           # list sessions in the pod
+    openrunner session watch s1 --org ORG --runner RID        # live-tail the pane (redraw)
+    openrunner session shell s1 --org ORG --runner RID        # interactive REPL loop
     openrunner session close s1 --org ORG --runner RID
 
+- `session shell` = a human-friendly interactive loop (type -> pane -> repeat);
+  `session watch` live-tails the pane. Both poll, so latency ~ the poll interval.
 - Open several names (`s1`, `s2`, ...) for **parallel** shells in the same pod.
 - Sessions **persist** (tmux) between commands -- cwd, env, running processes stay.
 - `session send` runs the line then returns the pane; add `--wait N` if the
@@ -3230,6 +3234,10 @@ Then ask replica bounds + autoscale:
 - 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`.
+- Once >=1 replica is live, call it through the governed router (LB across
+  replicas): `openrunner deploy call <id> predict -p ORG/NAME -d '{{"text":"hi"}}'`
+  (503 = still starting / scaled to zero). Give the user this command + the
+  endpoint_url to integrate.
 
 ## Guardrails
 - Ground every sizing number in the card/run; label anything estimated. Never

{openrunner_sdk-2.37.32 → openrunner_sdk-2.37.34}/pyproject.toml

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