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

tetra_rp/cli/commands/run.py

@@ -1,122 +1,100 @@
-"""Execute main entry point command."""
+"""Run Flash development server."""
 
-import asyncio
+import subprocess
 import sys
 from pathlib import Path
 from typing import Optional
+
 import typer
 from rich.console import Console
-from rich.progress import Progress, SpinnerColumn, TextColumn
-from rich.panel import Panel
-
-from tetra_rp.config import get_paths
 
 console = Console()
 
 
 def run_command(
-    entry_point: Optional[str] = typer.Option(
-        None, "--entry", "-e", help="Entry point file to execute"
-    ),
-    no_deploy: bool = typer.Option(
-        False, "--no-deploy", help="Skip resource deployment"
+    host: str = typer.Option("localhost", "--host", help="Host to bind to"),
+    port: int = typer.Option(8888, "--port", "-p", help="Port to bind to"),
+    reload: bool = typer.Option(
+        True, "--reload/--no-reload", help="Enable auto-reload"
     ),
 ):
-    """Execute the main entry point of the app."""
+    """Run Flash development server with uvicorn."""
 
-    # Discover entry point if not provided
+    # Discover entry point
+    entry_point = discover_entry_point()
     if not entry_point:
-        entry_point = discover_entry_point()
-        if not entry_point:
-            console.print("No entry point found")
-            console.print("Specify entry point with --entry or create main.py")
-            raise typer.Exit(1)
-
-    # Validate entry point exists
-    entry_path = Path(entry_point)
-    if not entry_path.exists():
-        console.print(f"Entry point not found: {entry_point}")
+        console.print("[red]Error:[/red] No entry point found")
+        console.print("Create main.py with a FastAPI app")
         raise typer.Exit(1)
 
-    console.print(f"🚀 Executing entry point: [bold]{entry_point}[/bold]")
+    # Check if entry point has FastAPI app
+    app_location = check_fastapi_app(entry_point)
+    if not app_location:
+        console.print(f"[red]Error:[/red] No FastAPI app found in {entry_point}")
+        console.print("Make sure your main.py contains: app = FastAPI()")
+        raise typer.Exit(1)
 
-    # Run the entry point
+    console.print("[green]Starting Flash Server[/green]")
+    console.print(f"Entry point: [bold]{app_location}[/bold]")
+    console.print(f"Server: [bold]http://{host}:{port}[/bold]")
+    console.print(f"Auto-reload: [bold]{'enabled' if reload else 'disabled'}[/bold]")
+    console.print("\nPress CTRL+C to stop\n")
+
+    # Build uvicorn command
+    cmd = [
+        sys.executable,
+        "-m",
+        "uvicorn",
+        app_location,
+        "--host",
+        host,
+        "--port",
+        str(port),
+    ]
+
+    if reload:
+        cmd.append("--reload")
+
+    # Run uvicorn
     try:
-        asyncio.run(execute_entry_point(entry_path, no_deploy))
+        subprocess.run(cmd)
     except KeyboardInterrupt:
-        console.print("\nExecution interrupted by user")
-        raise typer.Exit(1)
+        console.print("\n[yellow]Server stopped[/yellow]")
+        raise typer.Exit(0)
     except Exception as e:
-        console.print(f"Execution failed: {e}")
+        console.print(f"[red]Error:[/red] {e}")
         raise typer.Exit(1)
 
 
 def discover_entry_point() -> Optional[str]:
     """Discover the main entry point file."""
-    # Check common entry point names
-    candidates = ["main.py", "app.py", "run.py", "__main__.py"]
+    candidates = ["main.py", "app.py", "server.py"]
 
     for candidate in candidates:
         if Path(candidate).exists():
             return candidate
 
-    # Check for .tetra/config.json entry point
-    paths = get_paths()
-    config_path = paths.config_file
-    if config_path.exists():
-        try:
-            import json
+    return None
 
-            with open(config_path) as f:
-                config = json.load(f)
-            return config.get("entry_point")
-        except (json.JSONDecodeError, KeyError):
-            pass
 
-    return None
+def check_fastapi_app(entry_point: str) -> Optional[str]:
+    """
+    Check if entry point has a FastAPI app and return the app location.
+
+    Returns:
+        App location in format "module:app" or None
+    """
+    try:
+        # Read the file
+        content = Path(entry_point).read_text()
+
+        # Check for FastAPI app
+        if "app = FastAPI(" in content or "app=FastAPI(" in content:
+            # Extract module name from file path
+            module = entry_point.replace(".py", "").replace("/", ".")
+            return f"{module}:app"
 
+        return None
 
-async def execute_entry_point(entry_path: Path, no_deploy: bool = False):
-    """Execute the entry point with progress tracking."""
-
-    with Progress(
-        SpinnerColumn(),
-        TextColumn("[progress.description]{task.description}"),
-        console=console,
-    ) as progress:
-        if not no_deploy:
-            # Deployment phase
-            deploy_task = progress.add_task("Preparing resources...", total=None)
-            await asyncio.sleep(1)  # Mock deployment time
-            progress.update(deploy_task, description="Resources ready")
-            progress.stop_task(deploy_task)
-
-        # Execution phase
-        exec_task = progress.add_task("Executing...", total=None)
-
-        # Execute the Python file
-        try:
-            # Import and run the module
-            spec = __import__("importlib.util").util.spec_from_file_location(
-                entry_path.stem, entry_path
-            )
-            module = __import__("importlib.util").util.module_from_spec(spec)
-
-            # Add the directory to sys.path so imports work
-            sys.path.insert(0, str(entry_path.parent))
-
-            spec.loader.exec_module(module)
-
-            progress.update(exec_task, description="Complete!")
-            await asyncio.sleep(0.5)  # Brief pause to show completion
-
-        except Exception as e:
-            progress.update(exec_task, description=f"Failed: {e}")
-            raise
-        finally:
-            progress.stop_task(exec_task)
-
-    # Success message
-    console.print(
-        Panel("Execution completed successfully", title="Success", expand=False)
-    )
+    except Exception:
+        return None

tetra_rp/cli/main.py

@@ -8,6 +8,7 @@ from rich.panel import Panel
 from .commands import (
     init,
     run,
+    build,
     resource,
     deploy,
 )
@@ -26,7 +27,7 @@ console = Console()
 # command: flash
 app = typer.Typer(
     name="flash",
-    help="Flash CLI - Distributed inference and serving framework",
+    help="Runpod Flash CLI - Distributed inference and serving framework",
     no_args_is_help=True,
     rich_markup_mode="rich",
 )
@@ -34,6 +35,7 @@ app = typer.Typer(
 # command: flash <command>
 app.command("init")(init.init_command)
 app.command("run")(run.run_command)
+app.command("build")(build.build_command)
 app.command("report")(resource.report_command)
 app.command("clean")(resource.clean_command)
 
@@ -60,15 +62,15 @@ def main(
     ctx: typer.Context,
     version: bool = typer.Option(False, "--version", "-v", help="Show version"),
 ):
-    """Flash CLI - Distributed inference and serving framework."""
+    """Runpod Flash CLI - Distributed inference and serving framework."""
     if version:
-        console.print(f"Flash CLI v{get_version()}")
+        console.print(f"Runpod Flash CLI v{get_version()}")
         raise typer.Exit()
 
     if ctx.invoked_subcommand is None:
         console.print(
             Panel(
-                "[bold blue]Flash CLI[/bold blue]\n\n"
+                "[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",

tetra_rp/cli/utils/conda.py

@@ -0,0 +1,127 @@
+"""Conda environment management utilities."""
+
+import subprocess
+from typing import List, Tuple
+from rich.console import Console
+
+console = Console()
+
+
+def check_conda_available() -> bool:
+    """Check if conda is available on the system."""
+    try:
+        result = subprocess.run(
+            ["conda", "--version"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        return result.returncode == 0
+    except (subprocess.SubprocessError, FileNotFoundError):
+        return False
+
+
+def create_conda_environment(
+    env_name: str, python_version: str = "3.11"
+) -> Tuple[bool, str]:
+    """
+    Create a new conda environment.
+
+    Args:
+        env_name: Name of the conda environment
+        python_version: Python version to use
+
+    Returns:
+        Tuple of (success, message)
+    """
+    try:
+        console.print(f"Creating conda environment: {env_name}")
+
+        result = subprocess.run(
+            ["conda", "create", "-n", env_name, f"python={python_version}", "-y"],
+            capture_output=True,
+            text=True,
+            timeout=300,  # 5 minutes timeout
+        )
+
+        if result.returncode == 0:
+            return True, f"Conda environment '{env_name}' created successfully"
+        else:
+            return False, f"Failed to create environment: {result.stderr}"
+
+    except subprocess.TimeoutExpired:
+        return False, "Environment creation timed out"
+    except Exception as e:
+        return False, f"Error creating environment: {e}"
+
+
+def install_packages_in_env(
+    env_name: str, packages: List[str], use_pip: bool = True
+) -> Tuple[bool, str]:
+    """
+    Install packages in a conda environment.
+
+    Args:
+        env_name: Name of the conda environment
+        packages: List of packages to install
+        use_pip: If True, use pip install; otherwise use conda install
+
+    Returns:
+        Tuple of (success, message)
+    """
+    try:
+        console.print(f"Installing packages: {', '.join(packages)}")
+
+        if use_pip:
+            # Use conda run to execute pip in the environment
+            cmd = [
+                "conda",
+                "run",
+                "-n",
+                env_name,
+                "pip",
+                "install",
+            ] + packages
+        else:
+            cmd = ["conda", "install", "-n", env_name, "-y"] + packages
+
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=600,  # 10 minutes timeout
+        )
+
+        if result.returncode == 0:
+            return True, "Packages installed successfully"
+        else:
+            return False, f"Failed to install packages: {result.stderr}"
+
+    except subprocess.TimeoutExpired:
+        return False, "Package installation timed out"
+    except Exception as e:
+        return False, f"Error installing packages: {e}"
+
+
+def environment_exists(env_name: str) -> bool:
+    """Check if a conda environment exists."""
+    try:
+        result = subprocess.run(
+            ["conda", "env", "list"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+
+        if result.returncode == 0:
+            # Check if environment name appears in the output
+            return env_name in result.stdout
+        return False
+
+    except Exception:
+        return False
+
+
+def get_activation_command(env_name: str) -> str:
+    """Get the command to activate the conda environment."""
+    return f"conda activate {env_name}"

tetra_rp/cli/utils/ignore.py

@@ -0,0 +1,139 @@
+"""Ignore pattern matching utilities for Flash build."""
+
+import logging
+from pathlib import Path
+
+import pathspec
+
+log = logging.getLogger(__name__)
+
+
+def parse_ignore_file(file_path: Path) -> list[str]:
+    """
+    Parse an ignore file and return list of patterns.
+
+    Args:
+        file_path: Path to ignore file (.flashignore or .gitignore)
+
+    Returns:
+        List of pattern strings
+    """
+    if not file_path.exists():
+        return []
+
+    try:
+        content = file_path.read_text(encoding="utf-8")
+        patterns = []
+
+        for line in content.splitlines():
+            line = line.strip()
+            # Skip empty lines and comments
+            if line and not line.startswith("#"):
+                patterns.append(line)
+
+        return patterns
+
+    except Exception as e:
+        log.warning(f"Failed to read {file_path.name}: {e}")
+        return []
+
+
+def load_ignore_patterns(project_dir: Path) -> pathspec.PathSpec:
+    """
+    Load ignore patterns from .flashignore and .gitignore files.
+
+    Args:
+        project_dir: Flash project directory
+
+    Returns:
+        PathSpec object for pattern matching
+    """
+    patterns = []
+
+    # Load .flashignore
+    flashignore = project_dir / ".flashignore"
+    if flashignore.exists():
+        flash_patterns = parse_ignore_file(flashignore)
+        patterns.extend(flash_patterns)
+        log.debug(f"Loaded {len(flash_patterns)} patterns from .flashignore")
+
+    # Load .gitignore
+    gitignore = project_dir / ".gitignore"
+    if gitignore.exists():
+        git_patterns = parse_ignore_file(gitignore)
+        patterns.extend(git_patterns)
+        log.debug(f"Loaded {len(git_patterns)} patterns from .gitignore")
+
+    # Always exclude build artifacts
+    always_ignore = [
+        ".build/",
+        ".tetra/",
+        "*.tar.gz",
+        ".git/",
+    ]
+    patterns.extend(always_ignore)
+
+    # Create PathSpec with gitwildmatch pattern (gitignore-style)
+    return pathspec.PathSpec.from_lines("gitwildmatch", patterns)
+
+
+def should_ignore(file_path: Path, spec: pathspec.PathSpec, base_dir: Path) -> bool:
+    """
+    Check if a file should be ignored based on patterns.
+
+    Args:
+        file_path: File path to check
+        spec: PathSpec object with ignore patterns
+        base_dir: Base directory for relative path calculation
+
+    Returns:
+        True if file should be ignored
+    """
+    try:
+        # Get relative path for pattern matching
+        rel_path = file_path.relative_to(base_dir)
+
+        # Check if file matches any ignore pattern
+        return spec.match_file(str(rel_path))
+
+    except ValueError:
+        # file_path is not relative to base_dir
+        return False
+
+
+def get_file_tree(
+    directory: Path, spec: pathspec.PathSpec, base_dir: Path | None = None
+) -> list[Path]:
+    """
+    Recursively collect all files in directory excluding ignored patterns.
+
+    Args:
+        directory: Directory to scan
+        spec: PathSpec object with ignore patterns
+        base_dir: Base directory for relative paths (defaults to directory)
+
+    Returns:
+        List of file paths that should be included
+    """
+    if base_dir is None:
+        base_dir = directory
+
+    files = []
+
+    try:
+        for item in directory.iterdir():
+            # Check if should ignore
+            if should_ignore(item, spec, base_dir):
+                log.debug(f"Ignoring: {item.relative_to(base_dir)}")
+                continue
+
+            if item.is_file():
+                files.append(item)
+            elif item.is_dir():
+                # Recursively collect files from subdirectory
+                files.extend(get_file_tree(item, spec, base_dir))
+
+    except PermissionError as e:
+        log.warning(f"Permission denied: {directory} - {e}")
+
+    return files