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

tetra_rp/__init__.py

@@ -13,6 +13,7 @@ from .client import remote  # noqa: E402
 from .core.resources import (  # noqa: E402
     CpuServerlessEndpoint,
     CpuInstanceType,
+    CpuLiveServerless,
     CudaVersion,
     DataCenter,
     GpuGroup,
@@ -29,6 +30,7 @@ __all__ = [
     "remote",
     "CpuServerlessEndpoint",
     "CpuInstanceType",
+    "CpuLiveServerless",
     "CudaVersion",
     "DataCenter",
     "GpuGroup",

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}")

tetra_rp/core/resources/serverless.py

@@ -17,7 +17,6 @@ from ..utils.backoff import get_backoff_delay
 from .base import DeployableResource
 from .cloud import runpod
 from .constants import CONSOLE_URL
-from .cpu import CpuInstanceType
 from .environment import EnvironmentVars
 from .gpu import GpuGroup
 from .network_volume import NetworkVolume, DataCenter
@@ -86,7 +85,6 @@ class ServerlessResource(DeployableResource):
     executionTimeoutMs: Optional[int] = None
     gpuCount: Optional[int] = 1
     idleTimeout: Optional[int] = 5
-    instanceIds: Optional[List[CpuInstanceType]] = None
     locations: Optional[str] = None
     name: str
     networkVolumeId: Optional[str] = None
@@ -134,15 +132,6 @@ class ServerlessResource(DeployableResource):
         """Convert ServerlessScalerType enum to string."""
         return value.value if value is not None else None
 
-    @field_serializer("instanceIds")
-    def serialize_instance_ids(
-        self, value: Optional[List[CpuInstanceType]]
-    ) -> Optional[List[str]]:
-        """Convert CpuInstanceType enums to strings."""
-        if value is None:
-            return None
-        return [item.value if hasattr(item, "value") else str(item) for item in value]
-
     @field_validator("gpus")
     @classmethod
     def validate_gpus(cls, value: List[GpuGroup]) -> List[GpuGroup]:
@@ -172,10 +161,9 @@ class ServerlessResource(DeployableResource):
             # Volume already exists, use its ID
             self.networkVolumeId = self.networkVolume.id
 
-        if self.instanceIds:
-            return self._sync_input_fields_cpu()
-        else:
-            return self._sync_input_fields_gpu()
+        self._sync_input_fields_gpu()
+
+        return self
 
     def _sync_input_fields_gpu(self):
         # GPU-specific fields
@@ -199,14 +187,6 @@ class ServerlessResource(DeployableResource):
 
         return self
 
-    def _sync_input_fields_cpu(self):
-        # Override GPU-specific fields for CPU
-        self.gpuCount = 0
-        self.allowedCudaVersions = ""
-        self.gpuIds = ""
-
-        return self
-
     async def _ensure_network_volume_deployed(self) -> None:
         """
         Ensures network volume is deployed and ready if one is specified.
@@ -274,7 +254,7 @@ class ServerlessResource(DeployableResource):
             )
 
         try:
-            # log.debug(f"[{log_group}] Payload: {payload}")
+            # log.debug(f"[{self}] Payload: {payload}")
 
             log.info(f"{self} | API /run_sync")
             response = await asyncio.to_thread(_fetch_job)
@@ -355,6 +335,26 @@ class ServerlessEndpoint(ServerlessResource):
     Inherits from ServerlessResource.
     """
 
+    def _create_new_template(self) -> PodTemplate:
+        """Create a new PodTemplate with standard configuration."""
+        return PodTemplate(
+            name=self.resource_id,
+            imageName=self.imageName,
+            env=KeyValuePair.from_dict(self.env or get_env_vars()),
+        )
+
+    def _configure_existing_template(self) -> None:
+        """Configure an existing template with necessary overrides."""
+        if self.template is None:
+            return
+
+        self.template.name = f"{self.resource_id}__{self.template.resource_id}"
+
+        if self.imageName:
+            self.template.imageName = self.imageName
+        if self.env:
+            self.template.env = KeyValuePair.from_dict(self.env)
+
     @model_validator(mode="after")
     def set_serverless_template(self):
         if not any([self.imageName, self.template, self.templateId]):
@@ -363,32 +363,13 @@ class ServerlessEndpoint(ServerlessResource):
             )
 
         if not self.templateId and not self.template:
