databricks-sdk 0.23.0__py3-none-any.whl → 0.25.0__py3-none-any.whl

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/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/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/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/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/service/_internal.py

@@ -1,4 +1,5 @@
 import datetime
+import urllib.parse
 from typing import Callable, Dict, Generic, Optional, Type, TypeVar
 
 
@@ -38,6 +39,10 @@ def _repeated_enum(d: Dict[str, any], field: str, cls: Type) -> any:
     return res
 
 
+def _escape_multi_segment_path_parameter(param: str) -> str:
+    return urllib.parse.quote(param)
+
+
 ReturnType = TypeVar('ReturnType')