lyceum-cli 1.0.13__tar.gz → 1.0.18__tar.gz

{lyceum_cli-1.0.13 → lyceum_cli-1.0.18}/PKG-INFO

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

{lyceum_cli-1.0.13 → lyceum_cli-1.0.18}/lyceum/external/compute/execution/python.py

@@ -6,16 +6,13 @@ 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()
 
-# Import generated client modules
-from lyceum_cloud_execution_api_client.api.code_execution import start_execution_api_v2_external_compute_execution_run_post
-from lyceum_cloud_execution_api_client.models import CodeExecution
-
 python_app = typer.Typer(name="python", help="Python execution commands")
 
 
@@ -29,8 +26,6 @@ def run_python(
     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"""
-    client = config.get_client()
-    
     try:
         # Check if it's a file path
         code_to_execute = code_or_file
@@ -41,7 +36,7 @@ def run_python(
             # 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:
@@ -53,39 +48,47 @@ def run_python(
             else:
                 # Treat as direct pip requirements string
                 requirements_content = requirements
-        
-        # Create execution request
-        execution_request = CodeExecution(
-            code=code_to_execute,
-            execution_type=machine_type,
-            timeout=timeout,
-            file_name=file_name,
-            requirements_content=requirements_content,
-            prior_imports=imports
-        )
-        
-        response = start_execution_api_v2_external_compute_execution_run_post.sync_detailed(
-            client=client,
-            body=execution_request
+
+        # 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]")
-            if hasattr(response, 'content'):
-                console.print(f"[red]{response.content}[/red]")
+            console.print(f"[red]{response.content.decode()}[/red]")
             raise typer.Exit(1)
-        
-        data = response.parsed
+
+        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, client)
+        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]")

lyceum_cli-1.0.18/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.13 → lyceum_cli-1.0.18}/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.13 → lyceum_cli-1.0.18}/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.18/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.13 → lyceum_cli-1.0.18}/lyceum/shared/streaming.py

@@ -18,13 +18,18 @@ def strip_ansi_codes(text: str) -> str:
     return ansi_escape.sub('', text)
 
 
-def stream_execution_output(execution_id: str, client) -> bool:
+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."""
-    stream_url = f"{config.base_url}/api/v2/external/compute/execution/stream/{execution_id}"
-    
+    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]")
@@ -77,8 +82,53 @@ def stream_execution_output(execution_id: str, client) -> bool:
                             continue
             
             console.print(f"\n[yellow]⚠️ Stream ended without completion signal[/yellow]")
-            return False
-            
+            # Fallback: poll execution status
+            return check_execution_status(execution_id)
+
     except Exception as e:
         console.print(f"\n[red]❌ Streaming error: {e}[/red]")
-        return False
+        # 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.13 → lyceum_cli-1.0.18}/lyceum_cli.egg-info/PKG-INFO

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

lyceum_cli-1.0.18/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.13 → lyceum_cli-1.0.18}/setup.py

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

lyceum_cli-1.0.13/lyceum/__init__.py

@@ -1,3 +0,0 @@
-"""
-Lyceum CLI - Command-line interface for Lyceum Cloud Execution API
-"""

lyceum_cli-1.0.13/lyceum/external/auth/api_keys.py

@@ -1,58 +0,0 @@
-"""
-API key management commands
-"""
-
-import typer
-from rich.console import Console
-
-from ...shared.config import config
-from ...shared.display import create_table, format_timestamp, truncate_id
-
-console = Console()
-
-# Import generated client modules
-from lyceum_cloud_execution_api_client.api.api_keys import list_api_keys_api_v1_api_keys_get
-
-api_keys_app = typer.Typer(name="api-keys", help="API key management")
-
-
-@api_keys_app.command("list")
-def list_api_keys():
-    """List your API keys"""
-    client = config.get_client()
-    
-    try:
-        response = list_api_keys_api_v1_api_keys_get.sync_detailed(client=client)
-        
-        if response.status_code != 200:
-            console.print(f"[red]Error: HTTP {response.status_code}[/red]")
-            raise typer.Exit(1)
-        
-        api_keys = response.parsed if response.parsed else []
-        
-        if not api_keys:
-            console.print("[dim]No API keys found[/dim]")
-            return
-        
-        columns = [
-            {"header": "ID", "style": "cyan", "no_wrap": True, "max_width": 12},
-            {"header": "Name", "style": "yellow"},
-            {"header": "Active", "style": "green"},
-            {"header": "Created", "style": "dim"}
-        ]
-        
-        table = create_table("API Keys", columns)
-        
-        for key in api_keys:
-            table.add_row(
-                truncate_id(key.id, 8),
-                key.key_name, 
-                "✅" if key.is_active else "❌",
-                format_timestamp(getattr(key, 'created_at', None))
-            )
-        
-        console.print(table)
-        
-    except Exception as e:
-        console.print(f"[red]Error: {e}[/red]")
-        raise typer.Exit(1)