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

databricks/sdk/__init__.py

@@ -8,6 +8,7 @@ import databricks.sdk.dbutils as dbutils
 import databricks.sdk.service as service
 from databricks.sdk import azure
 from databricks.sdk.credentials_provider import CredentialsStrategy
+from databricks.sdk.data_plane import DataPlaneTokenSource
 from databricks.sdk.mixins.compute import ClustersExt
 from databricks.sdk.mixins.files import DbfsExt, FilesExt
 from databricks.sdk.mixins.jobs import JobsExt
@@ -63,7 +64,8 @@ from databricks.sdk.service.marketplace import (
     ProviderExchangeFiltersAPI, ProviderExchangesAPI, ProviderFilesAPI,
     ProviderListingsAPI, ProviderPersonalizationRequestsAPI,
     ProviderProviderAnalyticsDashboardsAPI, ProviderProvidersAPI)
-from databricks.sdk.service.ml import ExperimentsAPI, ModelRegistryAPI
+from databricks.sdk.service.ml import (ExperimentsAPI, ForecastingAPI,
+                                       ModelRegistryAPI)
 from databricks.sdk.service.oauth2 import (AccountFederationPolicyAPI,
                                            CustomAppIntegrationAPI,
                                            OAuthPublishedAppsAPI,
@@ -284,8 +286,11 @@ class WorkspaceClient:
         self._secrets = service.workspace.SecretsAPI(self._api_client)
         self._service_principals = service.iam.ServicePrincipalsAPI(self._api_client)
         self._serving_endpoints = serving_endpoints
+        serving_endpoints_data_plane_token_source = DataPlaneTokenSource(
+            self._config.host, self._config.oauth_token, not self._config.enable_experimental_async_token_refresh
+        )
         self._serving_endpoints_data_plane = service.serving.ServingEndpointsDataPlaneAPI(
-            self._api_client, serving_endpoints
+            self._api_client, serving_endpoints, serving_endpoints_data_plane_token_source
         )
         self._settings = service.settings.SettingsAPI(self._api_client)
         self._shares = service.sharing.SharesAPI(self._api_client)
@@ -305,6 +310,7 @@ class WorkspaceClient:
         self._workspace = WorkspaceExt(self._api_client)
         self._workspace_bindings = service.catalog.WorkspaceBindingsAPI(self._api_client)
         self._workspace_conf = service.settings.WorkspaceConfAPI(self._api_client)
+        self._forecasting = service.ml.ForecastingAPI(self._api_client)
 
     @property
     def config(self) -> client.Config:
@@ -808,6 +814,11 @@ class WorkspaceClient:
         """This API allows updating known workspace settings for advanced users."""
         return self._workspace_conf
 
+    @property
+    def forecasting(self) -> service.ml.ForecastingAPI:
+        """The Forecasting API allows you to create and get serverless forecasting experiments."""
+        return self._forecasting
+
     def get_workspace_id(self) -> int:
         """Get the workspace ID of the workspace that this client is connected to."""
         response = self._api_client.do("GET", "/api/2.0/preview/scim/v2/Me", response_headers=["X-Databricks-Org-Id"])

databricks/sdk/config.py

@@ -95,6 +95,10 @@ class Config:
     max_connections_per_pool: int = ConfigAttribute()
     databricks_environment: Optional[DatabricksEnvironment] = None
 
+    enable_experimental_async_token_refresh: bool = ConfigAttribute(
+        env="DATABRICKS_ENABLE_EXPERIMENTAL_ASYNC_TOKEN_REFRESH"
+    )
+
     enable_experimental_files_api_client: bool = ConfigAttribute(env="DATABRICKS_ENABLE_EXPERIMENTAL_FILES_API_CLIENT")
     files_api_client_download_max_total_recovers = None
     files_api_client_download_max_total_recovers_without_progressing = 1

databricks/sdk/credentials_provider.py

@@ -191,6 +191,7 @@ def oauth_service_principal(cfg: "Config") -> Optional[CredentialsProvider]:
         token_url=oidc.token_endpoint,
         scopes=["all-apis"],
         use_header=True,
+        disable_async=not cfg.enable_experimental_async_token_refresh,
     )
 
     def inner() -> Dict[str, str]:
@@ -290,6 +291,7 @@ def azure_service_principal(cfg: "Config") -> CredentialsProvider:
             token_url=f"{aad_endpoint}{cfg.azure_tenant_id}/oauth2/token",
             endpoint_params={"resource": resource},
             use_params=True,
+            disable_async=not cfg.enable_experimental_async_token_refresh,
         )
 
     _ensure_host_present(cfg, token_source_for)
@@ -355,6 +357,7 @@ def github_oidc_azure(cfg: "Config") -> Optional[CredentialsProvider]:
         token_url=f"{aad_endpoint}{cfg.azure_tenant_id}/oauth2/token",
         endpoint_params=params,
         use_params=True,
+        disable_async=not cfg.enable_experimental_async_token_refresh,
     )
 
     def refreshed_headers() -> Dict[str, str]:
@@ -458,8 +461,9 @@ class CliTokenSource(Refreshable):
         token_type_field: str,
         access_token_field: str,
         expiry_field: str,
+        disable_async: bool = True,
     ):
-        super().__init__()
+        super().__init__(disable_async=disable_async)
         self._cmd = cmd
         self._token_type_field = token_type_field
         self._access_token_field = access_token_field
@@ -690,6 +694,7 @@ class DatabricksCliTokenSource(CliTokenSource):
             token_type_field="token_type",
             access_token_field="access_token",
             expiry_field="expiry",
+            disable_async=not cfg.enable_experimental_async_token_refresh,
         )
 
     @staticmethod

databricks/sdk/data_plane.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import threading
 from dataclasses import dataclass
-from typing import Callable, List, Optional
+from typing import Callable, Optional
 from urllib import parse
 
 from databricks.sdk import oauth
@@ -88,61 +88,3 @@ class DataPlaneDetails:
     """URL used to query the endpoint through the DataPlane."""
     token: Token
     """Token to query the DataPlane endpoint."""
-
-
-## Old implementation. #TODO: Remove after the new implementation is used
-
-
-class DataPlaneService:
-    """Helper class to fetch and manage DataPlane details."""
-
-    from .service.serving import DataPlaneInfo
-
-    def __init__(self):
-        self._data_plane_info = {}
-        self._tokens = {}
-        self._lock = threading.Lock()
-
-    def get_data_plane_details(
-        self,
-        method: str,
-        params: List[str],
-        info_getter: Callable[[], DataPlaneInfo],
-        refresh: Callable[[str], Token],
-    ):
-        """Get and cache information required to query a Data Plane endpoint using the provided methods.
-
-        Returns a cached DataPlaneDetails if the details have already been fetched previously and are still valid.
-        If not, it uses the provided functions to fetch the details.
-
-        :param method: method name. Used to construct a unique key for the cache.
-        :param params: path params used in the "get" operation which uniquely determine the object. Used to construct a unique key for the cache.
-        :param info_getter: function which returns the DataPlaneInfo. It will only be called if the information is not already present in the cache.
-        :param refresh: function to refresh the token. It will only be called if the token is missing or expired.
-        """
-        all_elements = params.copy()
-        all_elements.insert(0, method)
-        map_key = "/".join(all_elements)
-        info = self._data_plane_info.get(map_key)
-        if not info:
-            self._lock.acquire()
-            try:
-                info = self._data_plane_info.get(map_key)
-                if not info:
-                    info = info_getter()
-                    self._data_plane_info[map_key] = info
-            finally:
-                self._lock.release()
-
-        token = self._tokens.get(map_key)
-        if not token or not token.valid:
-            self._lock.acquire()
-            token = self._tokens.get(map_key)
-            try:
-                if not token or not token.valid:
-                    token = refresh(info.authorization_details)
-                    self._tokens[map_key] = token
-            finally:
-                self._lock.release()
-
-        return DataPlaneDetails(endpoint_url=info.endpoint_url, token=token)

