nerdit 0.2.0__py3-none-any.whl

nerdit/__init__.py

@@ -0,0 +1,3 @@
+"""Nerdit — Le moteur de l'IA locale."""
+
+__version__ = "0.2.0"

nerdit/__main__.py

@@ -0,0 +1,3 @@
+from nerdit.cli.app import main
+
+main()

nerdit/cli/app.py

@@ -0,0 +1,61 @@
+"""Nerdit CLI application."""
+
+import typer
+
+import nerdit
+
+app = typer.Typer(
+    name="nerdit",
+    help="The local AI engine — HPC orchestrator for local GPUs",
+    no_args_is_help=True,
+)
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"nerdit {nerdit.__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main_callback(
+    version: bool = typer.Option(
+        False,
+        "--version",
+        "-v",
+        help="Show version",
+        callback=version_callback,
+        is_eager=True,
+    ),
+) -> None:
+    pass
+
+
+# Import and register commands (deferred to avoid circular imports)
+def _register_commands() -> None:
+    from nerdit.cli.commands.check_deps import check_deps  # noqa: F811
+    from nerdit.cli.commands.cleanup import cleanup  # noqa: F811
+    from nerdit.cli.commands.connect import connect  # noqa: F811
+    from nerdit.cli.commands.init import init  # noqa: F811
+    from nerdit.cli.commands.logs import logs  # noqa: F811
+    from nerdit.cli.commands.run import run  # noqa: F811
+    from nerdit.cli.commands.status import status  # noqa: F811
+    from nerdit.cli.commands.stop import stop  # noqa: F811
+    from nerdit.cli.commands.token import token  # noqa: F811
+
+    app.command(name="check-deps")(check_deps)
+    app.command()(init)
+    app.command()(run)
+    app.command()(status)
+    app.command()(logs)
+    app.command()(stop)
+    app.command()(cleanup)
+    app.command()(connect)
+    app.command()(token)
+
+
+_register_commands()
+
+
+def main() -> None:
+    app()

nerdit/cli/client.py

