openrunner-sdk 2.41.2__tar.gz → 2.41.4__tar.gz

{openrunner_sdk-2.41.2 → openrunner_sdk-2.41.4}/PKG-INFO

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

openrunner_sdk-2.41.4/openrunner/_native.py

@@ -0,0 +1,35 @@
+"""Optional native core: PyO3 bindings over the Rust openrunner-sdk.
+
+The Python SDK progressively delegates to `openrunner_core` (built from
+sdk-rust/openrunner-core-py with maturin) when it is installed; every call
+site keeps a pure-Python fallback, so the native core is an accelerator and
+single-implementation point, never a hard dependency.
+
+    pip install openrunner-core   # optional
+
+Covered surface today: projects (incl. linked repo), artifacts/versions,
+presigned downloads (selective, GIL released during transfers), container
+registries + broker login tokens, and dataset editable-overlay columns
+(add column / set cell / edit row / get row — source columns stay read-only).
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+try:  # pragma: no cover - depends on optional wheel
+    import openrunner_core as _core
+except ImportError:  # pragma: no cover
+    _core = None
+
+
+def available() -> bool:
+    """True when the native core wheel is importable."""
+    return _core is not None
+
+
+def native_client(base_url: str, api_key: str) -> Optional[Any]:
+    """A native Client for the given credentials, or None without the wheel."""
+    if _core is None:
+        return None
+    return _core.Client(base_url, api_key)

{openrunner_sdk-2.41.2 → openrunner_sdk-2.41.4}/openrunner/api_client.py

@@ -465,6 +465,110 @@ class APIClient:
             logger.warning("link_project_image failed: %s", e)
             return None
 
+    def update_project_repo(
+        self,
+        org_id: str,
+        project_id: str,
+        github_repo: str | None = ...,
+        github_path: str | None = ...,
+        github_branch: str | None = ...,
+    ) -> dict[str, Any] | None:
+        """PATCH /organizations/{org_id}/projects/{id}/repo -- link source repo.
+
+        Only pass the fields to change; an explicit None clears the stored
+        value (Ellipsis sentinel = leave unchanged).
+        """
+        try:
+            body: dict[str, Any] = {}
+            if github_repo is not ...:
+                body["github_repo"] = github_repo
+            if github_path is not ...:
+                body["github_path"] = github_path
+            if github_branch is not ...:
+                body["github_branch"] = github_branch
+            r = self._request(
+                "patch",
+                f"/organizations/{org_id}/projects/{project_id}/repo",
+                json=body,
+            )
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.warning("update_project_repo failed: %s", e)
+            return None
+
+    # -- Container registries (org-level, tokens encrypted server-side) ------
+
+    def list_container_registries(self, org_id: str) -> list[dict[str, Any]]:
+        """GET /gpu/registries -- the org's connected registries (no tokens)."""
+        try:
+            r = self._request("get", "/gpu/registries", params={"org_id": org_id})
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.warning("list_container_registries failed: %s", e)
+            return []
+
+    def create_container_registry(
+        self,
+        org_id: str,
+        name: str,
+        registry_url: str,
+        token: str,
+        username: str | None = None,
+        namespace: str | None = None,
+    ) -> dict[str, Any] | None:
+        """POST /gpu/registries -- store a registry credential (encrypted)."""
+        try:
+            r = self._request(
+                "post", "/gpu/registries", params={"org_id": org_id},
+                json={"name": name, "registry_url": registry_url, "token": token,
+                      "username": username, "namespace": namespace},
+            )
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.warning("create_container_registry failed: %s", e)
+            return None
+
+    def verify_container_registry(self, org_id: str, registry_id: str) -> dict[str, Any] | None:
+        """POST /gpu/registries/{id}/verify -- probe the stored credential."""
+        try:
+            r = self._request("post", f"/gpu/registries/{registry_id}/verify",
+                              params={"org_id": org_id})
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.warning("verify_container_registry failed: %s", e)
+            return None
+
+    def set_default_container_registry(self, org_id: str, registry_id: str) -> dict[str, Any] | None:
+        """POST /gpu/registries/{id}/default -- mark the org default registry."""
+        try:
+            r = self._request("post", f"/gpu/registries/{registry_id}/default",
+                              params={"org_id": org_id})
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.warning("set_default_container_registry failed: %s", e)
+            return None
+
+    def registry_login_token(self) -> dict[str, Any] | None:
+        """POST /registry/login-token -- short-lived broker docker-login credential.
+
+        Returns {token, registry_host, username, expires_in}; docker login the
+        registry_host with it, then push/pull <registry_host>/<ns>/<repo> — the
+        broker proxies to the upstream registry with the stored credential.
+        None when the broker is unavailable (503) or on failure.
+        """
+        try:
+            r = self._request("post", "/registry/login-token")
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.warning("registry_login_token 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:
@@ -674,6 +778,7 @@ class APIClient:
         description: str | None = None,
         metadata: dict[str, Any] | None = None,
         base_version_id: str | None = None,
+        message: str | None = None,
     ) -> dict[str, Any] | None:
         """POST /runs/{run_id}/artifacts -- create a new artifact version.
 
@@ -700,6 +805,8 @@ class APIClient:
                 body["metadata"] = metadata
             if base_version_id is not None:
                 body["base_version_id"] = base_version_id
+            if message is not None:
+                body["message"] = message
             response = self._request("post",f"/runs/{run_id}/artifacts", json=body)
             response.raise_for_status()
             return response.json()

{openrunner_sdk-2.41.2 → openrunner_sdk-2.41.4}/openrunner/cli.py

@@ -649,12 +649,178 @@ def _format_size(size_bytes: int) -> str:
     return f"{size_bytes / (1024 * 1024 * 1024):.2f} GB"
 
 
+def _resolve_org_and_project(
+    client: "APIClient", project_name: str
+) -> tuple[str, dict] | tuple[None, None]:
+    """Resolve 'org/name' (or bare name) to (org_id, project dict)."""
+    name = project_name.split("/")[-1]
+    for p in client.list_projects():
+        if p.get("name") == name or p.get("slug") == name or p.get("id") == project_name:
+            return str(p.get("org_id")), p
+    return None, None
+
+
+@main.group()
+def repo() -> None:
+    """Linked source repository (project <-> GitHub repo/subdir)."""
+    pass
+
+
+@repo.command("link")
+@click.argument("project")
+@click.option("--repo", "repo_", required=True,
+              help="GitHub repo as 'org/name' or full URL")
+@click.option("--path", "subdir", default=None,
+              help="Subdirectory of the repo holding this project's code (monorepo)")
+@click.option("--branch", default=None, help="Branch to track (server default: main)")
+def repo_link(project: str, repo_: str, subdir: str | None, branch: str | None) -> None:
+    """Link PROJECT to its source repository (with optional subdirectory)."""
+    client = _get_client()
+    org_id, proj = _resolve_org_and_project(client, project)
+    if proj is None:
+        click.echo(f"Error: project '{project}' not found.", err=True)
+        raise SystemExit(1)
+    kwargs: dict = {"github_repo": repo_}
+    if subdir is not None:
+        kwargs["github_path"] = subdir
+    if branch is not None:
+        kwargs["github_branch"] = branch
+    updated = client.update_project_repo(org_id, str(proj["id"]), **kwargs)
+    client.close()
+    if updated is None:
+        click.echo("Error: failed to link repository.", err=True)
+        raise SystemExit(1)
+    loc = updated.get("github_repo") or ""
+    if updated.get("github_path"):
+        loc += f"/{updated['github_path']}"
+    click.echo(f"Linked {proj.get('name')} -> {loc} @ {updated.get('github_branch') or 'main'}")
+
+
+@repo.command("show")
+@click.argument("project")
+def repo_show(project: str) -> None:
+    """Show PROJECT's linked repository."""
+    client = _get_client()
+    _org_id, proj = _resolve_org_and_project(client, project)
+    client.close()
+    if proj is None:
+        click.echo(f"Error: project '{project}' not found.", err=True)
+        raise SystemExit(1)
+    if not proj.get("github_repo"):
+        click.echo("No repository linked.")
+        return
+    click.echo(f"repo:   {proj['github_repo']}")
+    click.echo(f"path:   {proj.get('github_path') or '(repo root)'}")
+    click.echo(f"branch: {proj.get('github_branch') or 'main'}")
+
+
+@repo.command("unlink")
+@click.argument("project")
+def repo_unlink(project: str) -> None:
+    """Remove PROJECT's repository link."""
+    client = _get_client()
+    org_id, proj = _resolve_org_and_project(client, project)
+    if proj is None:
+        click.echo(f"Error: project '{project}' not found.", err=True)
+        raise SystemExit(1)
+    updated = client.update_project_repo(
+        org_id, str(proj["id"]),
+        github_repo=None, github_path=None, github_branch=None,
+    )
+    client.close()
+    if updated is None:
+        click.echo("Error: failed to unlink repository.", err=True)
+        raise SystemExit(1)
+    click.echo(f"Unlinked repository from {proj.get('name')}.")
+
+
 @main.group()
 def artifact() -> None:
     """Artifact management commands."""
     pass
 
 
