databricks-sdk 0.31.1__py3-none-any.whl → 0.32.0__py3-none-any.whl

databricks/sdk/core.py

@@ -1,7 +1,5 @@
 import re
-import urllib.parse
 from datetime import timedelta
-from json import JSONDecodeError
 from types import TracebackType
 from typing import Any, BinaryIO, Iterator, Type
 from urllib.parse import urlencode
@@ -12,8 +10,8 @@ from .casing import Casing
 from .config import *
 # To preserve backwards compatibility (as these definitions were previously in this module)
 from .credentials_provider import *
-from .errors import DatabricksError, error_mapper
-from .errors.private_link import _is_private_link_redirect
+from .errors import DatabricksError, get_api_error
+from .logger import RoundTrip
 from .oauth import retrieve_token
 from .retries import retried
 
@@ -262,134 +260,23 @@ class ApiClient:
                                          auth=auth,
                                          stream=raw,
                                          timeout=self._http_timeout_seconds)
-        try:
-            self._record_request_log(response, raw=raw or data is not None or files is not None)
-            if not response.ok: # internally calls response.raise_for_status()
-                # TODO: experiment with traceback pruning for better readability
-                # See https://stackoverflow.com/a/58821552/277035
-                payload = response.json()
-                raise self._make_nicer_error(response=response, **payload) from None
-            # Private link failures happen via a redirect to the login page. From a requests-perspective, the request
-            # is successful, but the response is not what we expect. We need to handle this case separately.
-            if _is_private_link_redirect(response):
-                raise self._make_nicer_error(response=response) from None
-            return response
-        except requests.exceptions.JSONDecodeError:
-            message = self._make_sense_from_html(response.text)
-            if not message:
-                message = response.reason
-            raise self._make_nicer_error(response=response, message=message) from None
-
-    @staticmethod
-    def _make_sense_from_html(txt: str) -> str:
-        matchers = [r'<pre>(.*)</pre>', r'<title>(.*)</title>']
-        for attempt in matchers:
-            expr = re.compile(attempt, re.MULTILINE)
-            match = expr.search(txt)
-            if not match:
-                continue
-            return match.group(1).strip()
-        return txt
-
-    def _make_nicer_error(self, *, response: requests.Response, **kwargs) -> DatabricksError:
-        status_code = response.status_code
-        message = kwargs.get('message', 'request failed')
-        is_http_unauthorized_or_forbidden = status_code in (401, 403)
-        is_too_many_requests_or_unavailable = status_code in (429, 503)
-        if is_http_unauthorized_or_forbidden:
-            message = self._cfg.wrap_debug_info(message)
-        if is_too_many_requests_or_unavailable:
-            kwargs['retry_after_secs'] = self._parse_retry_after(response)
-        kwargs['message'] = message
-        return error_mapper(response, kwargs)
-
-    def _record_request_log(self, response: requests.Response, raw=False):
+        self._record_request_log(response, raw=raw or data is not None or files is not None)
+        error = get_api_error(response)
+        if error is not None:
+            status_code = response.status_code
+            is_http_unauthorized_or_forbidden = status_code in (401, 403)
+            is_too_many_requests_or_unavailable = status_code in (429, 503)
+            if is_http_unauthorized_or_forbidden:
+                error.message = self._cfg.wrap_debug_info(error.message)
+            if is_too_many_requests_or_unavailable:
+                error.retry_after_secs = self._parse_retry_after(response)
+            raise error from None
+        return response
+
+    def _record_request_log(self, response: requests.Response, raw: bool = False) -> None:
         if not logger.isEnabledFor(logging.DEBUG):
             return
-        request = response.request
-        url = urllib.parse.urlparse(request.url)
-        query = ''
-        if url.query:
-            query = f'?{urllib.parse.unquote(url.query)}'
-        sb = [f'{request.method} {urllib.parse.unquote(url.path)}{query}']
-        if self._cfg.debug_headers:
-            if self._cfg.host:
-                sb.append(f'> * Host: {self._cfg.host}')
-            for k, v in request.headers.items():
-                sb.append(f'> * {k}: {self._only_n_bytes(v, self._debug_truncate_bytes)}')
-        if request.body:
-            sb.append("> [raw stream]" if raw else self._redacted_dump("> ", request.body))
-        sb.append(f'< {response.status_code} {response.reason}')
-        if raw and response.headers.get('Content-Type', None) != 'application/json':
-            # Raw streams with `Transfer-Encoding: chunked` do not have `Content-Type` header
-            sb.append("< [raw stream]")
-        elif response.content:
-            sb.append(self._redacted_dump("< ", response.content))
-        logger.debug("\n".join(sb))
-
-    @staticmethod
-    def _mask(m: Dict[str, any]):
-        for k in m:
-            if k in {'bytes_value', 'string_value', 'token_value', 'value', 'content'}:
-                m[k] = "**REDACTED**"
-
-    @staticmethod
-    def _map_keys(m: Dict[str, any]) -> List[str]:
-        keys = list(m.keys())
-        keys.sort()
-        return keys
-
-    @staticmethod
-    def _only_n_bytes(j: str, num_bytes: int = 96) -> str:
-        diff = len(j.encode('utf-8')) - num_bytes
-        if diff > 0:
-            return f"{j[:num_bytes]}... ({diff} more bytes)"
-        return j
-
-    def _recursive_marshal_dict(self, m, budget) -> dict:
-        out = {}
-        self._mask(m)
-        for k in sorted(m.keys()):
-            raw = self._recursive_marshal(m[k], budget)
-            out[k] = raw
-            budget -= len(str(raw))
-        return out
-
-    def _recursive_marshal_list(self, s, budget) -> list:
-        out = []
-        for i in range(len(s)):
-            if i > 0 >= budget:
-                out.append("... (%d additional elements)" % (len(s) - len(out)))
-                break
-            raw = self._recursive_marshal(s[i], budget)
-            out.append(raw)
-            budget -= len(str(raw))
-        return out
-
-    def _recursive_marshal(self, v: any, budget: int) -> any:
-        if isinstance(v, dict):
-            return self._recursive_marshal_dict(v, budget)
-        elif isinstance(v, list):
-            return self._recursive_marshal_list(v, budget)
-        elif isinstance(v, str):
-            return self._only_n_bytes(v, self._debug_truncate_bytes)
-        else:
-            return v
-
-    def _redacted_dump(self, prefix: str, body: str) -> str:
-        if len(body) == 0:
-            return ""
-        try:
-            # Unmarshal body into primitive types.
-            tmp = json.loads(body)
-            max_bytes = 96
-            if self._debug_truncate_bytes > max_bytes:
-                max_bytes = self._debug_truncate_bytes
-            # Re-marshal body taking redaction and character limit into account.
-            raw = self._recursive_marshal(tmp, max_bytes)
-            return "\n".join([f'{prefix}{line}' for line in json.dumps(raw, indent=2).split("\n")])
-        except JSONDecodeError:
-            return f'{prefix}[non-JSON document of {len(body)} bytes]'
+        logger.debug(RoundTrip(response, self._cfg.debug_headers, self._debug_truncate_bytes, raw).generate())
 
 
 class StreamingResponse(BinaryIO):

databricks/sdk/errors/__init__.py

@@ -1,5 +1,6 @@
 from .base import DatabricksError, ErrorDetail
-from .mapper import error_mapper
+from .mapper import _error_mapper
+from .parser import get_api_error
 from .platform import *
 from .private_link import PrivateLinkValidationError
 from .sdk import *

databricks/sdk/errors/base.py

@@ -1,4 +1,5 @@
 import re
+import warnings
 from dataclasses import dataclass
 from typing import Dict, List, Optional
 
@@ -41,9 +42,38 @@ class DatabricksError(IOError):
                  retry_after_secs: int = None,
                  details: List[Dict[str, any]] = None,
                  **kwargs):
+        """
+
+        :param message:
+        :param error_code:
+        :param detail: [Deprecated]
+        :param status: [Deprecated]
+        :param scimType: [Deprecated]
+        :param error: [Deprecated]
+        :param retry_after_secs:
+        :param details:
+        :param kwargs:
+        """
+        # SCIM-specific parameters are deprecated
+        if detail:
+            warnings.warn(
+                "The 'detail' parameter of DatabricksError is deprecated and will be removed in a future version."
+            )
+        if scimType:
+            warnings.warn(
+                "The 'scimType' parameter of DatabricksError is deprecated and will be removed in a future version."
+            )
+        if status:
+            warnings.warn(
+                "The 'status' parameter of DatabricksError is deprecated and will be removed in a future version."
+            )
+
+        # API 1.2-specific parameters are deprecated
         if error:
