gpuops 0.1.0__tar.gz → 0.1.1__tar.gz

{gpuops-0.1.0 → gpuops-0.1.1}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: gpuops
-Version: 0.1.0
+Version: 0.1.1
 Summary: A small GPU operations CLI for shared lab servers.
 Author: GPUOps contributors
 License-Expression: MIT
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+Requires-Dist: rich>=13.7
 
 # GPUOps
 
@@ -24,6 +25,8 @@ history.
 - Per-user summary across all GPUs.
 - Memory/running-time top view.
 - Lightweight JSONL history sampling and GPU-hour aggregation.
+- Rich terminal output: loading spinners, colored tables, memory bars, and progress bars.
+- Interactive kill confirmation with `gpuops kill --interactive`.
 - Safe-by-default process management: `kill` is dry-run unless `--yes` is passed.
 
 ## Install locally
@@ -52,6 +55,12 @@ gpuops kill --user alice
 gpuops kill --gpu 3 --user alice
 ```
 
+Preview and confirm in-place:
+
+```bash
+gpuops kill --gpu 3 --user alice --interactive
+```
+
 To actually send signals:
 
 ```bash
@@ -59,6 +68,9 @@ gpuops kill --gpu 3 --user alice --yes
 gpuops kill --user alice --force --yes
 ```
 
+Use `--json` on any command when piping into scripts; JSON output skips the
+loading spinners, prompts, and table styling.
+
 ## History
 
 `gpuops status --record` appends one sample to:

{gpuops-0.1.0 → gpuops-0.1.1}/README.md

@@ -15,6 +15,8 @@ history.
 - Per-user summary across all GPUs.
 - Memory/running-time top view.
 - Lightweight JSONL history sampling and GPU-hour aggregation.
+- Rich terminal output: loading spinners, colored tables, memory bars, and progress bars.
+- Interactive kill confirmation with `gpuops kill --interactive`.
 - Safe-by-default process management: `kill` is dry-run unless `--yes` is passed.
 
 ## Install locally
@@ -43,6 +45,12 @@ gpuops kill --user alice
 gpuops kill --gpu 3 --user alice
 ```
 
+Preview and confirm in-place:
+
+```bash
+gpuops kill --gpu 3 --user alice --interactive
+```
+
 To actually send signals:
 
 ```bash
@@ -50,6 +58,9 @@ gpuops kill --gpu 3 --user alice --yes
 gpuops kill --user alice --force --yes
 ```
 
+Use `--json` on any command when piping into scripts; JSON output skips the
+loading spinners, prompts, and table styling.
+
 ## History
 
 `gpuops status --record` appends one sample to:

{gpuops-0.1.0 → gpuops-0.1.1}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gpuops"
-version = "0.1.0"
+version = "0.1.1"
 description = "A small GPU operations CLI for shared lab servers."
 readme = "README.md"
 requires-python = ">=3.9"
 license = "MIT"
 authors = [{ name = "GPUOps contributors" }]
-dependencies = []
+dependencies = ["rich>=13.7"]
 
 [project.scripts]
 gpuops = "gpuops.cli:main"

{gpuops-0.1.0 → gpuops-0.1.1}/src/gpuops/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.1.0"
+__version__ = "0.1.1"

{gpuops-0.1.0 → gpuops-0.1.1}/src/gpuops/cli.py

@@ -1,18 +1,30 @@
 from __future__ import annotations
 
 import argparse
-import sys
 from collections import defaultdict
 from pathlib import Path
 from typing import List, Optional
 
 from .actions import filter_processes, kill_processes, signal_for
 from .alerts import evaluate_snapshot
-from .formatting import gpu_rows, json_dump, process_rows, table
+from .formatting import json_dump
 from .history import DEFAULT_HISTORY_PATH, read_snapshots, record_snapshot, since_days, summarize_user_usage
+from .models import Snapshot
 from .nvidia import NvidiaSmiError, collect_snapshot
 from .process_info import enrich_processes
-from .models import Snapshot
+from .ui import (
+    confirm,
+    loading,
+    print_alerts,
+    print_empty,
+    print_error,
+    print_gpu_status,
+    print_history,
+    print_kill_results,
+    print_processes,
+    print_users,
+    progress,
+)
 
 
 def build_parser() -> argparse.ArgumentParser:
@@ -50,6 +62,7 @@ def build_parser() -> argparse.ArgumentParser:
     kill.add_argument("--user")
     kill.add_argument("--force", action="store_true", help="use SIGKILL instead of SIGTERM")
     kill.add_argument("--yes", action="store_true", help="actually send the signal")
