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

lyceum/external/compute/inference/batch.py

@@ -0,0 +1,315 @@
+"""
+OpenAI-compatible batch processing commands
+"""
+
+import os
+import time
+from pathlib import Path
+from typing import Optional
+import typer
+import httpx
+from rich.console import Console
+
+from ....shared.config import config
+from ....shared.display import create_table, format_timestamp, truncate_id
+
+console = Console()
+
+batch_app = typer.Typer(name="batch", help="OpenAI-compatible batch processing")
+
+
+@batch_app.command("upload")
+def upload_file(
+    file_path: str = typer.Argument(..., help="Path to JSONL file to upload"),
+    purpose: str = typer.Option("batch", "--purpose", "-p", help="File purpose (batch, batch_output, batch_errors)"),
+):
+    """Upload a JSONL file for batch processing"""
+    # Check if file exists
+    if not Path(file_path).exists():
+        console.print(f"[red]Error: File '{file_path}' not found[/red]")
+        raise typer.Exit(1)
+    
+    # Validate file extension
+    if not file_path.endswith('.jsonl'):
+        console.print("[yellow]Warning: File doesn't have .jsonl extension[/yellow]")
+    
+    try:
+        console.print(f"[dim]📤 Uploading {os.path.basename(file_path)} for {purpose}...[/dim]")
+        
+        # Upload file using multipart form data
+        with open(file_path, 'rb') as f:
+            files = {'file': (os.path.basename(file_path), f, 'application/jsonl')}
+            data = {'purpose': purpose}
+            
+            response = httpx.post(
+                f"{config.base_url}/api/v2/external/files",
+                headers={"Authorization": f"Bearer {config.api_key}"},
+                files=files,
+                data=data,
+                timeout=60.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)
+        
+        data = response.json()
+        
+        console.print(f"[green]✅ File uploaded successfully![/green]")
+        console.print(f"[cyan]File ID: {data['id']}[/cyan]")
+        console.print(f"[dim]Size: {data['bytes']} bytes[/dim]")
+        console.print(f"[dim]Purpose: {data['purpose']}[/dim]")
+        console.print(f"[dim]Created: {data['created_at']}[/dim]")
+        
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@batch_app.command("create")
+def create_batch(
+    input_file_id: str = typer.Argument(..., help="File ID of uploaded JSONL file"),
+    endpoint: Optional[str] = typer.Option(None, "--endpoint", "-e", help="API endpoint (optional, uses URLs from JSONL if not specified)"),
+    model: Optional[str] = typer.Option(None, "--model", "-m", help="Model to use for all requests (overrides model in JSONL)"),
+    completion_window: str = typer.Option("24h", "--completion-window", "-w", help="Completion window (24h only)"),
+):
+    """Create a batch processing job"""
+    try:
+        console.print(f"[dim]🚀 Creating batch job for file {input_file_id}...[/dim]")
+        
+        request_data = {
+            "input_file_id": input_file_id,
+            "completion_window": completion_window
+        }
+        
+        # Only include endpoint if explicitly provided as override
+        if endpoint:
+            request_data["endpoint"] = endpoint
+            console.print(f"[dim]Using endpoint override: {endpoint}[/dim]")
+        # Note: endpoint is NOT required - the API should use URLs from JSONL file
+            
+        # Include model override if specified
+        if model:
+            request_data["model"] = model
+            console.print(f"[dim]Using model override: {model}[/dim]")
+        
+        response = httpx.post(
+            f"{config.base_url}/api/v2/external/batches",
+            headers={"Authorization": f"Bearer {config.api_key}"},
+            json=request_data,
+            timeout=30.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)
+        
+        data = response.json()
+        
+        console.print(f"[green]✅ Batch job created successfully![/green]")
+        console.print(f"[cyan]Batch ID: {data['id']}[/cyan]")
+        console.print(f"[yellow]Status: {data['status']}[/yellow]")
+        console.print(f"[dim]Endpoint: {data['endpoint']}[/dim]")
+        console.print(f"[dim]Input File ID: {data['input_file_id']}[/dim]")
+        console.print(f"[dim]Expires: {data['expires_at']}[/dim]")
+        
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@batch_app.command("get")
+def get_batch(
+    batch_id: str = typer.Argument(..., help="Batch ID to retrieve"),
+):
+    """Get batch job status and details"""
+    try:
+        console.print(f"[dim]🔍 Retrieving batch {batch_id}...[/dim]")
+        
+        response = httpx.get(
+            f"{config.base_url}/api/v2/external/batches/{batch_id}",
+            headers={"Authorization": f"Bearer {config.api_key}"},
+            timeout=30.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)
+        
+        data = response.json()
+        
+        # Status color coding
+        status = data['status']
+        if status == "completed":
+            status_color = "green"
+        elif status in ["failed", "expired", "cancelled"]:
+            status_color = "red"
+        elif status in ["in_progress", "finalizing"]:
+            status_color = "yellow"
+        else:
+            status_color = "dim"
+        
+        console.print(f"[cyan]Batch ID: {data['id']}[/cyan]")
+        console.print(f"[{status_color}]Status: {status}[/{status_color}]")
+        console.print(f"[dim]Endpoint: {data['endpoint']}[/dim]")
+        console.print(f"[dim]Input File: {data['input_file_id']}[/dim]")
+        
+        if data.get('output_file_id'):
+            console.print(f"[green]Output File: {data['output_file_id']}[/green]")
+        
+        if data.get('error_file_id'):
+            console.print(f"[red]Error File: {data['error_file_id']}[/red]")
+        
+        # Request statistics
+        counts = data.get('request_counts', {})
+        console.print(f"[dim]Requests - Total: {counts.get('total', 0)}, Completed: {counts.get('completed', 0)}, Failed: {counts.get('failed', 0)}[/dim]")
+        
+        # Timestamps
+        console.print(f"[dim]Created: {data.get('created_at', 'N/A')}[/dim]")
+        if data.get('completed_at'):
+            console.print(f"[dim]Completed: {data['completed_at']}[/dim]")
+        if data.get('expires_at'):
+            console.print(f"[dim]Expires: {data['expires_at']}[/dim]")
+        
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@batch_app.command("list")
+def list_batches(
+    after: Optional[str] = typer.Option(None, "--after", help="List batches after this batch ID"),
+    limit: int = typer.Option(20, "--limit", "-l", help="Number of batches to return"),
+):
+    """List batch jobs"""
+    try:
+        console.print("[dim]📋 Listing batch jobs...[/dim]")
+        
+        params = {"limit": limit}
+        if after:
+            params["after"] = after
+        
+        response = httpx.get(
+            f"{config.base_url}/api/v2/external/batches",
+            headers={"Authorization": f"Bearer {config.api_key}"},
+            params=params,
+            timeout=30.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)
+        
+        data = response.json()
+        batches = data.get('data', [])
+        
+        if not 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)
+        
+        for batch in batches:
+            batch_id = batch['id']
+            short_id = truncate_id(batch_id, 12)
+            
+            counts = batch.get('request_counts', {})
+            request_stats = f"{counts.get('completed', 0)}/{counts.get('total', 0)}"
+            
+            table.add_row(
+                short_id,
+                batch['status'],
+                batch['endpoint'],
+                request_stats,
+                format_timestamp(batch.get('created_at'))
+            )
+        
+        console.print(table)
+        console.print(f"\n[dim]Found {len(batches)} batch jobs[/dim]")
+        
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@batch_app.command("cancel")
+def cancel_batch(
+    batch_id: str = typer.Argument(..., help="Batch ID to cancel"),
+):
+    """Cancel a batch job"""
+    try:
+        console.print(f"[dim]🛑 Cancelling batch {batch_id}...[/dim]")
+        
+        response = httpx.post(
+            f"{config.base_url}/api/v2/external/batches/{batch_id}/cancel",
+            headers={"Authorization": f"Bearer {config.api_key}"},
+            timeout=30.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)
+        
+        data = response.json()
+        
+        console.print(f"[green]✅ Batch cancelled successfully![/green]")
+        console.print(f"[cyan]Batch ID: {data['id']}[/cyan]")
+        console.print(f"[yellow]Status: {data['status']}[/yellow]")
+        
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@batch_app.command("download")
+def download_file(
+    file_id: str = typer.Argument(..., help="File ID to download"),
+    output_file: Optional[str] = typer.Option(None, "--output", "-o", help="Output file path (prints to console if not specified)"),
+):
+    """Download batch file content (input, output, or error files)"""
+    try:
+        console.print(f"[dim]⬇️  Downloading file {file_id}...[/dim]")
+        
+        response = httpx.get(
+            f"{config.base_url}/api/v2/external/files/{file_id}/content",
+            headers={"Authorization": f"Bearer {config.api_key}"},
+            timeout=60.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)
+        
+        content = response.text
+        
+        if output_file:
+            # Save to file
+            with open(output_file, 'w') as f:
+                f.write(content)
+            console.print(f"[green]✅ Content saved to {output_file}[/green]")
+            console.print(f"[dim]Size: {len(content)} characters[/dim]")
+        else:
+            # Print to console
+            console.print("[green]📄 File Content:[/green]")
+            console.print("-" * 50)
+            console.print(content)
+            console.print("-" * 50)
+            console.print(f"[dim]Size: {len(content)} characters[/dim]")
+        
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)

