nerdit 0.2.0__py3-none-any.whl

nerdit/cli/commands/connect.py

@@ -0,0 +1,65 @@
+"""nerdit connect — Connect CLI to a remote nerditd daemon."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+import typer
+
+from nerdit.cli.display import console
+from nerdit.config.defaults import DEFAULT_PORT
+
+
+def connect(
+    host: str = typer.Argument(..., help="Server IP address or hostname"),
+    port: int = typer.Option(DEFAULT_PORT, "--port", "-p", help="Daemon port"),
+    token: str = typer.Option(..., "--token", "-t", help="Authentication token"),
+) -> None:
+    """Connect the CLI to a remote daemon."""
+    asyncio.run(_connect_async(host, port, token))
+
+
+async def _connect_async(host: str, port: int, token: str) -> None:
+    config_path = Path("~/.nerdit/config.toml").expanduser()
+
+    # Read existing config or start fresh
+    if config_path.exists():
+        import tomllib
+
+        with open(config_path, "rb") as f:
+            data = tomllib.load(f)
+    else:
+        data = {}
+
+    # Update [client] section
+    data["client"] = {
+        "remote_host": host,
+        "remote_port": port,
+        "auth_token": token,
+    }
+
+    # Write back
+    import tomli_w
+
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(config_path, "wb") as f:
+        tomli_w.dump(data, f)
+
+    console.print("[green]Client configuration saved[/green]")
+    console.print(f"  Server: {host}:{port}")
+
+    # Test connection
+    from nerdit.cli.client import NerditClient
+
+    client = NerditClient(host=host, port=port, token=token)
+    try:
+        health = await client.health()
+        console.print(
+            f"[green]Connection successful[/green] — version {health['version']}, "
+            f"{health['gpu_count']} GPU(s)"
+        )
+    except Exception as exc:
+        console.print(f"[red]Connection failed:[/red] {exc}")
+        console.print("[dim]Check that the daemon is running and the token is correct.[/dim]")
+        raise typer.Exit(1)

nerdit/cli/commands/init.py

@@ -0,0 +1,57 @@
+"""nerdit init — Generate project configuration."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from nerdit.cli.display import console
+
+NERDIT_TOML_TEMPLATE = """\
+# nerdit.toml — Project configuration for Nerdit
+# Place this file at the root of your project.
+# `nerdit run` with no arguments will use these defaults.
+
+[run]
+# script = "train.py"
+# gpus = 1
+# priority = 5
+# image = "nerdit-runtime:0.1"
+# tags = ["render", "nightly"]
+
+[scheduling]
+# time_window = "22:00-06:00"    # job starts only within this window
+# max_runtime = "12h"            # auto-kill after this duration
+# preemptible = false            # mark job as interruptible (future use)
+
+[data]
+# Data mounts: name = "host_path:container_path"
+# dataset = "/data/imagenet:/data"
+# output = "/results/{{job_id}}:/output"
+"""
+
+
+def init(
+    project: bool = typer.Option(
+        False, "--project", help="Generate a nerdit.toml in the current directory"
+    ),
+) -> None:
+    """Initialize a nerdit.toml project configuration."""
+    if project:
+        _generate_project_config()
+    else:
+        console.print(
+            "Use [cyan]nerdit init --project[/cyan] to generate a nerdit.toml template.\n"
+            "To start a daemon, install the full nerdit engine on your GPU server."
+        )
+
+
+def _generate_project_config() -> None:
+    """Write a nerdit.toml template to cwd."""
+    target = Path.cwd() / "nerdit.toml"
+    if target.exists():
+        console.print(f"[yellow]nerdit.toml already exists:[/yellow] {target}")
+        return
+    target.write_text(NERDIT_TOML_TEMPLATE)
+    console.print(f"[green]nerdit.toml created:[/green] {target}")

nerdit/cli/commands/logs.py