+@artifact.command("link-commit")
+@click.argument("name")
+@click.option("--commit", required=True, help="Git commit SHA the version points at")
+@click.option("--repo", "repo_", default=None,
+              help="Repo 'org/name' (default: the project's linked repo)")
+@click.option("--path", "subdir", default=None,
+              help="Subdirectory (default: the project's linked path)")
+@click.option("--branch", default=None, help="Branch the commit lives on")
+@click.option("--project", "-p", required=True, help="Project name or org/name")
+@click.option("--message", "-m", default=None, help="Version message (e.g. commit subject)")
+def artifact_link_commit(
+    name: str,
+    commit: str,
+    repo_: str | None,
+    subdir: str | None,
+    branch: str | None,
+    project: str,
+    message: str | None,
+) -> None:
+    """Record a new version of artifact NAME as a git commit reference.
+
+    Instead of uploading a code snapshot, the version stores {repo, commit,
+    path} in its metadata (zero bytes stored). Use for code artifacts whose
+    source of truth is the linked repository.
+    """
+    client = _get_client()
+    org_id, proj = _resolve_org_and_project(client, project)
+    if proj is None:
+        click.echo(f"Error: project '{project}' not found.", err=True)
+        client.close()
+        raise SystemExit(1)
+    repo_ = repo_ or proj.get("github_repo")
+    if subdir is None:
+        subdir = proj.get("github_path")
+    if not repo_:
+        click.echo("Error: no --repo given and project has no linked repository "
+                   "(openrunner repo link ...).", err=True)
+        client.close()
+        raise SystemExit(1)
+    client.close()
+
+    import openrunner
+
+    run = openrunner.init(
+        project=project,
+        name=f"link-commit-{name}",
+        save_code=False,
+    )
+    if run is None:
+        click.echo("Error: failed to initialize run.", err=True)
+        raise SystemExit(1)
+    try:
+        client = _get_client()
+        git_ref = {"repo": repo_, "commit": commit}
+        if subdir:
+            git_ref["path"] = subdir
+        if branch:
+            git_ref["branch"] = branch
+        result = client.create_artifact_version(
+            run.id, name, "code", [],
+            metadata={"git_ref": git_ref},
+            message=message or f"git ref {commit[:12]}",
+        )
+        if not result:
+            click.echo("Error: create_artifact_version failed.", err=True)
+            client.close()
+            raise SystemExit(1)
+        client.confirm_artifact_version(result["version_id"])
+        client.close()
+    finally:
+        openrunner.finish()
+    url = f"https://github.com/{repo_}/tree/{commit}"
+    if subdir:
+        url += f"/{subdir}"
+    click.echo(
+        f"'{name}' v{result.get('version', '?')} -> {repo_}@{commit[:12]}"
+        + (f" path {subdir}" if subdir else "")
+    )
+    click.echo(url)
+
+
 @artifact.command("list")
 @click.argument("project", required=False)
 @click.option("--project", "-p", "project_opt", default=None, help="Project name")