+    kill.add_argument("--interactive", "-i", action="store_true", help="preview and ask before sending signals")
 
     history = subparsers.add_parser("history", help="summarize recorded GPU usage")
     history.add_argument("--json", action="store_true", help="print machine-readable JSON")
@@ -59,9 +72,10 @@ def build_parser() -> argparse.ArgumentParser:
     return parser
 
 
-def _snapshot() -> Snapshot:
-    snap = collect_snapshot()
-    enrich_processes(snap.processes)
+def _snapshot(show_loading: bool = True) -> Snapshot:
+    with loading("Collecting GPU telemetry", enabled=show_loading):
+        snap = collect_snapshot()
+        enrich_processes(snap.processes)
     return snap
 
 
@@ -78,31 +92,35 @@ def _sort_gpus(gpus, key: str):
 
 
 def cmd_status(args) -> int:
-    snap = _snapshot()
+    snap = _snapshot(show_loading=not args.json)
     if args.record:
-        record_snapshot(snap)
+        with loading("Recording history sample", enabled=not args.json):
+            record_snapshot(snap)
     alerts = evaluate_snapshot(snap)
     gpus = _sort_gpus(snap.gpus, args.sort)
     if args.json:
         print(json_dump({"snapshot": snap.to_dict(), "alerts": [alert.__dict__ for alert in alerts]}))
         return 0
-    print(table(["GPU", "Name", "Memory", "Free", "Util", "Temp", "Power", "Alerts"], gpu_rows(gpus, alerts)))
+    print_gpu_status(gpus, alerts)
     return 0
 
 
 def cmd_ps(args) -> int:
-    snap = _snapshot()
+    snap = _snapshot(show_loading=not args.json)
     processes = filter_processes(snap.processes, gpu=args.gpu, user=args.user)
     processes.sort(key=lambda proc: (proc.gpu_index if proc.gpu_index is not None else 9999, -proc.used_memory_mb))
     if args.json:
         print(json_dump([proc.__dict__ for proc in processes]))
         return 0
-    print(table(["GPU", "PID", "User", "Memory", "Running", "Command", "CWD"], process_rows(processes)))
+    if not processes:
+        print_empty("No matching GPU processes.")
+        return 0
+    print_processes(processes)
     return 0
 
 
 def cmd_users(args) -> int:
-    snap = _snapshot()
+    snap = _snapshot(show_loading=not args.json)
     buckets = defaultdict(lambda: {"memory": 0, "processes": 0, "runtime": 0.0, "gpus": set()})
     for proc in snap.processes:
         user = proc.user or "unknown"
@@ -131,22 +149,15 @@ def cmd_users(args) -> int:
     if args.json:
         print(json_dump(summaries))
         return 0
-    rows = [
-        [item["user"], item["gpus"], item["processes"], f"{item['memory_mb']} MB", _duration(item["runtime_seconds"])]
-        for item in summaries
-    ]
-    print(table(["User", "GPUs", "Processes", "Memory", "Total Running"], rows))
+    if not summaries:
+        print_empty("No active GPU users.")
+        return 0
+    print_users(summaries)
     return 0
 
 
-def _duration(seconds: float) -> str:
-    from .formatting import human_duration
-
-    return human_duration(seconds)
-
-
 def cmd_top(args) -> int:
-    snap = _snapshot()
+    snap = _snapshot(show_loading=not args.json)
     if args.by == "runtime":
         processes = sorted(snap.processes, key=lambda proc: proc.running_seconds or 0, reverse=True)
     else:
@@ -155,56 +166,69 @@ def cmd_top(args) -> int:
     if args.json:
         print(json_dump([proc.__dict__ for proc in processes]))
         return 0
-    print(table(["GPU", "PID", "User", "Memory", "Running", "Command", "CWD"], process_rows(processes)))
+    if not processes:
+        print_empty("No GPU processes to rank.")
+        return 0
+    print_processes(processes, title=f"GPU Process Top by {args.by.title()}")
     return 0
 
 
 def cmd_doctor(args) -> int:
-    snap = _snapshot()
+    snap = _snapshot(show_loading=not args.json)
     alerts = evaluate_snapshot(snap, idle_util_percent=args.idle_util, occupied_memory_mb=args.occupied_mb)
     if args.json:
         print(json_dump([alert.__dict__ for alert in alerts]))
         return 0
