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

tetra_rp/cli/utils/skeleton.py

@@ -0,0 +1,101 @@
+"""Project skeleton creation utilities."""
+
+from pathlib import Path
+from typing import Dict, List, Any
+
+from tetra_rp.config import get_paths
+
+
+def get_template_directory() -> Path:
+    """Get the path to the templates directory."""
+    return Path(__file__).parent.parent / "templates"
+
+
+def load_template_files(template_name: str) -> Dict[str, Any]:
+    """Load template files from filesystem."""
+    template_dir = get_template_directory() / template_name
+
+    if not template_dir.exists():
+        raise ValueError(f"Template '{template_name}' not found in {template_dir}")
+
+    files = {}
+
+    # Load all files from the template directory
+    for file_path in template_dir.iterdir():
+        if file_path.is_file():
+            relative_path = file_path.name
+
+            # Special handling for config.json - return as callable that generates tetra config
+            if file_path.name == "config.json":
+                config_content = file_path.read_text()
+                files[".tetra/config.json"] = lambda content=config_content: content
+            else:
+                files[relative_path] = file_path.read_text()
+
+    return files
+
+
+def get_available_templates() -> Dict[str, Dict[str, Any]]:
+    """Get available project templates from filesystem."""
+    template_dir = get_template_directory()
+    templates = {}
+
+    # Template descriptions
+    descriptions = {
+        "basic": "Simple remote function example",
+        "advanced": "Multi-function project with dependencies",
+        "gpu-compute": "GPU-optimized compute workload",
+        "web-api": "FastAPI web service deployment",
+    }
+
+    # Discover templates from filesystem
+    for template_path in template_dir.iterdir():
+        if template_path.is_dir():
+            template_name = template_path.name
+            try:
+                templates[template_name] = {
+                    "description": descriptions.get(
+                        template_name, f"{template_name} template"
+                    ),
+                    "files": load_template_files(template_name),
+                }
+            except Exception as e:
+                print(f"Warning: Failed to load template '{template_name}': {e}")
+
+    return templates
+
+
+def create_project_skeleton(
+    template_name: str, template_info: Dict[str, Any], force: bool = False
+) -> List[str]:
+    """Create project skeleton from template."""
+    created_files = []
+
+    # Create .tetra directory using centralized config
+    paths = get_paths()
+    paths.ensure_tetra_dir()
+
+    # Create files from template
+    for file_path, content in template_info["files"].items():
+        path = Path(file_path)
+
+        # Create parent directories if needed
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Skip existing files unless force is True
+        if path.exists() and not force:
+            continue
+
+        # Get content (could be string or callable)
+        if callable(content):
+            file_content = content()
+        else:
+            file_content = content
+
+        # Write file
+        with open(path, "w") as f:
+            f.write(file_content)
+
+        created_files.append(str(path))
+
+    return created_files

tetra_rp/client.py