-            # API 1.2 has different response format, let's adapt
-            message = error
+            warnings.warn(
+                "The 'error' 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

databricks/sdk/errors/mapper.py

@@ -4,11 +4,9 @@ from databricks.sdk.errors import platform
 from databricks.sdk.errors.base import DatabricksError
 
 from .overrides import _ALL_OVERRIDES
-from .private_link import (_get_private_link_validation_error,
-                           _is_private_link_redirect)
 
 
-def error_mapper(response: requests.Response, 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)
@@ -23,8 +21,6 @@ def error_mapper(response: requests.Response, raw: dict) -> DatabricksError:
         # where there's a default exception class per HTTP status code, and we do
         # rely on Databricks platform exception mapper to do the right thing.
         return platform.STATUS_CODE_MAPPING[status_code](**raw)
-    if _is_private_link_redirect(response):
-        return _get_private_link_validation_error(response.url)
 
     # backwards-compatible error creation for cases like using older versions of
     # the SDK on way never releases of the platform.

databricks/sdk/errors/parser.py

@@ -0,0 +1,146 @@
+import abc
+import json
+import logging
+import re
+from typing import Optional
+
+import requests
+
+from ..logger import RoundTrip
+from .base import DatabricksError
+from .mapper import _error_mapper
+from .private_link import (_get_private_link_validation_error,
+                           _is_private_link_redirect)
+
+
+class _ErrorParser(abc.ABC):
+    """A parser for errors from the Databricks REST API."""
+
+    @abc.abstractmethod
+    def parse_error(self, response: requests.Response, response_body: bytes) -> Optional[dict]:
+        """Parses an error from the Databricks REST API. If the error cannot be parsed, returns None."""
+
+
+class _EmptyParser(_ErrorParser):
+    """A parser that handles empty responses."""
+
+    def parse_error(self, response: requests.Response, response_body: bytes) -> Optional[dict]:
+        if len(response_body) == 0:
+            return {'message': response.reason}
+        return None
+
+
+class _StandardErrorParser(_ErrorParser):
+    """
+    Parses errors from the Databricks REST API using the standard error format.
+    """
+
+    def parse_error(self, response: requests.Response, response_body: bytes) -> Optional[dict]:
+        try:
+            payload_str = response_body.decode('utf-8')
+            resp: dict = json.loads(payload_str)
+        except json.JSONDecodeError as e:
+            logging.debug('_StandardErrorParser: unable to deserialize response as json', exc_info=e)
+            return None
+
+        error_args = {
+            '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']
+
+        # Handle SCIM Errors
+        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
+            error_args[
+                'message'] = f"{scim_type} {error_args.get('message', 'SCIM API Internal Error')}".strip(" ")
+            error_args['error_code'] = f"SCIM_{status}"
+        return error_args
+
+
+class _StringErrorParser(_ErrorParser):
+    """
+    Parses errors from the Databricks REST API in the format "ERROR_CODE: MESSAGE".
+    """
+
+    __STRING_ERROR_REGEX = re.compile(r'([A-Z_]+): (.*)')
+
+    def parse_error(self, response: requests.Response, response_body: bytes) -> Optional[dict]:
+        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')
+            return None
+        error_code, message = match.groups()
+        return {'error_code': error_code, 'message': message, 'status': response.status_code, }
+
+
+class _HtmlErrorParser(_ErrorParser):
+    """
+    Parses errors from the Databricks REST API in HTML format.
+    """
+
+    __HTML_ERROR_REGEXES = [re.compile(r'<pre>(.*)</pre>'), re.compile(r'<title>(.*)</title>'), ]
+
+    def parse_error(self, response: requests.Response, response_body: bytes) -> Optional[dict]:
+        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(' ', '_')
+                }
+        logging.debug('_HtmlErrorParser: no <pre> tag found in error response')
+        return None
+
+
+# A list of ErrorParsers that are tried in order to parse an API error from a response body. Most errors should be
+# parsable by the _StandardErrorParser, but additional parsers can be added here for specific error formats. The order
+# of the parsers is not important, as the set of errors that can be parsed by each parser should be disjoint.
+_error_parsers = [_EmptyParser(), _StandardErrorParser(), _StringErrorParser(), _HtmlErrorParser(), ]
+
+
+def _unknown_error(response: requests.Response) -> str:
+    """A standard error message that can be shown when an API response cannot be parsed.
+
+    This error message includes a link to the issue tracker for the SDK for users to report the issue to us.
+    """
+    request_log = RoundTrip(response, debug_headers=True, debug_truncate_bytes=10 * 1024).generate()
+    return (
+        'This is likely a bug in the Databricks SDK for Python or the underlying '
+        'API. Please report this issue with the following debugging information to the SDK issue tracker at '
+        f'https://github.com/databricks/databricks-sdk-go/issues. Request log:```{request_log}```')
+
+
+def get_api_error(response: requests.Response) -> Optional[DatabricksError]:
+    """
+    Handles responses from the REST API and returns a DatabricksError if the response indicates an error.
+    :param response: The response from the REST API.
+    :return: A DatabricksError if the response indicates an error, otherwise None.
+    """
+    if not response.ok:
+        content = response.content
+        for parser in _error_parsers:
+            try:
+                error_args = parser.parse_error(response, content)
+                if error_args:
+                    return _error_mapper(response, error_args)
+            except Exception as e:
+                logging.debug(f'Error parsing response with {parser}, continuing', exc_info=e)
+        return _error_mapper(response, {'message': 'unable to parse response. ' + _unknown_error(response)})
+
+    # Private link failures happen via a redirect to the login page. From a requests-perspective, the request
+    # is successful, but the response is not what we expect. We need to handle this case separately.
+    if _is_private_link_redirect(response):
+        return _get_private_link_validation_error(response.url)

databricks/sdk/errors/private_link.py

@@ -51,7 +51,7 @@ def _is_private_link_redirect(resp: requests.Response) -> bool:
     return parsed.path == '/login.html' and 'error=private-link-validation-error' in parsed.query
 
 
