openrunner-sdk 2.41.5__tar.gz → 2.41.6__tar.gz

{openrunner_sdk-2.41.5 → openrunner_sdk-2.41.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrunner-sdk
-Version: 2.41.5
+Version: 2.41.6
 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.5 → openrunner_sdk-2.41.6}/openrunner/CLAUDE.md

@@ -96,10 +96,11 @@ falling back to pure-Python httpx otherwise:
 ord.search_dataset(repo, q, mode="mixed"|"exact", lang="fr")   # BM25 / phrase, lang filter
 ord.optimize_embedding_search(repo)                            # build ANN index (once)
 ord.semantic_search(repo, q, lang="en,fr")                     # vector (cosine) search
+ord.regex_search(repo, r"\bcancel(led)?\b", lang="en")         # Python-re over the text column (bounded)
 ord.word_lookup(repo, "medical,doctor", op="union"|"intersect", lang="fr")  # lexical_map
 ord.keyword_expand("medical terms in french", count=300)       # LLM -> {keywords, csv, count}
 
-# derive: mode = word (op union/intersect) | fts | exact | semantic; lang filter; append via target_repo_id
+# derive: mode = word (op union/intersect) | fts | exact | regex | semantic; lang filter; append via target_repo_id
 child = ord.derive_by_query(parent, keywords_csv, name="org/medical-fr",
                             mode="word", lang="fr", limit=5000)
 ord.derive_by_query(parent, "more,terms", target_repo_id="org/medical-fr", mode="word")  # append, de-dup

{openrunner_sdk-2.41.5 → openrunner_sdk-2.41.6}/openrunner/__init__.py

@@ -107,6 +107,7 @@ from openrunner.datasets import (
     optimize_embedding_search,
     push_dataset,
     search_dataset,
+    regex_search,
     semantic_search,
     word_lookup,
     set_dataset_card,

{openrunner_sdk-2.41.5 → openrunner_sdk-2.41.6}/openrunner/_native.py

@@ -11,8 +11,8 @@ 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 / word union·intersect,
-LLM keyword-expand, derive-by-query + derived rows).
+and dataset search + query-derivation (full-text / semantic / regex / word
+union·intersect, LLM keyword-expand, derive-by-query + derived rows).
 """
 
 from __future__ import annotations

{openrunner_sdk-2.41.5 → openrunner_sdk-2.41.6}/openrunner/datasets.py

@@ -794,6 +794,25 @@ class DatasetsClient:
         _check(r)
         return r.json().get("rows", r.json().get("hits", []))
 
+    def regex_search(
+        self, repo_id: str, pattern: str, *, limit: int = 20, lang: str = ""
+    ) -> 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.
+        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
+        r = self._http.get(f"/datasets/{ds.id}/search", params=params)
+        _check(r)
+        return r.json().get("rows", [])
+
     def optimize_embedding_search(
         self,
         repo_id: str,
@@ -869,7 +888,8 @@ class DatasetsClient:
         """Create (or append to) a dataset **derived from a query** over ``repo_id``.
 
         ``mode``: "word" (``q`` = term / CSV; pairs with LLM ``keyword_expand``),
