lyceum-cli 1.0.24__py3-none-any.whl → 1.0.26__py3-none-any.whl

lyceum/external/auth/login.py

@@ -338,12 +338,12 @@ def login(
             headers = {"Authorization": f"Bearer {config.api_key}"}
             response = httpx.get(f"{config.base_url}/api/v2/external/machine-types", headers=headers, timeout=10.0)
             if response.status_code == 200:
-                console.print("[green]✅ Successfully authenticated![/green]")
+                console.print("[green]Successfully authenticated![/green]")
             else:
-                console.print(f"[red]❌ Authentication failed: HTTP {response.status_code}[/red]")
+                console.print(f"[red]Authentication failed: HTTP {response.status_code}[/red]")
                 raise typer.Exit(1)
         except Exception as e:
-            console.print(f"[red]❌ Authentication failed: {e}[/red]")
+            console.print(f"[red]Authentication failed: {e}[/red]")
             raise typer.Exit(1)
         return
 
@@ -377,7 +377,7 @@ def login(
 
         # Open browser
         if not webbrowser.open(login_url):
-            console.print("[yellow]⚠️  Could not open browser automatically[/yellow]")
+            console.print("[yellow]Could not open browser automatically[/yellow]")
             console.print(f"[yellow]Please manually open: {login_url}[/yellow]")
 
         console.print("[dim]Waiting for authentication... (timeout: 120 seconds)[/dim]")
@@ -402,7 +402,7 @@ def login(
                     config.refresh_token = callback_result["refresh_token"]
                 config.save()
 
-                console.print("[green]✅ Authentication token received![/green]")
+                console.print("[green]Authentication token received![/green]")
 
                 # Test the connection using health endpoint
                 try:
@@ -417,37 +417,37 @@ def login(
                             headers=headers
                         )
                         if response.status_code == 200:
-                            console.print("[green]✅ Successfully authenticated![/green]")
+                            console.print("[green]Successfully authenticated![/green]")
                             if callback_result.get("user"):
                                 console.print(f"[dim]Logged in as: {callback_result['user']}[/dim]")
                         else:
-                            console.print(f"[red]❌ Token validation failed: HTTP {response.status_code}[/red]")
+                            console.print(f"[red]Token validation failed: HTTP {response.status_code}[/red]")
                             console.print(f"[dim]Response: {response.text}[/dim]")
                             raise typer.Exit(1)
                     finally:
                         client.close()
                 except httpx.TimeoutException as e:
-                    console.print(f"[yellow]⚠️  Token validation timed out: {e}[/yellow]")
+                    console.print(f"[yellow]Token validation timed out: {e}[/yellow]")
                     console.print(f"[yellow]Token saved but couldn't verify connectivity to {config.base_url}[/yellow]")
                     console.print("[dim]You can test the connection later with 'lyceum auth status'[/dim]")
                     # Don't exit with error - token was received successfully
                 except Exception as e:
-                    console.print(f"[red]❌ Token validation failed: {e}[/red]")
+                    console.print(f"[red]Token validation failed: {e}[/red]")
                     console.print(f"[dim]Token saved but couldn't verify. Error type: {type(e).__name__}[/dim]")
                     raise typer.Exit(1)
 
             elif callback_result["error"]:
-                console.print(f"[red]❌ Authentication failed: {callback_result['error']}[/red]")
+                console.print(f"[red]Authentication failed: {callback_result['error']}[/red]")
                 raise typer.Exit(1)
         else:
-            console.print("[red]❌ Authentication timed out. Please try again.[/red]")
+            console.print("[red]Authentication timed out. Please try again.[/red]")
             raise typer.Exit(1)
 
     except KeyboardInterrupt:
         console.print("\n[yellow]Authentication cancelled by user.[/yellow]")
         raise typer.Exit(1)
     except Exception as e:
-        console.print(f"[red]❌ Authentication error: {e}[/red]")
+        console.print(f"[red]Authentication error: {e}[/red]")
         raise typer.Exit(1)
 
 
@@ -457,7 +457,7 @@ def logout():
     from ...shared.config import CONFIG_FILE
     if CONFIG_FILE.exists():
         CONFIG_FILE.unlink()
-    console.print("[green]✅ Logged out successfully![/green]")
+    console.print("[green]Logged out successfully![/green]")
 
 
 @auth_app.command("status")
@@ -468,7 +468,7 @@ def status():
     console.print(f"[dim]Base URL: {config.base_url}[/dim]")
 
     if config.api_key:
-        console.print("[green]✅ Authenticated[/green]")
+        console.print("[green]Authenticated[/green]")
         console.print(f"[dim]API Key: {config.api_key[:8]}...[/dim]")
 
         # Test connection
@@ -477,10 +477,10 @@ def status():
             headers = {"Authorization": f"Bearer {config.api_key}"}
             response = httpx.get(f"{config.base_url}/api/v2/external/machine-types", headers=headers, timeout=10.0)
             if response.status_code == 200:
-                console.print("[green]✅ API connection working[/green]")
+                console.print("[green]API connection working[/green]")
             else:
-                console.print(f"[yellow]⚠️  API connection issues: HTTP {response.status_code}[/yellow]")
+                console.print(f"[yellow]API connection issues: HTTP {response.status_code}[/yellow]")
         except Exception as e:
-            console.print(f"[red]❌ API connection failed: {e}[/red]")
+            console.print(f"[red]API connection failed: {e}[/red]")
     else:
-        console.print("[red]❌ Not authenticated. Run 'lyceum login' first.[/red]")
+        console.print("[red]Not authenticated. Run 'lyceum auth login' first.[/red]")

lyceum/external/compute/execution/docker_compose.py

@@ -0,0 +1,263 @@
+"""
+Docker Compose execution commands
+"""
+
+import json
+from pathlib import Path
+from typing import Optional
+
+import httpx
+import typer
+from rich.console import Console
+
+from ....shared.config import config
+from ....shared.streaming import StatusLine, stream_execution_output
+
+console = Console()
+
+
+compose_app = typer.Typer(name="compose", help="Docker Compose execution commands")
+
+
+@compose_app.command("run")
+def run_docker_compose(
+    compose_file: Path = typer.Argument(
+        ...,
+        help="Path to docker-compose.yml file",
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        readable=True
+    ),
+    machine_type: str = typer.Option(
+        "cpu", "--machine", "-m", help="Machine type (cpu, a100, h100, etc.)"
+    ),
+    timeout: int = typer.Option(
+        300, "--timeout", "-t", help="Execution timeout in seconds"
+    ),
+    file_name: Optional[str] = typer.Option(
+        None, "--file-name", "-f", help="Name for the execution"
+    ),
+    detach: bool = typer.Option(
+        False, "--detach", "-d", help="Run in background and print execution ID"
+    ),
+    callback_url: Optional[str] = typer.Option(
+        None, "--callback", help="Webhook URL for completion notification"
+    ),
+    registry_creds: Optional[str] = typer.Option(
+        None, "--registry-creds", help="Docker registry credentials as JSON string"
+    ),
+    registry_type: Optional[str] = typer.Option(
+        None, "--registry-type", help="Registry credential type: basic, aws, etc."
+    ),
+):
+    """Execute a Docker Compose application on Lyceum Cloud.
+
+    By default, streams container output in real-time.
+    Use --detach to run in background and return immediately.
+
+    Examples:
+        lyceum compose run docker-compose.yml
+        lyceum compose run ./app/docker-compose.yml -m a100
+        lyceum compose run compose.yml --registry-type basic --registry-creds '{"username":"user","password":"pass"}'
+    """
+    status = StatusLine()
+
+    try:
+        config.get_client()
+
+        status.start()
+        status.update("Validating configuration...")
+
+        # Read the compose file
+        try:
+            compose_file_content = compose_file.read_text()
+        except Exception as e:
+            status.stop()
+            console.print(f"[red]Error reading compose file: {e}[/red]")
+            raise typer.Exit(1)
+
+        # Parse registry credentials
+        registry_credentials = None
+        if registry_creds:
+            try:
+                registry_credentials = json.loads(registry_creds)
+            except json.JSONDecodeError:
+                status.stop()
+                console.print(
+                    "[red]Error: Invalid JSON format for registry credentials[/red]"
+                )
+                raise typer.Exit(1)
+
+        # Validate registry credentials and type
+        if (registry_creds and not registry_type) or (
+            registry_type and not registry_creds
+        ):
+            status.stop()
+            console.print(
+                "[red]Error: Both --registry-creds and --registry-type must be provided together[/red]"
+            )
+            raise typer.Exit(1)
+
+        status.update(f"Starting Docker Compose from {compose_file.name}...")
+
+        # Build request for v2 compose API
+        compose_request = {
+            "compose_file_code": compose_file_content,
+            "timeout": timeout,
+            "execution_type": machine_type,
+        }
+
+        if file_name:
+            compose_request["file_name"] = file_name
+        else:
+            compose_request["file_name"] = compose_file.name
+
+        # Handle registry credentials
+        if registry_type and registry_credentials:
+            compose_request["docker_registry_credential_type"] = registry_type
+
+            if registry_type == "aws":
+                creds = registry_credentials
+                compose_request.update(
+                    {
+                        "aws_access_key_id": creds.get("aws_access_key_id"),
+                        "aws_secret_access_key": creds.get("aws_secret_access_key"),
+                        "aws_session_token": creds.get("aws_session_token"),
+                        "aws_region": creds.get("region", "us-east-1"),
+                    }
+                )
+            elif registry_type == "basic":
+                creds = registry_credentials
+                compose_request.update(
+                    {
+                        "docker_username": creds.get("username"),
+                        "docker_password": creds.get("password"),
+                    }
+                )
+
+        # Call the v2 compose endpoint
+        status.update("Submitting execution...")
+
+        response = httpx.post(
+            f"{config.base_url}/api/v2/external/execution/compose/start",
+            json=compose_request,
+            headers={"Authorization": f"Bearer {config.api_key}"},
+            timeout=30.0,
+        )
+
+        if response.status_code != 200:
+            status.stop()
+            console.print(f"[red]Error: HTTP {response.status_code}[/red]")
+            if response.status_code == 401:
+                console.print(
+                    "[red]Authentication failed. Your session may have expired.[/red]"
+                )
+                console.print("[yellow]Run 'lyceum auth login' to re-authenticate.[/yellow]")
+            elif response.content:
+                console.print(f"[red]{response.content.decode()}[/red]")
+            raise typer.Exit(1)
+
+        result = response.json()
+        execution_id = result.get("execution_id")
+        streaming_url = result.get("streaming_url")
+
+        if detach:
+            # Detached mode - just return the execution info
+            status.stop()
+            console.print(f"[dim]Compose file: {compose_file.name}[/dim]")
+            console.print(f"[dim]Machine: {machine_type}[/dim]")
+            console.print(f"[dim]Execution ID: {execution_id}[/dim]")
+            console.print("")
+            console.print(f"[dim]To stream logs:[/dim] lyceum compose logs {execution_id}")
+        else:
+            # Default: stream output in real-time
+            status.stop()
+            success = stream_execution_output(execution_id, streaming_url)
+
+            # Show execution ID at the end
+            console.print(f"[dim]Execution ID: {execution_id}[/dim]")
+
+            if not success:
+                raise typer.Exit(1)
+
+    except typer.Exit:
+        status.stop()
+        raise
+    except Exception as e:
+        status.stop()
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@compose_app.command("logs")
+def compose_logs(
+    execution_id: str = typer.Argument(..., help="Execution ID to stream logs from"),
+):
+    """Stream logs from a running or completed Docker Compose execution.
+
+    Examples:
+        lyceum compose logs 9d73319c-6f1c-4b4c-90e4-044244353ce4
+    """
+    status = StatusLine()
+
+    try:
+        config.get_client()
+
+        status.start()
+        status.update("Connecting to execution...")
+        status.stop()
+
+        # Pass None for streaming_url to use the default v2 endpoint
+        success = stream_execution_output(execution_id, None)
+
+        console.print(f"[dim]Execution ID: {execution_id}[/dim]")
+
+        if not success:
+            raise typer.Exit(1)
+
+    except typer.Exit:
+        status.stop()
+        raise
+    except Exception as e:
+        status.stop()
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@compose_app.command("registry-examples")
+def show_registry_examples():
+    """Show examples of Docker registry credential formats"""
+    console.print("[bold cyan]Docker Registry Credential Examples[/bold cyan]\n")
+
+    console.print("[bold]1. Docker Hub (basic)[/bold]")
+    console.print("Type: [green]basic[/green]")
+    console.print(
+        'Credentials: [yellow]\'{"username": "myuser", "password": "mypassword"}\'[/yellow]\n'
+    )
+
+    console.print("[bold]2. AWS ECR (aws)[/bold]")
+    console.print("Type: [green]aws[/green]")
+    console.print(
+        'Credentials: [yellow]\'{"region": "us-west-2", "aws_access_key_id": "AKIAI...", "aws_secret_access_key": "wJalrX...", "session_token": "optional..."}\'[/yellow]\n'
+    )
+
+    console.print("[bold]3. Private Registry (basic)[/bold]")
+    console.print("Type: [green]basic[/green]")
+    console.print(
+        'Credentials: [yellow]\'{"username": "admin", "password": "secret"}\'[/yellow]\n'
+    )
+
+    console.print("[bold]Example Commands:[/bold]")
+    console.print("# Docker Hub:")
+    console.print(
+        "[dim]lyceum compose run docker-compose.yml --registry-type basic --registry-creds '{\"username\": \"myuser\", \"password\": \"mytoken\"}'[/dim]"
+    )
+    console.print("\n# AWS ECR:")
+    console.print(
+        "[dim]lyceum compose run docker-compose.yml --registry-type aws --registry-creds '{\"region\": \"us-west-2\", \"aws_access_key_id\": \"AKIAI...\", \"aws_secret_access_key\": \"wJalrX...\"}'[/dim]"
+    )
+    console.print("\n# Private Registry:")
+    console.print(
+        "[dim]lyceum compose run docker-compose.yml --registry-type basic --registry-creds '{\"username\": \"admin\", \"password\": \"secret\"}'[/dim]"
+    )

lyceum/external/compute/execution/notebook.py

@@ -0,0 +1,240 @@
+"""
+Jupyter Notebook execution commands
+"""
+
+from typing import Optional
+
+import httpx
+import typer
+from rich.console import Console
+
+from ....shared.config import config
+from ....shared.streaming import StatusLine
+
+console = Console()
+
+notebook_app = typer.Typer(name="notebook", help="Launch Jupyter notebooks on Lyceum Cloud")
+
+# Pre-built Jupyter notebook image (linux/amd64)
+JUPYTER_IMAGE = "jupyter/base-notebook:latest"
+
+
+@notebook_app.command("launch")
+def launch_notebook(
+    machine_type: str = typer.Option(
+        "cpu", "--machine", "-m", help="Machine type (cpu, a100, h100, etc.)"
+    ),
+    timeout: int = typer.Option(
+        600, "--timeout", "-t", help="Session timeout in seconds (max: 600)"
+    ),
+    image: Optional[str] = typer.Option(
+        None, "--image", "-i", help="Custom Jupyter image (default: jupyter/base-notebook)"
+    ),
+    token: str = typer.Option(
+        "lyceum", "--token", help="Jupyter notebook token for authentication"
+    ),
+    port: int = typer.Option(
+        8888, "--port", "-p", help="Port for Jupyter server"
+    ),
+):
+    """Launch a Jupyter notebook server on Lyceum Cloud.
+
+    Starts a Jupyter notebook that you can access in your browser.
+    The notebook URL will be printed once the server is ready.
+
+    Examples:
+        lyceum notebook launch
+        lyceum notebook launch -m h100
+        lyceum notebook launch -m a100 --timeout 7200
+        lyceum notebook launch --image jupyter/scipy-notebook
+    """
+    status = StatusLine()
+
+    try:
+        config.get_client()
+
+        status.start()
+        status.update("Preparing notebook environment...")
+
+        jupyter_image = image or JUPYTER_IMAGE
+
+        # Build the Jupyter start command
+        # Using start-notebook.sh with custom options
+        jupyter_cmd = [
+            "start-notebook.sh",
+            f"--NotebookApp.token={token}",
+            f"--port={port}",
+            "--ip=0.0.0.0",
+            "--no-browser",
+        ]
+
+        # Build request for v2 image API
+        image_request = {
+            "docker_image_ref": jupyter_image,
+            "docker_run_cmd": jupyter_cmd,
+            "timeout": timeout,
+            "execution_type": machine_type,
+        }
+
+        status.update(f"Starting Jupyter on {machine_type}...")
+
+        response = httpx.post(
+            f"{config.base_url}/api/v2/external/execution/image/start",
+            json=image_request,
+            headers={"Authorization": f"Bearer {config.api_key}"},
+            timeout=30.0,
+        )
+
+        if response.status_code != 200:
+            status.stop()
+            console.print(f"[red]Error: HTTP {response.status_code}[/red]")
+            if response.status_code == 401:
+                console.print(
+                    "[red]Authentication failed. Your session may have expired.[/red]"
+                )
+                console.print("[yellow]Run 'lyceum auth login' to re-authenticate.[/yellow]")
+            elif response.content:
+                console.print(f"[red]{response.content.decode()}[/red]")
+            raise typer.Exit(1)
+
+        result = response.json()
+        execution_id = result.get("execution_id")
+
+        # Build the notebook URL immediately
+        notebook_url = f"https://{execution_id}-{port}.port.lyceum.technology"
+        full_url = f"{notebook_url}/?token={token}"
+
+        status.stop()
+
+        # Print URL immediately so user can click it
+        console.print()
+        console.print("[bold green]Notebook starting![/bold green]")
+        console.print()
+        console.print(f"[cyan]{full_url}[/cyan]")
+        console.print()
+        console.print(f"[dim]Execution ID:[/dim] {execution_id}")
+        console.print()
+        console.print("[dim]To stop:[/dim] lyceum notebook stop " + execution_id)
+
+    except typer.Exit:
+        status.stop()
+        raise
+    except Exception as e:
+        status.stop()
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@notebook_app.command("stop")
+def stop_notebook(
+    execution_id: str = typer.Argument(..., help="Execution ID of the notebook to stop"),
+):
+    """Stop a running Jupyter notebook.
+
+    Examples:
+        lyceum notebook stop 9d73319c-6f1c-4b4c-90e4-044244353ce4
+    """
+    status = StatusLine()
+
+    try:
+        config.get_client()
+
+        status.start()
+        status.update("Stopping notebook...")
+
+        response = httpx.post(
+            f"{config.base_url}/api/v2/external/workloads/abort/{execution_id}",
+            headers={"Authorization": f"Bearer {config.api_key}"},
+            timeout=30.0,
+        )
+
+        status.stop()
+
+        if response.status_code == 200:
+            console.print(f"[green]Notebook {execution_id} stopped.[/green]")
+        elif response.status_code == 404:
+            console.print(f"[yellow]Notebook {execution_id} not found or already stopped.[/yellow]")
+        else:
+            console.print(f"[red]Error stopping notebook: HTTP {response.status_code}[/red]")
+            if response.content:
+                console.print(f"[red]{response.content.decode()}[/red]")
+            raise typer.Exit(1)
+
+    except typer.Exit:
+        status.stop()
+        raise
+    except Exception as e:
+        status.stop()
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@notebook_app.command("list")
+def list_notebooks():
+    """List running Jupyter notebooks.
+
+    Shows all active notebook sessions with their URLs and status.
+    """
+    status = StatusLine()
+
+    try:
+        config.get_client()
+
+        status.start()
+        status.update("Fetching running notebooks...")
+
+        # Use the workloads API to get running executions
+        response = httpx.get(
+            f"{config.base_url}/api/v2/external/workloads/list",
+            headers={"Authorization": f"Bearer {config.api_key}"},
+            timeout=30.0,
+        )
+
+        status.stop()
+
+        if response.status_code != 200:
+            console.print(f"[red]Error: HTTP {response.status_code}[/red]")
+            if response.content:
+                console.print(f"[red]{response.content.decode()}[/red]")
+            raise typer.Exit(1)
+
+        executions = response.json()
+
+        # Filter for notebook executions (those running on port 8888 or with jupyter)
+        # Since we don't have image info, show all running executions
+        notebooks = [
+            e for e in executions
+            if e.get("status") in ["running", "pending", "queued", "starting"]
+        ]
+
+        if not notebooks:
+            console.print("[dim]No running workloads found.[/dim]")
+            return
+
+        console.print(f"[bold]Running Workloads ({len(notebooks)})[/bold]")
+        console.print()
+
+        for nb in notebooks:
+            exec_id = nb.get("execution_id", "unknown")
+            status_val = nb.get("status", "unknown")
+            created = nb.get("created_at", "")
+            file_name = nb.get("file_name", "")
+
+            # Assume port 8888 for Jupyter
+            url = f"https://{exec_id}-8888.port.lyceum.technology"
+
+            console.print(f"[cyan]{exec_id}[/cyan]")
+            if file_name:
+                console.print(f"  Name: {file_name}")
+            console.print(f"  Status: {status_val}")
+            console.print(f"  URL: {url}")
+            if created:
+                console.print(f"  Created: {created}")
+            console.print()
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        status.stop()
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)

lyceum/external/compute/inference/batch.py

@@ -6,9 +6,10 @@ from pathlib import Path
 import httpx
 import typer
 from rich.console import Console
+from rich.table import Table
 
 from ....shared.config import config
-from ....shared.display import create_table, format_timestamp, truncate_id
+from ....shared.display import format_timestamp, truncate_id
 
 console = Console()
 
@@ -218,15 +219,12 @@ def list_batches(
             console.print("[dim]No batch jobs found[/dim]")
             return
 
-        columns = [
-            {"header": "Batch ID", "style": "cyan", "no_wrap": True, "max_width": 16},
-            {"header": "Status", "style": "yellow"},
-            {"header": "Endpoint", "style": "green"},
-            {"header": "Requests", "style": "magenta", "justify": "center"},
-            {"header": "Created", "style": "dim"}
-        ]
-
-        table = create_table("Batch Jobs", columns)
+        table = Table(title="Batch Jobs")
+        table.add_column("Batch ID", style="cyan", no_wrap=True, max_width=16)
+        table.add_column("Status", style="yellow")
+        table.add_column("Endpoint", style="green")
+        table.add_column("Requests", style="magenta", justify="center")
+        table.add_column("Created", style="dim")
 
         for batch in batches:
             batch_id = batch['id']