tetra-rp 0.12.0__py3-none-any.whl → 0.14.0__py3-none-any.whl

tetra_rp/cli/commands/deploy.py

@@ -0,0 +1,336 @@
+"""Deployment environment management commands."""
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+import questionary
+
+from ..utils.deployment import (
+    get_deployment_environments,
+    create_deployment_environment,
+    remove_deployment_environment,
+    deploy_to_environment,
+    rollback_deployment,
+    get_environment_info,
+)
+
+console = Console()
+
+
+def list_command():
+    """Show available deployment environments."""
+
+    environments = get_deployment_environments()
+
+    if not environments:
+        console.print(
+            Panel(
+                "📦 No deployment environments found\n\n"
+                "Create one with: [bold]runpod remote deploy new <name>[/bold]",
+                title="Deployment Environments",
+                expand=False,
+            )
+        )
+        return
+
+    table = Table(title="Deployment Environments")
+    table.add_column("Environment", style="cyan", no_wrap=True)
+    table.add_column("Status", justify="center")
+    table.add_column("Current Version", style="magenta")
+    table.add_column("Last Deployed", style="yellow")
+    table.add_column("URL", style="blue")
+
+    active_count = 0
+    idle_count = 0
+
+    for env_name, env_info in environments.items():
+        status = env_info.get("status", "Unknown")
+        if status == "active":
+            status_display = "🟢 Active"
+            active_count += 1
+        elif status == "idle":
+            status_display = "🟡 Idle"
+            idle_count += 1
+        else:
+            status_display = "🔴 Error"
+
+        table.add_row(
+            env_name,
+            status_display,
+            env_info.get("current_version", "N/A"),
+            env_info.get("last_deployed", "Never"),
+            env_info.get("url", "N/A"),
+        )
+
+    console.print(table)
+
+    # Summary
+    total = len(environments)
+    error_count = total - active_count - idle_count
+    summary = f"Total: {total} environments ({active_count} active"
+    if idle_count > 0:
+        summary += f", {idle_count} idle"
+    if error_count > 0:
+        summary += f", {error_count} error"
+    summary += ")"
+
+    console.print(f"\n{summary}")
+
+
+def new_command(name: str):
+    """Create a new deployment environment."""
+
+    environments = get_deployment_environments()
+
+    if name in environments:
+        console.print(f"Environment '{name}' already exists")
+        raise typer.Exit(1)
+
+    # Interactive configuration
+    config = {}
+
+    try:
+        config["region"] = questionary.select(
+            "Select region:",
+            choices=["us-east-1", "us-west-2", "eu-west-1", "ap-southeast-1"],
+        ).ask()
+
+        config["instance_type"] = questionary.select(
+            "Instance type:", choices=["A40", "A100", "H100", "RTX4090"]
+        ).ask()
+
+        config["auto_scale"] = questionary.confirm("Enable auto-scaling?").ask()
+
+        if not all([config["region"], config["instance_type"]]):
+            console.print("Configuration cancelled")
+            raise typer.Exit(1)
+
+    except KeyboardInterrupt:
+        console.print("\nEnvironment creation cancelled")
+        raise typer.Exit(1)
+
+    # Create environment
+    with console.status(f"Creating environment '{name}'..."):
+        create_deployment_environment(name, config)
+
+    # Success message
+    panel_content = f"Environment '[bold]{name}[/bold]' created successfully\n\n"
+    panel_content += f"Region: {config['region']}\n"
+    panel_content += f"Instance: {config['instance_type']}\n"
+    panel_content += f"Auto-scale: {'Enabled' if config['auto_scale'] else 'Disabled'}"
+
+    console.print(Panel(panel_content, title="🚀 Environment Created", expand=False))
+
+    console.print(f"\nNext: [bold]flash deploy send {name}[/bold]")
+
+
+def send_command(name: str):
+    """Deploy project to deployment environment."""
+
+    environments = get_deployment_environments()
+
+    if name not in environments:
+        console.print(f"Environment '{name}' not found")
+        console.print("Available environments:")
+        for env_name in environments.keys():
+            console.print(f"  • {env_name}")
+        raise typer.Exit(1)
+
+    # Deploy with mock progress
+    console.print(f"🚀 Deploying to '[bold]{name}[/bold]'...")
+
+    try:
+        result = deploy_to_environment(name)
+
+        panel_content = f"Deployed to '[bold]{name}[/bold]' successfully\n\n"
+        panel_content += f"Version: {result['version']}\n"
+        panel_content += f"URL: {result['url']}\n"
+        panel_content += "Status: 🟢 Active"
+
+        console.print(
+            Panel(panel_content, title="🚀 Deployment Complete", expand=False)
+        )
+
+    except Exception as e:
+        console.print(f"Deployment failed: {e}")
+        raise typer.Exit(1)
+
+
+def report_command(name: str):
+    """Show detailed environment status and metrics."""
+
+    environments = get_deployment_environments()
+
+    if name not in environments:
+        console.print(f"Environment '{name}' not found")
+        raise typer.Exit(1)
+
+    env_info = get_environment_info(name)
+
+    # Environment status
+    status = env_info.get("status", "unknown")
+    status_display = {
+        "active": "🟢 Active",
+        "idle": "🟡 Idle",
+        "error": "🔴 Error",
+    }.get(status, "❓ Unknown")
+
+    # Main info panel
+    main_info = f"Status: {status_display}\n"
+    main_info += f"Current Version: {env_info.get('current_version', 'N/A')}\n"
+    main_info += f"URL: {env_info.get('url', 'N/A')}\n"
+    main_info += f"Last Deployed: {env_info.get('last_deployed', 'Never')}\n"
+    main_info += f"Uptime: {env_info.get('uptime', 'N/A')}"
+
+    console.print(
+        Panel(main_info, title=f"📊 Environment Report: {name}", expand=False)
+    )
+
+    # Version history
+    versions = env_info.get("version_history", [])
+    if versions:
+        version_table = Table(title="Version History")
+        version_table.add_column("Version", style="cyan")
+        version_table.add_column("Status", justify="center")
+        version_table.add_column("Deployed", style="yellow")
+        version_table.add_column("Description", style="white")
+
+        for version in versions[:5]:  # Show last 5 versions
+            version_status = (
+                "🟢 Current" if version.get("is_current") else "📦 Previous"
+            )
+            version_table.add_row(
+                version.get("version", "N/A"),
+                version_status,
+                version.get("deployed_at", "N/A"),
+                version.get("description", "No description"),
+            )
+
+        console.print(version_table)
+
+    # Mock metrics
+    console.print("\n[bold]Metrics (Last 24h):[/bold]")
+    metrics_info = [
+        "• Requests: 145,234",
+        "• Avg Response Time: 245ms",
+        "• Error Rate: 0.02%",
+        "• CPU Usage: 45%",
+        "• Memory Usage: 62%",
+    ]
+
+    for metric in metrics_info:
+        console.print(f"  {metric}")
+
+
+def rollback_command(name: str):
+    """Rollback deployment to previous version."""
+
+    environments = get_deployment_environments()
+
+    if name not in environments:
+        console.print(f"Environment '{name}' not found")
+        raise typer.Exit(1)
+
+    env_info = get_environment_info(name)
+    versions = env_info.get("version_history", [])
+
+    if len(versions) < 2:
+        console.print("No previous versions available for rollback")
+        raise typer.Exit(1)
+
+    # Show available versions (excluding current)
+    previous_versions = [v for v in versions if not v.get("is_current")]
+
+    if not previous_versions:
+        console.print("No previous versions available for rollback")
+        raise typer.Exit(1)
+
+    try:
+        version_choices = [
+            f"{v['version']} - {v.get('description', 'No description')}"
+            for v in previous_versions[:5]
+        ]
+
+        selected = questionary.select(
+            "Select version to rollback to:", choices=version_choices
+        ).ask()
+
+        if not selected:
+            console.print("Rollback cancelled")
+            raise typer.Exit(1)
+
+        target_version = selected.split(" - ")[0]
+
+        # Confirmation
+        confirmed = questionary.confirm(
+            f"Rollback environment '{name}' to version {target_version}?"
+        ).ask()
+
+        if not confirmed:
+            console.print("Rollback cancelled")
+            raise typer.Exit(1)
+
+    except KeyboardInterrupt:
+        console.print("\nRollback cancelled")
+        raise typer.Exit(1)
+
+    # Perform rollback
+    with console.status(f"Rolling back to {target_version}..."):
+        rollback_deployment(name, target_version)
+
+    console.print(f"Rolled back to version {target_version}")
+    console.print(f"Environment '{name}' is now running the previous version.")
+
+
+def remove_command(name: str):
+    """Remove deployment environment."""
+
+    environments = get_deployment_environments()
+
+    if name not in environments:
+        console.print(f"Environment '{name}' not found")
+        raise typer.Exit(1)
+
+    env_info = get_environment_info(name)
+
+    # Show removal preview
+    preview_content = f"Environment: {name}\n"
+    preview_content += f"Status: {env_info.get('status', 'unknown')}\n"
+    preview_content += f"URL: {env_info.get('url', 'N/A')}\n"
+    preview_content += f"Current Version: {env_info.get('current_version', 'N/A')}\n\n"
+    preview_content += "⚠️  This will permanently remove:\n"
+    preview_content += "  • All deployment history\n"
+    preview_content += "  • All associated resources\n"
+    preview_content += "  • Environment configuration\n"
+    preview_content += "  • Access URLs\n\n"
+    preview_content += "🚨 This action cannot be undone!"
+
+    console.print(Panel(preview_content, title="⚠️  Removal Preview", expand=False))
+
+    try:
+        # Double confirmation for safety
+        confirmed = questionary.confirm(
+            f"Are you sure you want to remove environment '{name}'?"
+        ).ask()
+
+        if not confirmed:
+            console.print("Removal cancelled")
+            raise typer.Exit(1)
+
+        # Type confirmation
+        typed_name = questionary.text(f"Type '{name}' to confirm removal:").ask()
+
+        if typed_name != name:
+            console.print("Confirmation failed - names do not match")
+            raise typer.Exit(1)
+
+    except KeyboardInterrupt:
+        console.print("\nRemoval cancelled")
+        raise typer.Exit(1)
+
+    # Remove environment
+    with console.status(f"Removing environment '{name}'..."):
+        remove_deployment_environment(name)
+
+    console.print(f"Environment '{name}' removed successfully")

