datacrunch 1.15.0__py3-none-any.whl → 1.17.1__py3-none-any.whl

datacrunch/exceptions.py

@@ -1,29 +0,0 @@
-class APIException(Exception):
-    """This exception is raised if there was an error from datacrunch's API.
-    Could be an invalid input, token etc.
-
-    Raised when an API HTTP call response has a status code >= 400
-    """
-
-    def __init__(self, code: str, message: str) -> None:
-        """
-
-        :param code: error code
-        :type code: str
-        :param message: error message
-        :type message: str
-        """
-        self.code = code
-        """Error code. should be available in DataCrunchClient.error_codes"""
-
-        self.message = message
-        """Error message
-        """
-
-    def __str__(self) -> str:
-        msg = ''
-        if self.code:
-            msg = f'error code: {self.code}\n'
-
-        msg += f'message: {self.message}'
-        return msg

datacrunch/helpers.py

@@ -1,13 +0,0 @@
-from typing import Type
-import json
-
-def stringify_class_object_properties(class_object: Type) -> str:
-    """Generates a json string representation of a class object's properties and values
-
-    :param class_object: An instance of a class
-    :type class_object: Type
-    :return: _description_
-    :rtype: json string representation of a class object's properties and values
-    """
-    class_properties = {property: getattr(class_object, property, '') for property in class_object.__dir__() if property[:1] != '_' and type(getattr(class_object, property, '')).__name__ != 'method'}
-    return json.dumps(class_properties, indent=2)

datacrunch/http_client/http_client.py

