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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lyceum-cli
-Version: 1.0.24
+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.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]")

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

@@ -0,0 +1,242 @@
+"""
+Jupyter Notebook execution commands
+"""
+
+from typing import Optional
+
+import httpx
+import typer
+from rich.console import Console
+
+from ....shared.config import config
+from ....shared.streaming import StatusLine
+
+console = Console()
+
+notebook_app = typer.Typer(name="notebook", help="Launch Jupyter notebooks on Lyceum Cloud")
+
+# Pre-built Jupyter notebook image (linux/amd64)
+JUPYTER_IMAGE = "jupyter/base-notebook:latest"
+
+
+@notebook_app.command("launch")
+def launch_notebook(
+    machine_type: str = typer.Option(
+        "cpu", "--machine", "-m", help="Machine type (cpu, a100, h100, etc.)"
+    ),
+    timeout: int = typer.Option(
+        600, "--timeout", "-t", help="Session timeout in seconds (max: 600)"
+    ),
+    image: Optional[str] = typer.Option(
+        None, "--image", "-i", help="Custom Jupyter image (default: jupyter/base-notebook)"
+    ),
+    token: str = typer.Option(
+        "lyceum", "--token", help="Jupyter notebook token for authentication"
+    ),
+    port: int = typer.Option(
+        8888, "--port", "-p", help="Port for Jupyter server"
+    ),
+):
+    """Launch a Jupyter notebook server on Lyceum Cloud.
+
+    Starts a Jupyter notebook that you can access in your browser.
+    The notebook URL will be printed once the server is ready.
+
+    Examples:
+        lyceum notebook launch
+        lyceum notebook launch -m h100
+        lyceum notebook launch -m a100 --timeout 7200
+        lyceum notebook launch --image jupyter/scipy-notebook
+    """
+    status = StatusLine()
+
+    try:
+        config.get_client()
+
+        status.start()
+        status.update("Preparing notebook environment...")
+
+        jupyter_image = image or JUPYTER_IMAGE
+
+        # Build the Jupyter start command
+        # Using start-notebook.sh with custom options
+        jupyter_cmd = [
+            "start-notebook.sh",
+            f"--NotebookApp.token={token}",
+            f"--port={port}",
+            "--ip=0.0.0.0",
+            "--no-browser",
+        ]
+
+        # Build request for v2 image API
+        image_request = {
+            "docker_image_ref": jupyter_image,
+            "docker_run_cmd": jupyter_cmd,
+            "timeout": timeout,
+            "execution_type": machine_type,
+        }
+
+        status.update(f"Starting Jupyter on {machine_type}...")
+
+        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")
+
+        # Build the notebook URL immediately
+        notebook_url = f"https://{execution_id}-{port}.port.lyceum.technology"
+        full_url = f"{notebook_url}/?token={token}"
+
+        status.stop()
+
+        # Print URL immediately so user can click it
+        console.print()
+        console.print("[bold green]Notebook starting![/bold green]")
+        console.print()
+        console.print(f"[cyan]{full_url}[/cyan]")
+        console.print()
+        console.print(f"[dim]Execution ID:[/dim] {execution_id}")
+        console.print()
+        console.print("[dim]To stop:[/dim] lyceum notebook stop " + execution_id)
+
+    except typer.Exit:
+        status.stop()
+        raise
+    except Exception as e:
+        status.stop()
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@notebook_app.command("stop")
+def stop_notebook(
+    execution_id: str = typer.Argument(..., help="Execution ID of the notebook to stop"),
+):
+    """Stop a running Jupyter notebook.
+
+    Examples:
+        lyceum notebook stop 9d73319c-6f1c-4b4c-90e4-044244353ce4
+    """
+    status = StatusLine()
+
+    try:
+        config.get_client()
+
+        status.start()
+        status.update("Stopping notebook...")
+
+        response = httpx.post(
+            f"{config.base_url}/api/v2/external/workloads/abort/{execution_id}",
+            headers={"Authorization": f"Bearer {config.api_key}"},
+            timeout=30.0,
+        )
+
+        status.stop()
+
+        if response.status_code == 200:
+            console.print(f"[green]Notebook {execution_id} stopped.[/green]")
+        elif response.status_code == 404:
+            console.print(f"[yellow]Notebook {execution_id} not found or already stopped.[/yellow]")
+        else:
+            console.print(f"[red]Error stopping notebook: HTTP {response.status_code}[/red]")
+            if response.content:
+                console.print(f"[red]{response.content.decode()}[/red]")
+            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)
+
+
+@notebook_app.command("list")
+def list_notebooks():
+    """List running Jupyter notebooks.
+
+    Shows all active notebook sessions with their URLs and status.
+    """
+    status = StatusLine()
+
+    try:
+        config.get_client()
+
+        status.start()
+        status.update("Fetching running notebooks...")
+
+        # Use the workloads API to get running executions
+        response = httpx.get(
+            f"{config.base_url}/api/v2/external/workloads/list",
+            headers={"Authorization": f"Bearer {config.api_key}"},
+            timeout=30.0,
+        )
+
+        status.stop()
+
+        if response.status_code != 200:
+            console.print(f"[red]Error: HTTP {response.status_code}[/red]")
+            if response.content:
+                console.print(f"[red]{response.content.decode()}[/red]")
+            raise typer.Exit(1)
+
+        executions = response.json()
+
+        # Filter for notebook executions (those running on port 8888 or with jupyter)
+        # Since we don't have image info, show all running executions
+        notebooks = [
+            e for e in executions
+            if e.get("status") in ["running", "pending", "queued", "starting"]
+        ]
+
+        if not notebooks:
+            console.print("[dim]No running workloads found.[/dim]")
+            return
+
+        console.print(f"[bold]Running Workloads ({len(notebooks)})[/bold]")
+        console.print()
+
+        for nb in notebooks:
+            exec_id = nb.get("execution_id", "unknown")
+            status_val = nb.get("status", "unknown")
+            created = nb.get("created_at", "")
+            file_name = nb.get("file_name", "")
+
+            # Assume port 8888 for Jupyter
+            url = f"https://{exec_id}-8888.port.lyceum.technology"
+
+            console.print(f"[cyan]{exec_id}[/cyan]")
+            if file_name:
+                console.print(f"  Name: {file_name}")
+            console.print(f"  Status: {status_val}")
+            console.print(f"  URL: {url}")
+            if created:
+                console.print(f"  Created: {created}")
+            console.print()
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        status.stop()
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+

