datacrunch 1.10.0__tar.gz → 1.11.0__tar.gz

{datacrunch-1.10.0 → datacrunch-1.11.0}/PKG-INFO

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

{datacrunch-1.10.0 → datacrunch-1.11.0}/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-1.11.0/datacrunch/__version__.py

@@ -0,0 +1 @@
+VERSION = '1.11.0'

{datacrunch-1.10.0 → datacrunch-1.11.0}/datacrunch/constants.py

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

datacrunch-1.11.0/datacrunch/instances/instances.py

@@ -0,0 +1,238 @@
+import time
+from typing import List, Union, Optional, Dict, Literal
+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']
+
+
+@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
+
+
+class InstancesService:
+    """Service for managing cloud instances through the API.
+
+    This service provides methods to create, retrieve, and manage cloud instances
+    through the DataCrunch API.
+    """
+
+    def __init__(self, http_client) -> None:
+        """Initializes the InstancesService with an HTTP client.
+
+        Args:
+            http_client: HTTP client for making API requests.
+        """
+        self._http_client = http_client
+
+    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.
+
+        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]
+
+    def get_by_id(self, id: str) -> Instance:
+        """Retrieves a specific instance by its ID.
+
+        Args:
+            id: Unique identifier of the instance to retrieve.
+
+        Returns:
+            Instance object with the specified ID.
+
+        Raises:
+            HTTPError: If the instance is not found or other API error occurs.
+        """
+        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:
+        """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,
+            "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
+        if pricing:
+            payload['pricing'] = pricing
+        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:
+            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 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]
+
+        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:
+        """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()
+
+    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.
+
+        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}
+        return self._http_client.get('/instance-availability', params=query_params).json()

{datacrunch-1.10.0 → datacrunch-1.11.0}/datacrunch.egg-info/PKG-INFO

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

datacrunch-1.10.0/datacrunch/__version__.py

@@ -1 +0,0 @@
-VERSION = '1.10.0'

datacrunch-1.10.0/datacrunch/instances/instances.py

@@ -1,498 +0,0 @@
-from typing import List, Union, Optional, Dict, Literal
-from datacrunch.helpers import stringify_class_object_properties
-from datacrunch.constants import Locations
-
-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
-
-    @property
-    def contract(self) -> bool:
-        """Get contract type
-
-        :return: contract type
-        :rtype: str
-        """
-        return self._contract
-
-    @property
-    def pricing(self) -> bool:
-        """Get pricing type
-
-        :return: pricing type
-        :rtype: str
-        """
-        return self._pricing
-
-    def __str__(self) -> str:
-        """Returns a string of the json representation of the instance
-
-        :return: json representation of the instance
-        :rtype: str
-        """
-        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.
-
-        :param status: optional, status of the instances, defaults to None
-        :type status: str, optional
-        :return: list of instance details objects
-        :rtype: List[Instance]
-        """
-        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
-
-    def get_by_id(self, id: str) -> Instance:
-        """Get an instance with specified id.
-
-        :param id: instance id
-        :type id: str
-        :return: instance details object
-        :rtype: Instance
-        """
-        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
-
-    def create(self,
-               instance_type: str,
-               image: str,
-               hostname: str,
-               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,
-               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
-        """
-        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,
-        }
-        if contract:
-            payload['contract'] = contract
-        if pricing:
-            payload['pricing'] = pricing
-        id = self._http_client.post(INSTANCES_ENDPOINT, json=payload).text
-        instance = self.get_by_id(id)
-        return instance
-
-    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]]
-        """
-        if type(id_list) is str:
-            id_list = [id_list]
-
-        payload = {
-            "id": id_list,
-            "action": action,
-            "volume_ids": volume_ids
-        }
-
-        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
-        """
-        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
-
-        :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
-        """
-        is_spot = str(is_spot).lower() if is_spot is not None else None
-        query_params = {'isSpot': is_spot, 'locationCode': location_code}
-        return self._http_client.get('/instance-availability', params=query_params).json()