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

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,93 +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,195 +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