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

datacrunch/volumes/volumes.py

@@ -1,385 +0,0 @@
-from typing import List, Union, Optional
-from datacrunch.constants import VolumeActions, Locations
-from datacrunch.helpers import stringify_class_object_properties
-
-VOLUMES_ENDPOINT = '/volumes'
-
-
-class Volume:
-    """A volume model class"""
-
-    def __init__(
-        self,
-        id: str,
-        status: str,
-        name: str,
-        size: int,
-        type: str,
-        is_os_volume: bool,
-        created_at: str,
-        target: str = None,
-        location: str = Locations.FIN_03,
-        instance_id: str = None,
-        ssh_key_ids: List[str] = [],
-        deleted_at: str = None,
-    ) -> None:
-        """Initialize the volume object
-
-        :param id: volume id
-        :type id: str
-        :param status: volume status
-        :type status: str
-        :param name: volume name
-        :type name: str
-        :param size: volume size in GB
-        :type size: int
-        :param type: volume type
-        :type type: str
-        :param is_os_volume: indication whether this is an operating systen volume
-        :type is_os_volume: bool
-        :param created_at: the time the volume was created (UTC)
-        :type created_at: str
-        :param target: target device e.g. vda
-        :type target: str, optional
-        :param location: datacenter location, defaults to "FIN-03"
-        :type location: str, optional
-        :param instance_id: the instance id the volume is attached to, None if detached
-        :type instance_id: str
-        :param ssh_key_ids: list of ssh keys ids
-        :type ssh_key_ids: List[str]
-        :param deleted_at: the time the volume was deleted (UTC), defaults to None
-        :type deleted_at: str, optional
-        """
-        self._id = id
-        self._status = status
-        self._name = name
-        self._size = size
-        self._type = type
-        self._is_os_volume = is_os_volume
-        self._created_at = created_at
-        self._target = target
-        self._location = location
-        self._instance_id = instance_id
-        self._ssh_key_ids = ssh_key_ids
-        self._deleted_at = deleted_at
-
-    @property
-    def id(self) -> str:
-        """Get the volume id
-
-        :return: volume id
-        :rtype: str
-        """
-        return self._id
-
-    @property
-    def status(self) -> str:
-        """Get the volume status
-
-        :return: volume status
-        :rtype: str
-        """
-        return self._status
-
-    @property
-    def name(self) -> str:
-        """Get the volume name
-
-        :return: volume name
-        :rtype: str
-        """
-        return self._name
-
-    @property
-    def size(self) -> int:
-        """Get the volume size
-
-        :return: volume size
-        :rtype: int
-        """
-        return self._size
-
-    @property
-    def type(self) -> int:
-        """Get the volume type
-
-        :return: volume type
-        :rtype: string
-        """
-        return self._type
-
-    @property
-    def is_os_volume(self) -> bool:
-        """Return true iff the volume contains an operating system
-
-        :return: true iff the volume contains an OS
-        :rtype: bool
-        """
-        return self._is_os_volume
-
-    @property
-    def created_at(self) -> str:
-        """Get the time when the volume was created (UTC)
-
-        :return: time
-        :rtype: str
-        """
-        return self._created_at
-
-    @property
-    def target(self) -> Optional[str]:
-        """Get the target device
-
-        :return: target device
-        :rtype: str, optional
-        """
-        return self._target
-
-    @property
-    def location(self) -> str:
-        """Get the volume datacenter location
-
-        :return: datacenter location
-        :rtype: str
-        """
-        return self._location
-
-    @property
-    def instance_id(self) -> Optional[str]:
-        """Get the instance id the volume is attached to, if attached. Otherwise None
-
-        :return: instance id if attached, None otherwise
-        :rtype: str, optional
-        """
-        return self._instance_id
-
-    @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 deleted_at(self) -> Optional[str]:
-        """Get the time when the volume was deleted (UTC)
-
-        :return: time
-        :rtype: str
-        """
-        return self._deleted_at
-
-    @classmethod
-    def create_from_dict(cls: 'Volume', volume_dict: dict) -> 'Volume':
-        """Create a Volume object from a dictionary
-
-        :param volume_dict: dictionary representing the volume
-        :type volume_dict: dict
-        :return: Volume
-        :rtype: Volume
-        """
-
-        return cls(
-            id=volume_dict['id'],
-            status=volume_dict['status'],
-            name=volume_dict['name'],
-            size=volume_dict['size'],
-            type=volume_dict['type'],
-            is_os_volume=volume_dict['is_os_volume'],
-            created_at=volume_dict['created_at'],
-            target=volume_dict['target'],
-            location=volume_dict['location'],
-            instance_id=volume_dict['instance_id'],
-            ssh_key_ids=volume_dict['ssh_key_ids'],
-            deleted_at=volume_dict.get('deleted_at'),
-        )
-
-    def __str__(self) -> str:
-        """Returns a string of the json representation of the volume
-
-        :return: json representation of the volume
-        :rtype: str
-        """
-        return stringify_class_object_properties(self)
-
-
-class VolumesService:
-    """A service for interacting with the volumes endpoint"""
-
-    def __init__(self, http_client) -> None:
-        self._http_client = http_client
-
-    def get(self, status: str = None) -> List[Volume]:
-        """Get all of the client's non-deleted volumes, or volumes with specific status.
-
-        :param status: optional, status of the volumes, defaults to None
-        :type status: str, optional
-        :return: list of volume details objects
-        :rtype: List[Volume]
-        """
-        volumes_dict = self._http_client.get(VOLUMES_ENDPOINT, params={'status': status}).json()
-        return list(map(Volume.create_from_dict, volumes_dict))
-
-    def get_by_id(self, id: str) -> Volume:
-        """Get a specific volume by its
-
-        :param id: volume id
-        :type id: str
-        :return: Volume details object
-        :rtype: Volume
-        """
-        volume_dict = self._http_client.get(VOLUMES_ENDPOINT + f'/{id}').json()
-
-        return Volume.create_from_dict(volume_dict)
-
-    def get_in_trash(self) -> List[Volume]:
-        """Get all volumes that are in trash
-
-        :return: list of volume details objects
-        :rtype: List[Volume]
-        """
-        volumes_dicts = self._http_client.get(VOLUMES_ENDPOINT + '/trash').json()
-
-        return list(map(Volume.create_from_dict, volumes_dicts))
-
-    def create(
-        self,
-        type: str,
-        name: str,
-        size: int,
-        instance_id: str = None,
-        location: str = Locations.FIN_03,
-    ) -> Volume:
-        """Create new volume
-
-        :param type: volume type
-        :type type: str
-        :param name: volume name
-        :type name: str
-        :param size: volume size, in GB
-        :type size: int
-        :param instance_id: Instance id to be attached to, defaults to None
-        :type instance_id: str, optional
-        :param location: datacenter location, defaults to "FIN-03"
-        :type location: str, optional
-        :return: the new volume object
-        :rtype: Volume
-        """
-        payload = {
-            'type': type,
-            'name': name,
-            'size': size,
-            'instance_id': instance_id,
-            'location_code': location,
-        }
-        id = self._http_client.post(VOLUMES_ENDPOINT, json=payload).text
-        volume = self.get_by_id(id)
-        return volume
-
-    def attach(self, id_list: Union[List[str], str], instance_id: str) -> None:
-        """Attach multiple volumes or single volume to an instance
-        Note: the instance needs to be shut-down (offline)
-
-        :param id_list: list of volume ids, or a volume id
-        :type id_list: Union[List[str], str]
-        :param instance_id: instance id the volume(s) will be attached to
-        :type instance_id: str
-        """
-        payload = {
-            'id': id_list,
-            'action': VolumeActions.ATTACH,
-            'instance_id': instance_id,
-        }
-
-        self._http_client.put(VOLUMES_ENDPOINT, json=payload)
-        return
-
-    def detach(self, id_list: Union[List[str], str]) -> None:
-        """Detach multiple volumes or single volume from an instance(s)
-        Note: the instances need to be shut-down (offline)
-
-        :param id_list: list of volume ids, or a volume id
-        :type id_list: Union[List[str], str]
-        """
-        payload = {
-            'id': id_list,
-            'action': VolumeActions.DETACH,
-        }
-
-        self._http_client.put(VOLUMES_ENDPOINT, json=payload)
-        return
-
-    def clone(self, id: str, name: str = None, type: str = None) -> Volume:
-        """Clone a volume or multiple volumes
-
-        :param id: volume id or list of volume ids
-        :type id: str or List[str]
-        :param name: new volume name
-        :type name: str
-        :param type: volume type
-        :type type: str, optional
-        :return: the new volume object, or a list of volume objects if cloned mutliple volumes
-        :rtype: Volume or List[Volume]
-        """
-        payload = {'id': id, 'action': VolumeActions.CLONE, 'name': name, 'type': type}
-
-        # clone volume(s)
-        volume_ids_array = self._http_client.put(VOLUMES_ENDPOINT, json=payload).json()
-
-        # map the IDs into Volume objects
-        volumes_array = list(map(lambda volume_id: self.get_by_id(volume_id), volume_ids_array))
-
-        # if the array has only one element, return that element
-        if len(volumes_array) == 1:
-            return volumes_array[0]
-
-        # otherwise return the volumes array
-        return volumes_array
-
-    def rename(self, id_list: Union[List[str], str], name: str) -> None:
-        """Rename multiple volumes or single volume
-
-        :param id_list: list of volume ids, or a volume id
-        :type id_list: Union[List[str], str]
-        :param name: new name
-        :type name: str
-        """
-        payload = {'id': id_list, 'action': VolumeActions.RENAME, 'name': name}
-
-        self._http_client.put(VOLUMES_ENDPOINT, json=payload)
-        return
-
-    def increase_size(self, id_list: Union[List[str], str], size: int) -> None:
-        """Increase size of multiple volumes or single volume
-
-        :param id_list: list of volume ids, or a volume id
-        :type id_list: Union[List[str], str]
-        :param size: new size in GB
-        :type size: int
-        """
-        payload = {
-            'id': id_list,
-            'action': VolumeActions.INCREASE_SIZE,
-            'size': size,
-        }
-
-        self._http_client.put(VOLUMES_ENDPOINT, json=payload)
-        return
-
-    def delete(self, id_list: Union[List[str], str], is_permanent: bool = False) -> None:
-        """Delete multiple volumes or single volume
-        Note: if attached to any instances, they need to be shut-down (offline)
-
-        :param id_list: list of volume ids, or a volume id
-        :type id_list: Union[List[str], str]
-        """
-        payload = {
-            'id': id_list,
-            'action': VolumeActions.DELETE,
-            'is_permanent': is_permanent,
-        }
-
-        self._http_client.put(VOLUMES_ENDPOINT, json=payload)
-        return

