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

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
@@ -62,6 +63,10 @@ class Ai21LabsConfig:
 
 @dataclass
 class AiGatewayConfig:
+    fallback_config: Optional[FallbackConfig] = None
+    """Configuration for traffic fallback which auto fallbacks to other served entities if the request
+    to a served entity fails with certain error codes, to increase availability."""
+
     guardrails: Optional[AiGatewayGuardrails] = None
     """Configuration for AI Guardrails to prevent unwanted data and unsafe data in requests and
     responses."""
@@ -80,6 +85,8 @@ class AiGatewayConfig:
     def as_dict(self) -> dict:
         """Serializes the AiGatewayConfig into a dictionary suitable for use as a JSON request body."""
         body = {}
+        if self.fallback_config:
+            body["fallback_config"] = self.fallback_config.as_dict()
         if self.guardrails:
             body["guardrails"] = self.guardrails.as_dict()
         if self.inference_table_config:
@@ -93,6 +100,8 @@ class AiGatewayConfig:
     def as_shallow_dict(self) -> dict:
         """Serializes the AiGatewayConfig into a shallow dictionary of its immediate attributes."""
         body = {}
+        if self.fallback_config:
+            body["fallback_config"] = self.fallback_config
         if self.guardrails:
             body["guardrails"] = self.guardrails
         if self.inference_table_config:
@@ -107,6 +116,7 @@ class AiGatewayConfig:
     def from_dict(cls, d: Dict[str, Any]) -> AiGatewayConfig:
         """Deserializes the AiGatewayConfig from a dictionary."""
         return cls(
+            fallback_config=_from_dict(d, "fallback_config", FallbackConfig),
             guardrails=_from_dict(d, "guardrails", AiGatewayGuardrails),
             inference_table_config=_from_dict(d, "inference_table_config", AiGatewayInferenceTableConfig),
             rate_limits=_repeated_dict(d, "rate_limits", AiGatewayRateLimit),
@@ -505,6 +515,47 @@ class AnthropicConfig:
         )
 
 
+@dataclass
+class ApiKeyAuth:
+    key: str
+    """The name of the API key parameter used for authentication."""
+
+    value: Optional[str] = None
+    """The Databricks secret key reference for an API Key. If you prefer to paste your token directly,
+    see `value_plaintext`."""
+
+    value_plaintext: Optional[str] = None
+    """The API Key provided as a plaintext string. If you prefer to reference your token using
+    Databricks Secrets, see `value`."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ApiKeyAuth into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.key is not None:
+            body["key"] = self.key
+        if self.value is not None:
+            body["value"] = self.value
+        if self.value_plaintext is not None:
+            body["value_plaintext"] = self.value_plaintext
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ApiKeyAuth into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.key is not None:
+            body["key"] = self.key
+        if self.value is not None:
+            body["value"] = self.value
+        if self.value_plaintext is not None:
+            body["value_plaintext"] = self.value_plaintext
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ApiKeyAuth:
+        """Deserializes the ApiKeyAuth from a dictionary."""
+        return cls(key=d.get("key", None), value=d.get("value", None), value_plaintext=d.get("value_plaintext", None))
+
+
 @dataclass
 class AutoCaptureConfigInput:
     catalog_name: Optional[str] = None
@@ -644,6 +695,40 @@ class AutoCaptureState:
         return cls(payload_table=_from_dict(d, "payload_table", PayloadTable))
 
 
+@dataclass
+class BearerTokenAuth:
+    token: Optional[str] = None
+    """The Databricks secret key reference for a token. If you prefer to paste your token directly, see
+    `token_plaintext`."""
+
+    token_plaintext: Optional[str] = None
+    """The token provided as a plaintext string. If you prefer to reference your token using Databricks
+    Secrets, see `token`."""
+
+    def as_dict(self) -> dict:
+        """Serializes the BearerTokenAuth into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.token is not None:
+            body["token"] = self.token
+        if self.token_plaintext is not None:
+            body["token_plaintext"] = self.token_plaintext
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the BearerTokenAuth into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.token is not None:
+            body["token"] = self.token
+        if self.token_plaintext is not None:
+            body["token_plaintext"] = self.token_plaintext
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> BearerTokenAuth:
+        """Deserializes the BearerTokenAuth from a dictionary."""
+        return cls(token=d.get("token", None), token_plaintext=d.get("token_plaintext", None))
+
+
 @dataclass
 class BuildLogsResponse:
     logs: str
