databricks-sdk 0.44.1__py3-none-any.whl → 0.45.0__py3-none-any.whl

databricks/sdk/errors/base.py

@@ -1,47 +1,55 @@
 import re
 import warnings
 from dataclasses import dataclass
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 import requests
 
+from . import details as errdetails
 
-class ErrorDetail:
 
-    def __init__(self,
-                 type: str = None,
-                 reason: str = None,
-                 domain: str = None,
-                 metadata: dict = None,
-                 **kwargs):
+# Deprecated.
+class ErrorDetail:
+    def __init__(
+        self,
+        type: Optional[str] = None,
+        reason: Optional[str] = None,
+        domain: Optional[str] = None,
+        metadata: Optional[dict] = None,
+        **kwargs,
+    ):
         self.type = type
         self.reason = reason
         self.domain = domain
         self.metadata = metadata
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'ErrorDetail':
-        if '@type' in d:
-            d['type'] = d['@type']
-        return cls(**d)
+    def from_dict(cls, d: Dict[str, Any]) -> "ErrorDetail":
+        # Key "@type" is not a valid keyword argument name in Python. Rename
+        # it to "type" to avoid conflicts.
+        safe_args = {}
+        for k, v in d.items():
+            safe_args[k if k != "@type" else "type"] = v
+
+        return cls(**safe_args)
 
 
 class DatabricksError(IOError):
-    """ Generic error from Databricks REST API """
-    # Known ErrorDetail types
-    _error_info_type = "type.googleapis.com/google.rpc.ErrorInfo"
-
-    def __init__(self,
-                 message: str = None,
-                 *,
-                 error_code: str = None,
-                 detail: str = None,
-                 status: str = None,
-                 scimType: str = None,
-                 error: str = None,
-                 retry_after_secs: int = None,
-                 details: List[Dict[str, any]] = None,
-                 **kwargs):
+    """Generic error from Databricks REST API"""
+
+    def __init__(
+        self,
+        message: Optional[str] = None,
+        *,
+        error_code: Optional[str] = None,
+        detail: Optional[str] = None,
+        status: Optional[str] = None,
+        scimType: Optional[str] = None,
+        error: Optional[str] = None,
+        retry_after_secs: Optional[int] = None,
+        details: Optional[List[Dict[str, Any]]] = None,
+        **kwargs,
+    ):
         """
 
         :param message:
@@ -50,11 +58,11 @@ class DatabricksError(IOError):
         :param status: [Deprecated]
         :param scimType: [Deprecated]
         :param error: [Deprecated]
-        :param retry_after_secs:
+        :param retry_after_secs: [Deprecated]
         :param details:
         :param kwargs:
         """
-        # SCIM-specific parameters are deprecated
+        # SCIM-specific parameters are deprecated.
         if detail:
             warnings.warn(
                 "The 'detail' parameter of DatabricksError is deprecated and will be removed in a future version."
@@ -68,12 +76,18 @@ class DatabricksError(IOError):
                 "The 'status' parameter of DatabricksError is deprecated and will be removed in a future version."
             )
 
-        # API 1.2-specific parameters are deprecated
+        # API 1.2-specific parameters are deprecated.
         if error:
             warnings.warn(
                 "The 'error' parameter of DatabricksError is deprecated and will be removed in a future version."
             )
 
+        # Retry-after is deprecated.
+        if retry_after_secs:
+            warnings.warn(
+                "The 'retry_after_secs' parameter of DatabricksError is deprecated and will be removed in a future version."
+            )
+
         if detail:
             # Handle SCIM error message details
             # @see https://tools.ietf.org/html/rfc7644#section-3.7.3
@@ -84,20 +98,32 @@ class DatabricksError(IOError):
             # add more context from SCIM responses
             message = f"{scimType} {message}".strip(" ")
             error_code = f"SCIM_{status}"
+
         super().__init__(message if message else error)
         self.error_code = error_code
         self.retry_after_secs = retry_after_secs
