lyceum-cli 1.0.23__tar.gz → 1.0.25__tar.gz

{lyceum_cli-1.0.23 → lyceum_cli-1.0.25}/PKG-INFO

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

{lyceum_cli-1.0.23 → lyceum_cli-1.0.25}/lyceum/external/auth/login.py

@@ -483,4 +483,4 @@ def status():
         except Exception as e:
             console.print(f"[red]❌ API connection failed: {e}[/red]")
     else:
-        console.print("[red]❌ Not authenticated. Run 'lyceum auth login' first.[/red]")
+        console.print("[red]❌ Not authenticated. Run 'lyceum login' first.[/red]")

lyceum_cli-1.0.25/lyceum/external/compute/execution/config.py

@@ -0,0 +1,258 @@
+"""Workspace configuration commands for Python execution"""
+
+import importlib.metadata as im
+import json
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from ....shared.imports import (
+    is_stdlib_module_by_name,
+    should_skip_path,
+    find_imports_in_file,
+    SKIP_DIRS,
+)
+
+console = Console()
+
+config_app = typer.Typer(name="config", help="Workspace configuration commands")
+
+# Known package name mismatches (import name -> pip name)
+PACKAGE_NAME_MAP = {
+    "sklearn": "scikit-learn",
+    "cv2": "opencv-python",
+    "PIL": "Pillow",
+    "bs4": "beautifulsoup4",
+    "yaml": "PyYAML",
+    "Crypto": "pycryptodome",
+    "OpenSSL": "pyOpenSSL",
+    "cudf": "cudf-cu12",
+    "cpuinfo": "py-cpuinfo",
+}
+
+
+def get_package_name(module_name: str) -> str:
+    """Convert import name to pip package name."""
+    top_level = module_name.split(".")[0]
+    return PACKAGE_NAME_MAP.get(top_level, top_level)
+
+
+def get_installed_version(package_name: str) -> Optional[str]:
+    """Get installed version of a package."""
+    try:
+        return im.version(package_name)
+    except Exception:
+        return None
+
+
+def find_local_packages(workspace: Path) -> dict[str, Path]:
+    """Find all local Python packages in the workspace recursively."""
+    packages = {}
+
+    for init_file in workspace.rglob("__init__.py"):
+        if should_skip_path(init_file):
+            continue
+
+        package_dir = init_file.parent
+        parent_init = package_dir.parent / "__init__.py"
+        if parent_init.exists() and not should_skip_path(parent_init):
+            continue
+
+        try:
+            rel_path = package_dir.relative_to(workspace)
+            packages[str(rel_path)] = package_dir
+        except ValueError:
+            pass
+
+    for item in workspace.iterdir():
+        if should_skip_path(item):
+            continue
+        if item.is_file() and item.suffix == ".py" and item.stem != "__init__":
+            packages[item.stem] = item
+
+    return packages
+
+
+def collect_all_python_files(workspace: Path) -> list[Path]:
+    """Collect all Python files in the workspace."""
+    py_files = []
+    for py_file in workspace.rglob("*.py"):
+        if not should_skip_path(py_file):
+            py_files.append(py_file)
+    return py_files
+
+
+def parse_requirements_file(req_file: Path) -> list[str]:
+    """Parse a requirements.txt file into a list of dependencies."""
+    deps = []
+    try:
+        with open(req_file) as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith("#") and not line.startswith("-"):
+                    deps.append(line)
+    except Exception:
+        pass
+    return deps
+
+
+def extract_package_name(dep: str) -> str:
+    """Extract package name from a dependency string."""
+    return dep.split("==")[0].split(">=")[0].split("<=")[0].split("<")[0].split(">")[0].split("[")[0].split("~=")[0].lower()
+
+
+@config_app.command("init")
+def init_config(
+    workspace: Path = typer.Argument(".", help="Workspace directory to analyze"),
+    requirements: Path | None = typer.Option(
+        None, "--requirements", "-r", help="Path to requirements.txt"
+    ),
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing config"),
+):
+    """Initialize workspace configuration for Lyceum Cloud execution.
+
+    Scans the workspace to detect:
+    - Local Python packages (for import resolution at runtime)
+    - External dependencies (from imports and requirements.txt)
+
+    Creates .lyceum/config.json with workspace metadata.
+    Local file contents are resolved at runtime based on what each script imports.
+
+    Example:
+        lyceum python config init
+        lyceum python config init ./my-project
+        lyceum python config init -r requirements.txt
+    """
+    workspace = Path(workspace).resolve()
+
+    if not workspace.exists():
+        console.print(f"[red]Error: Workspace directory does not exist: {workspace}[/red]")
+        raise typer.Exit(1)
+
+    config_dir = workspace / ".lyceum"
+    config_file = config_dir / "config.json"
+
+    if config_file.exists() and not force:
+        console.print(f"[yellow]Config already exists: {config_file}[/yellow]")
+        console.print("[dim]Use --force to overwrite[/dim]")
+        raise typer.Exit(1)
+
+    console.print(f"[dim]Scanning workspace: {workspace}[/dim]")
+
+    # Find local packages
+    local_packages = find_local_packages(workspace)
+    console.print(f"[dim]Found {len(local_packages)} local packages/modules[/dim]")
+
+    if local_packages:
+        for name in sorted(local_packages.keys())[:10]:
+            console.print(f"[dim]  - {name}[/dim]")
+        if len(local_packages) > 10:
+            console.print(f"[dim]  ... and {len(local_packages) - 10} more[/dim]")
+
+    # Collect all Python files for import scanning
+    py_files = collect_all_python_files(workspace)
+    console.print(f"[dim]Found {len(py_files)} Python files[/dim]")
+
+    # Scan all files for imports to detect external dependencies
+    all_imports = set()
+    for py_file in py_files:
+        all_imports.update(find_imports_in_file(py_file))
+
+    # Filter to external dependencies
+    local_package_names = {Path(p).parts[0] if "/" in p else p for p in local_packages.keys()}
+    external_deps = {
+        imp for imp in all_imports
+        if not is_stdlib_module_by_name(imp) and imp not in local_package_names
+    }
+    console.print(f"[dim]Found {len(external_deps)} external dependencies from imports[/dim]")
+
+    # Parse requirements.txt
+    requirements_deps = []
+    req_file = requirements or workspace / "requirements.txt"
+    if req_file.exists():
+        console.print(f"[dim]Reading requirements from: {req_file}[/dim]")
+        requirements_deps = parse_requirements_file(req_file)
+
+    # Build merged dependencies with versions
+    merged_deps = []
+    req_names = {extract_package_name(dep) for dep in requirements_deps}
+
+    for dep in requirements_deps:
+        merged_deps.append(dep)
+
+    for imp in sorted(external_deps):
+        pkg_name = get_package_name(imp)
+        if pkg_name.lower() not in req_names:
+            version = get_installed_version(pkg_name)
+            if version:
+                merged_deps.append(f"{pkg_name}=={version}")
+            else:
+                merged_deps.append(pkg_name)
+
+    # Build config (no local_imports - resolved at runtime)
+    config_data = {
+        "workspace": str(workspace),
+        "local_packages": {name: str(path) for name, path in sorted(local_packages.items())},
+        "dependencies": {
+            "from_imports": sorted(external_deps),
+            "from_requirements": requirements_deps,
+            "merged": sorted(set(merged_deps), key=str.lower),
+        },
+    }
+
+    # Write config
+    config_dir.mkdir(exist_ok=True)
+    with open(config_file, "w") as f:
+        json.dump(config_data, f, indent=2)
+
+    console.print(f"[green]Created config: {config_file}[/green]")
+    console.print(f"[dim]  - {len(local_packages)} local packages[/dim]")
+    console.print(f"[dim]  - {len(config_data['dependencies']['merged'])} dependencies[/dim]")
+    console.print("[dim]  - Local imports resolved at runtime per-file[/dim]")
+
+
+@config_app.command("show")
+def show_config(
+    workspace: Path = typer.Argument(".", help="Workspace directory"),
+):
+    """Show current workspace configuration."""
+    workspace = Path(workspace).resolve()
+    config_file = workspace / ".lyceum" / "config.json"
+
+    if not config_file.exists():
+        console.print(f"[yellow]No config found at: {config_file}[/yellow]")
+        console.print("[dim]Run 'lyceum python config init' to create one[/dim]")
+        raise typer.Exit(1)
+
+    with open(config_file) as f:
+        config_data = json.load(f)
+
+    console.print(f"[bold]Workspace:[/bold] {config_data.get('workspace', 'unknown')}")
+
+    local_packages = config_data.get("local_packages", {})
+    console.print(f"\n[bold]Local packages ({len(local_packages)}):[/bold]")
+    for pkg in list(local_packages.keys())[:15]:
+        console.print(f"  - {pkg}")
+    if len(local_packages) > 15:
+        console.print(f"  ... and {len(local_packages) - 15} more")
+
+    deps = config_data.get("dependencies", {})
+    merged = deps.get("merged", [])
+    console.print(f"\n[bold]Dependencies ({len(merged)}):[/bold]")
+    for dep in merged[:20]:
+        console.print(f"  - {dep}")
+    if len(merged) > 20:
+        console.print(f"  ... and {len(merged) - 20} more")
+
+
+@config_app.command("refresh")
+def refresh_config(
+    workspace: Path = typer.Argument(".", help="Workspace directory"),
+    requirements: Path | None = typer.Option(
+        None, "--requirements", "-r", help="Path to requirements.txt"
+    ),
+):
+    """Refresh workspace configuration (re-scans the workspace)."""
+    init_config(workspace=workspace, requirements=requirements, force=True)

