datacrunch 1.10.0__py3-none-any.whl → 1.12.0__py3-none-any.whl

datacrunch/InferenceClient/inference_client.py

@@ -6,16 +6,19 @@ from typing import Optional, Dict, Any, Union, Generator
 from urllib.parse import urlparse
 from enum import Enum
 
+
 class InferenceClientError(Exception):
     """Base exception for InferenceClient errors."""
     pass
 
+
 class AsyncStatus(int, Enum):
     Initialized = 0
     Queue = 1
     Inference = 2
     Completed = 3
 
+
 @dataclass_json(undefined=Undefined.EXCLUDE)
 @dataclass
 class InferenceResponse:
@@ -222,6 +225,22 @@ class InferenceClient:
             raise InferenceClientError(f"Request to {path} failed: {str(e)}")
 
     def run_sync(self, data: Dict[str, Any], path: str = "", timeout_seconds: int = 60 * 5, headers: Optional[Dict[str, str]] = None, http_method: str = "POST", stream: bool = False):
+        """Make a synchronous request to the inference endpoint.
+
+        Args:
+            data: The data payload to send with the request
+            path: API endpoint path. Defaults to empty string.
+            timeout_seconds: Request timeout in seconds. Defaults to 5 minutes.
+            headers: Optional headers to include in the request
+            http_method: HTTP method to use. Defaults to "POST".
+            stream: Whether to stream the response. Defaults to False.
+
+        Returns:
+            InferenceResponse: Object containing the response data.
+
+        Raises:
+            InferenceClientError: If the request fails
+        """
         response = self._make_request(
             http_method, path, json=data, timeout_seconds=timeout_seconds, headers=headers, stream=stream)
 
@@ -233,6 +252,23 @@ class InferenceClient:
         )
 
     def run(self, data: Dict[str, Any], path: str = "", timeout_seconds: int = 60 * 5, headers: Optional[Dict[str, str]] = None, http_method: str = "POST", no_response: bool = False):
+        """Make an asynchronous request to the inference endpoint.
+
+        Args:
+            data: The data payload to send with the request
+            path: API endpoint path. Defaults to empty string.
+            timeout_seconds: Request timeout in seconds. Defaults to 5 minutes.
+            headers: Optional headers to include in the request
+            http_method: HTTP method to use. Defaults to "POST".
+            no_response: If True, don't wait for response. Defaults to False.
+
+        Returns:
+            AsyncInferenceExecution: Object to track the async execution status.
+            If no_response is True, returns None.
+
+        Raises:
+            InferenceClientError: If the request fails
+        """
         # Add relevant headers to the request, to indicate that the request is async
         headers = headers or {}
         if no_response:

datacrunch/__version__.py

@@ -1 +1 @@
-VERSION = '1.10.0'
+VERSION = '1.12.0'

datacrunch/constants.py

@@ -22,6 +22,7 @@ class VolumeActions:
 
 
 class InstanceStatus:
+    ORDERED = 'ordered'
     RUNNING = 'running'
     PROVISIONING = 'provisioning'
     OFFLINE = 'offline'

datacrunch/containers/containers.py

@@ -4,6 +4,8 @@ This module provides functionality for managing container deployments, including
 creation, updates, deletion, and monitoring of containerized applications.
 """
 
+import base64
+import os
 from dataclasses import dataclass, field
 from dataclasses_json import dataclass_json, Undefined  # type: ignore
 from typing import List, Optional, Dict, Any
@@ -18,6 +20,7 @@ CONTAINER_DEPLOYMENTS_ENDPOINT = '/container-deployments'
 SERVERLESS_COMPUTE_RESOURCES_ENDPOINT = '/serverless-compute-resources'
 CONTAINER_REGISTRY_CREDENTIALS_ENDPOINT = '/container-registry-credentials'
 SECRETS_ENDPOINT = '/secrets'
+FILESET_SECRETS_ENDPOINT = '/file-secrets'
 
 
 class EnvVarType(str, Enum):
@@ -27,6 +30,13 @@ class EnvVarType(str, Enum):
     SECRET = "secret"
 
 
+class SecretType(str, Enum):
+    """Types of secrets that can be set in containers."""
+
+    GENERIC = "generic"  # Regular secret, can be used in env vars
+    FILESET = "file-secret"  # A file secret that can be mounted into the container
+
+
 class VolumeMountType(str, Enum):
     """Types of volume mounts that can be configured for containers."""
 
@@ -446,10 +456,12 @@ class Secret:
     Attributes:
         name: Name of the secret.
         created_at: Timestamp when the secret was created.
+        secret_type: Type of the secret.
     """
 
     name: str
     created_at: str