-        "fts" (BM25), "exact" (phrase), "semantic" (vector — needs
+        "fts" (BM25), "exact" (phrase), "regex" (``q`` = a Python-``re`` pattern
+        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
@@ -1292,6 +1312,11 @@ def semantic_search(repo_id: str, query: str, **kwargs: Any) -> list[dict]:
     return _c().semantic_search(repo_id, query, **kwargs)
 
 
+def regex_search(repo_id: str, pattern: str, **kwargs: Any) -> list[dict]:
+    """Regex search — Python-``re`` ``pattern`` over the text column (bounded)."""
+    return _c().regex_search(repo_id, pattern, **kwargs)
+
+
 def optimize_embedding_search(repo_id: str, **kwargs: Any) -> dict:
     """Embed rows + build the ANN index for semantic search / semantic-derive."""
     return _c().optimize_embedding_search(repo_id, **kwargs)

{openrunner_sdk-2.41.5 → openrunner_sdk-2.41.6}/openrunner/install_commands.py

@@ -2135,7 +2135,7 @@ Give the dataset **URL** (`<base>/datasets/<id>`), the modality/tasks/languages,
 
 DERIVE_DATASET_CMD = """---
 name: {prefix}derive-dataset
-description: Derive a dataset from an existing one — either by a SEARCH QUERY (semantic / word union·intersect / fts / exact, with language filter + LLM keyword expansion) or by adding a computed column. Keeps lineage, never re-uploads the parent's media.
+description: Derive a dataset from an existing one — either by a SEARCH QUERY (semantic / regex / word union·intersect / fts / exact, with language filter + LLM keyword expansion) or by adding a computed column. Keeps lineage, never re-uploads the parent's media.
 argument-hint: "[parent org/name] [child org/name] [--query ... | --column NAME]"
 allowed-tools:
   - Bash
@@ -2152,7 +2152,7 @@ Pick by intent: **subset/select rows -> A**; **annotate/flag rows -> B**.
 
 ---
 
-## A. Query-derivation (semantic / word union·intersect / fts / exact + lang + LLM keywords)
+## A. Query-derivation (semantic / regex / word union·intersect / fts / exact + lang + LLM keywords)
 
 All server-side; the SDK delegates to the native Rust core when installed. `PARENT` must be indexed (`ds.index_dataset(...)`; for `semantic`, also `ds.optimize_embedding_search(...)`).
 
@@ -2177,7 +2177,7 @@ print(ds.derived_rows('ORG/medical-fr', limit=10))
 "
 ```
 
-Query modes (`mode=`): `word` (CSV of terms; `op='union'|'intersect'`), `fts` (BM25), `exact` (phrase), `semantic` (vector ANN). `lang=` takes a language or CSV ("fr" / "en,fr"); "" = all. Lineage to `PARENT` is recorded automatically by `derive_by_query`.
+Query modes (`mode=`): `word` (CSV of terms; `op='union'|'intersect'`), `fts` (BM25), `exact` (phrase), `regex` (a Python-`re` pattern over the text column, e.g. `ds.regex_search('ORG/PARENT', r'\\bcancel(led)?\\b')` / `ds.derive_by_query('ORG/PARENT', r'\\brefund', name='ORG/refunds', mode='regex')`), `semantic` (vector ANN). `lang=` takes a language or CSV ("fr" / "en,fr"); "" = all. Lineage to `PARENT` is recorded automatically by `derive_by_query`.
 
 ---
 

{openrunner_sdk-2.41.5 → openrunner_sdk-2.41.6}/pyproject.toml

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

{openrunner_sdk-2.41.5 → openrunner_sdk-2.41.6}/tests/test_datasets_module.py

@@ -720,6 +720,40 @@ def test_semantic_search(monkeypatch):
     assert "/semantic" in c._http.get.call_args.args[0]
 
 
+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)
+    assert out[0]["debug_id"] == "r1"
+    params = c._http.get.call_args.kwargs["params"]
+    assert params["mode"] == "regex" and params["q"] == r"\bcancel(led)?\b"
+    assert params["lang"] == "en"
+    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")
+    body = c._http.post.call_args.kwargs["json"]
+    assert body["mode"] == "regex" and body["q"] == r"\bcancel" and body["lang"] == "en"
+
+
 def test_optimize_embedding_search(monkeypatch):
     c = _client(monkeypatch)
     c._native = None
@@ -1093,6 +1127,11 @@ def test_module_semantic_search(fake_singleton):
     assert ds_mod.semantic_search("g/n", "q", lang="fr") == [{"id": 2}]
 
 
+def test_module_regex_search(fake_singleton):
+    fake_singleton.regex_search.return_value = [{"debug_id": "r1"}]
+    assert ds_mod.regex_search("g/n", r"\bfoo", lang="en") == [{"debug_id": "r1"}]
+
+
 def test_module_optimize_embedding_search(fake_singleton):
     fake_singleton.optimize_embedding_search.return_value = {"status": "ready"}
     assert ds_mod.optimize_embedding_search("g/n") == {"status": "ready"}