lyceum_cli-1.0.25/lyceum/external/storage/files.py

@@ -0,0 +1,273 @@
+"""Storage file management commands"""
+
+from datetime import datetime
+from pathlib import Path
+
+import httpx
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from ...shared.config import config
+
+console = Console()
+
+storage_app = typer.Typer(name="storage", help="File storage commands")
+
+
+def format_size(size_bytes: int) -> str:
+    """Format bytes into human-readable size."""
+    for unit in ["B", "KB", "MB", "GB"]:
+        if size_bytes < 1024:
+            return f"{size_bytes:.1f} {unit}"
+        size_bytes /= 1024
+    return f"{size_bytes:.1f} TB"
+
+
+@storage_app.command("list")
+def list_files(
+    prefix: str = typer.Option("", "--prefix", "-p", help="Filter by prefix/folder"),
+    limit: int = typer.Option(100, "--limit", "-n", help="Maximum files to list"),
+):
+    """List files in your storage bucket."""
+    try:
+        config.get_client()
+
+        params = {"prefix": prefix, "max_files": limit}
+
+        response = httpx.get(
+            f"{config.base_url}/api/v2/external/storage/list-files",
+            headers={"Authorization": f"Bearer {config.api_key}"},
+            params=params,
+            timeout=30.0,
+        )
+
+        if response.status_code != 200:
+            console.print(f"[red]Error: HTTP {response.status_code}[/red]")
+            if response.status_code == 401:
+                console.print("[yellow]Run 'lyceum auth login' to re-authenticate.[/yellow]")
+            else:
+                console.print(f"[red]{response.content.decode()}[/red]")
+            raise typer.Exit(1)
+
+        files = response.json()
+
+        if not files:
+            console.print("[dim]No files found.[/dim]")
+            if prefix:
+                console.print(f"[dim]Prefix filter: {prefix}[/dim]")
+            return
+
+        table = Table(title="Storage Files")
+        table.add_column("Key", style="cyan")
+        table.add_column("Size", style="green", justify="right")
+        table.add_column("Last Modified", style="dim")
+
+        for f in files:
+            last_mod = f.get("last_modified", "")
+            if last_mod:
+                try:
+                    dt = datetime.fromisoformat(last_mod.replace("Z", "+00:00"))
+                    last_mod = dt.strftime("%Y-%m-%d %H:%M")
+                except Exception:
+                    pass
+
+            table.add_row(
+                f.get("key", ""),
+                format_size(f.get("size", 0)),
+                last_mod,
+            )
+
+        console.print(table)
+        console.print(f"\n[dim]Total: {len(files)} file(s)[/dim]")
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@storage_app.command("upload")
+def upload_file(
+    file_path: Path = typer.Argument(..., help="Local file to upload"),
+    dest: str = typer.Option(None, "--dest", "-d", help="Destination path in storage (defaults to filename)"),
+):
+    """Upload a file to your storage bucket."""
+    try:
+        config.get_client()
+
+        if not file_path.exists():
+            console.print(f"[red]Error: File not found: {file_path}[/red]")
+            raise typer.Exit(1)
+
+        if not file_path.is_file():
+            console.print(f"[red]Error: Not a file: {file_path}[/red]")
+            raise typer.Exit(1)
+
+        remote_path = dest or file_path.name
+        file_size = file_path.stat().st_size
+
+        console.print(f"[dim]Uploading {file_path.name} ({format_size(file_size)})...[/dim]")
+
+        with open(file_path, "rb") as f:
+            files = {"file": (file_path.name, f)}
+            data = {"key": remote_path} if dest else {}
+
+            response = httpx.post(
+                f"{config.base_url}/api/v2/external/storage/upload",
+                headers={"Authorization": f"Bearer {config.api_key}"},
+                files=files,
+                data=data,
+                timeout=300.0,  # 5 min timeout for large files
+            )
+
+        if response.status_code != 200:
+            console.print(f"[red]Error: HTTP {response.status_code}[/red]")
+            if response.status_code == 401:
+                console.print("[yellow]Run 'lyceum auth login' to re-authenticate.[/yellow]")
+            else:
+                console.print(f"[red]{response.content.decode()}[/red]")
+            raise typer.Exit(1)
+
+        result = response.json()
+        console.print(f"[green]Uploaded successfully![/green]")
+        console.print(f"[dim]Key: {result.get('key')}[/dim]")
+        console.print(f"[dim]Size: {format_size(result.get('size', 0))}[/dim]")
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@storage_app.command("download")
+def download_file(
+    path: str = typer.Argument(..., help="File path in storage to download"),
+    output: Path = typer.Option(None, "--output", "-o", help="Local output path (defaults to filename)"),
+):
+    """Download a file from your storage bucket."""
+    try:
+        config.get_client()
+
+        # Default output to the filename part of the path
+        output_path = output or Path(path.split("/")[-1])
+
+        console.print(f"[dim]Downloading {path}...[/dim]")
+
+        response = httpx.get(
+            f"{config.base_url}/api/v2/external/storage/download/{path}",
+            headers={"Authorization": f"Bearer {config.api_key}"},
+            timeout=300.0,
+        )
+
+        if response.status_code == 404:
+            console.print(f"[red]Error: File not found: {path}[/red]")
+            raise typer.Exit(1)
+
+        if response.status_code != 200:
+            console.print(f"[red]Error: HTTP {response.status_code}[/red]")
+            if response.status_code == 401:
+                console.print("[yellow]Run 'lyceum auth login' to re-authenticate.[/yellow]")
+            else:
+                console.print(f"[red]{response.content.decode()}[/red]")
+            raise typer.Exit(1)
+
+        with open(output_path, "wb") as f:
+            f.write(response.content)
+
+        console.print(f"[green]Downloaded successfully![/green]")
+        console.print(f"[dim]Saved to: {output_path}[/dim]")
+        console.print(f"[dim]Size: {format_size(len(response.content))}[/dim]")
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@storage_app.command("delete")
+def delete_file(
+    path: str = typer.Argument(..., help="File path in storage to delete"),
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation"),
+):
+    """Delete a file from your storage bucket."""
+    try:
+        config.get_client()
+
+        if not force:
+            confirm = typer.confirm(f"Delete '{path}'?")
+            if not confirm:
+                console.print("[dim]Cancelled.[/dim]")
+                raise typer.Exit(0)
+
+        response = httpx.delete(
+            f"{config.base_url}/api/v2/external/storage/delete/{path}",
+            headers={"Authorization": f"Bearer {config.api_key}"},
+            timeout=30.0,
+        )
+
+        if response.status_code == 404:
+            console.print(f"[red]Error: File not found: {path}[/red]")
+            raise typer.Exit(1)
+
+        if response.status_code != 200:
+            console.print(f"[red]Error: HTTP {response.status_code}[/red]")
+            if response.status_code == 401:
+                console.print("[yellow]Run 'lyceum auth login' to re-authenticate.[/yellow]")
+            else:
+                console.print(f"[red]{response.content.decode()}[/red]")
+            raise typer.Exit(1)
+
+        console.print(f"[green]Deleted: {path}[/green]")
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@storage_app.command("delete-folder")
+def delete_folder(
+    prefix: str = typer.Argument(..., help="Folder prefix to delete"),
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation"),
+):
+    """Delete all files in a folder (by prefix)."""
+    try:
+        config.get_client()
+
+        if not force:
+            confirm = typer.confirm(f"Delete all files in '{prefix}/'?")
+            if not confirm:
+                console.print("[dim]Cancelled.[/dim]")
+                raise typer.Exit(0)
+
+        response = httpx.delete(
+            f"{config.base_url}/api/v2/external/storage/delete-folder/{prefix}",
+            headers={"Authorization": f"Bearer {config.api_key}"},
+            timeout=60.0,
+        )
+
+        if response.status_code == 404:
+            console.print(f"[yellow]No files found in folder: {prefix}/[/yellow]")
+            raise typer.Exit(0)
+
+        if response.status_code != 200:
+            console.print(f"[red]Error: HTTP {response.status_code}[/red]")
+            if response.status_code == 401:
+                console.print("[yellow]Run 'lyceum auth login' to re-authenticate.[/yellow]")
+            else:
+                console.print(f"[red]{response.content.decode()}[/red]")
+            raise typer.Exit(1)
+
+        result = response.json()
+        console.print(f"[green]{result.get('message')}[/green]")
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)

