datacrunch 1.14.0__py3-none-any.whl → 1.16.0__py3-none-any.whl

datacrunch/http_client/http_client.py

@@ -2,7 +2,7 @@ import requests
 import json
 
 from datacrunch.exceptions import APIException
-from datacrunch.__version__ import VERSION
+from datacrunch._version import __version__
 
 
 def handle_error(response: requests.Response) -> None:
@@ -27,7 +27,7 @@ class HTTPClient:
     """
 
     def __init__(self, auth_service, base_url: str) -> None:
-        self._version = VERSION
+        self._version = __version__
         self._base_url = base_url
         self._auth_service = auth_service
         self._auth_service.authenticate()
@@ -56,8 +56,7 @@ class HTTPClient:
         url = self._add_base_url(url)
         headers = self._generate_headers()
 
-        response = requests.post(
-            url, json=json, headers=headers, params=params, **kwargs)
+        response = requests.post(url, json=json, headers=headers, params=params, **kwargs)
         handle_error(response)
 
         return response
@@ -86,8 +85,7 @@ class HTTPClient:
         url = self._add_base_url(url)
         headers = self._generate_headers()
 
-        response = requests.put(
-            url, json=json, headers=headers, params=params, **kwargs)
+        response = requests.put(url, json=json, headers=headers, params=params, **kwargs)
         handle_error(response)
 
         return response
@@ -119,7 +117,9 @@ class HTTPClient:
 
         return response
 
-    def patch(self, url: str, json: dict = None, params: dict = None, **kwargs) -> requests.Response:
+    def patch(
+        self, url: str, json: dict = None, params: dict = None, **kwargs
+    ) -> requests.Response:
         """Sends a PATCH request.
 
         A wrapper for the requests.patch method.
@@ -143,13 +143,14 @@ class HTTPClient:
         url = self._add_base_url(url)
         headers = self._generate_headers()
 
-        response = requests.patch(
-            url, json=json, headers=headers, params=params, **kwargs)
+        response = requests.patch(url, json=json, headers=headers, params=params, **kwargs)
         handle_error(response)
 
         return response
 
-    def delete(self, url: str, json: dict = None, params: dict = None, **kwargs) -> requests.Response:
+    def delete(
+        self, url: str, json: dict = None, params: dict = None, **kwargs
+    ) -> requests.Response:
         """Sends a DELETE request.
 
         A wrapper for the requests.delete method.
@@ -173,8 +174,7 @@ class HTTPClient:
         url = self._add_base_url(url)
         headers = self._generate_headers()
 
-        response = requests.delete(
-            url, headers=headers, json=json, params=params, **kwargs)
+        response = requests.delete(url, headers=headers, json=json, params=params, **kwargs)
         handle_error(response)
 
         return response
@@ -186,7 +186,7 @@ class HTTPClient:
 
         :raises APIException: an api exception with message and error type code
         """
-        if (self._auth_service.is_expired()):
+        if self._auth_service.is_expired():
             # try to refresh. if refresh token has expired, reauthenticate
             try:
                 self._auth_service.refresh()
@@ -202,7 +202,7 @@ class HTTPClient:
         headers = {
             'Authorization': self._generate_bearer_header(),
             'User-Agent': self._generate_user_agent(),
-            'Content-Type': 'application/json'
+            'Content-Type': 'application/json',
         }
         return headers
 

datacrunch/images/images.py

@@ -76,12 +76,18 @@ class ImagesService:
         self._http_client = http_client
 
     def get(self) -> List[Image]:
-        """Get the available instance images 
+        """Get the available instance images
 
         :return: list of images objects
         :rtype: List[Image]
         """
         images = self._http_client.get(IMAGES_ENDPOINT).json()
-        image_objects = list(map(lambda image: Image(
-            image['id'], image['name'], image['image_type'], image['details']), images))
+        image_objects = list(
+            map(
+                lambda image: Image(
+                    image['id'], image['name'], image['image_type'], image['details']
+                ),
+                images,
+            )
+        )
         return image_objects

datacrunch/instance_types/instance_types.py

@@ -4,18 +4,19 @@ INSTANCE_TYPES_ENDPOINT = '/instance-types'
 
 
 class InstanceType:
-
-    def __init__(self,
-                 id: str,
-                 instance_type: str,
-                 price_per_hour: float,
-                 spot_price_per_hour: float,
-                 description: str,
-                 cpu: dict,
-                 gpu: dict,
-                 memory: dict,
-                 gpu_memory: dict,
-                 storage: dict) -> None:
+    def __init__(
+        self,
+        id: str,
+        instance_type: str,
+        price_per_hour: float,
+        spot_price_per_hour: float,
+        description: str,
+        cpu: dict,
+        gpu: dict,
+        memory: dict,
+        gpu_memory: dict,
+        storage: dict,
+    ) -> None:
         """Initialize an instance type object
 
         :param id: instance type id