-            self.template = PodTemplate(
-                name=self.resource_id,
-                imageName=self.imageName,
-                env=KeyValuePair.from_dict(self.env or get_env_vars()),
-            )
-
+            self.template = self._create_new_template()
         elif self.template:
-            self.template.name = f"{self.resource_id}__{self.template.resource_id}"
-            if self.imageName:
-                self.template.imageName = self.imageName
-            if self.env:
-                self.template.env = KeyValuePair.from_dict(self.env)
+            self._configure_existing_template()
 
         return self
 
 
-class CpuServerlessEndpoint(ServerlessEndpoint):
-    """
-    Convenience class for CPU serverless endpoint.
-    Represents a CPU-only serverless endpoint distinct from a live serverless.
-    Inherits from ServerlessEndpoint.
-    """
-
-    instanceIds: Optional[List[CpuInstanceType]] = [CpuInstanceType.CPU3G_2_8]
-
-
 class JobOutput(BaseModel):
     id: str
     workerId: str
@@ -398,7 +379,7 @@ class JobOutput(BaseModel):
     output: Optional[Any] = None
     error: Optional[str] = ""
 
-    def model_post_init(self, __context):
+    def model_post_init(self, _: Any) -> None:
         log_group = f"Worker:{self.workerId}"
         log.info(f"{log_group} | Delay Time: {self.delayTime} ms")
         log.info(f"{log_group} | Execution Time: {self.executionTime} ms")

tetra_rp/core/resources/serverless_cpu.py

