openrunner-sdk 2.41.9__tar.gz → 2.41.10__tar.gz

{openrunner_sdk-2.41.9 → openrunner_sdk-2.41.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: openrunner-sdk
-Version: 2.41.9
+Version: 2.41.10
 Summary: OpenRunner SDK - W&B-compatible ML experiment tracking client
 Project-URL: Homepage, https://github.com/gladiaio/openrunner
 Project-URL: Repository, https://github.com/gladiaio/openrunner

{openrunner_sdk-2.41.9 → openrunner_sdk-2.41.10}/openrunner/CLAUDE.md

@@ -88,9 +88,7 @@ the LanceDB table on the dataset's own connection.
 
 Beyond FTS, the client exposes semantic / lexical search and **derivation by
 query** — build a child dataset from a SUBSET of a parent selected by a search
-(only matching primary keys stored; no media copied; de-dup + lineage automatic).
-These delegate to the native Rust core (`openrunner-core` wheel) when installed,
-falling back to pure-Python httpx otherwise:
+(only matching primary keys stored; no media copied; de-dup + lineage automatic):
 
 ```python
 ord.search_dataset(repo, q, mode="mixed"|"exact", lang="fr")   # BM25 / phrase, lang filter

{openrunner_sdk-2.41.9 → openrunner_sdk-2.41.10}/openrunner/datasets.py

@@ -208,11 +208,8 @@ 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"{self._base_url}/api/v1",
@@ -221,14 +218,6 @@ class DatasetsClient:
             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")
@@ -958,13 +947,8 @@ class DatasetsClient:
 
         ``mode``: "mixed" (ranked tokens, default) or "exact" (phrase match).
         ``lang``: restrict to a language / CSV ("fr" or "fr,en"); "" = all.
-        Delegates to the native (Rust) core when the ``openrunner-core`` wheel is
-        installed, else pure-Python httpx.
         """
         ds = self._resolve(repo_id)
-        nat = self._native_client()
-        if nat is not None:
-            return nat.dataset_search(str(ds.id), query, mode, lang, limit).get("rows", [])
         params: dict[str, Any] = {"q": query, "limit": limit, "mode": mode}
         if lang:
             params["lang"] = lang
@@ -979,13 +963,9 @@ class DatasetsClient:
         """Vector (cosine ANN) search over a dataset's embeddings.
 
         Requires the embedding index built first via
-        ``optimize_embedding_search``. Native core when available, else httpx.
+        ``optimize_embedding_search``.
         """
         ds = self._resolve(repo_id)
-        nat = self._native_client()
-        if nat is not None:
-            out = nat.semantic_search(str(ds.id), query, lang, limit)
-            return out.get("rows", out.get("hits", []))
         params: dict[str, Any] = {"q": query, "limit": limit}
         if lang:
             params["lang"] = lang
@@ -998,13 +978,10 @@ class DatasetsClient:
     ) -> list[dict]:
         """Regex search: match a Python-``re`` ``pattern`` against the dataset's
         text column (streamed, bounded — no index needed). Case-insensitive is
-        opt-in via an inline ``(?i)`` flag. Native core when available, else httpx.
+        opt-in via an inline ``(?i)`` flag.
         Pairs with ``derive_by_query(mode="regex")`` to build a regex-derived set.
         """
         ds = self._resolve(repo_id)
-        nat = self._native_client()
-        if nat is not None:
-            return nat.regex_search(str(ds.id), pattern, lang, limit).get("rows", [])
         params: dict[str, Any] = {"q": pattern, "limit": limit, "mode": "regex"}
         if lang:
             params["lang"] = lang
@@ -1021,11 +998,8 @@ class DatasetsClient:
         model: str | None = None,
     ) -> dict:
         """Embed missing rows and build the ANN index that ``semantic_search``
-        (and derive ``mode="semantic"``) need. Native core when available."""
+        (and derive ``mode="semantic"``) need."""
         ds = self._resolve(repo_id)
-        nat = self._native_client()
-        if nat is not None:
-            return nat.optimize_embedding_search(str(ds.id), text_column, max_rows, model)
         body = {"text_column": text_column, "max_rows": max_rows, "model": model}
         r = self._http.post(
             f"/datasets/{ds.id}/optimize-embedding-search", json=body, timeout=1800.0
@@ -1040,14 +1014,10 @@ class DatasetsClient:
 
         ``terms`` is one word, a CSV string, or a list. ``op`` combines
         multi-term hits: "union" (ANY) or "intersect" (ALL). ``lang`` scopes to a
-        language / CSV. Returns per-term df + combined ids. Native core when
-        available, else httpx.
+        language / CSV. Returns per-term df + combined ids.
         """
         ds = self._resolve(repo_id)
         term = ",".join(terms) if isinstance(terms, (list, tuple)) else terms
-        nat = self._native_client()
-        if nat is not None:
-            return nat.word_lookup(str(ds.id), term, op, lang)
         params: dict[str, Any] = {"term": term, "op": op}
         if lang:
             params["lang"] = lang
@@ -1061,12 +1031,8 @@ class DatasetsClient:
         """Expand a domain prompt into many search keywords via an LLM.
 
         Returns ``{keywords, csv, count, model, prompt}`` — feed ``csv`` into
-        ``word_lookup`` or ``derive_by_query(mode="word", q=csv)``. Native core
-        when available, else httpx.
+        ``word_lookup`` or ``derive_by_query(mode="word", q=csv)``.
         """
-        nat = self._native_client()
-        if nat is not None:
-            return nat.keyword_expand(prompt, count, model)
         body = {"prompt": prompt, "count": count, "model": model}
         r = self._http.post("/datasets/keyword-expand", json=body, timeout=120.0)
         _check(r)
@@ -1093,9 +1059,7 @@ class DatasetsClient:
         matched over the text column, bounded), "semantic" (vector — needs
         ``optimize_embedding_search``). ``lang`` filters by language / CSV. Pass
         ``name`` to create, or ``target_repo_id`` to append (must derive from the
-        same parent). Lineage is recorded automatically. The query runs and
-        member keys are recorded natively when the core wheel is installed; the
-        parent/target resolution + DatasetInfo wrapping stay in Python.
+        same parent). Lineage is recorded automatically.
         """
         ds = self._resolve(repo_id)
         body: dict[str, Any] = {"mode": mode, "q": q, "limit": limit}
@@ -1109,9 +1073,6 @@ class DatasetsClient:
             body["target_dataset_id"] = str(self._resolve(target_repo_id).id)
         elif not name:
             raise ValueError("derive_by_query needs either name= (create) or target_repo_id= (append)")
-        nat = self._native_client()
-        if nat is not None:
-            return DatasetInfo._from_json(nat.derive_dataset(str(ds.id), body))
         r = self._http.post(f"/datasets/{ds.id}/derive", json=body, timeout=600.0)
         _check(r)
         return DatasetInfo._from_json(r.json())
@@ -1168,7 +1129,6 @@ class DatasetsClient:
                     f"columns[{_n!r}] has {len(_v)} values but ids has {len(ids)}; "
                     "they are positional")
         ds = self._resolve(repo_id)
-        nat = self._native_client()
         info: DatasetInfo | None = None
         target_id = str(self._resolve(target_repo_id).id) if target_repo_id else None
         for i in range(0, len(ids), chunk_size):
@@ -1189,12 +1149,9 @@ class DatasetsClient:
                 if project_id:
                     body["project_id"] = str(project_id)
             try:
-                if nat is not None:
-                    info = DatasetInfo._from_json(nat.derive_dataset(str(ds.id), body))
-                else:
-                    r = self._http.post(f"/datasets/{ds.id}/derive", json=body, timeout=600.0)
-                    _check(r)
-                    info = DatasetInfo._from_json(r.json())
+                r = self._http.post(f"/datasets/{ds.id}/derive", json=body, timeout=600.0)
+                _check(r)
+                info = DatasetInfo._from_json(r.json())
             except Exception as e:
                 # A mid-loop failure leaves a dataset that exists and looks
                 # complete. Retrying the whole call re-sends batch 0 with name=
@@ -1213,11 +1170,8 @@ class DatasetsClient:
 
     def derived_rows(self, repo_id: str, *, limit: int = 50, offset: int = 0) -> dict:
         """Page a query-derived dataset's rows: member keys + inherited parent
-        fields (lineage-namespaced) + extra columns. Native core when available."""
+        fields (lineage-namespaced) + extra columns."""
         ds = self._resolve(repo_id)
-        nat = self._native_client()
-        if nat is not None:
-            return nat.derived_rows(str(ds.id), limit, offset)
         r = self._http.get(
             f"/datasets/{ds.id}/derived-rows", params={"limit": limit, "offset": offset}
         )
@@ -1296,9 +1250,6 @@ class DatasetsClient:
         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)
@@ -1331,9 +1282,6 @@ class DatasetsClient:
         ``{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)
@@ -1347,9 +1295,6 @@ class DatasetsClient:
         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()
@@ -1360,9 +1305,6 @@ class DatasetsClient:
         ``{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()

{openrunner_sdk-2.41.9 → openrunner_sdk-2.41.10}/pyproject.toml

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

{openrunner_sdk-2.41.9 → openrunner_sdk-2.41.10}/tests/test_datasets_module.py

@@ -19,6 +19,7 @@ from __future__ import annotations
 
 import io
 import json
+import sys
 import tarfile
 from pathlib import Path
 from unittest.mock import MagicMock, patch
@@ -768,7 +769,6 @@ def test_index_dataset_no_wait_returns_job(monkeypatch):
 
 def test_search_dataset(monkeypatch):
     c = _client(monkeypatch)
-    c._native = None  # force httpx fallback (no native wheel)
     c._resolve = MagicMock(return_value=DatasetInfo._from_json(_DS_JSON))
     c._http.get.return_value = _resp(200, {"rows": [{"id": 1}]})
     assert c.search_dataset("gladia/wmt", "hi") == [{"id": 1}]
@@ -776,7 +776,6 @@ def test_search_dataset(monkeypatch):
 
 def test_search_dataset_mode_and_lang(monkeypatch):
     c = _client(monkeypatch)
-    c._native = None
     c._resolve = MagicMock(return_value=DatasetInfo._from_json(_DS_JSON))
     c._http.get.return_value = _resp(200, {"rows": []})
     c.search_dataset("g/n", "hi", mode="exact", lang="fr")
@@ -784,20 +783,21 @@ def test_search_dataset_mode_and_lang(monkeypatch):
     assert params["mode"] == "exact" and params["lang"] == "fr"
 
 
-def test_search_dataset_native_delegates(monkeypatch):
+def test_search_ignores_a_leftover_openrunner_core_wheel(monkeypatch):
+    # The openrunner-core native wheel was dropped (never published): a stale
+    # install must not take over from the HTTP client.
+    leftover = MagicMock()
+    monkeypatch.setitem(sys.modules, "openrunner_core", leftover)
     c = _client(monkeypatch)
     c._resolve = MagicMock(return_value=DatasetInfo._from_json(_DS_JSON))
-    nat = MagicMock()
-    nat.dataset_search.return_value = {"rows": [{"id": 42}]}
-    c._native = nat
-    assert c.search_dataset("g/n", "hi", mode="exact", lang="fr", limit=5) == [{"id": 42}]
-    nat.dataset_search.assert_called_once_with("ds-1", "hi", "exact", "fr", 5)
-    c._http.get.assert_not_called()
+    c._http.get.return_value = _resp(200, {"rows": [{"id": 1}]})
+    assert c.search_dataset("g/n", "hi") == [{"id": 1}]
+    assert leftover.mock_calls == []
+
 
 
 def test_semantic_search(monkeypatch):
     c = _client(monkeypatch)
-    c._native = None
     c._resolve = MagicMock(return_value=DatasetInfo._from_json(_DS_JSON))
     c._http.get.return_value = _resp(200, {"hits": [{"id": 9, "score": 0.8}]})
     assert c.semantic_search("g/n", "symptoms", lang="en,fr")[0]["id"] == 9
@@ -806,7 +806,6 @@ def test_semantic_search(monkeypatch):
 
 def test_regex_search(monkeypatch):
     c = _client(monkeypatch)
-    c._native = None
     c._resolve = MagicMock(return_value=DatasetInfo._from_json(_DS_JSON))
     c._http.get.return_value = _resp(200, {"rows": [{"debug_id": "r1"}]})
     out = c.regex_search("g/n", r"\bcancel(led)?\b", lang="en", limit=5)
@@ -817,20 +816,9 @@ def test_regex_search(monkeypatch):
     assert "/search" in c._http.get.call_args.args[0]
 
 
-def test_regex_search_native_delegates(monkeypatch):
-    c = _client(monkeypatch)
-    c._resolve = MagicMock(return_value=DatasetInfo._from_json(_DS_JSON))
-    nat = MagicMock()
-    nat.regex_search.return_value = {"rows": [{"debug_id": "x"}]}
-    c._native = nat
-    assert c.regex_search("g/n", "foo.*bar", lang="fr", limit=7) == [{"debug_id": "x"}]
-    nat.regex_search.assert_called_once_with("ds-1", "foo.*bar", "fr", 7)
-    c._http.get.assert_not_called()
-
 
 def test_derive_by_query_regex_mode(monkeypatch):
     c = _client(monkeypatch)
-    c._native = None
     c._resolve = MagicMock(return_value=DatasetInfo._from_json(_DS_JSON))
     c._http.post.return_value = _resp(200, dict(_DS_JSON, name="cancels"))
     c.derive_by_query("g/parent", r"\bcancel", name="g/cancels", mode="regex", lang="en")
@@ -840,7 +828,6 @@ def test_derive_by_query_regex_mode(monkeypatch):
 
 def test_optimize_embedding_search(monkeypatch):
     c = _client(monkeypatch)
-    c._native = None
     c._resolve = MagicMock(return_value=DatasetInfo._from_json(_DS_JSON))
     c._http.post.return_value = _resp(200, {"status": "running"})
     assert c.optimize_embedding_search("g/n")["status"] == "running"
@@ -848,7 +835,6 @@ def test_optimize_embedding_search(monkeypatch):
 
 def test_word_lookup_union_intersect(monkeypatch):
     c = _client(monkeypatch)
-    c._native = None
     c._resolve = MagicMock(return_value=DatasetInfo._from_json(_DS_JSON))
     c._http.get.return_value = _resp(200, {"ids": [1, 2]})
     c.word_lookup("g/n", ["a", "b"], op="intersect", lang="fr")
@@ -858,7 +844,6 @@ def test_word_lookup_union_intersect(monkeypatch):
 
 def test_keyword_expand(monkeypatch):
     c = _client(monkeypatch)
-    c._native = None
     c._http.post.return_value = _resp(200, {"keywords": ["a", "b"], "csv": "a, b", "count": 2})
     out = c.keyword_expand("medical terms in french", count=2)
     assert out["count"] == 2
@@ -867,7 +852,6 @@ def test_keyword_expand(monkeypatch):
 
 def test_derive_by_query_create(monkeypatch):
     c = _client(monkeypatch)
-    c._native = None
     c._resolve = MagicMock(return_value=DatasetInfo._from_json(_DS_JSON))
     c._http.post.return_value = _resp(200, dict(_DS_JSON, name="medical-fr"))
     out = c.derive_by_query("g/parent", "a,b", name="g/medical-fr", mode="word", lang="fr")
@@ -878,7 +862,6 @@ def test_derive_by_query_create(monkeypatch):
 
 def test_derive_by_ids_create_sends_the_list(monkeypatch):
     c = _client(monkeypatch)
-    c._native = None
     c._resolve = MagicMock(return_value=DatasetInfo._from_json(_DS_JSON))
     c._http.post.return_value = _resp(200, dict(_DS_JSON, name="flagged"))
     out = c.derive_by_ids("g/parent", ["a", "b", "c"], name="g/flagged", lang="fr")
@@ -894,7 +877,6 @@ def test_derive_by_ids_chunks_and_appends(monkeypatch):
     # A 692k-id selection must not become one 24 MB request body. The first
     # batch creates the dataset; the rest append into it by id.
     c = _client(monkeypatch)
-    c._native = None
     c._resolve = MagicMock(return_value=DatasetInfo._from_json(_DS_JSON))
     c._http.post.return_value = _resp(200, dict(_DS_JSON, id="ds-new", name="big"))
     c.derive_by_ids("g/parent", [f"id-{i}" for i in range(250)], name="g/big", chunk_size=100)
@@ -907,7 +889,6 @@ def test_derive_by_ids_chunks_and_appends(monkeypatch):
 
 def test_derive_by_ids_rejects_empty_and_nameless(monkeypatch):
     c = _client(monkeypatch)
-    c._native = None
     c._resolve = MagicMock(return_value=DatasetInfo._from_json(_DS_JSON))
     with pytest.raises(ValueError, match="non-empty ids"):
         c.derive_by_ids("g/parent", [], name="g/x")
@@ -915,32 +896,10 @@ def test_derive_by_ids_rejects_empty_and_nameless(monkeypatch):
         c.derive_by_ids("g/parent", ["a"])
 
 
-def test_derive_by_ids_native_delegates(monkeypatch):
-    c = _client(monkeypatch)
-    c._resolve = MagicMock(return_value=DatasetInfo._from_json(_DS_JSON))
-    nat = MagicMock()
-    nat.derive_dataset.return_value = dict(_DS_JSON, name="flagged")
-    c._native = nat
-    assert c.derive_by_ids("g/parent", ["a"], name="g/flagged").name == "flagged"
-    assert nat.derive_dataset.call_args.args[1]["mode"] == "ids"
-    c._http.post.assert_not_called()
-
-
-def test_derive_by_query_native_delegates(monkeypatch):
-    c = _client(monkeypatch)
-    c._resolve = MagicMock(return_value=DatasetInfo._from_json(_DS_JSON))
-    nat = MagicMock()
-    nat.derive_dataset.return_value = dict(_DS_JSON, name="medical-fr")
-    c._native = nat
-    out = c.derive_by_query("g/parent", "a,b", name="g/medical-fr", mode="word")
-    assert out.name == "medical-fr"
-    nat.derive_dataset.assert_called_once()
-    c._http.post.assert_not_called()
 
 
 def test_derive_by_query_append(monkeypatch):
     c = _client(monkeypatch)
-    c._native = None
     parent = DatasetInfo._from_json(_DS_JSON)
     target = DatasetInfo._from_json(dict(_DS_JSON, id="ds-2", name="medical-fr"))
     c._resolve = MagicMock(side_effect=[parent, target])
@@ -952,7 +911,6 @@ def test_derive_by_query_append(monkeypatch):
 
 def test_derive_by_query_requires_name_or_target(monkeypatch):
     c = _client(monkeypatch)
-    c._native = None
     c._resolve = MagicMock(return_value=DatasetInfo._from_json(_DS_JSON))
     with pytest.raises(ValueError, match="name= .* target_repo_id="):
         c.derive_by_query("g/parent", "q", mode="word")
@@ -960,7 +918,6 @@ def test_derive_by_query_requires_name_or_target(monkeypatch):
 
 def test_derived_rows(monkeypatch):
     c = _client(monkeypatch)
-    c._native = None
     c._resolve = MagicMock(return_value=DatasetInfo._from_json(_DS_JSON))
     c._http.get.return_value = _resp(200, {"rows": [{"k": 1}], "total": 1, "offset": 0, "limit": 50})
     assert c.derived_rows("g/n")["total"] == 1
@@ -1364,7 +1321,6 @@ def test_module_delete_dataset(fake_singleton):
 def test_derive_by_ids_sends_columns(monkeypatch):
     c = _client(monkeypatch)
     c._resolve = MagicMock(return_value=DatasetInfo._from_json(_DS_JSON))
-    c._native = None
     c._http.post.return_value = _resp(200, _DS_JSON)
     c.derive_by_ids("g/n", ["a", "b"], name="g/child",
                     columns={"n_health": [9, 20]})
@@ -1377,7 +1333,6 @@ def test_derive_by_ids_chunks_columns_alongside_ids(monkeypatch):
     # wrong key -- and nothing downstream can tell.
     c = _client(monkeypatch)
     c._resolve = MagicMock(return_value=DatasetInfo._from_json(_DS_JSON))
-    c._native = None
     c._http.post.return_value = _resp(200, {**_DS_JSON, "id": "ds-new"})
     ids = [f"i{n}" for n in range(5)]
     c.derive_by_ids("g/n", ids, name="g/child", chunk_size=2,

openrunner_sdk-2.41.9/openrunner/_native.py

@@ -1,37 +0,0 @@
-"""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, dataset editable-overlay columns
-(add column / set cell / edit row / get row — source columns stay read-only),
-and dataset search + query-derivation (full-text / semantic / regex / word
-union·intersect, LLM keyword-expand, derive-by-query + derived rows).
-"""
-
-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)