hypercli-cli 0.4.6__tar.gz → 0.4.7__tar.gz

{hypercli_cli-0.4.6 → hypercli_cli-0.4.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypercli-cli
-Version: 0.4.6
+Version: 0.4.7
 Summary: CLI for HyperCLI - GPU orchestration and LLM API
 Project-URL: Homepage, https://hypercli.com
 Project-URL: Documentation, https://docs.hypercli.com

{hypercli_cli-0.4.6 → hypercli_cli-0.4.7}/hypercli_cli/billing.py

@@ -1,13 +1,13 @@
 """hyper billing commands"""
 import typer
-from hypercli import C3
+from hypercli import HyperCLI
 from .output import output, console, spinner
 
 app = typer.Typer(help="Billing and balance commands")
 
 
-def get_client() -> C3:
-    return C3()
+def get_client() -> HyperCLI:
+    return HyperCLI()
 
 
 @app.command("balance")

{hypercli_cli-0.4.6 → hypercli_cli-0.4.7}/hypercli_cli/cli.py

@@ -1,10 +1,10 @@
-"""C3 CLI - Main entry point"""
+"""HyperCLI - Main entry point"""
 import sys
 import typer
 from rich.console import Console
 from rich.prompt import Prompt
 
-from hypercli import C3, APIError, configure
+from hypercli import HyperCLI, APIError, configure
 from hypercli.config import CONFIG_FILE
 
 from . import billing, comfyui, instances, jobs, llm, renders, user
@@ -49,8 +49,8 @@ def fuzzy_match(input_str: str, options: list[str], threshold: float = 0.5) -> l
     return [opt for opt, _ in matches[:3]]
 
 app = typer.Typer(
-    name="c3",
-    help="HyperCLI CLI - GPU orchestration and LLM API",
+    name="hyper",
+    help="HyperCLI - GPU orchestration and LLM API",
     no_args_is_help=True,
     rich_markup_mode="rich",
 )
@@ -67,11 +67,11 @@ app.add_typer(user.app, name="user")
 
 @app.command("configure")
 def configure_cmd():
-    """Configure C3 CLI with your API key and API URL"""
+    """Configure HyperCLI with your API key and API URL"""
     import getpass
     from hypercli.config import get_api_key, get_api_url, DEFAULT_API_URL
 
-    console.print("\n[bold cyan]C3 CLI Configuration[/bold cyan]\n")
+    console.print("\n[bold cyan]HyperCLI Configuration[/bold cyan]\n")
 
     # Show current config
     current_key = get_api_key()
@@ -111,7 +111,7 @@ def configure_cmd():
         console.print(f"  API key: {preview}")
     if final_url:
         console.print(f"  API URL: {final_url}")
-    console.print("\nTest your setup with: [cyan]c3 billing balance[/cyan]\n")
+    console.print("\nTest your setup with: [cyan]hyper billing balance[/cyan]\n")
 
 
 @app.callback()
@@ -119,19 +119,19 @@ def main(
     version: bool = typer.Option(False, "--version", "-v", help="Show version"),
 ):
     """
-    [bold cyan]C3 CLI[/bold cyan] - HyperCLI GPU orchestration and LLM API
+    [bold cyan]HyperCLI[/bold cyan] - GPU orchestration and LLM API
 
-    Set your API key: [green]c3 configure[/green]
+    Set your API key: [green]hyper configure[/green]
 
     Get started:
-        c3 instances list      Browse available GPUs
-        c3 instances launch    Launch a GPU instance
-        c3 jobs list           View your running jobs
-        c3 llm chat -i         Start a chat
+        hyper instances list      Browse available GPUs
+        hyper instances launch    Launch a GPU instance
+        hyper jobs list           View your running jobs
+        hyper llm chat -i         Start a chat
     """
     if version:
         from . import __version__
-        console.print(f"c3 version {__version__}")
+        console.print(f"hyper version {__version__}")
         raise typer.Exit()
 
 
@@ -167,7 +167,7 @@ def cli():
         # Check for region errors
         if "region" in detail.lower() and "not found" in detail.lower():
             console.print(f"[bold red]Error:[/bold red] {detail}")
-            console.print("\n[dim]Tip: Use 'c3 jobs regions' to see available regions[/dim]")
+            console.print("\n[dim]Tip: Use 'hyper jobs regions' to see available regions[/dim]")
             sys.exit(1)
 
         # Generic API error

{hypercli_cli-0.4.6 → hypercli_cli-0.4.7}/hypercli_cli/comfyui.py

@@ -7,15 +7,15 @@ from typing import Optional
 
 import typer
 
-from hypercli import C3, ComfyUIJob, APIError, apply_params, apply_graph_modes, load_template, graph_to_api
+from hypercli import HyperCLI, ComfyUIJob, APIError, apply_params, apply_graph_modes, load_template, graph_to_api
 from .output import console, error, success, spinner
 from .tui import JobStatus, run_job_monitor
 
 app = typer.Typer(help="Run ComfyUI workflows on GPU")
 
 
-def get_client() -> C3:
-    return C3()
+def get_client() -> HyperCLI:
+    return HyperCLI()
 
 
 def _run_workflow(
@@ -220,14 +220,16 @@ def run(
     gpu_count: int = typer.Option(1, "--count", help="Number of GPUs"),
     interruptible: bool = typer.Option(True, "--interruptible/--on-demand", help="Use interruptible instances"),
     region: Optional[str] = typer.Option(None, "--region", help="Region (e.g., us-east, eu-west, asia-east)"),
+    runtime: int = typer.Option(3600, "--runtime", help="Instance runtime in seconds"),
     output_dir: str = typer.Option(".", "--output-dir", "-d", help="Output directory"),
-    timeout: int = typer.Option(600, "--timeout", "-t", help="Timeout in seconds"),
+    timeout: int = typer.Option(600, "--timeout", "-t", help="Workflow timeout in seconds"),
     num: int = typer.Option(1, "--num", "-N", help="Number of images to generate"),
     new: bool = typer.Option(False, "--new", help="Always launch new instance"),
     instance: Optional[str] = typer.Option(None, "--instance", "-i", help="Connect to job by ID, hostname, or IP"),
-    lb: Optional[int] = typer.Option(None, "--lb", help="Enable HTTPS load balancer on port (e.g., 8188)"),
-    auth: bool = typer.Option(False, "--auth", help="Enable Bearer token auth on load balancer"),
+    lb: int = typer.Option(8188, "--lb", help="HTTPS load balancer port (default: 8188, use 0 to disable)"),
+    auth: bool = typer.Option(True, "--auth/--no-auth", help="Bearer token auth (default: enabled)"),
     stdout: bool = typer.Option(False, "--stdout", help="Output to stdout instead of TUI"),
+    cancel_on_exit: bool = typer.Option(False, "--cancel-on-exit", help="Cancel job when exiting with Ctrl+C"),
     debug: bool = typer.Option(False, "--debug", help="Debug mode: stdout + verbose errors"),
     workflow_json: bool = typer.Option(False, "--workflow-json", help="Output generated workflow JSON and exit (don't run)"),
     nodes: Optional[str] = typer.Option(None, "--nodes", help="Node-specific params as JSON: '{\"node_id\": {\"image\": \"file.png\"}}'"),
@@ -301,24 +303,28 @@ def run(
 
     # Get or create job
     try:
+        # lb=0 means disabled
+        lb_port = lb if lb else None
+
         if instance:
             # Connect to specific instance by ID, hostname, or IP
             with spinner(f"Connecting to instance {instance}..."):
-                job = ComfyUIJob.get_by_instance(c3, instance)
+                job = ComfyUIJob.get_by_instance(client, instance)
                 job.template = template
-                job.use_lb = lb is not None
+                job.use_lb = lb_port is not None
                 job.use_auth = auth
         else:
             # Get or create job with template env var
             with spinner(f"Getting ComfyUI instance for {template}..."):
                 job = ComfyUIJob.get_or_create_for_template(
-                    c3,
+                    client,
                     template=template,
                     gpu_type=gpu_type,
                     gpu_count=gpu_count,
                     region=region,
+                    runtime=runtime,
                     reuse=not new,
-                    lb=lb,
+                    lb=lb_port,
                     auth=auth,
                     interruptible=interruptible,
                 )
@@ -438,26 +444,39 @@ def run(
             seed_info = f"seed: {iteration_seed}" if iteration_seed else "default seed"
             console.print(f"\n[bold]Image {i+1}/{num}[/bold] ({seed_info})")
 
-        if stdout or debug:
-            # Simple mode without TUI
-            _run_simple(job, template, params, timeout, Path(output_dir), debug=debug)
-        else:
-            # TUI mode with status pane
-            status_q: Queue = Queue()
-
-            # Start workflow in background thread
-            workflow_thread = threading.Thread(
-                target=_run_workflow,
-                args=(job, template, params, timeout, Path(output_dir), status_q),
-                daemon=True,
-            )
-            workflow_thread.start()
+        try:
+            if stdout or debug:
+                # Simple mode without TUI
+                _run_simple(job, template, params, timeout, Path(output_dir), debug=debug)
+            else:
+                # TUI mode with status pane
+                status_q: Queue = Queue()
+
+                # Start workflow in background thread
+                workflow_thread = threading.Thread(
+                    target=_run_workflow,
+                    args=(job, template, params, timeout, Path(output_dir), status_q),
+                    daemon=True,
+                )
+                workflow_thread.start()
 
-            # Run TUI in main thread
-            run_job_monitor(job.job_id, status_q=status_q, stop_on_status_complete=True)
+                # Run TUI in main thread
+                run_job_monitor(job.job_id, status_q=status_q, stop_on_status_complete=True, cancel_on_exit=cancel_on_exit)
 
-            # Wait for workflow thread to finish
-            workflow_thread.join(timeout=5)
+                # Wait for workflow thread to finish
+                workflow_thread.join(timeout=5)
+        except KeyboardInterrupt:
+            console.print("\n[dim]Interrupted[/dim]")
+            if cancel_on_exit:
+                try:
+                    job.refresh()
+                    if job.job.state in ("queued", "assigned", "running"):
+                        console.print("[yellow]Cancelling job...[/yellow]")
+                        client.jobs.cancel(job.job_id)
+                        console.print("[green]Job cancelled[/green]")
+                except Exception as e:
+                    console.print(f"[red]Failed to cancel: {e}[/red]")
+            raise typer.Exit(1)
 
 
 def _run_simple(job: ComfyUIJob, template: str, params: dict, timeout: int, output_dir: Path, debug: bool = False):
@@ -680,7 +699,7 @@ def status():
     client = get_client()
 
     with spinner("Checking for running jobs..."):
-        job = ComfyUIJob.get_running(c3)
+        job = ComfyUIJob.get_running(client)
 
     if not job:
         console.print("[dim]No running ComfyUI job[/dim]")
@@ -717,10 +736,10 @@ def download(
     # Get job
     if instance:
         with spinner(f"Connecting to {instance}..."):
-            job = ComfyUIJob.get_by_instance(c3, instance)
+            job = ComfyUIJob.get_by_instance(client, instance)
     else:
         with spinner("Finding running job..."):
-            job = ComfyUIJob.get_running(c3)
+            job = ComfyUIJob.get_running(client)
         if not job:
             error("No running ComfyUI job found. Use --instance to specify one.")
             raise typer.Exit(1)
@@ -809,7 +828,7 @@ def stop():
     client = get_client()
 
     with spinner("Finding running job..."):
-        job = ComfyUIJob.get_running(c3)
+        job = ComfyUIJob.get_running(client)
 
     if not job:
         console.print("[dim]No running ComfyUI job[/dim]")

{hypercli_cli-0.4.6 → hypercli_cli-0.4.7}/hypercli_cli/instances.py

@@ -1,14 +1,14 @@
 """hyper instances commands"""
 import typer
 from typing import Optional
-from hypercli import C3
+from hypercli import HyperCLI
 from .output import output, console, success, spinner
 
 app = typer.Typer(help="GPU instances - browse and launch")
 
 
-def get_client() -> C3:
-    return C3()
+def get_client() -> HyperCLI:
+    return HyperCLI()
 
 
 @app.command("list")
@@ -140,6 +140,7 @@ def launch(
     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"),
+    cancel_on_exit: bool = typer.Option(False, "--cancel-on-exit", help="Cancel job when exiting with Ctrl+C"),
     fmt: str = typer.Option("table", "--output", "-o", help="Output format: table|json"),
 ):
     """Launch a new GPU instance"""
@@ -190,4 +191,4 @@ def launch(
     if follow:
         console.print()
         from .tui.job_monitor import run_job_monitor
-        run_job_monitor(job.job_id)
+        run_job_monitor(job.job_id, cancel_on_exit=cancel_on_exit)

{hypercli_cli-0.4.6 → hypercli_cli-0.4.7}/hypercli_cli/jobs.py

@@ -1,14 +1,14 @@
 """hyper jobs commands"""
 import typer
 from typing import Optional
-from hypercli import C3
+from hypercli import HyperCLI
 from .output import output, console, success, spinner
 
 app = typer.Typer(help="Manage running jobs")
 
 
-def get_client() -> C3:
-    return C3()
+def get_client() -> HyperCLI:
+    return HyperCLI()
 
 
 @app.command("list")
@@ -46,12 +46,13 @@ def get_job(
 def logs(
     job_id: str = typer.Argument(..., help="Job ID"),
     follow: bool = typer.Option(False, "--follow", "-f", help="Stream logs"),
+    cancel_on_exit: bool = typer.Option(False, "--cancel-on-exit", help="Cancel job when exiting with Ctrl+C"),
 ):
     """Get job logs"""
     client = get_client()
 
     if follow:
-        _follow_job(job_id)
+        _follow_job(job_id, cancel_on_exit=cancel_on_exit)
     else:
         with spinner("Fetching logs..."):
             logs_str = client.jobs.logs(job_id)
@@ -167,10 +168,10 @@ def _make_bar(value: float, max_val: float, warn: float = None, crit: float = No
     return f"[{color}]{bar}[/{color}]"
 
 
-def _follow_job(job_id: str):
+def _follow_job(job_id: str, cancel_on_exit: bool = False):
     """Follow job with TUI"""
     from .tui.job_monitor import run_job_monitor
-    run_job_monitor(job_id)
+    run_job_monitor(job_id, cancel_on_exit=cancel_on_exit)
 
 
 def _watch_metrics(job_id: str):

{hypercli_cli-0.4.6 → hypercli_cli-0.4.7}/hypercli_cli/llm.py

@@ -9,10 +9,10 @@ app = typer.Typer(help="LLM API commands")
 
 
 def get_openai_client() -> OpenAI:
-    """Get OpenAI client configured for C3"""
+    """Get OpenAI client configured for HyperCLI"""
     api_key = get_api_key()
     if not api_key:
-        raise typer.Exit("HYPERCLI_API_KEY not set. Run: c3 configure")
+        raise typer.Exit("HYPERCLI_API_KEY not set. Run: hyper configure")
 
     base_url = get_api_url()
     return OpenAI(api_key=api_key, base_url=f"{base_url}/v1")
@@ -126,7 +126,7 @@ def _interactive_chat(client: OpenAI, model: Optional[str], system: Optional[str
             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]")
+    console.print("\n[bold cyan]HyperCLI Chat[/bold cyan]")
     show_status()
     console.print("[dim]Type /help for commands, /quit to exit[/dim]\n")
 

{hypercli_cli-0.4.6 → hypercli_cli-0.4.7}/hypercli_cli/renders.py

@@ -2,14 +2,14 @@
 import time
 import typer
 from typing import Optional
-from hypercli import C3
+from hypercli import HyperCLI
 from .output import output, console, success, spinner
 
 app = typer.Typer(help="Manage renders")
 
 
-def get_client() -> C3:
-    return C3()
+def get_client() -> HyperCLI:
+    return HyperCLI()
 
 
 @app.command("list")
@@ -77,7 +77,7 @@ def create_render(
         console.print(f"  State: {render.state}")
 
     if wait:
-        _wait_for_render(c3, render.render_id, fmt)
+        _wait_for_render(client, render.render_id, fmt)
 
 
 @app.command("status")
@@ -90,7 +90,7 @@ def status(
     client = get_client()
 
     if watch:
-        _watch_status(c3, render_id)
+        _watch_status(client, render_id)
     else:
         with spinner("Fetching status..."):
             s = client.renders.status(render_id)
@@ -108,7 +108,7 @@ def cancel(
     success(f"Render {render_id} cancelled")
 
 
-def _wait_for_render(c3: C3, render_id: str, fmt: str, poll_interval: float = 2.0):
+def _wait_for_render(client: HyperCLI, render_id: str, fmt: str, poll_interval: float = 2.0):
     """Wait for render to complete"""
     console.print("Waiting for completion...")
 
@@ -138,7 +138,7 @@ def _wait_for_render(c3: C3, render_id: str, fmt: str, poll_interval: float = 2.
                 console.print(f"  Error: {render.error}")
 
 
-def _watch_status(c3: C3, render_id: str, poll_interval: float = 2.0):
+def _watch_status(client: HyperCLI, render_id: str, poll_interval: float = 2.0):
     """Watch render status live"""
     from rich.live import Live
     from rich.panel import Panel

{hypercli_cli-0.4.6 → hypercli_cli-0.4.7}/hypercli_cli/tui/job_monitor.py

@@ -12,7 +12,7 @@ from rich.panel import Panel
 from rich.layout import Layout
 from rich import box
 
-from hypercli import C3, LogStream, fetch_logs
+from hypercli import HyperCLI, LogStream, fetch_logs
 
 console = Console()
 
@@ -70,7 +70,7 @@ def build_header(job, elapsed: int, metrics) -> Panel:
         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"[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)
 
@@ -162,9 +162,11 @@ async def _run_job_monitor_async(
     job_id: str,
     status_q: Queue = None,
     stop_on_status_complete: bool = False,
+    cancel_on_exit: bool = False,
 ):
     """Async job monitor - uses SDK LogStream for logs"""
-    client = C3()
+    client = HyperCLI()
+    should_cancel = False
     logs: deque[str] = deque(maxlen=MAX_LOG_LINES)
     log_stream: Optional[LogStream] = None
     log_task: Optional[asyncio.Task] = None
@@ -173,7 +175,8 @@ async def _run_job_monitor_async(
     ws_status = "[dim]● waiting[/]"
     stop_event = asyncio.Event()
 
-    console.print(f"[dim]Ctrl+C to exit[/]\n")
+    exit_msg = "Ctrl+C to exit and cancel job" if cancel_on_exit else "Ctrl+C to exit (job keeps running)"
+    console.print(f"[dim]{exit_msg}[/]\n")
 
     # Wait for job
     job = None
@@ -185,28 +188,15 @@ async def _run_job_monitor_async(
                 await asyncio.sleep(1)
 
     async def stream_logs_task(stream: LogStream):
-        """Background task that streams logs continuously with batching"""
+        """Background task that streams logs continuously"""
         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)
+                # Append directly - the deque handles thread safety
+                logs.append(line)
         except Exception:
             pass
         finally:
@@ -226,6 +216,8 @@ async def _run_job_monitor_async(
     async def fetch_job_task():
         """Background task that fetches job state periodically"""
         nonlocal job, log_stream, log_task, ws_status
+        ws_retries = 0
+        initial_logs_fetched = False
         while not stop_event.is_set():
             try:
                 job = await asyncio.to_thread(client.jobs.get, job_id)
@@ -233,21 +225,35 @@ async def _run_job_monitor_async(
                 # 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)
+                    if job.state == "running" and not initial_logs_fetched:
+                        initial = await asyncio.to_thread(fetch_logs, client, job_id, MAX_LOG_LINES)
                         for line in initial:
                             logs.append(line)
+                        initial_logs_fetched = True
 
                     # Connect websocket and start streaming task
-                    log_stream = LogStream(
-                        c3, job_id,
+                    temp_stream = LogStream(
+                        client, 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[/]"
+                    try:
+                        retry_msg = f" (retry {ws_retries})" if ws_retries > 0 else ""
+                        ws_status = f"[yellow]● connecting{retry_msg}...[/]"
+                        await temp_stream.connect()
+                        log_stream = temp_stream
+                        log_task = asyncio.create_task(stream_logs_task(log_stream))
+                        ws_status = "[green]● live[/]"
+                        ws_retries = 0
+                    except asyncio.TimeoutError:
+                        ws_retries += 1
+                        ws_status = f"[red]● timeout (retry {ws_retries})[/]"
+                        await asyncio.sleep(2)  # Wait before retry
+                    except Exception as e:
+                        ws_retries += 1
+                        ws_status = f"[red]● error (retry {ws_retries})[/]"
+                        await asyncio.sleep(2)  # Wait before retry
             except Exception:
                 pass
             await asyncio.sleep(1)
@@ -288,7 +294,7 @@ async def _run_job_monitor_async(
                     # 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)
+                        final = await asyncio.to_thread(fetch_logs, client, job_id, MAX_LOG_LINES)
                         logs.clear()
                         for line in final:
                             logs.append(line)
@@ -309,6 +315,7 @@ async def _run_job_monitor_async(
         console.print(f"\n[bold]Job {job.state}[/]")
 
     except KeyboardInterrupt:
+        should_cancel = cancel_on_exit
         console.print("\n[dim]Stopped[/]")
     finally:
         stop_event.set()
@@ -319,11 +326,20 @@ async def _run_job_monitor_async(
         metrics_task.cancel()
         job_task.cancel()
 
+        if should_cancel and job and job.state in ("queued", "assigned", "running"):
+            console.print("[yellow]Cancelling job...[/]")
+            try:
+                client.jobs.cancel(job_id)
+                console.print("[green]Job cancelled[/]")
+            except Exception as e:
+                console.print(f"[red]Failed to cancel: {e}[/]")
+
 
 def run_job_monitor(
     job_id: str,
     status_q: Queue = None,
     stop_on_status_complete: bool = False,
+    cancel_on_exit: bool = False,
 ):
     """Run the job monitor TUI (sync wrapper).
 
@@ -331,5 +347,6 @@ def run_job_monitor(
         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
+        cancel_on_exit: If True, cancel the job when exiting via Ctrl+C
     """
-    asyncio.run(_run_job_monitor_async(job_id, status_q, stop_on_status_complete))
+    asyncio.run(_run_job_monitor_async(job_id, status_q, stop_on_status_complete, cancel_on_exit))

{hypercli_cli-0.4.6 → hypercli_cli-0.4.7}/hypercli_cli/user.py

@@ -1,6 +1,6 @@
 """hyper user commands"""
 import typer
-from hypercli import C3
+from hypercli import HyperCLI
 from .output import output, spinner
 
 app = typer.Typer(help="User account commands")
@@ -13,7 +13,7 @@ def user_info(
 ):
     """Get current user info"""
     if ctx.invoked_subcommand is None:
-        client = C3()
+        client = HyperCLI()
         with spinner("Fetching user info..."):
             user = client.user.get()
         output(user, fmt)

{hypercli_cli-0.4.6 → hypercli_cli-0.4.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hypercli-cli"
-version = "0.4.6"
+version = "0.4.7"
 description = "CLI for HyperCLI - GPU orchestration and LLM API"
 readme = "README.md"
 requires-python = ">=3.10"