databricks/sdk/oauth.py

@@ -426,12 +426,16 @@ class SessionCredentials(Refreshable):
         client_id: str,
         client_secret: str = None,
         redirect_url: str = None,
+        disable_async: bool = True,
     ):
         self._token_endpoint = token_endpoint
         self._client_id = client_id
         self._client_secret = client_secret
         self._redirect_url = redirect_url
-        super().__init__(token)
+        super().__init__(
+            token=token,
+            disable_async=disable_async,
+        )
 
     def as_dict(self) -> dict:
         return {"token": self.token().as_dict()}
@@ -708,9 +712,10 @@ class ClientCredentials(Refreshable):
     scopes: List[str] = None
     use_params: bool = False
     use_header: bool = False
+    disable_async: bool = True
 
     def __post_init__(self):
-        super().__init__()
+        super().__init__(disable_async=self.disable_async)
 
     def refresh(self) -> Token:
         params = {"grant_type": "client_credentials"}

databricks/sdk/service/compute.py

@@ -3846,6 +3846,10 @@ class DestroyResponse:
 
 @dataclass
 class DiskSpec:
+    """Describes the disks that are launched for each instance in the spark cluster. For example, if
+    the cluster has 3 instances, each instance is configured to launch 2 disks, 100 GiB each, then
+    Databricks will launch a total of 6 disks, 100 GiB each, for this cluster."""
+
     disk_count: Optional[int] = None
     """The number of disks launched for each instance: - This feature is only enabled for supported
     node types. - Users can choose up to the limit of the disks supported by the node type. - For
@@ -3920,9 +3924,15 @@ class DiskSpec:
 
 @dataclass
 class DiskType:
+    """Describes the disk type."""
+
     azure_disk_volume_type: Optional[DiskTypeAzureDiskVolumeType] = None
+    """All Azure Disk types that Databricks supports. See
+    https://docs.microsoft.com/en-us/azure/storage/storage-about-disks-and-vhds-linux#types-of-disks"""
 
     ebs_volume_type: Optional[DiskTypeEbsVolumeType] = None
+    """All EBS volume types that Databricks supports. See https://aws.amazon.com/ebs/details/ for
+    details."""
 
     def as_dict(self) -> dict:
         """Serializes the DiskType into a dictionary suitable for use as a JSON request body."""
@@ -3952,12 +3962,16 @@ class DiskType:
 
 
 class DiskTypeAzureDiskVolumeType(Enum):
+    """All Azure Disk types that Databricks supports. See
+    https://docs.microsoft.com/en-us/azure/storage/storage-about-disks-and-vhds-linux#types-of-disks"""
 
     PREMIUM_LRS = "PREMIUM_LRS"
     STANDARD_LRS = "STANDARD_LRS"
 
 
 class DiskTypeEbsVolumeType(Enum):
+    """All EBS volume types that Databricks supports. See https://aws.amazon.com/ebs/details/ for
+    details."""
 
     GENERAL_PURPOSE_SSD = "GENERAL_PURPOSE_SSD"
     THROUGHPUT_OPTIMIZED_HDD = "THROUGHPUT_OPTIMIZED_HDD"
@@ -3998,6 +4012,7 @@ class DockerBasicAuth:
 @dataclass
 class DockerImage:
     basic_auth: Optional[DockerBasicAuth] = None
+    """Basic auth with username and password"""
 
     url: Optional[str] = None
     """URL of the docker image."""
@@ -5334,7 +5349,7 @@ class GetInstancePool:
     - Currently, Databricks allows at most 45 custom tags"""
 
     default_tags: Optional[Dict[str, str]] = None
-    """Tags that are added by Databricks regardless of any `custom_tags`, including:
+    """Tags that are added by Databricks regardless of any ``custom_tags``, including:
     
     - Vendor: Databricks
     
@@ -6250,7 +6265,7 @@ class InstancePoolAndStats:
     - Currently, Databricks allows at most 45 custom tags"""
 
     default_tags: Optional[Dict[str, str]] = None
-    """Tags that are added by Databricks regardless of any `custom_tags`, including:
+    """Tags that are added by Databricks regardless of any ``custom_tags``, including:
     
     - Vendor: Databricks
     
@@ -6427,10 +6442,10 @@ class InstancePoolAndStats:
 
 @dataclass
 class InstancePoolAwsAttributes:
+    """Attributes set during instance pool creation which are related to Amazon Web Services."""
+
     availability: Optional[InstancePoolAwsAttributesAvailability] = None
-    """Availability type used for the spot nodes.
-    
-    The default value is defined by InstancePoolConf.instancePoolDefaultAwsAvailability"""
+    """Availability type used for the spot nodes."""
 
     spot_bid_price_percent: Optional[int] = None
     """Calculates the bid price for AWS spot instances, as a percentage of the corresponding instance
@@ -6439,10 +6454,7 @@ class InstancePoolAwsAttributes:
     instances. Similarly, if this field is set to 200, the bid price is twice the price of on-demand
     `r3.xlarge` instances. If not specified, the default value is 100. When spot instances are
     requested for this cluster, only spot instances whose bid price percentage matches this field
-    will be considered. Note that, for safety, we enforce this field to be no more than 10000.
-    
-    The default value and documentation here should be kept consistent with
-    CommonConf.defaultSpotBidPricePercent and CommonConf.maxSpotBidPricePercent."""
+    will be considered. Note that, for safety, we enforce this field to be no more than 10000."""
 
     zone_id: Optional[str] = None
     """Identifier for the availability zone/datacenter in which the cluster resides. This string will
@@ -6485,9 +6497,7 @@ class InstancePoolAwsAttributes:
 
 
 class InstancePoolAwsAttributesAvailability(Enum):
-    """Availability type used for the spot nodes.
-
-    The default value is defined by InstancePoolConf.instancePoolDefaultAwsAvailability"""
+    """The set of AWS availability types supported when setting up nodes for a cluster."""
 
     ON_DEMAND = "ON_DEMAND"
     SPOT = "SPOT"
@@ -6495,14 +6505,16 @@ class InstancePoolAwsAttributesAvailability(Enum):
 
 @dataclass
 class InstancePoolAzureAttributes:
+    """Attributes set during instance pool creation which are related to Azure."""
+
     availability: Optional[InstancePoolAzureAttributesAvailability] = None
-    """Shows the Availability type used for the spot nodes.
-    
-    The default value is defined by InstancePoolConf.instancePoolDefaultAzureAvailability"""
+    """Availability type used for the spot nodes."""
 
     spot_bid_max_price: Optional[float] = None
-    """The default value and documentation here should be kept consistent with
-    CommonConf.defaultSpotBidMaxPrice."""
+    """With variable pricing, you have option to set a max price, in US dollars (USD) For example, the
+    value 2 would be a max price of $2.00 USD per hour. If you set the max price to be -1, the VM
+    won't be evicted based on price. The price for the VM will be the current price for spot or the
+    price for a standard VM, which ever is less, as long as there is capacity and quota available."""
 
     def as_dict(self) -> dict:
         """Serializes the InstancePoolAzureAttributes into a dictionary suitable for use as a JSON request body."""
@@ -6532,9 +6544,7 @@ class InstancePoolAzureAttributes:
 
 
 class InstancePoolAzureAttributesAvailability(Enum):
