tetra-rp 0.17.1__py3-none-any.whl

tetra_rp/cli/utils/skeleton.py

@@ -0,0 +1,184 @@
+"""Project skeleton creation utilities."""
+
+from fnmatch import fnmatch
+from pathlib import Path
+from typing import List
+
+# Patterns to ignore during skeleton operations
+IGNORE_PATTERNS = {
+    "__pycache__",
+    "*.pyc",
+    "*.pyo",
+    "*.pyd",
+    ".DS_Store",
+    "Thumbs.db",
+    ".git",
+    ".pytest_cache",
+    "*.egg-info",
+}
+
+
+def _should_ignore(path: Path) -> bool:
+    """
+    Check if path matches any ignore pattern.
+
+    Args:
+        path: Path to check
+
+    Returns:
+        True if path should be ignored, False otherwise
+    """
+    for pattern in IGNORE_PATTERNS:
+        # Check if any path component matches the pattern
+        if fnmatch(path.name, pattern):
+            return True
+        if any(fnmatch(part, pattern) for part in path.parts):
+            return True
+    return False
+
+
+def detect_file_conflicts(project_dir: Path) -> List[Path]:
+    """
+    Detect files that would be overwritten when creating project skeleton.
+
+    Args:
+        project_dir: Project directory path to check
+
+    Returns:
+        List of file paths that already exist and would be overwritten
+    """
+    conflicts: List[Path] = []
+
+    # Get template directory path
+    template_dir = Path(__file__).parent / "skeleton_template"
+
+    if not template_dir.exists():
+        return conflicts
+
+    def check_conflicts_recursive(src_dir: Path) -> None:
+        """Recursively check for file conflicts."""
+        for item in src_dir.iterdir():
+            if _should_ignore(item):
+                continue
+
+            relative_path = item.relative_to(template_dir)
+            target_file = project_dir / relative_path
+
+            if item.is_dir():
+                check_conflicts_recursive(item)
+            elif item.is_file():
+                if target_file.exists():
+                    conflicts.append(relative_path)
+
+    # Start recursive conflict check
+    check_conflicts_recursive(template_dir)
+
+    return conflicts
+
+
+def _copy_template_file(
+    item: Path,
+    template_dir: Path,
+    project_dir: Path,
+    force: bool,
+    created_files: List[str],
+) -> None:
+    """
+    Copy a single template file with substitutions.
+
+    Args:
+        item: Source file path
+        template_dir: Template directory base path
+        project_dir: Target project directory
+        force: Overwrite existing files
+        created_files: List to append created file paths to
+    """
+    relative_path = item.relative_to(template_dir)
+    target_path = project_dir / relative_path
+
+    # Skip existing files unless force is True
+    if target_path.exists() and not force:
+        return
+
+    # Create parent directories if needed
+    target_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Read content and handle template substitutions
+    try:
+        content = item.read_text()
+
+        # Replace {{project_name}} placeholder
+        if "{{project_name}}" in content:
+            content = content.replace("{{project_name}}", project_dir.name)
+
+        # Write file
+        target_path.write_text(content)
+        created_files.append(str(relative_path))
+    except UnicodeDecodeError:
+        # Handle binary files (just copy bytes)
+        target_path.write_bytes(item.read_bytes())
+        created_files.append(str(relative_path))
+
+
+def _copy_directory_recursive(
+    src_dir: Path,
+    template_dir: Path,
+    project_dir: Path,
+    force: bool,
+    created_files: List[str],
+) -> None:
+    """
+    Recursively copy directory contents, including hidden files.
+
+    Args:
+        src_dir: Source directory to copy from
+        template_dir: Template directory base path
+        project_dir: Target project directory
+        force: Overwrite existing files
+        created_files: List to append created file paths to
+    """
+    for item in src_dir.iterdir():
+        # Skip ignored items
+        if _should_ignore(item):
+            continue
+
+        if item.is_dir():
+            # Create target directory and recurse
+            relative_path = item.relative_to(template_dir)
+            target_path = project_dir / relative_path
+            target_path.mkdir(parents=True, exist_ok=True)
+            _copy_directory_recursive(
+                item, template_dir, project_dir, force, created_files
+            )
+        elif item.is_file():
+            _copy_template_file(item, template_dir, project_dir, force, created_files)
+
+
+def create_project_skeleton(project_dir: Path, force: bool = False) -> List[str]:
+    """
+    Create Flash project skeleton from template directory.
+
+    Args:
+        project_dir: Project directory path
+        force: Overwrite existing files
+
+    Returns:
+        List of created file paths
+    """
+    created_files: List[str] = []
+
+    # Get template directory path
+    template_dir = Path(__file__).parent / "skeleton_template"
+
+    if not template_dir.exists():
+        raise FileNotFoundError(f"Template directory not found: {template_dir}")
+
+    # Create project directory
+    project_dir.mkdir(parents=True, exist_ok=True)
+
+    # Start recursive copy
+    _copy_directory_recursive(
+        template_dir, template_dir, project_dir, force, created_files
+    )
+
+    return created_files