{lyceum_cli-1.0.24 → lyceum_cli-1.0.25}/lyceum/main.py

@@ -12,6 +12,7 @@ from .external.auth.login import auth_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.execution.notebook import notebook_app
 
 app = typer.Typer(
     name="lyceum",
@@ -26,6 +27,7 @@ app.add_typer(auth_app, name="auth")
 app.add_typer(python_app, name="python")
 app.add_typer(docker_app, name="docker")
 app.add_typer(workloads_app, name="workloads")
+app.add_typer(notebook_app, name="notebook")
 
 
 

{lyceum_cli-1.0.24 → lyceum_cli-1.0.25}/lyceum_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lyceum-cli
-Version: 1.0.24
+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.24 → lyceum_cli-1.0.25}/lyceum_cli.egg-info/SOURCES.txt

@@ -8,6 +8,8 @@ lyceum/external/compute/__init__.py
 lyceum/external/compute/execution/__init__.py
 lyceum/external/compute/execution/config.py
 lyceum/external/compute/execution/docker.py
+lyceum/external/compute/execution/docker_config.py
+lyceum/external/compute/execution/notebook.py
 lyceum/external/compute/execution/python.py
 lyceum/external/compute/execution/workloads.py
 lyceum/external/compute/inference/__init__.py
@@ -15,6 +17,8 @@ lyceum/external/compute/inference/batch.py
 lyceum/external/compute/inference/chat.py
 lyceum/external/compute/inference/models.py
 lyceum/external/general/__init__.py
+lyceum/external/storage/__init__.py
+lyceum/external/storage/files.py
 lyceum/shared/__init__.py
 lyceum/shared/config.py
 lyceum/shared/display.py

{lyceum_cli-1.0.24 → lyceum_cli-1.0.25}/setup.py

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