-    """Shows the Availability type used for the spot nodes.
-
-    The default value is defined by InstancePoolConf.instancePoolDefaultAzureAvailability"""
+    """The set of Azure availability types supported when setting up nodes for a cluster."""
 
     ON_DEMAND_AZURE = "ON_DEMAND_AZURE"
     SPOT_AZURE = "SPOT_AZURE"
@@ -6542,6 +6552,8 @@ class InstancePoolAzureAttributesAvailability(Enum):
 
 @dataclass
 class InstancePoolGcpAttributes:
+    """Attributes set during instance pool creation which are related to GCP."""
+
     gcp_availability: Optional[GcpAvailability] = None
     """This field determines whether the instance pool will contain preemptible VMs, on-demand VMs, or
     preemptible VMs with a fallback to on-demand VMs if the former is unavailable."""
@@ -6756,7 +6768,10 @@ class InstancePoolPermissionsRequest:
 
 
 class InstancePoolState(Enum):
-    """Current state of the instance pool."""
+    """The state of a Cluster. The current allowable state transitions are as follows:
+
+    - ``ACTIVE`` -> ``STOPPED`` - ``ACTIVE`` -> ``DELETED`` - ``STOPPED`` -> ``ACTIVE`` -
+    ``STOPPED`` -> ``DELETED``"""
 
     ACTIVE = "ACTIVE"
     DELETED = "DELETED"
@@ -7865,6 +7880,8 @@ class NodeType:
 
 @dataclass
 class PendingInstanceError:
+    """Error message of a failed pending instances"""
+
     instance_id: Optional[str] = None
 
     message: Optional[str] = None

databricks/sdk/service/dashboards.py

@@ -594,12 +594,15 @@ class GenieMessage:
     `ASKING_AI`: Waiting for the LLM to respond to the user's question. * `PENDING_WAREHOUSE`:
     Waiting for warehouse before the SQL query can start executing. * `EXECUTING_QUERY`: Executing a
     generated SQL query. Get the SQL query result by calling
-    [getMessageQueryResult](:method:genie/getMessageQueryResult) API. * `FAILED`: The response
-    generation or query execution failed. See `error` field. * `COMPLETED`: Message processing is
-    completed. Results are in the `attachments` field. Get the SQL query result by calling
-    [getMessageQueryResult](:method:genie/getMessageQueryResult) API. * `SUBMITTED`: Message has
-    been submitted. * `QUERY_RESULT_EXPIRED`: SQL result is not available anymore. The user needs to
-    rerun the query. * `CANCELLED`: Message has been cancelled."""
+    [getMessageAttachmentQueryResult](:method:genie/getMessageAttachmentQueryResult) API. *
+    `FAILED`: The response generation or query execution failed. See `error` field. * `COMPLETED`:
+    Message processing is completed. Results are in the `attachments` field. Get the SQL query
+    result by calling
+    [getMessageAttachmentQueryResult](:method:genie/getMessageAttachmentQueryResult) API. *
+    `SUBMITTED`: Message has been submitted. * `QUERY_RESULT_EXPIRED`: SQL result is not available
+    anymore. The user needs to rerun the query. Rerun the SQL query result by calling
+    [executeMessageAttachmentQuery](:method:genie/executeMessageAttachmentQuery) API. * `CANCELLED`:
+    Message has been cancelled."""
 
     user_id: Optional[int] = None
     """ID of the user who created the message"""
@@ -697,6 +700,10 @@ class GenieQueryAttachment:
     query_result_metadata: Optional[GenieResultMetadata] = None
     """Metadata associated with the query result."""
 
+    statement_id: Optional[str] = None
+    """Statement Execution API statement id. Use [Get status, manifest, and result first
+    chunk](:method:statementexecution/getstatement) to get the full result data."""
+
     title: Optional[str] = None
     """Name of the query"""
 
@@ -713,6 +720,8 @@ class GenieQueryAttachment:
             body["query"] = self.query
         if self.query_result_metadata:
             body["query_result_metadata"] = self.query_result_metadata.as_dict()
+        if self.statement_id is not None:
+            body["statement_id"] = self.statement_id
         if self.title is not None:
             body["title"] = self.title
         return body
@@ -730,6 +739,8 @@ class GenieQueryAttachment:
             body["query"] = self.query
         if self.query_result_metadata:
             body["query_result_metadata"] = self.query_result_metadata
+        if self.statement_id is not None:
+            body["statement_id"] = self.statement_id
         if self.title is not None:
             body["title"] = self.title
         return body
@@ -743,6 +754,7 @@ class GenieQueryAttachment:
             last_updated_timestamp=d.get("last_updated_timestamp", None),
             query=d.get("query", None),
             query_result_metadata=_from_dict(d, "query_result_metadata", GenieResultMetadata),
+            statement_id=d.get("statement_id", None),
             title=d.get("title", None),
         )
 
@@ -1062,6 +1074,7 @@ class MessageErrorType(Enum):
     CHAT_COMPLETION_NETWORK_EXCEPTION = "CHAT_COMPLETION_NETWORK_EXCEPTION"
     CONTENT_FILTER_EXCEPTION = "CONTENT_FILTER_EXCEPTION"
     CONTEXT_EXCEEDED_EXCEPTION = "CONTEXT_EXCEEDED_EXCEPTION"
+    COULD_NOT_GET_MODEL_DEPLOYMENTS_EXCEPTION = "COULD_NOT_GET_MODEL_DEPLOYMENTS_EXCEPTION"
     COULD_NOT_GET_UC_SCHEMA_EXCEPTION = "COULD_NOT_GET_UC_SCHEMA_EXCEPTION"
     DEPLOYMENT_NOT_FOUND_EXCEPTION = "DEPLOYMENT_NOT_FOUND_EXCEPTION"
     FUNCTIONS_NOT_AVAILABLE_EXCEPTION = "FUNCTIONS_NOT_AVAILABLE_EXCEPTION"
@@ -1107,12 +1120,15 @@ class MessageStatus(Enum):
     `ASKING_AI`: Waiting for the LLM to respond to the user's question. * `PENDING_WAREHOUSE`:
     Waiting for warehouse before the SQL query can start executing. * `EXECUTING_QUERY`: Executing a
     generated SQL query. Get the SQL query result by calling
-    [getMessageQueryResult](:method:genie/getMessageQueryResult) API. * `FAILED`: The response
-    generation or query execution failed. See `error` field. * `COMPLETED`: Message processing is
-    completed. Results are in the `attachments` field. Get the SQL query result by calling
-    [getMessageQueryResult](:method:genie/getMessageQueryResult) API. * `SUBMITTED`: Message has
-    been submitted. * `QUERY_RESULT_EXPIRED`: SQL result is not available anymore. The user needs to
-    rerun the query. * `CANCELLED`: Message has been cancelled."""
+    [getMessageAttachmentQueryResult](:method:genie/getMessageAttachmentQueryResult) API. *
+    `FAILED`: The response generation or query execution failed. See `error` field. * `COMPLETED`:
+    Message processing is completed. Results are in the `attachments` field. Get the SQL query
+    result by calling
+    [getMessageAttachmentQueryResult](:method:genie/getMessageAttachmentQueryResult) API. *
+    `SUBMITTED`: Message has been submitted. * `QUERY_RESULT_EXPIRED`: SQL result is not available
+    anymore. The user needs to rerun the query. Rerun the SQL query result by calling
+    [executeMessageAttachmentQuery](:method:genie/executeMessageAttachmentQuery) API. * `CANCELLED`:
+    Message has been cancelled."""
 
     ASKING_AI = "ASKING_AI"
     CANCELLED = "CANCELLED"