+    secret_type: SecretType
 
 
 @dataclass_json
@@ -909,6 +921,7 @@ class ContainersService:
             List[Secret]: List of all secrets.
         """
         response = self.client.get(SECRETS_ENDPOINT)
+        print(response.json())
         return [Secret.from_dict(secret) for secret in response.json()]
 
     def create_secret(self, name: str, value: str) -> None:
@@ -956,3 +969,42 @@ class ContainersService:
         """
         self.client.delete(
             f"{CONTAINER_REGISTRY_CREDENTIALS_ENDPOINT}/{credentials_name}")
+
+    def get_fileset_secrets(self) -> List[Secret]:
+        """Retrieves all fileset secrets.
+
+        Returns:
+           List of all fileset secrets.
+        """
+        response = self.client.get(FILESET_SECRETS_ENDPOINT)
+        return [Secret.from_dict(secret) for secret in response.json()]
+
+    def delete_fileset_secret(self, secret_name: str) -> None:
+        """Deletes a fileset secret.
+
+        Args:
+            secret_name: Name of the secret to delete.
+        """
+        self.client.delete(f"{FILESET_SECRETS_ENDPOINT}/{secret_name}")
+
+    def create_fileset_secret_from_file_paths(self, secret_name: str, file_paths: List[str]) -> None:
+        """Creates a new fileset secret.
+        A fileset secret is a secret that contains several files, 
+        and can be used to mount a directory with the files in a container.
+
+        Args:
+            secret_name: Name of the secret.
+            file_paths: List of file paths to include in the secret.
+        """
+        processed_files = []
+        for file_path in file_paths:
+            with open(file_path, "rb") as f:
+                base64_content = base64.b64encode(f.read()).decode("utf-8")
+                processed_files.append({
+                    "file_name": os.path.basename(file_path),
+                    "base64_content": base64_content
+                })
+        self.client.post(FILESET_SECRETS_ENDPOINT, {
+            "name": secret_name,
+            "files": processed_files
+        })

datacrunch/instances/instances.py

@@ -1,376 +1,113 @@
+import time
 from typing import List, Union, Optional, Dict, Literal
-from datacrunch.helpers import stringify_class_object_properties
-from datacrunch.constants import Locations
+from dataclasses import dataclass
+from dataclasses_json import dataclass_json
+from datacrunch.constants import Locations, InstanceStatus
 
 INSTANCES_ENDPOINT = '/instances'
 
 Contract = Literal['LONG_TERM', 'PAY_AS_YOU_GO', 'SPOT']
 Pricing = Literal['DYNAMIC_PRICE', 'FIXED_PRICE']
 