@@ -15,7 +15,6 @@ def remote(
     dependencies: Optional[List[str]] = None,
     system_dependencies: Optional[List[str]] = None,
     accelerate_downloads: bool = True,
-    hf_models_to_cache: Optional[List[str]] = None,
     **extra,
 ):
     """
@@ -33,8 +32,6 @@ def remote(
             environment before executing the function. Defaults to None.
         accelerate_downloads (bool, optional): Enable download acceleration for dependencies and models.
             Defaults to True.
-        hf_models_to_cache (List[str], optional): List of HuggingFace model IDs to pre-cache using
-            download acceleration. Defaults to None.
         extra (dict, optional): Additional parameters for the execution of the resource. Defaults to an empty dict.
 
     Returns:
@@ -47,7 +44,6 @@ def remote(
             resource_config=my_resource_config,
             dependencies=["numpy", "pandas"],
             accelerate_downloads=True,
-            hf_models_to_cache=["gpt2", "bert-base-uncased"]
         )
         async def my_function(data):
             # Function logic here
@@ -64,7 +60,6 @@ def remote(
                 dependencies,
                 system_dependencies,
                 accelerate_downloads,
-                hf_models_to_cache,
                 extra,
             )
         else:
@@ -82,7 +77,6 @@ def remote(
                     dependencies,
                     system_dependencies,
                     accelerate_downloads,
-                    hf_models_to_cache,
                     *args,
                     **kwargs,
                 )

tetra_rp/config.py

@@ -0,0 +1,29 @@
+"""Configuration management for tetra-rp CLI."""
+
+from pathlib import Path
+from typing import NamedTuple
+
+
+class TetraPaths(NamedTuple):
+    """Paths for tetra-rp configuration and data."""
+
+    tetra_dir: Path
+    config_file: Path
+    deployments_file: Path
+
+    def ensure_tetra_dir(self) -> None:
+        """Ensure the .tetra directory exists."""
+        self.tetra_dir.mkdir(exist_ok=True)
+
+
+def get_paths() -> TetraPaths:
+    """Get standardized paths for tetra-rp configuration."""
+    tetra_dir = Path.cwd() / ".tetra"
+    config_file = tetra_dir / "config.json"
+    deployments_file = tetra_dir / "deployments.json"
+
+    return TetraPaths(
+        tetra_dir=tetra_dir,
+        config_file=config_file,
+        deployments_file=deployments_file,
+    )

tetra_rp/core/resources/__init__.py

@@ -3,14 +3,14 @@ from .cloud import runpod
 from .cpu import CpuInstanceType
 from .gpu import GpuGroup, GpuType, GpuTypeDetail
 from .resource_manager import ResourceManager
-from .live_serverless import LiveServerless
+from .live_serverless import LiveServerless, CpuLiveServerless
 from .serverless import (
-    CpuServerlessEndpoint,
     ServerlessResource,
     ServerlessEndpoint,
     JobOutput,
     CudaVersion,
 )
+from .serverless_cpu import CpuServerlessEndpoint
 from .template import PodTemplate
 from .network_volume import NetworkVolume, DataCenter
 
@@ -19,6 +19,7 @@ __all__ = [
     "runpod",
     "BaseResource",
     "CpuInstanceType",
+    "CpuLiveServerless",
     "CpuServerlessEndpoint",
     "CudaVersion",
     "DataCenter",

tetra_rp/core/resources/cpu.py

@@ -1,4 +1,5 @@
 from enum import Enum
+from typing import List, Optional
 
 
 class CpuInstanceType(str, Enum):
@@ -16,19 +17,121 @@ class CpuInstanceType(str, Enum):
     """
 
     # 3rd Generation General Purpose (RAM multiplier: 4.0)
-    CPU3G_1_4 = "cpu3g-1-4"  # 1 vCPU, 4GB RAM
-    CPU3G_2_8 = "cpu3g-2-8"  # 2 vCPU, 8GB RAM
-    CPU3G_4_16 = "cpu3g-4-16"  # 4 vCPU, 16GB RAM
-    CPU3G_8_32 = "cpu3g-8-32"  # 8 vCPU, 32GB RAM
+
+    CPU3G_1_4 = "cpu3g-1-4"
+    """1 vCPU, 4GB RAM, max 10GB container disk"""
+
+    CPU3G_2_8 = "cpu3g-2-8"
+    """2 vCPU, 8GB RAM, max 20GB container disk"""
+
+    CPU3G_4_16 = "cpu3g-4-16"
+    """4 vCPU, 16GB RAM, max 40GB container disk"""
+
+    CPU3G_8_32 = "cpu3g-8-32"
+    """8 vCPU, 32GB RAM, max 80GB container disk"""
 
     # 3rd Generation Compute-Optimized (RAM multiplier: 2.0)