@@ -0,0 +1,69 @@
+"""nerdit logs — Stream job logs."""
+
+from __future__ import annotations
+
+import asyncio
+
+import typer
+
+from nerdit.cli.display import console, display_logs
+
+
+def logs(
+    job_id: str = typer.Argument(..., help="Job ID"),
+    follow: bool = typer.Option(False, "--follow", "-f", help="Follow logs continuously"),
+) -> None:
+    """Display logs for a job."""
+    asyncio.run(_logs_async(job_id, follow))
+
+
+async def _logs_async(job_id: str, follow: bool) -> None:
+    from nerdit.cli.client import get_configured_client
+
+    client = get_configured_client()
+
+    try:
+        if not follow:
+            entries = await client.get_logs(job_id, since_id=0)
+            if entries:
+                display_logs(entries)
+            else:
+                console.print("[dim]No logs available[/dim]")
+            return
+
+        # Follow mode: use SSE stream
+        try:
+            async for event in client.stream_logs(job_id):
+                if event["event"] == "log":
+                    display_logs([event["data"]])
+                elif event["event"] == "done":
+                    status = event["data"]["status"]
+                    console.print(f"\n[bold]Job finished: {status}[/bold]")
+                    break
+        except ImportError:
+            # Fallback to polling if httpx-sse not installed
+            await _follow_polling(client, job_id)
+
+    except Exception as exc:
+        console.print(f"[red]Error:[/red] {exc}")
+        raise typer.Exit(1)
+
+
+async def _follow_polling(client, job_id: str) -> None:
+    """Fallback follow mode using polling (v0.1 behavior)."""
+    since_id = 0
+    while True:
+        entries = await client.get_logs(job_id, since_id=since_id)
+        if entries:
+            display_logs(entries)
+            since_id = entries[-1]["id"]
+
+        job = await client.get_job(job_id)
+        if job["status"] in ("completed", "failed", "cancelled"):
+            entries = await client.get_logs(job_id, since_id=since_id)
+            if entries:
+                display_logs(entries)
+            console.print(f"\n[bold]Job finished: {job['status']}[/bold]")
+            break
+
+        await asyncio.sleep(1.0)

nerdit/cli/commands/run.py