@@ -0,0 +1,154 @@
+"""
+CPU-specific serverless endpoint classes.
+
+This module contains all CPU-related serverless functionality, separate from GPU serverless.
+"""
+
+from typing import List, Optional
+
+from pydantic import field_serializer, model_validator
+
+from .cpu import (
+    CpuInstanceType,
+    CPU_INSTANCE_DISK_LIMITS,
+    get_max_disk_size_for_instances,
+)
+from .serverless import ServerlessEndpoint, get_env_vars
+from .template import KeyValuePair, PodTemplate
+
+
+class CpuEndpointMixin:
+    """Mixin class that provides CPU-specific functionality for serverless endpoints."""
+
+    instanceIds: Optional[List[CpuInstanceType]]
+
+    def _is_cpu_endpoint(self) -> bool:
+        """Check if this is a CPU endpoint (has instanceIds)."""
+        return (
+            hasattr(self, "instanceIds")
+            and self.instanceIds is not None
+            and len(self.instanceIds) > 0
+        )
+
+    def _get_cpu_container_disk_size(self) -> Optional[int]:
+        """Get the appropriate container disk size for CPU instances."""
+        if not self._is_cpu_endpoint():
+            return None
+        return get_max_disk_size_for_instances(self.instanceIds)
+
+    def _apply_cpu_disk_sizing(self, template: PodTemplate) -> None:
+        """Apply CPU disk sizing to a template if it's using the default size."""
+        if not self._is_cpu_endpoint():
+            return
+
+        # Only auto-size if template is using the default value
+        default_disk_size = PodTemplate.model_fields["containerDiskInGb"].default
+        if template.containerDiskInGb == default_disk_size:
+            cpu_disk_size = self._get_cpu_container_disk_size()
+            if cpu_disk_size is not None:
+                template.containerDiskInGb = cpu_disk_size
+
+    def validate_cpu_container_disk_size(self) -> None:
+        """
+        Validate that container disk size doesn't exceed limits for CPU instances.
+
+        Raises:
+            ValueError: If container disk size exceeds the limit for any CPU instance
+        """
+        if (
+            not self._is_cpu_endpoint()
+            or not hasattr(self, "template")
+            or not self.template
+            or not self.template.containerDiskInGb
+        ):
+            return
+
+        max_allowed_disk_size = self._get_cpu_container_disk_size()
+        if max_allowed_disk_size is None:
+            return
+
+        if self.template.containerDiskInGb > max_allowed_disk_size:
+            instance_limits = []
+            for instance_type in self.instanceIds:
+                limit = CPU_INSTANCE_DISK_LIMITS[instance_type]
+                instance_limits.append(f"{instance_type.value}: max {limit}GB")
+
+            raise ValueError(
+                f"Container disk size {self.template.containerDiskInGb}GB exceeds the maximum "
+                f"allowed for CPU instances. Instance limits: {', '.join(instance_limits)}. "
+                f"Maximum allowed: {max_allowed_disk_size}GB"
+            )
+
+    def _sync_cpu_fields(self):
+        """Sync CPU-specific fields, overriding GPU defaults."""
+        # Override GPU-specific fields for CPU
+        if hasattr(self, "gpuCount"):
+            self.gpuCount = 0
+        if hasattr(self, "allowedCudaVersions"):
+            self.allowedCudaVersions = ""
+        if hasattr(self, "gpuIds"):
+            self.gpuIds = ""
+
+    @field_serializer("instanceIds")
+    def serialize_instance_ids(
+        self, value: Optional[List[CpuInstanceType]]
+    ) -> Optional[List[str]]:
+        """Convert CpuInstanceType enums to strings."""
+        if value is None:
+            return None
+        return [item.value if hasattr(item, "value") else str(item) for item in value]
+
+
+class CpuServerlessEndpoint(CpuEndpointMixin, ServerlessEndpoint):
+    """
+    CPU-only serverless endpoint with automatic disk sizing and validation.
+    Represents a CPU-only serverless endpoint distinct from a live serverless.
+    """
+
+    instanceIds: Optional[List[CpuInstanceType]] = [CpuInstanceType.CPU3G_2_8]
+
+    def _create_new_template(self) -> PodTemplate:
+        """Create a new PodTemplate with CPU-appropriate disk sizing."""
+        template = PodTemplate(
+            name=self.resource_id,
+            imageName=self.imageName,
+            env=KeyValuePair.from_dict(self.env or get_env_vars()),
+        )
+        # Apply CPU-specific disk sizing
+        self._apply_cpu_disk_sizing(template)
+        return template
+
+    def _configure_existing_template(self) -> None:
+        """Configure an existing template with necessary overrides and CPU sizing."""
+        if self.template is None:
+            return
+
+        self.template.name = f"{self.resource_id}__{self.template.resource_id}"
+
+        if self.imageName:
+            self.template.imageName = self.imageName
+        if self.env:
+            self.template.env = KeyValuePair.from_dict(self.env)
+
+        # Apply CPU-specific disk sizing
+        self._apply_cpu_disk_sizing(self.template)
+
+    @model_validator(mode="after")
+    def set_serverless_template(self):
+        # Sync CPU-specific fields first
+        self._sync_cpu_fields()
+
+        if not any([self.imageName, self.template, self.templateId]):
+            raise ValueError(
+                "Either imageName, template, or templateId must be provided"
+            )
+
+        if not self.templateId and not self.template:
+            self.template = self._create_new_template()
+        elif self.template:
+            self._configure_existing_template()
+
+        # Validate container disk size for CPU instances
+        self.validate_cpu_container_disk_size()
+
+        return self

tetra_rp/core/utils/file_lock.py

