tetra-rp 0.6.0__py3-none-any.whl → 0.24.0__py3-none-any.whl

tetra_rp/cli/commands/undeploy.py

@@ -0,0 +1,533 @@
+"""Undeploy command for managing RunPod serverless endpoints."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING, Dict, Optional, Tuple
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.prompt import Confirm
+import questionary
+
+if TYPE_CHECKING:
+    from ...core.resources.base import DeployableResource
+    from ...core.resources.resource_manager import ResourceManager
+
+console = Console()
+
+
+def _get_resource_manager():
+    """Get ResourceManager instance with lazy loading.
+
+    Imports are deferred to avoid loading heavy dependencies (runpod, aiohttp, etc)
+    at CLI startup time. This allows fast commands like 'flash init' to run without
+    loading unnecessary dependencies.
+
+    Can be mocked in tests: @patch('tetra_rp.cli.commands.undeploy._get_resource_manager')
+    """
+    from ...core.resources.resource_manager import ResourceManager
+
+    return ResourceManager()
+
+
+def _get_resource_status(resource) -> Tuple[str, str]:
+    """Get resource status with icon and text.
+
+    Args:
+        resource: DeployableResource to check
+
+    Returns:
+        Tuple of (status_icon, status_text)
+    """
+    try:
+        if resource.is_deployed():
+            return "🟢", "Active"
+        return "🔴", "Inactive"
+    except Exception:
+        return "❓", "Unknown"
+
+
+def _get_resource_type(resource) -> str:
+    """Get human-readable resource type.
+
+    Args:
+        resource: DeployableResource to check
+
+    Returns:
+        Resource type string
+    """
+    class_name = resource.__class__.__name__
+    return class_name.replace("Serverless", " Serverless").replace(
+        "Endpoint", " Endpoint"
+    )
+
+
+def list_command():
+    """List all deployed endpoints tracked in .tetra_resources.pkl."""
+    manager = _get_resource_manager()
+    resources = manager.list_all_resources()
+
+    if not resources:
+        console.print(
+            Panel(
+                "No endpoints found\n\n"
+                "Endpoints are automatically tracked when you use @remote decorator.",
+                title="Tracked Endpoints",
+                expand=False,
+            )
+        )
+        return
+
+    table = Table(title="Tracked RunPod Serverless Endpoints")
+    table.add_column("Name", style="cyan", no_wrap=True)
+    table.add_column("Endpoint ID", style="magenta")
+    table.add_column("Status", justify="center")
+    table.add_column("Type", style="yellow")
+    table.add_column("Resource ID", style="dim", no_wrap=True)
+
+    active_count = 0
+    inactive_count = 0
+
+    for resource_id, resource in resources.items():
+        status_icon, status_text = _get_resource_status(resource)
+        if status_text == "Active":
+            active_count += 1
+        elif status_text == "Inactive":
+            inactive_count += 1
+
+        # Get name if available
+        name = getattr(resource, "name", "N/A")
+        endpoint_id = getattr(resource, "id", "N/A")
+        resource_type = _get_resource_type(resource)
+
+        # Truncate resource_id for display
+        display_resource_id = (
+            resource_id[:12] + "..." if len(resource_id) > 12 else resource_id
+        )
+
+        table.add_row(
+            name,
+            endpoint_id,
+            f"{status_icon} {status_text}",
+            resource_type,
+            display_resource_id,
+        )
+
+    console.print(table)
+
+    # Summary
+    total = len(resources)
+    unknown_count = total - active_count - inactive_count
+    summary = f"Total: {total} endpoint{'s' if total != 1 else ''}"
+    if active_count > 0:
+        summary += f" ({active_count} active"
+    if inactive_count > 0:
+        summary += (
+            f", {inactive_count} inactive"
+            if active_count > 0
+            else f" ({inactive_count} inactive"
+        )
+    if unknown_count > 0:
+        summary += (
+            f", {unknown_count} unknown"
+            if (active_count > 0 or inactive_count > 0)
+            else f" ({unknown_count} unknown"
+        )
+    if active_count > 0 or inactive_count > 0 or unknown_count > 0:
+        summary += ")"
+
+    console.print(f"\n{summary}\n")
+    console.print("💡 Use [bold]flash undeploy <name>[/bold] to remove an endpoint")
+    console.print("💡 Use [bold]flash undeploy --all[/bold] to remove all endpoints")
+    console.print(
+        "💡 Use [bold]flash undeploy --interactive[/bold] for checkbox selection"
+    )
+
+
+def _cleanup_stale_endpoints(
+    resources: Dict[str, DeployableResource], manager: ResourceManager
+) -> None:
+    """Remove inactive endpoints from tracking (already deleted externally).
+
+    Args:
+        resources: Dictionary of resource_id -> DeployableResource
+        manager: ResourceManager instance for removing resources
+    """
+    console.print(
+        Panel(
+            "Checking for inactive endpoints...\n\n"
+            "This will remove endpoints from tracking that are no longer active\n"
+            "(already deleted via RunPod UI or API).",
+            title="Cleanup Stale Endpoints",
+            expand=False,
+        )
+    )
+
+    # Find inactive endpoints
+    inactive = []
+    with console.status("Checking endpoint status..."):
+        for resource_id, resource in resources.items():
+            status_icon, status_text = _get_resource_status(resource)
+            if status_text == "Inactive":
+                inactive.append((resource_id, resource))
+
+    if not inactive:
+        console.print("\n[green]✓[/green] No inactive endpoints found")
+        return
+
+    # Show what will be removed
+    console.print(f"\nFound [yellow]{len(inactive)}[/yellow] inactive endpoint(s):")
+    for resource_id, resource in inactive:
+        console.print(f"  • {resource.name} ({getattr(resource, 'id', 'N/A')})")
+
+    # Confirm removal
+    if not Confirm.ask(
+        "\n[yellow]⚠️  Remove these from tracking?[/yellow]",
+        default=False,
+    ):
+        console.print("[yellow]Cancelled[/yellow]")
+        return
+
+    # Undeploy inactive endpoints (force remove from tracking even if already deleted remotely)
+    removed_count = 0
+    for resource_id, resource in inactive:
+        result = asyncio.run(
+            manager.undeploy_resource(resource_id, resource.name, force_remove=True)
+        )
+
+        if result["success"]:
+            removed_count += 1
+            console.print(
+                f"[green]✓[/green] Removed [cyan]{resource.name}[/cyan] from tracking"
+            )
+        else:
+            # Resource already deleted remotely, but force_remove cleaned up tracking
+            removed_count += 1
+            console.print(
+                f"[yellow]⚠[/yellow] {resource.name}: Already deleted remotely, removed from tracking"
+            )
+
+    console.print(f"\n[green]✓[/green] Cleaned up {removed_count} inactive endpoint(s)")
+
+
+def undeploy_command(
+    name: Optional[str] = typer.Argument(
+        None, help="Name of the endpoint to undeploy (or 'list' to show all)"
+    ),
+    all: bool = typer.Option(False, "--all", help="Undeploy all endpoints"),
+    interactive: bool = typer.Option(
+        False, "--interactive", "-i", help="Interactive selection with checkboxes"
+    ),
+    cleanup_stale: bool = typer.Option(
+        False,
+        "--cleanup-stale",
+        help="Remove inactive endpoints from tracking (already deleted externally)",
+    ),
+    force: bool = typer.Option(
+        False, "--force", "-f", help="Force operation without confirmation prompts"
+    ),
+):
+    """Undeploy (delete) RunPod serverless endpoints.
+
+    Examples:
+
+        # List all endpoints
+        flash undeploy list
+
+        # Undeploy specific endpoint by name
+        flash undeploy my-api
+
+        # Undeploy all endpoints (with confirmation)
+        flash undeploy --all
+
+        # Undeploy all endpoints without confirmation
+        flash undeploy --all --force
+
+        # Interactive selection
+        flash undeploy --interactive
+
+        # Remove stale endpoint tracking (already deleted externally)
+        flash undeploy --cleanup-stale
+    """
+    # Handle "list" as a special case
+    if name == "list":
+        list_command()
+        return
+
+    manager = _get_resource_manager()
+    resources = manager.list_all_resources()
+
+    if not resources:
+        console.print(
+            Panel(
+                "No endpoints found to undeploy\n\n"
+                "Use @remote decorator to deploy endpoints.",
+                title="No Endpoints",
+                expand=False,
+            )
+        )
+        return
+
+    # Handle cleanup-stale mode
+    if cleanup_stale:
+        _cleanup_stale_endpoints(resources, manager)
+        return
+
+    # Handle different modes
+    if interactive:
+        _interactive_undeploy(resources, skip_confirm=force)
+    elif all:
+        _undeploy_all(resources, skip_confirm=force)
+    elif name:
+        _undeploy_by_name(name, resources, skip_confirm=force)
+    else:
+        console.print(
+            Panel(
+                "Usage: flash undeploy [name | list | --all | --interactive | --cleanup-stale]",
+                title="Undeploy Help",
+                expand=False,
+            )
+        )
+        console.print(
+            "[red]Error:[/red] Please specify a name, use --all/--interactive, or run `flash undeploy list`"
+        )
+        # Exit 0: Treat usage help display as successful operation for better UX
+        raise typer.Exit(0)
+
+
+def _undeploy_by_name(name: str, resources: dict, skip_confirm: bool = False):
+    """Undeploy endpoints matching the given name.
+
+    Args:
+        name: Name to search for
+        resources: Dict of all resources
+        skip_confirm: Skip confirmation prompts
+    """
+    # Find matching resources
+    matches = []
+    for resource_id, resource in resources.items():
+        if hasattr(resource, "name") and resource.name == name:
+            matches.append((resource_id, resource))
+
+    if not matches:
+        console.print(f"[red]Error:[/red] No endpoint found with name '{name}'")
+        console.print(
+            "\n💡 Use [bold]flash undeploy list[/bold] to see available endpoints"
+        )
+        raise typer.Exit(1)
+
+    # Show what will be deleted
+    console.print(
+        Panel(
+            "[yellow]⚠️  The following endpoint(s) will be deleted:[/yellow]\n",
+            title="Undeploy Confirmation",
+            expand=False,
+        )
+    )
+
+    for resource_id, resource in matches:
+        endpoint_id = getattr(resource, "id", "N/A")
+        resource_type = _get_resource_type(resource)
+        status_icon, status_text = _get_resource_status(resource)
+
+        console.print(f"  • [bold]{resource.name}[/bold]")
+        console.print(f"    Endpoint ID: {endpoint_id}")
+        console.print(f"    Type: {resource_type}")
+        console.print(f"    Status: {status_icon} {status_text}")
+        console.print()
+
+    console.print("[red]🚨 This action cannot be undone![/red]\n")
+
+    if not skip_confirm:
+        try:
+            confirmed = questionary.confirm(
+                f"Are you sure you want to delete {len(matches)} endpoint(s)?"
+            ).ask()
+
+            if not confirmed:
+                console.print("Undeploy cancelled")
+                raise typer.Exit(0)
+        except KeyboardInterrupt:
+            console.print("\nUndeploy cancelled")
+            raise typer.Exit(0)
+
+    # Delete endpoints
+    manager = _get_resource_manager()
+    with console.status("Deleting endpoint(s)..."):
+        results = []
+        for resource_id, resource in matches:
+            result = asyncio.run(manager.undeploy_resource(resource_id, resource.name))
+            results.append(result)
+
+    # Show results
+    success_count = sum(1 for r in results if r["success"])
+    fail_count = len(results) - success_count
+
+    if success_count > 0:
+        console.print(
+            f"\n[green]✓[/green] Successfully deleted {success_count} endpoint(s)"
+        )
+    if fail_count > 0:
+        console.print(f"[red]✗[/red] Failed to delete {fail_count} endpoint(s)")
+        console.print("\nErrors:")
+        for result in results:
+            if not result["success"]:
+                console.print(f"  • {result['message']}")
+
+
+def _undeploy_all(resources: dict, skip_confirm: bool = False):
+    """Undeploy all endpoints with confirmation.
+
+    Args:
+        resources: Dict of all resources
+        skip_confirm: Skip confirmation prompts
+    """
+    # Show what will be deleted
+    console.print(
+        Panel(
+            f"[yellow]⚠️  ALL {len(resources)} endpoint(s) will be deleted![/yellow]\n",
+            title="Undeploy All Confirmation",
+            expand=False,
+        )
+    )
+
+    for resource_id, resource in resources.items():
+        name = getattr(resource, "name", "N/A")
+        endpoint_id = getattr(resource, "id", "N/A")
+        console.print(f"  • {name} ({endpoint_id})")
+
+    console.print("\n[red]🚨 This action cannot be undone![/red]\n")
+
+    if not skip_confirm:
+        try:
+            confirmed = questionary.confirm(
+                f"Are you sure you want to delete ALL {len(resources)} endpoints?"
+            ).ask()
+
+            if not confirmed:
+                console.print("Undeploy cancelled")
+                raise typer.Exit(0)
+
+            # Double confirmation for --all
+            typed_confirm = questionary.text("Type 'DELETE ALL' to confirm:").ask()
+
+            if typed_confirm != "DELETE ALL":
+                console.print("Confirmation failed - text does not match")
+                raise typer.Exit(1)
+        except KeyboardInterrupt:
+            console.print("\nUndeploy cancelled")
+            raise typer.Exit(0)
+
+    # Delete all endpoints
+    manager = _get_resource_manager()
+    with console.status(f"Deleting {len(resources)} endpoint(s)..."):
+        results = []
+        for resource_id, resource in resources.items():
+            name = getattr(resource, "name", "N/A")
+            result = asyncio.run(manager.undeploy_resource(resource_id, name))
+            results.append(result)
+
+    # Show results
+    success_count = sum(1 for r in results if r["success"])
+    fail_count = len(results) - success_count
+
+    console.print("\n" + "=" * 50)
+    if success_count > 0:
+        console.print(
+            f"[green]✓[/green] Successfully deleted {success_count} endpoint(s)"
+        )
+    if fail_count > 0:
+        console.print(f"[red]✗[/red] Failed to delete {fail_count} endpoint(s)")
+        console.print("\nErrors:")
+        for result in results:
+            if not result["success"]:
+                console.print(f"  • {result['message']}")
+
+
+def _interactive_undeploy(resources: dict, skip_confirm: bool = False):
+    """Interactive checkbox selection for undeploying endpoints.
+
+    Args:
+        resources: Dict of all resources
+        skip_confirm: Skip confirmation prompts
+    """
+    # Create choices for questionary
+    choices = []
+    resource_map = {}
+
+    for resource_id, resource in resources.items():
+        name = getattr(resource, "name", "N/A")
+        endpoint_id = getattr(resource, "id", "N/A")
+        status_icon, status_text = _get_resource_status(resource)
+
+        choice_text = f"{name} ({endpoint_id}) - {status_icon} {status_text}"
+        choices.append(choice_text)
+        resource_map[choice_text] = (resource_id, resource)
+
+    try:
+        selected = questionary.checkbox(
+            "Select endpoints to undeploy (Space to select, Enter to confirm):",
+            choices=choices,
+        ).ask()
+
+        if not selected:
+            console.print("No endpoints selected")
+            raise typer.Exit(0)
+
+        # Show confirmation
+        console.print(
+            Panel(
+                f"[yellow]⚠️  {len(selected)} endpoint(s) will be deleted:[/yellow]\n",
+                title="Undeploy Confirmation",
+                expand=False,
+            )
+        )
+
+        selected_resources = []
+        for choice in selected:
+            resource_id, resource = resource_map[choice]
+            selected_resources.append((resource_id, resource))
+            name = getattr(resource, "name", "N/A")
+            endpoint_id = getattr(resource, "id", "N/A")
+            console.print(f"  • {name} ({endpoint_id})")
+
+        console.print("\n[red]🚨 This action cannot be undone![/red]\n")
+
+        if not skip_confirm:
+            confirmed = questionary.confirm(
+                f"Are you sure you want to delete {len(selected)} endpoint(s)?"
+            ).ask()
+
+            if not confirmed:
+                console.print("Undeploy cancelled")
+                raise typer.Exit(0)
+    except KeyboardInterrupt:
+        console.print("\nUndeploy cancelled")
+        raise typer.Exit(0)
+
+    # Delete selected endpoints
+    manager = _get_resource_manager()
+    with console.status(f"Deleting {len(selected_resources)} endpoint(s)..."):
+        results = []
+        for resource_id, resource in selected_resources:
+            name = getattr(resource, "name", "N/A")
+            result = asyncio.run(manager.undeploy_resource(resource_id, name))
+            results.append(result)
+
+    # Show results
+    success_count = sum(1 for r in results if r["success"])
+    fail_count = len(results) - success_count
+
+    console.print("\n" + "=" * 50)
+    if success_count > 0:
+        console.print(
+            f"[green]✓[/green] Successfully deleted {success_count} endpoint(s)"
+        )
+    if fail_count > 0:
+        console.print(f"[red]✗[/red] Failed to delete {fail_count} endpoint(s)")
+        console.print("\nErrors:")
+        for result in results:
+            if not result["success"]:
+                console.print(f"  • {result['message']}")

tetra_rp/cli/main.py

@@ -0,0 +1,97 @@
+"""Main CLI entry point for Flash CLI."""
+
+import typer
+from importlib import metadata
+from rich.console import Console
+from rich.panel import Panel
+
+from .commands import (
+    init,
+    run,
+    build,
+    test_mothership,
+    # resource,
+    deploy,
+    apps,
+    undeploy,
+)
+
+
+def get_version() -> str:
+    """Get the package version from metadata."""
+    try:
+        return metadata.version("tetra_rp")
+    except metadata.PackageNotFoundError:
+        return "unknown"
+
+
+console = Console()
+
+# command: flash
+app = typer.Typer(
+    name="flash",
+    help="Runpod Flash CLI - Distributed inference and serving framework",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
+
+# command: flash <command>
+app.command("init")(init.init_command)
+app.command("run")(run.run_command)
+app.command("build")(build.build_command)
+app.command("test-mothership")(test_mothership.test_mothership_command)
+# app.command("report")(resource.report_command)
+
+
+# command: flash deploy
+deploy_app = typer.Typer(
+    name="deploy",
+    help="Deployment environment management commands",
+    no_args_is_help=True,
+)
+
+deploy_app.command("list")(deploy.list_command)
+deploy_app.command("new")(deploy.new_command)
+deploy_app.command("send")(deploy.send_command)
+deploy_app.command("info")(deploy.info_command)
+deploy_app.command("delete")(deploy.delete_command)
+# deploy_app.command("report")(deploy.report_command)
+# deploy_app.command("rollback")(deploy.rollback_command)
+# deploy_app.command("remove")(deploy.remove_command)
+
+
+# command: flash deploy *
+app.add_typer(deploy_app, name="deploy")
+app.add_typer(apps.apps_app)
+
+
+# command: flash undeploy
+# Note: Using a simple command instead of sub-app to allow both "undeploy list" and "undeploy <name>"
+# The undeploy_command internally handles the "list" case
+app.command("undeploy")(undeploy.undeploy_command)
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: bool = typer.Option(False, "--version", "-v", help="Show version"),
+):
+    """Runpod Flash CLI - Distributed inference and serving framework."""
+    if version:
+        console.print(f"Runpod Flash CLI v{get_version()}")
+        raise typer.Exit()
+
+    if ctx.invoked_subcommand is None:
+        console.print(
+            Panel(
+                "[bold blue]Runpod Flash CLI[/bold blue]\n\n"
+                "A framework for distributed inference and serving of ML models.\n\n"
+                "Use [bold]flash --help[/bold] to see available commands.",
+                title="Welcome",
+                expand=False,
+            )
+        )
+
+
+if __name__ == "__main__":
+    app()

tetra_rp/cli/utils/__init__.py

@@ -0,0 +1 @@
+"""CLI utility modules."""

tetra_rp/cli/utils/app.py

@@ -0,0 +1,15 @@
+from pathlib import Path
+
+
+def discover_flash_project() -> tuple[Path, str]:
+    """
+    Discover Flash project directory and app name.
+    Returns:
+        Tuple of (project_dir, app_name)
+    Raises:
+        typer.Exit: If not in a Flash project directory
+    """
+    project_dir = Path.cwd()
+    app_name = project_dir.name
+
+    return project_dir, app_name