hypercli-cli 0.4.0__py3-none-any.whl

c3cli/output.py

@@ -0,0 +1,78 @@
+"""Output formatting"""
+import json as json_lib
+from typing import Any
+from rich.console import Console
+from rich.table import Table
+from rich import print_json
+
+console = Console()
+
+
+def output(data: Any, fmt: str = "table", columns: list[str] = None):
+    """Output data in requested format"""
+    if fmt == "json":
+        if hasattr(data, "__dict__"):
+            print_json(data=data.__dict__)
+        else:
+            print_json(data=data)
+    elif fmt == "table":
+        if isinstance(data, list):
+            table_list(data, columns)
+        elif hasattr(data, "__dict__"):
+            table_dict(data.__dict__)
+        elif isinstance(data, dict):
+            table_dict(data)
+        else:
+            console.print(data)
+    else:
+        console.print(data)
+
+
+def table_list(items: list, columns: list[str] = None):
+    """Render list as table"""
+    if not items:
+        console.print("[dim]No results[/dim]")
+        return
+
+    # Convert dataclass to dict if needed
+    if hasattr(items[0], "__dict__"):
+        items = [i.__dict__ for i in items]
+
+    cols = columns or list(items[0].keys())
+    table = Table(show_header=True, header_style="bold cyan")
+
+    for col in cols:
+        table.add_column(col)
+
+    for item in items:
+        row = [str(item.get(col, "")) for col in cols]
+        table.add_row(*row)
+
+    console.print(table)
+
+
+def table_dict(data: dict):
+    """Render dict as key-value table"""
+    table = Table(show_header=False, box=None)
+    table.add_column("Key", style="bold cyan")
+    table.add_column("Value")
+
+    for k, v in data.items():
+        if isinstance(v, (dict, list)):
+            v = json_lib.dumps(v, indent=2)
+        table.add_row(str(k), str(v))
+
+    console.print(table)
+
+
+def error(msg: str):
+    console.print(f"[bold red]Error:[/bold red] {msg}")
+
+
+def success(msg: str):
+    console.print(f"[bold green]✓[/bold green] {msg}")
+
+
+def spinner(msg: str = "Loading..."):
+    """Context manager for showing a spinner during slow operations"""
+    return console.status(f"[bold cyan]{msg}[/bold cyan]", spinner="dots")

c3cli/renders.py