-class Instance:
-    """An instance model class"""
-
-    def __init__(self,
-                 id: str,
-                 instance_type: str,
-                 image: str,
-                 price_per_hour: float,
-                 hostname: str,
-                 description: str,
-                 ip: str,
-                 status: str,
-                 created_at: str,
-                 ssh_key_ids: List[str],
-                 cpu: dict,
-                 gpu: dict,
-                 memory: dict,
-                 storage: dict,
-                 os_volume_id: str,
-                 gpu_memory: dict,
-                 location: str = Locations.FIN_01,
-                 startup_script_id: str = None,
-                 is_spot: bool = False,
-                 contract: Contract = None,
-                 pricing: Pricing = None,
-                 ) -> None:
-        """Initialize the instance object
-
-        :param id: instance id
-        :type id: str
-        :param instance_type: instance type. e.g. '8V100.48M'
-        :type instance_type: str
-        :param image: instance image type. e.g. 'ubuntu-20.04-cuda-11.0'
-        :type image: str
-        :param price_per_hour: price per hour
-        :type price_per_hour: float
-        :param hostname: instance hostname
-        :type hostname: str
-        :param description: instance description
-        :type description: str
-        :param ip: instance ip address
-        :type ip: str
-        :param status: instance current status, might be out of date if changed
-        :type status: str
-        :param created_at: the time the instance was deployed (UTC)
-        :type created_at: str
-        :param ssh_key_ids: list of ssh keys ids
-        :type ssh_key_ids: List[str]
-        :param cpu: cpu details
-        :type cpu: dict
-        :param gpu: gpu details
-        :type gpu: dict
-        :param memory: memory details
-        :type memory: dict
-        :param storage: storate details
-        :type storage: dict
-        :param id: main OS volume id
-        :type id: str
-        :param memory: gpu memory details
-        :type memory: dict
-        :param location: datacenter location, defaults to "FIN-01"
-        :type location: str, optional
-        :param startup_script_id: startup script id, defaults to None
-        :type startup_script_id: str, optional
-        :param is_spot: is this a spot instance, defaults to None
-        :type is_spot: bool, optional
-        """
-        self._id = id
-        self._instance_type = instance_type
-        self._image = image
-        self._price_per_hour = price_per_hour
-        self._location = location
-        self._hostname = hostname
-        self._description = description
-        self._ip = ip
-        self._status = status
-        self._created_at = created_at
-        self._ssh_key_ids = ssh_key_ids
-        self._startup_script_id = startup_script_id
-        self._cpu = cpu
-        self._gpu = gpu
-        self._memory = memory
-        self._storage = storage
-        self._os_volume_id = os_volume_id
-        self._gpu_memory = gpu_memory
-        self._is_spot = is_spot
-        self._contract = contract
-        self._pricing = pricing
-
-    @property
-    def id(self) -> str:
-        """Get the instance id
-
-        :return: instance id
-        :rtype: str
-        """
-        return self._id
-
-    @property
-    def instance_type(self) -> str:
-        """Get the instance type
-
-        :return: instance type
-        :rtype: str
-        """
-        return self._instance_type
-
-    @property
-    def image(self) -> str:
-        """Get the instance image type
-
-        :return: instance image type
-        :rtype: str
-        """
-        return self._image
-
-    @property
-    def price_per_hour(self) -> float:
-        """Get the instance price per hour
-
-        :return: price per hour
-        :rtype: float
-        """
-        return self._price_per_hour
-
-    @property
-    def location(self) -> str:
-        """Get the instance datacenter location
-
-        :return: datacenter location
-        :rtype: str
-        """
-        return self._location
-
-    @property
-    def hostname(self) -> str:
-        """Get the instance hostname
-
-        :return: hostname
-        :rtype: str
-        """
-        return self._hostname
-
-    @property
-    def description(self) -> str:
-        """Get the instance description
-
-        :return: instance description
-        :rtype: str
-        """
-        return self._description
-
-    @property
-    def ip(self) -> str:
-        """Get the instance ip address
-
-        :return: ip address
-        :rtype: str
-        """
-        return self._ip
-
-    @property
-    def status(self) -> str:
-        """Get the current instance status. might be out of date if changed.
-
-        :return: instance status
-        :rtype: str
-        """
-        return self._status
-
-    @property
-    def created_at(self) -> str:
-        """Get the time when the instance was deployed (UTC)
-
-        :return: time
-        :rtype: str
-        """
-        return self._created_at
-
-    @property
-    def ssh_key_ids(self) -> List[str]:
-        """Get the SSH key IDs of the instance
-
-        :return: SSH key IDs
-        :rtype: List[str]
-        """
-        return self._ssh_key_ids
-
-    @property
-    def startup_script_id(self) -> Union[str, None]:
-        """Get the startup script ID or None if the is no script
-
-        :return: startup script ID or None
-        :rtype: Union[str, None]
-        """
-        return self._startup_script_id
-
-    @property
-    def cpu(self) -> dict:
-        """Get the instance cpu details
-
-        :return: cpu details
-        :rtype: dict
-        """
-        return self._cpu
-
-    @property
-    def gpu(self) -> dict:
-        """Get the instance gpu details
 
-        :return: gpu details
-        :rtype: dict
-        """
-        return self._gpu
-
-    @property
-    def memory(self) -> dict:
-        """Get the instance memory details
-
-        :return: memory details
-        :rtype: dict
-        """
-        return self._memory
-
-    @property
-    def storage(self) -> dict:
-        """Get the instance storage details
-
-        :return: storage details
-        :rtype: dict
-        """
-        return self._storage
-
-    @property
-    def os_volume_id(self) -> str:
-        """Get the main os volume id
-
-        :return: main os volume id
-        :rtype: str
-        """
-        return self._os_volume_id
-
-    @property
-    def gpu_memory(self) -> dict:
-        """Get the instance gpu_memory details
-
-        :return: gpu_memory details
-        :rtype: dict
-        """
-        return self._gpu_memory
-
-    @property
-    def is_spot(self) -> bool:
-        """Is this a spot instance
-
-        :return: is spot details
-        :rtype: bool
-        """
-        return self._is_spot
+@dataclass_json
+@dataclass
+class Instance:
+    """Represents a cloud instance with its configuration and state.
+
+    Attributes:
+        id: Unique identifier for the instance.
+        instance_type: Type of the instance (e.g., '8V100.48V').
+        price_per_hour: Cost per hour of running the instance.
+        hostname: Network hostname of the instance.
+        description: Human-readable description of the instance.
+        status: Current operational status of the instance.
+        created_at: Timestamp of instance creation.
+        ssh_key_ids: List of SSH key IDs associated with the instance.
+        cpu: CPU configuration details.
+        gpu: GPU configuration details.
+        memory: Memory configuration details.
+        storage: Storage configuration details.
+        gpu_memory: GPU memory configuration details.
+        ip: IP address assigned to the instance.
+        os_volume_id: ID of the operating system volume.
+        location: Datacenter location code (default: Locations.FIN_01).
+        image: Image ID or type used for the instance.
+        startup_script_id: ID of the startup script to run.
+        is_spot: Whether the instance is a spot instance.
+        contract: Contract type for the instance. (e.g. 'LONG_TERM', 'PAY_AS_YOU_GO', 'SPOT')
+        pricing: Pricing model for the instance. (e.g. 'DYNAMIC_PRICE', 'FIXED_PRICE')
+    """
+
+    id: str
+    instance_type: str
+    price_per_hour: float
+    hostname: str
+    description: str
+    status: str
+    created_at: str
+    ssh_key_ids: List[str]
+    cpu: dict
+    gpu: dict
+    memory: dict
+    storage: dict
+    gpu_memory: dict
+    # Can be None if instance is still not provisioned
+    ip: Optional[str] = None
+    # Can be None if instance is still not provisioned
+    os_volume_id: Optional[str] = None
+    location: str = Locations.FIN_01
+    image: Optional[str] = None
+    startup_script_id: Optional[str] = None
+    is_spot: bool = False
+    contract: Optional[Contract] = None
+    pricing: Optional[Pricing] = None
 
