omnirun 0.2.1__tar.gz → 0.2.2__tar.gz

{omnirun-0.2.1 → omnirun-0.2.2}/.github/workflows/publish.yml

@@ -22,6 +22,9 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v7
 
+      - name: Check tag matches package version
+        run: ./scripts/check-version.sh "${GITHUB_REF_NAME}"
+
       - name: Install uv
         uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
         with:

{omnirun-0.2.1 → omnirun-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omnirun
-Version: 0.2.1
+Version: 0.2.2
 Summary: Run jobs from your repo anywhere: Slurm over SSH, any SSH box, Kaggle, Colab, or marketplace GPUs
 Author-email: Dmitrii Mukhutdinov <flyingleafe@gmail.com>
 License: MIT
@@ -140,7 +140,9 @@ section name is yours (you can have several of the same type). All backends
 accept `enabled = false` to keep the config without probing it. Every backend
 also accepts `project_root` (point it at an existing checkout to reuse its
 `.git`/`.venv`) and `max_parallel` (queue-daemon cap on concurrent jobs, default
-`1`).
+`1`). `project_root` may be a single path (applied to every repo) or a table
+mapping repo slug -> path, with an optional `default` key as fallback, so one
+backend can serve several repos (each getting the right checkout).
 
 ```toml
 [policy]
@@ -159,6 +161,7 @@ poll_interval_s = 10.0       # scheduler tick: refresh running + place pending
 type = "local"
 # root = "$HOME/.omnirun"    # OMNIRUN_ROOT: where jobs live
 # project_root = "$HOME/proj"  # reuse an existing checkout's .git and .venv
+# project_root = { my-repo = "$HOME/proj" }  # or per-repo (by slug), else default path
 # max_parallel = 2           # queue daemon: run up to 2 jobs here at once
 
 # ---- any machine you can ssh into ----

{omnirun-0.2.1 → omnirun-0.2.2}/README.md

@@ -120,7 +120,9 @@ section name is yours (you can have several of the same type). All backends
 accept `enabled = false` to keep the config without probing it. Every backend
 also accepts `project_root` (point it at an existing checkout to reuse its
 `.git`/`.venv`) and `max_parallel` (queue-daemon cap on concurrent jobs, default
-`1`).
+`1`). `project_root` may be a single path (applied to every repo) or a table
+mapping repo slug -> path, with an optional `default` key as fallback, so one
+backend can serve several repos (each getting the right checkout).
 
 ```toml
 [policy]
@@ -139,6 +141,7 @@ poll_interval_s = 10.0       # scheduler tick: refresh running + place pending
 type = "local"
 # root = "$HOME/.omnirun"    # OMNIRUN_ROOT: where jobs live
 # project_root = "$HOME/proj"  # reuse an existing checkout's .git and .venv
+# project_root = { my-repo = "$HOME/proj" }  # or per-repo (by slug), else default path
 # max_parallel = 2           # queue daemon: run up to 2 jobs here at once
 
 # ---- any machine you can ssh into ----

{omnirun-0.2.1 → omnirun-0.2.2}/flake.nix

@@ -71,6 +71,9 @@
 
           shellHook = ''
             ${pre-commit-check.shellHook}
+            # Guard against tagging a release without bumping the version.
+            # pre-commit owns only the pre-commit hook, so pre-push is ours.
+            ln -sf "$PWD/scripts/pre-push" "$(git rev-parse --git-path hooks)/pre-push"
             export LD_LIBRARY_PATH=${pkgs.lib.makeLibraryPath [ pkgs.stdenv.cc.cc.lib pkgs.zlib ]}:$LD_LIBRARY_PATH
             export UV_PYTHON=${python}/bin/python
             uv sync --quiet