tetra_rp/cli/commands/init.py

@@ -0,0 +1,135 @@
+"""Project initialization command."""
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from ..utils.skeleton import create_project_skeleton
+from ..utils.conda import (
+    check_conda_available,
+    create_conda_environment,
+    install_packages_in_env,
+    environment_exists,
+    get_activation_command,
+)
+
+console = Console()
+
+# Required packages for flash run to work smoothly
+REQUIRED_PACKAGES = [
+    "fastapi>=0.104.0",
+    "uvicorn[standard]>=0.24.0",
+    "python-dotenv>=1.0.0",
+    "pydantic>=2.0.0",
+    "aiohttp>=3.9.0",
+]
+
+
+def init_command(
+    project_name: str = typer.Argument(..., help="Project name"),
+    no_env: bool = typer.Option(
+        False, "--no-env", help="Skip conda environment creation"
+    ),
+    force: bool = typer.Option(
+        False, "--force", "-f", help="Overwrite existing directory"
+    ),
+):
+    """Create new Flash project with Flash Server and GPU workers."""
+
+    # Create project directory
+    project_dir = Path(project_name)
+
+    if project_dir.exists() and not force:
+        console.print(f"Directory '{project_name}' already exists")
+        console.print("Use --force to overwrite")
+        raise typer.Exit(1)
+
+    # Create project directory
+    project_dir.mkdir(parents=True, exist_ok=True)
+
+    with console.status(f"Creating Flash project '{project_name}'..."):
+        create_project_skeleton(project_dir, force)
+
+    # Create conda environment if requested
+    env_created = False
+    if not no_env:
+        if not check_conda_available():
+            console.print(
+                "[yellow]Warning: conda not found. Skipping environment creation.[/yellow]"
+            )
+            console.print(
+                "Install Miniconda or Anaconda, or use --no-env flag to skip this step."
+            )
+        else:
+            # Check if environment already exists
+            if environment_exists(project_name):
+                console.print(
+                    f"[yellow]Conda environment '{project_name}' already exists. Skipping creation.[/yellow]"
+                )
+                env_created = True
+            else:
+                # Create conda environment
+                with console.status(f"Creating conda environment '{project_name}'..."):
+                    success, message = create_conda_environment(project_name)
+
+                if not success:
+                    console.print(f"[yellow]Warning: {message}[/yellow]")
+                    console.print(
+                        "You can manually create the environment and install dependencies."
+                    )
+                else:
+                    env_created = True
+
+                    # Install required packages
+                    with console.status("Installing dependencies..."):
+                        success, message = install_packages_in_env(
+                            project_name, REQUIRED_PACKAGES, use_pip=True
+                        )
+
+                    if not success:
+                        console.print(f"[yellow]Warning: {message}[/yellow]")
+                        console.print(
+                            "You can manually install dependencies: pip install -r requirements.txt"
+                        )
+
+    # Success output
+    panel_content = (
+        f"Flash project '[bold]{project_name}[/bold]' created successfully!\n\n"
+    )
+    panel_content += "Project structure:\n"
+    panel_content += f"  {project_name}/\n"
+    panel_content += "  ├── main.py              # Flash Server (FastAPI)\n"
+    panel_content += "  ├── workers/             # GPU workers\n"
+    panel_content += "  │   └── example_worker.py\n"
+    panel_content += "  ├── .env.example\n"
+    panel_content += "  ├── requirements.txt\n"
+    panel_content += "  └── README.md\n"
+
+    if env_created:
+        panel_content += (
+            f"\nConda environment '[bold]{project_name}[/bold]' created and configured"
+        )
+
+    console.print(Panel(panel_content, title="Project Created", expand=False))
+
+    # Next steps
+    console.print("\n[bold]Next steps:[/bold]")
+    steps_table = Table(show_header=False, box=None, padding=(0, 1))
+    steps_table.add_column("Step", style="bold cyan")
+    steps_table.add_column("Description")
+
+    steps_table.add_row("1.", f"cd {project_name}")
+
+    if env_created:
+        steps_table.add_row("2.", f"{get_activation_command(project_name)}")
+        steps_table.add_row("3.", "cp .env.example .env  # Add your RUNPOD_API_KEY")
+        steps_table.add_row("4.", "flash run")
+    else:
+        steps_table.add_row("2.", "pip install -r requirements.txt")
+        steps_table.add_row("3.", "cp .env.example .env  # Add your RUNPOD_API_KEY")
+        steps_table.add_row("4.", "flash run")
+
+    console.print(steps_table)