@@ -0,0 +1,260 @@
+"""
+Cross-platform file locking utilities.
+
+Provides unified file locking interface that works across Windows, macOS, and Linux.
+Uses platform-appropriate locking mechanisms:
+- Windows: msvcrt.locking()
+- Unix/Linux/macOS: fcntl.flock()
+- Fallback: Basic file existence checking (limited protection)
+"""
+
+import contextlib
+import logging
+import platform
+import time
+from pathlib import Path
+from typing import BinaryIO, Optional
+
+log = logging.getLogger(__name__)
+
+# Platform detection
+_IS_WINDOWS = platform.system() == "Windows"
+_IS_UNIX = platform.system() in ("Linux", "Darwin")
+
+# Initialize availability flags
+_WINDOWS_LOCKING_AVAILABLE = False
+_UNIX_LOCKING_AVAILABLE = False
+
+# Import platform-specific modules
+if _IS_WINDOWS:
+    try:
+        import msvcrt
+
+        _WINDOWS_LOCKING_AVAILABLE = True
+    except ImportError:
+        msvcrt = None
+        log.warning("msvcrt not available on Windows platform")
+
+if _IS_UNIX:
+    try:
+        import fcntl
+
+        _UNIX_LOCKING_AVAILABLE = True
+    except ImportError:
+        fcntl = None
+        log.warning("fcntl not available on Unix platform")
+
+
+class FileLockError(Exception):
+    """Exception raised when file locking operations fail."""
+
+    pass
+
+
+class FileLockTimeout(FileLockError):
+    """Exception raised when file locking times out."""
+
+    pass
+
+
+@contextlib.contextmanager
+def file_lock(
+    file_handle: BinaryIO,
+    exclusive: bool = True,
+    timeout: Optional[float] = 10.0,
+    retry_interval: float = 0.1,
+):
+    """
+    Cross-platform file locking context manager.
+
+    Args:
+        file_handle: Open file handle to lock
+        exclusive: True for exclusive lock, False for shared lock
+        timeout: Maximum seconds to wait for lock (None = no timeout)
+        retry_interval: Seconds to wait between lock attempts
+
+    Raises:
+        FileLockTimeout: If lock cannot be acquired within timeout
+        FileLockError: If locking operation fails
+
+    Usage:
+        with open("file.dat", "rb") as f:
+            with file_lock(f, exclusive=False):  # Shared read lock
+                data = f.read()
+
+        with open("file.dat", "wb") as f:
+            with file_lock(f, exclusive=True):   # Exclusive write lock
+                f.write(data)
+    """
+    lock_acquired = False
+    start_time = time.time()
+
+    try:
+        # Platform-specific locking
+        while not lock_acquired:
+            try:
+                if _IS_WINDOWS and _WINDOWS_LOCKING_AVAILABLE:
+                    _acquire_windows_lock(file_handle, exclusive)
+                elif _IS_UNIX and _UNIX_LOCKING_AVAILABLE:
+                    _acquire_unix_lock(file_handle, exclusive)
+                else:
+                    # Fallback - limited protection via file existence
+                    _acquire_fallback_lock(file_handle, exclusive, timeout)
+
+                lock_acquired = True
+                log.debug(f"File lock acquired (exclusive={exclusive})")
+
+            except (OSError, IOError, FileLockError) as e:
+                # Check timeout
+                if timeout is not None and (time.time() - start_time) >= timeout:
+                    raise FileLockTimeout(
+                        f"Could not acquire file lock within {timeout} seconds: {e}"
+                    ) from e
+
+                # Retry after interval
+                time.sleep(retry_interval)
+
+        # Lock acquired successfully
+        yield
+
+    finally:
+        # Release lock
+        if lock_acquired:
+            try:
+                if _IS_WINDOWS and _WINDOWS_LOCKING_AVAILABLE:
+                    _release_windows_lock(file_handle)
+                elif _IS_UNIX and _UNIX_LOCKING_AVAILABLE:
+                    _release_unix_lock(file_handle)
+                else:
+                    _release_fallback_lock(file_handle)
+
+                log.debug("File lock released")
+
+            except Exception as e:
+                log.error(f"Error releasing file lock: {e}")
+                # Don't raise - we're in cleanup
+
+
+def _acquire_windows_lock(file_handle: BinaryIO, exclusive: bool) -> None:
+    """Acquire Windows file lock using msvcrt.locking()."""
+    if not _WINDOWS_LOCKING_AVAILABLE:
+        raise FileLockError("Windows file locking not available (msvcrt missing)")
+
+    # Windows locking modes
+    if exclusive:
+        lock_mode = msvcrt.LK_NBLCK  # Non-blocking exclusive lock
+    else:
+        # Windows doesn't have shared locks in msvcrt
+        # Fall back to exclusive for compatibility
+        lock_mode = msvcrt.LK_NBLCK
+        log.debug("Windows: Using exclusive lock instead of shared (msvcrt limitation)")
+
+    try:
+        # Lock the entire file (position 0, length 1)
+        file_handle.seek(0)
+        msvcrt.locking(file_handle.fileno(), lock_mode, 1)
+    except OSError as e:
+        raise FileLockError(f"Failed to acquire Windows file lock: {e}") from e
+
+
+def _release_windows_lock(file_handle: BinaryIO) -> None:
+    """Release Windows file lock."""
+    if not _WINDOWS_LOCKING_AVAILABLE:
+        return
+
+    try:
+        file_handle.seek(0)
+        msvcrt.locking(file_handle.fileno(), msvcrt.LK_UNLCK, 1)
+    except OSError as e:
+        raise FileLockError(f"Failed to release Windows file lock: {e}") from e
+
+
+def _acquire_unix_lock(file_handle: BinaryIO, exclusive: bool) -> None:
+    """Acquire Unix file lock using fcntl.flock()."""
+    if not _UNIX_LOCKING_AVAILABLE:
+        raise FileLockError("Unix file locking not available (fcntl missing)")
+
+    # Unix locking modes
+    if exclusive:
+        lock_mode = fcntl.LOCK_EX | fcntl.LOCK_NB  # Non-blocking exclusive
+    else:
+        lock_mode = fcntl.LOCK_SH | fcntl.LOCK_NB  # Non-blocking shared
+
+    try:
+        fcntl.flock(file_handle.fileno(), lock_mode)
+    except (OSError, IOError) as e:
+        raise FileLockError(f"Failed to acquire Unix file lock: {e}") from e
+
+
+def _release_unix_lock(file_handle: BinaryIO) -> None:
+    """Release Unix file lock."""
+    if not _UNIX_LOCKING_AVAILABLE:
+        return
+
+    try:
+        fcntl.flock(file_handle.fileno(), fcntl.LOCK_UN)
+    except (OSError, IOError) as e:
+        raise FileLockError(f"Failed to release Unix file lock: {e}") from e
+
+
+def _acquire_fallback_lock(
+    file_handle: BinaryIO, exclusive: bool, timeout: Optional[float]
+) -> None:
+    """
+    Fallback locking using lock files.
+
+    This provides minimal protection but doesn't prevent all race conditions.
+    It's better than no locking but not as robust as OS-level file locks.
+    """
+    log.warning(
+        "Using fallback file locking - limited protection against race conditions"
+    )
+
+    # Create lock file based on the original file
+    file_path = (
+        Path(file_handle.name) if hasattr(file_handle, "name") else Path("unknown")
+    )
+    lock_file = file_path.with_suffix(file_path.suffix + ".lock")
+
+    start_time = time.time()
+
+    while True:
+        try:
+            # Try to create lock file atomically
+            lock_file.touch(mode=0o600, exist_ok=False)
+            log.debug(f"Fallback lock file created: {lock_file}")
+            return
+
+        except FileExistsError:
+            # Lock file exists, check timeout
+            if timeout is not None and (time.time() - start_time) >= timeout:
+                raise FileLockError(f"Fallback lock timeout: {lock_file} exists")
+
+            # Wait and retry
+            time.sleep(0.1)
+
+
+def _release_fallback_lock(file_handle: BinaryIO) -> None:
+    """Release fallback lock by removing lock file."""
+    try:
+        file_path = (
+            Path(file_handle.name) if hasattr(file_handle, "name") else Path("unknown")
+        )
+        lock_file = file_path.with_suffix(file_path.suffix + ".lock")
+
+        if lock_file.exists():
+            lock_file.unlink()
+            log.debug(f"Fallback lock file removed: {lock_file}")
+
+    except Exception as e:
+        log.error(f"Failed to remove fallback lock file: {e}")
+
+
+def get_platform_info() -> dict:
+    """Get information about current platform and available locking mechanisms."""
+    return {
+        "platform": platform.system(),
+        "windows_locking": _IS_WINDOWS and _WINDOWS_LOCKING_AVAILABLE,
+        "unix_locking": _IS_UNIX and _UNIX_LOCKING_AVAILABLE,
+        "fallback_only": not (_WINDOWS_LOCKING_AVAILABLE or _UNIX_LOCKING_AVAILABLE),
+    }

