hypercli-cli 0.4.0__py3-none-any.whl

c3cli/instances.py

@@ -0,0 +1,193 @@
+"""c3 instances commands"""
+import typer
+from typing import Optional
+from c3 import C3
+from .output import output, console, success, spinner
+
+app = typer.Typer(help="GPU instances - browse and launch")
+
+
+def get_client() -> C3:
+    return C3()
+
+
+@app.command("list")
+def list_instances(
+    gpu: Optional[str] = typer.Option(None, "--gpu", "-g", help="Filter by GPU type"),
+    region: Optional[str] = typer.Option(None, "--region", "-r", help="Filter by region"),
+    fmt: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+):
+    """List available GPU instances with pricing"""
+    c3 = get_client()
+    with spinner("Fetching instances..."):
+        available = c3.instances.list_available(gpu_type=gpu, region=region)
+
+    if fmt == "json":
+        output(available, "json")
+    else:
+        from rich.table import Table
+        table = Table(show_header=True, header_style="bold cyan")
+        table.add_column("GPU")
+        table.add_column("Count", justify="right")
+        table.add_column("Region")
+        table.add_column("Spot $/hr", justify="right")
+        table.add_column("On-Demand $/hr", justify="right")
+        table.add_column("vCPUs", justify="right")
+        table.add_column("RAM GB", justify="right")
+
+        for item in sorted(available, key=lambda x: (x["gpu_type"], x["gpu_count"], x.get("price_spot") or 999)):
+            spot_price = f"${item['price_spot']:.2f}" if item['price_spot'] else "-"
+            od_price = f"${item['price_on_demand']:.2f}" if item['price_on_demand'] else "-"
+
+            table.add_row(
+                f"[green]{item['gpu_type']}[/]",
+                str(item['gpu_count']),
+                f"{item['region']} ({item['region_name']})",
+                f"[cyan]{spot_price}[/]",
+                od_price,
+                str(int(item['cpu_cores'])),
+                str(int(item['memory_gb'])),
+            )
+
+        console.print(table)
+
+
+@app.command("gpus")
+def list_gpus(
+    region: Optional[str] = typer.Option(None, "--region", "-r", help="Filter by region"),
+    fmt: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+):
+    """List available GPU types"""
+    c3 = get_client()
+    with spinner("Fetching GPU types..."):
+        types = c3.instances.types()
+
+    if fmt == "json":
+        output({k: {"name": v.name, "description": v.description, "configs": [
+            {"gpu_count": c.gpu_count, "cpu_cores": c.cpu_cores, "memory_gb": c.memory_gb, "regions": c.regions}
+            for c in v.configs
+        ]} for k, v in types.items()}, "json")
+    else:
+        from rich.table import Table
+        table = Table(show_header=True, header_style="bold cyan")
+        table.add_column("GPU Type")
+        table.add_column("Name")
+        table.add_column("Description")
+        table.add_column("Counts")
+        table.add_column("Regions")
+
+        for gpu_id, gpu in types.items():
+            available_counts = []
+            available_regions = set()
+            for config in gpu.configs:
+                if config.regions:
+                    if region and region not in config.regions:
+                        continue
+                    available_counts.append(str(config.gpu_count))
+                    available_regions.update(config.regions)
+
+            if not available_counts:
+                continue
+
+            table.add_row(
+                f"[green]{gpu_id}[/]",
+                gpu.name,
+                gpu.description,
+                ", ".join(available_counts),
+                ", ".join(sorted(available_regions)),
+            )
+
+        console.print(table)
+
+
+@app.command("regions")
+def list_regions(
+    fmt: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+):
+    """List available regions"""
+    c3 = get_client()
+    with spinner("Fetching regions..."):
+        regions = c3.instances.regions()
+
+    if fmt == "json":
+        output({k: {"description": v.description, "country": v.country} for k, v in regions.items()}, "json")
+    else:
+        from rich.table import Table
+        table = Table(show_header=True, header_style="bold cyan")
+        table.add_column("Code")
+        table.add_column("Location")
+        table.add_column("Country")
+
+        for region_id, region in regions.items():
+            table.add_row(
+                f"[green]{region_id}[/]",
+                region.description,
+                region.country,
+            )
+
+        console.print(table)
+
+
+@app.command("launch")
+def launch(
+    image: str = typer.Argument(..., help="Docker image"),
+    command: Optional[str] = typer.Option(None, "--command", "-c", help="Command to run"),
+    gpu: str = typer.Option("l40s", "--gpu", "-g", help="GPU type"),
+    count: int = typer.Option(1, "--count", "-n", help="Number of GPUs"),
+    region: Optional[str] = typer.Option(None, "--region", "-r", help="Region code"),
+    runtime: Optional[int] = typer.Option(None, "--runtime", "-t", help="Runtime in seconds"),
+    interruptible: bool = typer.Option(True, "--interruptible/--on-demand", help="Use interruptible instances"),
+    env: Optional[list[str]] = typer.Option(None, "--env", "-e", help="Env vars (KEY=VALUE)"),
+    port: Optional[list[str]] = typer.Option(None, "--port", "-p", help="Ports (name:port)"),
+    follow: bool = typer.Option(False, "--follow", "-f", help="Follow logs after creation"),
+    fmt: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+):
+    """Launch a new GPU instance"""
+    c3 = get_client()
+
+    # Parse env vars
+    env_dict = None
+    if env:
+        env_dict = {}
+        for e in env:
+            if "=" in e:
+                k, v = e.split("=", 1)
+                env_dict[k] = v
+
+    # Parse ports
+    ports_dict = None
+    if port:
+        ports_dict = {}
+        for p in port:
+            if ":" in p:
+                name, port_num = p.split(":", 1)
+                ports_dict[name] = int(port_num)
+
+    with spinner("Launching instance..."):
+        job = c3.jobs.create(
+            image=image,
+            command=command,
+            gpu_type=gpu,
+            gpu_count=count,
+            region=region,
+            runtime=runtime,
+            interruptible=interruptible,
+            env=env_dict,
+            ports=ports_dict,
+        )
+
+    if fmt == "json":
+        output(job, "json")
+    else:
+        success(f"Instance launched: {job.job_id}")
+        console.print(f"  State:    {job.state}")
+        console.print(f"  GPU:      {job.gpu_type} x{job.gpu_count}")
+        console.print(f"  Region:   {job.region}")
+        console.print(f"  Price:    ${job.price_per_hour:.2f}/hr")
+        if job.hostname:
+            console.print(f"  Hostname: {job.hostname}")
+
+    if follow:
+        console.print()
+        from .tui.job_monitor import run_job_monitor
+        run_job_monitor(job.job_id)