@@ -1917,7 +1933,8 @@ class GenieAPI:
     ) -> GenieGetMessageQueryResultResponse:
         """Execute message attachment SQL query.
 
-        Execute the SQL for a message query attachment.
+        Execute the SQL for a message query attachment. Use this API when the query attachment has expired and
+        needs to be re-executed.
 
         :param space_id: str
           Genie space ID
@@ -1945,7 +1962,7 @@ class GenieAPI:
     def execute_message_query(
         self, space_id: str, conversation_id: str, message_id: str
     ) -> GenieGetMessageQueryResultResponse:
-        """Execute SQL query in a conversation message.
+        """[Deprecated] Execute SQL query in a conversation message.
 
         Execute the SQL query in the message.
 
@@ -2059,7 +2076,7 @@ class GenieAPI:
     def get_message_query_result_by_attachment(
         self, space_id: str, conversation_id: str, message_id: str, attachment_id: str
     ) -> GenieGetMessageQueryResultResponse:
-        """[deprecated] Get conversation message SQL query result.
+        """[Deprecated] Get conversation message SQL query result.
 
         Get the result of SQL query if the message has a query attachment. This is only available if a message
         has a query attachment and the message status is `EXECUTING_QUERY` OR `COMPLETED`.
@@ -2088,9 +2105,9 @@ class GenieAPI:
         return GenieGetMessageQueryResultResponse.from_dict(res)
 
     def get_space(self, space_id: str) -> GenieSpace:
-        """Get details of a Genie Space.
+        """Get Genie Space.
 
-        Get a Genie Space.
+        Get details of a Genie Space.
 
         :param space_id: str
           The ID associated with the Genie space

databricks/sdk/service/files.py

@@ -314,12 +314,14 @@ class DirectoryEntry:
 @dataclass
 class DownloadResponse:
     content_length: Optional[int] = None
+    """The length of the HTTP response body in bytes."""
 
     content_type: Optional[str] = None
 
     contents: Optional[BinaryIO] = None
 
     last_modified: Optional[str] = None
+    """The last modified time of the file in HTTP-date (RFC 7231) format."""
 
     def as_dict(self) -> dict:
         """Serializes the DownloadResponse into a dictionary suitable for use as a JSON request body."""
@@ -430,10 +432,12 @@ class GetDirectoryMetadataResponse:
 @dataclass
 class GetMetadataResponse:
     content_length: Optional[int] = None
+    """The length of the HTTP response body in bytes."""
 
     content_type: Optional[str] = None
 
     last_modified: Optional[str] = None
+    """The last modified time of the file in HTTP-date (RFC 7231) format."""
 
     def as_dict(self) -> dict:
         """Serializes the GetMetadataResponse into a dictionary suitable for use as a JSON request body."""

databricks/sdk/service/ml.py

@@ -3,11 +3,15 @@
 from __future__ import annotations
 
 import logging
+import random
+import time
 from dataclasses import dataclass
+from datetime import timedelta
 from enum import Enum
-from typing import Any, Dict, Iterator, List, Optional
+from typing import Any, Callable, Dict, Iterator, List, Optional
 
-from ._internal import _enum, _from_dict, _repeated_dict, _repeated_enum
+from ..errors import OperationFailed
+from ._internal import Wait, _enum, _from_dict, _repeated_dict, _repeated_enum
 
 _LOG = logging.getLogger("databricks.sdk")
 
@@ -482,6 +486,197 @@ class CreateExperimentResponse:
         return cls(experiment_id=d.get("experiment_id", None))
 
 
+@dataclass
+class CreateForecastingExperimentRequest:
+    train_data_path: str
+    """The three-level (fully qualified) name of a unity catalog table. This table serves as the
+    training data for the forecasting model."""
+
+    target_column: str
+    """Name of the column in the input training table that serves as the prediction target. The values
+    in this column will be used as the ground truth for model training."""
+
+    time_column: str
+    """Name of the column in the input training table that represents the timestamp of each row."""
+
+    data_granularity_unit: str
+    """The time unit of the input data granularity. Together with data_granularity_quantity field, this
+    defines the time interval between consecutive rows in the time series data. Possible values: *
+    'W' (weeks) * 'D' / 'days' / 'day' * 'hours' / 'hour' / 'hr' / 'h' * 'm' / 'minute' / 'min' /
+    'minutes' / 'T' * 'S' / 'seconds' / 'sec' / 'second' * 'M' / 'month' / 'months' * 'Q' /
+    'quarter' / 'quarters' * 'Y' / 'year' / 'years'"""
+
+    forecast_horizon: int
+    """The number of time steps into the future for which predictions should be made. This value
+    represents a multiple of data_granularity_unit and data_granularity_quantity determining how far
+    ahead the model will forecast."""
+
+    custom_weights_column: Optional[str] = None
+    """Name of the column in the input training table used to customize the weight for each time series
+    to calculate weighted metrics."""
+
+    data_granularity_quantity: Optional[int] = None
+    """The quantity of the input data granularity. Together with data_granularity_unit field, this
+    defines the time interval between consecutive rows in the time series data. For now, only 1
+    second, 1/5/10/15/30 minutes, 1 hour, 1 day, 1 week, 1 month, 1 quarter, 1 year are supported."""
+
+    experiment_path: Optional[str] = None
+    """The path to the created experiment. This is the path where the experiment will be stored in the
+    workspace."""
+
+    holiday_regions: Optional[List[str]] = None
+    """Region code(s) to consider when automatically adding holiday features. When empty, no holiday
+    features are added. Only supports 1 holiday region for now."""
+
+    max_runtime: Optional[int] = None
+    """The maximum duration in minutes for which the experiment is allowed to run. If the experiment
+    exceeds this time limit it will be stopped automatically."""
+
+    prediction_data_path: Optional[str] = None
+    """The three-level (fully qualified) path to a unity catalog table. This table path serves to store
+    the predictions."""
+
+    primary_metric: Optional[str] = None
+    """The evaluation metric used to optimize the forecasting model."""
+
+    register_to: Optional[str] = None
+    """The three-level (fully qualified) path to a unity catalog model. This model path serves to store
+    the best model."""
+
+    split_column: Optional[str] = None
+    """Name of the column in the input training table used for custom data splits. The values in this
+    column must be "train", "validate", or "test" to indicate which split each row belongs to."""
+
+    timeseries_identifier_columns: Optional[List[str]] = None
+    """Name of the column in the input training table used to group the dataset to predict individual
+    time series"""
+
+    training_frameworks: Optional[List[str]] = None
+    """The list of frameworks to include for model tuning. Possible values: 'Prophet', 'ARIMA',
+    'DeepAR'. An empty list will include all supported frameworks."""
+
+    def as_dict(self) -> dict:
+        """Serializes the CreateForecastingExperimentRequest into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.custom_weights_column is not None:
+            body["custom_weights_column"] = self.custom_weights_column
+        if self.data_granularity_quantity is not None:
+            body["data_granularity_quantity"] = self.data_granularity_quantity
+        if self.data_granularity_unit is not None:
+            body["data_granularity_unit"] = self.data_granularity_unit
+        if self.experiment_path is not None:
+            body["experiment_path"] = self.experiment_path
+        if self.forecast_horizon is not None:
+            body["forecast_horizon"] = self.forecast_horizon
+        if self.holiday_regions:
+            body["holiday_regions"] = [v for v in self.holiday_regions]
+        if self.max_runtime is not None:
+            body["max_runtime"] = self.max_runtime
+        if self.prediction_data_path is not None:
+            body["prediction_data_path"] = self.prediction_data_path
+        if self.primary_metric is not None:
+            body["primary_metric"] = self.primary_metric
+        if self.register_to is not None:
+            body["register_to"] = self.register_to
+        if self.split_column is not None:
+            body["split_column"] = self.split_column
+        if self.target_column is not None:
+            body["target_column"] = self.target_column
+        if self.time_column is not None:
+            body["time_column"] = self.time_column
+        if self.timeseries_identifier_columns:
+            body["timeseries_identifier_columns"] = [v for v in self.timeseries_identifier_columns]
+        if self.train_data_path is not None:
+            body["train_data_path"] = self.train_data_path
+        if self.training_frameworks:
+            body["training_frameworks"] = [v for v in self.training_frameworks]
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateForecastingExperimentRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.custom_weights_column is not None:
+            body["custom_weights_column"] = self.custom_weights_column
+        if self.data_granularity_quantity is not None:
+            body["data_granularity_quantity"] = self.data_granularity_quantity
+        if self.data_granularity_unit is not None:
+            body["data_granularity_unit"] = self.data_granularity_unit
+        if self.experiment_path is not None:
+            body["experiment_path"] = self.experiment_path
+        if self.forecast_horizon is not None:
+            body["forecast_horizon"] = self.forecast_horizon
+        if self.holiday_regions:
+            body["holiday_regions"] = self.holiday_regions
+        if self.max_runtime is not None:
+            body["max_runtime"] = self.max_runtime
+        if self.prediction_data_path is not None:
+            body["prediction_data_path"] = self.prediction_data_path
+        if self.primary_metric is not None:
+            body["primary_metric"] = self.primary_metric
+        if self.register_to is not None:
+            body["register_to"] = self.register_to
+        if self.split_column is not None:
+            body["split_column"] = self.split_column
+        if self.target_column is not None:
+            body["target_column"] = self.target_column
+        if self.time_column is not None:
+            body["time_column"] = self.time_column
+        if self.timeseries_identifier_columns:
+            body["timeseries_identifier_columns"] = self.timeseries_identifier_columns
+        if self.train_data_path is not None:
+            body["train_data_path"] = self.train_data_path
+        if self.training_frameworks:
+            body["training_frameworks"] = self.training_frameworks
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> CreateForecastingExperimentRequest:
+        """Deserializes the CreateForecastingExperimentRequest from a dictionary."""
+        return cls(
+            custom_weights_column=d.get("custom_weights_column", None),
+            data_granularity_quantity=d.get("data_granularity_quantity", None),
+            data_granularity_unit=d.get("data_granularity_unit", None),
+            experiment_path=d.get("experiment_path", None),
+            forecast_horizon=d.get("forecast_horizon", None),
+            holiday_regions=d.get("holiday_regions", None),
+            max_runtime=d.get("max_runtime", None),
+            prediction_data_path=d.get("prediction_data_path", None),
+            primary_metric=d.get("primary_metric", None),
+            register_to=d.get("register_to", None),
+            split_column=d.get("split_column", None),
+            target_column=d.get("target_column", None),
+            time_column=d.get("time_column", None),
+            timeseries_identifier_columns=d.get("timeseries_identifier_columns", None),
+            train_data_path=d.get("train_data_path", None),
+            training_frameworks=d.get("training_frameworks", None),
+        )
+
+
+@dataclass
+class CreateForecastingExperimentResponse:
+    experiment_id: Optional[str] = None
+    """The unique ID of the created forecasting experiment"""
+
+    def as_dict(self) -> dict:
+        """Serializes the CreateForecastingExperimentResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.experiment_id is not None:
+            body["experiment_id"] = self.experiment_id
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateForecastingExperimentResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.experiment_id is not None:
+            body["experiment_id"] = self.experiment_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> CreateForecastingExperimentResponse:
+        """Deserializes the CreateForecastingExperimentResponse from a dictionary."""
+        return cls(experiment_id=d.get("experiment_id", None))
+
+
 @dataclass
 class CreateModelRequest:
     name: str
@@ -1800,6 +1995,60 @@ class FileInfo:
         return cls(file_size=d.get("file_size", None), is_dir=d.get("is_dir", None), path=d.get("path", None))
 
 
+@dataclass
+class ForecastingExperiment:
+    """Represents a forecasting experiment with its unique identifier, URL, and state."""
+
+    experiment_id: Optional[str] = None
+    """The unique ID for the forecasting experiment."""
+
+    experiment_page_url: Optional[str] = None
+    """The URL to the forecasting experiment page."""
+
+    state: Optional[ForecastingExperimentState] = None
+    """The current state of the forecasting experiment."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ForecastingExperiment into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.experiment_id is not None:
+            body["experiment_id"] = self.experiment_id
+        if self.experiment_page_url is not None:
+            body["experiment_page_url"] = self.experiment_page_url
+        if self.state is not None:
+            body["state"] = self.state.value
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ForecastingExperiment into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.experiment_id is not None:
+            body["experiment_id"] = self.experiment_id
+        if self.experiment_page_url is not None:
+            body["experiment_page_url"] = self.experiment_page_url
+        if self.state is not None:
+            body["state"] = self.state
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ForecastingExperiment:
+        """Deserializes the ForecastingExperiment from a dictionary."""
+        return cls(
+            experiment_id=d.get("experiment_id", None),
+            experiment_page_url=d.get("experiment_page_url", None),
+            state=_enum(d, "state", ForecastingExperimentState),
+        )
+
+
+class ForecastingExperimentState(Enum):
+
+    CANCELLED = "CANCELLED"
+    FAILED = "FAILED"
+    PENDING = "PENDING"
+    RUNNING = "RUNNING"
+    SUCCEEDED = "SUCCEEDED"
+
+
 @dataclass
 class GetExperimentByNameResponse:
     experiment: Optional[Experiment] = None