@@ -0,0 +1,192 @@
+"""c3 renders commands"""
+import time
+import typer
+from typing import Optional
+from c3 import C3
+from .output import output, console, success, spinner
+
+app = typer.Typer(help="Manage renders")
+
+
+def get_client() -> C3:
+    return C3()
+
+
+@app.command("list")
+def list_renders(
+    state: Optional[str] = typer.Option(None, "--state", "-s", help="Filter by state"),
+    template: Optional[str] = typer.Option(None, "--template", "-t", help="Filter by template"),
+    type: Optional[str] = typer.Option(None, "--type", help="Filter by render type"),
+    fmt: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+):
+    """List all renders"""
+    c3 = get_client()
+    with spinner("Fetching renders..."):
+        renders = c3.renders.list(state=state, template=template, type=type)
+
+    if fmt == "json":
+        output(renders, "json")
+    else:
+        if not renders:
+            console.print("[dim]No renders found[/dim]")
+            return
+        output(renders, "table", ["render_id", "state", "template", "render_type", "created_at"])
+
+
+@app.command("get")
+def get_render(
+    render_id: str = typer.Argument(..., help="Render ID"),
+    fmt: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+):
+    """Get render details"""
+    c3 = get_client()
+    with spinner("Fetching render..."):
+        render = c3.renders.get(render_id)
+    output(render, fmt)
+
+
+@app.command("create")
+def create_render(
+    template: str = typer.Argument(..., help="Template name"),
+    prompt: str = typer.Option(..., "--prompt", "-p", help="Text prompt"),
+    gpu: str = typer.Option("L40S", "--gpu", "-g", help="GPU type"),
+    region: Optional[str] = typer.Option(None, "--region", "-r", help="Region"),
+    render_type: str = typer.Option("comfyui", "--type", "-t", help="Render type"),
+    wait: bool = typer.Option(False, "--wait", "-w", help="Wait for completion"),
+    notify_url: Optional[str] = typer.Option(None, "--notify", help="Webhook URL for completion"),
+    fmt: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+):
+    """Create a new render"""
+    c3 = get_client()
+
+    params = {
+        "template": template,
+        "prompt": prompt,
+        "gpu_type": gpu,
+    }
+    if region:
+        params["region"] = region
+
+    with spinner("Creating render..."):
+        render = c3.renders.create(params=params, render_type=render_type, notify_url=notify_url)
+
+    if fmt == "json" and not wait:
+        output(render, "json")
+    else:
+        console.print(f"[bold green]✓[/bold green] Render created: [cyan]{render.render_id}[/cyan]")
+        console.print(f"  State: {render.state}")
+
+    if wait:
+        _wait_for_render(c3, render.render_id, fmt)
+
+
+@app.command("status")
+def status(
+    render_id: str = typer.Argument(..., help="Render ID"),
+    watch: bool = typer.Option(False, "--watch", "-w", help="Watch status live"),
+    fmt: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+):
+    """Get render status"""
+    c3 = get_client()
+
+    if watch:
+        _watch_status(c3, render_id)
+    else:
+        with spinner("Fetching status..."):
+            s = c3.renders.status(render_id)
+        output(s, fmt)
+
+
+@app.command("cancel")
+def cancel(
+    render_id: str = typer.Argument(..., help="Render ID"),
+):
+    """Cancel a render"""
+    c3 = get_client()
+    with spinner("Cancelling render..."):
+        c3.renders.cancel(render_id)
+    success(f"Render {render_id} cancelled")
+
+
+def _wait_for_render(c3: C3, render_id: str, fmt: str, poll_interval: float = 2.0):
+    """Wait for render to complete"""
+    console.print("Waiting for completion...")
+
+    while True:
+        status = c3.renders.status(render_id)
+        progress_str = f" ({status.progress:.0%})" if status.progress is not None else ""
+        console.print(f"  State: {status.state}{progress_str}")
+
+        if status.state in ("completed", "failed", "cancelled"):
+            break
+        time.sleep(poll_interval)
+
+    # Get final render details
+    render = c3.renders.get(render_id)
+
+    if fmt == "json":
+        output(render, "json")
+    else:
+        console.print()
+        if render.state == "completed":
+            success(f"Render completed!")
+            if render.result_url:
+                console.print(f"  Result: [link={render.result_url}]{render.result_url}[/link]")
+        else:
+            console.print(f"[bold red]Render {render.state}[/bold red]")
+            if render.error:
+                console.print(f"  Error: {render.error}")
+
+
+def _watch_status(c3: C3, render_id: str, poll_interval: float = 2.0):
+    """Watch render status live"""
+    from rich.live import Live
+    from rich.panel import Panel
+    from rich.table import Table
+
+    def render_status_panel(status, render=None):
+        table = Table(show_header=False, box=None)
+        table.add_column("Key", style="cyan")
+        table.add_column("Value")
+
+        table.add_row("ID", status.render_id)
+        table.add_row("State", _state_style(status.state))
+        if status.progress is not None:
+            table.add_row("Progress", f"{status.progress:.0%}")
+        if render and render.result_url:
+            table.add_row("Result", render.result_url)
+        if render and render.error:
+            table.add_row("Error", f"[red]{render.error}[/red]")
+
+        return Panel(table, title="[bold]Render Status[/bold]")
+
+    with Live(console=console, refresh_per_second=2) as live:
+        while True:
+            try:
+                status = c3.renders.status(render_id)
+                render = None
+
+                if status.state in ("completed", "failed", "cancelled"):
+                    render = c3.renders.get(render_id)
+                    live.update(render_status_panel(status, render))
+                    break
+
+                live.update(render_status_panel(status))
+                time.sleep(poll_interval)
+            except KeyboardInterrupt:
+                break
+            except Exception as e:
+                console.print(f"[red]Error: {e}[/red]")
+                break
+
+
+def _state_style(state: str) -> str:
+    """Style state for display"""
+    styles = {
+        "pending": "[yellow]pending[/yellow]",
+        "running": "[blue]running[/blue]",
+        "completed": "[green]completed[/green]",
+        "failed": "[red]failed[/red]",
+        "cancelled": "[dim]cancelled[/dim]",
+    }
+    return styles.get(state, state)

c3cli/tui/__init__.py

@@ -0,0 +1,4 @@
+"""TUI components for c3 CLI"""
+from .job_monitor import JobStatus, run_job_monitor
+
+__all__ = ["JobStatus", "run_job_monitor"]

c3cli/tui/job_monitor.py