lyceum_cli-1.0.25/lyceum/external/compute/execution/docker.py

@@ -0,0 +1,272 @@
+"""
+Docker execution commands
+"""
+
+import json
+import shlex
+from typing import Optional
+
+import httpx
+import typer
+from rich.console import Console
+
+from ....shared.config import config
+from ....shared.streaming import StatusLine, stream_execution_output
+
+console = Console()
+
+
+docker_app = typer.Typer(name="docker", help="Docker execution commands")
+
+
+@docker_app.command("run")
+def run_docker(
+    image: str = typer.Argument(..., help="Docker image to run"),
+    machine_type: str = typer.Option(
+        "cpu", "--machine", "-m", help="Machine type (cpu, a100, h100, etc.)"
+    ),
+    timeout: int = typer.Option(
+        300, "--timeout", "-t", help="Execution timeout in seconds"
+    ),
+    file_name: Optional[str] = typer.Option(
+        None, "--file-name", "-f", help="Name for the execution"
+    ),
+    command: Optional[str] = typer.Option(
+        None,
+        "--command",
+        "-c",
+        help="Command to run in container (e.g., 'python app.py')",
+    ),
+    env: Optional[list[str]] = typer.Option(
+        None, "--env", "-e", help="Environment variables (e.g., KEY=value)"
+    ),
+    detach: bool = typer.Option(
+        False, "--detach", "-d", help="Run container in background and print execution ID"
+    ),
+    callback_url: Optional[str] = typer.Option(
+        None, "--callback", help="Webhook URL for completion notification"
+    ),
+    registry_creds: Optional[str] = typer.Option(
+        None, "--registry-creds", help="Docker registry credentials as JSON string"
+    ),
+    registry_type: Optional[str] = typer.Option(
+        None, "--registry-type", help="Registry credential type: basic, aws, etc."
+    ),
+):
+    """Execute a Docker container on Lyceum Cloud.
+
+    By default, streams container output in real-time.
+    Use --detach to run in background and return immediately.
+
+    Examples:
+        lyceum docker run python:3.11 -c "python -c 'print(1+1)'"
+        lyceum docker run myapp:latest -e "DEBUG=true"
+        lyceum docker run nvidia/cuda:12.0-base -m a100 -d
+    """
+    status = StatusLine()
+
+    try:
+        config.get_client()
+
+        status.start()
+        status.update("Validating configuration...")
+
+        # Parse environment variables
+        docker_env = {}
+        if env:
+            for env_var in env:
+                if "=" in env_var:
+                    key, value = env_var.split("=", 1)
+                    docker_env[key] = value
+                else:
+                    status.stop()
+                    console.print(
+                        f"[yellow]Warning: Ignoring invalid env var format: {env_var}[/yellow]"
+                    )
+                    status.start()
+
+        # Parse registry credentials
+        registry_credentials = None
+        if registry_creds:
+            try:
+                registry_credentials = json.loads(registry_creds)
+            except json.JSONDecodeError:
+                status.stop()
+                console.print(
+                    "[red]Error: Invalid JSON format for registry credentials[/red]"
+                )
+                raise typer.Exit(1)
+
+        # Validate registry credentials and type
+        if (registry_creds and not registry_type) or (
+            registry_type and not registry_creds
+        ):
+            status.stop()
+            console.print(
+                "[red]Error: Both --registry-creds and --registry-type must be provided together[/red]"
+            )
+            raise typer.Exit(1)
+
+        status.update(f"Starting container {image}...")
+
+        # Build request for v2 image API
+        image_request = {
+            "docker_image_ref": image,
+            "timeout": timeout,
+            "execution_type": machine_type,
+        }
+
+        if command:
+            image_request["docker_run_cmd"] = shlex.split(command)
+        if file_name:
+            image_request["file_name"] = file_name
+        if env:
+            # Join with newlines - the execlet parses env vars by splitting on \n
+            image_request["docker_run_env"] = "\n".join(env)
+
+        # Handle registry credentials
+        if registry_type and registry_credentials:
+            image_request["docker_registry_credential_type"] = registry_type
+
+            if registry_type == "aws":
+                creds = registry_credentials
+                image_request.update(
+                    {
+                        "aws_access_key_id": creds.get("aws_access_key_id"),
+                        "aws_secret_access_key": creds.get("aws_secret_access_key"),
+                        "aws_session_token": creds.get("aws_session_token"),
+                        "aws_region": creds.get("region", "us-east-1"),
+                    }
+                )
+            elif registry_type == "basic":
+                creds = registry_credentials
+                image_request.update(
+                    {
+                        "docker_username": creds.get("username"),
+                        "docker_password": creds.get("password"),
+                    }
+                )
+
+        # Call the v2 image endpoint
+        status.update("Submitting execution...")
+
+        response = httpx.post(
+            f"{config.base_url}/api/v2/external/execution/image/start",
+            json=image_request,
+            headers={"Authorization": f"Bearer {config.api_key}"},
+            timeout=30.0,
+        )
+
+        if response.status_code != 200:
+            status.stop()
+            console.print(f"[red]Error: HTTP {response.status_code}[/red]")
+            if response.status_code == 401:
+                console.print(
+                    "[red]Authentication failed. Your session may have expired.[/red]"
+                )
+                console.print("[yellow]Run 'lyceum auth login' to re-authenticate.[/yellow]")
+            elif response.content:
+                console.print(f"[red]{response.content.decode()}[/red]")
+            raise typer.Exit(1)
+
+        result = response.json()
+        execution_id = result.get("execution_id")
+        streaming_url = result.get("streaming_url")
+
+        if detach:
+            # Detached mode - just return the execution info
+            status.stop()
+            console.print(f"[dim]Image: {image}[/dim]")
+            console.print(f"[dim]Machine: {machine_type}[/dim]")
+            console.print(f"[dim]Execution ID: {execution_id}[/dim]")
+            console.print("")
+            console.print(f"[dim]To stream logs:[/dim] lyceum docker logs {execution_id}")
+        else:
+            # Default: stream output in real-time (like docker run)
+            success = stream_execution_output(execution_id, streaming_url, status)
+
+            # Show execution ID at the end
+            console.print(f"[dim]Execution ID: {execution_id}[/dim]")
+
+            if not success:
+                raise typer.Exit(1)
+
+    except typer.Exit:
+        status.stop()
+        raise
+    except Exception as e:
+        status.stop()
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@docker_app.command("logs")
+def docker_logs(
+    execution_id: str = typer.Argument(..., help="Execution ID to stream logs from"),
+):
+    """Stream logs from a running or completed Docker execution.
+
+    Examples:
+        lyceum docker logs 9d73319c-6f1c-4b4c-90e4-044244353ce4
+    """
+    status = StatusLine()
+
+    try:
+        config.get_client()
+
+        status.start()
+        status.update("Connecting to execution...")
+
+        # Pass None for streaming_url to use the default v2 endpoint
+        success = stream_execution_output(execution_id, None, status)
+
+        console.print(f"[dim]Execution ID: {execution_id}[/dim]")
+
+        if not success:
+            raise typer.Exit(1)
+
+    except typer.Exit:
+        status.stop()
+        raise
+    except Exception as e:
+        status.stop()
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@docker_app.command("registry-examples")
+def show_registry_examples():
+    """Show examples of Docker registry credential formats"""
+    console.print("[bold cyan]Docker Registry Credential Examples[/bold cyan]\n")
+
+    console.print("[bold]1. Docker Hub (basic)[/bold]")
+    console.print("Type: [green]basic[/green]")
+    console.print(
+        'Credentials: [yellow]\'{"username": "myuser", "password": "mypassword"}\'[/yellow]\n'
+    )
+
+    console.print("[bold]2. AWS ECR (aws)[/bold]")
+    console.print("Type: [green]aws[/green]")
+    console.print(
+        'Credentials: [yellow]\'{"region": "us-west-2", "aws_access_key_id": "AKIAI...", "aws_secret_access_key": "wJalrX...", "session_token": "optional..."}\'[/yellow]\n'
+    )
+
+    console.print("[bold]3. Private Registry (basic)[/bold]")
+    console.print("Type: [green]basic[/green]")
+    console.print(
+        'Credentials: [yellow]\'{"username": "admin", "password": "secret"}\'[/yellow]\n'
+    )
+
+    console.print("[bold]Example Commands:[/bold]")
+    console.print("# Docker Hub:")
+    console.print(
+        "[dim]lyceum docker run myuser/myapp:latest --registry-type basic --registry-creds '{\"username\": \"myuser\", \"password\": \"mytoken\"}'[/dim]"
+    )
+    console.print("\n# AWS ECR:")
+    console.print(
+        "[dim]lyceum docker run 123456789012.dkr.ecr.us-west-2.amazonaws.com/myapp:latest --registry-type aws --registry-creds '{\"region\": \"us-west-2\", \"aws_access_key_id\": \"AKIAI...\", \"aws_secret_access_key\": \"wJalrX...\"}'[/dim]"
+    )
+    console.print("\n# Private Registry:")
+    console.print(
+        "[dim]lyceum docker run myregistry.com/myapp:latest --registry-type basic --registry-creds '{\"username\": \"admin\", \"password\": \"secret\"}'[/dim]"
+    )

