tetra-rp 0.5.5__py3-none-any.whl

tetra_rp/core/resources/cpu.py

@@ -0,0 +1,34 @@
+from enum import Enum
+
+
+class CpuInstanceType(str, Enum):
+    """Valid CPU instance types.
+
+    Format: {generation}{type}-{vcpu}-{memory_gb}
+    Based on Runpod backend validation logic:
+    - memoryInGb = vcpuCount * flavor.ramMultiplier
+
+    RAM Multipliers (DEV environment):
+    - cpu3g: 4.0 (1 vCPU = 4GB, 2 vCPU = 8GB, etc.)
+    - cpu3c: 2.0 (1 vCPU = 2GB, 2 vCPU = 4GB, etc.)
+    - cpu5c: 2.0 (1 vCPU = 2GB, 2 vCPU = 4GB, etc.)
+    - cpu5g: Not available
+    """
+
+    # 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
+
+    # 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
+
+    # 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

tetra_rp/core/resources/environment.py

@@ -0,0 +1,41 @@
+from typing import Dict, Optional
+from dotenv import dotenv_values
+
+
+class EnvironmentVars:
+    def __init__(self):
+        # Store environment variables from .env file
+        self.env = self._load_env()
+
+    def _load_env(self) -> Dict[str, str]:
+        """
+        Loads environment variables specifically from the .env file
+        and returns them as a dictionary.
+
+        Returns:
+            Dict[str, str]: Dictionary containing environment variables from .env file
+        """
+        # Use dotenv_values instead of load_dotenv to get only variables from .env
+        return dict(dotenv_values())
+
+    def get_env(self) -> Dict[str, str]:
+        """
+        Returns the dictionary of environment variables.
+
+        Returns:
+            Dict[str, str]: Dictionary containing environment variables
+        """
+        return self.env
+
+    def get_value(self, key: str, default: str = None) -> Optional[str]:
+        """
+        Gets a specific environment variable by key.
+
+        Args:
+            key (str): The environment variable key
+            default (str, optional): Default value if key doesn't exist
+
+        Returns:
+            Optional[str]: Value of the environment variable or default
+        """
+        return self.env.get(key, default)

tetra_rp/core/resources/gpu.py

@@ -0,0 +1,53 @@
+from typing import Optional, List
+from pydantic import BaseModel
+from enum import Enum
+
+
+class GpuLowestPrice(BaseModel):
+    minimumBidPrice: Optional[float] = None
+    uninterruptablePrice: Optional[float] = None
+
+
+class GpuType(BaseModel):
+    id: str
+    displayName: str
+    memoryInGb: int
+
+
+class GpuTypeDetail(GpuType):
+    communityCloud: Optional[bool] = None
+    communityPrice: Optional[float] = None
+    communitySpotPrice: Optional[float] = None
+    cudaCores: Optional[int] = None
+    lowestPrice: Optional[GpuLowestPrice] = None
+    manufacturer: Optional[str] = None
+    maxGpuCount: Optional[int] = None
+    oneMonthPrice: Optional[float] = None
+    oneWeekPrice: Optional[float] = None
+    secureCloud: Optional[bool] = None
+    securePrice: Optional[float] = None
+    secureSpotPrice: Optional[float] = None
+    threeMonthPrice: Optional[float] = None
+
+
+# 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"
+
+    @classmethod
+    def all(cls) -> List["GpuGroup"]:
+        """Returns all GPU groups."""
+        return [cls.AMPERE_48] + [g for g in cls if g != cls.ANY]

tetra_rp/core/resources/live_serverless.py

@@ -0,0 +1,32 @@
+# Ship serverless code as you write it. No builds, no deploys — just run.
+import os
+from pydantic import model_validator
+from .serverless import ServerlessEndpoint
+
+
+TETRA_GPU_IMAGE = os.environ.get("TETRA_GPU_IMAGE", "runpod/tetra-rp:dev")
+TETRA_CPU_IMAGE = os.environ.get("TETRA_CPU_IMAGE", "runpod/tetra-rp-cpu:dev")
+
+
+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
+
+    @property
+    def imageName(self):
+        # Lock imageName to always reflect instanceIds
+        return (
+            TETRA_CPU_IMAGE if getattr(self, "instanceIds", None) else TETRA_GPU_IMAGE
+        )
+
+    @imageName.setter
+    def imageName(self, value):
+        # Prevent manual setting of imageName
+        pass

tetra_rp/core/resources/resource_manager.py

@@ -0,0 +1,80 @@
+import cloudpickle
+import logging
+from typing import Dict
+from pathlib import Path
+
+from ..utils.singleton import SingletonMixin
+
+from .base import DeployableResource
+
+
+log = logging.getLogger(__name__)
+
+# File to persist state of resources
+RESOURCE_STATE_FILE = Path(".tetra_resources.pkl")
+
+
+class ResourceManager(SingletonMixin):
+    """Manages dynamic provisioning and tracking of remote resources."""
+
+    _resources: Dict[str, DeployableResource] = {}
+
+    def __init__(self):
+        if not self._resources:
+            self._load_resources()
+
+    def _load_resources(self) -> Dict[str, DeployableResource]:
+        """Load persisted resource information using cloudpickle."""
+        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:
+                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}")
+
+    def add_resource(self, uid: str, resource: DeployableResource):
+        """Add a resource to the manager."""
+        self._resources[uid] = resource
+        self._save_resources()
+
+    # function to check if resource still exists remotely, else remove it
+    def remove_resource(self, uid: str):
+        """Remove a resource from the manager."""
+        if uid not in self._resources:
+            log.warning(f"Resource {uid} not found for removal")
+            return
+
+        del self._resources[uid]
+        log.debug(f"Removed resource {uid}")
+
+        self._save_resources()
+
+    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)
+
+            log.debug(f"{existing} exists, reusing.")
+            log.info(f"URL: {existing.url}")
+            return existing
+
+        if 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}")