tetra-rp 0.20.1__tar.gz → 0.23.0__tar.gz

{tetra_rp-0.20.1 → tetra_rp-0.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tetra_rp
-Version: 0.20.1
+Version: 0.23.0
 Summary: A Python library for distributed inference and serving of machine learning models
 Author-email: Marut Pandya <pandyamarut@gmail.com>, Patrick Rachford <prachford@icloud.com>, Dean Quinanola <dean.quinanola@runpod.io>
 License: MIT

{tetra_rp-0.20.1 → tetra_rp-0.23.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tetra_rp"
-version = "0.20.1"
+version = "0.23.0"
 description = "A Python library for distributed inference and serving of machine learning models"
 authors = [
     { name = "Marut Pandya", email = "pandyamarut@gmail.com" },
@@ -87,10 +87,6 @@ filterwarnings = [
 ]
 
 [tool.ruff]
-# Exclude tetra-examples directory since it's a separate repository
-exclude = [
-    "tetra-examples/",
-]
 
 [tool.mypy]
 # Basic configuration
@@ -112,7 +108,6 @@ pretty = true
 
 # Exclude directories
 exclude = [
-    "tetra-examples/",
     "tests/",  # Start by excluding tests, can add later
 ]
 

{tetra_rp-0.20.1 → tetra_rp-0.23.0}/src/tetra_rp/__init__.py

@@ -22,6 +22,7 @@ if TYPE_CHECKING:
         CudaVersion,
         DataCenter,
         GpuGroup,
+        GpuType,
         LiveLoadBalancer,
         LiveServerless,
         LoadBalancerSlsResource,
@@ -49,6 +50,7 @@ def __getattr__(name):
         "CudaVersion",
         "DataCenter",
         "GpuGroup",
+        "GpuType",
         "LiveLoadBalancer",
         "LiveServerless",
         "LoadBalancerSlsResource",
@@ -68,6 +70,7 @@ def __getattr__(name):
             CudaVersion,
             DataCenter,
             GpuGroup,
+            GpuType,
             LiveLoadBalancer,
             LiveServerless,
             LoadBalancerSlsResource,
@@ -88,6 +91,7 @@ def __getattr__(name):
             "CudaVersion": CudaVersion,
             "DataCenter": DataCenter,
             "GpuGroup": GpuGroup,
+            "GpuType": GpuType,
             "LiveLoadBalancer": LiveLoadBalancer,
             "LiveServerless": LiveServerless,
             "LoadBalancerSlsResource": LoadBalancerSlsResource,
@@ -112,6 +116,7 @@ __all__ = [
     "CudaVersion",
     "DataCenter",
     "GpuGroup",
+    "GpuType",
     "LiveLoadBalancer",
     "LiveServerless",
     "LoadBalancerSlsResource",

{tetra_rp-0.20.1 → tetra_rp-0.23.0}/src/tetra_rp/cli/commands/build.py

@@ -27,6 +27,7 @@ from ..utils.ignore import get_file_tree, load_ignore_patterns
 from .build_utils.handler_generator import HandlerGenerator
 from .build_utils.lb_handler_generator import LBHandlerGenerator
 from .build_utils.manifest import ManifestBuilder
+from .build_utils.mothership_handler_generator import generate_mothership_handler
 from .build_utils.scanner import RemoteDecoratorScanner
 
 logger = logging.getLogger(__name__)
@@ -285,26 +286,35 @@ def build_command(
                     scanner = RemoteDecoratorScanner(build_dir)
                     remote_functions = scanner.discover_remote_functions()
 
-                    if remote_functions:
-                        # Build and write manifest
-                        manifest_builder = ManifestBuilder(app_name, remote_functions)
-                        manifest = manifest_builder.build()
-                        manifest_path = build_dir / "flash_manifest.json"
-                        manifest_path.write_text(json.dumps(manifest, indent=2))
+                    # Always build manifest (includes mothership even without @remote functions)
+                    manifest_builder = ManifestBuilder(
+                        app_name, remote_functions, scanner, build_dir=build_dir
+                    )
+                    manifest = manifest_builder.build()
+                    manifest_path = build_dir / "flash_manifest.json"
+                    manifest_path.write_text(json.dumps(manifest, indent=2))
+
+                    # Copy manifest to .flash/ directory for deployment reference
+                    # This avoids needing to extract from tarball during deploy
+                    flash_dir = project_dir / ".flash"
+                    deployment_manifest_path = flash_dir / "flash_manifest.json"
+                    shutil.copy2(manifest_path, deployment_manifest_path)
 
-                        # Generate handler files based on resource type
-                        handler_paths = []
+                    # Generate handler files if there are resources
+                    handler_paths = []
+                    manifest_resources = manifest.get("resources", {})
 
+                    if manifest_resources:
                         # Separate resources by type
                         # Use flag determined by isinstance() at scan time
                         lb_resources = {
                             name: data
-                            for name, data in manifest.get("resources", {}).items()
+                            for name, data in manifest_resources.items()
                             if data.get("is_load_balanced", False)
                         }
                         qb_resources = {
                             name: data
-                            for name, data in manifest.get("resources", {}).items()
+                            for name, data in manifest_resources.items()
                             if not data.get("is_load_balanced", False)
                         }
 
@@ -318,14 +328,43 @@ def build_command(
                             qb_gen = HandlerGenerator(manifest, build_dir)
                             handler_paths.extend(qb_gen.generate_handlers())
 
+                        # Generate mothership handler if present in manifest
+                        mothership_resources = {
+                            name: data
+                            for name, data in manifest_resources.items()
+                            if data.get("is_mothership", False)
+                        }
+                        if mothership_resources:
+                            for (
+                                resource_name,
+                                resource_data,
+                            ) in mothership_resources.items():
+                                mothership_handler_path = (
+                                    build_dir / "handlers" / "handler_mothership.py"
+                                )
+                                generate_mothership_handler(
+                                    main_file=resource_data.get("main_file", "main.py"),
+                                    app_variable=resource_data.get(
+                                        "app_variable", "app"
+                                    ),
+                                    output_path=mothership_handler_path,
+                                )
+                                handler_paths.append(str(mothership_handler_path))
+
+                    if handler_paths:
                         progress.update(
                             manifest_task,
                             description=f"[green]✓ Generated {len(handler_paths)} handlers and manifest",
                         )
+                    elif manifest_resources:
+                        progress.update(
+                            manifest_task,
+                            description=f"[green]✓ Generated manifest with {len(manifest_resources)} resources",
+                        )
                     else:
                         progress.update(
                             manifest_task,
-                            description="[yellow]⚠ No @remote functions found",
+                            description="[yellow]⚠ No resources detected",
                         )
 
                 except (ImportError, SyntaxError) as e:

{tetra_rp-0.20.1 → tetra_rp-0.23.0}/src/tetra_rp/cli/commands/build_utils/lb_handler_generator.py

@@ -40,9 +40,6 @@ ROUTE_REGISTRY = {{
 {registry}
 }}
 
-# Module-level state for /manifest endpoint
-_state_client: Optional[StateManagerClient] = None
-
 
 # Lifespan context manager for startup/shutdown
 @asynccontextmanager
@@ -51,43 +48,46 @@ async def lifespan(app: FastAPI):
     # Startup
     logger.info("Starting {resource_name} endpoint")
 
-    # Check if this is the mothership and initiate provisioning
+    # Check if this is the mothership and run reconciliation
+    # Note: Resources are now provisioned upfront by the CLI during deployment.
+    # This background task runs reconciliation on mothership startup to ensure
+    # all resources are still deployed and in sync with the manifest.
     try:
         from tetra_rp.runtime.mothership_provisioner import (
             is_mothership,
-            provision_children,
+            reconcile_children,
             get_mothership_url,
         )
         from tetra_rp.runtime.state_manager_client import StateManagerClient
 
         if is_mothership():
             logger.info("=" * 60)
-            logger.info("Mothership detected - Starting auto-provisioning")
-            logger.info("Test phase: Deploying child endpoints with 'tmp-' prefix")
+            logger.info("Mothership detected - Starting reconciliation task")
+            logger.info("Resources are provisioned upfront by the CLI")
+            logger.info("This task ensures all resources remain in sync")
             logger.info("=" * 60)
             try:
                 mothership_url = get_mothership_url()
                 logger.info(f"Mothership URL: {{mothership_url}}")
 
-                # Initialize State Manager client and store in module-level state
+                # Initialize State Manager client for reconciliation
                 state_client = StateManagerClient()
-                global _state_client
-                _state_client = state_client
 
-                # Spawn background provisioning task (non-blocking)
+                # Spawn background reconciliation task (non-blocking)
+                # This will verify all resources from manifest are deployed
                 manifest_path = Path(__file__).parent / "flash_manifest.json"
                 task = asyncio.create_task(
-                    provision_children(manifest_path, mothership_url, state_client)
+                    reconcile_children(manifest_path, mothership_url, state_client)
                 )
                 # Add error callback to catch and log background task exceptions
                 task.add_done_callback(
-                    lambda t: logger.error(f"Background provisioning failed: {{t.exception()}}")
+                    lambda t: logger.error(f"Reconciliation task failed: {{t.exception()}}")
                     if t.exception()
                     else None
                 )
 
             except Exception as e:
-                logger.error(f"Failed to start mothership provisioning: {{e}}")
+                logger.error(f"Failed to start reconciliation task: {{e}}")
                 # Don't fail startup - continue serving traffic
 
     except ImportError:
@@ -117,58 +117,6 @@ def ping():
     return {{"status": "healthy"}}
 
 
-# Manifest endpoint for service discovery
-@app.get("/manifest")
-async def manifest():
-    """Return complete authoritative manifest for service discovery.
-
-    Fetches the full manifest from State Manager, allowing child endpoints
-    to synchronize their configuration.
-
-    Returns:
-        dict: Complete manifest with version, generated_at, project_name,
-              function_registry, resources, and routes
-    """
-    try:
-        import os
-        from tetra_rp.runtime.mothership_provisioner import is_mothership
-
-        # Only mothership serves manifest
-        if not is_mothership():
-            return {{"error": "Only mothership serves manifest"}}, 403
-
-        # Check state client initialized
-        global _state_client
-        if _state_client is None:
-            return {{"error": "State Manager not initialized"}}, 500
-
-        # Get mothership ID
-        mothership_id = os.getenv("RUNPOD_ENDPOINT_ID")
-        if not mothership_id:
-            return {{"error": "RUNPOD_ENDPOINT_ID not set"}}, 500
-
-        # Fetch persisted manifest from State Manager (single source of truth)
-        persisted_manifest = await _state_client.get_persisted_manifest(mothership_id)
-
-        # First boot: no manifest yet, return minimal structure
-        if persisted_manifest is None:
-            return {{
-                "version": "1.0",
-                "generated_at": "",
-                "project_name": "",
-                "function_registry": {{}},
-                "resources": {{}},
-                "routes": {{}}
-            }}
-
-        # Return complete manifest
-        return persisted_manifest
-
-    except Exception as e:
-        logger.error(f"Failed to get manifest: {{e}}")
-        return {{"error": str(e)}}, 500
-
-
 if __name__ == "__main__":
     import uvicorn
     # Local development server for testing