datacrunch-1.16.0.dist-info/METADATA

@@ -1,182 +0,0 @@
-Metadata-Version: 2.3
-Name: datacrunch
-Version: 1.16.0
-Summary: Official Python SDK for DataCrunch Public API
-Author: DataCrunch Oy
-Author-email: DataCrunch Oy <info@datacrunch.io>
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Natural Language :: English
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Requires-Dist: requests>=2.25.1,<3
-Requires-Dist: dataclasses-json>=0.6.7
-Requires-Python: >=3.11
-Project-URL: Changelog, https://datacrunch-python.readthedocs.io/en/latest/changelog.html
-Project-URL: Documentation, https://datacrunch-python.readthedocs.io/
-Project-URL: Homepage, https://github.com/DataCrunch-io
-Project-URL: Repository, https://github.com/DataCrunch-io/datacrunch-python
-Description-Content-Type: text/markdown
-
-# DataCrunch Python SDK
-
-[<img src='https://github.com/DataCrunch-io/datacrunch-python/workflows/Unit%20Tests/badge.svg'>](https://github.com/DataCrunch-io/datacrunch-python/actions?query=workflow%3A%22Unit+Tests%22+branch%3Amaster)
-[<img src='https://github.com/DataCrunch-io/datacrunch-python/workflows/Code%20Style/badge.svg'>](https://github.com/DataCrunch-io/datacrunch-python/actions?query=workflow%3A%22Code+Style%22+branch%3Amaster)
-[<img src="https://codecov.io/gh/DataCrunch-io/datacrunch-python/branch/master/graph/badge.svg?token=5X5KTYSSPK">](https://codecov.io/gh/DataCrunch-io/datacrunch-python)
-[<img src='https://readthedocs.org/projects/datacrunch-python/badge/?version=latest'>](https://datacrunch-python.readthedocs.io/en/latest/)
-[<img src='https://img.shields.io/github/license/DataCrunch-io/datacrunch-python'>](https://github.com/DataCrunch-io/datacrunch-python/blob/master/LICENSE)
-[<img src='https://img.shields.io/pypi/v/datacrunch?logo=python'>](https://pypi.org/project/datacrunch/)
-[<img src='https://img.shields.io/pypi/pyversions/datacrunch'>](https://pypi.org/project/datacrunch/)
-
-The official [DataCrunch.io](https://datacrunch.io) Python SDK.
-
-The SDK's documentation is available on [ReadTheDocs](https://datacrunch-python.readthedocs.io/en/latest/)
-
-DataCrunch's Public API documentation [is available here](https://api.datacrunch.io/v1/docs).
-
-## Getting Started - Using the SDK:
-
-- Install:
-
-  ```bash
-  # via pip
-  pip3 install datacrunch
-
-  # via uv
-  uv add datacrunch
-  ```
-
-- Generate your client credentials - [instructions in the public API docs](https://api.datacrunch.io/v1/docs#description/quick-start-guide).
-
-
-- Add your client id and client secret to an environment variable (don't want it to be hardcoded):
-
-  Linux (bash):
-
-  ```bash
-  export DATACRUNCH_CLIENT_ID=YOUR_ID_HERE
-  export DATACRUNCH_CLIENT_SECRET=YOUR_SECRET_HERE
-  ```
-
-- To enable sending inference requests from SDK you must generate an inference key - [Instructions on inference authorization](https://docs.datacrunch.io/inference/authorization)
-  
-
-- Add your inference key to an environment variable
-
-  Linux (bash):
- 
-  ```bash
-  export DATACRUNCH_INFERENCE_KEY=YOUR_API_KEY_HERE
-  ```
-  
-  Other platforms:
-  https://en.wikipedia.org/wiki/Environment_variable
-
-
-
-- Example for creating a new instance:
-
-  ```python
-  import os
-  from datacrunch import DataCrunchClient
-
-  # Get credentials from environment variables
-  CLIENT_ID = os.environ.get('DATACRUNCH_CLIENT_ID')
-  CLIENT_SECRET = os.environ['DATACRUNCH_CLIENT_SECRET']
-
-  # Create datcrunch client
-  datacrunch = DataCrunchClient(CLIENT_ID, CLIENT_SECRET)
-
-  # Get all SSH keys
-  ssh_keys = datacrunch.ssh_keys.get()
-  ssh_keys = list(map(lambda key: key.id, ssh_keys))
-
-  # Create a new instance
-  instance = datacrunch.instances.create(instance_type='1V100.6V',
-                                        image='ubuntu-24.04-cuda-12.8-open-docker',
-                                        ssh_key_ids=ssh_keys,
-                                        hostname='example',
-                                        description='example instance')
-
-  # Delete instance
-  datacrunch.instances.action(instance.id, datacrunch.constants.instance_actions.DELETE)
-  ```
-
-  More examples can be found in the `/examples` folder or in the [documentation](https://datacrunch-python.readthedocs.io/en/latest/).
-
-## Development
-
-### Set up the local development environment
-
-Prerequisite: install [`uv`](https://docs.astral.sh/uv/).
-
-Clone the repository, create local environment and install dependencies:
-
-  ```bash
-  git clone git@github.com:DataCrunch-io/datacrunch-python.git
-  cd datacrunch-python
-  uv sync
-  ```
-
-### Run Tests
-
-- Execute all tests
-
-  ```bash
-  uv run pytest
-  ```
-
-- Execute a single test file
-
-  ```bash
-  uv run pytest tests/unit_tests/test_file.py
-  ```
-
-### Local Manual Testing
-
-Create a file in the root directory of the project:
-
-```python
-# example.py
-from datacrunch.datacrunch import DataCrunchClient
-
-CLIENT_SECRET = 'secret'
-CLIENT_ID = 'your-id'
-
-# Create datacrunch client
-datacrunch = DataCrunchClient(CLIENT_ID, CLIENT_SECRET, base_url='http://localhost:3001/v1')
-```
-
-Run it:
-
-```bash
-uv run python example.py
-```
-
-### Generating the documentation
-
-If added a new service, create a documentation template under api/services for that service.
-
-```bash
-cd docs
-make html
-```
-
-### Code style
-
-```bash
-# Lint
-uv run ruff check
-
-# Format code
-uv run ruff format
-```
-
-## Contact
-
-You can [contact us here](https://datacrunch.io/contact), or open an issue in the repo.

datacrunch-1.16.0.dist-info/RECORD

@@ -1,35 +0,0 @@
-datacrunch/InferenceClient/__init__.py,sha256=oe7RQfoKbKJnIFWOt6TNtdzjXk5Gcl4-smO5DjLE6M0,117
-datacrunch/InferenceClient/inference_client.py,sha256=GYjUshs2e2zKKw1B3KU8Dt2jr8kSt8QKRtML-Ce96GE,16907
-datacrunch/__init__.py,sha256=ssI1WpIpRQhdwiO_3kYVtS7h9ePGZ5sgTyRieTYhllU,96
-datacrunch/_version.py,sha256=5vv5w-bgsYeQlFvxgfqpdPWtyGiNYqDZyagqHmT6AwM,165
-datacrunch/authentication/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datacrunch/authentication/authentication.py,sha256=ksjcEKhx6xhbp86EnWuKHqHeFy7of_FAR7x1BS-hMbE,3508
-datacrunch/balance/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datacrunch/balance/balance.py,sha256=PT-d4JHCRiHJIk0K1Hi0v_R8CeDqa6000zfBSNV4nWE,1215
-datacrunch/constants.py,sha256=p7l9xNByisNVlXwy2jQskCxI1zU9bbTtq1hYgGXz2QE,2432
-datacrunch/containers/__init__.py,sha256=qNxgk3tS9Dx251ugXjmsDWeab2MO7EAFLd6aRo1XpmQ,744
-datacrunch/containers/containers.py,sha256=RJnMsTtQqDbWC_i0GqdKuQDtuFtziPW2kiP13MYuIos,35775
-datacrunch/datacrunch.py,sha256=U7kqcdt2hrG27M8a1dEbCWFo-eL_h71yMSX4vW-K2qA,3454
-datacrunch/exceptions.py,sha256=uOP_YU2HEUi_mcMxQ9WYrIjqWUuUrwdube-RdL1C4Ps,781
-datacrunch/helpers.py,sha256=OOG5B25q1tpDqa_6zen4C-nLEnPbI2sJGGC-btoZiRk,666
-datacrunch/http_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datacrunch/http_client/http_client.py,sha256=KjmAKhSgDFdps6Z4z2RqJIHpOannUkwQF8PvvntGHEM,8265
-datacrunch/images/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datacrunch/images/images.py,sha256=PmJZrX4qYAyeE4cwcfM2PWwNNN6aSFlAjEo578qP8h8,2260
-datacrunch/instance_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datacrunch/instance_types/instance_types.py,sha256=cHGLx5nSNGQhLL5WglJN5iYfUDoe9jSgzr9R7pwgIkk,5340
-datacrunch/instances/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datacrunch/instances/instances.py,sha256=VU7fxMFrT_x9u_xZP_WYrYR6U3Z6jSKlfODXL3KMODc,9813
-datacrunch/locations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datacrunch/locations/locations.py,sha256=tcmLrvyo6WaR-6YJ0Hr5vf_GqXjDzLTToybl5dYosgo,395
-datacrunch/ssh_keys/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datacrunch/ssh_keys/ssh_keys.py,sha256=YD9QnsvWAKC6i2RIxF9fo1u2Z9ayxj3jVZgyUxqvYVs,2894
-datacrunch/startup_scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datacrunch/startup_scripts/startup_scripts.py,sha256=vqEYOwRf2luaS_m0jrGbLtWu7HZpt-IfzXbhJ7DH_b8,3202
-datacrunch/volume_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datacrunch/volume_types/volume_types.py,sha256=KPNAUtvlZkYbX1IIBiAELVst8bU71v4MwztxLhKQHlI,1886
-datacrunch/volumes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datacrunch/volumes/volumes.py,sha256=UiuKBRv4dTEsJrEWSTMQyVurb9WZrLJy42pmYGmWL5o,11560
-datacrunch-1.16.0.dist-info/WHEEL,sha256=M6du7VZflc4UPsGphmOXHANdgk8zessdJG0DBUuoA-U,78
-datacrunch-1.16.0.dist-info/METADATA,sha256=momu6xw9SXypuLyhwtNfoHB6-0NYOMAuQBnuOFBPvqE,5673
-datacrunch-1.16.0.dist-info/RECORD,,