@@ -1,241 +0,0 @@
-import requests
-import json
-
-from datacrunch.exceptions import APIException
-from datacrunch.__version__ import VERSION
-
-
-def handle_error(response: requests.Response) -> None:
-    """checks for the response status code and raises an exception if it's 400 or higher.
-
-    :param response: the API call response
-    :raises APIException: an api exception with message and error type code
-    """
-    if not response.ok:
-        data = json.loads(response.text)
-        code = data['code'] if 'code' in data else None
-        message = data['message'] if 'message' in data else None
-        raise APIException(code, message)
-
-
-class HTTPClient:
-    """An http client, a wrapper for the requests library.
-
-    For each request, it adds the authentication header with an access token.
-    If the access token is expired it refreshes it before calling the specified API endpoint.
-    Also checks the response status code and raises an exception if needed.
-    """
-
-    def __init__(self, auth_service, base_url: str) -> None:
-        self._version = VERSION
-        self._base_url = base_url
-        self._auth_service = auth_service
-        self._auth_service.authenticate()
-
-    def post(self, url: str, json: dict = None, params: dict = None, **kwargs) -> requests.Response:
-        """Sends a POST request.
-
-        A wrapper for the requests.post method.
-
-        Builds the url, uses custom headers, refresh tokens if needed.
-
-        :param url: relative url of the API endpoint
-        :type url: str
-        :param json: A JSON serializable Python object to send in the body of the Request, defaults to None
-        :type json: dict, optional
-        :param params: Dictionary of querystring data to attach to the Request, defaults to None
-        :type params: dict, optional
-
-        :raises APIException: an api exception with message and error type code
-
-        :return: Response object
-        :rtype: requests.Response
-        """
-        self._refresh_token_if_expired()
-
-        url = self._add_base_url(url)
-        headers = self._generate_headers()
-
-        response = requests.post(
-            url, json=json, headers=headers, params=params, **kwargs)
-        handle_error(response)
-
-        return response
-
-    def put(self, url: str, json: dict = None, params: dict = None, **kwargs) -> requests.Response:
-        """Sends a PUT request.
-
-        A wrapper for the requests.put method.
-
-        Builds the url, uses custom headers, refresh tokens if needed.
-
-        :param url: relative url of the API endpoint
-        :type url: str
-        :param json: A JSON serializable Python object to send in the body of the Request, defaults to None
-        :type json: dict, optional
-        :param params: Dictionary of querystring data to attach to the Request, defaults to None
-        :type params: dict, optional
-
-        :raises APIException: an api exception with message and error type code
-
-        :return: Response object
-        :rtype: requests.Response
-        """
-        self._refresh_token_if_expired()
-
-        url = self._add_base_url(url)
-        headers = self._generate_headers()
-
-        response = requests.put(
-            url, json=json, headers=headers, params=params, **kwargs)
-        handle_error(response)
-
-        return response
-
-    def get(self, url: str, params: dict = None, **kwargs) -> requests.Response:
-        """Sends a GET request.
-
-        A wrapper for the requests.get method.
-
-        Builds the url, uses custom headers, refresh tokens if needed.
-
-        :param url: relative url of the API endpoint
-        :type url: str
-        :param params: Dictionary of querystring data to attach to the Request, defaults to None
-        :type params: dict, optional
-
-        :raises APIException: an api exception with message and error type code
-
-        :return: Response object
-        :rtype: requests.Response
-        """
-        self._refresh_token_if_expired()
-
-        url = self._add_base_url(url)
-        headers = self._generate_headers()
-
-        response = requests.get(url, params=params, headers=headers, **kwargs)
-        handle_error(response)
-
-        return 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.
-
-        Builds the url, uses custom headers, refresh tokens if needed.
-
-        :param url: relative url of the API endpoint
-        :type url: str
-        :param json: A JSON serializable Python object to send in the body of the Request, defaults to None
-        :type json: dict, optional
-        :param params: Dictionary of querystring data to attach to the Request, defaults to None
-        :type params: dict, optional
-
-        :raises APIException: an api exception with message and error type code
-
-        :return: Response object
-        :rtype: requests.Response
-        """
-        self._refresh_token_if_expired()
-
-        url = self._add_base_url(url)
-        headers = self._generate_headers()
-
-        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:
-        """Sends a DELETE request.
-
-        A wrapper for the requests.delete method.
-
-        Builds the url, uses custom headers, refresh tokens if needed.
-
-        :param url: relative url of the API endpoint
-        :type url: str
-        :param json: A JSON serializable Python object to send in the body of the Request, defaults to None
-        :type json: dict, optional
-        :param params: Dictionary of querystring data to attach to the Request, defaults to None
-        :type params: dict, optional
-
-        :raises APIException: an api exception with message and error type code
-
-        :return: Response object
-        :rtype: requests.Response
-        """
-        self._refresh_token_if_expired()
-
-        url = self._add_base_url(url)
-        headers = self._generate_headers()
-
-        response = requests.delete(
-            url, headers=headers, json=json, params=params, **kwargs)
-        handle_error(response)
-
-        return response
-
-    def _refresh_token_if_expired(self) -> None:
-        """refreshes the access token if it expired.
-
-        Uses the refresh token to refresh, and if the refresh token is also expired, uses the client credentials.
-
-        :raises APIException: an api exception with message and error type code
-        """
-        if (self._auth_service.is_expired()):
-            # try to refresh. if refresh token has expired, reauthenticate
-            try:
-                self._auth_service.refresh()
-            except Exception:
-                self._auth_service.authenticate()
-
-    def _generate_headers(self) -> dict:
-        """generate the default headers for every request
-
-        :return: dict with request headers
-        :rtype: dict
-        """
-        headers = {
-            'Authorization': self._generate_bearer_header(),
-            'User-Agent': self._generate_user_agent(),
-            'Content-Type': 'application/json'
-        }
-        return headers
-
-    def _generate_bearer_header(self) -> str:
-        """generate the authorization header Bearer string
-
-        :return: Authorization header Bearer string
-        :rtype: str
-        """
-        return f'Bearer {self._auth_service._access_token}'
-
-    def _generate_user_agent(self) -> str:
-        """generate the user agent string.
-
-        :return: user agent string
-        :rtype: str
-        """
-        # get the first 10 chars of the client id
-        client_id_truncated = self._auth_service._client_id[:10]
-
-        return f'datacrunch-python-v{self._version}-{client_id_truncated}'
-
-    def _add_base_url(self, url: str) -> str:
-        """Adds the base url to the relative url
-
-        example:
-        if the relative url is '/balance'
-        and the base url is 'https://api.datacrunch.io/v1'
-        then this method will return 'https://api.datacrunch.io/v1/balance'
-
-        :param url: a relative url path
-        :type url: str
-        :return: the full url path
-        :rtype: str
-        """
-        return self._base_url + url

datacrunch/images/images.py

@@ -1,87 +0,0 @@
-from typing import List
-from datacrunch.helpers import stringify_class_object_properties
-
-IMAGES_ENDPOINT = '/images'
-
-
-class Image:
-    """An image model class"""
-
-    def __init__(self, id: str, name: str, image_type: str, details: List[str]) -> None:
-        """Initialize an image object
-
-        :param id: image id
-        :type id: str
-        :param name: image name
-        :type name: str
-        :param image_type: image type, e.g. 'ubuntu-20.04-cuda-11.0'
-        :type image_type: str
-        :param details: image details
-        :type details: List[str]
-        """
-        self._id = id
-        self._name = name
-        self._image_type = image_type
-        self._details = details
-
-    @property
-    def id(self) -> str:
-        """Get the image id
-
-        :return: image id
-        :rtype: str
-        """
-        return self._id
-
-    @property
-    def name(self) -> str:
-        """Get the image name
-
-        :return: image name
-        :rtype: str
-        """
-        return self._name
-
-    @property
-    def image_type(self) -> str:
-        """Get the image type
-
-        :return: image type
-        :rtype: str
-        """
-        return self._image_type
-
-    @property
-    def details(self) -> List[str]:
-        """Get the image details
-
-        :return: image details
-        :rtype: List[str]
-        """
-        return self._details
-
-    def __str__(self) -> str:
-        """Returns a string of the json representation of the image
-
-        :return: json representation of the image
-        :rtype: str
-        """
-        return stringify_class_object_properties(self)
-
-
-class ImagesService:
-    """A service for interacting with the images endpoint"""
-
-    def __init__(self, http_client) -> None:
-        self._http_client = http_client
-
-    def get(self) -> List[Image]:
-        """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))
-        return image_objects