-        self.details = [ErrorDetail.from_dict(detail) for detail in details] if details else []
+        self._error_details = errdetails.parse_error_details(details or [])
         self.kwargs = kwargs
 
+        # Deprecated.
+        self.details = []
+        if details:
+            for d in details:
+                if not isinstance(d, dict):
+                    continue
+                self.details.append(ErrorDetail.from_dict(d))
+
     def get_error_info(self) -> List[ErrorDetail]:
-        return self._get_details_by_type(DatabricksError._error_info_type)
+        return self._get_details_by_type(errdetails._ERROR_INFO_TYPE)
 
     def _get_details_by_type(self, error_type) -> List[ErrorDetail]:
-        if self.details == None:
+        if self.details is None:
             return []
         return [detail for detail in self.details if detail.type == error_type]
 
+    def get_error_details(self) -> errdetails.ErrorDetails:
+        return self._error_details
+
 
 @dataclass
 class _ErrorOverride:
@@ -132,8 +158,8 @@ class _ErrorOverride:
             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', '')):
+        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', '')):
+        if self.message_matcher and not self.message_matcher.match(raw_error.get("message", "")):
             return False
         return True

databricks/sdk/errors/customizer.py

@@ -24,7 +24,7 @@ class _RetryAfterCustomizer(_ErrorCustomizer):
         retry_after = response.headers.get("Retry-After")
         if retry_after is None:
             logging.debug(
-                f'No Retry-After header received in response with status code 429 or 503. Defaulting to {cls._DEFAULT_RETRY_AFTER_SECONDS}'
+                f"No Retry-After header received in response with status code 429 or 503. Defaulting to {cls._DEFAULT_RETRY_AFTER_SECONDS}"
             )
             # 429 requests should include a `Retry-After` header, but if it's missing,
             # we default to 1 second.
@@ -40,11 +40,11 @@ class _RetryAfterCustomizer(_ErrorCustomizer):
             return int(retry_after)
         except ValueError:
             logging.debug(
-                f'Invalid Retry-After header received: {retry_after}. Defaulting to {cls._DEFAULT_RETRY_AFTER_SECONDS}'
+                f"Invalid Retry-After header received: {retry_after}. Defaulting to {cls._DEFAULT_RETRY_AFTER_SECONDS}"
             )
             # defaulting to 1 sleep second to make self._is_retryable() simpler
             return cls._DEFAULT_RETRY_AFTER_SECONDS
 
     def customize_error(self, response: requests.Response, kwargs: dict):
         if response.status_code in (429, 503):
-            kwargs['retry_after_secs'] = self._parse_retry_after(response)
+            kwargs["retry_after_secs"] = self._parse_retry_after(response)

databricks/sdk/errors/deserializer.py

@@ -20,7 +20,7 @@ class _EmptyDeserializer(_ErrorDeserializer):
 
     def deserialize_error(self, response: requests.Response, response_body: bytes) -> Optional[dict]:
         if len(response_body) == 0:
-            return {'message': response.reason}
+            return {"message": response.reason}
         return None
 
 
@@ -31,39 +31,45 @@ class _StandardErrorDeserializer(_ErrorDeserializer):
 
     def deserialize_error(self, response: requests.Response, response_body: bytes) -> Optional[dict]:
         try:
-            payload_str = response_body.decode('utf-8')
+            payload_str = response_body.decode("utf-8")
             resp = json.loads(payload_str)
         except UnicodeDecodeError as e:
-            logging.debug('_StandardErrorParser: unable to decode response using utf-8', exc_info=e)
+            logging.debug(
+                "_StandardErrorParser: unable to decode response using utf-8",
+                exc_info=e,
+            )
             return None
         except json.JSONDecodeError as e:
-            logging.debug('_StandardErrorParser: unable to deserialize response as json', exc_info=e)
+            logging.debug(
+                "_StandardErrorParser: unable to deserialize response as json",
+                exc_info=e,
+            )
             return None
         if not isinstance(resp, dict):
