WIP

Author: tamirse

datacrunch/containers/containers.py

@@ -1,8 +1,11 @@
+import requests
 from dataclasses import dataclass
 from dataclasses_json import dataclass_json, Undefined  # type: ignore
-from typing import List, Optional, Dict
+from typing import List, Optional, Dict, Any
 from enum import Enum
 
+from datacrunch.http_client.http_client import HTTPClient
+
 
 # API endpoints
 CONTAINER_DEPLOYMENTS_ENDPOINT = '/container-deployments'
@@ -256,39 +259,44 @@ class Deployment:
     :param is_spot: Whether is spot deployment
     :param endpoint_base_url: Optional base URL for the deployment endpoint
     :param scaling: Optional scaling configuration
+    :param created_at: Optional timestamp when the deployment was created
+    :param inference_key: Optional inference key for the deployment
     """
     name: str
     container_registry_settings: ContainerRegistrySettings
-    containers: List[Container]
+    containers: List[Container] | List[ContainerInfo]
     compute: ComputeResource
     is_spot: bool = False
     endpoint_base_url: Optional[str] = None
     scaling: Optional[ScalingOptions] = None
+    created_at: Optional[str] = None
 
+    inference_key: Optional[str] = None
 
-@dataclass_json(undefined=Undefined.EXCLUDE)
-@dataclass
-class DeploymentInfo:
-    """Configuration for a container deployment.
-    This class is read-only and includes system-managed fields.
+    @classmethod
+    def from_dict_with_inference_key(cls, data: Dict[str, Any], inference_key: str = None, **kwargs) -> 'Deployment':
+        """Create a Deployment instance from a dictionary with an inference key.
 
-    :param name: Name of the deployment
-    :param container_registry_settings: Settings for accessing container registry
-    :param containers: List of containers in the deployment
-    :param compute: Compute resource configuration
-    :param is_spot: Whether is spot deployment
-    :param endpoint_base_url: Optional base URL for the deployment endpoint
-    :param scaling: Optional scaling configuration
-    :param created_at: Timestamp when the deployment was created
-    """
-    name: str
-    container_registry_settings: ContainerRegistrySettings
-    containers: List[ContainerInfo]
-    compute: ComputeResource
-    is_spot: bool = False
-    endpoint_base_url: Optional[str] = None
-    scaling: Optional[ScalingOptions] = None
-    created_at: Optional[str] = None
+        :param data: Dictionary containing deployment data
+        :param inference_key: inference key to set on the deployment
+        :param **kwargs: Additional arguments to pass to from_dict
+        :return: Deployment instance
+        """
+        deployment = cls.from_dict(data, **kwargs)
+        deployment._inference_key = inference_key
+        return deployment
+
+    def run_sync(self, data: Dict[str, Any], path: str = "", timeout_seconds: int = 60 * 5):
+        if self._inference_key is None:
+            raise ValueError("Inference key is not set")  # TODO: review this
+
+        # TODO: create a request object
+        return requests.post(
+            url=f"{self.endpoint_base_url}{path}",
+            json=data,
+            headers={"Authorization": f"Bearer {self._inference_key}"},
+            timeout=timeout_seconds
+        )
 
 
 @dataclass_json
@@ -397,67 +405,71 @@ def __init__(self, name: str, docker_config_json: str):
 class ContainersService:
     """Service for managing container deployments"""
 
-    def __init__(self, http_client) -> None:
+    def __init__(self, http_client: HTTPClient, inference_key: str = None) -> None:
         """Initialize the containers service
 
         :param http_client: HTTP client for making API requests
         :type http_client: Any
         """
         self.client = http_client
+        self._inference_key = inference_key
 
-    def get_deployments(self) -> List[DeploymentInfo]:
+    def get_deployments(self) -> List[Deployment]:
         """Get all deployments
 
         :return: list of deployments
