tetra-rp 0.9.0__tar.gz → 0.10.0__tar.gz

{tetra_rp-0.9.0 → tetra_rp-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tetra_rp
-Version: 0.9.0
+Version: 0.10.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.9.0 → tetra_rp-0.10.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tetra_rp"
-version = "0.9.0"
+version = "0.10.0"
 description = "A Python library for distributed inference and serving of machine learning models"
 authors = [
     { name = "Marut Pandya", email = "pandyamarut@gmail.com" },

{tetra_rp-0.9.0 → tetra_rp-0.10.0}/src/tetra_rp/core/api/runpod.py

@@ -281,6 +281,30 @@ class RunpodRestClient:
 
         return result
 
+    async def list_network_volumes(self) -> Dict[str, Any]:
+        """
+        List all network volumes in Runpod.
+
+        Returns:
+            List of network volume objects or dict containing networkVolumes key.
+            The API may return either format depending on version.
+        """
+        log.debug("Listing network volumes")
+
+        result = await self._execute_rest(
+            "GET", f"{RUNPOD_REST_API_URL}/networkvolumes"
+        )
+
+        # Handle both list and dict responses
+        if isinstance(result, list):
+            volume_count = len(result)
+        else:
+            volume_count = len(result.get("networkVolumes", []))
+
+        log.debug(f"Listed {volume_count} network volumes")
+
+        return result
+
     async def close(self):
         """Close the HTTP session."""
         if self.session and not self.session.closed:

tetra_rp-0.10.0/src/tetra_rp/core/resources/network_volume.py

@@ -0,0 +1,152 @@
+import hashlib
+import logging
+from enum import Enum
+from typing import Optional
+
+from pydantic import (
+    Field,
+    field_serializer,
+)
+
+from ..api.runpod import RunpodRestClient
+from .base import DeployableResource
+from .constants import CONSOLE_BASE_URL
+
+log = logging.getLogger(__name__)
+
+
+class DataCenter(str, Enum):
+    """
+    Enum representing available data centers for network volumes.
+    #TODO: Add more data centers as needed. Lock this to the available data center.
+    """
+
+    EU_RO_1 = "EU-RO-1"
+
+
+class NetworkVolume(DeployableResource):
+    """
+    NetworkVolume resource for creating and managing Runpod network volumes.
+
+    This class handles the creation, deployment, and management of network volumes
+    that can be attached to serverless resources. Supports idempotent deployment
+    where multiple volumes with the same name will reuse existing volumes.
+
+    """
+
+    # Internal fixed value
+    dataCenterId: DataCenter = Field(default=DataCenter.EU_RO_1, frozen=True)
+
+    id: Optional[str] = Field(default=None)
+    name: Optional[str] = None
+    size: Optional[int] = Field(default=50, gt=0)  # Size in GB
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}:{self.id}"
+
+    @property
+    def resource_id(self) -> str:
+        """Unique resource ID based on name and datacenter for idempotent behavior."""
+        if self.name:
+            # Use name + datacenter for volumes with names to ensure idempotence
+            resource_type = self.__class__.__name__
+            config_key = f"{self.name}:{self.dataCenterId.value}"
+            hash_obj = hashlib.md5(f"{resource_type}:{config_key}".encode())
+            return f"{resource_type}_{hash_obj.hexdigest()}"
+        else:
+            # Fall back to default behavior for unnamed volumes
+            return super().resource_id
+
+    @field_serializer("dataCenterId")
+    def serialize_data_center_id(self, value: Optional[DataCenter]) -> Optional[str]:
+        """Convert DataCenter enum to string."""
+        return value.value if value is not None else None
+
+    @property
+    def is_created(self) -> bool:
+        "Returns True if the network volume already exists."
+        return self.id is not None
+
+    @property
+    def url(self) -> str:
+        """
+        Returns the URL for the network volume resource.
+        """
+        if not self.id:
+            raise ValueError("Network volume ID is not set")
+        return f"{CONSOLE_BASE_URL}/user/storage"
+
+    def is_deployed(self) -> bool:
+        """
+        Checks if the network volume resource is deployed and available.
+        """
+        return self.id is not None
+
+    def _normalize_volumes_response(self, volumes_response) -> list:
+        """Normalize API response to list format."""
+        if isinstance(volumes_response, list):
+            return volumes_response
+        return volumes_response.get("networkVolumes", [])
+
+    def _find_matching_volume(self, existing_volumes: list) -> Optional[dict]:
+        """Find existing volume matching name and datacenter."""
+        for volume_data in existing_volumes:
+            if (
+                volume_data.get("name") == self.name
+                and volume_data.get("dataCenterId") == self.dataCenterId.value
+            ):
+                return volume_data
+        return None
+
+    async def _find_existing_volume(self, client) -> Optional["NetworkVolume"]:
+        """Check for existing volume with same name and datacenter."""
+        if not self.name:
+            return None
+
+        log.debug(f"Checking for existing network volume with name: {self.name}")
+        volumes_response = await client.list_network_volumes()
+        existing_volumes = self._normalize_volumes_response(volumes_response)
+
+        if matching_volume := self._find_matching_volume(existing_volumes):
+            log.info(
+                f"Found existing network volume: {matching_volume.get('id')} with name '{self.name}'"
+            )
+            # Update our instance with the existing volume's ID
+            self.id = matching_volume.get("id")
+            return self
+
+        return None
+
+    async def _create_new_volume(self, client) -> "NetworkVolume":
+        """Create a new network volume."""
+        log.debug(f"Creating new network volume: {self.name or 'unnamed'}")
+        payload = self.model_dump(exclude_none=True)
+        result = await client.create_network_volume(payload)
+
+        if volume := self.__class__(**result):
+            return volume
+
+        raise ValueError("Deployment failed, no volume was created.")
+
+    async def deploy(self) -> "DeployableResource":
+        """
+        Deploys the network volume resource using the provided configuration.
+        Returns a DeployableResource object.
+        """
+        try:
+            # If the resource is already deployed, return it
+            if self.is_deployed():
+                log.debug(f"{self} exists")
+                return self
+
+            async with RunpodRestClient() as client:
+                # Check for existing volume first
+                if existing_volume := await self._find_existing_volume(client):
+                    return existing_volume
+
+                # No existing volume found, create a new one
+                return await self._create_new_volume(client)
+
+        except Exception as e:
+            log.error(f"{self} failed to deploy: {e}")
+            raise

{tetra_rp-0.9.0 → tetra_rp-0.10.0}/src/tetra_rp/core/resources/serverless.py

@@ -134,8 +134,12 @@ class ServerlessResource(DeployableResource):
         return value.value if value is not None else None
 
     @field_serializer("instanceIds")
-    def serialize_instance_ids(self, value: List[CpuInstanceType]) -> List[str]:
+    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")
@@ -247,62 +251,6 @@ class ServerlessResource(DeployableResource):
             log.error(f"{self} failed to deploy: {e}")
             raise
 
-    async def is_ready_for_requests(self, give_up_threshold=10) -> bool:
-        """
-        Asynchronously checks if the serverless resource is ready to handle
-        requests by polling its health endpoint.
-
-        Args:
-            give_up_threshold (int, optional): The maximum number of polling
-            attempts before giving up and raising an error. Defaults to 10.
-
-        Returns:
-            bool: True if the serverless resource is ready for requests.
-
-        Raises:
-            ValueError: If the serverless resource is not deployed.
-            RuntimeError: If the health status is THROTTLED, UNHEALTHY, or UNKNOWN
-            after exceeding the give_up_threshold.
-        """
-        if not self.is_deployed():
-            raise ValueError("Serverless is not deployed")
-
-        log.debug(f"{self} | API /health")
-
-        current_pace = 0
-        attempt = 0
-
-        # Poll for health status
-        while True:
-            await asyncio.sleep(current_pace)
-
-            health = await asyncio.to_thread(self.endpoint.health)
-            health = ServerlessHealth(**health)
-
-            if health.is_ready:
-                return True
-            else:
-                # nothing changed, increase the gap
-                attempt += 1
-                indicator = "." * (attempt // 2) if attempt % 2 == 0 else ""
-                if indicator:
-                    log.info(f"{self} | {indicator}")
-
-                status = health.workers.status
-                if status in [
-                    Status.THROTTLED,
-                    Status.UNHEALTHY,
-                    Status.UNKNOWN,
-                ]:
-                    log.debug(f"{self} | Health {status.value}")
-
-                    if attempt >= give_up_threshold:
-                        # Give up
-                        raise RuntimeError(f"Health {status.value}")
-
-            # Adjust polling pace appropriately
-            current_pace = get_backoff_delay(attempt)
-
     async def run_sync(self, payload: Dict[str, Any]) -> "JobOutput":
         """
         Executes a serverless endpoint request with the payload.
@@ -319,9 +267,6 @@ class ServerlessResource(DeployableResource):
         try:
             # log.debug(f"[{log_group}] Payload: {payload}")
 
-            # Poll until requests can be sent
-            await self.is_ready_for_requests()
-
             log.info(f"{self} | API /run_sync")
             response = await asyncio.to_thread(_fetch_job)
             return JobOutput(**response)
@@ -346,9 +291,6 @@ class ServerlessResource(DeployableResource):
         try:
             # log.debug(f"[{self}] Payload: {payload}")
 
-            # Poll until requests can be sent
-            await self.is_ready_for_requests()
-
             # Create a job using the endpoint
             log.info(f"{self} | API /run")
             job = await asyncio.to_thread(self.endpoint.run, request_input=payload)
@@ -366,9 +308,8 @@ class ServerlessResource(DeployableResource):
             while True:
                 await asyncio.sleep(current_pace)
 
-                if await self.is_ready_for_requests():
-                    # Check job status
-                    job_status = await asyncio.to_thread(job.status)
+                # Check job status
+                job_status = await asyncio.to_thread(job.status)
 
                 if last_status == job_status:
                     # nothing changed, increase the gap

{tetra_rp-0.9.0 → tetra_rp-0.10.0}/src/tetra_rp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tetra_rp
-Version: 0.9.0
+Version: 0.10.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.9.0/src/tetra_rp/core/resources/network_volume.py

@@ -1,107 +0,0 @@
-import logging
-from enum import Enum
-from typing import Optional
-
-from pydantic import (
-    Field,
-    field_serializer,
-)
-
-from ..api.runpod import RunpodRestClient
-from .base import DeployableResource
-from .constants import CONSOLE_BASE_URL
-
-log = logging.getLogger(__name__)
-
-
-class DataCenter(str, Enum):
-    """
-    Enum representing available data centers for network volumes.
-    #TODO: Add more data centers as needed. Lock this to the available data center.
-    """
-
-    EU_RO_1 = "EU-RO-1"
-
-
-class NetworkVolume(DeployableResource):
-    """
-    NetworkVolume resource for creating and managing Runpod netowrk volumes.
-
-    This class handles the creation, deployment, and management of network volumes
-    that can be attached to serverless resources.
-
-    """
-
-    # Internal fixed value
-    dataCenterId: DataCenter = Field(default=DataCenter.EU_RO_1, frozen=True)
-
-    id: Optional[str] = Field(default=None)
-    name: Optional[str] = None
-    size: Optional[int] = Field(default=10, gt=0)  # Size in GB
-
-    def __str__(self) -> str:
-        return f"{self.__class__.__name__}:{self.id}"
-
-    @field_serializer("dataCenterId")
-    def serialize_data_center_id(self, value: Optional[DataCenter]) -> Optional[str]:
-        """Convert DataCenter enum to string."""
-        return value.value if value is not None else None
-
-    @property
-    def is_created(self) -> bool:
-        "Returns True if the network volume already exists."
-        return self.id is not None
-
-    @property
-    def url(self) -> str:
-        """
-        Returns the URL for the network volume resource.
-        """
-        if not self.id:
-            raise ValueError("Network volume ID is not set")
-        return f"{CONSOLE_BASE_URL}/user/storage"
-
-    async def create_network_volume(self) -> str:
-        """
-        Creates a network volume using the provided configuration.
-        Returns the volume ID.
-        """
-        async with RunpodRestClient() as client:
-            # Create the network volume
-            payload = self.model_dump(exclude_none=True)
-            result = await client.create_network_volume(payload)
-
-        if volume := self.__class__(**result):
-            return volume
-
-    def is_deployed(self) -> bool:
-        """
-        Checks if the network volume resource is deployed and available.
-        """
-        return self.id is not None
-
-    async def deploy(self) -> "DeployableResource":
-        """
-        Deploys the network volume resource using the provided configuration.
-        Returns a DeployableResource object.
-        """
-        try:
-            # If the resource is already deployed, return it
-            if self.is_deployed():
-                log.debug(f"{self} exists")
-                return self
-
-            # Create the network volume
-            async with RunpodRestClient() as client:
-                # Create the network volume
-                payload = self.model_dump(exclude_none=True)
-                result = await client.create_network_volume(payload)
-
-            if volume := self.__class__(**result):
-                return volume
-
-            raise ValueError("Deployment failed, no volume was created.")
-
-        except Exception as e:
-            log.error(f"{self} failed to deploy: {e}")
-            raise