-    CPU3C_1_2 = "cpu3c-1-2"  # 1 vCPU, 2GB RAM
-    CPU3C_2_4 = "cpu3c-2-4"  # 2 vCPU, 4GB RAM
-    CPU3C_4_8 = "cpu3c-4-8"  # 4 vCPU, 8GB RAM
-    CPU3C_8_16 = "cpu3c-8-16"  # 8 vCPU, 16GB RAM
+
+    CPU3C_1_2 = "cpu3c-1-2"
+    """1 vCPU, 2GB RAM, max 10GB container disk"""
+
+    CPU3C_2_4 = "cpu3c-2-4"
+    """2 vCPU, 4GB RAM, max 20GB container disk"""
+
+    CPU3C_4_8 = "cpu3c-4-8"
+    """4 vCPU, 8GB RAM, max 40GB container disk"""
+
+    CPU3C_8_16 = "cpu3c-8-16"
+    """8 vCPU, 16GB RAM, max 80GB container disk"""
 
     # 5th Generation Compute-Optimized (RAM multiplier: 2.0)
-    CPU5C_1_2 = "cpu5c-1-2"  # 1 vCPU, 2GB RAM
-    CPU5C_2_4 = "cpu5c-2-4"  # 2 vCPU, 4GB RAM
-    CPU5C_4_8 = "cpu5c-4-8"  # 4 vCPU, 8GB RAM
-    CPU5C_8_16 = "cpu5c-8-16"  # 8 vCPU, 16GB RAM
+
+    CPU5C_1_2 = "cpu5c-1-2"
+    """1 vCPU, 2GB RAM, max 15GB container disk"""
+
+    CPU5C_2_4 = "cpu5c-2-4"
+    """2 vCPU, 4GB RAM, max 30GB container disk"""
+
+    CPU5C_4_8 = "cpu5c-4-8"
+    """4 vCPU, 8GB RAM, max 60GB container disk"""
+
+    CPU5C_8_16 = "cpu5c-8-16"
+    """8 vCPU, 16GB RAM, max 120GB container disk"""
+
+
+def calculate_max_disk_size(instance_type: CpuInstanceType) -> int:
+    """
+    Calculate the maximum container disk size for a CPU instance type.
+
+    Formula:
+    - CPU3G/CPU3C: vCPU count × 10GB
+    - CPU5C: vCPU count × 15GB
+
+    Args:
+        instance_type: CPU instance type enum
+
+    Returns:
+        Maximum container disk size in GB
+
+    Example:
+        >>> calculate_max_disk_size(CpuInstanceType.CPU3G_1_4)
+        10
+        >>> calculate_max_disk_size(CpuInstanceType.CPU5C_2_4)
+        30
+    """
+    # Parse the instance type string to extract vCPU count
+    # Format: "cpu{generation}{type}-{vcpu}-{memory}"
+    instance_str = instance_type.value
+    parts = instance_str.split("-")
+
+    if len(parts) != 3:
+        raise ValueError(f"Invalid instance type format: {instance_str}")
+
+    vcpu_count = int(parts[1])
+
+    # Determine disk multiplier based on generation
+    if instance_str.startswith("cpu5c"):
+        disk_multiplier = 15  # CPU5C: 15GB per vCPU
+    elif instance_str.startswith(("cpu3g", "cpu3c")):
+        disk_multiplier = 10  # CPU3G/CPU3C: 10GB per vCPU
+    else:
+        raise ValueError(f"Unknown CPU generation/type: {instance_str}")
+
+    return vcpu_count * disk_multiplier
+
+
+# CPU Instance Type Disk Limits (calculated programmatically)
+CPU_INSTANCE_DISK_LIMITS = {
+    instance_type: calculate_max_disk_size(instance_type)
+    for instance_type in CpuInstanceType
+}
+
+
+def get_max_disk_size_for_instances(
+    instance_types: Optional[List[CpuInstanceType]],
+) -> Optional[int]:
+    """
+    Calculate the maximum container disk size for a list of CPU instance types.
+
+    Returns the minimum disk limit across all instance types to ensure compatibility
+    with all specified instances.
+
+    Args:
+        instance_types: List of CPU instance types, or None
+
+    Returns:
+        Maximum allowed disk size in GB, or None if no CPU instances specified
+
+    Example:
+        >>> get_max_disk_size_for_instances([CpuInstanceType.CPU3G_1_4])
+        10
+        >>> get_max_disk_size_for_instances([CpuInstanceType.CPU3G_1_4, CpuInstanceType.CPU3G_2_8])
+        10
+    """
+    if not instance_types:
+        return None
+
+    disk_limits = [
+        CPU_INSTANCE_DISK_LIMITS[instance_type] for instance_type in instance_types
+    ]
+    return min(disk_limits)

