lyceum-cli 1.0.14__py3-none-any.whl → 1.0.18__py3-none-any.whl

lyceum/external/compute/inference/models.py

@@ -0,0 +1,242 @@
+"""
+Model discovery and information commands for AI inference
+"""
+
+from typing import Optional
+import typer
+import httpx
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+from ....shared.config import config
+
+console = Console()
+
+models_app = typer.Typer(name="models", help="Model discovery and information")
+
+
+@models_app.command("list")
+def list_models(
+    model_type: Optional[str] = typer.Option(None, "--type", "-t", help="Filter by model type (text, image, multimodal, etc.)"),
+    available_only: bool = typer.Option(False, "--available", "-a", help="Show only available models"),
+    sync_only: bool = typer.Option(False, "--sync", help="Show only models that support synchronous inference"),
+    async_only: bool = typer.Option(False, "--async", help="Show only models that support async/batch inference"),
+):
+    """List all available AI models"""
+    try:
+        # Determine the endpoint based on filters
+        if sync_only:
+            endpoint = "/api/v2/external/models/sync"
+        elif async_only:
+            endpoint = "/api/v2/external/models/async"
+        elif model_type:
+            endpoint = f"/api/v2/external/models/type/{model_type}"
+        else:
+            endpoint = "/api/v2/external/models/"
+
+        url = f"{config.base_url}{endpoint}"
+        headers = {"Authorization": f"Bearer {config.api_key}"}
+
+        console.print("[dim]🔍 Fetching available models...[/dim]")
+
+        with httpx.Client() as http_client:
+            response = http_client.get(url, headers=headers, timeout=10.0)
+
+            if response.status_code != 200:
+                console.print(f"[red]❌ Error: HTTP {response.status_code}[/red]")
+                console.print(f"[red]{response.text}[/red]")
+                raise typer.Exit(1)
+
+            models = response.json()
+
+            # Filter by availability if requested
+            if available_only:
+                models = [m for m in models if m.get('available', False)]
+
+            if not models:
+                console.print("[yellow]⚠️  No models found matching your criteria[/yellow]")
+                return
+
+            # Create a detailed table
+            table = Table(title="Available AI Models", show_header=True, header_style="bold cyan")
+            table.add_column("Model ID", style="cyan", no_wrap=True)
+            table.add_column("Name", style="white")
+            table.add_column("Type", style="magenta")
+            table.add_column("Provider", style="blue")
+            table.add_column("Status", justify="center")
+            table.add_column("Price/1K", justify="right", style="green")
+            table.add_column("Sync", justify="center", style="yellow")
+            table.add_column("Async", justify="center", style="yellow")
+
+            # Sort models: available first, then by type, then by name
+            sorted_models = sorted(models, key=lambda m: (
+                not m.get('available', False),
+                m.get('type', 'text'),
+                m.get('model_id', '')
+            ))
+
+            for model in sorted_models:
+                # Status with emoji
+                status = "🟢 Yes" if model.get('available') else "🔴 No"
+
+                # Sync/Async support
+                sync_support = "✓" if model.get('supports_sync', True) else "✗"
+                async_support = "✓" if model.get('supports_async', True) else "✗"
+
+                # Price
+                price = model.get('price_per_1k_tokens', 0)
+                price_str = f"${price:.4f}" if price > 0 else "Free"
+
+                table.add_row(
+                    model.get('model_id', 'Unknown'),
+                    model.get('name', 'Unknown'),
+                    model.get('type', 'text').title(),
+                    model.get('provider', 'unknown').title(),
+                    status,
+                    price_str,
+                    sync_support,
+                    async_support
+                )
+
+            console.print(table)
+
+            # Show summary
+            available_count = sum(1 for m in models if m.get('available'))
+            total_count = len(models)
+            console.print(f"\n[dim]📊 {available_count}/{total_count} models available[/dim]")
+
+    except Exception as e:
+        console.print(f"[red]❌ Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@models_app.command("info")
+def get_model_info(
+    model_id: str = typer.Argument(..., help="Model ID to get information about"),
+):
+    """Get detailed information about a specific model"""
+    try:
+        url = f"{config.base_url}/api/v2/external/models/{model_id}"
+        headers = {"Authorization": f"Bearer {config.api_key}"}
+
+        console.print(f"[dim]🔍 Fetching info for model: {model_id}...[/dim]")
+
+        with httpx.Client() as http_client:
+            response = http_client.get(url, headers=headers, timeout=10.0)
+
+            if response.status_code == 404:
+                console.print(f"[red]❌ Model '{model_id}' not found[/red]")
+                raise typer.Exit(1)
+            elif response.status_code != 200:
+                console.print(f"[red]❌ Error: HTTP {response.status_code}[/red]")
+                console.print(f"[red]{response.text}[/red]")
+                raise typer.Exit(1)
+
+            model = response.json()
+
+            # Build detailed info display
+            status_color = "green" if model.get('available') else "red"
+            status_text = "Available ✓" if model.get('available') else "Unavailable ✗"
+
+            info_lines = [
+                f"[bold cyan]Model ID:[/bold cyan] {model.get('model_id', 'Unknown')}",
+                f"[bold]Name:[/bold] {model.get('name', 'Unknown')}",
+                f"[bold]Description:[/bold] {model.get('description', 'No description available')}",
+                "",
+                f"[bold]Type:[/bold] {model.get('type', 'text').title()}",
+                f"[bold]Provider:[/bold] {model.get('provider', 'unknown').title()}",
+                f"[bold]Version:[/bold] {model.get('version', 'N/A')}",
+                f"[bold]Status:[/bold] [{status_color}]{status_text}[/{status_color}]",
+                "",
+                f"[bold yellow]Capabilities:[/bold yellow]",
+                f"  • Synchronous inference: {'Yes ✓' if model.get('supports_sync', True) else 'No ✗'}",
+                f"  • Asynchronous/Batch: {'Yes ✓' if model.get('supports_async', True) else 'No ✗'}",
+                f"  • GPU Required: {'Yes' if model.get('gpu_required', False) else 'No'}",
+                "",
+                f"[bold green]Input/Output:[/bold green]",
+                f"  • Input types: {', '.join(model.get('input_types', []))}",
+                f"  • Output types: {', '.join(model.get('output_types', []))}",
+                f"  • Max input tokens: {model.get('max_input_tokens', 'N/A'):,}",
+                f"  • Max output tokens: {model.get('max_output_tokens', 'N/A'):,}",
+                "",
+                f"[bold green]Pricing:[/bold green]",
+                f"  • Base price: ${model.get('price_per_1k_tokens', 0):.4f} per 1K tokens",
+                f"  • Batch discount: {model.get('batch_pricing_discount', 0.5) * 100:.0f}% off",
+                "",
+                f"[bold blue]Performance:[/bold blue]",
+                f"  • Estimated latency: {model.get('estimated_latency_ms', 0):,} ms",
+            ]
+
+            panel = Panel(
+                "\n".join(info_lines),
+                title=f"[bold white]Model Information: {model.get('name', model_id)}[/bold white]",
+                border_style="cyan",
+                padding=(1, 2)
+            )
+
+            console.print(panel)
+
+    except Exception as e:
+        console.print(f"[red]❌ Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@models_app.command("instances")
+def list_model_instances(
+    model_id: str = typer.Argument(..., help="Model ID to list instances for"),
+):
+    """List running instances for a specific model"""
+    try:
+        url = f"{config.base_url}/api/v2/external/models/{model_id}/instances"
+        headers = {"Authorization": f"Bearer {config.api_key}"}
+
+        console.print(f"[dim]🔍 Fetching instances for model: {model_id}...[/dim]")
+
+        with httpx.Client() as http_client:
+            response = http_client.get(url, headers=headers, timeout=10.0)
+
+            if response.status_code == 404:
+                console.print(f"[red]❌ Model '{model_id}' not found[/red]")
+                raise typer.Exit(1)
+            elif response.status_code != 200:
+                console.print(f"[red]❌ Error: HTTP {response.status_code}[/red]")
+                console.print(f"[red]{response.text}[/red]")
+                raise typer.Exit(1)
+
+            instances = response.json()
+
+            if not instances:
+                console.print(f"[yellow]⚠️  No instances found for model '{model_id}'[/yellow]")
+                return
+
+            # Create table for instances
+            table = Table(title=f"Instances for {model_id}", show_header=True, header_style="bold cyan")
+            table.add_column("Instance ID", style="cyan", no_wrap=True)
+            table.add_column("Instance URL", style="blue")
+            table.add_column("Status", justify="center", style="green")
+            table.add_column("Node ID", style="magenta")
+            table.add_column("Last Health Check", style="dim")
+
+            for instance in instances:
+                # Truncate instance ID for display
+                instance_id = instance.get('id', 'Unknown')
+                short_id = instance_id[:12] + "..." if len(instance_id) > 12 else instance_id
+
+                status = instance.get('status', 'unknown')
+                status_emoji = "🟢" if status == "running" else "🔴"
+
+                table.add_row(
+                    short_id,
+                    instance.get('instance_url', 'N/A'),
+                    f"{status_emoji} {status}",
+                    instance.get('node_id', 'N/A') or 'N/A',
+                    instance.get('last_health_check', 'N/A') or 'N/A'
+                )
+
+            console.print(table)
+            console.print(f"\n[dim]📊 Total instances: {len(instances)}[/dim]")
+
+    except Exception as e:
+        console.print(f"[red]❌ Error: {e}[/red]")
+        raise typer.Exit(1)

lyceum/main.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""
+Lyceum CLI - Command-line interface for Lyceum Cloud Execution API
+Refactored to match API directory structure
+"""
+
+import typer
+from rich.console import Console
+
+# Import all command modules
+from .external.auth.login import auth_app
+from .external.compute.execution.python import python_app
+from .external.compute.inference.batch import batch_app
+from .external.compute.inference.chat import chat_app
+from .external.compute.inference.models import models_app
+
+app = typer.Typer(
+    name="lyceum",
+    help="Lyceum Cloud Execution CLI",
+    add_completion=False,
+)
+
+console = Console()
+
+# Add all command groups
+app.add_typer(auth_app, name="auth")
+app.add_typer(python_app, name="python")
+app.add_typer(batch_app, name="batch")
+app.add_typer(chat_app, name="chat")
+app.add_typer(models_app, name="models")
+
+# Legacy aliases for backward compatibility
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+if __name__ == "__main__":
+    app()

lyceum/shared/config.py

@@ -0,0 +1,144 @@
+"""
+Configuration management for Lyceum CLI
+"""
+
+import json
+from pathlib import Path
+from typing import Optional
+import jwt
+import time
+import requests
+
+from rich.console import Console
+import typer
+from supabase import create_client
+
+# Add the generated client to the path
+import sys
+sys.path.insert(0, str(Path(__file__).parent.parent.parent / "lyceum-cloud-execution-api-client"))
+
+# Commented out - using httpx directly instead
+# from lyceum_cloud_execution_api_client.client import AuthenticatedClient
+
+console = Console()
+
+# Configuration
+CONFIG_DIR = Path.home() / ".lyceum"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+
+class Config:
+    """Configuration management for Lyceum CLI"""
+    
+    def __init__(self):
+        self.api_key: Optional[str] = None
+        self.base_url: str = "https://api.lyceum.technology"  # Production API URL
+        self.refresh_token: Optional[str] = None
+        self.dashboard_url: str = "https://dashboard.lyceum.technology"
+        self.load()
+    
+    def load(self):
+        """Load configuration from file"""
+        if CONFIG_FILE.exists():
+            try:
+                with open(CONFIG_FILE) as f:
+                    data = json.load(f)
+                    self.api_key = data.get("api_key")
+                    self.base_url = data.get("base_url", self.base_url)
+                    self.refresh_token = data.get("refresh_token")
+                    self.dashboard_url = data.get("dashboard_url", self.dashboard_url)
+            except Exception as e:
+                console.print(f"[yellow]Warning: Could not load config: {e}[/yellow]")
+    
+    def save(self):
+        """Save configuration to file"""
+        CONFIG_DIR.mkdir(exist_ok=True)
+        with open(CONFIG_FILE, "w") as f:
+            json.dump({
+                "api_key": self.api_key,
+                "base_url": self.base_url,
+                "refresh_token": self.refresh_token,
+                "dashboard_url": self.dashboard_url,
+            }, f, indent=2)
+    
+    def is_token_expired(self) -> bool:
+        """Check if the current token is expired or will expire soon (within 5 minutes)"""
+        if not self.api_key:
+            return True
+        
+        # Legacy API keys (starting with lk_) don't expire
+        if self.api_key.startswith('lk_'):
+            return False
+            
+        try:
+            # Decode without verification to get expiration
+            decoded = jwt.decode(self.api_key, options={"verify_signature": False})
+            exp = decoded.get('exp', 0)
+            
+            # Check if token expires within 5 minutes (300 seconds)
+            current_time = time.time()
+            return (exp - current_time) <= 300
+            
+        except Exception:
+            # If we can't decode the token, assume it's expired
+            return True
+    
+    def refresh_access_token(self) -> bool:
+        """Attempt to refresh the access token using Supabase refresh token"""
+        if not self.refresh_token:
+            return False
+            
+        # Only refresh JWT tokens, not legacy API keys
+        if self.api_key and self.api_key.startswith('lk_'):
+            return False
+            
+        try:
+            # Use Supabase's refresh_session method with the service role key
+            supabase_url = "https://tqcebgbexyszvqhnwnhh.supabase.co"
+            supabase_service_key = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InRxY2ViZ2JleHlzenZxaG53bmhoIiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTc0NzE1NDQ3MSwiZXhwIjoyMDYyNzMwNDcxfQ.RpxhmMxFKJSJERobr28bmaZOG9Fxe-qthTYlg8iyFdc"
+            
+            supabase = create_client(supabase_url, supabase_service_key)
+            
+            # Use refresh_session method
+            response = supabase.auth.refresh_session(refresh_token=self.refresh_token)
+            
+            if response.session and response.session.access_token:
+                # Successfully refreshed
+                self.api_key = response.session.access_token
+                if response.session.refresh_token:
+                    self.refresh_token = response.session.refresh_token
+                self.save()
+                console.print("[dim]🔄 Token refreshed automatically[/dim]")
+                return True
+            else:
+                # Refresh failed
+                error_msg = getattr(response, 'error', None)
+                if error_msg:
+                    console.print(f"[yellow]⚠️  Token refresh failed: {error_msg.message}[/yellow]")
+                else:
+                    console.print("[yellow]⚠️  Token refresh failed: No session returned[/yellow]")
+                return False
+                
+        except Exception as e:
+            console.print(f"[yellow]⚠️  Token refresh error: {e}[/yellow]")
+            return False
+    
+    def get_client(self):
+        """Get authenticated API client with automatic token refresh"""
+        if not self.api_key:
+            console.print("[red]Error: Not authenticated. Run 'lyceum login' first.[/red]")
+            raise typer.Exit(1)
+
+        # Check if token is expired and try to refresh
+        if self.is_token_expired():
+            console.print("[dim]🔄 Token expired, attempting refresh...[/dim]")
+            if not self.refresh_access_token():
+                console.print("[red]❌ Token refresh failed. Please run 'lyceum login' again.[/red]")
+                raise typer.Exit(1)
+
+        # Return config instance - commands use httpx directly
+        return self
+
+
+# Global config instance
+config = Config()

lyceum/shared/display.py

@@ -0,0 +1,195 @@
+"""
+Display utilities for CLI output formatting
+"""
+
+from rich.table import Table
+from datetime import datetime
+from typing import Optional
+
+
+def create_table(title: str, columns: list[tuple[str, str]]) -> Table:
+    """
+    Create a Rich table with the given title and columns.
+
+    Args:
+        title: Table title
+        columns: List of (column_name, style) tuples
+
+    Returns:
+        Rich Table instance
+    """
+    table = Table(title=title)
+    for col_name, style in columns:
+        table.add_column(col_name, style=style)
+    return table
+
+
+def format_timestamp(timestamp: str | int | datetime, relative: bool = False) -> str:
+    """
+    Format a timestamp for display.
+
+    Args:
+        timestamp: Unix timestamp (int/float), ISO string, or datetime object
+        relative: If True, show relative time (e.g., "2 hours ago")
+
+    Returns:
+        Formatted timestamp string
+    """
+    try:
+        # Convert to datetime if needed
+        if isinstance(timestamp, (int, float)):
+            dt = datetime.fromtimestamp(timestamp)
+        elif isinstance(timestamp, str):
+            # Try parsing ISO format
+            dt = datetime.fromisoformat(timestamp.replace('Z', '+00:00'))
+        elif isinstance(timestamp, datetime):
+            dt = timestamp
+        else:
+            return str(timestamp)
+
+        if relative:
+            # Calculate relative time
+            now = datetime.now(dt.tzinfo) if dt.tzinfo else datetime.now()
+            diff = now - dt
+
+            seconds = diff.total_seconds()
+            if seconds < 60:
+                return f"{int(seconds)}s ago"
+            elif seconds < 3600:
+                return f"{int(seconds / 60)}m ago"
+            elif seconds < 86400:
+                return f"{int(seconds / 3600)}h ago"
+            elif seconds < 604800:
+                return f"{int(seconds / 86400)}d ago"
+            else:
+                return dt.strftime("%Y-%m-%d")
+        else:
+            # Return absolute time
+            return dt.strftime("%Y-%m-%d %H:%M:%S")
+
+    except Exception:
+        return str(timestamp)
+
+
+def truncate_id(id_str: str, length: int = 8) -> str:
+    """
+    Truncate an ID string for display.
+
+    Args:
+        id_str: The ID string to truncate
+        length: Number of characters to keep from the start
+
+    Returns:
+        Truncated ID string
+    """
+    if not id_str:
+        return ""
+
+    if len(id_str) <= length:
+        return id_str
+
+    return f"{id_str[:length]}..."
+
+
+def format_file_size(bytes: int) -> str:
+    """
+    Format file size in human-readable format.
+
+    Args:
+        bytes: Size in bytes
+
+    Returns:
+        Formatted size string (e.g., "1.5 MB")
+    """
+    for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
+        if bytes < 1024.0:
+            return f"{bytes:.1f} {unit}"
+        bytes /= 1024.0
+    return f"{bytes:.1f} PB"
+
+
+def format_duration(seconds: float) -> str:
+    """
+    Format duration in human-readable format.
+
+    Args:
+        seconds: Duration in seconds
+
+    Returns:
+        Formatted duration string (e.g., "2h 15m 30s")
+    """
+    if seconds < 60:
+        return f"{seconds:.1f}s"
+
+    minutes = int(seconds / 60)
+    secs = int(seconds % 60)
+
+    if minutes < 60:
+        return f"{minutes}m {secs}s"
+
+    hours = int(minutes / 60)
+    mins = int(minutes % 60)
+
+    if hours < 24:
+        return f"{hours}h {mins}m"
+
+    days = int(hours / 24)
+    hrs = int(hours % 24)
+
+    return f"{days}d {hrs}h"
+
+
+def status_color(status: str) -> str:
+    """
+    Get color for status display.
+
+    Args:
+        status: Status string
+
+    Returns:
+        Color name for Rich formatting
+    """
+    status_lower = status.lower()
+
+    if status_lower in ['completed', 'success', 'running']:
+        return 'green'
+    elif status_lower in ['failed', 'error', 'failed_user', 'failed_system']:
+        return 'red'
+    elif status_lower in ['pending', 'queued', 'in_progress', 'validating', 'finalizing']:
+        return 'yellow'
+    elif status_lower in ['cancelled', 'expired', 'timeout']:
+        return 'dim'
+    else:
+        return 'white'
+
+
+def status_emoji(status: str) -> str:
+    """
+    Get emoji for status display.
+
+    Args:
+        status: Status string
+
+    Returns:
+        Emoji character
+    """
+    status_lower = status.lower()
+
+    if status_lower in ['completed', 'success']:
+        return '✅'
+    elif status_lower in ['failed', 'error', 'failed_user', 'failed_system']:
+        return '❌'
+    elif status_lower in ['running', 'in_progress']:
+        return '🔄'
+    elif status_lower in ['pending', 'queued']:
+        return '⏳'
+    elif status_lower in ['validating']:
+        return '🔍'
+    elif status_lower in ['finalizing']:
+        return '📦'
+    elif status_lower in ['cancelled']:
+        return '🛑'
+    elif status_lower in ['expired', 'timeout']:
+        return '⏰'
+    else:
+        return '⚪'