lyceum-cli 1.0.14__tar.gz → 1.0.19__tar.gz

{lyceum_cli-1.0.14 → lyceum_cli-1.0.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lyceum-cli
-Version: 1.0.14
+Version: 1.0.19
 Summary: Command-line interface for Lyceum Cloud Execution API
 Home-page: https://lyceum.technology
 Author: Lyceum Team

lyceum_cli-1.0.19/lyceum/external/compute/execution/python.py

@@ -0,0 +1,99 @@
+"""
+Python execution commands
+"""
+
+from pathlib import Path
+from typing import Optional
+import typer
+from rich.console import Console
+import httpx
+
+from ....shared.config import config
+from ....shared.streaming import stream_execution_output
+
+console = Console()
+
+python_app = typer.Typer(name="python", help="Python execution commands")
+
+
+@python_app.command("run")
+def run_python(
+    code_or_file: str = typer.Argument(..., help="Python code to execute or path to Python file"),
+    machine_type: str = typer.Option("cpu", "--machine", "-m", help="Machine type (cpu, a100, h100, etc.)"),
+    timeout: int = typer.Option(60, "--timeout", "-t", help="Execution timeout in seconds"),
+    file_name: Optional[str] = typer.Option(None, "--file-name", "-f", help="Name for the execution"),
+    requirements: Optional[str] = typer.Option(None, "--requirements", "-r", help="Requirements file path or pip requirements string"),
+    imports: Optional[list[str]] = typer.Option(None, "--import", help="Pre-import modules (can be used multiple times)"),
+):
+    """Execute Python code or file on Lyceum Cloud"""
+    try:
+        # Check if it's a file path
+        code_to_execute = code_or_file
+        if Path(code_or_file).exists():
+            console.print(f"[dim]Reading code from file: {code_or_file}[/dim]")
+            with open(code_or_file, 'r') as f:
+                code_to_execute = f.read()
+            # Use filename as execution name if not provided
+            if not file_name:
+                file_name = Path(code_or_file).name
+
+        # Handle requirements
+        requirements_content = None
+        if requirements:
+            # Check if it's a file path
+            if Path(requirements).exists():
+                console.print(f"[dim]Reading requirements from file: {requirements}[/dim]")
+                with open(requirements, 'r') as f:
+                    requirements_content = f.read()
+            else:
+                # Treat as direct pip requirements string
+                requirements_content = requirements
+
+        # Create execution request payload
+        payload = {
+            "code": code_to_execute,
+            "nbcode": 0,
+            "execution_type": machine_type,
+            "timeout": timeout,
+        }
+
+        if file_name:
+            payload["file_name"] = file_name
+        if requirements_content:
+            payload["requirements_content"] = requirements_content
+        if imports:
+            payload["prior_imports"] = imports
+
+        # Make API request
+        response = httpx.post(
+            f"{config.base_url}/api/v2/external/execution/streaming/start",
+            headers={"Authorization": f"Bearer {config.api_key}"},
+            json=payload,
+            timeout=30.0
+        )
+
+        if response.status_code != 200:
+            console.print(f"[red]Error: HTTP {response.status_code}[/red]")
+            console.print(f"[red]{response.content.decode()}[/red]")
+            raise typer.Exit(1)
+
+        data = response.json()
+        execution_id = data['execution_id']
+        streaming_url = data.get('streaming_url')
+
+        console.print(f"[green]✅ Execution started![/green]")
+        console.print(f"[dim]Execution ID: {execution_id}[/dim]")
+
+        if 'pythia_decision' in data:
+            console.print(f"[dim]Pythia recommendation: {data['pythia_decision']}[/dim]")
+
+        # Stream the execution output
+        success = stream_execution_output(execution_id, streaming_url)
+        
+        if not success:
+            console.print(f"[yellow]💡 You can check the execution later with: lyceum status[/yellow]")
+            raise typer.Exit(1)
+        
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)

lyceum_cli-1.0.19/lyceum/external/compute/inference/__init__.py

@@ -0,0 +1,2 @@
+# Empty init - import modules directly in main.py to avoid circular imports
+__all__ = []