tetra_rp/core/resources/gpu.py

@@ -32,20 +32,35 @@ class GpuTypeDetail(GpuType):
 
 # TODO: this should be fetched from an API
 class GpuGroup(Enum):
-    ANY = "any"  # "Any GPU"
-    ADA_24 = "ADA_24"  # "NVIDIA GeForce RTX 4090"
-    ADA_32_PRO = "ADA_32_PRO"  # "NVIDIA GeForce RTX 5090"
-    ADA_48_PRO = (
-        "ADA_48_PRO"  # "NVIDIA RTX 6000 Ada Generation, NVIDIA L40, NVIDIA L40S"
-    )
-    ADA_80_PRO = (
-        "ADA_80_PRO"  # "NVIDIA H100 PCIe, NVIDIA H100 80GB HBM3, NVIDIA H100 NVL"
-    )
-    AMPERE_16 = "AMPERE_16"  # "NVIDIA RTX A4000, NVIDIA RTX A4500, NVIDIA RTX 4000 Ada Generation, NVIDIA RTX 2000 Ada Generation"
-    AMPERE_24 = "AMPERE_24"  # "NVIDIA RTX A5000, NVIDIA L4, NVIDIA GeForce RTX 3090"
-    AMPERE_48 = "AMPERE_48"  # "NVIDIA A40, NVIDIA RTX A6000"
-    AMPERE_80 = "AMPERE_80"  # "NVIDIA A100 80GB PCIe, NVIDIA A100-SXM4-80GB"
-    HOPPER_141 = "HOPPER_141"  # "NVIDIA H200"
+    ANY = "any"
+    """Any GPU"""
+
+    ADA_24 = "ADA_24"
+    """NVIDIA GeForce RTX 4090"""
+
+    ADA_32_PRO = "ADA_32_PRO"
+    """NVIDIA GeForce RTX 5090"""
+
+    ADA_48_PRO = "ADA_48_PRO"
+    """NVIDIA RTX 6000 Ada Generation, NVIDIA L40, NVIDIA L40S"""
+
+    ADA_80_PRO = "ADA_80_PRO"
+    """NVIDIA H100 PCIe, NVIDIA H100 80GB HBM3, NVIDIA H100 NVL"""
+
+    AMPERE_16 = "AMPERE_16"
+    """NVIDIA RTX A4000, NVIDIA RTX A4500, NVIDIA RTX 4000 Ada Generation, NVIDIA RTX 2000 Ada Generation"""
+
+    AMPERE_24 = "AMPERE_24"
+    """NVIDIA RTX A5000, NVIDIA L4, NVIDIA GeForce RTX 3090"""
+
+    AMPERE_48 = "AMPERE_48"
+    """NVIDIA A40, NVIDIA RTX A6000"""
+
+    AMPERE_80 = "AMPERE_80"
+    """NVIDIA A100 80GB PCIe, NVIDIA A100-SXM4-80GB"""
+
+    HOPPER_141 = "HOPPER_141"
+    """NVIDIA H200"""
 
     @classmethod
     def all(cls) -> List["GpuGroup"]:

tetra_rp/core/resources/live_serverless.py

@@ -2,6 +2,7 @@
 import os
 from pydantic import model_validator
 from .serverless import ServerlessEndpoint