{openrunner_sdk-2.41.2 → openrunner_sdk-2.41.4}/openrunner/datasets.py

@@ -194,14 +194,27 @@ class DatasetsClient:
                or _g.get("base_url") or "http://localhost:8000")
         if not key:
             raise ValueError("API key required. Set OPENRUNNER_API_KEY, pass api_key=, or run `openrunner login`.")
+        # Raw creds kept so the optional native core (Rust) can be built lazily —
+        # the crate appends its own /api/v1, so hand it the bare base URL.
+        self._base_url = url.rstrip("/")
+        self._api_key = key
+        self._native: Any = "unset"  # sentinel: native core not yet resolved
         from ._retry_transport import RetryTransport
         self._http = httpx.Client(
-            base_url=f"{url.rstrip('/')}/api/v1",
-            headers={"Authorization": f"Bearer {key}"},
+            base_url=f"{self._base_url}/api/v1",
+            headers={"Authorization": f"Bearer {self._api_key}"},
             timeout=timeout,
             transport=RetryTransport(),
         )
 
+    def _native_client(self):
+        """The native (Rust/PyO3) client if the ``openrunner-core`` wheel is
+        installed, else ``None`` — an accelerator with a pure-Python fallback."""
+        if self._native == "unset":
+            from openrunner import _native
+            self._native = _native.native_client(self._base_url, self._api_key)
+        return self._native
+
     # -- resolution ----------------------------------------------------------
     def _org_id(self, org: str) -> str:
         r = self._http.get("/organizations")