{omnirun-0.2.1 → omnirun-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "omnirun"
-version = "0.2.1"
+version = "0.2.2"
 description = "Run jobs from your repo anywhere: Slurm over SSH, any SSH box, Kaggle, Colab, or marketplace GPUs"
 readme = "README.md"
 requires-python = ">=3.12"

omnirun-0.2.2/scripts/check-version.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+# Verify the package version is internally consistent, and optionally that it
+# matches an expected version (e.g. a release tag).
+#
+#   scripts/check-version.sh            # pyproject.toml == src/omnirun/__init__.py
+#   scripts/check-version.sh v0.2.2     # ...and both equal 0.2.2
+#
+# Used by both the publish workflow and the pre-push hook so the rule lives in
+# one place.
+set -euo pipefail
+
+root="$(cd "$(dirname "$0")/.." && pwd)"
+
+extract() { grep -m1 -E "$2" "$root/$1" | sed -E 's/.*"([^"]+)".*/\1/'; }
+
+pyproject="$(extract pyproject.toml '^version *= *"')"
+init="$(extract src/omnirun/__init__.py '^__version__ *= *"')"
+
+if [ "$pyproject" != "$init" ]; then
+  echo "version mismatch: pyproject.toml=$pyproject src/omnirun/__init__.py=$init" >&2
+  exit 1
+fi
+
+if [ "$#" -ge 1 ]; then
+  expected="${1#v}"
+  if [ "$pyproject" != "$expected" ]; then
+    echo "version mismatch: expected $expected but package version is $pyproject" >&2
+    exit 1
+  fi
+fi
+
+echo "version OK: $pyproject"

omnirun-0.2.2/scripts/pre-push

@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+# Refuse to push a release tag whose commit does not declare a matching version.
+#
+# Installed as .git/hooks/pre-push by the devShell (see flake.nix). It inspects
+# the *pushed commit's* content (via `git show <sha>:path`), so it catches a
+# stale worktree too. CI (publish.yml) enforces the same rule server-side.
+set -euo pipefail
+
+version_at() { git show "$1:$2" | grep -m1 -E "$3" | sed -E 's/.*"([^"]+)".*/\1/'; }
+
+status=0
+while read -r _local_ref local_sha remote_ref _remote_sha; do
+  case "$remote_ref" in
+    refs/tags/v[0-9]*) ;;
+    *) continue ;;
+  esac
+  # Deleting a tag pushes the zero sha; nothing to check.
+  case "$local_sha" in
+    0000000000000000000000000000000000000000) continue ;;
+  esac
+
+  tag="${remote_ref#refs/tags/}"
+  pyproject="$(version_at "$local_sha" pyproject.toml '^version *= *"')"
+  init="$(version_at "$local_sha" src/omnirun/__init__.py '^__version__ *= *"')"
+
+  if [ "$tag" != "v$pyproject" ]; then
+    echo "pre-push: tag $tag != pyproject version $pyproject (commit ${local_sha:0:12})" >&2
+    status=1
+  fi
+  if [ "$pyproject" != "$init" ]; then
+    echo "pre-push: pyproject $pyproject != __init__ $init (commit ${local_sha:0:12})" >&2
+    status=1
+  fi
+done
+
+if [ "$status" -ne 0 ]; then
+  echo "pre-push: bump the version before tagging (see scripts/check-version.sh)" >&2
+fi
+exit "$status"

{omnirun-0.2.1 → omnirun-0.2.2}/src/omnirun/__init__.py

@@ -1,3 +1,3 @@
 """omnirun — run jobs from your repo anywhere."""
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"

{omnirun-0.2.1 → omnirun-0.2.2}/src/omnirun/backends/colab.py

@@ -360,7 +360,9 @@ class ColabBackend(Backend):
                 BootstrapParams(
                     omnirun_root=COLAB_ROOT,
                     project_root=jobdir.project_root_of(
-                        COLAB_ROOT, spec.repo.slug, self.config.project_root
+                        COLAB_ROOT,
+                        spec.repo.slug,
+                        self.config.project_root_for(spec.repo.slug),
                     ),
                     code=code,
                 ),

{omnirun-0.2.1 → omnirun-0.2.2}/src/omnirun/backends/kaggle.py