-def _get_private_link_validation_error(url: str) -> _PrivateLinkInfo:
+def _get_private_link_validation_error(url: str) -> PrivateLinkValidationError:
     parsed = parse.urlparse(url)
     env = get_environment_for_hostname(parsed.hostname)
     return PrivateLinkValidationError(message=_private_link_info_map[env.cloud].error_message(),

databricks/sdk/logger/__init__.py

@@ -0,0 +1 @@
+from .round_trip_logger import RoundTrip

databricks/sdk/logger/round_trip_logger.py

@@ -0,0 +1,118 @@
+import json
+import urllib.parse
+from typing import Dict, List
+
+import requests
+
+
+class RoundTrip:
+    """
+    A utility class for converting HTTP requests and responses to strings.
+
+    :param response: The response object to stringify.
+    :param debug_headers: Whether to include headers in the generated string.
+    :param debug_truncate_bytes: The maximum number of bytes to include in the generated string.
+    :param raw: Whether the response is a stream or not. If True, the response will not be logged directly.
+    """
+
+    def __init__(self,
+                 response: requests.Response,
+                 debug_headers: bool,
+                 debug_truncate_bytes: int,
+                 raw=False):
+        self._debug_headers = debug_headers
+        self._debug_truncate_bytes = max(debug_truncate_bytes, 96)
+        self._raw = raw
+        self._response = response
+
+    def generate(self) -> str:
+        """
+        Generate a string representation of the request and response. The string will include the request method, URL,
+        headers, and body, as well as the response status code, reason, headers, and body. Outgoing information
+        will be prefixed with `>`, and incoming information will be prefixed with `<`.
+        :return: A string representation of the request.
+        """
+        request = self._response.request
+        url = urllib.parse.urlparse(request.url)
+        query = ''
+        if url.query:
+            query = f'?{urllib.parse.unquote(url.query)}'
+        sb = [f'{request.method} {urllib.parse.unquote(url.path)}{query}']
+        if self._debug_headers:
+            for k, v in request.headers.items():
+                sb.append(f'> * {k}: {self._only_n_bytes(v, self._debug_truncate_bytes)}')
+        if request.body:
+            sb.append("> [raw stream]" if self._raw else self._redacted_dump("> ", request.body))
+        sb.append(f'< {self._response.status_code} {self._response.reason}')
+        if self._raw and self._response.headers.get('Content-Type', None) != 'application/json':
+            # Raw streams with `Transfer-Encoding: chunked` do not have `Content-Type` header
+            sb.append("< [raw stream]")
+        elif self._response.content:
+            sb.append(self._redacted_dump("< ", self._response.content.decode('utf-8')))
+        return '\n'.join(sb)
+
+    @staticmethod
+    def _mask(m: Dict[str, any]):
+        for k in m:
+            if k in {'bytes_value', 'string_value', 'token_value', 'value', 'content'}:
+                m[k] = "**REDACTED**"
+
+    @staticmethod
+    def _map_keys(m: Dict[str, any]) -> List[str]:
+        keys = list(m.keys())
+        keys.sort()
+        return keys
+
+    @staticmethod
+    def _only_n_bytes(j: str, num_bytes: int = 96) -> str:
+        diff = len(j.encode('utf-8')) - num_bytes
+        if diff > 0:
+            return f"{j[:num_bytes]}... ({diff} more bytes)"
+        return j
+
+    def _recursive_marshal_dict(self, m, budget) -> dict:
+        out = {}
+        self._mask(m)
+        for k in sorted(m.keys()):
+            raw = self._recursive_marshal(m[k], budget)
+            out[k] = raw
+            budget -= len(str(raw))
+        return out
+
+    def _recursive_marshal_list(self, s, budget) -> list:
+        out = []
+        for i in range(len(s)):
+            if i > 0 >= budget:
+                out.append("... (%d additional elements)" % (len(s) - len(out)))
+                break
+            raw = self._recursive_marshal(s[i], budget)
+            out.append(raw)
+            budget -= len(str(raw))
+        return out
+
+    def _recursive_marshal(self, v: any, budget: int) -> any:
+        if isinstance(v, dict):
+            return self._recursive_marshal_dict(v, budget)
+        elif isinstance(v, list):
+            return self._recursive_marshal_list(v, budget)
+        elif isinstance(v, str):
+            return self._only_n_bytes(v, self._debug_truncate_bytes)
+        else:
+            return v
+
+    def _redacted_dump(self, prefix: str, body: str) -> str:
+        if len(body) == 0:
+            return ""
+        try:
+            # Unmarshal body into primitive types.
+            tmp = json.loads(body)
+            max_bytes = 96
+            if self._debug_truncate_bytes > max_bytes:
+                max_bytes = self._debug_truncate_bytes
+            # Re-marshal body taking redaction and character limit into account.
+            raw = self._recursive_marshal(tmp, max_bytes)
+            return "\n".join([f'{prefix}{line}' for line in json.dumps(raw, indent=2).split("\n")])
+        except json.JSONDecodeError:
+            to_log = self._only_n_bytes(body, self._debug_truncate_bytes)
+            log_lines = [prefix + x.strip('\r') for x in to_log.split("\n")]
+            return '\n'.join(log_lines)

databricks/sdk/service/catalog.py

@@ -1268,7 +1268,8 @@ class CreateMetastoreAssignment:
     """The unique ID of the metastore."""
 
     default_catalog_name: str
-    """The name of the default catalog in the metastore."""
+    """The name of the default catalog in the metastore. This field is depracted. Please use "Default
+    Namespace API" to configure the default catalog for a Databricks workspace."""
 
     workspace_id: Optional[int] = None
     """A workspace ID."""
@@ -4150,6 +4151,49 @@ class QuotaInfo:
                    quota_name=d.get('quota_name', None))
 
 
+@dataclass
+class RegenerateDashboardRequest:
+    table_name: Optional[str] = None
+    """Full name of the table."""
+
+    warehouse_id: Optional[str] = None
+    """Optional argument to specify the warehouse for dashboard regeneration. If not specified, the
+    first running warehouse will be used."""
+
+    def as_dict(self) -> dict:
+        """Serializes the RegenerateDashboardRequest into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.table_name is not None: body['table_name'] = self.table_name
+        if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> RegenerateDashboardRequest:
+        """Deserializes the RegenerateDashboardRequest from a dictionary."""
+        return cls(table_name=d.get('table_name', None), warehouse_id=d.get('warehouse_id', None))
+
+
+@dataclass
+class RegenerateDashboardResponse:
+    dashboard_id: Optional[str] = None
+    """Id of the regenerated monitoring dashboard."""
+
+    parent_folder: Optional[str] = None
+    """The directory where the regenerated dashboard is stored."""
+
+    def as_dict(self) -> dict:
+        """Serializes the RegenerateDashboardResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.dashboard_id is not None: body['dashboard_id'] = self.dashboard_id
+        if self.parent_folder is not None: body['parent_folder'] = self.parent_folder
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> RegenerateDashboardResponse:
+        """Deserializes the RegenerateDashboardResponse from a dictionary."""
+        return cls(dashboard_id=d.get('dashboard_id', None), parent_folder=d.get('parent_folder', None))
+
+
 @dataclass
 class RegisteredModelAlias:
     """Registered model alias."""
@@ -5220,7 +5264,8 @@ class UpdateMetastore:
 @dataclass
 class UpdateMetastoreAssignment:
     default_catalog_name: Optional[str] = None
-    """The name of the default catalog for the metastore."""
+    """The name of the default catalog in the metastore. This field is depracted. Please use "Default
+    Namespace API" to configure the default catalog for a Databricks workspace."""
 
     metastore_id: Optional[str] = None
     """The unique ID of the metastore."""
@@ -7208,7 +7253,8 @@ class MetastoresAPI:
         :param metastore_id: str
           The unique ID of the metastore.
         :param default_catalog_name: str
-          The name of the default catalog in the metastore.
+          The name of the default catalog in the metastore. This field is depracted. Please use "Default
+          Namespace API" to configure the default catalog for a Databricks workspace.
         
         
         """
@@ -7421,7 +7467,8 @@ class MetastoresAPI:
         :param workspace_id: int
           A workspace ID.
         :param default_catalog_name: str (optional)
-          The name of the default catalog for the metastore.
+          The name of the default catalog in the metastore. This field is depracted. Please use "Default
+          Namespace API" to configure the default catalog for a Databricks workspace.
         :param metastore_id: str (optional)
           The unique ID of the metastore.
         
@@ -7916,6 +7963,40 @@ class QualityMonitorsAPI:
                            headers=headers)
         return MonitorRefreshListResponse.from_dict(res)
 
+    def regenerate_dashboard(self,
+                             table_name: str,
+                             *,
+                             warehouse_id: Optional[str] = None) -> RegenerateDashboardResponse:
+        """Regenerate a monitoring dashboard.
+        
+        Regenerates the monitoring dashboard for the specified table.
+        
+        The caller must either: 1. be an owner of the table's parent catalog 2. have **USE_CATALOG** on the
+        table's parent catalog and be an owner of the table's parent schema 3. have the following permissions:
+        - **USE_CATALOG** on the table's parent catalog - **USE_SCHEMA** on the table's parent schema - be an
+        owner of the table
+        
+        The call must be made from the workspace where the monitor was created. The dashboard will be
+        regenerated in the assets directory that was specified when the monitor was created.
+        
+        :param table_name: str
+          Full name of the table.
+        :param warehouse_id: str (optional)
+          Optional argument to specify the warehouse for dashboard regeneration. If not specified, the first
+          running warehouse will be used.
+        
+        :returns: :class:`RegenerateDashboardResponse`
+        """
+        body = {}
+        if warehouse_id is not None: body['warehouse_id'] = warehouse_id
+        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
+
+        res = self._api.do('POST',
+                           f'/api/2.1/quality-monitoring/tables/{table_name}/monitor/dashboard',
+                           body=body,
+                           headers=headers)
+        return RegenerateDashboardResponse.from_dict(res)
+
     def run_refresh(self, table_name: str) -> MonitorRefreshInfo:
         """Queue a metric refresh for a monitor.
         

databricks/sdk/service/iam.py