c3cli/jobs.py

@@ -0,0 +1,239 @@
+"""c3 jobs commands"""
+import typer
+from typing import Optional
+from c3 import C3
+from .output import output, console, success, spinner
+
+app = typer.Typer(help="Manage running jobs")
+
+
+def get_client() -> C3:
+    return C3()
+
+
+@app.command("list")
+def list_jobs(
+    state: Optional[str] = typer.Option(None, "--state", "-s", help="Filter by state"),
+    fmt: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+):
+    """List all jobs"""
+    c3 = get_client()
+    with spinner("Fetching jobs..."):
+        jobs = c3.jobs.list(state=state)
+
+    if fmt == "json":
+        output(jobs, "json")
+    else:
+        if not jobs:
+            console.print("[dim]No jobs found[/dim]")
+            return
+        output(jobs, "table", ["job_id", "state", "gpu_type", "gpu_count", "region", "hostname"])
+
+
+@app.command("get")
+def get_job(
+    job_id: str = typer.Argument(..., help="Job ID"),
+    fmt: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+):
+    """Get job details"""
+    c3 = get_client()
+    with spinner("Fetching job..."):
+        job = c3.jobs.get(job_id)
+    output(job, fmt)
+
+
+@app.command("logs")
+def logs(
+    job_id: str = typer.Argument(..., help="Job ID"),
+    follow: bool = typer.Option(False, "--follow", "-f", help="Stream logs"),
+):
+    """Get job logs"""
+    c3 = get_client()
+
+    if follow:
+        _follow_job(job_id)
+    else:
+        with spinner("Fetching logs..."):
+            logs_str = c3.jobs.logs(job_id)
+        console.print(logs_str)
+
+
+@app.command("metrics")
+def metrics(
+    job_id: str = typer.Argument(..., help="Job ID"),
+    watch: bool = typer.Option(False, "--watch", "-w", help="Watch metrics live"),
+    fmt: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+):
+    """Get job GPU metrics"""
+    c3 = get_client()
+
+    if watch:
+        _watch_metrics(job_id)
+    else:
+        with spinner("Fetching metrics..."):
+            m = c3.jobs.metrics(job_id)
+        if fmt == "json":
+            output(m, "json")
+        else:
+            _print_metrics(m)
+
+
+@app.command("cancel")
+def cancel(
+    job_id: str = typer.Argument(..., help="Job ID"),
+):
+    """Cancel a running job"""
+    c3 = get_client()
+    with spinner("Cancelling job..."):
+        c3.jobs.cancel(job_id)
+    success(f"Job {job_id} cancelled")
+
+
+@app.command("extend")
+def extend(
+    job_id: str = typer.Argument(..., help="Job ID"),
+    runtime: int = typer.Argument(..., help="New runtime in seconds"),
+    fmt: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+):
+    """Extend job runtime"""
+    c3 = get_client()
+    with spinner("Extending runtime..."):
+        job = c3.jobs.extend(job_id, runtime)
+    if fmt == "json":
+        output(job, "json")
+    else:
+        success(f"Job extended to {runtime}s runtime")
+
+
+def _print_metrics(m):
+    """Print GPU metrics"""
+    from rich.panel import Panel
+    from rich.table import Table
+
+    # System metrics (CPU/RAM)
+    if m.system:
+        sys_table = Table(show_header=False, box=None, padding=(0, 2))
+        sys_table.add_column("Metric", style="cyan")
+        sys_table.add_column("Value")
+        sys_table.add_column("Bar", width=30)
+
+        cpu_bar = _make_bar(m.system.cpu_percent, 100)
+        mem_pct = (m.system.memory_used / m.system.memory_limit * 100) if m.system.memory_limit else 0
+        mem_bar = _make_bar(mem_pct, 100)
+
+        sys_table.add_row("CPU", f"{m.system.cpu_percent:5.1f}%", cpu_bar)
+        sys_table.add_row("RAM", f"{m.system.memory_used/1024:.1f}/{m.system.memory_limit/1024:.1f} GB", mem_bar)
+
+        console.print(Panel(sys_table, title="[bold]System[/bold]"))
+
+    if not m.gpus:
+        console.print("[dim]No GPU metrics available[/dim]")
+        return
+
+    for gpu in m.gpus:
+        table = Table(show_header=False, box=None, padding=(0, 2))
+        table.add_column("Metric", style="cyan")
+        table.add_column("Value")
+        table.add_column("Bar", width=30)
+
+        util_bar = _make_bar(gpu.utilization, 100)
+        mem_pct = (gpu.memory_used / gpu.memory_total * 100) if gpu.memory_total else 0
+        mem_bar = _make_bar(mem_pct, 100)
+        temp_bar = _make_bar(gpu.temperature, 100, warn=70, crit=85)
+
+        table.add_row("GPU", f"{gpu.utilization:5.1f}%", util_bar)
+        table.add_row("VRAM", f"{gpu.memory_used/1024:.1f}/{gpu.memory_total/1024:.1f} GB", mem_bar)
+        table.add_row("Temp", f"{gpu.temperature}°C", temp_bar)
+        table.add_row("Power", f"{gpu.power_draw:.0f}W", "")
+
+        title = f"[bold]GPU {gpu.index}: {gpu.name}[/bold]" if gpu.name else f"[bold]GPU {gpu.index}[/bold]"
+        console.print(Panel(table, title=title))
+
+
+def _make_bar(value: float, max_val: float, warn: float = None, crit: float = None) -> str:
+    """Create a colored progress bar"""
+    pct = min(value / max_val, 1.0) if max_val else 0
+    width = 25
+    filled = int(pct * width)
+
+    if crit and value >= crit:
+        color = "red"
+    elif warn and value >= warn:
+        color = "yellow"
+    else:
+        color = "green"
+
+    bar = "█" * filled + "░" * (width - filled)
+    return f"[{color}]{bar}[/{color}]"
+
+
+def _follow_job(job_id: str):
+    """Follow job with TUI"""
+    from .tui.job_monitor import run_job_monitor
+    run_job_monitor(job_id)
+
+
+def _watch_metrics(job_id: str):
+    """Watch metrics live"""
+    import time
+    from rich.live import Live
+
+    c3 = get_client()
+
+    with Live(console=console, refresh_per_second=2) as live:
+        while True:
+            try:
+                m = c3.jobs.metrics(job_id)
+                live.update(_render_metrics(m))
+                time.sleep(1)
+            except KeyboardInterrupt:
+                break
+            except Exception as e:
+                console.print(f"[red]Error: {e}[/red]")
+                break
+
+
+def _render_metrics(m):
+    """Render metrics as Rich panel"""
+    from rich.panel import Panel
+    from rich.table import Table
+    from rich.console import Group
+
+    panels = []
+
+    # System metrics
+    if m.system:
+        sys_table = Table(show_header=False, box=None)
+        sys_table.add_column("Metric", style="cyan")
+        sys_table.add_column("Value")
+        cpu_bar = _make_bar(m.system.cpu_percent, 100)
+        mem_pct = (m.system.memory_used / m.system.memory_limit * 100) if m.system.memory_limit else 0
+        mem_bar = _make_bar(mem_pct, 100)
+        sys_table.add_row("CPU", f"{m.system.cpu_percent:5.1f}% {cpu_bar}")
+        sys_table.add_row("RAM", f"{m.system.memory_used/1024:.1f}/{m.system.memory_limit/1024:.1f}GB {mem_bar}")
+        panels.append(Panel(sys_table, title="[bold]System[/bold]", border_style="blue"))
+
+    if not m.gpus:
+        panels.append(Panel("[dim]No GPU metrics[/dim]"))
+        return Group(*panels)
+
+    table = Table(show_header=True, header_style="bold cyan", box=None)
+    table.add_column("GPU")
+    table.add_column("Util")
+    table.add_column("VRAM")
+    table.add_column("Temp")
+    table.add_column("Power")
+
+    for gpu in m.gpus:
+        util_bar = _make_bar(gpu.utilization, 100)
+        name = f"{gpu.index}: {gpu.name}" if gpu.name else str(gpu.index)
+        table.add_row(
+            f"[bold]{name}[/bold]",
+            f"{gpu.utilization:5.1f}% {util_bar}",
+            f"{gpu.memory_used/1024:.1f}/{gpu.memory_total/1024:.1f}GB",
+            f"{gpu.temperature}°C",
+            f"{gpu.power_draw:.0f}W"
+        )
+
+    panels.append(Panel(table, title="[bold]GPU Metrics[/bold]", border_style="green"))
+    return Group(*panels)