@@ -801,6 +814,70 @@ class DatasetsClient:
         _check(r)
         return DatasetInfo._from_json(r.json())
 
+    def add_column(self, repo_id: str, name: str, *, default: str | None = None) -> list[str]:
+        """Add an editable column to an indexed dataset.
+
+        The dataset's indexed source ("parent") columns stay **read-only**: the new
+        column lives in a separate overlay table keyed on the primary key
+        (``debug_id``), so the source data is never mutated. Works on a plain
+        indexed dataset or a query-derived one — ``index_dataset`` the dataset first
+        if it isn't already. A name that collides with a read-only source column is
+        rejected. Returns the editable column names.
+        """
+        ds = self._resolve(repo_id)
+        nat = self._native_client()
+        if nat is not None:
+            return nat.add_dataset_column(str(ds.id), name, default)
+        r = self._http.post(f"/datasets/{ds.id}/columns",
+                            json={"name": name, "default": default})
+        _check(r)
+        return r.json().get("columns", [])
+
+    def set_cell(self, repo_id: str, debug_id: str, column: str,
+                 value: str | None = None) -> dict:
+        """Set ONE editable cell (creates the column on first write).
+
+        ``debug_id`` is the row's primary-key value; ``value=None`` clears it. A
+        read-only source column (or the primary key) is rejected. Returns
+        ``{ok, debug_id, column}``.
+        """
+        ds = self._resolve(repo_id)
+        nat = self._native_client()
+        if nat is not None:
+            return nat.set_dataset_cell(str(ds.id), debug_id, column, value)
+        r = self._http.patch(f"/datasets/{ds.id}/cell",
+                            json={"debug_id": debug_id, "column": column, "value": value})
+        _check(r)
+        return r.json()
+
+    def edit_row(self, repo_id: str, debug_id: str, values: dict[str, str | None]) -> dict:
+        """Edit one row — set several editable columns at once.
+
+        ``values`` maps column -> value (``None`` clears). Only user-added overlay /
+        derived columns are writable; the whole edit is rejected (400) if any key is
+        a read-only source column. Returns ``{ok, debug_id, columns}``.
+        """
+        ds = self._resolve(repo_id)
+        nat = self._native_client()
+        if nat is not None:
+            return nat.edit_dataset_row(str(ds.id), debug_id, values)
+        r = self._http.patch(f"/datasets/{ds.id}/rows/{debug_id}", json={"values": values})
+        _check(r)
+        return r.json()
+
+    def get_row(self, repo_id: str, debug_id: str) -> dict:
+        """Fetch one full row by ``debug_id``: read-only source fields with any
+        editable overlay values merged on top. Returns
+        ``{debug_id, row, editable_columns}`` (everything in ``row`` not listed in
+        ``editable_columns`` is a read-only parent column)."""
+        ds = self._resolve(repo_id)
+        nat = self._native_client()
+        if nat is not None:
+            return nat.get_dataset_row(str(ds.id), debug_id)
+        r = self._http.get(f"/datasets/{ds.id}/row", params={"debug_id": debug_id})
+        _check(r)
+        return r.json()
+
     def delete_dataset(self, repo_id: str) -> None:
         ds = self._resolve(repo_id)
         self._http.delete(f"/datasets/{ds.id}")