lyceum/external/compute/inference/chat.py

@@ -0,0 +1,220 @@
+"""
+Synchronous inference commands for chat/completion
+"""
+
+from typing import Optional
+import typer
+from rich.console import Console
+from rich.table import Table
+import json
+
+from ....shared.config import config
+
+console = Console()
+
+# Import generated client modules
+# We'll use direct HTTP calls since the sync inference models aren't generated yet
+
+chat_app = typer.Typer(name="chat", help="Synchronous inference commands")
+
+
+@chat_app.command("send")
+def send_message(
+    message: str = typer.Argument(..., help="Message to send to the model"),
+    model: str = typer.Option("gpt-4", "--model", "-m", help="Model to use for inference"),
+    max_tokens: int = typer.Option(1000, "--max-tokens", help="Maximum tokens in response"),
+    temperature: float = typer.Option(0.7, "--temperature", "-t", help="Temperature (0.0-2.0)"),
+    system_prompt: Optional[str] = typer.Option(None, "--system", "-s", help="System prompt"),
+):
+    """Send a message to an AI model and get a response"""
+    try:
+        client = config.get_client()
+        
+        # Create the sync request payload directly
+        sync_request = {
+            "model_id": model,
+            "input": {
+                "text": message,
+                "parameters": {"system_prompt": system_prompt} if system_prompt else {}
+            },
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "top_p": 1.0,
+            "stream": False
+        }
+        
+        console.print(f"[dim]🤖 Sending message to {model}...[/dim]")
+        
+        # Make the API call using httpx directly (since we don't have generated client for sync inference yet)
+        import httpx
+        
+        url = f"{config.base_url}/api/v2/external/sync/"
+        headers = {"Authorization": f"Bearer {config.api_key}", "Content-Type": "application/json"}
+        
+        with httpx.Client() as http_client:
+            response = http_client.post(
+                url,
+                json=sync_request,
+                headers=headers,
+                timeout=60.0
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                
+                console.print(f"[green]✅ Response from {model}:[/green]")
+                console.print(f"[cyan]{result['output']}[/cyan]")
+                
+                # Show usage stats
+                if 'usage' in result:
+                    usage = result['usage']
+                    console.print(f"[dim]📊 Tokens: {usage.get('total_tokens', 0)} | "
+                                f"Latency: {result.get('latency_ms', 0)}ms | "
+                                f"Cost: ${result.get('cost', 0):.4f}[/dim]")
+                
+            elif response.status_code == 503:
+                console.print(f"[red]❌ Model {model} is not running. Please contact support to start the model.[/red]")
+                raise typer.Exit(1)
+            else:
+                console.print(f"[red]❌ Error: HTTP {response.status_code}[/red]")
+                console.print(f"[red]{response.text}[/red]")
+                raise typer.Exit(1)
+                
+    except Exception as e:
+        console.print(f"[red]❌ Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@chat_app.command("models")  
+def list_models():
+    """List available models for inference"""
+    try:
+        client = config.get_client()
+        
+        # Make API call to get available models
+        import httpx
+        
+        url = f"{config.base_url}/api/v2/external/models/"
+        headers = {"Authorization": f"Bearer {config.api_key}"}
+        
+        with httpx.Client() as http_client:
+            response = http_client.get(url, headers=headers, timeout=10.0)
+            
+            if response.status_code == 200:
+                models = response.json()
+                
+                if models:
+                    # Create a table
+                    table = Table(title="Available AI Models")
+                    table.add_column("Model", style="cyan", no_wrap=True)
+                    table.add_column("Type", style="magenta")
+                    table.add_column("Status", justify="center")
+                    table.add_column("Price/1K tokens", justify="right", style="green")
+                    
+                    # Sort models: running first, then by type, then by name
+                    sorted_models = sorted(models, key=lambda m: (
+                        not m.get('available', False),  # Running models first
+                        m.get('type', 'text'),          # Then by type
+                        m.get('model_id', '')           # Then by name
+                    ))
+                    
+                    for model in sorted_models:
+                        # Status with emoji
+                        status = "🟢 Running" if model.get('available') else "🔴 Stopped"
+                        
+                        # Model type with emoji
+                        model_type = model.get('type', 'text')
+                        type_emoji = {
+                            'text': 'Text',
+                            'image': 'Image', 
+                            'audio': 'Audio',
+                            'multimodal': 'Multi',
+                            'embedding': 'Embed'
+                        }.get(model_type, f'❓ {model_type.title()}')
+                        
+                        # Provider
+                        provider = model.get('provider', 'unknown').title()
+                        
+                        # 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'),
+                            type_emoji,
+                            status,
+                            price_str
+                        )
+                    
+                    console.print(table)
+                    
+                    # Show summary
+                    running_count = sum(1 for m in models if m.get('available'))
+                    total_count = len(models)
+                    console.print(f"\n[dim]📊 {running_count}/{total_count} models running[/dim]")
+                    
+                else:
+                    console.print("[yellow]No models are currently available[/yellow]")
+            else:
+                console.print(f"[red]❌ Error: HTTP {response.status_code}[/red]")
+                console.print(f"[red]{response.text}[/red]")
+                raise typer.Exit(1)
+                
+    except Exception as e:
+        console.print(f"[red]❌ Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@chat_app.command("image")
+def analyze_image(
+    image_url: str = typer.Argument(..., help="URL of image to analyze"),
+    prompt: str = typer.Option("What do you see in this image?", "--prompt", "-p", help="Question about the image"),
+    model: str = typer.Option("gpt-4-vision", "--model", "-m", help="Vision model to use"),
+):
+    """Analyze an image with AI vision models"""
+    try:
+        client = config.get_client()
+        
+        # Create request payload for image analysis
+        sync_request = {
+            "model_id": model,
+            "input": {
+                "text": prompt,
+                "image_url": image_url
+            },
+            "max_tokens": 1000,
+            "temperature": 0.7
+        }
+        
+        console.print(f"[dim]👁️  Analyzing image with {model}...[/dim]")
+        
+        import httpx
+        
+        url = f"{config.base_url}/api/v2/external/sync/"
+        headers = {"Authorization": f"Bearer {config.api_key}", "Content-Type": "application/json"}
+        
+        with httpx.Client() as http_client:
+            response = http_client.post(
+                url,
+                json=sync_request,
+                headers=headers,
+                timeout=60.0
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                
+                console.print(f"[green]✅ Image Analysis:[/green]")
+                console.print(f"[cyan]{result['output']}[/cyan]")
+                
+            elif response.status_code == 503:
+                console.print(f"[red]❌ Vision model {model} is not running.[/red]")
+                raise typer.Exit(1)
+            else:
+                console.print(f"[red]❌ Error: HTTP {response.status_code}[/red]")
+                console.print(f"[red]{response.text}[/red]")
+                raise typer.Exit(1)
+                
+    except Exception as e:
+        console.print(f"[red]❌ Error: {e}[/red]")
+        raise typer.Exit(1)