@@ -835,6 +920,53 @@ class CreateServingEndpoint:
         )
 
 
+@dataclass
+class CustomProviderConfig:
+    """Configs needed to create a custom provider model route."""
+
+    custom_provider_url: str
+    """This is a field to provide the URL of the custom provider API."""
+
+    api_key_auth: Optional[ApiKeyAuth] = None
+    """This is a field to provide API key authentication for the custom provider API. You can only
+    specify one authentication method."""
+
+    bearer_token_auth: Optional[BearerTokenAuth] = None
+    """This is a field to provide bearer token authentication for the custom provider API. You can only
+    specify one authentication method."""
+
+    def as_dict(self) -> dict:
+        """Serializes the CustomProviderConfig into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.api_key_auth:
+            body["api_key_auth"] = self.api_key_auth.as_dict()
+        if self.bearer_token_auth:
+            body["bearer_token_auth"] = self.bearer_token_auth.as_dict()
+        if self.custom_provider_url is not None:
+            body["custom_provider_url"] = self.custom_provider_url
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CustomProviderConfig into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.api_key_auth:
+            body["api_key_auth"] = self.api_key_auth
+        if self.bearer_token_auth:
+            body["bearer_token_auth"] = self.bearer_token_auth
+        if self.custom_provider_url is not None:
+            body["custom_provider_url"] = self.custom_provider_url
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> CustomProviderConfig:
+        """Deserializes the CustomProviderConfig from a dictionary."""
+        return cls(
+            api_key_auth=_from_dict(d, "api_key_auth", ApiKeyAuth),
+            bearer_token_auth=_from_dict(d, "bearer_token_auth", BearerTokenAuth),
+            custom_provider_url=d.get("custom_provider_url", None),
+        )
+
+
 @dataclass
 class DataPlaneInfo:
     """Details necessary to query this object's API through the DataPlane APIs."""
@@ -1494,6 +1626,9 @@ class ExternalModel:
     cohere_config: Optional[CohereConfig] = None
     """Cohere Config. Only required if the provider is 'cohere'."""
 
+    custom_provider_config: Optional[CustomProviderConfig] = None
+    """Custom Provider Config. Only required if the provider is 'custom'."""
+
     databricks_model_serving_config: Optional[DatabricksModelServingConfig] = None
     """Databricks Model Serving Config. Only required if the provider is 'databricks-model-serving'."""
 
@@ -1517,6 +1652,8 @@ class ExternalModel:
             body["anthropic_config"] = self.anthropic_config.as_dict()
         if self.cohere_config:
             body["cohere_config"] = self.cohere_config.as_dict()
+        if self.custom_provider_config:
+            body["custom_provider_config"] = self.custom_provider_config.as_dict()
         if self.databricks_model_serving_config:
             body["databricks_model_serving_config"] = self.databricks_model_serving_config.as_dict()
         if self.google_cloud_vertex_ai_config:
@@ -1544,6 +1681,8 @@ class ExternalModel:
             body["anthropic_config"] = self.anthropic_config
         if self.cohere_config:
             body["cohere_config"] = self.cohere_config
+        if self.custom_provider_config:
+            body["custom_provider_config"] = self.custom_provider_config
         if self.databricks_model_serving_config:
             body["databricks_model_serving_config"] = self.databricks_model_serving_config
         if self.google_cloud_vertex_ai_config:
@@ -1568,6 +1707,7 @@ class ExternalModel:
             amazon_bedrock_config=_from_dict(d, "amazon_bedrock_config", AmazonBedrockConfig),
             anthropic_config=_from_dict(d, "anthropic_config", AnthropicConfig),
             cohere_config=_from_dict(d, "cohere_config", CohereConfig),
+            custom_provider_config=_from_dict(d, "custom_provider_config", CustomProviderConfig),
             databricks_model_serving_config=_from_dict(
                 d, "databricks_model_serving_config", DatabricksModelServingConfig
             ),
@@ -1586,6 +1726,7 @@ class ExternalModelProvider(Enum):
     AMAZON_BEDROCK = "amazon-bedrock"
     ANTHROPIC = "anthropic"
     COHERE = "cohere"
+    CUSTOM = "custom"
     DATABRICKS_MODEL_SERVING = "databricks-model-serving"
     GOOGLE_CLOUD_VERTEX_AI = "google-cloud-vertex-ai"
     OPENAI = "openai"
