lyceum-cli 1.0.28__py3-none-any.whl → 1.0.30__py3-none-any.whl

lyceum/external/compute/inference/models.py

@@ -1,67 +1,52 @@
 """Model discovery and information commands for AI inference"""
 
-
 import httpx
 import typer
 from rich.console import Console
-from rich.panel import Panel
 from rich.table import Table
 
 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: 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"""
+def models_cmd():
+    """Retrieve available 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/"
+        config.get_client()
+
+        endpoint = "/api/v2/external/models/"
 
         url = f"{config.base_url}{endpoint}"
-        headers = {"Authorization": f"Bearer {config.api_key}"}
+        headers = {
+            "Authorization": f"Bearer {config.api_key}",
+            "ngrok-skip-browser-warning": "true",
+        }
 
-        console.print("[dim]🔍 Fetching available models...[/dim]")
+        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]")
+                console.print(f"[red]Error: HTTP {response.status_code}[/red]")
+                try:
+                    console.print(f"[red]{response.text}[/red]")
+                except:
+                    pass
                 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
+
+            # Filter to only available models
+            models = [m for m in models if m.get('available', False)]
 
             if not models:
-                console.print("[yellow]⚠️  No models found matching your criteria[/yellow]")
+                console.print("[yellow]No available models found.[/yellow]")
+                console.print("[dim]Deploy a new model with: lyceum infer deploy <model_id>[/dim]")
                 return
 
             # Create a detailed table
@@ -69,180 +54,22 @@ def list_models(
             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
+            # Sort models 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}]",
-                "",
-                "[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'}",
-                "",
-                "[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'):,}",
-                "",
-                "[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",
-                "",
-                "[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'
+                    model.get('type', 'text').title()
                 )
 
             console.print(table)
-            console.print(f"\n[dim]📊 Total instances: {len(instances)}[/dim]")
 
     except Exception as e:
-        console.print(f"[red]❌ Error: {e}[/red]")
+        console.print(f"[red]Error: {e}[/red]")
         raise typer.Exit(1)

lyceum/main.py

@@ -14,7 +14,9 @@ from .external.compute.execution.docker import docker_app
 from .external.compute.execution.docker_compose import compose_app
 from .external.compute.execution.workloads import workloads_app
 from .external.compute.execution.notebook import notebook_app
