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

datacrunch/__init__.py

@@ -1 +1,53 @@
-from datacrunch.datacrunch import DataCrunchClient
+# Compatibility layer for deprecated `datacrunch` package
+
+from verda import (
+    InferenceClient,
+    __version__,
+    authentication,
+    balance,
+    constants,
+    containers,
+    exceptions,
+    helpers,
+    http_client,
+    images,
+    instance_types,
+    instances,
+    locations,
+    ssh_keys,
+    startup_scripts,
+    volume_types,
+    volumes,
+)
+from verda import VerdaClient as DataCrunchClient
+
+# For old `from datacrunch import *``
+__all__ = [
+    'DataCrunchClient',
+    'InferenceClient',
+    '__version__',
+    'authentication',
+    'balance',
+    'constants',
+    'containers',
+    'datacrunch',
+    'exceptions',
+    'helpers',
+    'http_client',
+    'images',
+    'instance_types',
+    'instances',
+    'locations',
+    'ssh_keys',
+    'startup_scripts',
+    'volume_types',
+    'volumes',
+]
+
+import warnings
+
+warnings.warn(
+    'datacrunch is deprecated; use verda package instead: https://github.com/verda-cloud/sdk-python/blob/master/CHANGELOG.md#1170---2025-11-26',
+    DeprecationWarning,
+    stacklevel=2,
+)

datacrunch/datacrunch.py

@@ -1,81 +1,44 @@
-from datacrunch.authentication.authentication import AuthenticationService
-from datacrunch.balance.balance import BalanceService
-from datacrunch.http_client.http_client import HTTPClient
-from datacrunch.images.images import ImagesService
-from datacrunch.instance_types.instance_types import InstanceTypesService
-from datacrunch.instances.instances import InstancesService
-from datacrunch.ssh_keys.ssh_keys import SSHKeysService
-from datacrunch.startup_scripts.startup_scripts import StartupScriptsService
-from datacrunch.volume_types.volume_types import VolumeTypesService
-from datacrunch.volumes.volumes import VolumesService
-from datacrunch.containers.containers import ContainersService
-from datacrunch.constants import Constants
-from datacrunch.locations.locations import LocationsService
-from datacrunch.__version__ import VERSION
-
-
-class DataCrunchClient:
-    """Client for interacting with DataCrunch's public API"""
-
-    def __init__(self, client_id: str, client_secret: str, base_url: str = "https://api.datacrunch.io/v1", inference_key: str = None) -> None:
-        """The DataCrunch client
-
-        :param client_id: client id
-        :type client_id: str
-        :param client_secret: client secret
-        :type client_secret: str
-        :param base_url: base url for all the endpoints, optional, defaults to "https://api.datacrunch.io/v1"
-        :type base_url: str, optional
-        :param inference_key: inference key, optional
-        :type inference_key: str, optional
-        """
-
-        # Validate that client_id and client_secret are not empty
-        if not client_id or not client_secret:
-            raise ValueError(
-                "client_id and client_secret must be provided")
-
-        # Constants
-        self.constants: Constants = Constants(base_url, VERSION)
-        """Constants"""
-
-        # Services
-        self._authentication: AuthenticationService = AuthenticationService(
-            client_id, client_secret, self.constants.base_url)
-        self._http_client: HTTPClient = HTTPClient(
-            self._authentication, self.constants.base_url)
-
-        self.balance: BalanceService = BalanceService(self._http_client)
-        """Balance service. Get client balance"""
-
-        self.images: ImagesService = ImagesService(self._http_client)
-        """Image service"""
-
-        self.instance_types: InstanceTypesService = InstanceTypesService(
-            self._http_client)
-        """Instance type service"""
-
-        self.instances: InstancesService = InstancesService(self._http_client)
-        """Instances service. Deploy, delete, hibernate (etc) instances"""
-
-        self.ssh_keys: SSHKeysService = SSHKeysService(self._http_client)
-        """SSH keys service"""
-
-        self.startup_scripts: StartupScriptsService = StartupScriptsService(
-            self._http_client)
-        """Startup Scripts service"""
-
-        self.volume_types: VolumeTypesService = VolumeTypesService(
-            self._http_client)
-        """Volume type service"""
-
-        self.volumes: VolumesService = VolumesService(self._http_client)
-        """Volume service. Create, attach, detach, get, rename, delete volumes"""
-
-        self.locations: LocationsService = LocationsService(
-            self._http_client)
-        """Locations service. Get locations"""
-
-        self.containers: ContainersService = ContainersService(
-            self._http_client, inference_key)
-        """Containers service. Deploy, manage, and monitor container deployments"""
+# Compatibility layer for deprecated `datacrunch.datacrunch` package
+
+from verda import VerdaClient as 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
+
+# for `from datacrunch.datacrunch import *`
+__all__ = [
+    'AuthenticationService',
+    'BalanceService',
+    'Constants',
+    'ContainersService',
+    'DataCrunchClient',
+    'HTTPClient',
+    'ImagesService',
+    'InstanceTypesService',
+    'InstancesService',
+    'LocationsService',
+    'SSHKeysService',
+    'StartupScriptsService',
+    'VolumeTypesService',
+    'VolumesService',
+    '__version__',
+]
+
+import warnings
+
+warnings.warn(
+    'datacrunch is deprecated; use verda package instead: https://github.com/verda-cloud/sdk-python/blob/master/CHANGELOG.md#1170---2025-11-26',
+    DeprecationWarning,
+    stacklevel=2,
+)