datacrunch/instance_types/instance_types.py

@@ -1,188 +0,0 @@
-from typing import List
-
-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:
-        """Initialize an instance type object
-
-        :param id: instance type id
-        :type id: str
-        :param instance_type: instance type. e.g. '8V100.48M'
-        :type instance_type: str
-        :param price_per_hour: price per hour
-        :type price_per_hour: float
-        :param spot_price_per_hour: spot price per hour
-        :type spot_price_per_hour: float
-        :param description: instance type description
-        :type description: str
-        :param cpu: cpu details
-        :type cpu: dict
-        :param gpu: gpu details
-        :type gpu: dict
-        :param memory: memory details
-        :type memory: dict
-        :param gpu_memory: gpu memory details
-        :type gpu_memory: dict
-        :param storage: storage details
-        :type storage: dict
-        """
-        self._id = id
-        self._instance_type = instance_type
-        self._price_per_hour = float(price_per_hour)
-        self._spot_price_per_hour = float(spot_price_per_hour)
-        self._description = description
-        self._cpu = cpu
-        self._gpu = gpu
-        self._memory = memory
-        self._gpu_memory = gpu_memory
-        self._storage = storage
-
-    @property
-    def id(self) -> str:
-        """Get the instance type id
-
-        :return: instance type id
-        :rtype: str
-        """
-        return self._id
-
-    @property
-    def instance_type(self) -> str:
-        """Get the instance type
-
-        :return: instance type. e.g. '8V100.48M'
-        :rtype: str
-        """
-        return self._instance_type
-
-    @property
-    def price_per_hour(self) -> float:
-        """Get the instance type price per hour
-
-        :return: price per hour
-        :rtype: float
-        """
-        return self._price_per_hour
-
-    @property
-    def spot_price_per_hour(self) -> float:
-        """Get the instance spot price per hour
-
-        :return: spot price per hour
-        :rtype: float
-        """
-        return self._spot_price_per_hour
-
-    @property
-    def description(self) -> str:
-        """Get the instance type description
-
-        :return: instance type description
-        :rtype: str
-        """
-        return self._description
-
-    @property
-    def cpu(self) -> dict:
-        """Get the instance type cpu details
-
-        :return: cpu details
-        :rtype: dict
-        """
-        return self._cpu
-
-    @property
-    def gpu(self) -> dict:
-        """Get the instance type gpu details
-
-        :return: gpu details
-        :rtype: dict
-        """
-        return self._gpu
-
-    @property
-    def memory(self) -> dict:
-        """Get the instance type memory details
-
-        :return: memory details
-        :rtype: dict
-        """
-        return self._memory
-
-    @property
-    def gpu_memory(self) -> dict:
-        """Get the instance type gpu_memory details
-
-        :return: gpu_memory details
-        :rtype: dict
-        """
-        return self._gpu_memory
-
-    @property
-    def storage(self) -> dict:
-        """Get the instance type storage details
-
-        :return: storage details
-        :rtype: dict
-        """
-        return self._storage
-
-    def __str__(self) -> str:
-        """Prints the instance type
-
-        :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'
-                )
-
-
-class InstanceTypesService:
-    """A service for interacting with the instance-types endpoint"""
-
-    def __init__(self, http_client) -> None:
-        self._http_client = http_client
-
-    def get(self) -> List[InstanceType]:
-        """Get all instance types
-
-        :return: list of instance type objects
-        :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))
-
-        return instance_type_objects