-            logging.debug('_StandardErrorParser: response is valid JSON but not a dictionary')
+            logging.debug("_StandardErrorParser: response is valid JSON but not a dictionary")
             return None
 
         error_args = {
-            'message': resp.get('message', 'request failed'),
-            'error_code': resp.get('error_code'),
-            'details': resp.get('details'),
+            "message": resp.get("message", "request failed"),
+            "error_code": resp.get("error_code"),
+            "details": resp.get("details"),
         }
 
         # Handle API 1.2-style errors
-        if 'error' in resp:
-            error_args['message'] = resp['error']
+        if "error" in resp:
+            error_args["message"] = resp["error"]
 
         # Handle SCIM Errors
-        detail = resp.get('detail')
-        status = resp.get('status')
-        scim_type = resp.get('scimType')
+        detail = resp.get("detail")
+        status = resp.get("status")
+        scim_type = resp.get("scimType")
         if detail:
             # Handle SCIM error message details
             # @see https://tools.ietf.org/html/rfc7644#section-3.7.3
             if detail == "null":
                 detail = "SCIM API Internal Error"
-            error_args['message'] = f"{scim_type} {detail}".strip(" ")
-            error_args['error_code'] = f"SCIM_{status}"
+            error_args["message"] = f"{scim_type} {detail}".strip(" ")
+            error_args["error_code"] = f"SCIM_{status}"
         return error_args
 
 
@@ -72,16 +78,20 @@ class _StringErrorDeserializer(_ErrorDeserializer):
     Parses errors from the Databricks REST API in the format "ERROR_CODE: MESSAGE".
     """
 
-    __STRING_ERROR_REGEX = re.compile(r'([A-Z_]+): (.*)')
+    __STRING_ERROR_REGEX = re.compile(r"([A-Z_]+): (.*)")
 
     def deserialize_error(self, response: requests.Response, response_body: bytes) -> Optional[dict]:
-        payload_str = response_body.decode('utf-8')
+        payload_str = response_body.decode("utf-8")
         match = self.__STRING_ERROR_REGEX.match(payload_str)
         if not match:
-            logging.debug('_StringErrorParser: unable to parse response as string')
+            logging.debug("_StringErrorParser: unable to parse response as string")
             return None
         error_code, message = match.groups()
-        return {'error_code': error_code, 'message': message, 'status': response.status_code, }
+        return {
+            "error_code": error_code,
+            "message": message,
+            "status": response.status_code,
+        }
 
 
 class _HtmlErrorDeserializer(_ErrorDeserializer):
@@ -89,18 +99,21 @@ class _HtmlErrorDeserializer(_ErrorDeserializer):
     Parses errors from the Databricks REST API in HTML format.
     """
 
-    __HTML_ERROR_REGEXES = [re.compile(r'<pre>(.*)</pre>'), re.compile(r'<title>(.*)</title>'), ]
+    __HTML_ERROR_REGEXES = [
+        re.compile(r"<pre>(.*)</pre>"),
+        re.compile(r"<title>(.*)</title>"),
+    ]
 
     def deserialize_error(self, response: requests.Response, response_body: bytes) -> Optional[dict]:
-        payload_str = response_body.decode('utf-8')
+        payload_str = response_body.decode("utf-8")
         for regex in self.__HTML_ERROR_REGEXES:
             match = regex.search(payload_str)
             if match:
                 message = match.group(1) if match.group(1) else response.reason
                 return {
-                    'status': response.status_code,
-                    'message': message,
-                    'error_code': response.reason.upper().replace(' ', '_')
+                    "status": response.status_code,
+                    "message": message,
+                    "error_code": response.reason.upper().replace(" ", "_"),
                 }
-        logging.debug('_HtmlErrorParser: no <pre> tag found in error response')
+        logging.debug("_HtmlErrorParser: no <pre> tag found in error response")
         return None