verda 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

verda/datacrunch.py

@@ -0,0 +1,43 @@
+# Frozen, minimal compatibility layer for old DataCrunch API
+
+from verda import DataCrunchClient
+from verda._version import __version__
+from verda.authentication.authentication import AuthenticationService
+from verda.balance.balance import BalanceService
+from verda.constants import Constants
+from verda.containers.containers import ContainersService
+from verda.http_client.http_client import HTTPClient
+from verda.images.images import ImagesService
+from verda.instance_types.instance_types import InstanceTypesService
+from verda.instances.instances import InstancesService
+from verda.locations.locations import LocationsService
+from verda.ssh_keys.ssh_keys import SSHKeysService
+from verda.startup_scripts.startup_scripts import StartupScriptsService
+from verda.volume_types.volume_types import VolumeTypesService
+from verda.volumes.volumes import VolumesService
+
+__all__ = [
+    'AuthenticationService',
+    'BalanceService',
+    'Constants',
+    'ContainersService',
+    'DataCrunchClient',
+    'HTTPClient',
+    'ImagesService',
+    'InstanceTypesService',
+    'InstancesService',
+    'LocationsService',
+    'SSHKeysService',
+    'StartupScriptsService',
+    'VolumeTypesService',
+    'VolumesService',
+    '__version__',
+]
+
+import warnings
+
+warnings.warn(
+    'datacrunch.datacrunch is deprecated; use `from verda` instead.',
+    DeprecationWarning,
+    stacklevel=2,
+)

verda/exceptions.py

@@ -0,0 +1,30 @@
+class APIException(Exception):
+    """This exception is raised if there was an error from verda'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:
+        """API Exception.
+
+        :param code: error code
+        :type code: str
+        :param message: error message
+        :type message: str
+        """
+        self.code = code
+        """Error code. should be available in VerdaClient.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

verda/helpers.py

@@ -0,0 +1,17 @@
+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__()  # noqa: A001
+        if property[:1] != '_' and type(getattr(class_object, property, '')).__name__ != 'method'
+    }
+    return json.dumps(class_properties, indent=2)

verda/http_client/http_client.py

@@ -0,0 +1,246 @@
+import json
+
+import requests
+
+from verda._version import __version__
+from verda.exceptions import APIException
+
+
+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 = None, params: dict | None = 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 = None, params: dict | None = 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 = 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 = None, params: dict | None = 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 = None, params: dict | None = 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

verda/images/images.py

@@ -0,0 +1,88 @@
+from verda.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 = [
+            Image(image['id'], image['name'], image['image_type'], image['details'])
+            for image in images
+        ]
+        return image_objects

verda/instance_types/instance_types.py

@@ -0,0 +1,67 @@
+from dataclasses import dataclass
+
+from dataclasses_json import dataclass_json
+
+INSTANCE_TYPES_ENDPOINT = '/instance-types'
+
+
+@dataclass_json
+@dataclass
+class InstanceType:
+    """Instance type.
+
+    Attributes:
+        id: instance type id.
+        instance_type: instance type, e.g. '8V100.48M'.
+        price_per_hour: instance type price per hour.
+        spot_price_per_hour: instance type spot price per hour.
+        description: instance type description.
+        cpu: instance type cpu details.
+        gpu: instance type gpu details.
+        memory: instance type memory details.
+        gpu_memory: instance type gpu memory details.
+        storage: instance type storage details.
+    """
+
+    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
+
+
+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 = [
+            InstanceType(
+                id=instance_type['id'],
+                instance_type=instance_type['instance_type'],
+                price_per_hour=float(instance_type['price_per_hour']),
+                spot_price_per_hour=float(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'],
+            )
+            for instance_type in instance_types
+        ]
+
+        return instance_type_objects