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

tetra_rp/cli/templates/advanced/main.py

@@ -1,58 +0,0 @@
-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

@@ -1,24 +0,0 @@
-"""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

@@ -1,32 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,67 +0,0 @@
-"""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

@@ -1,42 +0,0 @@
-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}")