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

tetra_rp/cli/commands/build.py

@@ -0,0 +1,501 @@
+"""Flash build command - Package Flash applications for deployment."""
+
+import ast
+import shutil
+import subprocess
+import sys
+import tarfile
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.table import Table
+
+from ..utils.ignore import get_file_tree, load_ignore_patterns
+
+console = Console()
+
+# Constants
+PIP_INSTALL_TIMEOUT_SECONDS = 600  # 10 minute timeout for pip install
+
+
+def build_command(
+    no_deps: bool = typer.Option(
+        False, "--no-deps", help="Skip transitive dependencies during pip install"
+    ),
+    keep_build: bool = typer.Option(
+        False, "--keep-build", help="Keep .build directory after creating archive"
+    ),
+    output_name: str | None = typer.Option(
+        None, "--output", "-o", help="Custom archive name (default: archive.tar.gz)"
+    ),
+):
+    """
+    Build Flash application for deployment.
+
+    Packages the application code and dependencies into a self-contained tarball,
+    similar to AWS Lambda packaging. All pip packages are installed as local modules.
+
+    Examples:
+      flash build                  # Build with all dependencies
+      flash build --no-deps        # Skip transitive dependencies
+      flash build --keep-build     # Keep temporary build directory
+      flash build -o my-app.tar.gz # Custom archive name
+    """
+    try:
+        # Validate project structure
+        project_dir, app_name = discover_flash_project()
+
+        if not validate_project_structure(project_dir):
+            console.print("[red]Error:[/red] Not a valid Flash project")
+            console.print("Run [bold]flash init[/bold] to create a Flash project")
+            raise typer.Exit(1)
+
+        # Display configuration
+        _display_build_config(project_dir, app_name, no_deps, keep_build, output_name)
+
+        # Execute build
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+        ) as progress:
+            # Load ignore patterns
+            ignore_task = progress.add_task("Loading ignore patterns...")
+            spec = load_ignore_patterns(project_dir)
+            progress.update(ignore_task, description="[green]✓ Loaded ignore patterns")
+            progress.stop_task(ignore_task)
+
+            # Collect files
+            collect_task = progress.add_task("Collecting project files...")
+            files = get_file_tree(project_dir, spec)
+            progress.update(
+                collect_task,
+                description=f"[green]✓ Found {len(files)} files to package",
+            )
+            progress.stop_task(collect_task)
+
+            # Create build directory
+            build_task = progress.add_task("Creating build directory...")
+            build_dir = create_build_directory(project_dir, app_name)
+            progress.update(
+                build_task,
+                description=f"[green]✓ Created .tetra/.build/{app_name}/",
+            )
+            progress.stop_task(build_task)
+
+            # Copy files
+            copy_task = progress.add_task("Copying project files...")
+            copy_project_files(files, project_dir, build_dir)
+            progress.update(
+                copy_task, description=f"[green]✓ Copied {len(files)} files"
+            )
+            progress.stop_task(copy_task)
+
+            # Install dependencies
+            deps_task = progress.add_task("Installing dependencies...")
+            requirements = collect_requirements(project_dir, build_dir)
+
+            if not requirements:
+                progress.update(
+                    deps_task,
+                    description="[yellow]⚠ No dependencies found",
+                )
+            else:
+                progress.update(
+                    deps_task,
+                    description=f"Installing {len(requirements)} packages...",
+                )
+
+                success = install_dependencies(build_dir, requirements, no_deps)
+
+                if not success:
+                    progress.stop_task(deps_task)
+                    console.print("[red]Error:[/red] Failed to install dependencies")
+                    raise typer.Exit(1)
+
+                progress.update(
+                    deps_task,
+                    description=f"[green]✓ Installed {len(requirements)} packages",
+                )
+
+            progress.stop_task(deps_task)
+
+            # Create archive
+            archive_task = progress.add_task("Creating archive...")
+            archive_name = output_name or "archive.tar.gz"
+            archive_path = project_dir / ".tetra" / archive_name
+
+            create_tarball(build_dir, archive_path, app_name)
+
+            # Get archive size
+            size_mb = archive_path.stat().st_size / (1024 * 1024)
+
+            progress.update(
+                archive_task,
+                description=f"[green]✓ Created {archive_name} ({size_mb:.1f} MB)",
+            )
+            progress.stop_task(archive_task)
+
+            # Cleanup
+            if not keep_build:
+                cleanup_task = progress.add_task("Cleaning up...")
+                cleanup_build_directory(build_dir.parent)
+                progress.update(
+                    cleanup_task, description="[green]✓ Removed .build directory"
+                )
+                progress.stop_task(cleanup_task)
+
+        # Success summary
+        _display_build_summary(archive_path, app_name, len(files), len(requirements))
+
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Build cancelled by user[/yellow]")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"\n[red]Build failed:[/red] {e}")
+        import traceback
+
+        console.print(traceback.format_exc())
+        raise typer.Exit(1)
+
+
+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
+
+
+def validate_project_structure(project_dir: Path) -> bool:
+    """
+    Validate that directory is a Flash project.
+
+    Args:
+        project_dir: Directory to validate
+
+    Returns:
+        True if valid Flash project
+    """
+    main_py = project_dir / "main.py"
+
+    if not main_py.exists():
+        console.print(f"[red]Error:[/red] main.py not found in {project_dir}")
+        return False
+
+    # Check if main.py has FastAPI app
+    try:
+        content = main_py.read_text(encoding="utf-8")
+        if "FastAPI" not in content:
+            console.print(
+                "[yellow]Warning:[/yellow] main.py does not appear to have a FastAPI app"
+            )
+    except Exception:
+        pass
+
+    return True
+
+
+def create_build_directory(project_dir: Path, app_name: str) -> Path:
+    """
+    Create .tetra/.build/{app_name}/ directory.
+
+    Args:
+        project_dir: Flash project directory
+        app_name: Application name
+
+    Returns:
+        Path to build directory
+    """
+    tetra_dir = project_dir / ".tetra"
+    tetra_dir.mkdir(exist_ok=True)
+
+    build_base = tetra_dir / ".build"
+    build_dir = build_base / app_name
+
+    # Remove existing build directory
+    if build_dir.exists():
+        shutil.rmtree(build_dir)
+
+    build_dir.mkdir(parents=True, exist_ok=True)
+
+    return build_dir
+
+
+def copy_project_files(files: list[Path], source_dir: Path, dest_dir: Path) -> None:
+    """
+    Copy project files to build directory.
+
+    Args:
+        files: List of files to copy
+        source_dir: Source directory
+        dest_dir: Destination directory
+    """
+    for file_path in files:
+        # Get relative path
+        rel_path = file_path.relative_to(source_dir)
+
+        # Create destination path
+        dest_path = dest_dir / rel_path
+
+        # Create parent directories
+        dest_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Copy file
+        shutil.copy2(file_path, dest_path)
+
+
+def collect_requirements(project_dir: Path, build_dir: Path) -> list[str]:
+    """
+    Collect all requirements from requirements.txt and @remote decorators.
+
+    Args:
+        project_dir: Flash project directory
+        build_dir: Build directory (to check for workers)
+
+    Returns:
+        List of requirement strings
+    """
+    requirements = []
+
+    # Load requirements.txt
+    req_file = project_dir / "requirements.txt"
+    if req_file.exists():
+        try:
+            content = req_file.read_text(encoding="utf-8")
+            for line in content.splitlines():
+                line = line.strip()
+                # Skip empty lines and comments
+                if line and not line.startswith("#"):
+                    requirements.append(line)
+        except Exception as e:
+            console.print(
+                f"[yellow]Warning:[/yellow] Failed to read requirements.txt: {e}"
+            )
+
+    # Extract dependencies from @remote decorators
+    workers_dir = build_dir / "workers"
+    if workers_dir.exists():
+        remote_deps = extract_remote_dependencies(workers_dir)
+        requirements.extend(remote_deps)
+
+    # Remove duplicates while preserving order
+    seen = set()
+    unique_requirements = []
+    for req in requirements:
+        if req not in seen:
+            seen.add(req)
+            unique_requirements.append(req)
+
+    return unique_requirements
+
+
+def extract_remote_dependencies(workers_dir: Path) -> list[str]:
+    """
+    Extract dependencies from @remote decorators in worker files.
+
+    Args:
+        workers_dir: Path to workers directory
+
+    Returns:
+        List of dependency strings
+    """
+    dependencies = []
+
+    for py_file in workers_dir.glob("*.py"):
+        if py_file.name == "__init__.py":
+            continue
+
+        try:
+            tree = ast.parse(py_file.read_text(encoding="utf-8"))
+
+            for node in ast.walk(tree):
+                if isinstance(node, (ast.ClassDef, ast.FunctionDef)):
+                    for decorator in node.decorator_list:
+                        if isinstance(decorator, ast.Call):
+                            func_name = None
+                            if isinstance(decorator.func, ast.Name):
+                                func_name = decorator.func.id
+                            elif isinstance(decorator.func, ast.Attribute):
+                                func_name = decorator.func.attr
+
+                            if func_name == "remote":
+                                # Extract dependencies keyword argument
+                                for keyword in decorator.keywords:
+                                    if keyword.arg == "dependencies":
+                                        if isinstance(keyword.value, ast.List):
+                                            for elt in keyword.value.elts:
+                                                if isinstance(elt, ast.Constant):
+                                                    dependencies.append(elt.value)
+
+        except Exception as e:
+            console.print(
+                f"[yellow]Warning:[/yellow] Failed to parse {py_file.name}: {e}"
+            )
+
+    return dependencies
+
+
+def install_dependencies(
+    build_dir: Path, requirements: list[str], no_deps: bool
+) -> bool:
+    """
+    Install dependencies to build directory using pip.
+
+    Args:
+        build_dir: Build directory (pip --target)
+        requirements: List of requirements to install
+        no_deps: If True, skip transitive dependencies
+
+    Returns:
+        True if successful
+    """
+    if not requirements:
+        return True
+
+    # Use only sys.executable -m pip to ensure correct environment
+    pip_cmd = [sys.executable, "-m", "pip"]
+
+    # Check if pip is available
+    try:
+        result = subprocess.run(
+            pip_cmd + ["--version"],
+            capture_output=True,
+            timeout=5,
+        )
+        if result.returncode != 0:
+            console.print(
+                "[red]Error:[/red] pip not found in current Python environment"
+            )
+            return False
+    except (subprocess.SubprocessError, FileNotFoundError):
+        console.print("[red]Error:[/red] pip not found in current Python environment")
+        return False
+
+    cmd = pip_cmd + [
+        "install",
+        "--target",
+        str(build_dir),
+        "--upgrade",
+    ]
+
+    if no_deps:
+        cmd.append("--no-deps")
+
+    cmd.extend(requirements)
+
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=PIP_INSTALL_TIMEOUT_SECONDS,
+        )
+
+        if result.returncode != 0:
+            console.print(f"[red]pip install failed:[/red]\n{result.stderr}")
+            return False
+
+        return True
+
+    except subprocess.TimeoutExpired:
+        console.print(
+            f"[red]pip install timed out ({PIP_INSTALL_TIMEOUT_SECONDS} seconds)[/red]"
+        )
+        return False
+    except Exception as e:
+        console.print(f"[red]pip install error:[/red] {e}")
+        return False
+
+
+def create_tarball(build_dir: Path, output_path: Path, app_name: str) -> None:
+    """
+    Create gzipped tarball of build directory.
+
+    Args:
+        build_dir: Build directory to archive
+        output_path: Output archive path
+        app_name: Application name (used as archive root)
+    """
+    # Remove existing archive
+    if output_path.exists():
+        output_path.unlink()
+
+    # Create tarball with app_name as root directory
+    with tarfile.open(output_path, "w:gz") as tar:
+        tar.add(build_dir, arcname=app_name)
+
+
+def cleanup_build_directory(build_base: Path) -> None:
+    """
+    Remove build directory.
+
+    Args:
+        build_base: .build directory to remove
+    """
+    if build_base.exists():
+        shutil.rmtree(build_base)
+
+
+def _display_build_config(
+    project_dir: Path,
+    app_name: str,
+    no_deps: bool,
+    keep_build: bool,
+    output_name: str | None,
+):
+    """Display build configuration."""
+    archive_name = output_name or "archive.tar.gz"
+
+    console.print(
+        Panel(
+            f"[bold]Project:[/bold] {app_name}\n"
+            f"[bold]Directory:[/bold] {project_dir}\n"
+            f"[bold]Archive:[/bold] .tetra/{archive_name}\n"
+            f"[bold]Skip transitive deps:[/bold] {no_deps}\n"
+            f"[bold]Keep build dir:[/bold] {keep_build}",
+            title="Flash Build Configuration",
+            expand=False,
+        )
+    )
+
+
+def _display_build_summary(
+    archive_path: Path, app_name: str, file_count: int, dep_count: int
+):
+    """Display build summary."""
+    size_mb = archive_path.stat().st_size / (1024 * 1024)
+
+    summary = Table(show_header=False, box=None)
+    summary.add_column("Item", style="bold")
+    summary.add_column("Value", style="cyan")
+
+    summary.add_row("Application", app_name)
+    summary.add_row("Files packaged", str(file_count))
+    summary.add_row("Dependencies", str(dep_count))
+    summary.add_row("Archive", str(archive_path.relative_to(Path.cwd())))
+    summary.add_row("Size", f"{size_mb:.1f} MB")
+
+    console.print("\n")
+    console.print(summary)
+
+    console.print(
+        Panel(
+            f"[bold]{app_name}[/bold] built successfully!\n\n"
+            f"Archive ready for deployment.",
+            title="✓ Build Complete",
+            expand=False,
+            border_style="green",
+        )
+    )

