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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: openrunner-sdk
-Version: 2.41.9
+Version: 2.41.11
 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
@@ -19,6 +19,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.10
+Requires-Dist: certifi>=2026.10.19
 Requires-Dist: click<9.0,>=8.1
 Requires-Dist: httpx<1.0,>=0.27
 Requires-Dist: mcp<2.0,>=1.0

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

@@ -70,6 +70,23 @@ CLI: `openrunner datasets create … --connection ML.text-datasets`,
 Files land under `s3://<bucket>/<conn.prefix>/datasets/<org_id>/<name>/<path>`;
 `source_uri` is set to that prefix and `source_type` becomes `managed`.
 
+### Import from the Hugging Face Hub
+
+Clone a Hub dataset into a managed dataset, with lineage — the server streams
+only the selected files to the org's storage (no local copy), packs loose audio
+into WebDataset shards, records `derived from hf://<repo>@<commit>`, adopts the
+card and indexes the result:
+
+```python
+ord.import_hf("https://huggingface.co/datasets/org/name", org="gladia",
+              config="fr", splits=["test"], languages=["fr"])  # -> {status, dataset_id, revision, ...}
+```
+
+CLI: `openrunner dataset import-hf hf://org/name@main --split test --lang fr`.
+Same repo + commit + selection again returns the existing dataset
+(`status="exists"`); `force=True` re-imports. Language selection is per file /
+config (no row-level filtering inside parquet).
+
 Uploading does **not** index/embed. To make a managed dataset searchable, build
 a LanceDB index (written to the same connection) — opt-in:
 
@@ -88,9 +105,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.11}/openrunner/cli.py

@@ -4229,6 +4229,10 @@ def datasets() -> None:
     pass
 
 
+# ``openrunner dataset ...`` is an alias of ``openrunner datasets ...``.
+main.add_command(datasets, name="dataset")
+
+
 @datasets.command("list")
 @click.option("--org", default=None, help="Scope to an organization (slug/name)")
 def datasets_list(org: str | None) -> None:
@@ -4372,6 +4376,47 @@ def datasets_shard(repo_id, folder, connection, shard_size, do_index):
                    + (f" (truncated at {ir.get('cap')}, pass --max-rows)" if ir.get("truncated") else ""))
 
 
+@datasets.command("import-hf")
+@click.argument("url")
+@click.option("--org", default=None, help="Target organization (default: your only org)")
+@click.option("--name", default=None, help="OpenRunner dataset name (default: the HF repo name)")
+@click.option("--revision", default=None, help="Branch, tag or commit (default: main)")
+@click.option("--config", default=None, help="HF config (subset) to import")
+@click.option("--split", "splits", multiple=True, help="Split to import (repeatable or a,b)")
+@click.option("--lang", "langs", multiple=True, help="Language to import (repeatable or a,b)")
+@click.option("--connection", default=None, help="Storage connection (name or UUID); default: org default")
+@click.option("--force", is_flag=True, help="Re-import even if this repo@revision was imported")
+@click.option("--index/--no-index", "do_index", default=True, help="Build the search index after the copy")
+@click.option("--no-wait", is_flag=True, help="Return once the import job has started")
+def datasets_import_hf(url, org, name, revision, config, splits, langs, connection, force,
+                       do_index, no_wait):
+    """Clone a Hugging Face dataset into OpenRunner, with lineage.
+
+    URL is org/name, hf://org/name@rev or https://huggingface.co/datasets/org/name.
+    Only the chosen config/splits/languages are copied, streamed from the Hub to
+    the org's storage (audio packed into WebDataset shards); the dataset is
+    recorded as derived from hf://<repo>@<commit> and indexed. Re-running with
+    the same repo, commit and selection returns the existing dataset.
+    """
+    from openrunner import datasets as ord
+
+    res = ord.import_hf(
+        url, org=org, name=name, revision=revision, config=config,
+        splits=",".join(splits) or None, languages=",".join(langs) or None,
+        connection=connection, force=force, index=do_index, wait=not no_wait,
+    )
+    ref = f"hf://{res.get('hf_repo_id')}@{res.get('revision')}"
+    status = res.get("status")
+    if status == "exists":
+        click.echo(f"Already imported: {res.get('dataset_name')} ({res.get('dataset_id')}) <- {ref}")
+    elif status == "running":
+        click.echo(f"Importing {ref} into {res.get('dataset_name')} ({res.get('dataset_id')}) in the background")
+    else:
+        idx = (res.get("index") or {}).get("status")
+        click.echo(f"Imported {ref} -> {res.get('dataset_name')} ({res.get('dataset_id')}): "
+                   f"{res.get('files_pulled', 0)} files" + (f", index {idx}" if idx else ""))
+
+
 @datasets.command("reconcile-shards")
 @click.argument("repo_id")
 def datasets_reconcile_shards(repo_id):

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