-from .external.vms.management import vms_app
+from .external.compute.execution.gpu_selection import gpu_selection_app
+# from .external.compute.inference.infer import infer_app
+# from .external.vms.management import vms_app
 
 app = typer.Typer(
     name="lyceum",
@@ -31,6 +33,9 @@ app.add_typer(docker_app, name="docker")
 app.add_typer(compose_app, name="compose")
 app.add_typer(workloads_app, name="workloads")
 app.add_typer(notebook_app, name="notebook")
+app.add_typer(gpu_selection_app, name="gpu-selection")
+# app.add_typer(infer_app, name="infer")
+# app.add_typer(vms_app, name="vms")
 
 
 

lyceum/shared/config.py

@@ -16,9 +16,12 @@ console = Console()
 CONFIG_DIR = Path.home() / ".lyceum"
 CONFIG_FILE = CONFIG_DIR / "config.json"
 
-# Supabase configuration - these are public anon keys safe for client-side use
+# Supabase configuration from environment variables
 SUPABASE_URL = os.getenv("SUPABASE_URL", "https://tqcebgbexyszvqhnwnhh.supabase.co")
-SUPABASE_ANON_KEY = os.getenv("SUPABASE_ANON_KEY", "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InRxY2ViZ2JleHlzenZxaG53bmhoIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NDcxNTQ0NzEsImV4cCI6MjA2MjczMDQ3MX0.VvPV8oRJUSGadaPf9RwTn6URuC_5oL7KulsJgE2vpH4")
+SUPABASE_ANON_KEY = os.getenv(
+    "SUPABASE_ANON_KEY",
+    "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InRxY2ViZ2JleHlzenZxaG53bmhoIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NDcxNTQ0NzEsImV4cCI6MjA2MjczMDQ3MX0.VvPV8oRJUSGadaPf9RwTn6URuC_5oL7KulsJgE2vpH4"
+)
 
 
 class _Config:
@@ -88,13 +91,6 @@ class _Config:
             return False
 
         try:
-            # Check if Supabase credentials are configured
-            if not SUPABASE_URL or not SUPABASE_ANON_KEY:
-                console.print(
-                    "[red]Error: SUPABASE_URL and SUPABASE_ANON_KEY environment variables must be set[/red]"
-                )
-                return False
-
             # Use Supabase's refresh_session method with the public anon key
             # This is safe for client-side use and properly scoped for user token refresh
             supabase = create_client(SUPABASE_URL, SUPABASE_ANON_KEY)

lyceum/shared/streaming.py

@@ -60,7 +60,7 @@ def normalize_newlines(text: str) -> str:
     return re.sub(r'\n{2,}', '\n', text)
 
 
-def stream_execution_output(execution_id: str, streaming_url: str = None) -> bool:
+def stream_execution_output(execution_id: str, streaming_url: str = None, status: StatusLine = None) -> bool:
     """Stream execution output in real-time. Returns True if successful, False if failed."""
     if not streaming_url:
         # Fallback to stream endpoint if no streaming URL provided
@@ -69,15 +69,25 @@ def stream_execution_output(execution_id: str, streaming_url: str = None) -> boo
         stream_url = streaming_url
 
     try:
-        console.print("[dim]Connecting to execution stream...[/dim]")
-
-        headers = {"Authorization": f"Bearer {config.api_key}"}
-        with httpx.stream("GET", stream_url, headers=headers, timeout=600.0) as response:
+        if status:
+            status.update("Connecting to stream...")
+
+        headers = {
+            "Accept": "text/event-stream",
+            "Cache-Control": "no-cache",
+        }
+        with httpx.stream("POST", stream_url, headers=headers, timeout=600.0) as response:
             if response.status_code != 200:
-                console.print(f"[red]Stream failed: HTTP {response.status_code}[/red]")
+                if status:
+                    status.stop()
+                if response.status_code == 404:
+                    console.print("[yellow]Stream not found - execution may have already completed[/yellow]")
+                else:
+                    console.print(f"[red]Stream failed: HTTP {response.status_code}[/red]")
                 return False
 
-            console.print("[dim]Streaming output...[/dim]")
+            if status:
+                status.update("Waiting for output...")
 
             first_output = True
             for line in response.iter_lines():
@@ -93,6 +103,10 @@ def stream_execution_output(execution_id: str, streaming_url: str = None) -> boo
                                 output_data = data["output"]
                                 content = output_data.get("content", "")
                                 if content:
+                                    # Stop status spinner on first output
+                                    if first_output and status:
+                                        status.stop()
+                                        first_output = False
                                     clean_output = strip_ansi_codes(content)
                                     # Normalize newlines to avoid excessive blank lines
                                     clean_output = normalize_newlines(clean_output)
@@ -100,6 +114,8 @@ def stream_execution_output(execution_id: str, streaming_url: str = None) -> boo
 
                             # Handle job finished event
                             elif "jobFinished" in data:
+                                if status:
+                                    status.stop()
                                 job_data = data["jobFinished"]
                                 job = job_data.get("job", {})
                                 result = job.get("result", {})
@@ -110,6 +126,7 @@ def stream_execution_output(execution_id: str, streaming_url: str = None) -> boo
                                 if not first_output:
                                     print()
 
+                                # Check for system failure (error field present)
                                 if error:
                                     console.print(f"[red]{error}[/red]")
                                     return False
@@ -126,34 +143,46 @@ def stream_execution_output(execution_id: str, streaming_url: str = None) -> boo
                                 if event_type == "output":
                                     output = data.get("content", "")
                                     if output:
+                                        if first_output and status:
+                                            status.stop()
+                                            first_output = False
                                         clean_output = strip_ansi_codes(output)
                                         clean_output = normalize_newlines(clean_output)
                                         print(clean_output, end="", flush=True)
 
                                 elif event_type == "completed":
-                                    status = data.get("status", "unknown")
-                                    if status == "completed":
-                                        console.print("\n[green]Execution completed successfully[/green]")
+                                    if status:
+                                        status.stop()
+                                    status_val = data.get("status", "unknown")
+                                    if not first_output:
+                                        print()
+                                    if status_val == "completed":
                                         return True
                                     else:
-                                        console.print(f"\n[red]Execution failed: {status}[/red]")
+                                        console.print(f"[red]Failed: {status_val}[/red]")
                                         return False
 
                                 elif event_type == "error":
+                                    if status:
+                                        status.stop()
                                     error_msg = data.get("message", "Unknown error")
-                                    console.print(f"\n[red]Error: {error_msg}[/red]")
+                                    console.print(f"[red]Error: {error_msg}[/red]")
                                     return False
 
                         except json.JSONDecodeError:
                             # Skip malformed JSON
                             continue
 
-            console.print("\n[yellow]Stream ended without completion signal[/yellow]")
+            if status:
+                status.stop()
+            console.print("[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]")
+        if status:
+            status.stop()
+        console.print(f"[red]Streaming error: {e}[/red]")
         # Fallback: poll execution status
         return check_execution_status(execution_id)
 
@@ -177,16 +206,15 @@ def check_execution_status(execution_id: str) -> bool:
                 status = data.get('status', 'unknown')
 
                 if status == 'completed':
-                    console.print("[green]Execution completed successfully[/green]")
                     return True
                 elif status in ['failed_user', 'failed_system', 'failed']:
-                    console.print(f"[red]Execution failed: {status}[/red]")
+                    console.print(f"[red]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]")
+                    console.print(f"[yellow]{status.capitalize()}[/yellow]")
                     return False
                 elif status in ['running', 'pending', 'queued']:
                     # Still running, continue polling

{lyceum_cli-1.0.28.dist-info → lyceum_cli-1.0.30.dist-info}/METADATA

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

{lyceum_cli-1.0.28.dist-info → lyceum_cli-1.0.30.dist-info}/RECORD

@@ -1,5 +1,5 @@
 lyceum/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-lyceum/main.py,sha256=s4ZvNPGMeGoV9AIq68hEwfo9ioFfu2qIoRXb2upjNDk,1076
+lyceum/main.py,sha256=8outCbb7DSurGzwG1EX_5k89l85OeBgxUUedbjj6UIQ,1341
 lyceum/external/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 lyceum/external/auth/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 lyceum/external/auth/login.py,sha256=-yJ0aEV8_vDXiT6BXzjpqZ2uDdnTnkop4qhagw2dSZA,23447
@@ -8,27 +8,29 @@ lyceum/external/compute/execution/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZ
 lyceum/external/compute/execution/config.py,sha256=6JJgLJnDPTwevEaNdB1nEICih_qbBmws5u5_S9gj7k0,8866
 lyceum/external/compute/execution/docker.py,sha256=0Y6lxJAm56Jrl0HxeNz1mX6DGs556i2iMN9_U1JQP0c,9635
 lyceum/external/compute/execution/docker_compose.py,sha256=YsWPnw5nB1ZpqjU9X8o_klT78I5m46PapVwVEeWra_8,9189
+lyceum/external/compute/execution/gpu_selection.py,sha256=1rLFUAxqY6TiRcEfeduNnScGw0QbxSSMbgTAQ3QWMhQ,39020
 lyceum/external/compute/execution/notebook.py,sha256=Gw9UhJ-UjYhpjdIYQ4IMYhVjhSkAFpOQ9aFYj1qOeww,7542
 lyceum/external/compute/execution/python.py,sha256=8Y9ElWs9RdauQbhECKcBPSoT0XZeGhXZ_pkEpr3sGro,12878
 lyceum/external/compute/execution/workloads.py,sha256=4fsRWbYGmsQMGPPIN1jUG8cG5NPG9yV26ANJ-DtaXqc,5844
 lyceum/external/compute/inference/__init__.py,sha256=4YLoUKDEzitexynJv_Q5O0w1lty8CJ6uyRxuc1LiaBw,89
-lyceum/external/compute/inference/batch.py,sha256=mgEndr02UM1j00o-iRLUpDqS5KFvyg0Htc0Gg0s3hTU,11394
-lyceum/external/compute/inference/chat.py,sha256=hITj_UGLaxCJQskU-YbeaEerM5Xt_eJpEsYrTJoUpk4,8485
-lyceum/external/compute/inference/models.py,sha256=BkCEdvyliezGOUulj557e-Eoif0_HKR3CxqpEhdAZaA,10339
+lyceum/external/compute/inference/batch.py,sha256=F4MlR2IEi1X7qUo3UDUVRWclHLLmmjqu7KZ3RkHIjNM,4349
+lyceum/external/compute/inference/chat.py,sha256=vGjRLYcR31jHCpHKhlZHJB9obboScz_RcuyHZ_yW1Ts,5301
+lyceum/external/compute/inference/infer.py,sha256=vf0jXN3Hb7H_dfI6dqZrp9oJiwutznHamFnhqa_Izig,3829
+lyceum/external/compute/inference/models.py,sha256=fZDZb4YRbzqEIU3CGfGD6t8BiSUJD-voMqtBCiwsVDE,2438
 lyceum/external/general/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 lyceum/external/vms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lyceum/external/vms/instances.py,sha256=8DKpI8PbyZFzk5RT-IPgoMDjkf_-HC-2pJKuSFs-5BA,11007
 lyceum/external/vms/management.py,sha256=dYEkN5Qiur-SG4G5CLOk2Rbr0HW3rK1BROSp0K6KxC8,15405
 lyceum/shared/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-lyceum/shared/config.py,sha256=XGMmoGVzmcxSvS-s1kDbOkp_LEGY-wEenKZ8cb4NBBM,5656
+lyceum/shared/config.py,sha256=gEXf_hEmgUq3rSxU2SY75qg32mFS6qsruox7uvQlf3I,5334
 lyceum/shared/display.py,sha256=-VSAfoa0yivTvxRrN2RYr2Sq1x_msZqENjnkSedmbhQ,4444
 lyceum/shared/imports.py,sha256=wEG4wfVTIqJ6MBWDRAN96iGmVCb9ST2aOqSjkbvajug,11768
-lyceum/shared/streaming.py,sha256=x3zA8Pn9ia06t8nKJfP6hztxOVKPUC3Nk3qmAiIsl9M,8194
+lyceum/shared/streaming.py,sha256=wFb7w7fra63y8WWaIA8_E1Z6Sx_6G-0J53Zh010eZgk,9355
 lyceum_cloud_execution_api_client/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 lyceum_cloud_execution_api_client/api/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 lyceum_cloud_execution_api_client/models/__init__.py,sha256=AMlb9R9O9aNC9hvKz_8TFpEfOolYC3VtFS5JX17kYks,4888
-lyceum_cli-1.0.28.dist-info/METADATA,sha256=gsm3uSzI8owqGaoCDqiHeYCAHYmCr-CVafDknHw1KUA,1482
-lyceum_cli-1.0.28.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-lyceum_cli-1.0.28.dist-info/entry_points.txt,sha256=Oq-9wDkxVd6MHgNiUTYwXI9SGhvR3VkD7Mvk0xhiUZo,43
-lyceum_cli-1.0.28.dist-info/top_level.txt,sha256=CR7FEMloAXgLsHUR6ti3mWNcpgje27HRHSfq8doIils,41
-lyceum_cli-1.0.28.dist-info/RECORD,,
+lyceum_cli-1.0.30.dist-info/METADATA,sha256=pdV-mL-39UWQJfpEd91DK88AWhgCO-KD2GV5tWaJtLs,1482
+lyceum_cli-1.0.30.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+lyceum_cli-1.0.30.dist-info/entry_points.txt,sha256=Oq-9wDkxVd6MHgNiUTYwXI9SGhvR3VkD7Mvk0xhiUZo,43
+lyceum_cli-1.0.30.dist-info/top_level.txt,sha256=CR7FEMloAXgLsHUR6ti3mWNcpgje27HRHSfq8doIils,41
+lyceum_cli-1.0.30.dist-info/RECORD,,

{lyceum_cli-1.0.28.dist-info → lyceum_cli-1.0.30.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any