tetra_rp/cli/commands/init.py

@@ -1,77 +1,119 @@
 """Project initialization command."""
 
+from pathlib import Path
+
 import typer
-from typing import Optional
 from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
-import questionary
 
-from tetra_rp.config import get_paths
-from ..utils.skeleton import create_project_skeleton, get_available_templates
+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(
-    template: Optional[str] = typer.Option(
-        None, "--template", "-t", help="Project template to use"
+    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"
     ),
-    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing files"),
 ):
-    """Create skeleton application with starter files."""
+    """Create new Flash project with Flash Server and GPU workers."""
 
-    # Check if we're already in a Tetra project
-    paths = get_paths()
-    if paths.tetra_dir.exists() and not force:
-        console.print("Already in a Tetra project directory")
-        console.print("Use --force to overwrite existing configuration")
-        raise typer.Exit(1)
+    # Create project directory
+    project_dir = Path(project_name)
 
-    # Get available templates
-    available_templates = get_available_templates()
-
-    # Interactive template selection if not provided
-    if not template:
-        template_choices = []
-        for name, info in available_templates.items():
-            template_choices.append(f"{name} - {info['description']}")
-
-        try:
-            selected = questionary.select(
-                "Choose a project template:", choices=template_choices
-            ).ask()
-
-            if not selected:
-                console.print("Template selection cancelled")
-                raise typer.Exit(1)
-
-            template = selected.split(" - ")[0]
-        except KeyboardInterrupt:
-            console.print("\nTemplate selection cancelled")
-            raise typer.Exit(1)
-
-    # Validate template choice
-    if template not in available_templates:
-        console.print(f"Unknown template: {template}")
-        console.print("Available templates:")
-        for name, info in available_templates.items():
-            console.print(f"  • {name} - {info['description']}")
+    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 skeleton
-    template_info = available_templates[template]
-
-    with console.status(f"Creating project with {template} template..."):
-        created_files = create_project_skeleton(template, template_info, force)
+    # 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"Project initialized with [bold]{template}[/bold] template\n\n"
-    panel_content += "Created files:\n"
-    for file_path in created_files:
-        panel_content += f"  • {file_path}\n"
-
-    console.print(Panel(panel_content, title="Project Initialized", expand=False))
+    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]")
@@ -79,8 +121,15 @@ def init_command(
     steps_table.add_column("Step", style="bold cyan")
     steps_table.add_column("Description")
 
-    steps_table.add_row("1.", "Edit .env with your RunPod API key")
-    steps_table.add_row("2.", "Install dependencies: pip install -r requirements.txt")
-    steps_table.add_row("3.", "Run your project: flash run")
+    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)