tetra_rp/cli/utils/skeleton_template/.env.example

@@ -0,0 +1,3 @@
+# RUNPOD_API_KEY=your_api_key_here
+# PORT=80
+# LOG_LEVEL=INFO

tetra_rp/cli/utils/skeleton_template/.flashignore

@@ -0,0 +1,40 @@
+# Flash Build Ignore Patterns
+
+# Python cache
+__pycache__/
+*.pyc
+
+# Virtual environments
+venv/
+.venv/
+env/
+
+# IDE
+.vscode/
+.idea/
+
+# Environment files
+.env
+.env.local
+
+# Git
+.git/
+.gitignore
+
+# Build artifacts
+dist/
+build/
+*.egg-info/
+
+# Flash resources
+.tetra_resources.pkl
+
+# Tests
+tests/
+test_*.py
+*_test.py
+
+# Documentation
+docs/
+*.md
+!README.md

tetra_rp/cli/utils/skeleton_template/.gitignore

@@ -0,0 +1,44 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+.venv/
+ENV/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Environment
+.env
+.env.local
+
+# Flash
+.tetra_resources.pkl
+dist/
+
+# OS
+.DS_Store
+Thumbs.db

tetra_rp/cli/utils/skeleton_template/README.md

@@ -0,0 +1,256 @@
+# {{project_name}}
+
+Flash application demonstrating distributed GPU and CPU computing on Runpod's serverless infrastructure.
+
+## About This Template
+
+This project was generated using `flash init`. The `{{project_name}}` placeholder is automatically replaced with your actual project name during initialization.
+
+## Quick Start
+
+### 1. Install Dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+### 2. Configure Environment
+
+Create `.env` file:
+
+```bash
+RUNPOD_API_KEY=your_api_key_here
+```
+
+Get your API key from [Runpod Settings](https://www.runpod.io/console/user/settings).
+
+### 3. Run Locally
+
+```bash
+flash run
+```
+
+Server starts at **http://localhost:8000**
+
+### 4. Test the API
+
+```bash
+# Health check
+curl http://localhost:8000/ping
+
+# GPU worker
+curl -X POST http://localhost:8000/gpu/hello \
+  -H "Content-Type: application/json" \
+  -d '{"message": "Hello GPU!"}'
+
+# CPU worker
+curl -X POST http://localhost:8000/cpu/hello \
+  -H "Content-Type: application/json" \
+  -d '{"message": "Hello CPU!"}'
+```
+
+Visit **http://localhost:8000/docs** for interactive API documentation.
+
+## What This Demonstrates
+
+### GPU Worker (`workers/gpu/`)
+Simple GPU-based serverless function:
+- Remote execution with `@remote` decorator
+- GPU resource configuration
+- Automatic scaling (0-3 workers)
+- No external dependencies required
+
+```python
+@remote(
+    resource_config=LiveServerless(
+        name="gpu_worker",
+        gpus=[GpuGroup.ADA_24],  # RTX 4090
+        workersMin=0,
+        workersMax=3,
+    )
+)
+async def gpu_hello(input_data: dict) -> dict:
+    # Your GPU code here
+    return {"status": "success", "message": "Hello from GPU!"}
+```
+
+### CPU Worker (`workers/cpu/`)
+Simple CPU-based serverless function:
+- CPU-only execution (no GPU overhead)
+- CpuLiveServerless configuration
+- Efficient for API endpoints
+- Automatic scaling (0-5 workers)
+
+```python
+@remote(
+    resource_config=CpuLiveServerless(
+        name="cpu_worker",
+        instanceIds=[CpuInstanceType.CPU3G_2_8],  # 2 vCPU, 8GB RAM
+        workersMin=0,
+        workersMax=5,
+    )
+)
+async def cpu_hello(input_data: dict) -> dict:
+    # Your CPU code here
+    return {"status": "success", "message": "Hello from CPU!"}
+```
+
+## Project Structure
+
+```
+{{project_name}}/
+├── main.py                    # FastAPI application
+├── workers/
+│   ├── gpu/                  # GPU worker
+│   │   ├── __init__.py       # FastAPI router
+│   │   └── endpoint.py       # @remote decorated function
+│   └── cpu/                  # CPU worker
+│       ├── __init__.py       # FastAPI router
+│       └── endpoint.py       # @remote decorated function
+├── .env                      # Environment variables
+├── requirements.txt          # Dependencies
+└── README.md                 # This file
+```
+
+## Key Concepts
+
+### Remote Execution
+The `@remote` decorator transparently executes functions on serverless infrastructure:
+- Code runs locally during development
+- Automatically deploys to Runpod when configured
+- Handles serialization, dependencies, and resource management
+
+### Resource Scaling
+Both workers scale to zero when idle to minimize costs:
+- **idleTimeout**: Minutes before scaling down (default: 5)
+- **workersMin**: 0 = completely scales to zero
+- **workersMax**: Maximum concurrent workers
+
+### GPU Types
+Available GPU options for `LiveServerless`:
+- `GpuGroup.ADA_24` - RTX 4090 (24GB)
+- `GpuGroup.ADA_48_PRO` - RTX 6000 Ada, L40 (48GB)
+- `GpuGroup.AMPERE_80` - A100 (80GB)
+- `GpuGroup.ANY` - Any available GPU
+
+### CPU Types
+Available CPU options for `CpuLiveServerless`:
+- `CpuInstanceType.CPU3G_2_8` - 2 vCPU, 8GB RAM (General Purpose)
+- `CpuInstanceType.CPU3C_4_8` - 4 vCPU, 8GB RAM (Compute Optimized)
+- `CpuInstanceType.CPU5G_4_16` - 4 vCPU, 16GB RAM (Latest Gen)
+- `CpuInstanceType.ANY` - Any available GPU
+
+## Development Workflow
+
+### Test Workers Locally
+```bash
+# Test GPU worker
+python -m workers.gpu.endpoint
+
+# Test CPU worker
+python -m workers.cpu.endpoint
+```
+
+### Run the Application
+```bash
+flash run
+```
+
+### Deploy to Production
+```bash
+# Discover and configure handlers
+flash build
+
+# Create deployment environment
+flash deploy new production
+
+# Deploy to Runpod
+flash deploy send production
+```
+
+## Adding New Workers
+
+### Add a GPU Worker
+
+1. Create `workers/my_worker/endpoint.py`:
+```python
+from tetra_rp import remote, LiveServerless
+
+config = LiveServerless(name="my_worker")
+
+@remote(resource_config=config, dependencies=["torch"])
+async def my_function(data: dict) -> dict:
+    import torch
+    # Your code here
+    return {"result": "success"}
+```
+
+2. Create `workers/my_worker/__init__.py`:
+```python
+from fastapi import APIRouter
+from .endpoint import my_function
+
+router = APIRouter()
+
+@router.post("/process")
+async def handler(data: dict):
+    return await my_function(data)
+```
+
+3. Add to `main.py`:
+```python
+from workers.my_worker import router as my_router
+app.include_router(my_router, prefix="/my_worker")
+```
+
+### Add a CPU Worker
+
+Same pattern but use `CpuLiveServerless`:
+```python
+from tetra_rp import remote, CpuLiveServerless, CpuInstanceType
+
+config = CpuLiveServerless(
+    name="my_cpu_worker",
+    instanceIds=[CpuInstanceType.CPU3G_2_8]
+)
+
+@remote(resource_config=config, dependencies=["requests"])
+async def fetch_data(url: str) -> dict:
+    import requests
+    return requests.get(url).json()
+```
+
+## Adding Dependencies
+
+Specify dependencies in the `@remote` decorator:
+```python
+@remote(
+    resource_config=config,
+    dependencies=["torch>=2.0.0", "transformers"],  # Python packages
+    system_dependencies=["ffmpeg"]  # System packages
+)
+async def my_function(data: dict) -> dict:
+    # Dependencies are automatically installed
+    import torch
+    import transformers
+```
+
+## Environment Variables
+
+```bash
+# Required
+RUNPOD_API_KEY=your_api_key
+
+# Optional
+PORT=8000
+LOG_LEVEL=INFO
+```
+
+## Next Steps
+
+- Add your ML models or processing logic
+- Configure GPU/CPU resources based on your needs
+- Add authentication to your endpoints
+- Implement error handling and retries
+- Add monitoring and logging
+- Deploy to production with `flash deploy`

tetra_rp/cli/utils/skeleton_template/main.py

@@ -0,0 +1,43 @@
+import os
+import logging
+from fastapi import FastAPI
+
+from workers.gpu import gpu_router
+from workers.cpu import cpu_router
+
+
+logger = logging.getLogger(__name__)
+
+
+app = FastAPI(
+    title="Flash Application",
+    description="Distributed GPU and CPU computing with Runpod Flash",
+    version="0.1.0",
+)
+
+# Include routers
+app.include_router(gpu_router, prefix="/gpu", tags=["GPU Workers"])
+app.include_router(cpu_router, prefix="/cpu", tags=["CPU Workers"])
+
+
+@app.get("/")
+def home():
+    return {
+        "message": "Flash Application",
+        "docs": "/docs",
+        "endpoints": {"gpu_hello": "/gpu/hello", "cpu_hello": "/cpu/hello"},
+    }
+
+
+@app.get("/ping")
+def ping():
+    return {"status": "healthy"}
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    port = int(os.getenv("PORT", 8888))
+    logger.info(f"Starting Flash server on port {port}")
+
+    uvicorn.run(app, host="0.0.0.0", port=port)

tetra_rp/cli/utils/skeleton_template/requirements.txt

@@ -0,0 +1 @@
+tetra_rp

tetra_rp/cli/utils/skeleton_template/workers/cpu/__init__.py

@@ -0,0 +1,20 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+from .endpoint import cpu_hello
+
+
+cpu_router = APIRouter()
+
+
+class MessageRequest(BaseModel):
+    """Request model for CPU worker."""
+
+    message: str = "Hello from CPU!"
+
+
+@cpu_router.post("/hello")
+async def hello(request: MessageRequest):
+    """Simple CPU worker endpoint."""
+    result = await cpu_hello({"message": request.message})
+    return result

tetra_rp/cli/utils/skeleton_template/workers/cpu/endpoint.py

@@ -0,0 +1,38 @@
+from tetra_rp import remote, CpuLiveServerless, CpuInstanceType
+
+
+cpu_config = CpuLiveServerless(
+    name="cpu_worker",
+    instanceIds=[CpuInstanceType.ANY],
+    workersMin=0,
+    workersMax=5,
+    idleTimeout=5,
+)
+
+
+@remote(resource_config=cpu_config)
+async def cpu_hello(input_data: dict) -> dict:
+    """Simple CPU worker example."""
+    import platform
+    from datetime import datetime
+
+    message = input_data.get("message", "Hello from CPU worker!")
+
+    return {
+        "status": "success",
+        "message": message,
+        "worker_type": "CPU",
+        "timestamp": datetime.now().isoformat(),
+        "platform": platform.system(),
+        "python_version": platform.python_version(),
+    }
+
+
+# Test locally with: python -m workers.cpu.endpoint
+if __name__ == "__main__":
+    import asyncio
+
+    test_payload = {"message": "Testing CPU worker"}
+    print(f"Testing CPU worker with payload: {test_payload}")
+    result = asyncio.run(cpu_hello(test_payload))
+    print(f"Result: {result}")

tetra_rp/cli/utils/skeleton_template/workers/gpu/__init__.py

@@ -0,0 +1,20 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+from .endpoint import gpu_hello
+
+
+gpu_router = APIRouter()
+
+
+class MessageRequest(BaseModel):
+    """Request model for GPU worker."""
+
+    message: str = "Hello from GPU!"
+
+
+@gpu_router.post("/hello")
+async def hello(request: MessageRequest):
+    """Simple GPU worker endpoint."""
+    result = await gpu_hello({"message": request.message})
+    return result