{lyceum_cli-1.0.14 → lyceum_cli-1.0.19}/lyceum/external/compute/inference/chat.py

@@ -167,24 +167,50 @@ def list_models():
 
 @chat_app.command("image")
 def analyze_image(
-    image_url: str = typer.Argument(..., help="URL of image to analyze"),
+    image_source: str = typer.Argument(..., help="Image URL or path to base64 file"),
     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"),
+    model: str = typer.Option("paddleocr-vl", "--model", "-m", help="Vision model to use"),
+    base64: bool = typer.Option(False, "--base64", "-b", help="Treat image_source as path to base64 file"),
 ):
     """Analyze an image with AI vision models"""
     try:
         client = config.get_client()
-        
+
+        # Prepare image data
+        image_url = None
+        image_data = None
+
+        if base64:
+            # Read base64 from file
+            from pathlib import Path
+            base64_path = Path(image_source)
+            if not base64_path.exists():
+                console.print(f"[red]❌ File not found: {image_source}[/red]")
+                raise typer.Exit(1)
+
+            with open(base64_path, 'r') as f:
+                image_data = f.read().strip()
+
+            console.print(f"[dim]📄 Read base64 image from {image_source} ({len(image_data)} chars)[/dim]")
+        else:
+            # Use as URL
+            image_url = image_source
+
         # Create request payload for image analysis
         sync_request = {
             "model_id": model,
             "input": {
                 "text": prompt,
-                "image_url": image_url
             },
             "max_tokens": 1000,
             "temperature": 0.7
         }
+
+        # Add image data
+        if image_data:
+            sync_request["input"]["image_data"] = image_data
+        else:
+            sync_request["input"]["image_url"] = image_url
         
         console.print(f"[dim]👁️  Analyzing image with {model}...[/dim]")
         

{lyceum_cli-1.0.14 → lyceum_cli-1.0.19}/lyceum/main.py

@@ -9,14 +9,10 @@ from rich.console import Console
 
 # Import all command modules
 from .external.auth.login import auth_app
-from .external.auth.api_keys import api_keys_app
 from .external.compute.execution.python import python_app