datacrunch-1.17.1.dist-info/METADATA

@@ -0,0 +1,30 @@
+Metadata-Version: 2.3
+Name: datacrunch
+Version: 1.17.1
+Summary: datacrunch is now verda
+Author: Verda Cloud Oy
+Author-email: Verda Cloud Oy <info@verda.com>
+Classifier: Development Status :: 7 - Inactive
+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.10
+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: verda==1.17.1
+Requires-Python: >=3.10
+Project-URL: Changelog, https://github.com/verda-cloud/sdk-python/blob/master/CHANGELOG.md
+Project-URL: Documentation, https://datacrunch-python.readthedocs.io/
+Project-URL: Homepage, https://github.com/verda-cloud
+Project-URL: Repository, https://github.com/verda-cloud/sdk-python
+Description-Content-Type: text/markdown
+
+# datacrunch is now verda
+
+This package has been [renamed](https://verda.com/blog/datacrunch-is-changing-its-name-to-verda). Use `pip install verda` or `uv add verda` instead.
+
+New package: https://pypi.org/project/verda/

datacrunch-1.17.1.dist-info/RECORD

@@ -0,0 +1,5 @@
+datacrunch/__init__.py,sha256=LLVG36knotjujxtucyiuLyCagKOQHCtuwMxgWXPkAOg,1034
+datacrunch/datacrunch.py,sha256=km7nY38skCriD4pfKsksTkvGeVUwWkMuQrzb-eQf0U8,1518
+datacrunch-1.17.1.dist-info/WHEEL,sha256=YUH1mBqsx8Dh2cQG2rlcuRYUhJddG9iClegy4IgnHik,79
+datacrunch-1.17.1.dist-info/METADATA,sha256=ur8v0nRpL7OXL5kIQBEw1rzv86xAl65MJ66eziVR1LQ,1287
+datacrunch-1.17.1.dist-info/RECORD,,

datacrunch-1.17.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.9.11
+Root-Is-Purelib: true
+Tag: py3-none-any

datacrunch/InferenceClient/__init__.py

@@ -1,3 +0,0 @@
-from .inference_client import InferenceClient, InferenceResponse
-
-__all__ = ['InferenceClient', 'InferenceResponse']

datacrunch/InferenceClient/inference_client.py

@@ -1,379 +0,0 @@
-from dataclasses import dataclass
-from dataclasses_json import dataclass_json, Undefined  # type: ignore
-import requests
-from requests.structures import CaseInsensitiveDict
-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(str, Enum):
-    Initialized = "Initialized"
-    Queue = "Queue"
-    Inference = "Inference"
-    Completed = "Completed"
-
-
-@dataclass_json(undefined=Undefined.EXCLUDE)
-@dataclass
-class InferenceResponse:
-    headers: CaseInsensitiveDict[str]
-    status_code: int
-    status_text: str
-    _original_response: requests.Response
-    _stream: bool = False
-
-    def _is_stream_response(self, headers: CaseInsensitiveDict[str]) -> bool:
-        """Check if the response headers indicate a streaming response.
-
-        Args:
-            headers: The response headers to check
-
-        Returns:
-            bool: True if the response is likely a stream, False otherwise
-        """
-        # Standard chunked transfer encoding
-        is_chunked_transfer = headers.get(
-            'Transfer-Encoding', '').lower() == 'chunked'
-        # Server-Sent Events content type
-        is_event_stream = headers.get(
-            'Content-Type', '').lower() == 'text/event-stream'
-        # NDJSON
-        is_ndjson = headers.get(
-            'Content-Type', '').lower() == 'application/x-ndjson'
-        # Stream JSON
-        is_stream_json = headers.get(
-            'Content-Type', '').lower() == 'application/stream+json'
-        # Keep-alive
-        is_keep_alive = headers.get(
-            'Connection', '').lower() == 'keep-alive'
-        # No content length
-        has_no_content_length = 'Content-Length' not in headers
-
-        # No Content-Length with keep-alive often suggests streaming (though not definitive)
-        is_keep_alive_and_no_content_length = is_keep_alive and has_no_content_length
-
-        return (self._stream or is_chunked_transfer or is_event_stream or is_ndjson or
-                is_stream_json or is_keep_alive_and_no_content_length)
-
-    def output(self, is_text: bool = False) -> Any:
-        try:
-            if is_text:
-                return self._original_response.text
-            return self._original_response.json()
-        except Exception as e:
-            # if the response is a stream (check headers), raise relevant error
-            if self._is_stream_response(self._original_response.headers):
-                raise InferenceClientError(
-                    f"Response might be a stream, use the stream method instead")
-            raise InferenceClientError(
-                f"Failed to parse response as JSON: {str(e)}")
-
-    def stream(self, chunk_size: int = 512, as_text: bool = True) -> Generator[Any, None, None]:
-        """Stream the response content.
-
-        Args:
-            chunk_size: Size of chunks to stream, in bytes
-            as_text: If True, stream as text using iter_lines. If False, stream as binary using iter_content.
-
-        Returns:
-            Generator yielding chunks of the response
-        """
-        if as_text:
-            for chunk in self._original_response.iter_lines(chunk_size=chunk_size):
-                if chunk:
-                    yield chunk
-        else:
-            for chunk in self._original_response.iter_content(chunk_size=chunk_size):
-                if chunk:
-                    yield chunk
-
-
-class InferenceClient:
-    def __init__(self, inference_key: str, endpoint_base_url: str, timeout_seconds: int = 60 * 5) -> None:
-        """
-        Initialize the InferenceClient.
-
-        Args:
-            inference_key: The authentication key for the API
-            endpoint_base_url: The base URL for the API
-            timeout_seconds: Request timeout in seconds
-
-        Raises:
-            InferenceClientError: If the parameters are invalid
-        """
-        if not inference_key:
-            raise InferenceClientError("inference_key cannot be empty")
-
-        parsed_url = urlparse(endpoint_base_url)
-        if not parsed_url.scheme or not parsed_url.netloc:
-            raise InferenceClientError("endpoint_base_url must be a valid URL")
-
-        self.inference_key = inference_key
-        self.endpoint_base_url = endpoint_base_url.rstrip('/')
-        self.base_domain = self.endpoint_base_url[:self.endpoint_base_url.rindex(
-            '/')]
-        self.deployment_name = self.endpoint_base_url[self.endpoint_base_url.rindex(
-            '/')+1:]
-        self.timeout_seconds = timeout_seconds
-        self._session = requests.Session()
-        self._global_headers = {
-            'Authorization': f'Bearer {inference_key}',
-            'Content-Type': 'application/json'
-        }
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self._session.close()
-
-    @property
-    def global_headers(self) -> Dict[str, str]:
-        """
-        Get the current global headers that will be used for all requests.
-
-        Returns:
-            Dictionary of current global headers
-        """
-        return self._global_headers.copy()
-
-    def set_global_header(self, key: str, value: str) -> None:
-        """
-        Set or update a global header that will be used for all requests.
-
-        Args:
-            key: Header name
-            value: Header value
-        """
-        self._global_headers[key] = value
-
-    def set_global_headers(self, headers: Dict[str, str]) -> None:
-        """
-        Set multiple global headers at once that will be used for all requests.
-
-        Args:
-            headers: Dictionary of headers to set globally
-        """
-        self._global_headers.update(headers)
-
-    def remove_global_header(self, key: str) -> None:
-        """
-        Remove a global header.
-
-        Args:
-            key: Header name to remove from global headers
-        """
-        if key in self._global_headers:
-            del self._global_headers[key]
-
-    def _build_url(self, path: str) -> str:
-        """Construct the full URL by joining the base URL with the path."""
-        return f"{self.endpoint_base_url}/{path.lstrip('/')}"
-
-    def _build_request_headers(self, request_headers: Optional[Dict[str, str]] = None) -> Dict[str, str]:
-        """
-        Build the final headers by merging global headers with request-specific headers.
-
-        Args:
-            request_headers: Optional headers specific to this request
-
-        Returns:
-            Merged headers dictionary
-        """
-        headers = self._global_headers.copy()
-        if request_headers:
-            headers.update(request_headers)
-        return headers
-
-    def _make_request(self, method: str, path: str, **kwargs) -> requests.Response:
-        """
-        Make an HTTP request with error handling.
-
-        Args:
-            method: HTTP method to use
-            path: API endpoint path
-            **kwargs: Additional arguments to pass to the request
-
-        Returns:
-            Response object from the request
-
-        Raises:
-            InferenceClientError: If the request fails
-        """
-        timeout = kwargs.pop('timeout_seconds', self.timeout_seconds)
-        try:
-            response = self._session.request(
-                method=method,
-                url=self._build_url(path),
-                headers=self._build_request_headers(
-                    kwargs.pop('headers', None)),
-                timeout=timeout,
-                **kwargs
-            )
-            response.raise_for_status()
-            return response
-        except requests.exceptions.Timeout:
-            raise InferenceClientError(
-                f"Request to {path} timed out after {timeout} seconds")
-        except requests.exceptions.RequestException as e:
-            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)
-
-        return InferenceResponse(
-            headers=response.headers,
-            status_code=response.status_code,
-            status_text=response.reason,
-            _original_response=response
-        )
-
-    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:
-            # If no_response is True, use the "Prefer: respond-async-proxy" header to run async and don't wait for the response
-            headers['Prefer'] = 'respond-async-proxy'
-            self._make_request(
-                http_method, path, json=data, timeout_seconds=timeout_seconds, headers=headers)
-            return
-        # Add the "Prefer: respond-async" header to the request, to run async and wait for the response
-        headers['Prefer'] = 'respond-async'
-
-        response = self._make_request(
-            http_method, path, json=data, timeout_seconds=timeout_seconds, headers=headers)
-
-        result = response.json()
-        execution_id = result['Id']
-
-        return AsyncInferenceExecution(self, execution_id, AsyncStatus.Initialized)
-
-    def get(self, path: str, params: Optional[Dict[str, Any]] = None, headers: Optional[Dict[str, str]] = None, timeout_seconds: Optional[int] = None) -> requests.Response:
-        return self._make_request('GET', path, params=params, headers=headers, timeout_seconds=timeout_seconds)
-
-    def post(self, path: str, json: Optional[Dict[str, Any]] = None, data: Optional[Union[str, Dict[str, Any]]] = None,
-             params: Optional[Dict[str, Any]] = None, headers: Optional[Dict[str, str]] = None, timeout_seconds: Optional[int] = None) -> requests.Response:
-        return self._make_request('POST', path, json=json, data=data, params=params, headers=headers, timeout_seconds=timeout_seconds)
-
-    def put(self, path: str, json: Optional[Dict[str, Any]] = None, data: Optional[Union[str, Dict[str, Any]]] = None,
-            params: Optional[Dict[str, Any]] = None, headers: Optional[Dict[str, str]] = None, timeout_seconds: Optional[int] = None) -> requests.Response:
-        return self._make_request('PUT', path, json=json, data=data, params=params, headers=headers, timeout_seconds=timeout_seconds)
-
-    def delete(self, path: str, params: Optional[Dict[str, Any]] = None, headers: Optional[Dict[str, str]] = None, timeout_seconds: Optional[int] = None) -> requests.Response:
-        return self._make_request('DELETE', path, params=params, headers=headers, timeout_seconds=timeout_seconds)
-
-    def patch(self, path: str, json: Optional[Dict[str, Any]] = None, data: Optional[Union[str, Dict[str, Any]]] = None,
-              params: Optional[Dict[str, Any]] = None, headers: Optional[Dict[str, str]] = None, timeout_seconds: Optional[int] = None) -> requests.Response:
-        return self._make_request('PATCH', path, json=json, data=data, params=params, headers=headers, timeout_seconds=timeout_seconds)
-
-    def head(self, path: str, params: Optional[Dict[str, Any]] = None, headers: Optional[Dict[str, str]] = None, timeout_seconds: Optional[int] = None) -> requests.Response:
-        return self._make_request('HEAD', path, params=params, headers=headers, timeout_seconds=timeout_seconds)
-
-    def options(self, path: str, params: Optional[Dict[str, Any]] = None, headers: Optional[Dict[str, str]] = None, timeout_seconds: Optional[int] = None) -> requests.Response:
-        return self._make_request('OPTIONS', path, params=params, headers=headers, timeout_seconds=timeout_seconds)
-
-    def health(self, healthcheck_path: str = "/health") -> requests.Response:
-        """
-        Check the health status of the API.
-
-        Returns:
-            requests.Response: The response from the health check
-
-        Raises:
-            InferenceClientError: If the health check fails
-        """
-        try:
-            return self.get(healthcheck_path)
-        except InferenceClientError as e:
-            raise InferenceClientError(f"Health check failed: {str(e)}")
-
-
-@dataclass_json(undefined=Undefined.EXCLUDE)
-@dataclass
-class AsyncInferenceExecution:
-    _inference_client: 'InferenceClient'
-    id: str
-    _status: AsyncStatus
-    INFERENCE_ID_HEADER = 'X-Inference-Id'
-
-    def status(self) -> AsyncStatus:
-        """Get the current stored status of the async inference execution. Only the status value type
-
-        Returns:
-            AsyncStatus: The status object
-        """
-
-        return self._status
-
-    def status_json(self) -> Dict[str, Any]:
-        """Get the current status of the async inference execution. Return the status json
-
-        Returns:
-            Dict[str, Any]: The status response containing the execution status and other metadata
-        """
-        url = f'{self._inference_client.base_domain}/status/{self._inference_client.deployment_name}'
-        response = self._inference_client._session.get(
-            url, headers=self._inference_client._build_request_headers({self.INFERENCE_ID_HEADER: self.id}))
-
-        response_json = response.json()
-        self._status = AsyncStatus(response_json['Status'])
-
-        return response_json
-
-    def result(self) -> Dict[str, Any]:
-        """Get the results of the async inference execution.
-
-        Returns:
-            Dict[str, Any]: The results of the inference execution
-        """
-        url = f'{self._inference_client.base_domain}/result/{self._inference_client.deployment_name}'
-        response = self._inference_client._session.get(
-            url, headers=self._inference_client._build_request_headers({self.INFERENCE_ID_HEADER: self.id}))
-
-        if response.headers['Content-Type'] == 'application/json':
-            return response.json()
-        else:
-            return {'result': response.text}
-
-    # alias for get_results
-    output = result

datacrunch/__version__.py

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