-        :rtype: List[DeploymentInfo]
+        :rtype: List[Deployment]
         """
         response = self.client.get(CONTAINER_DEPLOYMENTS_ENDPOINT)
-        return [DeploymentInfo.from_dict(deployment, infer_missing=True) for deployment in response.json()]
+        return [Deployment.from_dict(deployment, infer_missing=True) for deployment in response.json()]
 
-    def get_deployment_by_name(self, deployment_name: str) -> DeploymentInfo:
+    def get_deployment_by_name(self, deployment_name: str) -> Deployment:
         """Get a deployment by name
 
         :param deployment_name: name of the deployment
         :type deployment_name: str
         :return: deployment
-        :rtype: DeploymentInfo
+        :rtype: Deployment
         """
         response = self.client.get(
             f"{CONTAINER_DEPLOYMENTS_ENDPOINT}/{deployment_name}")
-        return DeploymentInfo.from_dict(response.json(), infer_missing=True)
+        return Deployment.from_dict_with_inference_key(response.json(), self._inference_key)
+
+    # Function alias
+    get_deployment = get_deployment_by_name
 
     def create_deployment(
         self,
         deployment: Deployment
-    ) -> DeploymentInfo:
+    ) -> Deployment:
         """Create a new deployment
 
         :param deployment: deployment configuration
         :type deployment: Deployment
         :return: created deployment
-        :rtype: DeploymentInfo
+        :rtype: Deployment
         """
         response = self.client.post(
             CONTAINER_DEPLOYMENTS_ENDPOINT,
             deployment.to_dict()
         )
-        return DeploymentInfo.from_dict(response.json(), infer_missing=True)
+        return Deployment.from_dict(response.json(), infer_missing=True)
 
-    def update_deployment(self, deployment_name: str, deployment: DeploymentInfo) -> DeploymentInfo:
+    def update_deployment(self, deployment_name: str, deployment: Deployment) -> Deployment:
         """Update an existing deployment
 
         :param deployment_name: name of the deployment to update
         :type deployment_name: str
         :param deployment: updated deployment
-        :type deployment: DeploymentInfo
+        :type deployment: Deployment
         :return: updated deployment
-        :rtype: DeploymentInfo
+        :rtype: Deployment
         """
         response = self.client.patch(
             f"{CONTAINER_DEPLOYMENTS_ENDPOINT}/{deployment_name}",
             deployment.to_dict()
         )
-        return DeploymentInfo.from_dict(response.json(), infer_missing=True)
+        return Deployment.from_dict(response.json(), infer_missing=True)
 
     def delete_deployment(self, deployment_name: str) -> None:
         """Delete a deployment
@@ -661,6 +673,9 @@ def get_compute_resources(self) -> List[ComputeResource]:
                 resources.append(ComputeResource.from_dict(resource))
         return resources
 
+    # Function alias
+    get_gpus = get_compute_resources
+
     def get_secrets(self) -> List[Secret]:
         """Get all secrets
 

datacrunch/datacrunch.py

@@ -17,7 +17,7 @@
 class DataCrunchClient:
     """Client for interacting with DataCrunch's public API"""
 
-    def __init__(self, client_id: str, client_secret: str, base_url: str = "https://api.datacrunch.io/v1") -> None:
+    def __init__(self, client_id: str, client_secret: str, base_url: str = "https://api.datacrunch.io/v1", inference_key: str = None) -> None:
         """The DataCrunch client
 
         :param client_id: client id
@@ -26,6 +26,8 @@ def __init__(self, client_id: str, client_secret: str, base_url: str = "https://
         :type client_secret: str
         :param base_url: base url for all the endpoints, optional, defaults to "https://api.datacrunch.io/v1"
         :type base_url: str, optional
+        :param inference_key: inference key, optional
+        :type inference_key: str, optional
         """
 
         # Constants
@@ -70,5 +72,5 @@ def __init__(self, client_id: str, client_secret: str, base_url: str = "https://
         """Locations service. Get locations"""
 
         self.containers: ContainersService = ContainersService(
-            self._http_client)
+            self._http_client, inference_key)
         """Containers service. Deploy, manage, and monitor container deployments"""