@@ -435,7 +435,9 @@ class KaggleBackend(Backend):
                 BootstrapParams(
                     omnirun_root=KAGGLE_ROOT,
                     project_root=jobdir.project_root_of(
-                        KAGGLE_ROOT, spec.repo.slug, self.config.project_root
+                        KAGGLE_ROOT,
+                        spec.repo.slug,
+                        self.config.project_root_for(spec.repo.slug),
                     ),
                     code=code,
                 ),

{omnirun-0.2.1 → omnirun-0.2.2}/src/omnirun/backends/local.py

@@ -113,7 +113,10 @@ class LocalBackend(Backend):
     def submit(self, spec: JobSpec, offer: Offer) -> JobHandle:
         root = jobdir.remote_root(self.exec, self.config.root)
         project_root = jobdir.resolve_project_root(
-            self.exec, root, spec.repo.slug, self.config.project_root
+            self.exec,
+            root,
+            spec.repo.slug,
+            self.config.project_root_for(spec.repo.slug),
         )
         params = BootstrapParams(
             omnirun_root=root,

{omnirun-0.2.1 → omnirun-0.2.2}/src/omnirun/backends/marketplace.py

@@ -286,7 +286,7 @@ class MarketplaceBackend(Backend, ABC):
             self._wait_ssh(ex)
             root = jobdir.remote_root(ex, self.config.root)
             project_root = jobdir.resolve_project_root(
-                ex, root, spec.repo.slug, self.config.project_root
+                ex, root, spec.repo.slug, self.config.project_root_for(spec.repo.slug)
             )
             params = BootstrapParams(
                 omnirun_root=root,

{omnirun-0.2.1 → omnirun-0.2.2}/src/omnirun/backends/slurm.py

@@ -181,6 +181,8 @@ class SlurmBackend(Backend):
 
         reasons: list[str] = []
         notes: list[str] = []
+        if res.wants_gpu() and self.config.extra("has_gpus", True) is False:
+            reasons.append(f"backend {self.name} is CPU-only (has_gpus = false)")
         if res.wants_gpu() and res.gpu_type and self.config.gpu_map:
             if _gpu_map_lookup(self.config.gpu_map, res.gpu_type) is None:
                 reasons.append(
@@ -258,7 +260,7 @@ class SlurmBackend(Backend):
         root = self.config.root
         job_dir = jobdir.job_dir_of(root, spec.job_id)
         project_root = jobdir.project_root_of(
-            root, spec.repo.slug, self.config.project_root
+            root, spec.repo.slug, self.config.project_root_for(spec.repo.slug)
         )
         sbatch = render_sbatch(spec, self.config, job_dir, root)
         bootstrap = generate_bootstrap(
@@ -281,7 +283,7 @@ class SlurmBackend(Backend):
         ex = self.exec_
         root = jobdir.remote_root(ex, self.config.root)
         project_root = jobdir.resolve_project_root(
-            ex, root, spec.repo.slug, self.config.project_root
+            ex, root, spec.repo.slug, self.config.project_root_for(spec.repo.slug)
         )
         params = BootstrapParams(
             omnirun_root=root,

{omnirun-0.2.1 → omnirun-0.2.2}/src/omnirun/backends/ssh.py

@@ -217,7 +217,7 @@ class SshBackend(Backend):
         ex = self.exec_
         root = jobdir.remote_root(ex, self.config.root)
         project_root = jobdir.resolve_project_root(
-            ex, root, spec.repo.slug, self.config.project_root
+            ex, root, spec.repo.slug, self.config.project_root_for(spec.repo.slug)
         )
         params = BootstrapParams(
             omnirun_root=root,

{omnirun-0.2.1 → omnirun-0.2.2}/src/omnirun/backends/vast.py

@@ -37,23 +37,25 @@ OFFER_LIMIT = 5
 MIN_RELIABILITY = 0.95
 
 # normalized name -> vast gpu_name values (their catalog naming)
+# The REST /bundles/ endpoint matches gpu_name with spaces ("A100 SXM4");
+# underscore forms match nothing (the vast CLI translates them, the API doesn't).
 VAST_GPU_NAMES: dict[str, list[str]] = {
     "H200": ["H200"],
-    "H100": ["H100_SXM", "H100_PCIE", "H100_NVL"],
-    "A100": ["A100_SXM4", "A100_PCIE", "A100X"],
-    "A100-80": ["A100_SXM4", "A100_PCIE"],
-    "A6000": ["RTX_A6000"],
+    "H100": ["H100 SXM", "H100 PCIE", "H100 NVL"],
+    "A100": ["A100 SXM4", "A100 PCIE", "A100X"],
+    "A100-80": ["A100 SXM4", "A100 PCIE"],
+    "A6000": ["RTX A6000"],
     "L40": ["L40", "L40S"],
     "L4": ["L4"],
-    "V100": ["Tesla_V100"],
-    "4090": ["RTX_4090"],
-    "3090": ["RTX_3090"],
-    "5090": ["RTX_5090"],
+    "V100": ["Tesla V100"],
+    "4090": ["RTX 4090"],
+    "3090": ["RTX 3090"],
+    "5090": ["RTX 5090"],
 }
 
 
 def vast_gpu_names(gpu_type: str) -> list[str]:
-    return VAST_GPU_NAMES.get(gpu_type, [gpu_type.replace(" ", "_").replace("-", "_")])
+    return VAST_GPU_NAMES.get(gpu_type, [gpu_type.replace("_", " ").replace("-", " ")])
 
 
 def normalize_vast_gpu(name: str, gpu_ram_mb: float | None = None) -> str:
@@ -84,6 +86,10 @@ class VastBackend(MarketplaceBackend):
         }
         if res.gpu_type is not None:
             filt["gpu_name"] = {"in": vast_gpu_names(res.gpu_type)}
+            if res.gpu_type == "A100-80":
+                # cheapest-first + OFFER_LIMIT would otherwise fill the page
+                # with 40GB A100s that normalization then discards
+                filt["gpu_ram"] = {"gte": 70_000}
         elif res.min_vram_gb is not None:
             # vast reports gpu_ram in MB (verify live)
             filt["gpu_ram"] = {"gte": res.min_vram_gb * 1024}

{omnirun-0.2.1 → omnirun-0.2.2}/src/omnirun/config.py

@@ -48,8 +48,10 @@ class BackendConfig(BaseModel, extra="allow"):
     env_setup: list[str] = Field(default_factory=list)  # module loads, exports
     # Where a project's shared checkout + .venv live on the worker. Default
     # "$OMNIRUN_ROOT/projects/<slug>"; point at an existing clone to reuse it
-    # (its .git becomes the object store, its .venv the shared env).
-    project_root: str | None = None
+    # (its .git becomes the object store, its .venv the shared env). A str
+    # applies to every repo; a dict maps repo slug -> path (with an optional
+    # "default" key as fallback) so one backend can serve several repos.
+    project_root: str | dict[str, str] | None = None
 
     # static capability declaration (ssh backend; probe checks live via nvidia-smi)
     gpus: list[GpuDecl] = Field(default_factory=list)
@@ -74,6 +76,15 @@ class BackendConfig(BaseModel, extra="allow"):
     def extra(self, key: str, default: Any = None) -> Any:
         return (self.model_extra or {}).get(key, default)
 
+    def project_root_for(self, slug: str) -> str | None:
+        """Configured project root for a repo. A str applies to every repo; a
+        dict is keyed by slug, falling back to a "default" key, then to None
+        (the built-in "$OMNIRUN_ROOT/projects/<slug>" path)."""
+        pr = self.project_root
+        if isinstance(pr, dict):
+            return pr.get(slug) or pr.get("default")
+        return pr
+
 
 class DaemonConfig(BaseModel):
     host: str = "127.0.0.1"  # localhost socket; bind 0.0.0.0 + auth to go remote

omnirun-0.2.2/tests/test_config.py

@@ -0,0 +1,37 @@
+"""BackendConfig helpers: project_root_for resolution (str / dict / None)."""
+
+from __future__ import annotations
+
+from omnirun.config import BackendConfig
+
+
+def make_config(**kw) -> BackendConfig:
+    return BackendConfig.model_validate({"type": "slurm", **kw})
+
+
+def test_project_root_for_none_is_default():
+    assert make_config().project_root_for("proj") is None
+
+
+def test_project_root_for_str_applies_to_every_repo():
+    c = make_config(project_root="$HOME/shared")
+    assert c.project_root_for("proj") == "$HOME/shared"
+    assert c.project_root_for("other") == "$HOME/shared"
+
+
+def test_project_root_for_dict_slug_hit():
+    c = make_config(project_root={"hns": "$HOME/projects/hns"})
+    assert c.project_root_for("hns") == "$HOME/projects/hns"
+
+
+def test_project_root_for_dict_no_match_falls_through_to_none():
+    c = make_config(project_root={"hns": "$HOME/projects/hns"})
+    assert c.project_root_for("auraflow") is None
+
+
+def test_project_root_for_dict_default_fallback():
+    c = make_config(
+        project_root={"hns": "$HOME/projects/hns", "default": "$HOME/managed"}
+    )
+    assert c.project_root_for("hns") == "$HOME/projects/hns"  # slug wins over default
+    assert c.project_root_for("auraflow") == "$HOME/managed"  # fallback

{omnirun-0.2.1 → omnirun-0.2.2}/tests/test_marketplaces.py

@@ -474,7 +474,7 @@ def test_vast_probe_filter_and_parsing():
 
     body = json.loads(route.calls[0].request.content)
     assert body["type"] == "ondemand"
-    assert body["gpu_name"] == {"in": ["H100_SXM", "H100_PCIE", "H100_NVL"]}
+    assert body["gpu_name"] == {"in": ["H100 SXM", "H100 PCIE", "H100 NVL"]}
     assert body["num_gpus"] == {"eq": 1}
     assert body["rentable"] == {"eq": True}
     assert body["verified"] == {"eq": True}

{omnirun-0.2.1 → omnirun-0.2.2}/tests/test_slurm.py

@@ -295,6 +295,22 @@ def test_render_payload_sbatch_then_bootstrap():
     assert fake.files == {}
 
 
+def test_render_payload_project_root_dict_matches_slug():
+    # spec slug is "proj": a per-repo dict resolves to that repo's checkout...
+    fake = FakeExec()
+    b = make_backend(fake, root=ROOT, project_root={"proj": "/data/existing/proj"})
+    payload = b.render_payload(make_spec(), offer=None)
+    assert 'PROJECT_ROOT="/data/existing/proj"' in payload
+
+
+def test_render_payload_project_root_dict_no_match_uses_default():
+    # ...and an unrelated slug falls through to the built-in "$root/projects/<slug>".
+    fake = FakeExec()
+    b = make_backend(fake, root=ROOT, project_root={"other": "/data/existing/other"})
+    payload = b.render_payload(make_spec(), offer=None)
+    assert f'PROJECT_ROOT="{ROOT}/projects/proj"' in payload
+
+
 # --- status mapping -------------------------------------------------------------------
 
 
@@ -515,6 +531,16 @@ def test_probe_warns_when_type_requested_but_no_map():
     assert "gpu_map" in offer.notes
 
 
+def test_probe_unfit_for_gpu_job_when_cpu_only():
+    fake = FakeExec()
+    (offer,) = make_backend(fake, has_gpus=False).probe(ResourceSpec(gpus=1))
+    assert not offer.fits
+    assert "CPU-only" in offer.unfit_reasons[0]
+    # CPU jobs still fit
+    (offer,) = make_backend(fake, has_gpus=False).probe(ResourceSpec())
+    assert offer.fits
+
+
 def test_probe_wait_tier1_idle_nodes():
     fake = FakeExec()
     fake.add(r"sinfo -p gpu -t idle", stdout="node01 gpu:a100:4\nnode02 (null)\n")