-    @property
-    def contract(self) -> bool:
-        """Get contract type
 
-        :return: contract type
-        :rtype: str
-        """
-        return self._contract
+class InstancesService:
+    """Service for managing cloud instances through the API.
 
-    @property
-    def pricing(self) -> bool:
-        """Get pricing type
+    This service provides methods to create, retrieve, and manage cloud instances
+    through the DataCrunch API.
+    """
 
-        :return: pricing type
-        :rtype: str
-        """
-        return self._pricing
-
-    def __str__(self) -> str:
-        """Returns a string of the json representation of the instance
+    def __init__(self, http_client) -> None:
+        """Initializes the InstancesService with an HTTP client.
 
-        :return: json representation of the instance
-        :rtype: str
+        Args:
+            http_client: HTTP client for making API requests.
         """
-        return stringify_class_object_properties(self)
-
-
-class InstancesService:
-    """A service for interacting with the instances endpoint"""
-
-    def __init__(self, http_client) -> None:
         self._http_client = http_client
 
-    def get(self, status: str = None) -> List[Instance]:
-        """Get all of the client's non-deleted instances, or instances with specific status.
+    def get(self, status: Optional[str] = None) -> List[Instance]:
+        """Retrieves all non-deleted instances or instances with specific status.
+
+        Args:
+            status: Optional status filter for instances. If None, returns all
+                non-deleted instances.
 
-        :param status: optional, status of the instances, defaults to None
-        :type status: str, optional
-        :return: list of instance details objects
-        :rtype: List[Instance]
+        Returns:
+            List of instance objects matching the criteria.
         """
         instances_dict = self._http_client.get(
             INSTANCES_ENDPOINT, params={'status': status}).json()
