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

tetra_rp/cli/commands/run.py

@@ -0,0 +1,122 @@
+"""Execute main entry point command."""
+
+import asyncio
+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"
+    ),
+):
+    """Execute the main entry point of the app."""
+
+    # Discover entry point if not provided
+    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}")
+        raise typer.Exit(1)
+
+    console.print(f"🚀 Executing entry point: [bold]{entry_point}[/bold]")
+
+    # Run the entry point
+    try:
+        asyncio.run(execute_entry_point(entry_path, no_deploy))
+    except KeyboardInterrupt:
+        console.print("\nExecution interrupted by user")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"Execution failed: {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"]
+
+    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
+
+            with open(config_path) as f:
+                config = json.load(f)
+            return config.get("entry_point")
+        except (json.JSONDecodeError, KeyError):
+            pass
+
+    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)
+    )

tetra_rp/cli/main.py

@@ -0,0 +1,81 @@
+"""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,
+    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="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("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,
+)
+
+# command: flash deploy *
+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)
+
+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"),
+):
+    """Flash CLI - Distributed inference and serving framework."""
+    if version:
+        console.print(f"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"
+                "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/templates/advanced/main.py

@@ -0,0 +1,58 @@
+import asyncio
+from dotenv import load_dotenv
+from tetra_rp import remote, LiveServerless
+from utils import generate_report
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Configuration for compute workload
+compute_config = LiveServerless(
+    name="advanced_compute",
+    workersMax=2,
+    cpu=2,
+    memory=4096,
+)
+
+
+@remote(compute_config)
+def analyze_data(data):
+    """Process and analyze data remotely."""
+    import pandas as pd
+
+    # Convert to DataFrame
+    df = pd.DataFrame(data)
+
+    # Perform analysis
+    result = {
+        "mean": df.mean().to_dict(),
+        "std": df.std().to_dict(),
+        "count": len(df),
+        "summary": df.describe().to_dict(),
+    }
+
+    return result
+
+
+async def main():
+    print("🚀 Running advanced Tetra example...")
+
+    # Sample data
+    sample_data = {
+        "values": [1, 2, 3, 4, 5, 10, 15, 20],
+        "categories": ["A", "B", "A", "C", "B", "A", "C", "B"],
+    }
+
+    # Process remotely
+    result = await analyze_data(sample_data)
+
+    # Generate report
+    report = generate_report(result)
+    print(report)
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except Exception as e:
+        print(f"An error occurred: {e}")

tetra_rp/cli/templates/advanced/utils.py

@@ -0,0 +1,24 @@
+"""Utility functions for advanced example."""
+
+
+def process_data(data):
+    """Process raw data before analysis."""
+    # Add any preprocessing logic here
+    return data
+
+
+def generate_report(analysis_result):
+    """Generate a formatted report from analysis results."""
+    report = "\n=== Analysis Report ===\n"
+
+    if "mean" in analysis_result:
+        report += "\nMean values:\n"
+        for key, value in analysis_result["mean"].items():
+            report += f"  {key}: {value:.2f}\n"
+
+    if "count" in analysis_result:
+        report += f"\nTotal records: {analysis_result['count']}\n"
+
+    report += "\n" + "=" * 25
+
+    return report

tetra_rp/cli/templates/basic/main.py

@@ -0,0 +1,32 @@
+import asyncio
+from dotenv import load_dotenv
+from tetra_rp import remote, LiveServerless
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Configuration for a simple resource
+config = LiveServerless(
+    name="basic_example",
+    workersMax=1,
+)
+
+
+@remote(config)
+def hello_world():
+    """Simple remote function example."""
+    print("Hello from the remote function!")
+    return "Hello, World!"
+
+
+async def main():
+    print("🚀 Running basic Tetra example...")
+    result = await hello_world()
+    print(f"Result: {result}")
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except Exception as e:
+        print(f"An error occurred: {e}")

tetra_rp/cli/templates/gpu-compute/main.py

@@ -0,0 +1,64 @@
+import asyncio
+from dotenv import load_dotenv
+from tetra_rp import remote, LiveServerless
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Configuration for GPU workload
+gpu_config = LiveServerless(
+    name="gpu_compute",
+    workersMax=1,
+    gpu=1,
+    gpuType="A40",
+    cpu=4,
+    memory=8192,
+)
+
+
+@remote(gpu_config)
+def gpu_computation():
+    """GPU-accelerated computation example."""
+    try:
+        import torch
+
+        # Check GPU availability
+        if torch.cuda.is_available():
+            device = torch.cuda.get_device_name(0)
+            print(f"Using GPU: {device}")
+
+            # Simple GPU computation
+            x = torch.randn(1000, 1000).cuda()
+            y = torch.randn(1000, 1000).cuda()
+            result = torch.mm(x, y)
+
+            return {
+                "device": device,
+                "matrix_shape": result.shape,
+                "result_mean": result.mean().item(),
+                "computation": "Matrix multiplication completed on GPU",
+            }
+        else:
+            return {"error": "GPU not available"}
+
+    except ImportError:
+        return {"error": "PyTorch not available"}
+
+
+async def main():
+    print("🚀 Running GPU compute example...")
+    result = await gpu_computation()
+
+    if "error" in result:
+        print(f"{result['error']}")
+    else:
+        print("GPU computation completed!")
+        print(f"Device: {result['device']}")
+        print(f"Result: {result['computation']}")
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except Exception as e:
+        print(f"An error occurred: {e}")

tetra_rp/cli/templates/web-api/api.py

@@ -0,0 +1,67 @@
+"""FastAPI application with example endpoints."""
+
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+
+
+def create_api_app() -> FastAPI:
+    """Create and configure FastAPI application."""
+
+    app = FastAPI(
+        title="Tetra API Service",
+        description="Example web API deployed with Tetra",
+        version="1.0.0",
+    )
+
+    # Example models
+    class ComputeRequest(BaseModel):
+        operation: str
+        values: list[float]
+
+    class ComputeResponse(BaseModel):
+        result: float
+        operation: str
+        input_count: int
+
+    @app.get("/")
+    async def root():
+        """Root endpoint."""
+        return {"message": "Tetra API Service", "status": "running"}
+
+    @app.get("/health")
+    async def health_check():
+        """Health check endpoint."""
+        return {"status": "healthy", "service": "tetra-rp-api"}
+
+    @app.post("/compute", response_model=ComputeResponse)
+    async def compute(request: ComputeRequest):
+        """Perform computation on provided values."""
+
+        if not request.values:
+            raise HTTPException(status_code=400, detail="No values provided")
+
+        try:
+            if request.operation == "sum":
+                result = sum(request.values)
+            elif request.operation == "mean":
+                result = sum(request.values) / len(request.values)
+            elif request.operation == "max":
+                result = max(request.values)
+            elif request.operation == "min":
+                result = min(request.values)
+            else:
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"Unsupported operation: {request.operation}",
+                )
+
+            return ComputeResponse(
+                result=result,
+                operation=request.operation,
+                input_count=len(request.values),
+            )
+
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+
+    return app

tetra_rp/cli/templates/web-api/main.py

@@ -0,0 +1,42 @@
+import asyncio
+from dotenv import load_dotenv
+from tetra_rp import remote, LiveServerless
+from api import create_api_app
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Configuration for web API
+api_config = LiveServerless(
+    name="web_api_service",
+    workersMax=3,
+    cpu=2,
+    memory=2048,
+    ports=[8000],
+)
+
+
+@remote(api_config)
+def run_api_server():
+    """Run FastAPI web service."""
+    import uvicorn
+
+    app = create_api_app()
+
+    # Run the server
+    uvicorn.run(app, host="0.0.0.0", port=8000, log_level="info")
+
+    return "API server started"
+
+
+async def main():
+    print("🚀 Starting web API service...")
+    result = await run_api_server()
+    print(f"Result: {result}")
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except Exception as e:
+        print(f"An error occurred: {e}")

tetra_rp/cli/utils/__init__.py

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

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