nvdc 0.2.3__tar.gz → 0.2.4__tar.gz

{nvdc-0.2.3 → nvdc-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nvdc
-Version: 0.2.3
+Version: 0.2.4
 Summary: Bring your GPU onto the network: one command turns a GPU into a verifiable, OpenAI-compatible inference node.
 Author: NVDC
 License: Apache-2.0
@@ -14,6 +14,7 @@ Requires-Dist: cryptography>=42.0
 Requires-Dist: nvidia-ml-py>=12.535.77
 Requires-Dist: redis>=5.0
 Requires-Dist: stripe>=9.0
+Requires-Dist: zstandard>=0.22
 Provides-Extra: attestation
 Requires-Dist: nv-attestation-sdk>=2.7.0; extra == "attestation"
 Requires-Dist: nv-local-gpu-verifier>=2.7.0; extra == "attestation"

{nvdc-0.2.3 → nvdc-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nvdc"
-version = "0.2.3"
+version = "0.2.4"
 description = "Bring your GPU onto the network: one command turns a GPU into a verifiable, OpenAI-compatible inference node."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -15,6 +15,8 @@ dependencies = [
     "nvidia-ml-py>=12.535.77",
     "redis>=5.0",
     "stripe>=9.0",
+    # Ollama distributes its runtime as .tar.zst; used by the auto-installer.
+    "zstandard>=0.22",
 ]
 
 [project.optional-dependencies]

{nvdc-0.2.3 → nvdc-0.2.4}/src/nvdc/__init__.py

@@ -1,3 +1,3 @@
 """nvdc: bring your GPU onto the network as a verifiable, OpenAI-compatible inference node."""
 
-__version__ = "0.2.3"
+__version__ = "0.2.4"

{nvdc-0.2.3 → nvdc-0.2.4}/src/nvdc/runtime.py

@@ -14,10 +14,14 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import os
+import platform
 import shutil
 import subprocess
+import sys
 import time
 from dataclasses import asdict, dataclass, field
+from pathlib import Path
 from typing import Optional
 
 import httpx
@@ -36,6 +40,19 @@ log = logging.getLogger("nvdc.runtime")
 
 OLLAMA_URL = "http://localhost:11434"
 
+# User-space Ollama runtime, installed by the client itself when no system
+# Ollama exists (no sudo required — the official tarball is self-contained).
+OLLAMA_INSTALL_DIR = Path(os.path.expanduser("~/.nvdc/ollama"))
+
+
+def _ollama_arch() -> str:
+    m = platform.machine().lower()
+    if m in ("x86_64", "amd64"):
+        return "amd64"
+    if m in ("aarch64", "arm64"):
+        return "arm64"
+    return ""
+
 
 @dataclass
 class LoadState:
@@ -259,8 +276,11 @@ class NodeRuntime:
             return tip + "."
         if any(k in m for k in ("not found", "no such model", "pull")):
             return "Model couldn't be fetched — check your internet connection and try loading again."
-        if any(k in m for k in ("connection", "refused", "not installed", "could not start")):
-            return "Ollama isn't running. Install it from https://ollama.com and try again."
+        if "not installed" in m:
+            return ("On Linux the client installs Ollama automatically — retry the load. "
+                    "On macOS: brew install --cask ollama (or use the MLX backend).")
+        if any(k in m for k in ("connection", "refused", "could not start")):
+            return "Ollama isn't running. Retry the load, or start it manually with 'ollama serve'."
         return "Try a smaller model, or verify Ollama is installed and running, then reload."
 
     async def _ollama_preflight(self, model_id: str):
@@ -290,6 +310,97 @@ class NodeRuntime:
         self.load.detail = "warming model into memory (mock)"
         await asyncio.sleep(0.6)
 
+    def _ollama_bin(self) -> Optional[str]:
+        """The Ollama binary to use: system install, else our user-space one."""
+        found = shutil.which("ollama")
+        if found:
+            return found
+        local = OLLAMA_INSTALL_DIR / "bin" / "ollama"
+        return str(local) if local.exists() else None
+
+    async def _ollama_install(self):
+        """Install the Ollama runtime user-space — the app owns its deps.
+
+        Uses the official self-contained tarball, extracted under ~/.nvdc —
+        no sudo, no system Python/packages touched. Linux only; macOS users
+        get it via the installer script (brew cask) or use the MLX backend.
+        """
+        arch = _ollama_arch()
+        if sys.platform != "linux" or not arch:
+            hint = (" On macOS: brew install --cask ollama"
+                    if sys.platform == "darwin" else "")
+            raise RuntimeError(
+                "Ollama is not installed. Install it from https://ollama.com" + hint)
+        self.load.status = "pulling"
+        self.load.progress = 0
+        self.load.detail = "installing the Ollama runtime (one-time setup)…"
+        OLLAMA_INSTALL_DIR.mkdir(parents=True, exist_ok=True)
+        # Ollama distributes .tar.zst today; keep .tgz as a legacy fallback.
+        tmp = None
+        last_err: Optional[Exception] = None
+        for suffix in (".tar.zst", ".tgz"):
+            url = f"https://ollama.com/download/ollama-linux-{arch}{suffix}"
+            candidate = OLLAMA_INSTALL_DIR / (".download" + suffix)
+            try:
+                log.info("installing the Ollama runtime from %s", url)
+                await self._download(url, candidate)
+                tmp = candidate
+                break
+            except Exception as e:
+                last_err = e
+                candidate.unlink(missing_ok=True)
+        if tmp is None:
+            raise RuntimeError(f"could not download the Ollama runtime: {last_err}")
+        self.load.detail = "unpacking the Ollama runtime…"
+        await asyncio.to_thread(self._extract_runtime, tmp)
+        tmp.unlink(missing_ok=True)
+        # Best-effort: expose `ollama` on the user's PATH for terminal use too.
+        try:
+            local_bin = Path(os.path.expanduser("~/.local/bin"))
+            local_bin.mkdir(parents=True, exist_ok=True)
+            link = local_bin / "ollama"
+            if not link.exists():
+                link.symlink_to(OLLAMA_INSTALL_DIR / "bin" / "ollama")
+        except Exception:
+            pass
+        log.info("Ollama runtime installed to %s", OLLAMA_INSTALL_DIR)
+
+    async def _download(self, url: str, dest: Path):
+        async with httpx.AsyncClient(timeout=None, follow_redirects=True) as c:
+            async with c.stream("GET", url) as r:
+                r.raise_for_status()
+                total = int(r.headers.get("content-length") or 0)
+                done = 0
+                with open(dest, "wb") as f:
+                    async for chunk in r.aiter_bytes(1024 * 1024):
+                        f.write(chunk)
+                        done += len(chunk)
+                        if total:
+                            self.load.progress = int(done * 100 / total)
+                            self.load.detail = (
+                                f"installing the Ollama runtime… "
+                                f"{done // (1024*1024)} / {total // (1024*1024)} MB")
+
+    @staticmethod
+    def _extract_runtime(archive: Path):
+        import tarfile
+
+        def _extract(t: tarfile.TarFile):
+            try:
+                t.extractall(OLLAMA_INSTALL_DIR, filter="data")
+            except TypeError:  # Python < 3.12 without the filter parameter
+                t.extractall(OLLAMA_INSTALL_DIR)
+
+        if archive.name.endswith(".tar.zst"):
+            import zstandard
+            with open(archive, "rb") as f:
+                with zstandard.ZstdDecompressor().stream_reader(f) as reader:
+                    with tarfile.open(fileobj=reader, mode="r|") as t:
+                        _extract(t)
+        else:
+            with tarfile.open(archive, "r:gz") as t:
+                _extract(t)
+
     async def _ollama_ensure_server(self):
         try:
             async with httpx.AsyncClient(timeout=3) as c:
@@ -297,9 +408,15 @@ class NodeRuntime:
             return
         except Exception:
             pass
-        if shutil.which("ollama") is None:
-            raise RuntimeError("Ollama is not installed. Install it from https://ollama.com")
-        subprocess.Popen(["ollama", "serve"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        binary = self._ollama_bin()
+        if binary is None:
+            # The app owns its dependencies: install the runtime, don't bail.
+            await self._ollama_install()
+            binary = self._ollama_bin()
+            if binary is None:
+                raise RuntimeError("Ollama install completed but the binary "
+                                   "was not found — please report this")
+        subprocess.Popen([binary, "serve"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
         for _ in range(20):
             await asyncio.sleep(0.5)
             try:

{nvdc-0.2.3 → nvdc-0.2.4}/src/nvdc.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nvdc
-Version: 0.2.3
+Version: 0.2.4
 Summary: Bring your GPU onto the network: one command turns a GPU into a verifiable, OpenAI-compatible inference node.
 Author: NVDC
 License: Apache-2.0
@@ -14,6 +14,7 @@ Requires-Dist: cryptography>=42.0
 Requires-Dist: nvidia-ml-py>=12.535.77
 Requires-Dist: redis>=5.0
 Requires-Dist: stripe>=9.0
+Requires-Dist: zstandard>=0.22
 Provides-Extra: attestation
 Requires-Dist: nv-attestation-sdk>=2.7.0; extra == "attestation"
 Requires-Dist: nv-local-gpu-verifier>=2.7.0; extra == "attestation"

{nvdc-0.2.3 → nvdc-0.2.4}/src/nvdc.egg-info/SOURCES.txt

@@ -34,6 +34,7 @@ tests/test_coordinator_security.py
 tests/test_house_node.py
 tests/test_mlx_custody.py
 tests/test_model_attestation.py
+tests/test_ollama_autoinstall.py
 tests/test_persistence.py
 tests/test_self_serve.py
 tests/test_self_update.py

{nvdc-0.2.3 → nvdc-0.2.4}/src/nvdc.egg-info/requires.txt

@@ -6,6 +6,7 @@ cryptography>=42.0
 nvidia-ml-py>=12.535.77
 redis>=5.0
 stripe>=9.0
+zstandard>=0.22
 
 [attestation]
 nv-attestation-sdk>=2.7.0

nvdc-0.2.4/tests/test_ollama_autoinstall.py

@@ -0,0 +1,83 @@
+"""The client installs its own Ollama runtime instead of bailing out."""
+
+import asyncio
+
+import pytest
+
+from nvdc import runtime as rt
+
+
+def test_arch_mapping(monkeypatch):
+    cases = {"x86_64": "amd64", "amd64": "amd64",
+             "aarch64": "arm64", "arm64": "arm64", "riscv64": ""}
+    for machine, expect in cases.items():
+        monkeypatch.setattr(rt.platform, "machine", lambda m=machine: m)
+        assert rt._ollama_arch() == expect
+
+
+@pytest.fixture()
+def runtime(monkeypatch, tmp_path):
+    monkeypatch.setenv("HOME", str(tmp_path))
+    return rt.NodeRuntime(name="t", mock=True)
+
+
+def test_ollama_bin_prefers_system_then_local(runtime, monkeypatch, tmp_path):
+    monkeypatch.setattr(rt.shutil, "which", lambda _: "/usr/bin/ollama")
+    assert runtime._ollama_bin() == "/usr/bin/ollama"
+
+    monkeypatch.setattr(rt.shutil, "which", lambda _: None)
+    monkeypatch.setattr(rt, "OLLAMA_INSTALL_DIR", tmp_path / "ollama")
+    assert runtime._ollama_bin() is None
+    binpath = tmp_path / "ollama" / "bin"
+    binpath.mkdir(parents=True)
+    (binpath / "ollama").write_text("#!/bin/sh\n")
+    assert runtime._ollama_bin() == str(binpath / "ollama")
+
+
+def test_ensure_server_installs_instead_of_bailing(runtime, monkeypatch):
+    """The reported bug: 'Ollama is not installed' was a dead end."""
+    class _Boom(Exception):
+        pass
+
+    async def fake_install():
+        raise _Boom("install path reached")
+
+    monkeypatch.setattr(rt.shutil, "which", lambda _: None)
+    monkeypatch.setattr(rt, "OLLAMA_INSTALL_DIR", rt.Path("/nonexistent-nvdc-test"))
+    monkeypatch.setattr(runtime, "_ollama_install", fake_install)
+    with pytest.raises(_Boom):
+        asyncio.run(runtime._ollama_ensure_server())
+
+
+def test_extract_runtime_handles_tar_zst(monkeypatch, tmp_path):
+    import io
+    import tarfile
+    import zstandard
+
+    # Build a tiny ollama-style .tar.zst (bin/ollama with exec bit).
+    buf = io.BytesIO()
+    with tarfile.open(fileobj=buf, mode="w") as t:
+        info = tarfile.TarInfo("bin/ollama")
+        payload = b"#!/bin/sh\necho ollama\n"
+        info.size = len(payload)
+        info.mode = 0o755
+        t.addfile(info, io.BytesIO(payload))
+    archive = tmp_path / ".download.tar.zst"
+    archive.write_bytes(zstandard.ZstdCompressor().compress(buf.getvalue()))
+
+    monkeypatch.setattr(rt, "OLLAMA_INSTALL_DIR", tmp_path / "ollama")
+    (tmp_path / "ollama").mkdir()
+    rt.NodeRuntime._extract_runtime(archive)
+    binary = tmp_path / "ollama" / "bin" / "ollama"
+    assert binary.exists()
+    assert binary.stat().st_mode & 0o111  # executable
+
+
+def test_install_refuses_unsupported_platform(runtime, monkeypatch):
+    monkeypatch.setattr(rt.sys, "platform", "darwin")
+    with pytest.raises(RuntimeError, match="brew install --cask ollama"):
+        asyncio.run(runtime._ollama_install())
+    monkeypatch.setattr(rt.sys, "platform", "linux")
+    monkeypatch.setattr(rt.platform, "machine", lambda: "riscv64")
+    with pytest.raises(RuntimeError, match="ollama.com"):
+        asyncio.run(runtime._ollama_install())