tetra_rp/cli/commands/resource.py

@@ -0,0 +1,191 @@
+"""Resource management commands."""
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.live import Live
+from rich.progress import Progress, SpinnerColumn, TextColumn
+import questionary
+import time
+
+from ...core.resources.resource_manager import ResourceManager
+
+console = Console()
+
+
+def report_command(
+    live: bool = typer.Option(False, "--live", "-l", help="Live updating status"),
+    refresh: int = typer.Option(
+        2, "--refresh", "-r", help="Refresh interval for live mode"
+    ),
+):
+    """Show resource status dashboard."""
+
+    resource_manager = ResourceManager()
+
+    if live:
+        try:
+            with Live(
+                generate_resource_table(resource_manager),
+                console=console,
+                refresh_per_second=1 / refresh,
+                screen=True,
+            ) as live_display:
+                while True:
+                    time.sleep(refresh)
+                    live_display.update(generate_resource_table(resource_manager))
+        except KeyboardInterrupt:
+            console.print("\n📊 Live monitoring stopped")
+    else:
+        table = generate_resource_table(resource_manager)
+        console.print(table)
+
+
+def clean_command(
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation"),
+):
+    """Remove all tracked resources after confirmation."""
+
+    resource_manager = ResourceManager()
+    resources = resource_manager._resources
+
+    if not resources:
+        console.print("🧹 No resources to clean")
+        return
+
+    # Show cleanup preview
+    console.print(generate_cleanup_preview(resources))
+
+    # Confirmation unless forced
+    if not force:
+        try:
+            confirmed = questionary.confirm(
+                "Are you sure you want to clean all resources?"
+            ).ask()
+
+            if not confirmed:
+                console.print("Cleanup cancelled")
+                return
+        except KeyboardInterrupt:
+            console.print("\nCleanup cancelled")
+            return
+
+    # Clean resources with progress
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        task = progress.add_task("Cleaning resources...", total=len(resources))
+
+        for uid in list(resources.keys()):
+            resource = resources[uid]
+            progress.update(
+                task, description=f"Removing {resource.__class__.__name__}..."
+            )
+
+            # Remove resource (this will also clean up remotely if needed)
+            resource_manager.remove_resource(uid)
+
+            progress.advance(task)
+            time.sleep(0.1)  # Small delay for visual feedback
+
+    console.print("All resources cleaned successfully")
+
+
+def generate_resource_table(resource_manager: ResourceManager) -> Panel:
+    """Generate a formatted table of resources."""
+
+    resources = resource_manager._resources
+
+    if not resources:
+        return Panel(
+            "📊 No resources currently tracked\n\n"
+            "Resources will appear here after running your Tetra applications.",
+            title="Resource Status Report",
+            expand=False,
+        )
+
+    table = Table(title="Resource Status Report")
+    table.add_column("Resource ID", style="cyan", no_wrap=True)
+    table.add_column("Status", justify="center")
+    table.add_column("Type", style="magenta")
+    table.add_column("URL", style="blue")
+    table.add_column("Health", justify="center")
+
+    active_count = 0
+    error_count = 0
+
+    for uid, resource in resources.items():
+        # Determine status
+        try:
+            is_deployed = resource.is_deployed()
+            if is_deployed:
+                status = "🟢 Active"
+                active_count += 1
+            else:
+                status = "🔴 Inactive"
+                error_count += 1
+        except Exception:
+            status = "🟡 Unknown"
+
+        # Get resource info
+        resource_type = resource.__class__.__name__
+
+        try:
+            url = resource.url if hasattr(resource, "url") else "N/A"
+        except Exception:
+            url = "N/A"
+
+        # Health check (simplified for now)
+        health = "✓" if status == "🟢 Active" else "✗"
+
+        table.add_row(
+            uid[:20] + "..." if len(uid) > 20 else uid,
+            status,
+            resource_type,
+            url,
+            health,
+        )
+
+    # Summary
+    total = len(resources)
+    idle_count = total - active_count - error_count
+    summary = f"Total: {total} resources ({active_count} active"
+    if idle_count > 0:
+        summary += f", {idle_count} idle"
+    if error_count > 0:
+        summary += f", {error_count} error"
+    summary += ")"
+
+    return Panel(table, subtitle=summary, expand=False)
+
+
+def generate_cleanup_preview(resources: dict) -> Panel:
+    """Generate a preview of resources to be cleaned."""
+
+    content = "The following resources will be removed:\n\n"
+
+    for uid, resource in resources.items():
+        resource_type = resource.__class__.__name__
+
+        try:
+            status = "Active" if resource.is_deployed() else "Inactive"
+        except Exception:
+            status = "Unknown"
+
+        try:
+            url = (
+                f" - {resource.url}"
+                if hasattr(resource, "url") and resource.url != "N/A"
+                else ""
+            )
+        except Exception:
+            url = ""
+
+        content += f"  • {resource_type} ({status}){url}\n"
+
+    content += "\n⚠️  This action cannot be undone!"
+
+    return Panel(content, title="🧹 Cleanup Preview", expand=False)