-    if not alerts:
-        print("No suspicious GPU state found.")
-        return 0
-    rows = [[alert.level, alert.gpu_index, alert.message] for alert in alerts]
-    print(table(["Level", "GPU", "Message"], rows))
+    print_alerts(alerts)
     return 1 if any(alert.level == "crit" for alert in alerts) else 0
 
 
 def cmd_kill(args) -> int:
     if args.gpu is None and args.user is None:
-        print("Refusing to select every GPU process. Pass --gpu, --user, or both.", file=sys.stderr)
+        print_error("Refusing to select every GPU process. Pass --gpu, --user, or both.")
         return 2
-    snap = _snapshot()
+    snap = _snapshot(show_loading=not args.json)
     selected = filter_processes(snap.processes, gpu=args.gpu, user=args.user)
     sig = signal_for(args.force)
-    results = kill_processes(selected, sig=sig, dry_run=not args.yes)
-    rows = [[r.gpu_index if r.gpu_index is not None else "-", r.pid, r.user or "-", r.signal_name, r.message] for r in results]
+    dry_run = not args.yes
+    if args.interactive and selected and not args.yes and not args.json:
+        preview = kill_processes(selected, sig=sig, dry_run=True)
+        print_kill_results(preview)
+        dry_run = not confirm(f"Send {sig.name} to {len(selected)} selected process(es)?", default=False)
+
+    results = []
+    if selected and not dry_run and not args.json:
+        with progress("Sending signals", total=len(selected)) as bar:
+            task_id = bar.add_task("Sending signals", total=len(selected))
+            for proc in selected:
+                results.extend(kill_processes([proc], sig=sig, dry_run=False))
+                bar.advance(task_id)
+    else:
+        results = kill_processes(selected, sig=sig, dry_run=dry_run)
     if args.json:
         print(json_dump([result.__dict__ for result in results]))
         return 0
-    if not rows:
-        print("No matching GPU processes.")
+    if not results:
+        print_empty("No matching GPU processes.")
         return 0
-    print(table(["GPU", "PID", "User", "Signal", "Result"], rows))
-    if not args.yes:
-        print("\nDry-run only. Re-run with --yes to send the signal.")
+    print_kill_results(results)
+    if dry_run:
+        print_empty("Dry-run only. Re-run with --yes, or use --interactive to confirm in-place.")
     return 0
 
 
 def cmd_history(args) -> int:
-    samples = read_snapshots(path=Path(args.path).expanduser(), since=since_days(args.days))
-    usage = summarize_user_usage(samples)
+    with loading("Reading usage history", enabled=not args.json):
+        samples = read_snapshots(path=Path(args.path).expanduser(), since=since_days(args.days))
+    with loading("Summarizing GPU hours", enabled=not args.json):
+        usage = summarize_user_usage(samples)
     if args.json:
         print(json_dump([item.__dict__ for item in usage]))
         return 0
     if not usage:
-        print("No history samples found. Run `gpuops status --record` periodically first.")
+        print_empty("No history samples found. Run `gpuops status --record` periodically first.")
         return 0
-    rows = [[item.user, f"{item.gpu_hours:.2f}", f"{item.memory_gb_hours:.2f}", item.samples] for item in usage]
-    print(table(["User", "GPU Hours", "GB Hours", "Samples"], rows))
+    print_history(usage, args.days)
     return 0
 
 
@@ -222,5 +246,5 @@ def main(argv: Optional[List[str]] = None) -> int:
             "history": cmd_history,
         }[args.command](args)
     except NvidiaSmiError as exc:
-        print(str(exc), file=sys.stderr)
+        print_error(str(exc))
         return 127

gpuops-0.1.1/src/gpuops/ui.py