@@ -0,0 +1,335 @@
+"""Job monitor TUI - async log streaming with metrics display"""
+import asyncio
+import time
+from collections import deque
+from typing import Optional
+from queue import Queue, Empty
+from dataclasses import dataclass, field
+
+from rich.console import Console
+from rich.live import Live
+from rich.panel import Panel
+from rich.layout import Layout
+from rich import box
+
+from c3 import C3, LogStream, fetch_logs
+
+console = Console()
+
+# Buffer limits
+MAX_LOG_LINES = 1000
+
+
+@dataclass
+class JobStatus:
+    """Status updates for job execution (e.g., ComfyUI workflow progress)"""
+    stage: str = "initializing"
+    message: str = ""
+    progress: float = 0
+    history: list[str] = field(default_factory=list)
+    error: str | None = None
+    complete: bool = False
+    result: dict | None = None
+
+
+def format_time(seconds: int) -> str:
+    h, m, s = seconds // 3600, (seconds % 3600) // 60, seconds % 60
+    return f"{h}h {m}m {s}s" if h else f"{m}m {s}s" if m else f"{s}s"
+
+
+def bar(pct: float, width: int = 30, color: str = "blue") -> str:
+    filled = int(pct / 100 * width)
+    return f"[{color}]{'█' * filled}[/][dim]{'░' * (width - filled)}[/]"
+
+
+def build_header(job, elapsed: int, metrics) -> Panel:
+    """Combined job info + metrics header"""
+    parts = []
+
+    # Job info line
+    colors = {"queued": "yellow", "assigned": "blue", "running": "green",
+              "succeeded": "bright_green", "failed": "red", "terminated": "red"}
+    state_color = colors.get(job.state, "white")
+
+    info = f"[bold {state_color}]{job.state.upper()}[/]  {job.gpu_type} x{job.gpu_count}  {job.region}  ${job.price_per_hour:.2f}/hr"
+    if job.hostname:
+        info += f"  [dim]{job.hostname}[/]"
+    if job.runtime and elapsed > 0:
+        left = max(0, job.runtime - elapsed)
+        pct = min(elapsed / job.runtime * 100, 100)
+        c = "red" if left < 300 else "yellow" if left < 900 else "green"
+        info += f"  {bar(pct, 10, c)} [{c}]{format_time(left)}[/]"
+    parts.append(info)
+
+    # System metrics (CPU + RAM) - show first
+    if metrics and metrics.system:
+        parts.append("")
+        s = metrics.system
+        cpu_pct = min(s.cpu_percent, 100)  # Clamp at 100% for display
+        cpu_c = "green" if cpu_pct < 70 else "yellow" if cpu_pct < 90 else "red"
+        mem_pct = (s.memory_used / s.memory_limit * 100) if s.memory_limit else 0
+        mem_c = "red" if mem_pct >= 90 else "yellow" if mem_pct >= 70 else "green"
+
+        line = f"[bold]CPU[/]  {bar(cpu_pct, 20, cpu_c)} {cpu_pct:4.0f}%  "
+        line += f"RAM  {bar(mem_pct, 15, mem_c)} {s.memory_used/1024:.1f}/{s.memory_limit/1024:.1f}GB"
+        parts.append(line)
+
+    # GPU metrics
+    if metrics and metrics.gpus:
+        if not metrics.system:
+            parts.append("")
+        for g in metrics.gpus:
+            uc = "green" if g.utilization >= 50 else "yellow" if g.utilization >= 20 else "dim"
+            mp = (g.memory_used / g.memory_total * 100) if g.memory_total else 0
+            mc = "red" if mp >= 90 else "yellow" if mp >= 70 else "green"
+            tc = "red" if g.temperature >= 85 else "yellow" if g.temperature >= 70 else "green"
+            pc = "green" if g.power_draw < 100 else "yellow" if g.power_draw < 250 else "bright_red" if g.power_draw < 350 else "red"
+
+            line = f"[bold]GPU {g.index}[/]  {bar(g.utilization, 20, uc)} {g.utilization:4.0f}%  "
+            line += f"VRAM {bar(mp, 15, mc)} {g.memory_used/1024:.1f}/{g.memory_total/1024:.1f}GB  "
+            line += f"[{tc}]{g.temperature}°C[/]  [{pc}]{g.power_draw:.0f}W[/]"
+            parts.append(line)
+
+    return Panel("\n".join(parts), title=f"[bold]{job.job_id[:24]}[/]", border_style="blue", box=box.ROUNDED)
+
+
+def build_status_panel(status: JobStatus, height: int = 10) -> Panel:
+    """Build the job status panel showing workflow progress"""
+    parts = []
+
+    if status.progress > 0:
+        prog_bar = bar(status.progress, 30, "cyan")
+        parts.append(f"[bold]{status.stage}[/]  {prog_bar} {status.progress:.0f}%")
+    else:
+        parts.append(f"[bold cyan]{status.stage}[/]")
+
+    if status.message:
+        parts.append(f"  {status.message}")
+
+    if status.error:
+        parts.append(f"\n[bold red]Error:[/] {status.error}")
+
+    if status.history:
+        parts.append("")
+        visible_history = status.history[-(height - 4):]
+        for msg in visible_history:
+            parts.append(f"[dim]  {msg}[/]")
+
+    border = "green" if status.complete else "red" if status.error else "magenta"
+    title = "[bold]Status[/]"
+    if status.complete:
+        title = "[bold green]Complete[/]"
+    elif status.error:
+        title = "[bold red]Failed[/]"
+
+    return Panel("\n".join(parts), title=title, border_style=border, box=box.ROUNDED)
+
+
+def build_layout(job, elapsed, metrics, logs, ws_status, job_status, content_height) -> Layout:
+    """Build the full layout"""
+    layout = Layout()
+    header = build_header(job, elapsed, metrics)
+    header_height = 3 + (len(metrics.gpus) if metrics and metrics.gpus else 0) + (1 if metrics and metrics.system else 0)
+
+    if job_status:
+        log_lines = int(content_height * 0.7)
+        log_content = "\n".join(list(logs)[-log_lines:]) if logs else "[dim]Waiting for logs...[/]"
+        log_panel = Panel(log_content, title=f"[bold]Logs[/] ({ws_status})", border_style="yellow", box=box.ROUNDED, height=content_height + 2)
+
+        status_panel = build_status_panel(job_status, content_height)
+        content_layout = Layout()
+        content_layout.split_row(
+            Layout(log_panel, name="logs", ratio=2),
+            Layout(status_panel, name="status", ratio=1),
+        )
+        layout.split_column(
+            Layout(header, name="header", size=header_height + 2),
+            content_layout,
+        )
+    else:
+        log_content = "\n".join(list(logs)[-content_height:]) if logs else "[dim]Waiting for logs...[/]"
+        log_panel = Panel(log_content, title=f"[bold]Logs[/] ({ws_status})", border_style="yellow", box=box.ROUNDED, height=content_height + 2)
+
+        layout.split_column(
+            Layout(header, name="header", size=header_height + 2),
+            Layout(log_panel, name="logs"),
+        )
+
+    return layout
+
+
+async def _run_job_monitor_async(
+    job_id: str,
+    status_q: Queue = None,
+    stop_on_status_complete: bool = False,
+):
+    """Async job monitor - uses SDK LogStream for logs"""
+    c3 = C3()
+    logs: deque[str] = deque(maxlen=MAX_LOG_LINES)
+    log_stream: Optional[LogStream] = None
+    log_task: Optional[asyncio.Task] = None
+    metrics = None
+    job_status: Optional[JobStatus] = None
+    ws_status = "[dim]● waiting[/]"
+    stop_event = asyncio.Event()
+
+    console.print(f"[dim]Ctrl+C to exit[/]\n")
+
+    # Wait for job
+    job = None
+    with console.status("[cyan]Connecting..."):
+        while not job:
+            try:
+                job = c3.jobs.get(job_id)
+            except Exception:
+                await asyncio.sleep(1)
+
+    async def stream_logs_task(stream: LogStream):
+        """Background task that streams logs continuously with batching"""
+        nonlocal ws_status
+        log_batch = []
+        last_flush = asyncio.get_event_loop().time()
+        FLUSH_INTERVAL = 0.05  # Flush every 50ms
+
+        try:
+            async for line in stream:
+                if stop_event.is_set():
+                    break
+                log_batch.append(line)
+
+                # Flush batch periodically
+                now = asyncio.get_event_loop().time()
+                if now - last_flush >= FLUSH_INTERVAL:
+                    logs.extend(log_batch)
+                    log_batch.clear()
+                    last_flush = now
+
+            # Flush remaining
+            if log_batch:
+                logs.extend(log_batch)
+        except Exception:
+            pass
+        finally:
+            ws_status = "[dim]● ended[/]"
+
+    async def fetch_metrics_task():
+        """Background task that fetches metrics periodically"""
+        nonlocal metrics
+        while not stop_event.is_set():
+            try:
+                if job and job.state in ("assigned", "running"):
+                    metrics = await asyncio.to_thread(c3.jobs.metrics, job_id)
+            except Exception:
+                pass
+            await asyncio.sleep(2)
+
+    async def fetch_job_task():
+        """Background task that fetches job state periodically"""
+        nonlocal job, log_stream, log_task, ws_status
+        while not stop_event.is_set():
+            try:
+                job = await asyncio.to_thread(c3.jobs.get, job_id)
+
+                # Start log stream when job is ready
+                if job.state in ("assigned", "running") and log_stream is None and job.job_key:
+                    # Fetch initial logs ONCE
+                    if job.state == "running":
+                        initial = await asyncio.to_thread(fetch_logs, c3, job_id, MAX_LOG_LINES)
+                        for line in initial:
+                            logs.append(line)
+
+                    # Connect websocket and start streaming task
+                    log_stream = LogStream(
+                        c3, job_id,
+                        job_key=job.job_key,
+                        fetch_initial=False,
+                        max_buffer=MAX_LOG_LINES,
+                    )
+                    await log_stream.connect()
+                    log_task = asyncio.create_task(stream_logs_task(log_stream))
+                    ws_status = "[green]● live[/]"
+            except Exception:
+                pass
+            await asyncio.sleep(1)
+
+    try:
+        # Start background tasks
+        metrics_task = asyncio.create_task(fetch_metrics_task())
+        job_task = asyncio.create_task(fetch_job_task())
+
+        with Live(console=console, refresh_per_second=10, screen=True) as live:
+            while True:
+                try:
+                    elapsed = int(time.time() - job.started_at) if job and job.started_at else 0
+
+                    # Drain status queue if provided
+                    if status_q:
+                        while True:
+                            try:
+                                job_status = status_q.get_nowait()
+                            except Empty:
+                                break
+
+                    # Calculate layout
+                    term_height = console.size.height
+                    header_height = 3 + (len(metrics.gpus) if metrics and metrics.gpus else 0) + (1 if metrics and metrics.system else 0)
+                    content_height = max(10, term_height - header_height - 4)
+
+                    # Update display
+                    if job:
+                        layout = build_layout(job, elapsed, metrics, logs, ws_status, job_status, content_height)
+                        live.update(layout)
+
+                    # Check completion
+                    if stop_on_status_complete and job_status and job_status.complete:
+                        await asyncio.sleep(3)
+                        break
+
+                    # Job terminated
+                    if job and job.state in ("succeeded", "failed", "canceled", "terminated"):
+                        # Fetch final logs ONCE
+                        final = await asyncio.to_thread(fetch_logs, c3, job_id, MAX_LOG_LINES)
+                        logs.clear()
+                        for line in final:
+                            logs.append(line)
+                        ws_status = "[dim]● ended[/]"
+
+                        layout = build_layout(job, elapsed, metrics, logs, ws_status, job_status, content_height)
+                        live.update(layout)
+                        await asyncio.sleep(1)
+                        break
+
+                except KeyboardInterrupt:
+                    raise
+                except Exception as e:
+                    console.print(f"[red]{e}[/]")
+
+                await asyncio.sleep(0.05)  # 20fps render loop
+
+        console.print(f"\n[bold]Job {job.state}[/]")
+
+    except KeyboardInterrupt:
+        console.print("\n[dim]Stopped[/]")
+    finally:
+        stop_event.set()
+        if log_task:
+            log_task.cancel()
+        if log_stream:
+            await log_stream.close()
+        metrics_task.cancel()
+        job_task.cancel()
+
+
+def run_job_monitor(
+    job_id: str,
+    status_q: Queue = None,
+    stop_on_status_complete: bool = False,
+):
+    """Run the job monitor TUI (sync wrapper).
+
+    Args:
+        job_id: The job ID to monitor
+        status_q: Optional queue receiving JobStatus updates for status pane
+        stop_on_status_complete: If True, exit when JobStatus.complete is True
+    """
+    asyncio.run(_run_job_monitor_async(job_id, status_q, stop_on_status_complete))

c3cli/user.py

@@ -0,0 +1,19 @@
+"""c3 user commands"""
+import typer
+from c3 import C3
+from .output import output, spinner
+
+app = typer.Typer(help="User account commands")
+
+
+@app.callback(invoke_without_command=True)
+def user_info(
+    ctx: typer.Context,
+    fmt: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
+):
+    """Get current user info"""
+    if ctx.invoked_subcommand is None:
+        c3 = C3()
+        with spinner("Fetching user info..."):
+            user = c3.user.get()
+        output(user, fmt)