databricks-sdk 0.24.0__tar.gz → 0.25.1__tar.gz

{databricks-sdk-0.24.0/databricks_sdk.egg-info → databricks-sdk-0.25.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: databricks-sdk
-Version: 0.24.0
+Version: 0.25.1
 Summary: Databricks SDK for Python (Beta)
 Home-page: https://databricks-sdk-py.readthedocs.io
 Author: Serge Smertin
@@ -59,6 +59,7 @@ The SDK's internal HTTP client is robust and handles failures on different level
 - [Long-running operations](#long-running-operations)
 - [Paginated responses](#paginated-responses)
 - [Single-sign-on with OAuth](#single-sign-on-sso-with-oauth)
+- [Error handling](#error-handling)
 - [Logging](#logging)
 - [Integration with `dbutils`](#interaction-with-dbutils)
 - [Interface stability](#interface-stability)
@@ -536,6 +537,23 @@ logging.info(f'Created new custom app: '
              f'--client_secret {custom_app.client_secret}')
 ```
 
+## Error handling<a id="error-handling"></a>
+
+The Databricks SDK for Python provides a robust error-handling mechanism that allows developers to catch and handle API errors. When an error occurs, the SDK will raise an exception that contains information about the error, such as the HTTP status code, error message, and error details. Developers can catch these exceptions and handle them appropriately in their code.
+
+```python
+from databricks.sdk import WorkspaceClient
+from databricks.sdk.errors import ResourceDoesNotExist
+
+w = WorkspaceClient()
+try:
+    w.clusters.get(cluster_id='1234-5678-9012')
+except ResourceDoesNotExist as e:
+    print(f'Cluster not found: {e}')
+```
+
+The SDK handles inconsistencies in error responses amongst the different services, providing a consistent interface for developers to work with. Simply catch the appropriate exception type and handle the error as needed. The errors returned by the Databricks API are defined in [databricks/sdk/errors/platform.py](https://github.com/databricks/databricks-sdk-py/blob/main/databricks/sdk/errors/platform.py).
+
 ## Logging<a id="logging"></a>
 
 The Databricks SDK for Python seamlessly integrates with the standard [Logging facility for Python](https://docs.python.org/3/library/logging.html).

{databricks-sdk-0.24.0 → databricks-sdk-0.25.1}/README.md

@@ -30,6 +30,7 @@ The SDK's internal HTTP client is robust and handles failures on different level
 - [Long-running operations](#long-running-operations)
 - [Paginated responses](#paginated-responses)
 - [Single-sign-on with OAuth](#single-sign-on-sso-with-oauth)
+- [Error handling](#error-handling)
 - [Logging](#logging)
 - [Integration with `dbutils`](#interaction-with-dbutils)
 - [Interface stability](#interface-stability)
@@ -507,6 +508,23 @@ logging.info(f'Created new custom app: '
              f'--client_secret {custom_app.client_secret}')
 ```
 
+## Error handling<a id="error-handling"></a>
+
+The Databricks SDK for Python provides a robust error-handling mechanism that allows developers to catch and handle API errors. When an error occurs, the SDK will raise an exception that contains information about the error, such as the HTTP status code, error message, and error details. Developers can catch these exceptions and handle them appropriately in their code.
+
+```python
+from databricks.sdk import WorkspaceClient
+from databricks.sdk.errors import ResourceDoesNotExist
+
+w = WorkspaceClient()
+try:
+    w.clusters.get(cluster_id='1234-5678-9012')
+except ResourceDoesNotExist as e:
+    print(f'Cluster not found: {e}')
+```
+
+The SDK handles inconsistencies in error responses amongst the different services, providing a consistent interface for developers to work with. Simply catch the appropriate exception type and handle the error as needed. The errors returned by the Databricks API are defined in [databricks/sdk/errors/platform.py](https://github.com/databricks/databricks-sdk-py/blob/main/databricks/sdk/errors/platform.py).
+
 ## Logging<a id="logging"></a>
 
 The Databricks SDK for Python seamlessly integrates with the standard [Logging facility for Python](https://docs.python.org/3/library/logging.html).

{databricks-sdk-0.24.0 → databricks-sdk-0.25.1}/databricks/sdk/__init__.py

@@ -38,6 +38,12 @@ from databricks.sdk.service.iam import (AccountAccessControlAPI,
                                         PermissionsAPI, ServicePrincipalsAPI,
                                         UsersAPI, WorkspaceAssignmentAPI)
 from databricks.sdk.service.jobs import JobsAPI
+from databricks.sdk.service.marketplace import (
+    ConsumerFulfillmentsAPI, ConsumerInstallationsAPI, ConsumerListingsAPI,
+    ConsumerPersonalizationRequestsAPI, ConsumerProvidersAPI,
+    ProviderExchangeFiltersAPI, ProviderExchangesAPI, ProviderFilesAPI,
+    ProviderListingsAPI, ProviderPersonalizationRequestsAPI,
+    ProviderProviderAnalyticsDashboardsAPI, ProviderProvidersAPI)
 from databricks.sdk.service.ml import ExperimentsAPI, ModelRegistryAPI
 from databricks.sdk.service.oauth2 import (CustomAppIntegrationAPI,
                                            OAuthPublishedAppsAPI,
@@ -164,6 +170,11 @@ class WorkspaceClient:
         self._clusters = ClustersExt(self._api_client)
         self._command_execution = CommandExecutionAPI(self._api_client)
         self._connections = ConnectionsAPI(self._api_client)
+        self._consumer_fulfillments = ConsumerFulfillmentsAPI(self._api_client)
+        self._consumer_installations = ConsumerInstallationsAPI(self._api_client)
+        self._consumer_listings = ConsumerListingsAPI(self._api_client)
+        self._consumer_personalization_requests = ConsumerPersonalizationRequestsAPI(self._api_client)
+        self._consumer_providers = ConsumerProvidersAPI(self._api_client)
         self._credentials_manager = CredentialsManagerAPI(self._api_client)
         self._current_user = CurrentUserAPI(self._api_client)
         self._dashboard_widgets = DashboardWidgetsAPI(self._api_client)
@@ -194,6 +205,14 @@ class WorkspaceClient:
         self._permissions = PermissionsAPI(self._api_client)
         self._pipelines = PipelinesAPI(self._api_client)
         self._policy_families = PolicyFamiliesAPI(self._api_client)
+        self._provider_exchange_filters = ProviderExchangeFiltersAPI(self._api_client)
+        self._provider_exchanges = ProviderExchangesAPI(self._api_client)
+        self._provider_files = ProviderFilesAPI(self._api_client)
+        self._provider_listings = ProviderListingsAPI(self._api_client)
+        self._provider_personalization_requests = ProviderPersonalizationRequestsAPI(self._api_client)
+        self._provider_provider_analytics_dashboards = ProviderProviderAnalyticsDashboardsAPI(
+            self._api_client)
+        self._provider_providers = ProviderProvidersAPI(self._api_client)
         self._providers = ProvidersAPI(self._api_client)
         self._queries = QueriesAPI(self._api_client)
         self._query_history = QueryHistoryAPI(self._api_client)
@@ -286,6 +305,31 @@ class WorkspaceClient:
         """Connections allow for creating a connection to an external data source."""
         return self._connections
 
+    @property
+    def consumer_fulfillments(self) -> ConsumerFulfillmentsAPI:
+        """Fulfillments are entities that allow consumers to preview installations."""
+        return self._consumer_fulfillments
+
+    @property
+    def consumer_installations(self) -> ConsumerInstallationsAPI:
+        """Installations are entities that allow consumers to interact with Databricks Marketplace listings."""
+        return self._consumer_installations
+
+    @property
+    def consumer_listings(self) -> ConsumerListingsAPI:
+        """Listings are the core entities in the Marketplace."""
+        return self._consumer_listings
+
+    @property
+    def consumer_personalization_requests(self) -> ConsumerPersonalizationRequestsAPI:
+        """Personalization Requests allow customers to interact with the individualized Marketplace listing flow."""
+        return self._consumer_personalization_requests
+
+    @property
+    def consumer_providers(self) -> ConsumerProvidersAPI:
+        """Providers are the entities that publish listings to the Marketplace."""
+        return self._consumer_providers
+
     @property
     def credentials_manager(self) -> CredentialsManagerAPI:
         """Credentials manager interacts with with Identity Providers to to perform token exchanges using stored credentials and refresh tokens."""
@@ -436,6 +480,41 @@ class WorkspaceClient:
         """View available policy families."""
         return self._policy_families
 
+    @property
+    def provider_exchange_filters(self) -> ProviderExchangeFiltersAPI:
+        """Marketplace exchanges filters curate which groups can access an exchange."""
+        return self._provider_exchange_filters
+
+    @property
+    def provider_exchanges(self) -> ProviderExchangesAPI:
+        """Marketplace exchanges allow providers to share their listings with a curated set of customers."""
+        return self._provider_exchanges
+
+    @property
+    def provider_files(self) -> ProviderFilesAPI:
+        """Marketplace offers a set of file APIs for various purposes such as preview notebooks and provider icons."""
+        return self._provider_files
+
+    @property
+    def provider_listings(self) -> ProviderListingsAPI:
+        """Listings are the core entities in the Marketplace."""
+        return self._provider_listings
+
+    @property
+    def provider_personalization_requests(self) -> ProviderPersonalizationRequestsAPI:
+        """Personalization requests are an alternate to instantly available listings."""
+        return self._provider_personalization_requests
+
+    @property
+    def provider_provider_analytics_dashboards(self) -> ProviderProviderAnalyticsDashboardsAPI:
+        """Manage templated analytics solution for providers."""
+        return self._provider_provider_analytics_dashboards
+
+    @property
+    def provider_providers(self) -> ProviderProvidersAPI:
+        """Providers are entities that manage assets in Marketplace."""
+        return self._provider_providers
+
     @property
     def providers(self) -> ProvidersAPI:
         """A data provider is an object representing the organization in the real world who shares the data."""

{databricks-sdk-0.24.0 → databricks-sdk-0.25.1}/databricks/sdk/core.py

@@ -264,7 +264,7 @@ class ApiClient:
         if is_too_many_requests_or_unavailable:
             kwargs['retry_after_secs'] = self._parse_retry_after(response)
         kwargs['message'] = message
-        return error_mapper(status_code, kwargs)
+        return error_mapper(response, kwargs)
 
     def _record_request_log(self, response: requests.Response, raw=False):
         if not logger.isEnabledFor(logging.DEBUG):

{databricks-sdk-0.24.0 → databricks-sdk-0.25.1}/databricks/sdk/errors/base.py

@@ -1,4 +1,8 @@
-from typing import Dict, List
+import re
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+import requests
 
 
 class ErrorDetail:
@@ -63,3 +67,43 @@ class DatabricksError(IOError):
         if self.details == None:
             return []
         return [detail for detail in self.details if detail.type == error_type]
+
+
+@dataclass
+class _ErrorOverride:
+    # The name of the override. Used for logging purposes.
+    debug_name: str
+
+    # A regex that must match the path of the request for this override to be applied.
+    path_regex: re.Pattern
+
+    # The HTTP method of the request for the override to apply
+    verb: str
+
+    # The custom error class to use for this override.
+    custom_error: type
+
+    # A regular expression that must match the error code for this override to be applied. If None,
+    # this field is ignored.
+    status_code_matcher: Optional[re.Pattern] = None
+
+    # A regular expression that must match the error code for this override to be applied. If None,
+    # this field is ignored.
+    error_code_matcher: Optional[re.Pattern] = None
+
+    # A regular expression that must match the message for this override to be applied. If None,
+    # this field is ignored.
+    message_matcher: Optional[re.Pattern] = None
+
+    def matches(self, response: requests.Response, raw_error: dict):
+        if response.request.method != self.verb:
+            return False
+        if not self.path_regex.match(response.request.path_url):
+            return False
+        if self.status_code_matcher and not self.status_code_matcher.match(str(response.status_code)):
+            return False
+        if self.error_code_matcher and not self.error_code_matcher.match(raw_error.get('error_code', '')):
+            return False
+        if self.message_matcher and not self.message_matcher.match(raw_error.get('message', '')):
+            return False
+        return True

{databricks-sdk-0.24.0 → databricks-sdk-0.25.1}/databricks/sdk/errors/mapper.py

@@ -1,8 +1,16 @@
+import requests
+
 from databricks.sdk.errors import platform
 from databricks.sdk.errors.base import DatabricksError
 
+from .overrides import _ALL_OVERRIDES
+
 
-def error_mapper(status_code: int, raw: dict) -> DatabricksError:
+def error_mapper(response: requests.Response, raw: dict) -> DatabricksError:
+    for override in _ALL_OVERRIDES:
+        if override.matches(response, raw):
+            return override.custom_error(**raw)
+    status_code = response.status_code
     error_code = raw.get('error_code', None)
     if error_code in platform.ERROR_CODE_MAPPING:
         # more specific error codes override more generic HTTP status codes

databricks-sdk-0.25.1/databricks/sdk/errors/overrides.py

@@ -0,0 +1,25 @@
+# Code generated from OpenAPI specs by Databricks SDK Generator. DO NOT EDIT.
+
+import re
+
+from .base import _ErrorOverride
+from .platform import ResourceDoesNotExist
+
+_ALL_OVERRIDES = [
+    _ErrorOverride(debug_name="Clusters InvalidParameterValue=>ResourceDoesNotExist",
+                   path_regex=re.compile(r'^/api/2\.\d/clusters/get'),
+                   verb="GET",
+                   status_code_matcher=re.compile(r'^400$'),
+                   error_code_matcher=re.compile(r'INVALID_PARAMETER_VALUE'),
+                   message_matcher=re.compile(r'Cluster .* does not exist'),
+                   custom_error=ResourceDoesNotExist,
+                   ),
+    _ErrorOverride(debug_name="Jobs InvalidParameterValue=>ResourceDoesNotExist",
+                   path_regex=re.compile(r'^/api/2\.\d/jobs/get'),
+                   verb="GET",
+                   status_code_matcher=re.compile(r'^400$'),
+                   error_code_matcher=re.compile(r'INVALID_PARAMETER_VALUE'),
+                   message_matcher=re.compile(r'Job .* does not exist'),
+                   custom_error=ResourceDoesNotExist,
+                   ),
+]

{databricks-sdk-0.24.0 → databricks-sdk-0.25.1}/databricks/sdk/mixins/compute.py

@@ -86,6 +86,7 @@ class ClustersExt(compute.ClustersAPI):
         :param beta: bool
         :param latest: bool
         :param ml: bool
+        :param genomics: bool
         :param gpu: bool
         :param scala: str
         :param spark_version: str
@@ -100,7 +101,7 @@ class ClustersExt(compute.ClustersAPI):
         for version in sv.versions:
             if "-scala" + scala not in version.key:
                 continue
-            matches = ((not "apache-spark-" in version.key) and (("-ml-" in version.key) == ml)
+            matches = (("apache-spark-" not in version.key) and (("-ml-" in version.key) == ml)
                        and (("-hls-" in version.key) == genomics) and (("-gpu-" in version.key) == gpu)
                        and (("-photon-" in version.key) == photon)
                        and (("-aarch64-" in version.key) == graviton) and (("Beta" in version.name) == beta))
@@ -137,7 +138,7 @@ class ClustersExt(compute.ClustersAPI):
             return False
         val = compute.CloudProviderNodeStatus
         for st in nt.node_info.status:
-            if st in (val.NotAvailableInRegion, val.NotEnabledOnSubscription):
+            if st in (val.NOT_AVAILABLE_IN_REGION, val.NOT_ENABLED_ON_SUBSCRIPTION):
                 return True
         return False
 
@@ -168,6 +169,8 @@ class ClustersExt(compute.ClustersAPI):
         :param photon_driver_capable: bool
         :param graviton: bool
         :param is_io_cache_enabled: bool
+        :param support_port_forwarding: bool
+        :param fleet: bool
 
         :returns: `node_type` compatible string
         """