tetra-rp 0.17.1__py3-none-any.whl

tetra_rp/cli/commands/run.py

@@ -0,0 +1,100 @@
+"""Run Flash development server."""
+
+import subprocess
+import sys
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+console = Console()
+
+
+def run_command(
+    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"
+    ),
+):
+    """Run Flash development server with uvicorn."""
+
+    # Discover entry point
+    entry_point = discover_entry_point()
+    if not entry_point:
+        console.print("[red]Error:[/red] No entry point found")
+        console.print("Create main.py with a FastAPI app")
+        raise typer.Exit(1)
+
+    # 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)
+
+    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:
+        subprocess.run(cmd)
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Server stopped[/yellow]")
+        raise typer.Exit(0)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+
+def discover_entry_point() -> Optional[str]:
+    """Discover the main entry point file."""
+    candidates = ["main.py", "app.py", "server.py"]
+
+    for candidate in candidates:
+        if Path(candidate).exists():
+            return candidate
+
+    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
+
+    except Exception:
+        return None

tetra_rp/cli/main.py

@@ -0,0 +1,85 @@
+"""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,
+    # resource,
+    deploy,
+)
+
+
+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("report")(resource.report_command)
+# app.command("clean")(resource.clean_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("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.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/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/deployment.py

@@ -0,0 +1,172 @@
+"""Deployment environment management utilities."""
+
+import json
+from typing import Dict, Any
+from datetime import datetime
+
+from tetra_rp.config import get_paths
+
+
+def get_deployment_environments() -> Dict[str, Dict[str, Any]]:
+    """Get all deployment environments."""
+    paths = get_paths()
+    deployments_file = paths.deployments_file
+
+    if not deployments_file.exists():
+        return {}
+
+    try:
+        with open(deployments_file) as f:
+            return json.load(f)
+    except (json.JSONDecodeError, FileNotFoundError):
+        return {}
+
+
+def save_deployment_environments(environments: Dict[str, Dict[str, Any]]):
+    """Save deployment environments to file."""
+    paths = get_paths()
+    deployments_file = paths.deployments_file
+
+    # Ensure .tetra directory exists
+    paths.ensure_tetra_dir()
+
+    with open(deployments_file, "w") as f:
+        json.dump(environments, f, indent=2)
+
+
+def create_deployment_environment(name: str, config: Dict[str, Any]):
+    """Create a new deployment environment."""
+    environments = get_deployment_environments()
+
+    # Mock environment creation
+    environments[name] = {
+        "status": "idle",
+        "config": config,
+        "created_at": datetime.now().isoformat(),
+        "current_version": None,
+        "last_deployed": None,
+        "url": None,
+        "version_history": [],
+    }
+
+    save_deployment_environments(environments)
+
+
+def remove_deployment_environment(name: str):
+    """Remove a deployment environment."""
+    environments = get_deployment_environments()
+
+    if name in environments:
+        del environments[name]
+        save_deployment_environments(environments)
+
+
+def deploy_to_environment(name: str) -> Dict[str, Any]:
+    """Deploy current project to environment (mock implementation)."""
+    environments = get_deployment_environments()
+
+    if name not in environments:
+        raise ValueError(f"Environment {name} not found")
+
+    # Mock deployment
+    version = f"v1.{len(environments[name]['version_history'])}.0"
+    url = f"https://{name.lower()}.example.com"
+
+    # Update environment
+    environments[name].update(
+        {
+            "status": "active",
+            "current_version": version,
+            "last_deployed": datetime.now().isoformat(),
+            "url": url,
+            "uptime": "99.9%",
+        }
+    )
+
+    # Add to version history
+    version_entry = {
+        "version": version,
+        "deployed_at": datetime.now().isoformat(),
+        "description": "Deployment via CLI",
+        "is_current": True,
+    }
+
+    # Mark previous versions as not current
+    for v in environments[name]["version_history"]:
+        v["is_current"] = False
+
+    environments[name]["version_history"].insert(0, version_entry)
+
+    save_deployment_environments(environments)
+
+    return {"version": version, "url": url, "status": "active"}
+
+
+def rollback_deployment(name: str, target_version: str):
+    """Rollback deployment to a previous version (mock implementation)."""
+    environments = get_deployment_environments()
+
+    if name not in environments:
+        raise ValueError(f"Environment {name} not found")
+
+    # Find target version
+    target_version_info = None
+    for version in environments[name]["version_history"]:
+        if version["version"] == target_version:
+            target_version_info = version
+            break
+
+    if not target_version_info:
+        raise ValueError(f"Version {target_version} not found")
+
+    # Update current version
+    environments[name]["current_version"] = target_version
+    environments[name]["last_deployed"] = datetime.now().isoformat()
+
+    # Update version history
+    for version in environments[name]["version_history"]:
+        version["is_current"] = version["version"] == target_version
+
+    save_deployment_environments(environments)
+
+
+def get_environment_info(name: str) -> Dict[str, Any]:
+    """Get detailed information about an environment."""
+    environments = get_deployment_environments()
+
+    if name not in environments:
+        raise ValueError(f"Environment {name} not found")
+
+    env_info = environments[name].copy()
+
+    # Add mock metrics and additional info
+    if env_info["status"] == "active":
+        env_info.update(
+            {
+                "uptime": "99.9%",
+                "requests_24h": 145234,
+                "avg_response_time": "245ms",
+                "error_rate": "0.02%",
+                "cpu_usage": "45%",
+                "memory_usage": "62%",
+            }
+        )
+
+    # Ensure version history exists and is properly formatted
+    if "version_history" not in env_info:
+        env_info["version_history"] = []
+
+    # Add sample version history if empty
+    if not env_info["version_history"] and env_info["current_version"]:
+        env_info["version_history"] = [
+            {
+                "version": env_info["current_version"],
+                "deployed_at": env_info.get(
+                    "last_deployed", datetime.now().isoformat()
+                ),
+                "description": "Initial deployment",
+                "is_current": True,
+            }
+        ]
+
+    return env_info

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