tetra_rp/core/utils/singleton.py

@@ -1,7 +1,21 @@
+import threading
+
+
 class SingletonMixin:
+    """Thread-safe singleton mixin class.
+
+    Uses threading.Lock to ensure only one instance is created
+    per class, even under concurrent access.
+    """
+
     _instances = {}
+    _lock = threading.Lock()
 
     def __new__(cls, *args, **kwargs):
+        # Use double-checked locking pattern for performance
         if cls not in cls._instances:
-            cls._instances[cls] = super().__new__(cls)
+            with cls._lock:
+                # Check again inside the lock (double-checked locking)
+                if cls not in cls._instances:
+                    cls._instances[cls] = super().__new__(cls)
         return cls._instances[cls]

tetra_rp/stubs/live_serverless.py

@@ -4,6 +4,7 @@ import inspect
 import textwrap
 import hashlib
 import traceback
+import threading
 import cloudpickle
 import logging
 from ..core.resources import LiveServerless
@@ -16,8 +17,9 @@ from ..protos.remote_execution import (
 log = logging.getLogger(__name__)
 
 
-# global in memory cache, TODO: use a more robust cache in future
+# Global in-memory cache with thread safety
 _SERIALIZED_FUNCTION_CACHE = {}
+_function_cache_lock = threading.RLock()
 
 
 def get_function_source(func):
@@ -80,12 +82,14 @@ class LiveServerlessStub(RemoteExecutorStub):
             "hf_models_to_cache": hf_models_to_cache,
         }
 