@@ -1635,6 +1776,35 @@ class ExternalModelUsageElement:
         )
 
 
+@dataclass
+class FallbackConfig:
+    enabled: bool
+    """Whether to enable traffic fallback. When a served entity in the serving endpoint returns
+    specific error codes (e.g. 500), the request will automatically be round-robin attempted with
+    other served entities in the same endpoint, following the order of served entity list, until a
+    successful response is returned. If all attempts fail, return the last response with the error
+    code."""
+
+    def as_dict(self) -> dict:
+        """Serializes the FallbackConfig into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.enabled is not None:
+            body["enabled"] = self.enabled
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the FallbackConfig into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.enabled is not None:
+            body["enabled"] = self.enabled
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> FallbackConfig:
+        """Deserializes the FallbackConfig from a dictionary."""
+        return cls(enabled=d.get("enabled", None))
+
+
 @dataclass
 class FoundationModel:
     """All fields are not sensitive as they are hard-coded in the system and made available to
@@ -2123,6 +2293,10 @@ class PayloadTable:
 
 @dataclass
 class PutAiGatewayRequest:
+    fallback_config: Optional[FallbackConfig] = None
+    """Configuration for traffic fallback which auto fallbacks to other served entities if the request
+    to a served entity fails with certain error codes, to increase availability."""
+
     guardrails: Optional[AiGatewayGuardrails] = None
     """Configuration for AI Guardrails to prevent unwanted data and unsafe data in requests and
     responses."""
@@ -2144,6 +2318,8 @@ class PutAiGatewayRequest:
     def as_dict(self) -> dict:
         """Serializes the PutAiGatewayRequest into a dictionary suitable for use as a JSON request body."""
         body = {}
+        if self.fallback_config:
+            body["fallback_config"] = self.fallback_config.as_dict()
         if self.guardrails:
             body["guardrails"] = self.guardrails.as_dict()
         if self.inference_table_config:
@@ -2159,6 +2335,8 @@ class PutAiGatewayRequest:
     def as_shallow_dict(self) -> dict:
         """Serializes the PutAiGatewayRequest into a shallow dictionary of its immediate attributes."""
         body = {}
+        if self.fallback_config:
+            body["fallback_config"] = self.fallback_config
         if self.guardrails:
             body["guardrails"] = self.guardrails
         if self.inference_table_config:
@@ -2175,6 +2353,7 @@ class PutAiGatewayRequest:
     def from_dict(cls, d: Dict[str, Any]) -> PutAiGatewayRequest:
         """Deserializes the PutAiGatewayRequest from a dictionary."""
         return cls(
+            fallback_config=_from_dict(d, "fallback_config", FallbackConfig),
             guardrails=_from_dict(d, "guardrails", AiGatewayGuardrails),
             inference_table_config=_from_dict(d, "inference_table_config", AiGatewayInferenceTableConfig),
             name=d.get("name", None),
@@ -2185,6 +2364,10 @@ class PutAiGatewayRequest:
 
 @dataclass
 class PutAiGatewayResponse:
+    fallback_config: Optional[FallbackConfig] = None
+    """Configuration for traffic fallback which auto fallbacks to other served entities if the request
+    to a served entity fails with certain error codes, to increase availability."""
+
     guardrails: Optional[AiGatewayGuardrails] = None
     """Configuration for AI Guardrails to prevent unwanted data and unsafe data in requests and
     responses."""
@@ -2203,6 +2386,8 @@ class PutAiGatewayResponse:
     def as_dict(self) -> dict:
         """Serializes the PutAiGatewayResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
+        if self.fallback_config:
+            body["fallback_config"] = self.fallback_config.as_dict()
         if self.guardrails:
             body["guardrails"] = self.guardrails.as_dict()
         if self.inference_table_config:
@@ -2216,6 +2401,8 @@ class PutAiGatewayResponse:
     def as_shallow_dict(self) -> dict:
         """Serializes the PutAiGatewayResponse into a shallow dictionary of its immediate attributes."""
         body = {}
+        if self.fallback_config:
+            body["fallback_config"] = self.fallback_config
         if self.guardrails:
             body["guardrails"] = self.guardrails
         if self.inference_table_config:
@@ -2230,6 +2417,7 @@ class PutAiGatewayResponse:
     def from_dict(cls, d: Dict[str, Any]) -> PutAiGatewayResponse:
         """Deserializes the PutAiGatewayResponse from a dictionary."""
         return cls(
+            fallback_config=_from_dict(d, "fallback_config", FallbackConfig),
             guardrails=_from_dict(d, "guardrails", AiGatewayGuardrails),
             inference_table_config=_from_dict(d, "inference_table_config", AiGatewayInferenceTableConfig),
             rate_limits=_repeated_dict(d, "rate_limits", AiGatewayRateLimit),
@@ -4368,6 +4556,7 @@ class ServingEndpointsAPI:
         self,
         name: str,
         *,
+        fallback_config: Optional[FallbackConfig] = None,
         guardrails: Optional[AiGatewayGuardrails] = None,
         inference_table_config: Optional[AiGatewayInferenceTableConfig] = None,
         rate_limits: Optional[List[AiGatewayRateLimit]] = None,
@@ -4380,6 +4569,9 @@ class ServingEndpointsAPI:
 
         :param name: str
           The name of the serving endpoint whose AI Gateway is being updated. This field is required.
+        :param fallback_config: :class:`FallbackConfig` (optional)
+          Configuration for traffic fallback which auto fallbacks to other served entities if the request to a
+          served entity fails with certain error codes, to increase availability.
         :param guardrails: :class:`AiGatewayGuardrails` (optional)
           Configuration for AI Guardrails to prevent unwanted data and unsafe data in requests and responses.
         :param inference_table_config: :class:`AiGatewayInferenceTableConfig` (optional)
@@ -4394,6 +4586,8 @@ class ServingEndpointsAPI:
         :returns: :class:`PutAiGatewayResponse`
         """
         body = {}
+        if fallback_config is not None:
+            body["fallback_config"] = fallback_config.as_dict()
         if guardrails is not None:
             body["guardrails"] = guardrails.as_dict()
         if inference_table_config is not None:
@@ -4657,12 +4851,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 +4970,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 +4989,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/service/sharing.py

@@ -324,71 +324,7 @@ class DeltaSharingDependencyList:
 
 
 @dataclass
-class DeltaSharingFunctionDependency:
-    """A Function in UC as a dependency."""
-
-    function_name: Optional[str] = None
-
-    schema_name: Optional[str] = None
-
-    def as_dict(self) -> dict:
-        """Serializes the DeltaSharingFunctionDependency into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.function_name is not None:
-            body["function_name"] = self.function_name
-        if self.schema_name is not None:
-            body["schema_name"] = self.schema_name
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DeltaSharingFunctionDependency into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.function_name is not None:
-            body["function_name"] = self.function_name
-        if self.schema_name is not None:
-            body["schema_name"] = self.schema_name
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DeltaSharingFunctionDependency:
-        """Deserializes the DeltaSharingFunctionDependency from a dictionary."""
-        return cls(function_name=d.get("function_name", None), schema_name=d.get("schema_name", None))
-
-
-@dataclass
-class DeltaSharingTableDependency:
-    """A Table in UC as a dependency."""
-
-    schema_name: Optional[str] = None
-
-    table_name: Optional[str] = None
-
-    def as_dict(self) -> dict:
-        """Serializes the DeltaSharingTableDependency into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.schema_name is not None:
-            body["schema_name"] = self.schema_name
-        if self.table_name is not None:
-            body["table_name"] = self.table_name
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DeltaSharingTableDependency into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.schema_name is not None:
-            body["schema_name"] = self.schema_name
-        if self.table_name is not None:
-            body["table_name"] = self.table_name
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DeltaSharingTableDependency:
-        """Deserializes the DeltaSharingTableDependency from a dictionary."""
-        return cls(schema_name=d.get("schema_name", None), table_name=d.get("table_name", None))
-
-
-@dataclass
-class Function:
+class DeltaSharingFunction:
     aliases: Optional[List[RegisteredModelAlias]] = None
     """The aliass of registered model."""
 
@@ -438,7 +374,7 @@ class Function:
     """The tags of the function."""
 
     def as_dict(self) -> dict:
-        """Serializes the Function into a dictionary suitable for use as a JSON request body."""
+        """Serializes the DeltaSharingFunction into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.aliases:
             body["aliases"] = [v.as_dict() for v in self.aliases]
@@ -475,7 +411,7 @@ class Function:
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the Function into a shallow dictionary of its immediate attributes."""
+        """Serializes the DeltaSharingFunction into a shallow dictionary of its immediate attributes."""
         body = {}
         if self.aliases:
             body["aliases"] = self.aliases
@@ -512,8 +448,8 @@ class Function:
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> Function:
-        """Deserializes the Function from a dictionary."""
+    def from_dict(cls, d: Dict[str, Any]) -> DeltaSharingFunction:
+        """Deserializes the DeltaSharingFunction from a dictionary."""
         return cls(
             aliases=_repeated_dict(d, "aliases", RegisteredModelAlias),
             comment=d.get("comment", None),
@@ -534,6 +470,70 @@ class Function:
         )
 
 
+@dataclass
+class DeltaSharingFunctionDependency:
+    """A Function in UC as a dependency."""
+
+    function_name: Optional[str] = None
+
+    schema_name: Optional[str] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the DeltaSharingFunctionDependency into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.function_name is not None:
+            body["function_name"] = self.function_name
+        if self.schema_name is not None:
+            body["schema_name"] = self.schema_name
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DeltaSharingFunctionDependency into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.function_name is not None:
+            body["function_name"] = self.function_name
+        if self.schema_name is not None:
+            body["schema_name"] = self.schema_name
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> DeltaSharingFunctionDependency:
+        """Deserializes the DeltaSharingFunctionDependency from a dictionary."""
+        return cls(function_name=d.get("function_name", None), schema_name=d.get("schema_name", None))
+
+
+@dataclass
+class DeltaSharingTableDependency:
+    """A Table in UC as a dependency."""
+
+    schema_name: Optional[str] = None
+
+    table_name: Optional[str] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the DeltaSharingTableDependency into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.schema_name is not None:
+            body["schema_name"] = self.schema_name
+        if self.table_name is not None:
+            body["table_name"] = self.table_name
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DeltaSharingTableDependency into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.schema_name is not None:
+            body["schema_name"] = self.schema_name
+        if self.table_name is not None:
+            body["table_name"] = self.table_name
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> DeltaSharingTableDependency:
+        """Deserializes the DeltaSharingTableDependency from a dictionary."""
+        return cls(schema_name=d.get("schema_name", None), table_name=d.get("table_name", None))
+
+
 @dataclass
 class FunctionParameterInfo:
     """Represents a parameter of a function. The same message is used for both input and output
@@ -809,7 +809,7 @@ class IpAccessList:
 class ListProviderShareAssetsResponse:
     """Response to ListProviderShareAssets, which contains the list of assets of a share."""
 
-    functions: Optional[List[Function]] = None
+    functions: Optional[List[DeltaSharingFunction]] = None
     """The list of functions in the share."""
 
     notebooks: Optional[List[NotebookFile]] = None
@@ -851,7 +851,7 @@ class ListProviderShareAssetsResponse:
     def from_dict(cls, d: Dict[str, Any]) -> ListProviderShareAssetsResponse:
         """Deserializes the ListProviderShareAssetsResponse from a dictionary."""
         return cls(
-            functions=_repeated_dict(d, "functions", Function),
+            functions=_repeated_dict(d, "functions", DeltaSharingFunction),
             notebooks=_repeated_dict(d, "notebooks", NotebookFile),
             tables=_repeated_dict(d, "tables", Table),
             volumes=_repeated_dict(d, "volumes", Volume),

databricks/sdk/version.py

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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: databricks-sdk
-Version: 0.45.0
+Version: 0.47.0
 Summary: Databricks SDK for Python (Beta)
 Project-URL: Documentation, https://databricks-sdk-py.readthedocs.io
 Keywords: databricks,sdk
@@ -44,12 +44,13 @@ Requires-Dist: langchain-openai; python_version > "3.7" and extra == "dev"
 Requires-Dist: httpx; extra == "dev"
 Requires-Dist: build; extra == "dev"
 Provides-Extra: notebook
-Requires-Dist: ipython<9,>=8; extra == "notebook"
+Requires-Dist: ipython<10,>=8; extra == "notebook"
 Requires-Dist: ipywidgets<9,>=8; extra == "notebook"
 Provides-Extra: openai
 Requires-Dist: openai; extra == "openai"
 Requires-Dist: langchain-openai; python_version > "3.7" and extra == "openai"
 Requires-Dist: httpx; extra == "openai"
+Dynamic: license-file
 
 # Databricks SDK for Python (Beta)