@@ -6705,6 +6954,231 @@ class ExperimentsAPI:
         return UpdateRunResponse.from_dict(res)
 
 
+class ForecastingAPI:
+    """The Forecasting API allows you to create and get serverless forecasting experiments"""
+
+    def __init__(self, api_client):
+        self._api = api_client
+
+    def wait_get_experiment_forecasting_succeeded(
+        self,
+        experiment_id: str,
+        timeout=timedelta(minutes=120),
+        callback: Optional[Callable[[ForecastingExperiment], None]] = None,
+    ) -> ForecastingExperiment:
+        deadline = time.time() + timeout.total_seconds()
+        target_states = (ForecastingExperimentState.SUCCEEDED,)
+        failure_states = (
+            ForecastingExperimentState.FAILED,
+            ForecastingExperimentState.CANCELLED,
+        )
+        status_message = "polling..."
+        attempt = 1
+        while time.time() < deadline:
+            poll = self.get_experiment(experiment_id=experiment_id)
+            status = poll.state
+            status_message = f"current status: {status}"
+            if status in target_states:
+                return poll
+            if callback:
+                callback(poll)
+            if status in failure_states:
+                msg = f"failed to reach SUCCEEDED, got {status}: {status_message}"
+                raise OperationFailed(msg)
+            prefix = f"experiment_id={experiment_id}"
+            sleep = attempt
+            if sleep > 10:
+                # sleep 10s max per attempt
+                sleep = 10
+            _LOG.debug(f"{prefix}: ({status}) {status_message} (sleeping ~{sleep}s)")
+            time.sleep(sleep + random.random())
+            attempt += 1
+        raise TimeoutError(f"timed out after {timeout}: {status_message}")
+
+    def create_experiment(
+        self,
+        train_data_path: str,
+        target_column: str,
+        time_column: str,
+        data_granularity_unit: str,
+        forecast_horizon: int,
+        *,
+        custom_weights_column: Optional[str] = None,
+        data_granularity_quantity: Optional[int] = None,
+        experiment_path: Optional[str] = None,
+        holiday_regions: Optional[List[str]] = None,
+        max_runtime: Optional[int] = None,
+        prediction_data_path: Optional[str] = None,
+        primary_metric: Optional[str] = None,
+        register_to: Optional[str] = None,
+        split_column: Optional[str] = None,
+        timeseries_identifier_columns: Optional[List[str]] = None,
+        training_frameworks: Optional[List[str]] = None,
+    ) -> Wait[ForecastingExperiment]:
+        """Create a forecasting experiment.
+
+        Creates a serverless forecasting experiment. Returns the experiment ID.
+
+        :param train_data_path: str
+          The three-level (fully qualified) name of a unity catalog table. This table serves as the training
+          data for the forecasting model.
+        :param target_column: str
+          Name of the column in the input training table that serves as the prediction target. The values in
+          this column will be used as the ground truth for model training.
+        :param time_column: str
+          Name of the column in the input training table that represents the timestamp of each row.
+        :param data_granularity_unit: str
+          The time unit of the input data granularity. Together with data_granularity_quantity field, this
+          defines the time interval between consecutive rows in the time series data. Possible values: * 'W'
+          (weeks) * 'D' / 'days' / 'day' * 'hours' / 'hour' / 'hr' / 'h' * 'm' / 'minute' / 'min' / 'minutes'
+          / 'T' * 'S' / 'seconds' / 'sec' / 'second' * 'M' / 'month' / 'months' * 'Q' / 'quarter' / 'quarters'
+          * 'Y' / 'year' / 'years'
+        :param forecast_horizon: int
+          The number of time steps into the future for which predictions should be made. This value represents
+          a multiple of data_granularity_unit and data_granularity_quantity determining how far ahead the
+          model will forecast.
+        :param custom_weights_column: str (optional)
+          Name of the column in the input training table used to customize the weight for each time series to
+          calculate weighted metrics.
+        :param data_granularity_quantity: int (optional)
+          The quantity of the input data granularity. Together with data_granularity_unit field, this defines
+          the time interval between consecutive rows in the time series data. For now, only 1 second,
+          1/5/10/15/30 minutes, 1 hour, 1 day, 1 week, 1 month, 1 quarter, 1 year are supported.
+        :param experiment_path: str (optional)
+          The path to the created experiment. This is the path where the experiment will be stored in the
+          workspace.
+        :param holiday_regions: List[str] (optional)
+          Region code(s) to consider when automatically adding holiday features. When empty, no holiday
+          features are added. Only supports 1 holiday region for now.
+        :param max_runtime: int (optional)
+          The maximum duration in minutes for which the experiment is allowed to run. If the experiment
+          exceeds this time limit it will be stopped automatically.
+        :param prediction_data_path: str (optional)
+          The three-level (fully qualified) path to a unity catalog table. This table path serves to store the
+          predictions.
+        :param primary_metric: str (optional)
+          The evaluation metric used to optimize the forecasting model.
+        :param register_to: str (optional)
+          The three-level (fully qualified) path to a unity catalog model. This model path serves to store the
+          best model.
+        :param split_column: str (optional)
+          Name of the column in the input training table used for custom data splits. The values in this
+          column must be "train", "validate", or "test" to indicate which split each row belongs to.
+        :param timeseries_identifier_columns: List[str] (optional)
+          Name of the column in the input training table used to group the dataset to predict individual time
+          series
+        :param training_frameworks: List[str] (optional)
+          The list of frameworks to include for model tuning. Possible values: 'Prophet', 'ARIMA', 'DeepAR'.
+          An empty list will include all supported frameworks.
+
+        :returns:
+          Long-running operation waiter for :class:`ForecastingExperiment`.
+          See :method:wait_get_experiment_forecasting_succeeded for more details.
+        """
+        body = {}
+        if custom_weights_column is not None:
+            body["custom_weights_column"] = custom_weights_column
+        if data_granularity_quantity is not None:
+            body["data_granularity_quantity"] = data_granularity_quantity
+        if data_granularity_unit is not None:
+            body["data_granularity_unit"] = data_granularity_unit
+        if experiment_path is not None:
+            body["experiment_path"] = experiment_path
+        if forecast_horizon is not None:
+            body["forecast_horizon"] = forecast_horizon
+        if holiday_regions is not None:
+            body["holiday_regions"] = [v for v in holiday_regions]
+        if max_runtime is not None:
+            body["max_runtime"] = max_runtime
+        if prediction_data_path is not None:
+            body["prediction_data_path"] = prediction_data_path
+        if primary_metric is not None:
+            body["primary_metric"] = primary_metric
+        if register_to is not None:
+            body["register_to"] = register_to
+        if split_column is not None:
+            body["split_column"] = split_column
+        if target_column is not None:
+            body["target_column"] = target_column
+        if time_column is not None:
+            body["time_column"] = time_column
+        if timeseries_identifier_columns is not None:
+            body["timeseries_identifier_columns"] = [v for v in timeseries_identifier_columns]
+        if train_data_path is not None:
+            body["train_data_path"] = train_data_path
+        if training_frameworks is not None:
+            body["training_frameworks"] = [v for v in training_frameworks]
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        op_response = self._api.do("POST", "/api/2.0/automl/create-forecasting-experiment", body=body, headers=headers)
+        return Wait(
+            self.wait_get_experiment_forecasting_succeeded,
+            response=CreateForecastingExperimentResponse.from_dict(op_response),
+            experiment_id=op_response["experiment_id"],
+        )
+
+    def create_experiment_and_wait(
+        self,
+        train_data_path: str,
+        target_column: str,
+        time_column: str,
+        data_granularity_unit: str,
+        forecast_horizon: int,
+        *,
+        custom_weights_column: Optional[str] = None,
+        data_granularity_quantity: Optional[int] = None,
+        experiment_path: Optional[str] = None,
+        holiday_regions: Optional[List[str]] = None,
+        max_runtime: Optional[int] = None,
+        prediction_data_path: Optional[str] = None,
+        primary_metric: Optional[str] = None,
+        register_to: Optional[str] = None,
+        split_column: Optional[str] = None,
+        timeseries_identifier_columns: Optional[List[str]] = None,
+        training_frameworks: Optional[List[str]] = None,
+        timeout=timedelta(minutes=120),
+    ) -> ForecastingExperiment:
+        return self.create_experiment(
+            custom_weights_column=custom_weights_column,
+            data_granularity_quantity=data_granularity_quantity,
+            data_granularity_unit=data_granularity_unit,
+            experiment_path=experiment_path,
+            forecast_horizon=forecast_horizon,
+            holiday_regions=holiday_regions,
+            max_runtime=max_runtime,
+            prediction_data_path=prediction_data_path,
+            primary_metric=primary_metric,
+            register_to=register_to,
+            split_column=split_column,
+            target_column=target_column,
+            time_column=time_column,
+            timeseries_identifier_columns=timeseries_identifier_columns,
+            train_data_path=train_data_path,
+            training_frameworks=training_frameworks,
+        ).result(timeout=timeout)
+
+    def get_experiment(self, experiment_id: str) -> ForecastingExperiment:
+        """Get a forecasting experiment.
+
+        Public RPC to get forecasting experiment
+
+        :param experiment_id: str
+          The unique ID of a forecasting experiment
+
+        :returns: :class:`ForecastingExperiment`
+        """
+
+        headers = {
+            "Accept": "application/json",
+        }
+
+        res = self._api.do("GET", f"/api/2.0/automl/get-forecasting-experiment/{experiment_id}", headers=headers)
+        return ForecastingExperiment.from_dict(res)
+
+
 class ModelRegistryAPI:
     """Note: This API reference documents APIs for the Workspace Model Registry. Databricks recommends using
     [Models in Unity Catalog](/api/workspace/registeredmodels) instead. Models in Unity Catalog provides

databricks/sdk/service/oauth2.py

@@ -776,13 +776,6 @@ class OidcFederationPolicy:
     endpoint. Databricks strongly recommends relying on your issuer’s well known endpoint for
     discovering public keys."""
 