lyceum_cli-1.0.25/lyceum/external/compute/execution/docker_config.py

@@ -0,0 +1,123 @@
+"""Docker registry configuration commands"""
+
+import json
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+docker_config_app = typer.Typer(name="config", help="Docker registry configuration")
+
+CONFIG_DIR = Path.home() / ".lyceum"
+DOCKER_CONFIG_FILE = CONFIG_DIR / "docker-registries.json"
+
+
+def load_docker_config() -> dict:
+    """Load docker registry configuration."""
+    if DOCKER_CONFIG_FILE.exists():
+        try:
+            with open(DOCKER_CONFIG_FILE) as f:
+                return json.load(f)
+        except Exception:
+            pass
+    return {"registries": {}}
+
+
+def save_docker_config(config: dict) -> None:
+    """Save docker registry configuration."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    with open(DOCKER_CONFIG_FILE, "w") as f:
+        json.dump(config, f, indent=2)
+    # Set restrictive permissions since this contains credentials
+    DOCKER_CONFIG_FILE.chmod(0o600)
+
+
+def get_hub_credentials(image: str) -> dict | None:
+    """Get Docker Hub credentials if the image is from Docker Hub.
+
+    Docker Hub images either have no registry prefix or use docker.io.
+    Returns None if no credentials found or image is not from Docker Hub.
+    """
+    config = load_docker_config()
+    registries = config.get("registries", {})
+
+    if "hub" not in registries:
+        return None
+
+    # Check if this looks like a Docker Hub image
+    # Docker Hub: no dots in the first part, or explicitly docker.io
+    if "/" not in image:
+        # Single name like "python:3.9" - it's Docker Hub
+        return registries["hub"]
+
+    parts = image.split("/")
+    first_part = parts[0]
+
+    # If first part has a dot, it's a custom registry (not Docker Hub)
+    # Exception: docker.io is Docker Hub
+    if "." in first_part and first_part != "docker.io":
+        return None
+
+    # Otherwise it's Docker Hub (e.g., "myuser/myimage" or "docker.io/myuser/myimage")
+    return registries["hub"]
+
+
+@docker_config_app.command("hub")
+def configure_hub():
+    """Configure Docker Hub credentials interactively."""
+    console.print("\n[bold]Docker Hub Configuration[/bold]")
+    console.print("[dim]These credentials will be used for private Docker Hub images.[/dim]\n")
+
+    username = typer.prompt("Docker Hub Username")
+    password = typer.prompt("Docker Hub Password/Token", hide_input=True)
+
+    config = load_docker_config()
+    config["registries"]["hub"] = {
+        "username": username,
+        "password": password,
+    }
+    save_docker_config(config)
+
+    console.print("\n[green]Docker Hub credentials saved![/green]")
+    console.print("[dim]Credentials stored in ~/.lyceum/docker-registries.json[/dim]")
+
+
+@docker_config_app.command("show")
+def show_config():
+    """Show configured docker registries."""
+    config = load_docker_config()
+    registries = config.get("registries", {})
+
+    if not registries:
+        console.print("[dim]No docker registries configured.[/dim]")
+        console.print("[dim]Run 'lyceum docker config hub' to configure Docker Hub.[/dim]")
+        console.print("[dim]For AWS ECR, use 'lyceum docker run <image> --aws' to auto-detect credentials.[/dim]")
+        return
+
+    table = Table(title="Configured Docker Registries")
+    table.add_column("Registry", style="cyan")
+    table.add_column("Details", style="dim")
+
+    if "hub" in registries:
+        hub = registries["hub"]
+        username = hub.get("username", "")
+        table.add_row("Docker Hub", f"User: {username}")
+
+    console.print(table)
+    console.print("\n[dim]For AWS ECR, use 'lyceum docker run <image> --aws' to auto-detect credentials.[/dim]")
+
+
+@docker_config_app.command("clear")
+def clear_config():
+    """Clear saved Docker Hub credentials."""
+    config = load_docker_config()
+
+    if "hub" in config.get("registries", {}):
+        del config["registries"]["hub"]
+        save_docker_config(config)
+        console.print("[green]Cleared Docker Hub credentials.[/green]")
+    else:
+        console.print("[yellow]No Docker Hub credentials found.[/yellow]")