-        # check if the function is already cached
-        if src_hash not in _SERIALIZED_FUNCTION_CACHE:
-            # Cache the serialized function
-            _SERIALIZED_FUNCTION_CACHE[src_hash] = source
+        # Thread-safe cache access
+        with _function_cache_lock:
+            # check if the function is already cached
+            if src_hash not in _SERIALIZED_FUNCTION_CACHE:
+                # Cache the serialized function
+                _SERIALIZED_FUNCTION_CACHE[src_hash] = source
 
-        request["function_code"] = _SERIALIZED_FUNCTION_CACHE[src_hash]
+            request["function_code"] = _SERIALIZED_FUNCTION_CACHE[src_hash]
 
         # Serialize arguments using cloudpickle
         if args:

tetra_rp/stubs/registry.py

@@ -2,6 +2,7 @@ import logging
 from functools import singledispatch
 
 from ..core.resources import (
+    CpuLiveServerless,
     CpuServerlessEndpoint,
     LiveServerless,
     ServerlessEndpoint,
@@ -20,8 +21,8 @@ def stub_resource(resource, **extra):
     return fallback
 
 
-@stub_resource.register(LiveServerless)
-def _(resource, **extra):
+def _create_live_serverless_stub(resource, **extra):
+    """Create a live serverless stub for both LiveServerless and CpuLiveServerless."""
     stub = LiveServerlessStub(resource)
 
     # Function execution
@@ -60,15 +61,27 @@ def _(resource, **extra):
     return stubbed_resource
 
 
+@stub_resource.register(LiveServerless)
+def _(resource, **extra):
+    return _create_live_serverless_stub(resource, **extra)
+
+
+@stub_resource.register(CpuLiveServerless)
+def _(resource, **extra):
+    return _create_live_serverless_stub(resource, **extra)
+
+
 @stub_resource.register(ServerlessEndpoint)
 def _(resource, **extra):
     async def stubbed_resource(
-        func, dependencies, system_dependencies, *args, **kwargs
+        func,
+        dependencies,
+        system_dependencies,
+        accelerate_downloads,
+        hf_models_to_cache,
+        *args,
+        **kwargs,
     ) -> dict:
-        if args == (None,):
-            # cleanup: when the function is called with no args
-            args = []
-
         if dependencies or system_dependencies:
             log.warning(
                 "Dependencies are not supported for ServerlessEndpoint. "
@@ -86,12 +99,14 @@ def _(resource, **extra):
 @stub_resource.register(CpuServerlessEndpoint)
 def _(resource, **extra):
     async def stubbed_resource(
-        func, dependencies, system_dependencies, *args, **kwargs
+        func,
+        dependencies,
+        system_dependencies,
+        accelerate_downloads,
+        hf_models_to_cache,
+        *args,
+        **kwargs,
     ) -> dict:
-        if args == (None,):
-            # cleanup: when the function is called with no args
-            args = []
-
         if dependencies or system_dependencies:
             log.warning(
                 "Dependencies are not supported for CpuServerlessEndpoint. "

{tetra_rp-0.11.0.dist-info → tetra_rp-0.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tetra_rp
-Version: 0.11.0
+Version: 0.12.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.11.0.dist-info → tetra_rp-0.12.0.dist-info}/RECORD

@@ -1,36 +1,38 @@
-tetra_rp/__init__.py,sha256=1ZWWK0rHCpkvxN4hYSFv1xJ6pwJxDJHqsKTBdr0Lxa4,721
+tetra_rp/__init__.py,sha256=_D3Wbtv9tBh_WGS4Si5uQbsefL63GqqjoGTN3R8P6fA,769
 tetra_rp/client.py,sha256=urSVh0j9didd9U8lboPv3TtFYURp2XO6ReOICr9Xrls,3414
 tetra_rp/execute_class.py,sha256=jYNFalqqjKvvCz1zzodRvOkrLQd2FYnLYa4EElEYp8w,12243
 tetra_rp/logger.py,sha256=gk5-PWp3k_GQ5DxndsRkBCX0jarp_3lgZ1oiTFuThQg,1125
 tetra_rp/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tetra_rp/core/api/__init__.py,sha256=oldrEKMwxYoBPLvPfVlaFS3wfUtTTxCN6-HzlpTh6vE,124
 tetra_rp/core/api/runpod.py,sha256=3TTx1fkXMLZ2R5JCrQYPEn8dhdUsBt8i5OEwAfaKQ_k,10451
-tetra_rp/core/resources/__init__.py,sha256=b9Odwyc9BzINinDajKWX-WV-fR6mPrg6bF4evMTZpWU,844
+tetra_rp/core/resources/__init__.py,sha256=ZvSfceYV4S1Xo3YA03B-sR5VRud8BKfx5Pe44xFfruo,911
 tetra_rp/core/resources/base.py,sha256=UJeDiFN45aO1n5SBcxn56ohLhj-AWHoj0KO7mF4yJ_o,1440
 tetra_rp/core/resources/cloud.py,sha256=XJOWPfzYlDVJGHxgffcfpEaOKrWhGdi7AzTlaGuYj0o,70
 tetra_rp/core/resources/constants.py,sha256=F1gPqFaXcCmfrbUSO9PQtUBv984TxFc3pySgVy-kXk8,158
-tetra_rp/core/resources/cpu.py,sha256=YIE-tKolSU3JJzpPB7ey-PbRdqKWsJZ_Ad4h2OYaaiA,1231
+tetra_rp/core/resources/cpu.py,sha256=szhkjaJ9OnjzLvaD7Yc2hRCR-C9eyB6tswo1Qe6VuZ0,3962
 tetra_rp/core/resources/environment.py,sha256=FC9kJCa8YLSar75AKUKqJYnNLrUdjZj8ZTOrspBrS00,1267
-tetra_rp/core/resources/gpu.py,sha256=2jIIMr8PNnlIAP8ZTKO8Imx-rdxXp2rbdSHJeVfjawk,1858
-tetra_rp/core/resources/live_serverless.py,sha256=A3JRdCYwHR2KN_OlmTLcv-m_ObxNhBhc5CnUzXOpOtc,1177
+tetra_rp/core/resources/gpu.py,sha256=mMOPLhBugFBAMAl3ezhjAxKuvYya5_9A_h7kvaCoAfk,1885
+tetra_rp/core/resources/live_serverless.py,sha256=FLmaQdn5UMczEfkP3qykIfRVfZeyYdvyNHX9Nd13_54,1868
 tetra_rp/core/resources/network_volume.py,sha256=h_1xhrbBm9jJWROOGl5qy9u4_kCKSyV4idzt0567-J8,5193
-tetra_rp/core/resources/resource_manager.py,sha256=kUVZDblfUzaG78S8FwOzu4rN6QSegUgQNK3fJ_X7l0w,2834
-tetra_rp/core/resources/serverless.py,sha256=OxJb5ojx6GidA6nFvVav52PkzRFDC1CetdMYSyfZG2s,14102
+tetra_rp/core/resources/resource_manager.py,sha256=K-SgCk2BMNEAnkB87YynxUH-suZcdcOPLMonL7EogIw,4988
+tetra_rp/core/resources/serverless.py,sha256=1T21RkMjGnM1I87AsGQ6qazp7A9cE7LwH_c6yJ5shPQ,13427
+tetra_rp/core/resources/serverless_cpu.py,sha256=OiG1C_5_j7pYPHdGp3lQQanIl2ak81u8-jlZo2OXflA,5567
 tetra_rp/core/resources/template.py,sha256=qQ8Wd7Rzr1_YeAbW1V7_k7AVHzgWR_RPjcaRfKsetAk,3141
 tetra_rp/core/resources/utils.py,sha256=mgXfgz_NuHN_IC7TzMNdH9II-LMjxcDCG7syDTcPiGs,1721
 tetra_rp/core/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tetra_rp/core/utils/backoff.py,sha256=1pfa0smFNpib8nztcIgBbtrVvQeECKh-aNOfL2TztgU,1324
 tetra_rp/core/utils/constants.py,sha256=Dm4XiO5zTzfdqOSeYVfAjaf2LyHnIEVmbOi_s_k1J_E,375
+tetra_rp/core/utils/file_lock.py,sha256=bxtAexD2rbqMhdr94VbmKdNp0gfKRgxDXx1n7LX4Eso,8269
 tetra_rp/core/utils/json.py,sha256=q0r7aEdfh8kKVeHGeh9fBDfuhHYNopSreislAMB6HhM,1163
 tetra_rp/core/utils/lru_cache.py,sha256=drwKg-DfLbeBRGTzuxKqNKMQq0EuZV15LMTZIOyZuVk,2618
-tetra_rp/core/utils/singleton.py,sha256=JRli0HhBfq4P9mBUOg1TZUUwMvIenRqWdymX3qFMm2k,210
+tetra_rp/core/utils/singleton.py,sha256=lSXgEQGX9nzhrc05GMpThn9SHKG45iajBbSEtwCcNyI,632
 tetra_rp/protos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tetra_rp/protos/remote_execution.py,sha256=flKJG0U4ked84cXyF4Gfs_7fBgLsEVOzBv8ZWB9UlP0,5648
 tetra_rp/stubs/__init__.py,sha256=ozKsHs8q0T7o2qhQEquub9hqomh1Htys53mMraaRu2E,72
-tetra_rp/stubs/live_serverless.py,sha256=IjocUFkbtvbfXIXWjvxnc0Qk-rMCbwpnuERv6TpmAq0,4424
-tetra_rp/stubs/registry.py,sha256=HcEoedZS-okQ2P9E4LoqK3cE2U9ozvHvf4R6ppHNGog,3045
+tetra_rp/stubs/live_serverless.py,sha256=2bQ47Hq4D8o3YydkxR6QVuLjYrzYS427r3067beYK2A,4550
+tetra_rp/stubs/registry.py,sha256=akJREObyvTAVp6Rvxw8O49W52eJAjByleLU_phMyaDI,3351
 tetra_rp/stubs/serverless.py,sha256=BM_a5Ml5VADBYu2WRNmo9qnicP8NnXDGl5ywifulbD0,947
-tetra_rp-0.11.0.dist-info/METADATA,sha256=J2uAyIH81jei8H_QSkBaff-uivccdtsugDtxSqT_L80,28077
-tetra_rp-0.11.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tetra_rp-0.11.0.dist-info/top_level.txt,sha256=bBay7JTDwJXsTYvVjrwno9hnF-j0q272lk65f2AcPjU,9
-tetra_rp-0.11.0.dist-info/RECORD,,
+tetra_rp-0.12.0.dist-info/METADATA,sha256=u2OHbJV-8KIiOca3SenK2J6I8ms13P8Jc64KGNhFAyE,28077
+tetra_rp-0.12.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tetra_rp-0.12.0.dist-info/top_level.txt,sha256=bBay7JTDwJXsTYvVjrwno9hnF-j0q272lk65f2AcPjU,9
+tetra_rp-0.12.0.dist-info/RECORD,,