@@ -892,8 +892,8 @@ class PermissionsRequest:
 
     request_object_type: Optional[str] = None
     """The type of the request object. Can be one of the following: alerts, authorization, clusters,
-    cluster-policies, dbsql-dashboards, directories, experiments, files, instance-pools, jobs,
-    notebooks, pipelines, queries, registered-models, repos, serving-endpoints, or warehouses."""
+    cluster-policies, dashboards, dbsql-dashboards, directories, experiments, files, instance-pools,
+    jobs, notebooks, pipelines, queries, registered-models, repos, serving-endpoints, or warehouses."""
 
     def as_dict(self) -> dict:
         """Serializes the PermissionsRequest into a dictionary suitable for use as a JSON request body."""
@@ -2600,8 +2600,8 @@ class PermissionsAPI:
         
         :param request_object_type: str
           The type of the request object. Can be one of the following: alerts, authorization, clusters,
-          cluster-policies, dbsql-dashboards, directories, experiments, files, instance-pools, jobs,
-          notebooks, pipelines, queries, registered-models, repos, serving-endpoints, or warehouses.
+          cluster-policies, dashboards, dbsql-dashboards, directories, experiments, files, instance-pools,
+          jobs, notebooks, pipelines, queries, registered-models, repos, serving-endpoints, or warehouses.
         :param request_object_id: str
           The id of the request object.
         
@@ -2648,8 +2648,8 @@ class PermissionsAPI:
         
         :param request_object_type: str
           The type of the request object. Can be one of the following: alerts, authorization, clusters,
-          cluster-policies, dbsql-dashboards, directories, experiments, files, instance-pools, jobs,
-          notebooks, pipelines, queries, registered-models, repos, serving-endpoints, or warehouses.
+          cluster-policies, dashboards, dbsql-dashboards, directories, experiments, files, instance-pools,
+          jobs, notebooks, pipelines, queries, registered-models, repos, serving-endpoints, or warehouses.
         :param request_object_id: str
           The id of the request object.
         :param access_control_list: List[:class:`AccessControlRequest`] (optional)
@@ -2679,8 +2679,8 @@ class PermissionsAPI:
         
         :param request_object_type: str
           The type of the request object. Can be one of the following: alerts, authorization, clusters,
-          cluster-policies, dbsql-dashboards, directories, experiments, files, instance-pools, jobs,
-          notebooks, pipelines, queries, registered-models, repos, serving-endpoints, or warehouses.
+          cluster-policies, dashboards, dbsql-dashboards, directories, experiments, files, instance-pools,
+          jobs, notebooks, pipelines, queries, registered-models, repos, serving-endpoints, or warehouses.
         :param request_object_id: str
           The id of the request object.
         :param access_control_list: List[:class:`AccessControlRequest`] (optional)

databricks/sdk/service/jobs.py

@@ -171,7 +171,10 @@ class BaseRun:
     scheduled to run on a new cluster, this is the time the cluster creation call is issued."""
 
     state: Optional[RunState] = None
-    """The current state of the run."""
+    """Deprecated. Please use the `status` field instead."""
+
+    status: Optional[RunStatus] = None
+    """The current status of the run"""
 
     tasks: Optional[List[RunTask]] = None
     """The list of tasks performed by the run. Each task has its own `run_id` which you can use to call
@@ -222,6 +225,7 @@ class BaseRun:
         if self.setup_duration is not None: body['setup_duration'] = self.setup_duration
         if self.start_time is not None: body['start_time'] = self.start_time
         if self.state: body['state'] = self.state.as_dict()
+        if self.status: body['status'] = self.status.as_dict()
         if self.tasks: body['tasks'] = [v.as_dict() for v in self.tasks]
         if self.trigger is not None: body['trigger'] = self.trigger.value
         if self.trigger_info: body['trigger_info'] = self.trigger_info.as_dict()
@@ -257,6 +261,7 @@ class BaseRun:
                    setup_duration=d.get('setup_duration', None),
                    start_time=d.get('start_time', None),
                    state=_from_dict(d, 'state', RunState),
+                   status=_from_dict(d, 'status', RunStatus),
                    tasks=_repeated_dict(d, 'tasks', RunTask),
                    trigger=_enum(d, 'trigger', TriggerType),
                    trigger_info=_from_dict(d, 'trigger_info', TriggerInfo))
@@ -2314,6 +2319,44 @@ class PythonWheelTask:
                    parameters=d.get('parameters', None))
 
 
+@dataclass
+class QueueDetails:
+    code: Optional[QueueDetailsCodeCode] = None
+    """The reason for queuing the run. * `ACTIVE_RUNS_LIMIT_REACHED`: The run was queued due to
+    reaching the workspace limit of active task runs. * `MAX_CONCURRENT_RUNS_REACHED`: The run was
+    queued due to reaching the per-job limit of concurrent job runs. *
+    `ACTIVE_RUN_JOB_TASKS_LIMIT_REACHED`: The run was queued due to reaching the workspace limit of
+    active run job tasks."""
+
+    message: Optional[str] = None
+    """A descriptive message with the queuing details. This field is unstructured, and its exact format
+    is subject to change."""
+
+    def as_dict(self) -> dict:
+        """Serializes the QueueDetails into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.code is not None: body['code'] = self.code.value
+        if self.message is not None: body['message'] = self.message
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> QueueDetails:
+        """Deserializes the QueueDetails from a dictionary."""
+        return cls(code=_enum(d, 'code', QueueDetailsCodeCode), message=d.get('message', None))
+
+
+class QueueDetailsCodeCode(Enum):
+    """The reason for queuing the run. * `ACTIVE_RUNS_LIMIT_REACHED`: The run was queued due to
+    reaching the workspace limit of active task runs. * `MAX_CONCURRENT_RUNS_REACHED`: The run was
+    queued due to reaching the per-job limit of concurrent job runs. *
+    `ACTIVE_RUN_JOB_TASKS_LIMIT_REACHED`: The run was queued due to reaching the workspace limit of
+    active run job tasks."""
+
+    ACTIVE_RUNS_LIMIT_REACHED = 'ACTIVE_RUNS_LIMIT_REACHED'
+    ACTIVE_RUN_JOB_TASKS_LIMIT_REACHED = 'ACTIVE_RUN_JOB_TASKS_LIMIT_REACHED'
+    MAX_CONCURRENT_RUNS_REACHED = 'MAX_CONCURRENT_RUNS_REACHED'
+
+
 @dataclass
 class QueueSettings:
     enabled: bool
@@ -2343,7 +2386,10 @@ class RepairHistoryItem:
     """The start time of the (repaired) run."""
 
     state: Optional[RunState] = None
-    """The current state of the run."""
+    """Deprecated. Please use the `status` field instead."""
+
+    status: Optional[RunStatus] = None
+    """The current status of the run"""
 
     task_run_ids: Optional[List[int]] = None
     """The run IDs of the task runs that ran as part of this repair history item."""
@@ -2358,6 +2404,7 @@ class RepairHistoryItem:
         if self.id is not None: body['id'] = self.id
         if self.start_time is not None: body['start_time'] = self.start_time
         if self.state: body['state'] = self.state.as_dict()
+        if self.status: body['status'] = self.status.as_dict()
         if self.task_run_ids: body['task_run_ids'] = [v for v in self.task_run_ids]
         if self.type is not None: body['type'] = self.type.value
         return body
@@ -2369,6 +2416,7 @@ class RepairHistoryItem:
                    id=d.get('id', None),
                    start_time=d.get('start_time', None),
                    state=_from_dict(d, 'state', RunState),
+                   status=_from_dict(d, 'status', RunStatus),
                    task_run_ids=d.get('task_run_ids', None),
                    type=_enum(d, 'type', RepairHistoryItemType))
 
@@ -2873,7 +2921,10 @@ class Run:
     scheduled to run on a new cluster, this is the time the cluster creation call is issued."""
 
     state: Optional[RunState] = None
-    """The current state of the run."""
+    """Deprecated. Please use the `status` field instead."""
+
+    status: Optional[RunStatus] = None
+    """The current status of the run"""
 
     tasks: Optional[List[RunTask]] = None
     """The list of tasks performed by the run. Each task has its own `run_id` which you can use to call
@@ -2927,6 +2978,7 @@ class Run:
         if self.setup_duration is not None: body['setup_duration'] = self.setup_duration
         if self.start_time is not None: body['start_time'] = self.start_time
         if self.state: body['state'] = self.state.as_dict()
+        if self.status: body['status'] = self.status.as_dict()
         if self.tasks: body['tasks'] = [v.as_dict() for v in self.tasks]
         if self.trigger is not None: body['trigger'] = self.trigger.value
         if self.trigger_info: body['trigger_info'] = self.trigger_info.as_dict()