+from .serverless_cpu import CpuServerlessEndpoint
 
 TETRA_IMAGE_TAG = os.environ.get("TETRA_IMAGE_TAG", "latest")
 TETRA_GPU_IMAGE = os.environ.get(
@@ -12,25 +13,50 @@ TETRA_CPU_IMAGE = os.environ.get(
 )
 
 
-class LiveServerless(ServerlessEndpoint):
-    @model_validator(mode="before")
-    @classmethod
-    def set_live_serverless_template(cls, data: dict):
-        """Set default templates for Live Serverless. This can't be changed."""
-        # Always set imageName based on instanceIds presence
-        data["imageName"] = (
-            TETRA_CPU_IMAGE if data.get("instanceIds") else TETRA_GPU_IMAGE
-        )
-        return data
+class LiveServerlessMixin:
+    """Common mixin for live serverless endpoints that locks the image."""
+
+    @property
+    def _live_image(self) -> str:
+        """Override in subclasses to specify the locked image."""
+        raise NotImplementedError("Subclasses must define _live_image")
 
     @property
     def imageName(self):
-        # Lock imageName to always reflect instanceIds
-        return (
-            TETRA_CPU_IMAGE if getattr(self, "instanceIds", None) else TETRA_GPU_IMAGE
-        )
+        # Lock imageName to specific image
+        return self._live_image
 
     @imageName.setter
     def imageName(self, value):
         # Prevent manual setting of imageName
         pass
+
+
+class LiveServerless(LiveServerlessMixin, ServerlessEndpoint):
+    """GPU-only live serverless endpoint."""
+
+    @property
+    def _live_image(self) -> str:
+        return TETRA_GPU_IMAGE
+
+    @model_validator(mode="before")
+    @classmethod
+    def set_live_serverless_template(cls, data: dict):
+        """Set default GPU image for Live Serverless."""
+        data["imageName"] = TETRA_GPU_IMAGE
+        return data
+
+
+class CpuLiveServerless(LiveServerlessMixin, CpuServerlessEndpoint):
+    """CPU-only live serverless endpoint with automatic disk sizing."""
+
+    @property
+    def _live_image(self) -> str:
+        return TETRA_CPU_IMAGE
+
+    @model_validator(mode="before")
+    @classmethod
+    def set_live_serverless_template(cls, data: dict):
+        """Set default CPU image for Live Serverless."""
+        data["imageName"] = TETRA_CPU_IMAGE
+        return data

tetra_rp/core/resources/resource_manager.py

@@ -1,9 +1,11 @@
+import asyncio
 import cloudpickle
 import logging
-from typing import Dict
+from typing import Dict, Optional
 from pathlib import Path
 
 from ..utils.singleton import SingletonMixin
+from ..utils.file_lock import file_lock, FileLockError
 
 from .base import DeployableResource
 
@@ -17,28 +19,46 @@ RESOURCE_STATE_FILE = Path(".tetra_resources.pkl")
 class ResourceManager(SingletonMixin):
     """Manages dynamic provisioning and tracking of remote resources."""
 
+    # Class variables shared across all instances (singleton)
     _resources: Dict[str, DeployableResource] = {}
+    _deployment_locks: Dict[str, asyncio.Lock] = {}
+    _global_lock: Optional[asyncio.Lock] = None  # Will be initialized lazily
+    _lock_initialized = False
 
     def __init__(self):
+        # Ensure async locks are initialized properly for the singleton instance
+        if not ResourceManager._lock_initialized:
+            ResourceManager._global_lock = asyncio.Lock()
+            ResourceManager._lock_initialized = True
+
         if not self._resources:
             self._load_resources()
 
     def _load_resources(self) -> Dict[str, DeployableResource]:
-        """Load persisted resource information using cloudpickle."""
+        """Load persisted resource information using cross-platform file locking."""
         if RESOURCE_STATE_FILE.exists():
             try:
                 with open(RESOURCE_STATE_FILE, "rb") as f:
-                    self._resources = cloudpickle.load(f)
-                    log.debug(f"Loaded saved resources from {RESOURCE_STATE_FILE}")
-            except Exception as e:
+                    # Acquire shared lock for reading (cross-platform)
+                    with file_lock(f, exclusive=False):
+                        self._resources = cloudpickle.load(f)
+                        log.debug(f"Loaded saved resources from {RESOURCE_STATE_FILE}")
+            except (FileLockError, Exception) as e:
                 log.error(f"Failed to load resources from {RESOURCE_STATE_FILE}: {e}")
         return self._resources
 
     def _save_resources(self) -> None:
-        """Persist state of resources to disk using cloudpickle."""
-        with open(RESOURCE_STATE_FILE, "wb") as f:
-            cloudpickle.dump(self._resources, f)
-        log.debug(f"Saved resources in {RESOURCE_STATE_FILE}")
+        """Persist state of resources to disk using cross-platform file locking."""
+        try:
+            with open(RESOURCE_STATE_FILE, "wb") as f:
+                # Acquire exclusive lock for writing (cross-platform)
+                with file_lock(f, exclusive=True):
+                    cloudpickle.dump(self._resources, f)
+                    f.flush()  # Ensure data is written to disk
+                    log.debug(f"Saved resources in {RESOURCE_STATE_FILE}")
+        except (FileLockError, Exception) as e:
+            log.error(f"Failed to save resources to {RESOURCE_STATE_FILE}: {e}")
+            raise
 
     def add_resource(self, uid: str, resource: DeployableResource):
         """Add a resource to the manager."""
@@ -60,21 +80,42 @@ class ResourceManager(SingletonMixin):
     async def get_or_deploy_resource(
         self, config: DeployableResource
     ) -> DeployableResource:
-        """Get existing or create new resource based on config."""
-        uid = config.resource_id
-        if existing := self._resources.get(uid):
-            if not existing.is_deployed():
-                log.warning(f"{existing} is no longer valid, redeploying.")
-                self.remove_resource(uid)
-                return await self.get_or_deploy_resource(config)
+        """Get existing or create new resource based on config.
 
-            log.debug(f"{existing} exists, reusing.")
-            log.info(f"URL: {existing.url}")
-            return existing
+        Thread-safe implementation that prevents concurrent deployments
+        of the same resource configuration.
+        """
+        uid = config.resource_id
 
-        if deployed_resource := await config.deploy():
+        # Ensure global lock is initialized (should be done in __init__)
+        assert ResourceManager._global_lock is not None, "Global lock not initialized"
+
+        # Get or create a per-resource lock
+        async with ResourceManager._global_lock:
+            if uid not in ResourceManager._deployment_locks:
+                ResourceManager._deployment_locks[uid] = asyncio.Lock()
+            resource_lock = ResourceManager._deployment_locks[uid]
+
+        # Acquire per-resource lock for this specific configuration
+        async with resource_lock:
+            # Double-check pattern: check again inside the lock
+            if existing := self._resources.get(uid):
+                if not existing.is_deployed():
+                    log.warning(f"{existing} is no longer valid, redeploying.")
+                    self.remove_resource(uid)
+                    # Don't recursive call - deploy directly within the lock
+                    deployed_resource = await config.deploy()
+                    log.info(f"URL: {deployed_resource.url}")
+                    self.add_resource(uid, deployed_resource)
+                    return deployed_resource
+
+                log.debug(f"{existing} exists, reusing.")
+                log.info(f"URL: {existing.url}")
+                return existing
+
+            # No existing resource, deploy new one
+            log.debug(f"Deploying new resource: {uid}")
+            deployed_resource = await config.deploy()
             log.info(f"URL: {deployed_resource.url}")
             self.add_resource(uid, deployed_resource)
             return deployed_resource
-
-        raise RuntimeError(f"Deployment failed for resource {uid}")