c3cli/llm.py

@@ -0,0 +1,263 @@
+"""c3 llm commands - uses OpenAI SDK"""
+import typer
+from typing import Optional
+from openai import OpenAI
+from c3.config import get_api_key, get_api_url
+from .output import output, console, spinner
+
+app = typer.Typer(help="LLM API commands")
+
+
+def get_openai_client() -> OpenAI:
+    """Get OpenAI client configured for C3"""
+    api_key = get_api_key()
+    if not api_key:
+        raise typer.Exit("C3_API_KEY not set. Run: c3 configure")
+
+    base_url = get_api_url()
+    return OpenAI(api_key=api_key, base_url=f"{base_url}/v1")
+
+
+@app.command("models")
+def models(
+    fmt: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+):
+    """List available models"""
+    client = get_openai_client()
+    with spinner("Fetching models..."):
+        models_list = list(client.models.list())
+
+    if fmt == "json":
+        output([{"id": m.id, "owned_by": m.owned_by} for m in models_list], "json")
+    else:
+        data = [{"id": m.id, "owned_by": m.owned_by} for m in models_list]
+        output(data, "table", ["id", "owned_by"])
+
+
+@app.command("chat")
+def chat(
+    model: Optional[str] = typer.Argument(None, help="Model name (optional for interactive)"),
+    prompt: Optional[str] = typer.Argument(None, help="Prompt (omit for interactive)"),
+    system: Optional[str] = typer.Option(None, "--system", "-s", help="System message"),
+    max_tokens: int = typer.Option(4096, "--max-tokens", "-m", help="Max tokens"),
+    temperature: float = typer.Option(0.7, "--temperature", "-t", help="Temperature"),
+    no_stream: bool = typer.Option(False, "--no-stream", help="Disable streaming"),
+    interactive: bool = typer.Option(False, "--interactive", "-i", help="Interactive mode"),
+    fmt: str = typer.Option("text", "--output", "-o", help="Output format: text|json"),
+):
+    """Chat completion"""
+    client = get_openai_client()
+
+    # Interactive mode if -i flag or no model provided
+    if interactive or model is None:
+        _interactive_chat(client, model, system, max_tokens, temperature)
+        return
+
+    if prompt is None:
+        _interactive_chat(client, model, system, max_tokens, temperature)
+        return
+
+    messages = []
+    if system:
+        messages.append({"role": "system", "content": system})
+    messages.append({"role": "user", "content": prompt})
+
+    if no_stream or fmt == "json":
+        with spinner("Generating response..."):
+            response = client.chat.completions.create(
+                model=model,
+                messages=messages,
+                max_tokens=max_tokens,
+                temperature=temperature,
+            )
+        if fmt == "json":
+            output(response.model_dump(), "json")
+        else:
+            console.print(response.choices[0].message.content)
+    else:
+        stream = client.chat.completions.create(
+            model=model,
+            messages=messages,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            stream=True,
+        )
+        for chunk in stream:
+            content = chunk.choices[0].delta.content
+            if content:
+                console.print(content, end="")
+        console.print()
+
+
+def _interactive_chat(client: OpenAI, model: Optional[str], system: Optional[str], max_tokens: int, temperature: float):
+    """Interactive chat mode with slash commands"""
+    from rich.table import Table
+
+    # Default model if none provided
+    current_model = model or "meta-llama/llama-3.3-70b-instruct"
+    current_system = system
+    current_temp = temperature
+    current_max_tokens = max_tokens
+    messages: list[dict] = []
+
+    if current_system:
+        messages.append({"role": "system", "content": current_system})
+
+    def show_help():
+        console.print("\n[bold cyan]Commands:[/bold cyan]")
+        table = Table(show_header=False, box=None, padding=(0, 2))
+        table.add_column("Command", style="green")
+        table.add_column("Description")
+        table.add_row("/model <name>", "Switch to a different model")
+        table.add_row("/models", "List available models")
+        table.add_row("/system <prompt>", "Set system prompt")
+        table.add_row("/temp <value>", "Set temperature (0.0-2.0)")
+        table.add_row("/tokens <value>", "Set max tokens")
+        table.add_row("/clear", "Clear conversation history")
+        table.add_row("/history", "Show conversation history")
+        table.add_row("/help", "Show this help")
+        table.add_row("/quit", "Exit chat")
+        console.print(table)
+        console.print()
+
+    def show_status():
+        console.print(f"[dim]Model: [green]{current_model}[/] | Temp: {current_temp} | Max tokens: {current_max_tokens}[/]")
+        if current_system:
+            sys_preview = current_system[:50] + "..." if len(current_system) > 50 else current_system
+            console.print(f"[dim]System: {sys_preview}[/]")
+
+    console.print("\n[bold cyan]C3 Chat[/bold cyan]")
+    show_status()
+    console.print("[dim]Type /help for commands, /quit to exit[/dim]\n")
+
+    while True:
+        try:
+            user_input = console.input("[bold blue]> [/bold blue]").strip()
+
+            if not user_input:
+                continue
+
+            # Handle slash commands
+            if user_input.startswith("/"):
+                parts = user_input[1:].split(maxsplit=1)
+                cmd = parts[0].lower()
+                arg = parts[1] if len(parts) > 1 else None
+
+                if cmd in ("quit", "exit", "q"):
+                    console.print("[dim]Goodbye![/dim]")
+                    break
+
+                elif cmd == "help":
+                    show_help()
+
+                elif cmd == "models":
+                    with spinner("Fetching models..."):
+                        models_list = list(client.models.list())
+                    console.print("\n[bold]Available models:[/bold]")
+                    for m in models_list:
+                        marker = "[green]●[/]" if m.id == current_model else "[dim]○[/]"
+                        console.print(f"  {marker} {m.id}")
+                    console.print()
+
+                elif cmd == "model":
+                    if not arg:
+                        console.print(f"[dim]Current model: [green]{current_model}[/][/]")
+                    else:
+                        current_model = arg
+                        console.print(f"[green]✓[/] Switched to model: [bold]{current_model}[/]")
+
+                elif cmd == "system":
+                    if not arg:
+                        if current_system:
+                            console.print(f"[dim]System prompt: {current_system}[/]")
+                        else:
+                            console.print("[dim]No system prompt set[/]")
+                    else:
+                        current_system = arg
+                        # Update or add system message
+                        if messages and messages[0]["role"] == "system":
+                            messages[0]["content"] = current_system
+                        else:
+                            messages.insert(0, {"role": "system", "content": current_system})
+                        console.print(f"[green]✓[/] System prompt updated")
+
+                elif cmd == "temp":
+                    if not arg:
+                        console.print(f"[dim]Temperature: {current_temp}[/]")
+                    else:
+                        try:
+                            current_temp = float(arg)
+                            console.print(f"[green]✓[/] Temperature set to {current_temp}")
+                        except ValueError:
+                            console.print("[red]Invalid temperature value[/]")
+
+                elif cmd == "tokens":
+                    if not arg:
+                        console.print(f"[dim]Max tokens: {current_max_tokens}[/]")
+                    else:
+                        try:
+                            current_max_tokens = int(arg)
+                            console.print(f"[green]✓[/] Max tokens set to {current_max_tokens}")
+                        except ValueError:
+                            console.print("[red]Invalid token value[/]")
+
+                elif cmd == "clear":
+                    messages.clear()
+                    if current_system:
+                        messages.append({"role": "system", "content": current_system})
+                    console.print("[green]✓[/] Conversation cleared")
+
+                elif cmd == "history":
+                    if not messages or (len(messages) == 1 and messages[0]["role"] == "system"):
+                        console.print("[dim]No conversation history[/]")
+                    else:
+                        console.print("\n[bold]Conversation history:[/bold]")
+                        for msg in messages:
+                            if msg["role"] == "system":
+                                console.print(f"[dim]System: {msg['content'][:100]}...[/]")
+                            elif msg["role"] == "user":
+                                console.print(f"[blue]You:[/] {msg['content'][:100]}...")
+                            else:
+                                console.print(f"[green]Assistant:[/] {msg['content'][:100]}...")
+                        console.print()
+
+                else:
+                    console.print(f"[red]Unknown command: /{cmd}[/] - type /help for commands")
+
+                continue
+
+            # Regular message - send to model
+            messages.append({"role": "user", "content": user_input})
+
+            console.print("[bold green]Assistant:[/bold green] ", end="")
+
+            try:
+                full_response = []
+                stream = client.chat.completions.create(
+                    model=current_model,
+                    messages=messages,
+                    max_tokens=current_max_tokens,
+                    temperature=current_temp,
+                    stream=True,
+                )
+
+                for chunk in stream:
+                    if chunk.choices and chunk.choices[0].delta.content:
+                        content = chunk.choices[0].delta.content
+                        console.print(content, end="")
+                        full_response.append(content)
+
+                console.print("\n")
+                messages.append({"role": "assistant", "content": "".join(full_response)})
+
+            except Exception as e:
+                console.print(f"\n[red]Error: {e}[/]\n")
+                # Remove the failed user message
+                messages.pop()
+
+        except KeyboardInterrupt:
+            console.print("\n[dim]Goodbye![/dim]")
+            break
+        except EOFError:
+            console.print("\n[dim]Goodbye![/dim]")
+            break