@@ -2965,6 +3017,7 @@ class Run:
                    setup_duration=d.get('setup_duration', None),
                    start_time=d.get('start_time', None),
                    state=_from_dict(d, 'state', RunState),
+                   status=_from_dict(d, 'status', RunStatus),
                    tasks=_repeated_dict(d, 'tasks', RunTask),
                    trigger=_enum(d, 'trigger', TriggerType),
                    trigger_info=_from_dict(d, 'trigger_info', TriggerInfo))
@@ -3216,6 +3269,17 @@ class RunLifeCycleState(Enum):
     WAITING_FOR_RETRY = 'WAITING_FOR_RETRY'
 
 
+class RunLifecycleStateV2State(Enum):
+    """The current state of the run."""
+
+    BLOCKED = 'BLOCKED'
+    PENDING = 'PENDING'
+    QUEUED = 'QUEUED'
+    RUNNING = 'RUNNING'
+    TERMINATED = 'TERMINATED'
+    TERMINATING = 'TERMINATING'
+
+
 @dataclass
 class RunNow:
     job_id: int
@@ -3609,6 +3673,36 @@ class RunState:
                    user_cancelled_or_timedout=d.get('user_cancelled_or_timedout', None))
 
 
+@dataclass
+class RunStatus:
+    """The current status of the run"""
+
+    queue_details: Optional[QueueDetails] = None
+    """If the run was queued, details about the reason for queuing the run."""
+
+    state: Optional[RunLifecycleStateV2State] = None
+    """The current state of the run."""
+
+    termination_details: Optional[TerminationDetails] = None
+    """If the run is in a TERMINATING or TERMINATED state, details about the reason for terminating the
+    run."""
+
+    def as_dict(self) -> dict:
+        """Serializes the RunStatus into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.queue_details: body['queue_details'] = self.queue_details.as_dict()
+        if self.state is not None: body['state'] = self.state.value
+        if self.termination_details: body['termination_details'] = self.termination_details.as_dict()
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> RunStatus:
+        """Deserializes the RunStatus from a dictionary."""
+        return cls(queue_details=_from_dict(d, 'queue_details', QueueDetails),
+                   state=_enum(d, 'state', RunLifecycleStateV2State),
+                   termination_details=_from_dict(d, 'termination_details', TerminationDetails))
+
+
 @dataclass
 class RunTask:
     """Used when outputting a child run, in GetRun or ListRuns."""
@@ -3773,7 +3867,10 @@ class RunTask:
     scheduled to run on a new cluster, this is the time the cluster creation call is issued."""
 
     state: Optional[RunState] = None
-    """The current state of the run."""
+    """Deprecated. Please use the `status` field instead."""
+
+    status: Optional[RunStatus] = None
+    """The current status of the run"""
 
     timeout_seconds: Optional[int] = None
     """An optional timeout applied to each run of this job task. A value of `0` means no timeout."""
@@ -3821,6 +3918,7 @@ class RunTask:
         if self.sql_task: body['sql_task'] = self.sql_task.as_dict()
         if self.start_time is not None: body['start_time'] = self.start_time
         if self.state: body['state'] = self.state.as_dict()
+        if self.status: body['status'] = self.status.as_dict()
         if self.task_key is not None: body['task_key'] = self.task_key
         if self.timeout_seconds is not None: body['timeout_seconds'] = self.timeout_seconds
         if self.webhook_notifications: body['webhook_notifications'] = self.webhook_notifications.as_dict()
@@ -3864,6 +3962,7 @@ class RunTask:
                    sql_task=_from_dict(d, 'sql_task', SqlTask),
                    start_time=d.get('start_time', None),
                    state=_from_dict(d, 'state', RunState),
+                   status=_from_dict(d, 'status', RunStatus),
                    task_key=d.get('task_key', None),
                    timeout_seconds=d.get('timeout_seconds', None),
                    webhook_notifications=_from_dict(d, 'webhook_notifications', WebhookNotifications))
@@ -5027,6 +5126,149 @@ class TaskNotificationSettings:
                    no_alert_for_skipped_runs=d.get('no_alert_for_skipped_runs', None))
 
 