@@ -45,6 +45,14 @@ class DeriveIncomplete(RuntimeError):
         self.resume_from = resume_from
 
 
+def _str_list(v: list[str] | str | None) -> list[str] | None:
+    """``"a,b"`` or ``["a", "b"]`` -> ``["a", "b"]``; empty -> None."""
+    if isinstance(v, str):
+        v = v.split(",")
+    out = [x.strip() for x in v or [] if x and x.strip()]
+    return out or None
+
+
 def _check(r: "httpx.Response") -> "httpx.Response":
     """Raise with the API's actual error detail (FastAPI 422 lists the bad field)."""
     if r.is_success:
@@ -208,11 +216,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 +226,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")
@@ -780,21 +777,38 @@ class DatasetsClient:
             return r.json()
         return self._retry(call)
 
-    def list_files(self, repo_id: str, *, prefix: str = "", limit: int = 5000, offset: int = 0) -> list[dict]:
+    def list_files(
+        self,
+        repo_id: str,
+        *,
+        prefix: str = "",
+        limit: int | None = None,
+        offset: int = 0,
+        page_size: int = 5000,
+    ) -> list[dict]:
         """List the file manifest of a managed dataset (path/size/sha256/uploader).
 
-        `prefix` filters by path prefix; `limit`/`offset` paginate (default 5000)
-        so huge datasets don't return everything at once."""
+        `prefix` filters by path prefix. Pages through the API (which caps a page
+        at 50k, default 5k) until `limit` files are collected, or EVERY file when
+        `limit` is None — a single page silently truncated large datasets (e.g.
+        upload_folder's skip_existing re-uploaded everything past file 5000)."""
         ds = self._resolve(repo_id)
-        params = {"limit": limit, "offset": offset}
-        if prefix:
-            params["prefix"] = prefix
-
-        def call():
-            r = self._http.get(f"/datasets/{ds.id}/files", params=params)
-            _check(r)
-            return r.json()
-        return self._retry(call)
+        out: list[dict] = []
+        while limit is None or len(out) < limit:
+            want = page_size if limit is None else min(page_size, limit - len(out))
+            params = {"limit": want, "offset": offset + len(out)}
+            if prefix:
+                params["prefix"] = prefix
+
+            def call(params=params):
+                r = self._http.get(f"/datasets/{ds.id}/files", params=params)
+                _check(r)
+                return r.json()
+            page = self._retry(call)
+            out.extend(page)
+            if len(page) < want:
+                break
+        return out
 
     # -- search index --------------------------------------------------------
     def index_dataset(
@@ -875,6 +889,83 @@ class DatasetsClient:
             time.sleep(delay)
             delay = min(delay * 1.5, 30.0)
 
+    # -- Hugging Face import -------------------------------------------------
+    def import_hf(
+        self,
+        url: str,
+        *,
+        org: str | None = None,
+        name: str | None = None,
+        revision: str | None = None,
+        config: str | None = None,
+        splits: list[str] | str | None = None,
+        languages: list[str] | str | None = None,
+        connection: str | None = None,
+        force: bool = False,
+        index: bool = True,
+        wait: bool = True,
+        timeout: float = 86400.0,
+    ) -> dict:
+        """Clone a Hugging Face dataset into OpenRunner, with lineage.
+
+        ``url`` is ``org/name``, ``hf://org/name@rev`` or a
+        ``https://huggingface.co/datasets/...`` URL. The server streams the
+        selected files (``config`` / ``splits`` / ``languages``) from the Hub
+        straight into the org's storage connection (audio packed into WebDataset
+        shards), records ``derived from hf://<repo>@<sha>``, adopts the HF card
+        and indexes the result. Re-importing the same repo at the same commit
+        with the same selection returns the existing dataset
+        (``status="exists"``) unless ``force=True``.
+
+        ``org`` defaults to your only organization. With ``wait=True`` this
+        polls until the import job finishes and returns
+        ``{"status", "dataset_id", "dataset_name", "revision", ...}``.
+        """
+        org_id = self._org_id(org) if org else self._only_org_id()
+        body = {
+            "hf_repo_id": url, "repo_type": "dataset", "org_id": org_id, "name": name,
+            "revision": revision, "config": config, "splits": _str_list(splits),
+            "languages": _str_list(languages), "connection": connection,
+            "force": force, "index": index, "background": True,
+        }
+        r = self._http.post("/hf/import", json=body, timeout=300.0)
+        _check(r)
+        res = r.json()
+        if res.get("status") != "running" or not wait:
+            return res
+        return self._wait_hf_import(res, timeout)
+
+    def _only_org_id(self) -> str:
+        r = self._http.get("/organizations")
+        _check(r)
+        orgs = r.json()
+        orgs = orgs if isinstance(orgs, list) else orgs.get("organizations", [])
+        if len(orgs) != 1:
+            raise ValueError(f"pass org= (you belong to {len(orgs)} organizations)")
+        return str(orgs[0]["id"])
+
+    def _wait_hf_import(self, res: dict, timeout: float) -> dict:
+        """Poll ``dataset_metadata.hf_import_job`` until the import ends."""
+        import time
+
+        ds_id = res["dataset_id"]
+        deadline, delay = time.monotonic() + timeout, 2.0
+        while True:
+            r = self._http.get(f"/datasets/{ds_id}")
+            _check(r)
+            meta = r.json().get("metadata") or {}
+            job = meta.get("hf_import_job") or {}
+            if job.get("status") == "ready":
+                return {**res, "status": "success", "files_pulled": job.get("files", 0),
+                        "revision": job.get("revision") or res.get("revision"),
+                        "index": meta.get("index_job")}
+            if job.get("status") == "error":
+                raise RuntimeError(f"Hugging Face import failed: {job.get('error')}")
+            if time.monotonic() > deadline:
+                raise TimeoutError(f"Hugging Face import still running after {timeout:.0f}s")
+            time.sleep(delay)
+            delay = min(delay * 1.5, 30.0)
+
     @staticmethod
     def _warn_truncated(res: dict) -> dict:
         if res.get("truncated"):
@@ -958,13 +1049,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 +1065,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 +1080,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 +1100,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 +1116,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 +1133,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 +1161,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 +1175,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 +1231,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 +1251,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 +1272,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 +1352,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 +1384,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 +1397,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 +1407,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()
@@ -1650,6 +1694,14 @@ def upload_sharded(repo_id: str, folder: str, **kwargs: Any) -> dict:
     return _c().upload_sharded(repo_id, folder, **kwargs)
 
 
+def import_hf(url: str, **kwargs: Any) -> dict:
+    """Clone a Hugging Face dataset (streamed, with lineage + index) into OpenRunner.
+
+    ``import_hf("hf://org/name", splits=["test"], languages=["fr"], org="gladia")``.
+    """
+    return _c().import_hf(url, **kwargs)
+
+
 def reconcile_shards(repo_id: str, **kwargs: Any) -> dict:
     """Rebuild the tar clip index (index.jsonl) from the shards on S3."""
     return _c().reconcile_shards(repo_id, **kwargs)

{openrunner_sdk-2.41.9 → openrunner_sdk-2.41.11}/openrunner/install_commands.py

@@ -1654,7 +1654,7 @@ if '/' not in target:
 else:
     repos = [(target, None)]
 for repo, meta in repos:
-    files = ds.list_files(repo, limit=100000)
+    files = ds.list_files(repo)
     total = sum((f.get('size_bytes') or f.get('size') or 0) for f in files)
     print(f'{{repo}}: {{len(files)}} files, {{total/1e9:.1f}} GB')
 print('PLAN: dir=' + ddir + ' max_files=' + str(mx))
@@ -1685,7 +1685,7 @@ if '/' not in target:
 else:
     repos = [target]
 for repo in repos:
-    files = ds.list_files(repo, limit=100000)
+    files = ds.list_files(repo)
     paths = [f['path'] for f in files]
     if mx is not None: paths = paths[:mx]
     name = repo.split('/')[-1]

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

@@ -1,6 +1,6 @@
 [project]
 name = "openrunner-sdk"
-version = "2.41.9"
+version = "2.41.11"
 description = "OpenRunner SDK - W&B-compatible ML experiment tracking client"
 readme = "README.md"
 license = {text = "MIT"}
@@ -19,7 +19,7 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
 ]
-dependencies = ["httpx>=0.27,<1.0", "Pillow>=10.0,<14", "psutil>=6.0,<8.0", "click>=8.1,<9.0", "nvidia-ml-py>=12.0,<14.0", "mcp>=1.0,<2.0"]
+dependencies = ["httpx>=0.27,<1.0", "certifi>=2026.10.19", "Pillow>=10.0,<14", "psutil>=6.0,<8.0", "click>=8.1,<9.0", "nvidia-ml-py>=12.0,<14.0", "mcp>=1.0,<2.0"]
 
 [project.urls]
 Homepage = "https://github.com/gladiaio/openrunner"