-    jwks_uri: Optional[str] = None
-    """URL of the public keys used to validate the signature of federated tokens, in JWKS format. Most
-    use cases should not need to specify this field. If jwks_uri and jwks_json are both unspecified
-    (recommended), Databricks automatically fetches the public keys from your issuer’s well known
-    endpoint. Databricks strongly recommends relying on your issuer’s well known endpoint for
-    discovering public keys."""
-
     subject: Optional[str] = None
     """The required token subject, as specified in the subject claim of federated tokens. Must be
     specified for service principal federation policies. Must not be specified for account
@@ -800,8 +793,6 @@ class OidcFederationPolicy:
             body["issuer"] = self.issuer
         if self.jwks_json is not None:
             body["jwks_json"] = self.jwks_json
-        if self.jwks_uri is not None:
-            body["jwks_uri"] = self.jwks_uri
         if self.subject is not None:
             body["subject"] = self.subject
         if self.subject_claim is not None:
@@ -817,8 +808,6 @@ class OidcFederationPolicy:
             body["issuer"] = self.issuer
         if self.jwks_json is not None:
             body["jwks_json"] = self.jwks_json
-        if self.jwks_uri is not None:
-            body["jwks_uri"] = self.jwks_uri
         if self.subject is not None:
             body["subject"] = self.subject
         if self.subject_claim is not None:
@@ -832,7 +821,6 @@ class OidcFederationPolicy:
             audiences=d.get("audiences", None),
             issuer=d.get("issuer", None),
             jwks_json=d.get("jwks_json", None),
-            jwks_uri=d.get("jwks_uri", None),
             subject=d.get("subject", None),
             subject_claim=d.get("subject_claim", None),
         )

databricks/sdk/service/serving.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import logging
 import random
+import threading
 import time
 from dataclasses import dataclass
 from datetime import timedelta
@@ -4657,12 +4658,31 @@ class ServingEndpointsDataPlaneAPI:
     """Serving endpoints DataPlane provides a set of operations to interact with data plane endpoints for Serving
     endpoints service."""
 
-    def __init__(self, api_client, control_plane):
+    def __init__(self, api_client, control_plane_service, dpts):
         self._api = api_client
-        self._control_plane = control_plane
-        from ..data_plane import DataPlaneService
-
-        self._data_plane_service = DataPlaneService()
+        self._lock = threading.Lock()
+        self._control_plane_service = control_plane_service
+        self._dpts = dpts
+        self._data_plane_details = {}
+
+    def _data_plane_info_query(self, name: str) -> DataPlaneInfo:
+        key = "query" + "/".join(
+            [
+                str(name),
+            ]
+        )
+        with self._lock:
+            if key in self._data_plane_details:
+                return self._data_plane_details[key]
+        response = self._control_plane_service.get(
+            name=name,
+        )
+        if response.data_plane_info is None:
+            raise Exception("Resource does not support direct Data Plane access")
+        result = response.data_plane_info.query_info
+        with self._lock:
+            self._data_plane_details[key] = result
+        return result
 
     def query(
         self,
@@ -4757,22 +4777,10 @@ class ServingEndpointsDataPlaneAPI:
             body["stream"] = stream
         if temperature is not None:
             body["temperature"] = temperature
-
-        def info_getter():
-            response = self._control_plane.get(
-                name=name,
-            )
-            if response.data_plane_info is None:
-                raise Exception("Resource does not support direct Data Plane access")
-            return response.data_plane_info.query_info
-
-        get_params = [
-            name,
-        ]
-        data_plane_details = self._data_plane_service.get_data_plane_details(
-            "query", get_params, info_getter, self._api.get_oauth_token
+        data_plane_info = self._data_plane_info_query(
+            name=name,
         )
-        token = data_plane_details.token
+        token = self._dpts.token(data_plane_info.endpoint_url, data_plane_info.authorization_details)
 
         def auth(r: requests.PreparedRequest) -> requests.PreparedRequest:
             authorization = f"{token.token_type} {token.access_token}"
@@ -4788,7 +4796,7 @@ class ServingEndpointsDataPlaneAPI:
         ]
         res = self._api.do(
             "POST",
-            url=data_plane_details.endpoint_url,
+            url=data_plane_info.endpoint_url,
             body=body,
             headers=headers,
             response_headers=response_headers,

databricks/sdk/version.py

@@ -1 +1 @@
-__version__ = "0.45.0"
+__version__ = "0.46.0"

{databricks_sdk-0.45.0.dist-info → databricks_sdk-0.46.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: databricks-sdk
-Version: 0.45.0
+Version: 0.46.0
 Summary: Databricks SDK for Python (Beta)
 Project-URL: Documentation, https://databricks-sdk-py.readthedocs.io
 Keywords: databricks,sdk

{databricks_sdk-0.45.0.dist-info → databricks_sdk-0.46.0.dist-info}/RECORD

@@ -1,21 +1,21 @@
 databricks/__init__.py,sha256=CF2MJcZFwbpn9TwQER8qnCDhkPooBGQNVkX4v7g6p3g,537
-databricks/sdk/__init__.py,sha256=eWUNC35CmwGdDnlpAYKdeFXkzoS5e9rAnBnFNfwzemw,54909
+databricks/sdk/__init__.py,sha256=qCmezvkTnXqC1wVdQpE2oyM-W-QfC0dYnTeWaSLhoOI,55541
 databricks/sdk/_base_client.py,sha256=IMHtzC5BhWt-lBVjifewR1Ah5fegGDMv0__-O1hCxWI,15850
 databricks/sdk/_property.py,sha256=ccbxhkXZmZOxbx2sqKMTzhVZDuvWXG0WPHFRgac6JAM,1701
 databricks/sdk/azure.py,sha256=sN_ARpmP9h1JovtiHIsDLtrVQP_K11eNDDtHS6PD19k,1015
 databricks/sdk/casing.py,sha256=gZy-FlI7og5WNVX88Vb_7S1WeInwJLGws80CGj_9s48,1137
 databricks/sdk/clock.py,sha256=Ivlow0r_TkXcTJ8UXkxSA0czKrY0GvwHAeOvjPkJnAQ,1360
-databricks/sdk/config.py,sha256=owcay_mMwDi_ad-gk_bJ46mGjeRcOzMIaTww6XTVRDY,22815
+databricks/sdk/config.py,sha256=xBSaO4CasFR_Bd0nNMwYicyAouvMl5BtcIRv2jC7HCM,22956
 databricks/sdk/core.py,sha256=6lsRl6BL3pLgqMMVFrOnQsx-RxxaJJL_Gt2jJfWUovs,3724
-databricks/sdk/credentials_provider.py,sha256=3ZHvqRriyR6lcMSLZA3IUOGVDC25RXT_ym9YDdkbwyE,37517
-databricks/sdk/data_plane.py,sha256=erod0IbG4Mk8zseRpphScG_0-N36rOVWC5sgrj3AKoU,5399
+databricks/sdk/credentials_provider.py,sha256=sFqCsVOe9-pKSTzkZELnIgeOalnM4h6EGw8TN3yKUeQ,37872
+databricks/sdk/data_plane.py,sha256=br5IPnOdE611IBubxP8xkUR9_qzbSRSYyVWSua6znWs,3109
 databricks/sdk/dbutils.py,sha256=PoDIwNAYGZhVZC7krox7tsudUDNVSk0gsFjFWlKJXVk,15753
 databricks/sdk/environments.py,sha256=9eVeb68cksqY2Lqwth2PJNmK0JEGdIjh-ebrrmUbqCc,3963
-databricks/sdk/oauth.py,sha256=j7VMWacnO6eiZXI87F0j2yNBSA_OES5Mzk_p-wXztfk,28017
+databricks/sdk/oauth.py,sha256=rXvPGPSXmm2ZL0HkmrvkdCaSD-uM02jTbx58L1fm-J0,28186
 databricks/sdk/py.typed,sha256=pSvaHpbY1UPNEXyVFUjlgBhjPFZMmVC_UNrPC7eMOHI,74
 databricks/sdk/retries.py,sha256=7k2kEexGqGKXHNAWHbPFSZSugU8UIU0qtyly_hix22Q,2581
 databricks/sdk/useragent.py,sha256=boEgzTv-Zmo6boipZKjSopNy0CXg4GShC1_lTKpJgqs,7361
-databricks/sdk/version.py,sha256=p2Xvd610sh3godS2s3KpBCKAbfwwnEs-mH0Q6wQI5LE,23
+databricks/sdk/version.py,sha256=VTDTPpzZ6KwzjCPZhHgalFxPlpuy4ZGRkHB_n3WGwYs,23
 databricks/sdk/_widgets/__init__.py,sha256=VhI-VvLlr3rKUT1nbROslHJIbmZX_tPJ9rRhrdFsYUA,2811
 databricks/sdk/_widgets/default_widgets_utils.py,sha256=_hwCbptLbRzWEmknco0H1wQNAYcuy2pjFO9NiRbvFeo,1127
 databricks/sdk/_widgets/ipywidgets_utils.py,sha256=mg3rEPG9z76e0yVjGgcLybUvd_zSuN5ziGeKiZ-c8Ew,2927
@@ -46,25 +46,25 @@ databricks/sdk/service/apps.py,sha256=NdPhpycOpsYlXlBB5JTvt-AmiaCxIqFKMz7370CKKQ
 databricks/sdk/service/billing.py,sha256=s-QN57TyMMfJSA40CfIjjno8iWHBssjpxcy0xcEcwyw,98590
 databricks/sdk/service/catalog.py,sha256=eu1zLzoeQxirFPMbthS5d5Mt0EjdbuqYP4sESotNwHc,602387
 databricks/sdk/service/cleanrooms.py,sha256=TON2V0-T_TOk31K9bUypuRJaAJhHMM0bQDbMjJWlCDQ,58613
-databricks/sdk/service/compute.py,sha256=2BXAeAzovCGF5LUrt9ZtbY5PGe1jCxaLe40QT0aF1nw,552285
-databricks/sdk/service/dashboards.py,sha256=ZqOsLIPmUL5x-dbRXiMIrW__TGANyrHCjI0B5_nZOPc,104271
-databricks/sdk/service/files.py,sha256=hTLecMRkeN_3nfPd9lg3O8cL0ah1L1RdGYBpd0Ce9JY,45966
+databricks/sdk/service/compute.py,sha256=R8GilWUVYVljZHfdNuiP4AJiAFWqKG4_XKn6Wg-um68,553503
+databricks/sdk/service/dashboards.py,sha256=MhKFjglM4odyOiNzagII4pprkPMh8FOfzvwm9Ntlyr8,105263
+databricks/sdk/service/files.py,sha256=gWjtORuRe7B1VZol0rr_dcSHq1gMmuKszGHaMqunslU,46234
 databricks/sdk/service/iam.py,sha256=TFKlhh7A1INGVcfAZQ1f0ORpAIzWLJ78l23vkerTe4M,174846
 databricks/sdk/service/jobs.py,sha256=2DQIqaeYq2tOeRzeeq23Q8_ntXaeJNK0LHhlcbd_8A4,443424
 databricks/sdk/service/marketplace.py,sha256=h-hGo2GHrjbVe0lXuengvqIDEN5VGhBdna4di9at5hA,175736
-databricks/sdk/service/ml.py,sha256=S4-bv47TVHwh5-YiiwUpAqKe_AzGZRYnSutnQc5AcDw,294041
-databricks/sdk/service/oauth2.py,sha256=EKptQcQnTX0M4JDLfzwTKekjWLDS_LPIwZdTXv6-YwU,80467
+databricks/sdk/service/ml.py,sha256=q5vdOguyLiTpGqT6R5w41l_cCendUx4Hm-fQeW1-08k,316482
+databricks/sdk/service/oauth2.py,sha256=LLp1uMvxfPOXzuekLjnLH6si6YOCvie7qZSpjSNDYd4,79788
 databricks/sdk/service/pipelines.py,sha256=_2RpczckyhexbCtLoB_ewVKgZNFseN8bCwABod6YUqs,166666
 databricks/sdk/service/provisioning.py,sha256=-Ly2o02i-jhNmiP9zLPeYF8H2usoB-oTG0RLF5gkIpc,169311
-databricks/sdk/service/serving.py,sha256=VOrHguP8NlRo2rrN1gXQrbRxBHZYNy7T2VZ4zhSmBz4,204080
+databricks/sdk/service/serving.py,sha256=eHPRoxeOpqV-dyVf7V8_6_FHBoTTwXqr5W9Y6b_iZtI,204406
 databricks/sdk/service/settings.py,sha256=9I8NHnVTtTn_u91fYQi-QpDMjKPF2c2Sec0gEub6on0,323112
 databricks/sdk/service/sharing.py,sha256=jP3XWl3qojFWmZE9xkgCixqEZPuGZAJC_M-eGXMrPQs,142473
 databricks/sdk/service/sql.py,sha256=2t8QhrEUyLekRYHnRYKkxVY8qpDbxE7JayfMSds6OKM,409593
 databricks/sdk/service/vectorsearch.py,sha256=stdRmV-iE8L0rGzhSSG5tmoVRXb9bPItSE_ss6HQVDo,79897
 databricks/sdk/service/workspace.py,sha256=T0ZbnG1qcPjKysGO_tBzl5x1PyalydeYJRBZbooYNm0,130893
-databricks_sdk-0.45.0.dist-info/LICENSE,sha256=afBgTZo-JsYqj4VOjnejBetMuHKcFR30YobDdpVFkqY,11411
-databricks_sdk-0.45.0.dist-info/METADATA,sha256=pov8CHm4DWdNEwLrOFy-BVj0O1ozO2T4a1wJpc2ULRI,38311
-databricks_sdk-0.45.0.dist-info/NOTICE,sha256=tkRcQYA1k68wDLcnOWbg2xJDsUOJw8G8DGBhb8dnI3w,1588
-databricks_sdk-0.45.0.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-databricks_sdk-0.45.0.dist-info/top_level.txt,sha256=7kRdatoSgU0EUurRQJ_3F1Nv4EOSHWAr6ng25tJOJKU,11
-databricks_sdk-0.45.0.dist-info/RECORD,,
+databricks_sdk-0.46.0.dist-info/LICENSE,sha256=afBgTZo-JsYqj4VOjnejBetMuHKcFR30YobDdpVFkqY,11411
+databricks_sdk-0.46.0.dist-info/METADATA,sha256=f3lrq-aclP8VS34ht65GoP5mUPPaaogzFQYVoi7Eue8,38311
+databricks_sdk-0.46.0.dist-info/NOTICE,sha256=tkRcQYA1k68wDLcnOWbg2xJDsUOJw8G8DGBhb8dnI3w,1588
+databricks_sdk-0.46.0.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+databricks_sdk-0.46.0.dist-info/top_level.txt,sha256=7kRdatoSgU0EUurRQJ_3F1Nv4EOSHWAr6ng25tJOJKU,11
+databricks_sdk-0.46.0.dist-info/RECORD,,

{databricks_sdk-0.45.0.dist-info → databricks_sdk-0.46.0.dist-info}/WHEEL

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