+class TerminationCodeCode(Enum):
+    """The code indicates why the run was terminated. Additional codes might be introduced in future
+    releases. * `SUCCESS`: The run was completed successfully. * `CANCELED`: The run was canceled
+    during execution by the Databricks platform; for example, if the maximum run duration was
+    exceeded. * `SKIPPED`: Run was never executed, for example, if the upstream task run failed, the
+    dependency type condition was not met, or there were no material tasks to execute. *
+    `INTERNAL_ERROR`: The run encountered an unexpected error. Refer to the state message for
+    further details. * `DRIVER_ERROR`: The run encountered an error while communicating with the
+    Spark Driver. * `CLUSTER_ERROR`: The run failed due to a cluster error. Refer to the state
+    message for further details. * `REPOSITORY_CHECKOUT_FAILED`: Failed to complete the checkout due
+    to an error when communicating with the third party service. * `INVALID_CLUSTER_REQUEST`: The
+    run failed because it issued an invalid request to start the cluster. *
+    `WORKSPACE_RUN_LIMIT_EXCEEDED`: The workspace has reached the quota for the maximum number of
+    concurrent active runs. Consider scheduling the runs over a larger time frame. *
+    `FEATURE_DISABLED`: The run failed because it tried to access a feature unavailable for the
+    workspace. * `CLUSTER_REQUEST_LIMIT_EXCEEDED`: The number of cluster creation, start, and upsize
+    requests have exceeded the allotted rate limit. Consider spreading the run execution over a
+    larger time frame. * `STORAGE_ACCESS_ERROR`: The run failed due to an error when accessing the
+    customer blob storage. Refer to the state message for further details. * `RUN_EXECUTION_ERROR`:
+    The run was completed with task failures. For more details, refer to the state message or run
+    output. * `UNAUTHORIZED_ERROR`: The run failed due to a permission issue while accessing a
+    resource. Refer to the state message for further details. * `LIBRARY_INSTALLATION_ERROR`: The
+    run failed while installing the user-requested library. Refer to the state message for further
+    details. The causes might include, but are not limited to: The provided library is invalid,
+    there are insufficient permissions to install the library, and so forth. *
+    `MAX_CONCURRENT_RUNS_EXCEEDED`: The scheduled run exceeds the limit of maximum concurrent runs
+    set for the job. * `MAX_SPARK_CONTEXTS_EXCEEDED`: The run is scheduled on a cluster that has
+    already reached the maximum number of contexts it is configured to create. See: [Link]. *
+    `RESOURCE_NOT_FOUND`: A resource necessary for run execution does not exist. Refer to the state
+    message for further details. * `INVALID_RUN_CONFIGURATION`: The run failed due to an invalid
+    configuration. Refer to the state message for further details. * `CLOUD_FAILURE`: The run failed
+    due to a cloud provider issue. Refer to the state message for further details. *
+    `MAX_JOB_QUEUE_SIZE_EXCEEDED`: The run was skipped due to reaching the job level queue size
+    limit.
+    
+    [Link]: https://kb.databricks.com/en_US/notebooks/too-many-execution-contexts-are-open-right-now"""
+
+    CANCELED = 'CANCELED'
+    CLOUD_FAILURE = 'CLOUD_FAILURE'
+    CLUSTER_ERROR = 'CLUSTER_ERROR'
+    CLUSTER_REQUEST_LIMIT_EXCEEDED = 'CLUSTER_REQUEST_LIMIT_EXCEEDED'
+    DRIVER_ERROR = 'DRIVER_ERROR'
+    FEATURE_DISABLED = 'FEATURE_DISABLED'
+    INTERNAL_ERROR = 'INTERNAL_ERROR'
+    INVALID_CLUSTER_REQUEST = 'INVALID_CLUSTER_REQUEST'
+    INVALID_RUN_CONFIGURATION = 'INVALID_RUN_CONFIGURATION'
+    LIBRARY_INSTALLATION_ERROR = 'LIBRARY_INSTALLATION_ERROR'
+    MAX_CONCURRENT_RUNS_EXCEEDED = 'MAX_CONCURRENT_RUNS_EXCEEDED'
+    MAX_JOB_QUEUE_SIZE_EXCEEDED = 'MAX_JOB_QUEUE_SIZE_EXCEEDED'
+    MAX_SPARK_CONTEXTS_EXCEEDED = 'MAX_SPARK_CONTEXTS_EXCEEDED'
+    REPOSITORY_CHECKOUT_FAILED = 'REPOSITORY_CHECKOUT_FAILED'
+    RESOURCE_NOT_FOUND = 'RESOURCE_NOT_FOUND'
+    RUN_EXECUTION_ERROR = 'RUN_EXECUTION_ERROR'
+    SKIPPED = 'SKIPPED'
+    STORAGE_ACCESS_ERROR = 'STORAGE_ACCESS_ERROR'
+    SUCCESS = 'SUCCESS'
+    UNAUTHORIZED_ERROR = 'UNAUTHORIZED_ERROR'
+    WORKSPACE_RUN_LIMIT_EXCEEDED = 'WORKSPACE_RUN_LIMIT_EXCEEDED'
+
+
+@dataclass
+class TerminationDetails:
+    code: Optional[TerminationCodeCode] = None
+    """The code indicates why the run was terminated. Additional codes might be introduced in future
+    releases. * `SUCCESS`: The run was completed successfully. * `CANCELED`: The run was canceled
+    during execution by the Databricks platform; for example, if the maximum run duration was
+    exceeded. * `SKIPPED`: Run was never executed, for example, if the upstream task run failed, the
+    dependency type condition was not met, or there were no material tasks to execute. *
+    `INTERNAL_ERROR`: The run encountered an unexpected error. Refer to the state message for
+    further details. * `DRIVER_ERROR`: The run encountered an error while communicating with the
+    Spark Driver. * `CLUSTER_ERROR`: The run failed due to a cluster error. Refer to the state
+    message for further details. * `REPOSITORY_CHECKOUT_FAILED`: Failed to complete the checkout due
+    to an error when communicating with the third party service. * `INVALID_CLUSTER_REQUEST`: The
+    run failed because it issued an invalid request to start the cluster. *
+    `WORKSPACE_RUN_LIMIT_EXCEEDED`: The workspace has reached the quota for the maximum number of
+    concurrent active runs. Consider scheduling the runs over a larger time frame. *
+    `FEATURE_DISABLED`: The run failed because it tried to access a feature unavailable for the
+    workspace. * `CLUSTER_REQUEST_LIMIT_EXCEEDED`: The number of cluster creation, start, and upsize
+    requests have exceeded the allotted rate limit. Consider spreading the run execution over a
+    larger time frame. * `STORAGE_ACCESS_ERROR`: The run failed due to an error when accessing the
+    customer blob storage. Refer to the state message for further details. * `RUN_EXECUTION_ERROR`:
+    The run was completed with task failures. For more details, refer to the state message or run
+    output. * `UNAUTHORIZED_ERROR`: The run failed due to a permission issue while accessing a
+    resource. Refer to the state message for further details. * `LIBRARY_INSTALLATION_ERROR`: The
+    run failed while installing the user-requested library. Refer to the state message for further
+    details. The causes might include, but are not limited to: The provided library is invalid,
+    there are insufficient permissions to install the library, and so forth. *
+    `MAX_CONCURRENT_RUNS_EXCEEDED`: The scheduled run exceeds the limit of maximum concurrent runs
+    set for the job. * `MAX_SPARK_CONTEXTS_EXCEEDED`: The run is scheduled on a cluster that has
+    already reached the maximum number of contexts it is configured to create. See: [Link]. *
+    `RESOURCE_NOT_FOUND`: A resource necessary for run execution does not exist. Refer to the state
+    message for further details. * `INVALID_RUN_CONFIGURATION`: The run failed due to an invalid
+    configuration. Refer to the state message for further details. * `CLOUD_FAILURE`: The run failed
+    due to a cloud provider issue. Refer to the state message for further details. *
+    `MAX_JOB_QUEUE_SIZE_EXCEEDED`: The run was skipped due to reaching the job level queue size
+    limit.
+    
+    [Link]: https://kb.databricks.com/en_US/notebooks/too-many-execution-contexts-are-open-right-now"""
+
+    message: Optional[str] = None
+    """A descriptive message with the termination details. This field is unstructured and the format
+    might change."""
+
+    type: Optional[TerminationTypeType] = None
+    """* `SUCCESS`: The run terminated without any issues * `INTERNAL_ERROR`: An error occurred in the
+    Databricks platform. Please look at the [status page] or contact support if the issue persists.
+    * `CLIENT_ERROR`: The run was terminated because of an error caused by user input or the job
+    configuration. * `CLOUD_FAILURE`: The run was terminated because of an issue with your cloud
+    provider.
+    
+    [status page]: https://status.databricks.com/"""
+
+    def as_dict(self) -> dict:
+        """Serializes the TerminationDetails into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.code is not None: body['code'] = self.code.value
+        if self.message is not None: body['message'] = self.message
+        if self.type is not None: body['type'] = self.type.value
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> TerminationDetails:
+        """Deserializes the TerminationDetails from a dictionary."""
+        return cls(code=_enum(d, 'code', TerminationCodeCode),
+                   message=d.get('message', None),
+                   type=_enum(d, 'type', TerminationTypeType))
+
+
+class TerminationTypeType(Enum):
+    """* `SUCCESS`: The run terminated without any issues * `INTERNAL_ERROR`: An error occurred in the
+    Databricks platform. Please look at the [status page] or contact support if the issue persists.
+    * `CLIENT_ERROR`: The run was terminated because of an error caused by user input or the job
+    configuration. * `CLOUD_FAILURE`: The run was terminated because of an issue with your cloud
+    provider.
+    
+    [status page]: https://status.databricks.com/"""
+
+    CLIENT_ERROR = 'CLIENT_ERROR'
+    CLOUD_FAILURE = 'CLOUD_FAILURE'
+    INTERNAL_ERROR = 'INTERNAL_ERROR'
+    SUCCESS = 'SUCCESS'
+
+
 @dataclass
 class TriggerInfo:
     """Additional details about what triggered the run"""

databricks/sdk/service/ml.py

@@ -4143,10 +4143,16 @@ class ExperimentsAPI:
         """Get all artifacts.
         
         List artifacts for a run. Takes an optional `artifact_path` prefix. If it is specified, the response
-        contains only artifacts with the specified prefix.",
+        contains only artifacts with the specified prefix. This API does not support pagination when listing
+        artifacts in UC Volumes. A maximum of 1000 artifacts will be retrieved for UC Volumes. Please call
+        `/api/2.0/fs/directories{directory_path}` for listing artifacts in UC Volumes, which supports
+        pagination. See [List directory contents | Files API](/api/workspace/files/listdirectorycontents).
         
         :param page_token: str (optional)
-          Token indicating the page of artifact results to fetch
+          Token indicating the page of artifact results to fetch. `page_token` is not supported when listing
+          artifacts in UC Volumes. A maximum of 1000 artifacts will be retrieved for UC Volumes. Please call
+          `/api/2.0/fs/directories{directory_path}` for listing artifacts in UC Volumes, which supports
+          pagination. See [List directory contents | Files API](/api/workspace/files/listdirectorycontents).
         :param path: str (optional)
           Filter artifacts matching this path (a relative path from the root artifact directory).
         :param run_id: str (optional)

databricks/sdk/service/serving.py

@@ -1629,14 +1629,6 @@ class ServedModelInput:
     model_version: str
     """The version of the model in Databricks Model Registry or Unity Catalog to be served."""
 
-    workload_size: ServedModelInputWorkloadSize
-    """The workload size of the served model. The workload size corresponds to a range of provisioned
-    concurrency that the compute will autoscale between. A single unit of provisioned concurrency
-    can process one request at a time. Valid workload sizes are "Small" (4 - 4 provisioned
-    concurrency), "Medium" (8 - 16 provisioned concurrency), and "Large" (16 - 64 provisioned
-    concurrency). If scale-to-zero is enabled, the lower bound of the provisioned concurrency for
-    each workload size will be 0."""
-
     scale_to_zero_enabled: bool
     """Whether the compute resources for the served model should scale down to zero."""
 
@@ -1649,11 +1641,25 @@ class ServedModelInput:
     instance_profile_arn: Optional[str] = None
     """ARN of the instance profile that the served model will use to access AWS resources."""
 
+    max_provisioned_throughput: Optional[int] = None
+    """The maximum tokens per second that the endpoint can scale up to."""
+
+    min_provisioned_throughput: Optional[int] = None
+    """The minimum tokens per second that the endpoint can scale down to."""
+
     name: Optional[str] = None
     """The name of a served model. It must be unique across an endpoint. If not specified, this field
     will default to <model-name>-<model-version>. A served model name can consist of alphanumeric
     characters, dashes, and underscores."""
 
+    workload_size: Optional[ServedModelInputWorkloadSize] = None
+    """The workload size of the served model. The workload size corresponds to a range of provisioned
+    concurrency that the compute will autoscale between. A single unit of provisioned concurrency
+    can process one request at a time. Valid workload sizes are "Small" (4 - 4 provisioned
+    concurrency), "Medium" (8 - 16 provisioned concurrency), and "Large" (16 - 64 provisioned
+    concurrency). If scale-to-zero is enabled, the lower bound of the provisioned concurrency for
+    each workload size will be 0."""
+
     workload_type: Optional[ServedModelInputWorkloadType] = None
     """The workload type of the served model. The workload type selects which type of compute to use in
     the endpoint. The default value for this parameter is "CPU". For deep learning workloads, GPU