@@ -0,0 +1,206 @@
+from __future__ import annotations
+
+from contextlib import contextmanager
+from typing import Iterable, Iterator, Sequence
+
+from rich import box
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
+from rich.prompt import Confirm
+from rich.table import Table
+from rich.text import Text
+
+from .actions import KillResult
+from .alerts import Alert
+from .formatting import human_duration
+from .history import UserUsage
+from .models import GPU, GPUProcess
+
+
+console = Console()
+error_console = Console(stderr=True)
+
+
+@contextmanager
+def loading(message: str, enabled: bool = True) -> Iterator[None]:
+    if not enabled:
+        yield
+        return
+    with console.status(f"[bold cyan]{message}[/]", spinner="dots"):
+        yield
+
+
+def memory_bar(used_mb: int, total_mb: int, width: int = 18) -> Text:
+    ratio = 0 if total_mb <= 0 else min(1.0, used_mb / total_mb)
+    filled = round(ratio * width)
+    color = "green"
+    if ratio >= 0.9:
+        color = "red"
+    elif ratio >= 0.75:
+        color = "yellow"
+    text = Text()
+    text.append("█" * filled, style=color)
+    text.append("░" * (width - filled), style="dim")
+    text.append(f" {ratio * 100:4.0f}%", style=color)
+    return text
+
+
+def util_text(value: int) -> Text:
+    style = "green"
+    if value >= 90:
+        style = "red"
+    elif value >= 60:
+        style = "yellow"
+    elif value <= 5:
+        style = "dim"
+    return Text(f"{value}%", style=style)
+
+
+def alert_badge(alerts: Sequence[str]) -> Text:
+    if not alerts:
+        return Text("healthy", style="green")
+    text = Text()
+    for index, alert in enumerate(alerts):
+        if index:
+            text.append("\n")
+        text.append(alert, style="bold yellow")
+    return text
+
+
+def print_gpu_status(gpus: Sequence[GPU], alerts: Sequence[Alert]) -> None:
+    alert_by_gpu: dict[int, list[str]] = {}
+    for alert in alerts:
+        alert_by_gpu.setdefault(alert.gpu_index, []).append(alert.message)
+
+    table = Table(title="GPUOps Status", box=box.ROUNDED, header_style="bold cyan", show_lines=False)
+    table.add_column("GPU", justify="right", style="bold", no_wrap=True)
+    table.add_column("Model", overflow="fold")
+    table.add_column("Memory", min_width=22)
+    table.add_column("Util", justify="right", no_wrap=True)
+    table.add_column("Temp", justify="right", no_wrap=True)
+    table.add_column("Power", justify="right", no_wrap=True)
+    table.add_column("State")
+    for gpu in gpus:
+        memory = Text()
+        memory.append(f"{gpu.memory_used_mb}/{gpu.memory_total_mb} MB\n", style="bold")
+        memory.append(memory_bar(gpu.memory_used_mb, gpu.memory_total_mb, width=10))
+        table.add_row(
+            str(gpu.index),
+            gpu.name,
+            memory,
+            util_text(gpu.utilization_gpu_percent),
+            "-" if gpu.temperature_c is None else f"{gpu.temperature_c}C",
+            "-" if gpu.power_w is None else f"{gpu.power_w:.0f}W",
+            alert_badge(alert_by_gpu.get(gpu.index, [])),
+        )
+    console.print(table)
+
+
+def print_processes(processes: Sequence[GPUProcess], title: str = "GPU Processes") -> None:
+    table = Table(title=title, box=box.ROUNDED, header_style="bold cyan")
+    table.add_column("GPU", justify="right")
+    table.add_column("PID", justify="right", style="bold")
+    table.add_column("User")
+    table.add_column("Memory", justify="right")
+    table.add_column("Running", justify="right")
+    table.add_column("Command", overflow="fold")
+    table.add_column("CWD", overflow="fold", style="dim")
+    for proc in processes:
+        table.add_row(
+            "-" if proc.gpu_index is None else str(proc.gpu_index),
+            str(proc.pid),
+            proc.user or "-",
+            f"{proc.used_memory_mb} MB",
+            human_duration(proc.running_seconds),
+            proc.command or proc.process_name,
+            proc.cwd or "-",
+        )
+    console.print(table)
+
+
+def print_users(summaries: Sequence[dict[str, object]]) -> None:
+    table = Table(title="GPU Usage by User", box=box.ROUNDED, header_style="bold cyan")
+    table.add_column("User", style="bold")
+    table.add_column("GPUs")
+    table.add_column("Processes", justify="right")
+    table.add_column("Memory", justify="right")
+    table.add_column("Total Running", justify="right")
+    for item in summaries:
+        table.add_row(
+            str(item["user"]),
+            str(item["gpus"]),
+            str(item["processes"]),
+            f"{item['memory_mb']} MB",
+            human_duration(float(item["runtime_seconds"])),
+        )
+    console.print(table)
+
+
+def print_alerts(alerts: Sequence[Alert]) -> None:
+    if not alerts:
+        console.print(Panel("No suspicious GPU state found.", title="GPUOps Doctor", border_style="green"))
+        return
+    table = Table(title="GPUOps Doctor", box=box.ROUNDED, header_style="bold cyan")
+    table.add_column("Level")
+    table.add_column("GPU", justify="right")
+    table.add_column("Message")
+    for alert in alerts:
+        style = "bold red" if alert.level == "crit" else "yellow"
+        table.add_row(Text(alert.level, style=style), str(alert.gpu_index), Text(alert.message, style=style))
+    console.print(table)
+
+
+def print_history(usage: Sequence[UserUsage], days: int) -> None:
+    table = Table(title=f"GPU Usage History ({days}d)", box=box.ROUNDED, header_style="bold cyan")
+    table.add_column("User", style="bold")
+    table.add_column("GPU Hours", justify="right")
+    table.add_column("GB Hours", justify="right")
+    table.add_column("Samples", justify="right")
+    for item in usage:
+        table.add_row(item.user, f"{item.gpu_hours:.2f}", f"{item.memory_gb_hours:.2f}", str(item.samples))
+    console.print(table)
+
+
+def print_kill_results(results: Sequence[KillResult]) -> None:
+    is_plan = all(result.message == "dry-run" for result in results)
+    table = Table(title="Kill Plan" if is_plan else "Kill Results", box=box.ROUNDED, header_style="bold cyan")
+    table.add_column("GPU", justify="right")
+    table.add_column("PID", justify="right", style="bold")
+    table.add_column("User")
+    table.add_column("Signal")
+    table.add_column("Result")
+    for result in results:
+        style = "green" if result.killed else "yellow" if result.message == "dry-run" else "red"
+        table.add_row(
+            "-" if result.gpu_index is None else str(result.gpu_index),
+            str(result.pid),
+            result.user or "-",
+            result.signal_name,
+            Text(result.message, style=style),
+        )
+    console.print(table)
+
+
+def confirm(message: str, default: bool = False) -> bool:
+    return Confirm.ask(message, default=default, console=console)
+
+
+def progress(description: str, total: int) -> Progress:
+    return Progress(
+        SpinnerColumn(),
+        TextColumn("[bold cyan]{task.description}"),
+        BarColumn(),
+        TextColumn("{task.completed}/{task.total}"),
+        TimeElapsedColumn(),
+        console=console,
+        transient=False,
+    )
+
+
+def print_empty(message: str) -> None:
+    console.print(Panel(message, border_style="dim"))
+
+
+def print_error(message: str) -> None:
+    error_console.print(f"[bold red]error:[/] {message}")