@@ -146,17 +147,18 @@ class InstanceType:
         :return: instance type string representation
         :rtype: str
         """
-        return (f'id: {self._id}\n'
-                f'instance type: {self._instance_type}\n'
-                f'price_per_hour: ${self._price_per_hour}\n'
-                f'spot_price_per_hour: ${self._spot_price_per_hour}\n'
-                f'description: {self._description}\n'
-                f'cpu: {self._cpu}\n'
-                f'gpu: {self._gpu}\n'
-                f'memory :{self._memory}\n'
-                f'gpu_memory :{self._gpu_memory}\n'
-                f'storage :{self._storage}\n'
-                )
+        return (
+            f'id: {self._id}\n'
+            f'instance type: {self._instance_type}\n'
+            f'price_per_hour: ${self._price_per_hour}\n'
+            f'spot_price_per_hour: ${self._spot_price_per_hour}\n'
+            f'description: {self._description}\n'
+            f'cpu: {self._cpu}\n'
+            f'gpu: {self._gpu}\n'
+            f'memory :{self._memory}\n'
+            f'gpu_memory :{self._gpu_memory}\n'
+            f'storage :{self._storage}\n'
+        )
 
 
 class InstanceTypesService:
@@ -172,17 +174,22 @@ class InstanceTypesService:
         :rtype: List[InstanceType]
         """
         instance_types = self._http_client.get(INSTANCE_TYPES_ENDPOINT).json()
-        instance_type_objects = list(map(lambda instance_type: InstanceType(
-            id=instance_type['id'],
-            instance_type=instance_type['instance_type'],
-            price_per_hour=instance_type['price_per_hour'],
-            spot_price_per_hour=instance_type['spot_price'],
-            description=instance_type['description'],
-            cpu=instance_type['cpu'],
-            gpu=instance_type['gpu'],
-            memory=instance_type['memory'],
-            gpu_memory=instance_type['gpu_memory'],
-            storage=instance_type['storage']
-        ), instance_types))
+        instance_type_objects = list(
+            map(
+                lambda instance_type: InstanceType(
+                    id=instance_type['id'],
+                    instance_type=instance_type['instance_type'],
+                    price_per_hour=instance_type['price_per_hour'],
+                    spot_price_per_hour=instance_type['spot_price'],
+                    description=instance_type['description'],
+                    cpu=instance_type['cpu'],
+                    gpu=instance_type['gpu'],
+                    memory=instance_type['memory'],
+                    gpu_memory=instance_type['gpu_memory'],
+                    storage=instance_type['storage'],
+                ),
+                instance_types,
+            )
+        )
 
         return instance_type_objects

datacrunch/instances/instances.py

@@ -1,4 +1,5 @@
 import time
+import itertools
 from typing import List, Union, Optional, Dict, Literal
 from dataclasses import dataclass
 from dataclasses_json import dataclass_json
@@ -31,7 +32,7 @@ class Instance:
         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).
+        location: Datacenter location code (default: Locations.FIN_03).
         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.
@@ -56,7 +57,7 @@ class Instance:
     ip: Optional[str] = None
     # Can be None if instance is still not provisioned
     os_volume_id: Optional[str] = None
-    location: str = Locations.FIN_01
+    location: str = Locations.FIN_03
     image: Optional[str] = None
     startup_script_id: Optional[str] = None
     is_spot: bool = False
@@ -89,9 +90,11 @@ class InstancesService:
         Returns:
             List of instance objects matching the criteria.
         """
-        instances_dict = self._http_client.get(
-            INSTANCES_ENDPOINT, params={'status': status}).json()
-        return [Instance.from_dict(instance_dict, infer_missing=True) for instance_dict in instances_dict]
+        instances_dict = self._http_client.get(INSTANCES_ENDPOINT, params={'status': status}).json()
+        return [
+            Instance.from_dict(instance_dict, infer_missing=True)
+            for instance_dict in instances_dict
+        ]
 
     def get_by_id(self, id: str) -> Instance:
         """Retrieves a specific instance by its ID.