@@ -1003,6 +1080,28 @@ def add_derivation(repo_id: str, parent_repo_id: str) -> "DatasetInfo":
     return _c().add_derivation(repo_id, parent_repo_id)
 
 
+def add_column(repo_id: str, name: str, *, default: str | None = None) -> list[str]:
+    """Add an editable overlay column to an indexed dataset (source columns stay
+    read-only). Module-level mirror of DatasetsClient.add_column."""
+    return _c().add_column(repo_id, name, default=default)
+
+
+def set_cell(repo_id: str, debug_id: str, column: str, value: str | None = None) -> dict:
+    """Set one editable cell of a dataset row (creates the column if new)."""
+    return _c().set_cell(repo_id, debug_id, column, value)
+
+
+def edit_row(repo_id: str, debug_id: str, values: dict[str, str | None]) -> dict:
+    """Edit one row — set several editable columns at once (read-only source
+    columns are rejected)."""
+    return _c().edit_row(repo_id, debug_id, values)
+
+
+def get_row(repo_id: str, debug_id: str) -> dict:
+    """Fetch one full row by debug_id (source fields + editable overlay values)."""
+    return _c().get_row(repo_id, debug_id)
+
+
 def presign_batch(repo_id: str, paths: list[str], **kwargs: Any) -> list[dict]:
     return _c().presign_batch(repo_id, paths, **kwargs)
 

{openrunner_sdk-2.41.2 → openrunner_sdk-2.41.4}/openrunner/install_commands.py

@@ -2188,6 +2188,26 @@ python3 -c "from openrunner import datasets as ds; ds.add_derivation('ORG/CHILD'
 ### 5. Card + verify lineage
 Write a short card explaining the heuristic + thresholds + per-language stats, then `ds.set_dataset_card('ORG/CHILD', md)`. Verify: `GET /datasets/{{id}}/lineage` (or the dataset page Lineage tab) now shows CHILD under the parent's children, and the parent can no longer be deleted without removing the child first.
 
+## Alternative: add an editable column IN PLACE (no new dataset)
+
+When you don't need a separate child dataset — you just want to **annotate / label / correct** rows of an existing **indexed** dataset — add an editable column directly. The dataset's indexed source columns stay **read-only** ("parent" columns); your new column lives in a separate overlay table keyed on `debug_id`, so the source data is never touched. This is the right tool for human review, GT correction, or attaching a quality flag you edit over time.
+
+```bash
+python3 -c "
+from openrunner import datasets as ds
+# 1. Add the editable column (index the dataset first if it isn't: ds.index_dataset('ORG/NAME', text_columns=[...]))
+ds.add_column('ORG/NAME', 'review_status', default='pending')   # -> editable column names
+# 2. Edit one cell of a row (debug_id = the row's primary key)
+ds.set_cell('ORG/NAME', 'ROW_DEBUG_ID', 'review_status', 'approved')
+# 3. Or edit several editable columns of a row at once
+ds.edit_row('ORG/NAME', 'ROW_DEBUG_ID', {{'review_status': 'rejected', 'note': 'misaligned'}})
+# 4. Read the row back (source fields + your overlay values merged)
+row = ds.get_row('ORG/NAME', 'ROW_DEBUG_ID'); print(row['editable_columns'], row['row'])
+"
+```
+
+Rules: writing a read-only **source** column (or the primary key) is rejected — only user-added columns are editable. `edit_row` validates every column up front and rejects the whole edit if any is read-only. Use this for in-place edits; use the derive flow above when you want a distinct, lineage-linked child dataset.
+
 ## Common mistakes
 - ❌ `openrunner.Artifact(...).add_file(parquet); run.log_artifact(a)` — that's a run artifact, **not** a dataset; no lineage, not queryable.
 - ❌ Re-uploading the parent's audio into the child — derived datasets reference parent media.