lyceum-cli 1.0.21__py3-none-any.whl → 1.0.23__py3-none-any.whl

lyceum/external/compute/inference/batch.py

@@ -1,13 +1,10 @@
-"""
-OpenAI-compatible batch processing commands
-"""
+"""OpenAI-compatible batch processing commands"""
 
 import os
-import time
 from pathlib import Path
-from typing import Optional
-import typer
+
 import httpx
+import typer
 from rich.console import Console
 
 from ....shared.config import config
@@ -28,19 +25,19 @@ def upload_file(
     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}"},
@@ -48,20 +45,20 @@ def upload_file(
                 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("[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)
@@ -70,51 +67,57 @@ def upload_file(
 @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)"),
+    endpoint: str | None = typer.Option(
+        None, "--endpoint", "-e", help="API endpoint (optional, uses URLs from JSONL if not specified)"
+    ),
+    model: str | None = 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("[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)
@@ -127,20 +130,20 @@ def get_batch(
     """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":
@@ -151,29 +154,33 @@ def get_batch(
             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]")
-        
+        console.print(
+            f"[dim]Requests - Total: {counts.get('total', 0)}, "
+            f"Completed: {counts.get('completed', 0)}, "
+            f"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)
@@ -181,36 +188,36 @@ def get_batch(
 
 @batch_app.command("list")
 def list_batches(
-    after: Optional[str] = typer.Option(None, "--after", help="List batches after this batch ID"),
+    after: str | None = 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"},
@@ -218,16 +225,16 @@ def list_batches(
             {"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'],
@@ -235,10 +242,10 @@ def list_batches(
                 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)
@@ -251,24 +258,24 @@ def cancel_batch(
     """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("[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)
@@ -277,25 +284,27 @@ def cancel_batch(
 @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)"),
+    output_file: str | None = 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:
@@ -309,7 +318,7 @@ def download_file(
             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)
+        raise typer.Exit(1)

lyceum/external/compute/inference/chat.py

@@ -1,12 +1,10 @@
-"""
-Synchronous inference commands for chat/completion
-"""
+"""Synchronous inference commands for chat/completion"""
+
+import json
 
-from typing import Optional
 import typer
 from rich.console import Console
 from rich.table import Table
-import json
 
 from ....shared.config import config
 
@@ -24,12 +22,12 @@ def send_message(
     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"),
+    system_prompt: str | None = typer.Option(None, "--system", "-s", help="System prompt"),
 ):
     """Send a message to an AI model and get a response"""
     try:
-        client = config.get_client()
-        
+        config.get_client()
+
         # Create the sync request payload directly
         sync_request = {
             "model_id": model,
@@ -42,15 +40,15 @@ def send_message(
             "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,
@@ -58,20 +56,20 @@ def send_message(
                 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)
@@ -79,30 +77,30 @@ def send_message(
                 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")  
+@chat_app.command("models")
 def list_models():
     """List available models for inference"""
     try:
-        client = config.get_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")
@@ -110,56 +108,53 @@ def list_models():
                     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', 
+                            '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)
@@ -174,7 +169,7 @@ def analyze_image(
 ):
     """Analyze an image with AI vision models"""
     try:
-        client = config.get_client()
+        config.get_client()
 
         # Create request payload for image analysis
         sync_request = {
@@ -207,10 +202,10 @@ def analyze_image(
                 result = response.json()
 
                 if raw_output:
-                    console.print(f"[green]✅ Raw Response:[/green]")
+                    console.print("[green]✅ Raw Response:[/green]")
                     console.print(json.dumps(result.get('raw_response', result['output']), indent=2))
                 else:
-                    console.print(f"[green]✅ Image Analysis:[/green]")
+                    console.print("[green]✅ Image Analysis:[/green]")
                     console.print(f"[cyan]{result['output']}[/cyan]")
 
             elif response.status_code == 503:
@@ -223,4 +218,4 @@ def analyze_image(
 
     except Exception as e:
         console.print(f"[red]❌ Error: {e}[/red]")
-        raise typer.Exit(1)
+        raise typer.Exit(1)

lyceum/external/compute/inference/models.py

@@ -1,13 +1,11 @@
-"""
-Model discovery and information commands for AI inference
-"""
+"""Model discovery and information commands for AI inference"""
+
 
-from typing import Optional
-import typer
 import httpx
+import typer
 from rich.console import Console
-from rich.table import Table
 from rich.panel import Panel
+from rich.table import Table
 
 from ....shared.config import config
 
@@ -18,10 +16,18 @@ 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"),
+    model_type: str | None = 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:
@@ -149,22 +155,22 @@ def get_model_info(
                 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]",
+                "[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]",
+                "[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]",
+                "[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]",
+                "[bold blue]Performance:[/bold blue]",
                 f"  • Estimated latency: {model.get('estimated_latency_ms', 0):,} ms",
             ]
 

lyceum/external/general/__init__.py

@@ -0,0 +1 @@
+