@@ -1667,6 +1673,10 @@ class ServedModelInput:
         body = {}
         if self.environment_vars: body['environment_vars'] = self.environment_vars
         if self.instance_profile_arn is not None: body['instance_profile_arn'] = self.instance_profile_arn
+        if self.max_provisioned_throughput is not None:
+            body['max_provisioned_throughput'] = self.max_provisioned_throughput
+        if self.min_provisioned_throughput is not None:
+            body['min_provisioned_throughput'] = self.min_provisioned_throughput
         if self.model_name is not None: body['model_name'] = self.model_name
         if self.model_version is not None: body['model_version'] = self.model_version
         if self.name is not None: body['name'] = self.name
@@ -1680,6 +1690,8 @@ class ServedModelInput:
         """Deserializes the ServedModelInput from a dictionary."""
         return cls(environment_vars=d.get('environment_vars', None),
                    instance_profile_arn=d.get('instance_profile_arn', None),
+                   max_provisioned_throughput=d.get('max_provisioned_throughput', None),
+                   min_provisioned_throughput=d.get('min_provisioned_throughput', None),
                    model_name=d.get('model_name', None),
                    model_version=d.get('model_version', None),
                    name=d.get('name', None),

databricks/sdk/service/vectorsearch.py

@@ -231,6 +231,11 @@ class DeleteIndexResponse:
 
 @dataclass
 class DeltaSyncVectorIndexSpecRequest:
+    columns_to_sync: Optional[List[str]] = None
+    """[Optional] Select the columns to sync with the vector index. If you leave this field blank, all
+    columns from the source table are synced with the index. The primary key column and embedding
+    source column or embedding vector column are always synced."""
+
     embedding_source_columns: Optional[List[EmbeddingSourceColumn]] = None
     """The columns that contain the embedding source."""
 
@@ -256,6 +261,7 @@ class DeltaSyncVectorIndexSpecRequest:
     def as_dict(self) -> dict:
         """Serializes the DeltaSyncVectorIndexSpecRequest into a dictionary suitable for use as a JSON request body."""
         body = {}
+        if self.columns_to_sync: body['columns_to_sync'] = [v for v in self.columns_to_sync]
         if self.embedding_source_columns:
             body['embedding_source_columns'] = [v.as_dict() for v in self.embedding_source_columns]
         if self.embedding_vector_columns:
@@ -269,7 +275,8 @@ class DeltaSyncVectorIndexSpecRequest:
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DeltaSyncVectorIndexSpecRequest:
         """Deserializes the DeltaSyncVectorIndexSpecRequest from a dictionary."""
-        return cls(embedding_source_columns=_repeated_dict(d, 'embedding_source_columns',
+        return cls(columns_to_sync=d.get('columns_to_sync', None),
+                   embedding_source_columns=_repeated_dict(d, 'embedding_source_columns',
                                                            EmbeddingSourceColumn),
                    embedding_vector_columns=_repeated_dict(d, 'embedding_vector_columns',
                                                            EmbeddingVectorColumn),

databricks/sdk/version.py

@@ -1 +1 @@
-__version__ = '0.31.1'
+__version__ = '0.32.0'

{databricks_sdk-0.31.1.dist-info → databricks_sdk-0.32.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: databricks-sdk
-Version: 0.31.1
+Version: 0.32.0
 Summary: Databricks SDK for Python (Beta)
 Home-page: https://databricks-sdk-py.readthedocs.io
 Author: Serge Smertin

{databricks_sdk-0.31.1.dist-info → databricks_sdk-0.32.0.dist-info}/RECORD

@@ -5,7 +5,7 @@ databricks/sdk/azure.py,sha256=8P7nEdun0hbQCap9Ojo7yZse_JHxnhYsE6ApojnPz7Q,1009
 databricks/sdk/casing.py,sha256=NKYPrfPbQjM7lU4hhNQK3z1jb_VEA29BfH4FEdby2tg,1137
 databricks/sdk/clock.py,sha256=Ivlow0r_TkXcTJ8UXkxSA0czKrY0GvwHAeOvjPkJnAQ,1360
 databricks/sdk/config.py,sha256=FWEiIY34C_4Mmv8B9w284BR2FHug2T2ySpmtyg51ttA,21139
-databricks/sdk/core.py,sha256=PWU2kTHXOF6x7i9_yRUFGj-iusr_Mo7awROiBpA9nJQ,20398
+databricks/sdk/core.py,sha256=7zjTSCUNrI1R4WFvQ-243tKyuDhBPQdg1rrJB-3IU04,15636
 databricks/sdk/credentials_provider.py,sha256=1y5Very59gwWIJkL3183PwPaYtiYJDAycn1hp2JZVx4,29282
 databricks/sdk/data_plane.py,sha256=Er2z2fT-KVupJKzGozGGZ-jCQ3AmDWq-DZppahIK6tU,2591
 databricks/sdk/dbutils.py,sha256=HFCuB-el6SFKhF8qRfJxYANtyLTm-VG9GtQuQgZXFkM,15741
@@ -14,17 +14,20 @@ databricks/sdk/oauth.py,sha256=KzcJPYLL3JL6RDvf_Q8SDAaF9xSaoYNCRD4rYInZDuo,18319
 databricks/sdk/py.typed,sha256=pSvaHpbY1UPNEXyVFUjlgBhjPFZMmVC_UNrPC7eMOHI,74
 databricks/sdk/retries.py,sha256=WgLh12bwdBc6fCQlaig3kKu18cVhPzFDGsspvq629Ew,2454
 databricks/sdk/useragent.py,sha256=I2-VnJSE6cg9QV4GXkoQSkHsEB3bDvRGgkawbBNl4G0,5540
-databricks/sdk/version.py,sha256=tRB_zFsl50GcGW0VJzWbf3saZdjvFdafbOBwklaz9EU,23
+databricks/sdk/version.py,sha256=Mhyb-htYwxK6GrdhYyT56CJeGp4A5jZLmueZGXkszEY,23
 databricks/sdk/_widgets/__init__.py,sha256=Qm3JB8LmdPgEn_-VgxKkodTO4gn6OdaDPwsYcDmeIRI,2667
 databricks/sdk/_widgets/default_widgets_utils.py,sha256=Rk59AFzVYVpOektB_yC_7j-vSt5OdtZA85IlG0kw0xA,1202
 databricks/sdk/_widgets/ipywidgets_utils.py,sha256=P-AyGeahPiX3S59mxpAMgffi4gyJ0irEOY7Ekkn9nQ0,2850
-databricks/sdk/errors/__init__.py,sha256=3l_wHB0S9Y6mDc_c5mUHb-TndDQxa-tdPeWmTbnBNAo,176
-databricks/sdk/errors/base.py,sha256=oawBxpuoyImsLu29ntpAgOc6RQ7kD-UcuFFER9jB3iI,3880
-databricks/sdk/errors/mapper.py,sha256=sK4aoloV-F8h1J4YHFrcNVAUBLLQQFti-ceXVmm6HpU,1386
+databricks/sdk/errors/__init__.py,sha256=S_xkqeqBtYrW-QeFL007woajSA07TLwDKCgD0h3zxAI,211
+databricks/sdk/errors/base.py,sha256=eSOKUZ5t8e_S6OFrsEyzx-vraQ0PYemsP98H9Md53M4,4893
+databricks/sdk/errors/mapper.py,sha256=G52KAcRfDFUOjgS-gvh8_X_3FXqN1P5Mmgi6F0VAb5k,1162
 databricks/sdk/errors/overrides.py,sha256=u1fZ1X2gPRv_zf1u_4EqVzbWHiFsPzm_X0sMNOCMwAE,1649
+databricks/sdk/errors/parser.py,sha256=_R8Gd5IMlGQbwsVxDKjTchA46YKAulIENAQm_HjIwyU,6085
 databricks/sdk/errors/platform.py,sha256=0EwGUTcmoobAK41KsFAnRkT6AlOY_umzr4jWEgd-6hY,3113
-databricks/sdk/errors/private_link.py,sha256=6wVRJQqousGQC7qfT0pV8LqujqfR3XLbSix_XjqVC8s,2304
+databricks/sdk/errors/private_link.py,sha256=-cDxHSm7MBpdaEFgDGvbrW4dxCRVQwSunGhwe5Ay80g,2314
 databricks/sdk/errors/sdk.py,sha256=_euMruhvquB0v_SKtgqxJUiyXHWuTb4Jl7ji6_h0E_A,109
+databricks/sdk/logger/__init__.py,sha256=0_sSQfDkaFGqMHZUVw-g_Ax-RFmOv0Z6NjxCVAeUSO0,41
+databricks/sdk/logger/round_trip_logger.py,sha256=c33VEVdy_tifQ62lF-2U39nvaRfGaahFqULb0Z7g3mk,4746
 databricks/sdk/mixins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 databricks/sdk/mixins/compute.py,sha256=khb00BzBckc4RLUF4-GnNMCSO5lXKt_XYMM3IhiUxlA,11237
 databricks/sdk/mixins/files.py,sha256=bLGFu1kVIQECTmuc_9jUf-n_Cth4COBMbmKqAYxkEkM,20542
@@ -35,26 +38,26 @@ databricks/sdk/service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 databricks/sdk/service/_internal.py,sha256=nWbJfW5eJCQgAZ3TmA26xoWb6SNZ5N76ZA8bO1N4AsU,1961
 databricks/sdk/service/apps.py,sha256=536HvScC96edq9EXMUcyVh1h2jE5zCeCMa_l7HZiu20,38170
 databricks/sdk/service/billing.py,sha256=Ru6GumI-M4_X71HTMj2VSVBQ7tRMTrwKzhdwNyiC3fA,69733
-databricks/sdk/service/catalog.py,sha256=pJ3LWcHaljhfXKAJoHnbJpaiSOUpGymsWLHfSYaDOdo,430741
+databricks/sdk/service/catalog.py,sha256=CUm4OCGgvTUNDLXKURsp-Fj5Cx7A-iKTNnQ2dcGSsZ0,434746
 databricks/sdk/service/compute.py,sha256=u8iVnqGFS7WGrLYQ0CrhwQEXs0WkjoPbHsHeVA6-h6g,433402
 databricks/sdk/service/dashboards.py,sha256=-nrRkNLBDJU4w0OAy-EjZkI8I5ktYqX475YTAW65u9I,76081
 databricks/sdk/service/files.py,sha256=VCt83YSI9rhQexmxaQdrUXHq2UCYfZcDMLvJx5X6n1M,38162
-databricks/sdk/service/iam.py,sha256=fj1RQtCdg8E8oUt1SEnm6PzMR6UB-jaCn8M354KiB-o,148500
-databricks/sdk/service/jobs.py,sha256=c9m2GoNfMBCGSfr82MZd6zf2aDIza6Ip0jaaW8E_3hQ,318698
+databricks/sdk/service/iam.py,sha256=P_2k7_MDV-Iw4heUD78i3XQriSoYZX1Jhhfnn4gS4Zk,148548
+databricks/sdk/service/jobs.py,sha256=vcwp6ZaMJ1xo5HPkGg63k-RYVulQmA4zaXcEbJcpGwI,332433
 databricks/sdk/service/marketplace.py,sha256=Fgk_8V9zbQ8QcNPUw-yZehHv8LgnDtFJUe-YixjxkYo,136405
-databricks/sdk/service/ml.py,sha256=vohBdESClI3EOpO-ZZ44W-CMz1alq5Tw4oJnWa99Z2M,236128
+databricks/sdk/service/ml.py,sha256=KG5nG9ap1IJejha2JFhX13f61C6tShO0AnHvLNDz0KE,236858
 databricks/sdk/service/oauth2.py,sha256=67pr6gUnYwO6BaGNQfjW1qvcEB3ejdNbI9Pmvqs5bSE,39928
 databricks/sdk/service/pipelines.py,sha256=tGCo1F3tW1GxB9Q63qsh2AyisJmXqYSsGkJK0OdS06Q,119378
 databricks/sdk/service/provisioning.py,sha256=DP4Df4X-p0JEUk4zAJQhjX_wxpMi673OKLXFhxl6YSE,142678
-databricks/sdk/service/serving.py,sha256=BfShf0ceupXgLccU5zp1CZyBW1260Ga73USM2T5KxXs,140008
+databricks/sdk/service/serving.py,sha256=DfgyhXi1UB88pYJnxXqzYoAZ8vqBCbr5OFitYdHOztA,140737
 databricks/sdk/service/settings.py,sha256=7PXxsrXUe7exM35O7_iUp9r78zn5oGnPbhX_sh3v1_0,193732
 databricks/sdk/service/sharing.py,sha256=kalJYd0v1SwuGhlCaq4l2ZhzNlev9OwNbCXFIOKIMXU,113253
 databricks/sdk/service/sql.py,sha256=RaXIYMDtHbhvB7gtSMyvQsqiO_E0cMz5NXeTsrqtPVk,334558
-databricks/sdk/service/vectorsearch.py,sha256=ZfiTEpTNg8nnzPuw24MeiDn8eq6PHmEWqTHS0zdDdEo,62484
+databricks/sdk/service/vectorsearch.py,sha256=a5Y4vrS_oAJJqa69XwKMANhGuZi5glS0PSXBXz1bKGU,62961
 databricks/sdk/service/workspace.py,sha256=FKLf5esRmfFstIXo7HQg6HQCzQ2svrb6ulr8yzZ7-8U,101182
-databricks_sdk-0.31.1.dist-info/LICENSE,sha256=afBgTZo-JsYqj4VOjnejBetMuHKcFR30YobDdpVFkqY,11411
-databricks_sdk-0.31.1.dist-info/METADATA,sha256=pXe1gIePCrKpmVF1TtO18KrN6u7DTwWjbi1a2vXWpc4,37967
-databricks_sdk-0.31.1.dist-info/NOTICE,sha256=Qnc0m8JjZNTDV80y0h1aJGvsr4GqM63m1nr2VTypg6E,963
-databricks_sdk-0.31.1.dist-info/WHEEL,sha256=UvcQYKBHoFqaQd6LKyqHw9fxEolWLQnlzP0h_LgJAfI,91
-databricks_sdk-0.31.1.dist-info/top_level.txt,sha256=7kRdatoSgU0EUurRQJ_3F1Nv4EOSHWAr6ng25tJOJKU,11
-databricks_sdk-0.31.1.dist-info/RECORD,,
+databricks_sdk-0.32.0.dist-info/LICENSE,sha256=afBgTZo-JsYqj4VOjnejBetMuHKcFR30YobDdpVFkqY,11411
+databricks_sdk-0.32.0.dist-info/METADATA,sha256=5bGVpoXLejnZgLyT7jHHe5zK-7iW7ISiKOVyThA3Il0,37967
+databricks_sdk-0.32.0.dist-info/NOTICE,sha256=Qnc0m8JjZNTDV80y0h1aJGvsr4GqM63m1nr2VTypg6E,963
+databricks_sdk-0.32.0.dist-info/WHEEL,sha256=uCRv0ZEik_232NlR4YDw4Pv3Ajt5bKvMH13NUU7hFuI,91
+databricks_sdk-0.32.0.dist-info/top_level.txt,sha256=7kRdatoSgU0EUurRQJ_3F1Nv4EOSHWAr6ng25tJOJKU,11
+databricks_sdk-0.32.0.dist-info/RECORD,,

{databricks_sdk-0.31.1.dist-info → databricks_sdk-0.32.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (74.0.0)
+Generator: setuptools (74.1.1)
 Root-Is-Purelib: true
 Tag: py3-none-any