@@ -0,0 +1,157 @@
+"""nerdit run — Submit a job to the scheduler."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from nerdit.cli.display import console, display_job_submitted
+
+
+def run(
+    script: Optional[str] = typer.Argument(None, help="Python script to run"),
+    gpus: Optional[int] = typer.Option(None, "--gpus", "-g", help="Number of GPUs required"),
+    priority: Optional[int] = typer.Option(None, "--priority", "-p", help="Priority (1-10)"),
+    image: Optional[str] = typer.Option(None, "--image", "-i", help="Docker image to use"),
+    name: Optional[str] = typer.Option(None, "--name", "-n", help="Job name"),
+    data: Optional[list[str]] = typer.Option(
+        None, "--data", "-d", help="Data mount host:container"
+    ),
+    tag: Optional[list[str]] = typer.Option(None, "--tag", "-t", help="Job tag (repeatable)"),
+) -> None:
+    """Submit a job to the scheduler."""
+    asyncio.run(_run_async(script, gpus, priority, image, name, data, tag))
+
+
+async def _run_async(
+    script: str | None,
+    gpus: int | None,
+    priority: int | None,
+    image: str | None,
+    name: str | None,
+    data: list[str] | None,
+    tag: list[str] | None,
+) -> None:
+    """Build effective job parameters by merging CLI flags over nerdit.toml defaults."""
+    from nerdit.cli.client import get_configured_client
+    from nerdit.config.project import (
+        load_project_config,
+        parse_data_flags,
+        parse_data_mounts,
+    )
+    from nerdit.config.settings import load_settings
+
+    # Load nerdit.toml defaults
+    project = load_project_config()
+    if project:
+        console.print("[dim]nerdit.toml found[/dim]")
+
+    # Merge: CLI flags override nerdit.toml [run] defaults
+    run_cfg = project.run if project and project.run else None
+    sched_cfg = project.scheduling if project and project.scheduling else None
+
+    effective_script = script or (run_cfg.script if run_cfg else None)
+    if not effective_script:
+        console.print("[red]No script specified (argument or nerdit.toml [run].script)[/red]")
+        raise typer.Exit(1)
+
+    effective_gpus = gpus if gpus is not None else (run_cfg.gpus if run_cfg else None) or 1
+    effective_priority = (
+        priority if priority is not None else (run_cfg.priority if run_cfg else None) or 5
+    )
+    effective_image = image or (run_cfg.image if run_cfg else None)
+
+    # Build tags: toml [run].tags + --tag CLI flags
+    effective_tags: list[str] = []
+    if run_cfg and run_cfg.tags:
+        effective_tags.extend(run_cfg.tags)
+    if tag:
+        for t in tag:
+            if t not in effective_tags:
+                effective_tags.append(t)
+
+    # Scheduling fields from toml [scheduling]
+    effective_time_window = sched_cfg.time_window if sched_cfg else None
+    effective_max_runtime = sched_cfg.max_runtime if sched_cfg else None
+    effective_preemptible = sched_cfg.preemptible if sched_cfg else False
+
+    # Build volumes: start with toml [data] mounts, overlay --data flags
+    volumes: dict[str, str] = {}
+    if project and project.data:
+        volumes.update(parse_data_mounts(project.data))
+    if data:
+        volumes.update(parse_data_flags(data))
+
+    # Resolve script to absolute path
+    script_path = str(Path(effective_script).resolve())
+
+    if not Path(script_path).exists():
+        console.print(f"[red]File not found:[/red] {script_path}")
+        raise typer.Exit(1)
+
+    settings = load_settings()
+    client = get_configured_client()
+
+    # Warn about remote mount paths
+    if settings.client.remote_host and volumes:
+        console.print("[yellow]Remote mode: mount paths reference the remote server.[/yellow]")
+
+    try:
+        if settings.client.remote_host:
+            # Remote mode: create ZIP archive and upload
+            from nerdit.cli.upload import (
+                check_upload_size,
+                create_script_zip,
+                warn_large_upload,
+            )
+
+            console.print("[dim]Remote mode — creating archive...[/dim]")
+            zip_bytes, script_name = create_script_zip(script_path)
+
+            check_upload_size(zip_bytes)
+
+            warning = warn_large_upload(zip_bytes)
+            if warning:
+                console.print(f"[yellow]{warning}[/yellow]")
+
+            size_mb = len(zip_bytes) / (1024 * 1024)
+            console.print(f"[dim]Uploading archive ({size_mb:.1f} MB)...[/dim]")
+
+            job = await client.upload_job(
+                zip_bytes,
+                script_name,
+                name=name,
+                gpu_count=effective_gpus,
+                priority=effective_priority,
+                image=effective_image,
+                volumes=volumes or None,
+                tags=effective_tags or None,
+                preemptible=effective_preemptible,
+                max_runtime=effective_max_runtime,
+                time_window=effective_time_window,
+            )
+        else:
+            # Local mode: existing path-based job creation
+            job = await client.create_job(
+                script_path=script_path,
+                name=name,
+                gpu_count=effective_gpus,
+                priority=effective_priority,
+                image=effective_image,
+                volumes=volumes or None,
+                tags=effective_tags or None,
+                preemptible=effective_preemptible,
+                max_runtime=effective_max_runtime,
+                time_window=effective_time_window,
+            )
+        display_job_submitted(job)
+    except ValueError as exc:
+        console.print(f"[red]Error:[/red] {exc}")
+        raise typer.Exit(1)
+    except Exception as exc:
+        console.print(f"[red]Error:[/red] {exc}")
+        console.print("[dim]Is the daemon running? (nerdit init)[/dim]")
+        raise typer.Exit(1)

nerdit/cli/commands/status.py

@@ -0,0 +1,39 @@
+"""nerdit status — Display GPU and job status."""
+
+from __future__ import annotations
+
+import asyncio
+
+import typer
+
+from nerdit.cli.display import console, display_gpu_table, display_job_table
+
+
+def status() -> None:
+    """Display GPU and job status."""
+    asyncio.run(_status_async())
+
+
+async def _status_async() -> None:
+    from nerdit.cli.client import get_configured_client
+
+    client = get_configured_client()
+    try:
+        gpus = await client.list_gpus()
+        jobs = await client.list_jobs()
+
+        if gpus:
+            display_gpu_table(gpus)
+        else:
+            console.print(
+                "[yellow]No GPU detected. Jobs requiring GPUs will stay pending.[/yellow]"
+            )
+        console.print()
+        if jobs:
+            display_job_table(jobs)
+        else:
+            console.print("[dim]No jobs[/dim]")
+    except Exception as exc:
+        console.print(f"[red]Error:[/red] {exc}")
+        console.print("[dim]Is the daemon running? (nerdit init)[/dim]")
+        raise typer.Exit(1)

nerdit/cli/commands/stop.py

@@ -0,0 +1,31 @@
+"""nerdit stop — Stop a running job."""
+
+from __future__ import annotations
+
+import asyncio
+
+import typer
+
+from nerdit.cli.display import console
+
+
+def stop(
+    job_id: str = typer.Argument(..., help="Job ID to stop"),
+) -> None:
+    """Stop a running job."""
+    asyncio.run(_stop_async(job_id))
+
+
+async def _stop_async(job_id: str) -> None:
+    from nerdit.cli.client import get_configured_client
+
+    client = get_configured_client()
+    try:
+        result = await client.stop_job(job_id)
+        if result.get("stopped"):
+            console.print(f"[green]Job {job_id} stopped[/green]")
+        else:
+            console.print(f"[yellow]Job {job_id} could not be stopped[/yellow]")
+    except Exception as exc:
+        console.print(f"[red]Error:[/red] {exc}")
+        raise typer.Exit(1)

nerdit/cli/commands/token.py

@@ -0,0 +1,20 @@
+"""nerdit token — Display the current authentication token."""
+
+from __future__ import annotations
+
+from nerdit.cli.display import console
+from nerdit.config.settings import load_settings
+
+
+def token() -> None:
+    """Display the current authentication token."""
+    settings = load_settings()
+
+    auth_token = settings.daemon.auth_token
+    if settings.client.remote_host:
+        auth_token = settings.client.auth_token
+
+    if auth_token:
+        console.print(auth_token)
+    else:
+        console.print("[yellow]No authentication token configured.[/yellow]")

nerdit/cli/display.py

@@ -0,0 +1,101 @@
+"""Rich display formatters for CLI output."""
+
+from __future__ import annotations
+
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+
+def display_gpu_table(gpus: list[dict]) -> None:
+    """Display a Rich table of GPU information."""
+    table = Table(title="GPUs")
+    table.add_column("ID", style="dim", max_width=16)
+    table.add_column("Name", style="cyan")
+    table.add_column("Memory", justify="right")
+    table.add_column("Status", style="bold")
+    table.add_column("Util %", justify="right")
+    table.add_column("Temp °C", justify="right")
+
+    for gpu in gpus:
+        status_style = {
+            "idle": "green",
+            "busy": "yellow",
+            "error": "red",
+            "offline": "dim",
+        }.get(gpu["status"], "")
+
+        raw_util = gpu.get("utilization_percent")
+        util = str(raw_util) if raw_util is not None else "-"
+        raw_temp = gpu.get("temperature_c")
+        temp = str(raw_temp) if raw_temp is not None else "-"
+
+        table.add_row(
+            gpu["id"][:12] + "...",
+            gpu["name"],
+            f"{gpu['memory_mb']} MB",
+            f"[{status_style}]{gpu['status']}[/{status_style}]",
+            util,
+            temp,
+        )
+
+    console.print(table)
+
+
+def display_job_table(jobs: list[dict]) -> None:
+    """Display a Rich table of jobs."""
+    table = Table(title="Jobs")
+    table.add_column("ID", style="dim")
+    table.add_column("Name")
+    table.add_column("Status", style="bold")
+    table.add_column("GPUs", justify="right")
+    table.add_column("Priority", justify="right")
+    table.add_column("Created")
+
+    for job in jobs:
+        status_style = {
+            "pending": "yellow",
+            "scheduled": "blue",
+            "running": "green",
+            "completed": "green bold",
+            "failed": "red",
+            "cancelled": "dim",
+            "retrying": "magenta",
+        }.get(job["status"], "")
+
+        name = job.get("name") or job.get("script_path", "").split("/")[-1]
+
+        table.add_row(
+            job["id"][:12],
+            name,
+            f"[{status_style}]{job['status']}[/{status_style}]",
+            str(job["gpu_count"]),
+            str(job["priority"]),
+            job.get("created_at", "")[:19],
+        )
+
+    console.print(table)
+
+
+def display_job_submitted(job: dict) -> None:
+    """Display a submitted job confirmation."""
+    console.print(f"[green]Job submitted:[/green] {job['id']}")
+    console.print(f"  Script: {job['script_path']}")
+    console.print(f"  GPUs:   {job['gpu_count']}")
+    console.print(f"  Status: {job['status']}")
+
+
+def display_logs(logs: list[dict]) -> None:
+    """Display log entries."""
+    for log in logs:
+        stream = log.get("stream", "stdout")
+        message = log.get("message", "")
+        ts = log.get("timestamp", "")[:19]
+
+        if stream == "stderr":
+            console.print(f"[dim]{ts}[/dim] [red]{message}[/red]")
+        elif stream == "system":
+            console.print(f"[dim]{ts}[/dim] [blue]{message}[/blue]")
+        else:
+            console.print(f"[dim]{ts}[/dim] {message}")

nerdit/cli/upload.py

@@ -0,0 +1,70 @@
+"""ZIP creation and upload helpers for remote job submission."""
+
+from __future__ import annotations
+
+import fnmatch
+import io
+import zipfile
+from pathlib import Path
+
+from nerdit.config.defaults import (
+    DEFAULT_MAX_UPLOAD_BYTES,
+    UPLOAD_WARNING_BYTES,
+    ZIP_EXCLUDE_PATTERNS,
+)
+
+
+def should_exclude(rel_path: str) -> bool:
+    """Check if a relative path matches any exclusion pattern."""
+    parts = Path(rel_path).parts
+    for pattern in ZIP_EXCLUDE_PATTERNS:
+        # Directory pattern (ends with /)
+        if pattern.endswith("/"):
+            dir_name = pattern.rstrip("/")
+            if dir_name in parts:
+                return True
+        # Glob pattern
+        elif any(fnmatch.fnmatch(part, pattern) for part in parts):
+            return True
+    return False
+
+
+def create_script_zip(script_path: str) -> tuple[bytes, str]:
+    """Create a ZIP archive of the script's parent directory.
+
+    Returns (zip_bytes, script_name) where script_name is the relative
+    path of the script inside the archive.
+    """
+    script = Path(script_path).resolve()
+    base_dir = script.parent
+
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
+        for file in sorted(base_dir.rglob("*")):
+            if not file.is_file():
+                continue
+            rel = str(file.relative_to(base_dir))
+            if should_exclude(rel):
+                continue
+            zf.write(file, rel)
+
+    return buf.getvalue(), script.name
+
+
+def check_upload_size(
+    zip_bytes: bytes,
+    max_bytes: int = DEFAULT_MAX_UPLOAD_BYTES,
+) -> None:
+    """Raise ValueError if zip_bytes exceed the maximum upload size."""
+    if len(zip_bytes) > max_bytes:
+        size_mb = len(zip_bytes) / (1024 * 1024)
+        limit_mb = max_bytes / (1024 * 1024)
+        raise ValueError(f"Archive is {size_mb:.0f} MB, limit is {limit_mb:.0f} MB.")
+
+
+def warn_large_upload(zip_bytes: bytes) -> str | None:
+    """Return a warning message if zip_bytes exceed the warning threshold."""
+    if len(zip_bytes) > UPLOAD_WARNING_BYTES:
+        size_mb = len(zip_bytes) / (1024 * 1024)
+        return f"Archive is {size_mb:.0f} MB — upload may take a while."
+    return None

nerdit/config/defaults.py

@@ -0,0 +1,31 @@
+"""Default constants for Nerdit configuration."""
+
+from pathlib import Path
+
+DEFAULT_HOST = "127.0.0.1"
+DEFAULT_PORT = 9321
+DEFAULT_DATA_DIR = Path("~/.nerdit")
+DEFAULT_DB_NAME = "nerdit.db"
+DEFAULT_PID_FILE = "nerditd.pid"
+DEFAULT_LOG_LEVEL = "info"
+
+DEFAULT_IMAGE = "nerdit-runtime:0.1"
+DEFAULT_RUNTIME = "docker"
+DEFAULT_CACHE_DIR = "~/.nerdit/cache"
+
+DEFAULT_PRIORITY = 5
+DEFAULT_MAX_CONCURRENT_JOBS = 0  # 0 = auto (number of GPUs)
+DEFAULT_TIMEOUT = 0  # 0 = no timeout
+DEFAULT_MAX_RETRIES = 3
+
+DEFAULT_MONITOR_INTERVAL = 5  # seconds
+DEFAULT_GPU_TEMP_WARNING = 80  # °C
+DEFAULT_GPU_TEMP_CRITICAL = 90  # °C
+
+DAEMON_URL = f"http://{DEFAULT_HOST}:{DEFAULT_PORT}"
+
+# Upload / ZIP constants (v0.2)
+DEFAULT_UPLOAD_DIR = Path("~/.nerdit/uploads")
+DEFAULT_MAX_UPLOAD_BYTES = 500 * 1024 * 1024  # 500 MB
+UPLOAD_WARNING_BYTES = 100 * 1024 * 1024  # 100 MB
+ZIP_EXCLUDE_PATTERNS = {".git", "data/", "*.pyc", "__pycache__", ".venv", "node_modules"}