@@ -105,25 +108,31 @@ class InstancesService:
         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_dict = self._http_client.get(INSTANCES_ENDPOINT + f'/{id}').json()
         return Instance.from_dict(instance_dict, infer_missing=True)
 
-    def create(self,
-               instance_type: str,
-               image: str,
-               hostname: str,
-               description: str,
-               ssh_key_ids: list = [],
-               location: str = Locations.FIN_01,
-               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: Optional[Contract] = None,
-               pricing: Optional[Pricing] = None,
-               coupon: Optional[str] = None) -> Instance:
+    def create(
+        self,
+        instance_type: str,
+        image: str,
+        hostname: str,
+        description: str,
+        ssh_key_ids: list = [],
+        location: str = Locations.FIN_03,
+        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: Optional[Contract] = None,
+        pricing: Optional[Pricing] = None,
+        coupon: Optional[str] = None,
+        *,
+        max_wait_time: float = 180,
+        initial_interval: float = 0.5,
+        max_interval: float = 5,
+        backoff_coefficient: float = 2.0,
+    ) -> Instance:
         """Creates and deploys a new cloud instance.
 
         Args:
@@ -132,7 +141,7 @@ class InstancesService:
             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).
+            location: Datacenter location code (default: Locations.FIN_03).
             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.
@@ -141,6 +150,10 @@ class InstancesService:
             contract: Optional contract type for the instance.
             pricing: Optional pricing model for the instance.
             coupon: Optional coupon code for discounts.
+            max_wait_time: Maximum total wait for the instance to start provisioning, in seconds (default: 180)
+            initial_interval: Initial interval, in seconds (default: 0.5)
+            max_interval: The longest single delay allowed between retries, in seconds (default: 5)
+            backoff_coefficient: Coefficient to calculate the next retry interval (default 2.0)
 
         Returns:
             The newly created instance object.
@@ -149,18 +162,18 @@ class InstancesService:
             HTTPError: If instance creation fails or other API error occurs.
         """
         payload = {
-            "instance_type": instance_type,
-            "image": image,
-            "ssh_key_ids": ssh_key_ids,
-            "startup_script_id": startup_script_id,
-            "hostname": hostname,
-            "description": description,
-            "location_code": location,
-            "os_volume": os_volume,
-            "volumes": volumes,
-            "existing_volumes": existing_volumes,
-            "is_spot": is_spot,
-            "coupon": coupon,
+            'instance_type': instance_type,
+            'image': image,
+            'ssh_key_ids': ssh_key_ids,
+            'startup_script_id': startup_script_id,
+            'hostname': hostname,
+            'description': description,
+            'location_code': location,
+            'os_volume': os_volume,
+            'volumes': volumes,
+            'existing_volumes': existing_volumes,
+            'is_spot': is_spot,
+            'coupon': coupon,
         }
         if contract:
             payload['contract'] = contract
@@ -169,22 +182,27 @@ class InstancesService:
         id = self._http_client.post(INSTANCES_ENDPOINT, json=payload).text
 
         # 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:
+        deadline = time.monotonic() + max_wait_time
+        for i in itertools.count():
             instance = self.get_by_id(id)
             if instance.status != InstanceStatus.ORDERED:
                 return instance
 
-            if time.time() - start_time > MAX_WAIT_TIME:
+            now = time.monotonic()
+            if now >= deadline:
                 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:
+                    f'Instance {id} did not enter provisioning state within {max_wait_time:.1f} seconds'
+                )
+
+            interval = min(initial_interval * backoff_coefficient**i, max_interval, deadline - now)
+            time.sleep(interval)
+
+    def action(
+        self,
+        id_list: Union[List[str], str],
+        action: str,
+        volume_ids: Optional[List[str]] = None,
+    ) -> None:
         """Performs an action on one or more instances.
 
         Args:
@@ -198,16 +216,17 @@ class InstancesService:
         if type(id_list) is str:
             id_list = [id_list]
 
-        payload = {
-            "id": id_list,
-            "action": action,
-            "volume_ids": volume_ids
-        }
+        payload = {'id': id_list, 'action': action, 'volume_ids': volume_ids}
 
         self._http_client.put(INSTANCES_ENDPOINT, json=payload)
         return
 
-    def is_available(self, instance_type: str, is_spot: bool = False, location_code: Optional[str] = None) -> 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:
@@ -223,7 +242,9 @@ class InstancesService:
         url = f'/instance-availability/{instance_type}'
         return self._http_client.get(url, query_params).json()
 
-    def get_availabilities(self, is_spot: Optional[bool] = None, location_code: Optional[str] = None) -> List[Dict]:
+    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:

datacrunch/locations/locations.py

@@ -10,7 +10,6 @@ class LocationsService:
         self._http_client = http_client
 
     def get(self) -> List[dict]:
-        """Get all locations
-        """
+        """Get all locations"""
         locations = self._http_client.get(LOCATIONS_ENDPOINT).json()
         return locations

datacrunch/ssh_keys/ssh_keys.py

@@ -61,8 +61,7 @@ class SSHKeysService:
         :rtype: List[SSHKey]
         """
         keys = self._http_client.get(SSHKEYS_ENDPOINT).json()