{gpuops-0.1.0 → gpuops-0.1.1}/src/gpuops.egg-info/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: gpuops
-Version: 0.1.0
+Version: 0.1.1
 Summary: A small GPU operations CLI for shared lab servers.
 Author: GPUOps contributors
 License-Expression: MIT
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+Requires-Dist: rich>=13.7
 
 # GPUOps
 
@@ -24,6 +25,8 @@ history.
 - Per-user summary across all GPUs.
 - Memory/running-time top view.
 - Lightweight JSONL history sampling and GPU-hour aggregation.
+- Rich terminal output: loading spinners, colored tables, memory bars, and progress bars.
+- Interactive kill confirmation with `gpuops kill --interactive`.
 - Safe-by-default process management: `kill` is dry-run unless `--yes` is passed.
 
 ## Install locally
@@ -52,6 +55,12 @@ gpuops kill --user alice
 gpuops kill --gpu 3 --user alice
 ```
 
+Preview and confirm in-place:
+
+```bash
+gpuops kill --gpu 3 --user alice --interactive
+```
+
 To actually send signals:
 
 ```bash
@@ -59,6 +68,9 @@ gpuops kill --gpu 3 --user alice --yes
 gpuops kill --user alice --force --yes
 ```
 
+Use `--json` on any command when piping into scripts; JSON output skips the
+loading spinners, prompts, and table styling.
+
 ## History
 
 `gpuops status --record` appends one sample to:

{gpuops-0.1.0 → gpuops-0.1.1}/src/gpuops.egg-info/SOURCES.txt

@@ -10,10 +10,12 @@ src/gpuops/history.py
 src/gpuops/models.py
 src/gpuops/nvidia.py
 src/gpuops/process_info.py
+src/gpuops/ui.py
 src/gpuops.egg-info/PKG-INFO
 src/gpuops.egg-info/SOURCES.txt
 src/gpuops.egg-info/dependency_links.txt
 src/gpuops.egg-info/entry_points.txt
+src/gpuops.egg-info/requires.txt
 src/gpuops.egg-info/top_level.txt
 tests/test_alerts_history_actions.py
 tests/test_nvidia.py

gpuops-0.1.1/src/gpuops.egg-info/requires.txt

@@ -0,0 +1 @@
+rich>=13.7