-        instances = list(map(lambda instance_dict: Instance(
-            id=instance_dict['id'],
-            instance_type=instance_dict['instance_type'],
-            image=instance_dict['image'],
-            price_per_hour=instance_dict['price_per_hour'] if 'price_per_hour' in instance_dict else None,
-            location=instance_dict['location'],
-            hostname=instance_dict['hostname'],
-            description=instance_dict['description'],
-            ip=instance_dict['ip'],
-            status=instance_dict['status'],
-            created_at=instance_dict['created_at'],
-            ssh_key_ids=instance_dict['ssh_key_ids'] if 'ssh_key_ids' in instance_dict else [
-            ],
-            startup_script_id=instance_dict['startup_script_id'] if 'startup_script_id' in instance_dict else None,
-            cpu=instance_dict['cpu'],
-            gpu=instance_dict['gpu'],
-            memory=instance_dict['memory'],
-            storage=instance_dict['storage'],
-            os_volume_id=instance_dict['os_volume_id'] if 'os_volume_id' in instance_dict else None,
-            gpu_memory=instance_dict['gpu_memory'] if 'gpu_memory' in instance_dict else None,
-            is_spot=instance_dict['is_spot'] if 'is_spot' in instance_dict else False,
-            contract=instance_dict['contract'] if 'contract' in instance_dict else False,
-            pricing=instance_dict['pricing'] if 'pricing' in instance_dict else False,
-        ), instances_dict))
-        return instances
+        return [Instance.from_dict(instance_dict, infer_missing=True) for instance_dict in instances_dict]
 
     def get_by_id(self, id: str) -> Instance:
-        """Get an instance with specified id.
+        """Retrieves a specific instance by its ID.
+
+        Args:
+            id: Unique identifier of the instance to retrieve.
+
+        Returns:
+            Instance object with the specified ID.
 