@@ -0,0 +1,208 @@
+"""HTTP client for communicating with nerditd."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+
+import httpx
+
+from nerdit.config.defaults import DEFAULT_HOST, DEFAULT_PORT
+
+
+class NerditClient:
+    """Async HTTP client wrapping the nerditd REST API."""
+
+    def __init__(
+        self,
+        host: str = DEFAULT_HOST,
+        port: int = DEFAULT_PORT,
+        token: str | None = None,
+    ) -> None:
+        self._base_url = f"http://{host}:{port}"
+        self._headers: dict[str, str] = {}
+        if token:
+            self._headers["Authorization"] = f"Bearer {token}"
+
+    def _client(self, **kwargs) -> httpx.AsyncClient:
+        """Create an httpx.AsyncClient with auth headers."""
+        return httpx.AsyncClient(headers=self._headers, **kwargs)
+
+    async def health(self) -> dict:
+        """Call ``GET /health`` and return the parsed JSON response."""
+        async with self._client() as client:
+            resp = await client.get(f"{self._base_url}/health", timeout=5.0)
+            resp.raise_for_status()
+            return resp.json()
+
+    async def list_gpus(self) -> list[dict]:
+        """Fetch all GPUs from the daemon."""
+        async with self._client() as client:
+            resp = await client.get(f"{self._base_url}/gpus", timeout=5.0)
+            resp.raise_for_status()
+            return resp.json()
+
+    async def create_job(
+        self,
+        script_path: str,
+        *,
+        name: str | None = None,
+        gpu_count: int = 1,
+        priority: int = 5,
+        image: str | None = None,
+        max_retries: int = 3,
+        volumes: dict[str, str] | None = None,
+        tags: list[str] | None = None,
+        preemptible: bool = False,
+        max_runtime: str | None = None,
+        time_window: str | None = None,
+    ) -> dict:
+        """Submit a new job via ``POST /jobs``."""
+        payload: dict = {
+            "script_path": script_path,
+            "gpu_count": gpu_count,
+            "priority": priority,
+            "max_retries": max_retries,
+        }
+        if name:
+            payload["name"] = name
+        if image:
+            payload["image"] = image
+        if volumes:
+            payload["volumes"] = volumes
+        if tags:
+            payload["tags"] = tags
+        if preemptible:
+            payload["preemptible"] = True
+        if max_runtime:
+            payload["max_runtime"] = max_runtime
+        if time_window:
+            payload["time_window"] = time_window
+
+        async with self._client() as client:
+            resp = await client.post(f"{self._base_url}/jobs", json=payload, timeout=10.0)
+            resp.raise_for_status()
+            return resp.json()
+
+    async def upload_job(
+        self,
+        zip_bytes: bytes,
+        script_name: str,
+        *,
+        name: str | None = None,
+        gpu_count: int = 1,
+        priority: int = 5,
+        image: str | None = None,
+        max_retries: int = 3,
+        volumes: dict[str, str] | None = None,
+        tags: list[str] | None = None,
+        preemptible: bool = False,
+        max_runtime: str | None = None,
+        time_window: str | None = None,
+    ) -> dict:
+        """Upload a ZIP archive and create a job on the remote daemon."""
+        import json
+
+        files = {"archive": ("scripts.zip", zip_bytes, "application/zip")}
+        data: dict[str, str] = {
+            "script_name": script_name,
+            "gpu_count": str(gpu_count),
+            "priority": str(priority),
+            "max_retries": str(max_retries),
+        }
+        if name:
+            data["name"] = name
+        if image:
+            data["image"] = image
+        if volumes:
+            data["volumes"] = json.dumps(volumes)
+        if tags:
+            data["tags"] = json.dumps(tags)
+        if preemptible:
+            data["preemptible"] = "true"
+        if max_runtime:
+            data["max_runtime"] = max_runtime
+        if time_window:
+            data["time_window"] = time_window
+
+        async with self._client() as client:
+            resp = await client.post(
+                f"{self._base_url}/jobs/upload",
+                files=files,
+                data=data,
+                timeout=120.0,
+            )
+            resp.raise_for_status()
+            return resp.json()
+
+    async def list_jobs(self, status: str | None = None) -> list[dict]:
+        """List jobs, optionally filtered by status."""
+        params = {}
+        if status:
+            params["status"] = status
+
+        async with self._client() as client:
+            resp = await client.get(f"{self._base_url}/jobs", params=params, timeout=5.0)
+            resp.raise_for_status()
+            return resp.json()
+
+    async def get_job(self, job_id: str) -> dict:
+        """Fetch a single job by ID."""
+        async with self._client() as client:
+            resp = await client.get(f"{self._base_url}/jobs/{job_id}", timeout=5.0)
+            resp.raise_for_status()
+            return resp.json()
+
+    async def stop_job(self, job_id: str) -> dict:
+        """Request the daemon to stop a job."""
+        async with self._client() as client:
+            resp = await client.post(f"{self._base_url}/jobs/{job_id}/stop", timeout=10.0)
+            resp.raise_for_status()
+            return resp.json()
+
+    async def get_logs(self, job_id: str, since_id: int = 0) -> list[dict]:
+        """Fetch log entries for a job since a given ID."""
+        async with self._client() as client:
+            resp = await client.get(
+                f"{self._base_url}/jobs/{job_id}/logs",
+                params={"since_id": since_id},
+                timeout=5.0,
+            )
+            resp.raise_for_status()
+            return resp.json()
+
+    async def stream_logs(self, job_id: str) -> AsyncIterator[dict]:
+        """Consume SSE log stream from the daemon. Yields parsed event dicts."""
+        import httpx_sse
+
+        timeout = httpx.Timeout(5.0, read=None)  # no read timeout for SSE
+        async with self._client(timeout=timeout) as client:
+            async with httpx_sse.aconnect_sse(
+                client, "GET", f"{self._base_url}/jobs/{job_id}/logs/stream"
+            ) as sse:
+                async for event in sse.aiter_sse():
+                    import json
+
+                    if event.event == "done":
+                        yield {"event": "done", "data": json.loads(event.data)}
+                        return
+                    if event.event == "log":
+                        yield {"event": "log", "data": json.loads(event.data)}
+
+    async def cleanup(self) -> dict:
+        """Request the daemon to stop all active jobs."""
+        async with self._client() as client:
+            resp = await client.post(f"{self._base_url}/cleanup", timeout=10.0)
+            resp.raise_for_status()
+            return resp.json()
+
+
+def get_configured_client() -> NerditClient:
+    """Create a NerditClient from ~/.nerdit/config.toml settings.
+
+    If [client].remote_host is set, connects to the remote daemon with token.
+    Otherwise falls back to localhost (v0.1 compat).
+    """
+    from nerdit.config.settings import get_client_config
+
+    host, port, token = get_client_config()
+    return NerditClient(host=host, port=port, token=token)

nerdit/cli/commands/check_deps.py

@@ -0,0 +1,363 @@
+"""nerdit check-deps — Check and optionally install system dependencies."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import typer
+from rich.table import Table
+
+from nerdit.cli.display import console
+
+# ---------------------------------------------------------------------------
+# Check functions — each returns (ok, detail_string)
+# ---------------------------------------------------------------------------
+
+_LIB_DIRS = ["/usr/lib/x86_64-linux-gnu", "/usr/lib64", "/usr/lib"]
+
+
+def _check_python() -> tuple[bool, str]:
+    """Check Python >= 3.11."""
+    major, minor, micro = sys.version_info[0], sys.version_info[1], sys.version_info[2]
+    ver = f"{major}.{minor}.{micro}"
+    if major >= 3 and minor >= 11:
+        return True, ver
+    return False, f"{ver} (need >=3.11)"
+
+
+def _check_nvidia_driver() -> tuple[bool, str]:
+    """Check NVIDIA driver via nvidia-smi."""
+    if shutil.which("nvidia-smi") is None:
+        return False, "nvidia-smi not found"
+    try:
+        result = subprocess.run(
+            ["nvidia-smi", "--query-gpu=driver_version", "--format=csv,noheader"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        if result.returncode != 0:
+            return False, "nvidia-smi failed"
+        driver_ver = result.stdout.strip().splitlines()[0]
+        major = int(driver_ver.split(".")[0])
+        if major >= 535:
+            return True, driver_ver
+        return False, f"{driver_ver} (need >=535)"
+    except (subprocess.TimeoutExpired, FileNotFoundError, ValueError, IndexError):
+        return False, "nvidia-smi error"
+
+
+def _check_nvidia_lib() -> tuple[bool, str]:
+    """Check libnvidia-ml.so.1 on the host."""
+    for d in _LIB_DIRS:
+        p = Path(d) / "libnvidia-ml.so.1"
+        if p.exists():
+            return True, str(p)
+    return False, "not found"
+
+
+def _check_docker() -> tuple[bool, str]:
+    """Check Docker Engine is running."""
+    if shutil.which("docker") is None:
+        return False, "docker not found"
+    try:
+        result = subprocess.run(
+            ["docker", "info"],
+            capture_output=True,
+            timeout=10,
+        )
+        if result.returncode != 0:
+            return False, "not running or no permission"
+        ver_result = subprocess.run(
+            ["docker", "version", "--format", "{{.Server.Version}}"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        ver = ver_result.stdout.strip() if ver_result.returncode == 0 else "unknown"
+        return True, ver
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        return False, "error"
+
+
+def _check_nvidia_toolkit() -> tuple[bool, str]:
+    """Check NVIDIA Container Toolkit in Docker runtimes."""
+    # If Docker CLI itself is not available, skip this check.
+    if shutil.which("docker") is None:
+        return False, "skipped (Docker not installed)"
+    try:
+        result = subprocess.run(
+            ["docker", "info", "--format", "{{json .Runtimes}}"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        if result.returncode != 0:
+            detail = "skipped (docker info failed; is Docker running / do you have permission?)"
+            if result.stderr:
+                stderr = result.stderr.strip()
+                if stderr:
+                    detail = f"{detail}: {stderr}"
+            return False, detail
+        if "nvidia" in result.stdout:
+            return True, "registered"
+        return False, "not found in Docker runtimes"
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        return False, "skipped (Docker not available)"
+
+
+def _check_runtime_image() -> tuple[bool, str]:
+    """Check if nerdit-runtime:0.1 Docker image exists."""
+    try:
+        result = subprocess.run(
+            ["docker", "image", "inspect", "nerdit-runtime:0.1"],
+            capture_output=True,
+            timeout=10,
+        )
+        if result.returncode == 0:
+            return True, "available"
+        return False, "image not found"
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        return False, "skipped (Docker not available)"
+
+
+# ---------------------------------------------------------------------------
+# Install helpers
+# ---------------------------------------------------------------------------
+
+
+def _run_install(description: str, cmd: list[str], *, shell: bool = False) -> bool:
+    """Run an install command with user-visible output. Returns success."""
+    console.print(f"  [dim]Running: {' '.join(cmd)}[/dim]")
+    try:
+        if shell:
+            result = subprocess.run(
+                " ".join(cmd),
+                shell=True,
+                timeout=300,  # noqa: S602
+            )
+        else:
+            result = subprocess.run(cmd, timeout=300)
+        return result.returncode == 0
+    except (subprocess.TimeoutExpired, FileNotFoundError) as exc:
+        console.print(f"  [red]Failed: {exc}[/red]")
+        return False
+
+
+def _install_python() -> bool:
+    return _run_install(
+        "Python 3.11",
+        ["sudo", "apt-get", "install", "-y", "python3.11"],
+    )
+
+
+def _install_nvidia_driver() -> bool:
+    ok = _run_install(
+        "NVIDIA Driver",
+        ["sudo", "apt-get", "install", "-y", "nvidia-driver-535"],
+    )
+    if ok:
+        console.print("  [yellow]A reboot may be required.[/yellow]")
+    return ok
+
+
+def _install_docker() -> bool:
+    ok = _run_install(
+        "Docker Engine",
+        ["sh", "-c", "curl -fsSL https://get.docker.com | sudo sh"],
+    )
+    if ok:
+        subprocess.run(
+            ["sudo", "usermod", "-aG", "docker", str(Path.home().name)],
+            timeout=10,
+        )
+        console.print("  [yellow]Log out and back in for group changes to take effect.[/yellow]")
+    return ok
+
+
+def _install_nvidia_toolkit() -> bool:
+    cmds = [
+        "curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey"
+        " | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg",
+        "curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/"
+        "nvidia-container-toolkit.list"
+        " | sed 's#deb https://#deb [signed-by=/usr/share/keyrings/"
+        "nvidia-container-toolkit-keyring.gpg] https://#g'"
+        " | sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list"
+        " > /dev/null",
+        "sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit",
+        "sudo nvidia-ctk runtime configure --runtime=docker",
+        "sudo systemctl restart docker",
+    ]
+    for cmd in cmds:
+        result = subprocess.run(cmd, shell=True, timeout=120)  # noqa: S602
+        if result.returncode != 0:
+            console.print(f"  [red]Step failed: {cmd}[/red]")
+            return False
+    return True
+
+
+def _find_dockerfile() -> Path | None:
+    candidates = [
+        Path("docker/Dockerfile"),
+        Path.cwd() / "docker" / "Dockerfile",
+    ]
+    pkg_root = Path(__file__).resolve().parents[4]
+    candidates.append(pkg_root / "docker" / "Dockerfile")
+    for path in candidates:
+        resolved = path.resolve()
+        if resolved.is_file():
+            return resolved
+    return None
+
+
+def _install_runtime_image() -> bool:
+    dockerfile = _find_dockerfile()
+    if dockerfile is None:
+        console.print("  [red]Dockerfile not found. Cannot build image.[/red]")
+        return False
+    return _run_install(
+        "nerdit-runtime:0.1",
+        ["docker", "build", "-t", "nerdit-runtime:0.1", str(dockerfile.parent)],
+    )
+
+
+# ---------------------------------------------------------------------------
+# Dependency registry
+# ---------------------------------------------------------------------------
+
+_DEPS: list[
+    tuple[str, callable, callable | None, str]  # type: ignore[type-arg]
+] = [
+    (
+        "Python >=3.11",
+        _check_python,
+        _install_python,
+        "sudo apt install python3.11",
+    ),
+    (
+        "NVIDIA Driver (>=535)",
+        _check_nvidia_driver,
+        _install_nvidia_driver,
+        "sudo apt install nvidia-driver-535",
+    ),
+    (
+        "libnvidia-ml.so.1",
+        _check_nvidia_lib,
+        None,  # installed with driver
+        "Provided by NVIDIA driver — try: sudo ldconfig",
+    ),
+    (
+        "Docker Engine",
+        _check_docker,
+        _install_docker,
+        "curl -fsSL https://get.docker.com | sudo sh",
+    ),
+    (
+        "NVIDIA Container Toolkit",
+        _check_nvidia_toolkit,
+        _install_nvidia_toolkit,
+        "sudo apt install nvidia-container-toolkit",
+    ),
+    (
+        "nerdit-runtime:0.1",
+        _check_runtime_image,
+        _install_runtime_image,
+        "docker build -t nerdit-runtime:0.1 docker/",
+    ),
+]
+
+
+# ---------------------------------------------------------------------------
+# Command
+# ---------------------------------------------------------------------------
+
+
+def check_deps(
+    install: bool = typer.Option(
+        False,
+        "--install",
+        "-i",
+        help="Offer to install missing dependencies (with confirmation)",
+    ),
+) -> None:
+    """Check system dependencies and optionally install missing ones."""
+    results: list[tuple[str, bool, str]] = []
+    for name, check_fn, _, _ in _DEPS:
+        ok, detail = check_fn()
+        results.append((name, ok, detail))
+
+    # Display table
+    table = Table(title="Nerdit — Dependency Check")
+    table.add_column("Dependency", style="bold")
+    table.add_column("Status", justify="center")
+    table.add_column("Detail")
+
+    for name, ok, detail in results:
+        status = "[green]✓[/green]" if ok else "[red]✗[/red]"
+        detail_style = "" if ok else "[yellow]"
+        detail_end = "" if ok else "[/yellow]"
+        table.add_row(name, status, f"{detail_style}{detail}{detail_end}")
+
+    console.print()
+    console.print(table)
+    console.print()
+
+    missing = [(i, name) for i, (name, ok, _) in enumerate(results) if not ok]
+    if not missing:
+        console.print("[bold green]All dependencies are installed.[/bold green]")
+        return
+
+    console.print(
+        f"[yellow]{len(missing)} missing dependenc{'y' if len(missing) == 1 else 'ies'}.[/yellow]"
+    )
+
+    if not install:
+        console.print("[dim]Run with --install to interactively install missing deps.[/dim]")
+        console.print()
+        for idx, name in missing:
+            _, _, _, hint = _DEPS[idx]
+            console.print(f"  [dim]{name}:[/dim] {hint}")
+        raise typer.Exit(1)
+
+    # Interactive install flow
+    console.print()
+    any_installed = False
+    for idx, name in missing:
+        _, _, install_fn, hint = _DEPS[idx]
+        if install_fn is None:
+            console.print(f"[dim]{name}: no automatic installer — {hint}[/dim]")
+            continue
+        if typer.confirm(f"Install {name}?", default=False):
+            success = install_fn()
+            if success:
+                console.print(f"  [green]✓ {name} installed[/green]")
+                any_installed = True
+            else:
+                console.print(f"  [red]✗ {name} installation failed[/red]")
+        else:
+            console.print(f"  [dim]Skipped {name}[/dim]")
+
+    # Re-check if anything was installed
+    if any_installed:
+        console.print("\n[bold]Re-checking...[/bold]\n")
+        still_missing = 0
+        for name, check_fn, _, _ in _DEPS:
+            ok, detail = check_fn()
+            status = "[green]✓[/green]" if ok else "[red]✗[/red]"
+            console.print(f"  {status} {name}: {detail}")
+            if not ok:
+                still_missing += 1
+        if still_missing == 0:
+            console.print("\n[bold green]All dependencies are now installed.[/bold green]")
+        else:
+            console.print(
+                f"\n[yellow]{still_missing} dependenc{'y' if still_missing == 1 else 'ies'}"
+                " still missing.[/yellow]"
+            )
+            raise typer.Exit(1)
+    else:
+        raise typer.Exit(1)

nerdit/cli/commands/cleanup.py

@@ -0,0 +1,30 @@
+"""nerdit cleanup — Force-stop all running jobs."""
+
+from __future__ import annotations
+
+import asyncio
+
+import typer
+
+from nerdit.cli.display import console
+
+
+def cleanup() -> None:
+    """Force-stop all jobs and release resources."""
+    asyncio.run(_cleanup_async())
+
+
+async def _cleanup_async() -> None:
+    from nerdit.cli.client import get_configured_client
+
+    client = get_configured_client()
+    try:
+        result = await client.cleanup()
+        count = result.get("stopped", 0)
+        if count > 0:
+            console.print(f"[green]{count} job(s) stopped[/green]")
+        else:
+            console.print("[dim]No running jobs to stop[/dim]")
+    except Exception as exc:
+        console.print(f"[red]Error:[/red] {exc}")
+        raise typer.Exit(1)