-        keys_object_list = list(map(lambda key: SSHKey(
-            key['id'], key['name'], key['key']), keys))
+        keys_object_list = list(map(lambda key: SSHKey(key['id'], key['name'], key['key']), keys))
 
         return keys_object_list
 
@@ -84,7 +83,7 @@ class SSHKeysService:
         :param id_list: list of SSH keys ids
         :type id_list: List[str]
         """
-        payload = {"keys": id_list}
+        payload = {'keys': id_list}
         self._http_client.delete(SSHKEYS_ENDPOINT, json=payload)
         return
 
@@ -107,6 +106,6 @@ class SSHKeysService:
         :return: new SSH key object
         :rtype: SSHKey
         """
-        payload = {"name": name, "key": key}
+        payload = {'name': name, 'key': key}
         id = self._http_client.post(SSHKEYS_ENDPOINT, json=payload).text
         return SSHKey(id, name, key)

datacrunch/startup_scripts/startup_scripts.py

@@ -61,8 +61,12 @@ class StartupScriptsService:
         :rtype: List[StartupScript]
         """
         scripts = self._http_client.get(STARTUP_SCRIPTS_ENDPOINT).json()
-        scripts_objects = list(map(lambda script: StartupScript(
-            script['id'], script['name'], script['script']), scripts))
+        scripts_objects = list(
+            map(
+                lambda script: StartupScript(script['id'], script['name'], script['script']),
+                scripts,
+            )
+        )
         return scripts_objects
 
     def get_by_id(self, id) -> StartupScript:
@@ -73,8 +77,7 @@ class StartupScriptsService:
         :return: startup script object
         :rtype: StartupScript
         """
-        script = self._http_client.get(
-            STARTUP_SCRIPTS_ENDPOINT + f'/{id}').json()[0]
+        script = self._http_client.get(STARTUP_SCRIPTS_ENDPOINT + f'/{id}').json()[0]
 
         return StartupScript(script['id'], script['name'], script['script'])
 
@@ -84,7 +87,7 @@ class StartupScriptsService:
         :param id_list: list of startup scripts ids
         :type id_list: List[str]
         """
-        payload = {"scripts": id_list}
+        payload = {'scripts': id_list}
         self._http_client.delete(STARTUP_SCRIPTS_ENDPOINT, json=payload)
         return
 
@@ -107,7 +110,6 @@ class StartupScriptsService:
         :return: the new startup script's id
         :rtype: str
         """
-        payload = {"name": name, "script": script}
-        id = self._http_client.post(
-            STARTUP_SCRIPTS_ENDPOINT, json=payload).text
+        payload = {'name': name, 'script': script}
+        id = self._http_client.post(STARTUP_SCRIPTS_ENDPOINT, json=payload).text
         return StartupScript(id, name, script)

datacrunch/volume_types/volume_types.py

@@ -4,10 +4,7 @@ VOLUME_TYPES_ENDPOINT = '/volume-types'
 
 
 class VolumeType:
-
-    def __init__(self,
-                 type: str,
-                 price_per_month_per_gb: float) -> None:
+    def __init__(self, type: str, price_per_month_per_gb: float) -> None:
         """Initialize a volume type object
 
         :param type: volume type name
@@ -58,9 +55,14 @@ class VolumeTypesService:
         :rtype: List[VolumesType]
         """
         volume_types = self._http_client.get(VOLUME_TYPES_ENDPOINT).json()
-        volume_type_objects = list(map(lambda volume_type: VolumeType(
-            type=volume_type['type'],
-            price_per_month_per_gb=volume_type['price']['price_per_month_per_gb'],
-        ), volume_types))
+        volume_type_objects = list(
+            map(
+                lambda volume_type: VolumeType(
+                    type=volume_type['type'],
+                    price_per_month_per_gb=volume_type['price']['price_per_month_per_gb'],
+                ),
+                volume_types,
+            )
+        )
 
         return volume_type_objects