-from .external.compute.execution.docker import docker_app
-from .external.compute.execution.workloads import workloads_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
-from .external.general.resources import resources_app
 
 app = typer.Typer(
     name="lyceum",
@@ -28,14 +24,10 @@ console = Console()
 
 # Add all command groups
 app.add_typer(auth_app, name="auth")
-app.add_typer(api_keys_app, name="api-keys")
 app.add_typer(python_app, name="python")
-app.add_typer(docker_app, name="docker")
-app.add_typer(workloads_app, name="workloads")
 app.add_typer(batch_app, name="batch")
 app.add_typer(chat_app, name="chat")
 app.add_typer(models_app, name="models")
-app.add_typer(resources_app, name="resources")
 
 # Legacy aliases for backward compatibility
 

{lyceum_cli-1.0.14 → lyceum_cli-1.0.19}/lyceum/shared/config.py

@@ -17,7 +17,8 @@ from supabase import create_client
 import sys
 sys.path.insert(0, str(Path(__file__).parent.parent.parent / "lyceum-cloud-execution-api-client"))
 
-from lyceum_cloud_execution_api_client.client import AuthenticatedClient
+# Commented out - using httpx directly instead
+# from lyceum_cloud_execution_api_client.client import AuthenticatedClient
 
 console = Console()
 
@@ -122,23 +123,21 @@ class Config:
             console.print(f"[yellow]⚠️  Token refresh error: {e}[/yellow]")
             return False
     
-    def get_client(self) -> AuthenticatedClient:
+    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 AuthenticatedClient(
-            base_url=self.base_url,
-            token=self.api_key
-        )
+
+        # Return config instance - commands use httpx directly
+        return self
 
 
 # Global config instance

lyceum_cli-1.0.19/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 '⚪'

lyceum_cli-1.0.19/lyceum/shared/streaming.py

@@ -0,0 +1,134 @@
+"""
+Streaming utilities for execution output
+"""
+
+import json
+import re
+import httpx
+from rich.console import Console
+
+from .config import config
+
+console = Console()
+
+
+def strip_ansi_codes(text: str) -> str:
+    """Remove ANSI escape codes from text"""
+    ansi_escape = re.compile(r'\x1b\[[0-9;]*m')
+    return ansi_escape.sub('', text)
+
+
+def stream_execution_output(execution_id: str, streaming_url: str = None) -> bool:
+    """Stream execution output in real-time. Returns True if successful, False if failed."""
+    if not streaming_url:
+        # Fallback to old endpoint if no streaming URL provided
+        stream_url = f"{config.base_url}/api/v2/external/execution/streaming/{execution_id}"
+    else:
+        stream_url = streaming_url
+
+    try:
+        console.print(f"[dim]🔗 Connecting to execution stream...[/dim]")
+        console.print(f"[dim]Stream URL: {stream_url}[/dim]")
+
+        with httpx.stream("GET", stream_url, headers={"Authorization": f"Bearer {config.api_key}"}, timeout=600.0) as response:
+            if response.status_code != 200:
+                console.print(f"[red]❌ Stream failed: HTTP {response.status_code}[/red]")
+                return False
+            
+            console.print("[dim]📡 Streaming output...[/dim]")
+            
+            for line in response.iter_lines():
+                if line.strip():
+                    # Parse Server-Sent Events format
+                    if line.startswith("data: "):
+                        data_json = line[6:]  # Remove "data: " prefix
+                        try:
+                            data = json.loads(data_json)
+                            event_type = data.get("type", "unknown")
+                            
+                            if event_type == "output":
+                                # Print output without extra formatting, stripping ANSI codes
+                                output = data.get("content", "")  # Fixed: server sends "content" not "output"
+                                if output:
+                                    clean_output = strip_ansi_codes(output)
+                                    console.print(clean_output, end="")
+                            
+                            elif event_type == "completed":
+                                status = data.get("status", "unknown")
+                                exec_time = data.get("execution_time", 0)
+                                
+                                if status == "completed":
+                                    console.print(f"\n[green]✅ Execution completed successfully in {exec_time:.1f}s[/green]")
+                                elif status in ["failed_user", "failed_system"]:
+                                    console.print(f"\n[red]❌ Execution failed: {status}[/red]")
+                                    # Show errors if available
+                                    errors = data.get("errors")
+                                    if errors:
+                                        console.print(f"[red]Error: {errors}[/red]")
+                                elif status == "timeout":
+                                    console.print(f"\n[yellow]⏰ Execution timed out after {exec_time:.1f}s[/yellow]")
+                                elif status == "cancelled":
+                                    console.print(f"\n[yellow]🛑 Execution was cancelled[/yellow]")
+                                
+                                return status == "completed"
+                            
+                            elif event_type == "error":
+                                error_msg = data.get("message", "Unknown error")
+                                console.print(f"\n[red]❌ Error: {error_msg}[/red]")
+                                return False
+                                
+                        except json.JSONDecodeError:
+                            # Skip malformed JSON
+                            continue
+            
+            console.print(f"\n[yellow]⚠️ Stream ended without completion signal[/yellow]")
+            # Fallback: poll execution status
+            return check_execution_status(execution_id)
+
+    except Exception as e:
+        console.print(f"\n[red]❌ Streaming error: {e}[/red]")
+        # Fallback: poll execution status
+        return check_execution_status(execution_id)
+
+
+def check_execution_status(execution_id: str) -> bool:
+    """Check execution status as fallback when streaming fails."""
+    import time
+
+    console.print("[dim]⏳ Checking execution status...[/dim]")
+
+    for _ in range(30):  # Poll for up to 30 seconds
+        try:
+            response = httpx.get(
+                f"{config.base_url}/api/v2/external/execution/streaming/{execution_id}/status",
+                headers={"Authorization": f"Bearer {config.api_key}"},
+                timeout=10.0
+            )
+
+            if response.status_code == 200:
+                data = response.json()
+                status = data.get('status', 'unknown')
+
+                if status == 'completed':
+                    console.print(f"[green]✅ Execution completed successfully![/green]")
+                    return True
+                elif status in ['failed_user', 'failed_system', 'failed']:
+                    console.print(f"[red]❌ Execution failed: {status}[/red]")
+                    errors = data.get('errors')
+                    if errors:
+                        console.print(f"[red]Error: {errors}[/red]")
+                    return False
+                elif status in ['timeout', 'cancelled']:
+                    console.print(f"[yellow]⚠️ Execution {status}[/yellow]")
+                    return False
+                elif status in ['running', 'pending', 'queued']:
+                    # Still running, continue polling
+                    time.sleep(1)
+                    continue
+
+        except Exception as e:
+            console.print(f"[red]Error checking status: {e}[/red]")
+            break
+
+    console.print("[yellow]⚠️ Status check timed out[/yellow]")
+    return False

{lyceum_cli-1.0.14 → lyceum_cli-1.0.19}/lyceum_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lyceum-cli
-Version: 1.0.14
+Version: 1.0.19
 Summary: Command-line interface for Lyceum Cloud Execution API
 Home-page: https://lyceum.technology
 Author: Lyceum Team

lyceum_cli-1.0.19/lyceum_cli.egg-info/SOURCES.txt

@@ -0,0 +1,27 @@
+setup.py
+lyceum/__init__.py
+lyceum/main.py
+lyceum/external/__init__.py
+lyceum/external/auth/__init__.py
+lyceum/external/auth/login.py
+lyceum/external/compute/__init__.py
+lyceum/external/compute/execution/__init__.py
+lyceum/external/compute/execution/python.py
+lyceum/external/compute/inference/__init__.py
+lyceum/external/compute/inference/batch.py
+lyceum/external/compute/inference/chat.py
+lyceum/external/compute/inference/models.py
+lyceum/external/general/__init__.py
+lyceum/shared/__init__.py
+lyceum/shared/config.py
+lyceum/shared/display.py
+lyceum/shared/streaming.py
+lyceum_cli.egg-info/PKG-INFO
+lyceum_cli.egg-info/SOURCES.txt
+lyceum_cli.egg-info/dependency_links.txt
+lyceum_cli.egg-info/entry_points.txt
+lyceum_cli.egg-info/requires.txt
+lyceum_cli.egg-info/top_level.txt
+lyceum_cloud_execution_api_client/__init__.py
+lyceum_cloud_execution_api_client/api/__init__.py
+lyceum_cloud_execution_api_client/models/__init__.py

lyceum_cli-1.0.19/lyceum_cli.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+lyceum
+lyceum_cloud_execution_api_client

{lyceum_cli-1.0.14 → lyceum_cli-1.0.19}/setup.py

@@ -15,7 +15,7 @@ if readme_file.exists():
 
 setup(
     name="lyceum-cli",
-    version="1.0.14",
+    version="1.0.19",
     description="Command-line interface for Lyceum Cloud Execution API",
     long_description=long_description,
     long_description_content_type="text/markdown",

lyceum_cli-1.0.14/lyceum/external/compute/inference/__init__.py

@@ -1,5 +0,0 @@
-from .chat import chat_app
-from .batch import batch_app
-from .models import models_app
-
-__all__ = ["chat_app", "batch_app", "models_app"]

lyceum_cli-1.0.14/lyceum_cli.egg-info/SOURCES.txt

@@ -1,15 +0,0 @@
-setup.py
-lyceum/main.py
-lyceum/external/auth/login.py
-lyceum/external/compute/inference/__init__.py
-lyceum/external/compute/inference/batch.py
-lyceum/external/compute/inference/chat.py
-lyceum/external/compute/inference/models.py
-lyceum/shared/config.py
-lyceum_cli.egg-info/PKG-INFO
-lyceum_cli.egg-info/SOURCES.txt
-lyceum_cli.egg-info/dependency_links.txt
-lyceum_cli.egg-info/entry_points.txt
-lyceum_cli.egg-info/requires.txt
-lyceum_cli.egg-info/top_level.txt
-lyceum_cloud_execution_api_client/models/__init__.py

lyceum_cli-1.0.14/lyceum_cli.egg-info/top_level.txt

@@ -1 +0,0 @@
-