-        :param id: instance id
-        :type id: str
-        :return: instance details object
-        :rtype: Instance
+        Raises:
+            HTTPError: If the instance is not found or other API error occurs.
         """
         instance_dict = self._http_client.get(
             INSTANCES_ENDPOINT + f'/{id}').json()
-        instance = Instance(
-            id=instance_dict['id'],
-            instance_type=instance_dict['instance_type'],
-            image=instance_dict['image'],
-            price_per_hour=instance_dict['price_per_hour'] if 'price_per_hour' in instance_dict else None,
-            location=instance_dict['location'],
-            hostname=instance_dict['hostname'],
-            description=instance_dict['description'],
-            ip=instance_dict['ip'],
-            status=instance_dict['status'],
-            created_at=instance_dict['created_at'],
-            ssh_key_ids=instance_dict['ssh_key_ids'] if 'ssh_key_ids' in instance_dict else [
-            ],
-            startup_script_id=instance_dict['startup_script_id'] if 'startup_script_id' in instance_dict else None,
-            cpu=instance_dict['cpu'],
-            gpu=instance_dict['gpu'],
-            memory=instance_dict['memory'],
-            storage=instance_dict['storage'],
-            os_volume_id=instance_dict['os_volume_id'] if 'os_volume_id' in instance_dict else None,
-            gpu_memory=instance_dict['gpu_memory'] if 'gpu_memory' in instance_dict else None,
-            is_spot=instance_dict['is_spot'] if 'is_spot' in instance_dict else False,
-            contract=instance_dict['contract'] if 'contract' in instance_dict else False,
-            pricing=instance_dict['pricing'] if 'pricing' in instance_dict else False,
-        )
-        return instance
+        return Instance.from_dict(instance_dict, infer_missing=True)
 
     def create(self,
                instance_type: str,
@@ -379,46 +116,37 @@ class InstancesService:
                description: str,
                ssh_key_ids: list = [],
                location: str = Locations.FIN_01,
-               startup_script_id: str = None,
-               volumes: List[Dict] = None,
-               existing_volumes: List[str] = None,
-               os_volume: Dict = None,
+               startup_script_id: Optional[str] = None,
+               volumes: Optional[List[Dict]] = None,
+               existing_volumes: Optional[List[str]] = None,
+               os_volume: Optional[Dict] = None,
                is_spot: bool = False,
-               contract: Contract = None,
-               pricing: Pricing = None,
-               coupon: str = None) -> Instance:
-        """Creates (deploys) a new instance
-
-        :param instance_type: instance type. e.g. '8V100.48M'
-        :type instance_type: str
-        :param image: instance image type. e.g. 'ubuntu-20.04-cuda-11.0', or existing OS volume id
-        :type image: str
-        :param ssh_key_ids: list of ssh key ids
-        :type ssh_key_ids: list
-        :param hostname: instance hostname
-        :type hostname: str
-        :param description: instance description
-        :type description: str
-        :param location: datacenter location, defaults to "FIN-01"
-        :type location: str, optional
-        :param startup_script_id: startup script id, defaults to None
-        :type startup_script_id: str, optional
-        :param volumes: List of volume data dictionaries to create alongside the instance
-        :type volumes: List[Dict], optional
-        :param existing_volumes: List of existing volume ids to attach to the instance
-        :type existing_volumes: List[str], optional
-        :param os_volume: OS volume details, defaults to None
-        :type os_volume: Dict, optional
-        :param is_spot: Is spot instance
-        :type is_spot: bool, optional
-        :param pricing: Pricing type
-        :type pricing: str, optional
-        :param contract: Contract type
-        :type contract: str, optional
-        :param coupon: coupon code
-        :type coupon: str, optional
-        :return: the new instance object
-        :rtype: id
+               contract: Optional[Contract] = None,
+               pricing: Optional[Pricing] = None,
+               coupon: Optional[str] = None) -> Instance:
+        """Creates and deploys a new cloud instance.
+
+        Args:
+            instance_type: Type of instance to create (e.g., '8V100.48V').
+            image: Image type or existing OS volume ID for the instance.
+            hostname: Network hostname for the instance.
+            description: Human-readable description of the instance.
+            ssh_key_ids: List of SSH key IDs to associate with the instance.
+            location: Datacenter location code (default: Locations.FIN_01).
+            startup_script_id: Optional ID of startup script to run.
+            volumes: Optional list of volume configurations to create.
+            existing_volumes: Optional list of existing volume IDs to attach.
+            os_volume: Optional OS volume configuration details.
+            is_spot: Whether to create a spot instance.
+            contract: Optional contract type for the instance.
+            pricing: Optional pricing model for the instance.
+            coupon: Optional coupon code for discounts.
+
+        Returns:
+            The newly created instance object.
+
+        Raises:
+            HTTPError: If instance creation fails or other API error occurs.
         """
         payload = {
             "instance_type": instance_type,
@@ -439,18 +167,33 @@ class InstancesService:
         if pricing:
             payload['pricing'] = pricing
         id = self._http_client.post(INSTANCES_ENDPOINT, json=payload).text
-        instance = self.get_by_id(id)
-        return instance
+
+        # Wait for instance to enter provisioning state with timeout
+        MAX_WAIT_TIME = 60  # Maximum wait time in seconds
+        POLL_INTERVAL = 0.5  # Time between status checks
+
+        start_time = time.time()
+        while True:
+            instance = self.get_by_id(id)
+            if instance.status != InstanceStatus.ORDERED:
+                return instance
+
+            if time.time() - start_time > MAX_WAIT_TIME:
+                raise TimeoutError(
+                    f"Instance {id} did not enter provisioning state within {MAX_WAIT_TIME} seconds")
+
+            time.sleep(POLL_INTERVAL)
 
     def action(self, id_list: Union[List[str], str], action: str, volume_ids: Optional[List[str]] = None) -> None:
-        """Performs an action on a list of instances / single instance
-
-        :param id_list: list of instance ids, or an instance id
-        :type id_list: Union[List[str], str]
-        :param action: the action to perform
-        :type action: str
-        :param volume_ids: the volume ids to delete
-        :type volume_ids: Optional[List[str]]
+        """Performs an action on one or more instances.
+
+        Args:
+            id_list: Single instance ID or list of instance IDs to act upon.
+            action: Action to perform on the instances.
+            volume_ids: Optional list of volume IDs to delete.
+
+        Raises:
+            HTTPError: If the action fails or other API error occurs.
         """
         if type(id_list) is str:
             id_list = [id_list]
@@ -464,34 +207,31 @@ class InstancesService:
         self._http_client.put(INSTANCES_ENDPOINT, json=payload)
         return
 
-    # TODO: use enum/const for location_code
-    def is_available(self, instance_type: str, is_spot: bool = False, location_code: str = None) -> bool:
-        """Returns True if a specific instance type is now available for deployment
-
-        :param instance_type: instance type
-        :type instance_type: str
-        :param is_spot: Is spot instance
-        :type is_spot: bool, optional
-        :param location_code: datacenter location, defaults to "FIN-01"
-        :type location_code: str, optional
-        :return: True if available to deploy, False otherwise
-        :rtype: bool
+    def is_available(self, instance_type: str, is_spot: bool = False, location_code: Optional[str] = None) -> bool:
+        """Checks if a specific instance type is available for deployment.
+
+        Args:
+            instance_type: Type of instance to check availability for.
+            is_spot: Whether to check spot instance availability.
+            location_code: Optional datacenter location code.
+
+        Returns:
+            True if the instance type is available, False otherwise.
         """
         is_spot = str(is_spot).lower()
         query_params = {'isSpot': is_spot, 'location_code': location_code}
         url = f'/instance-availability/{instance_type}'
         return self._http_client.get(url, query_params).json()
 
-    # TODO: use enum/const for location_code
-    def get_availabilities(self, is_spot: bool = None, location_code: str = None) -> bool:
-        """Returns a list of available instance types
+    def get_availabilities(self, is_spot: Optional[bool] = None, location_code: Optional[str] = None) -> List[Dict]:
+        """Retrieves a list of available instance types across locations.
+
+        Args:
+            is_spot: Optional flag to filter spot instance availability.
+            location_code: Optional datacenter location code to filter by.
 
-        :param is_spot: Is spot instance
-        :type is_spot: bool, optional
-        :param location_code: datacenter location, defaults to "FIN-01"
-        :type location_code: str, optional
-        :return: list of available instance types in every location
-        :rtype: list
+        Returns:
+            List of available instance types and their details.
         """
         is_spot = str(is_spot).lower() if is_spot is not None else None
         query_params = {'isSpot': is_spot, 'locationCode': location_code}

{datacrunch-1.10.0.dist-info → datacrunch-1.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datacrunch
-Version: 1.10.0
+Version: 1.12.0
 Summary: Official Python SDK for DataCrunch Public API
 Home-page: https://github.com/DataCrunch-io
 Author: DataCrunch Oy

{datacrunch-1.10.0.dist-info → datacrunch-1.12.0.dist-info}/RECORD

@@ -1,17 +1,17 @@
 datacrunch/__init__.py,sha256=OG-5Avmuq3NXyBs_66GMwyzscUi0c-T6vWW5sRIfnZg,51
-datacrunch/__version__.py,sha256=VntYBWPvXjh_VXu4WVj3EEodB6Jeg2IODCkHTuqpLfc,19
-datacrunch/constants.py,sha256=uBtS1kTe6ip5oWzA4SKAVftdapkKwUU45GdLYOuBzAA,2354
+datacrunch/__version__.py,sha256=o_CvBCGiCiaIWFGapX_FcRb3zCO9gmamKVsYWQWdAmY,19
+datacrunch/constants.py,sha256=i0jCX91H2lKp1Uvk4GDsaTeXk0WmjyeSGpMfPs69BB4,2378
 datacrunch/datacrunch.py,sha256=2IqrTY39sLuwtuQ_QP3jCI1d5AaCwriYgAUEFoZZzPU,3488
 datacrunch/exceptions.py,sha256=uOP_YU2HEUi_mcMxQ9WYrIjqWUuUrwdube-RdL1C4Ps,781
 datacrunch/helpers.py,sha256=Eq5htNxpJUCJG9D6QxbnWwch3ppmi2lfi-rFCGXf3fs,634
 datacrunch/InferenceClient/__init__.py,sha256=oe7RQfoKbKJnIFWOt6TNtdzjXk5Gcl4-smO5DjLE6M0,117
-datacrunch/InferenceClient/inference_client.py,sha256=x3nWsQc5ds_ndXINdfk0KVW_R_rito_ArLouug0C_rI,14174
+datacrunch/InferenceClient/inference_client.py,sha256=CM-ijRQuvaSf8BSbltkeocaIBvsAoBKT7xxnOT1q-Xs,15555
 datacrunch/authentication/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datacrunch/authentication/authentication.py,sha256=CThTxA99jseh7TKIdUR1M9RErIJoXvTB8CbF1VGFPCE,3589
 datacrunch/balance/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datacrunch/balance/balance.py,sha256=rkqqXC3MLVxk6ym9Hlp9tsLbLWJculIn8q3BYbsme28,1240
 datacrunch/containers/__init__.py,sha256=T9ROCN-a3rQfboTk3mol4OUhi6FMo5wUqahJZOBg0uw,675
-datacrunch/containers/containers.py,sha256=6KXt3OFvcagXlgL7peWTVgqcFwVRsfrEAFQXtsqX64U,31283
+datacrunch/containers/containers.py,sha256=xGDlHi8nAbYZyP039_VbNba_Z0Mk-RI1N3XlHISM3Ao,33167
 datacrunch/http_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datacrunch/http_client/http_client.py,sha256=tmpVd3p7-NAIaTM4E13inFZWUetdVEFZnRE38p5eVk0,8285
 datacrunch/images/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -19,7 +19,7 @@ datacrunch/images/images.py,sha256=hCAtSzozHcAAJ_UZOvnAbQSEU7BfCuixpIsmcd2RM2k,2
 datacrunch/instance_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datacrunch/instance_types/instance_types.py,sha256=NLkUI6UdfXg-zDkMu9j9RzVISLG8jdABhT_R7XpfBdA,5289
 datacrunch/instances/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datacrunch/instances/instances.py,sha256=DAjFSQPwugN4_u-13Q9K4gyjrPYwdTrIw2exHwhJ1bw,16626
+datacrunch/instances/instances.py,sha256=GKPpZshn5JBsduR5zyT57fonB0GDdOLkPfPmGqgJQow,9239
 datacrunch/locations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datacrunch/locations/locations.py,sha256=2f1OF2ObNaqGam_Mm0Btie1GymnAI9UzXulhqSSm7zo,404
 datacrunch/ssh_keys/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -30,7 +30,7 @@ datacrunch/volume_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG
 datacrunch/volume_types/volume_types.py,sha256=CNJ8kfd_nxmF99x-UAJeku-uN4Gdh-yg15Aa8WGLgWU,1828
 datacrunch/volumes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datacrunch/volumes/volumes.py,sha256=aAH4UIVG-7NehjHu-a_4MGSdZ1jmeApV-kKh-X6TB-s,11908
-datacrunch-1.10.0.dist-info/licenses/LICENSE,sha256=LkdhbR2MArjDfV8M0dySL5mG_kfzxF2ntMgbJvWGyUQ,1069
+datacrunch-1.12.0.dist-info/licenses/LICENSE,sha256=LkdhbR2MArjDfV8M0dySL5mG_kfzxF2ntMgbJvWGyUQ,1069
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/integration_tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/integration_tests/conftest.py,sha256=PWf6K1G3NoddebmDIy_Pk02dHQrEKfrNxpWwqE8Eqrk,546
@@ -46,7 +46,7 @@ tests/unit_tests/authentication/test_authentication.py,sha256=P84VnD9utk8y3ZPhUf
 tests/unit_tests/balance/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/unit_tests/balance/test_balance.py,sha256=Cojbjd7wc9-8eRQb_fR0xLXEX7fGqobdQICH3O7WAx4,651
 tests/unit_tests/containers/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
-tests/unit_tests/containers/test_containers.py,sha256=T23I-Sb0VbCJAeIYwFniW9XELrNvL06A7lycU2MyL84,30977
+tests/unit_tests/containers/test_containers.py,sha256=lr7Thrpl5hC6iBG91YjBUEpkv6t6CVnXjIzkXmvXg0U,31011
 tests/unit_tests/http_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/unit_tests/http_client/test_http_client.py,sha256=JfEy7pADx0gS9KNNwVLVeG-bG4DRRXxze4dQkP_WIvw,6776
 tests/unit_tests/images/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -63,7 +63,7 @@ tests/unit_tests/volume_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5N
 tests/unit_tests/volume_types/test_volume_types.py,sha256=vGuC3dWjhQLD8bTYgw_we3dZ6vlUKRmKZbb9yCfhe0w,1386
 tests/unit_tests/volumes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/unit_tests/volumes/test_volumes.py,sha256=p53eSIHddWKL7U9oLLTnxo849LrJSoi6A5lpWF6ydHs,20672
-datacrunch-1.10.0.dist-info/METADATA,sha256=SZ0jATJaVzH7jJ-jc7vRcQfIN-RUTe85nwCpu4w-YrM,6261
-datacrunch-1.10.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-datacrunch-1.10.0.dist-info/top_level.txt,sha256=FvH4EZJkbUxNm-aKx0RjmWwnduAMpfRT13Fo123i7yE,17
-datacrunch-1.10.0.dist-info/RECORD,,
+datacrunch-1.12.0.dist-info/METADATA,sha256=EoUDXb19WnnqRmbjakFTxgSlC_BAThYyCWLMfHuqz3I,6261
+datacrunch-1.12.0.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+datacrunch-1.12.0.dist-info/top_level.txt,sha256=FvH4EZJkbUxNm-aKx0RjmWwnduAMpfRT13Fo123i7yE,17
+datacrunch-1.12.0.dist-info/RECORD,,

{datacrunch-1.10.0.dist-info → datacrunch-1.12.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (80.4.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

tests/unit_tests/containers/test_containers.py

@@ -134,7 +134,8 @@ COMPUTE_RESOURCES_DATA = [
 SECRETS_DATA = [
     {
         "name": SECRET_NAME,
-        "created_at": "2023-01-01T00:00:00+00:00"
+        "created_at": "2023-01-01T00:00:00+00:00",
+        "secret_type": "generic"
     }
 ]