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

databricks/sdk/service/dashboards.py

@@ -4,13 +4,119 @@ from __future__ import annotations
 
 import logging
 from dataclasses import dataclass
+from enum import Enum
 from typing import Dict, Optional
 
+from ._internal import _enum
+
 _LOG = logging.getLogger('databricks.sdk')
 
 # all definitions in this file are in alphabetical order
 
 
+@dataclass
+class CreateDashboardRequest:
+    display_name: str
+    """The display name of the dashboard."""
+
+    parent_path: Optional[str] = None
+    """The workspace path of the folder containing the dashboard. Includes leading slash and no
+    trailing slash."""
+
+    serialized_dashboard: Optional[str] = None
+    """The contents of the dashboard in serialized string form."""
+
+    warehouse_id: Optional[str] = None
+    """The warehouse ID used to run the dashboard."""
+
+    def as_dict(self) -> dict:
+        """Serializes the CreateDashboardRequest into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.parent_path is not None: body['parent_path'] = self.parent_path
+        if self.serialized_dashboard is not None: body['serialized_dashboard'] = self.serialized_dashboard
+        if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> CreateDashboardRequest:
+        """Deserializes the CreateDashboardRequest from a dictionary."""
+        return cls(display_name=d.get('display_name', None),
+                   parent_path=d.get('parent_path', None),
+                   serialized_dashboard=d.get('serialized_dashboard', None),
+                   warehouse_id=d.get('warehouse_id', None))
+
+
+@dataclass
+class Dashboard:
+    create_time: Optional[str] = None
+    """The timestamp of when the dashboard was created."""
+
+    dashboard_id: Optional[str] = None
+    """UUID identifying the dashboard."""
+
+    display_name: Optional[str] = None
+    """The display name of the dashboard."""
+
+    etag: Optional[str] = None
+    """The etag for the dashboard. Can be optionally provided on updates to ensure that the dashboard
+    has not been modified since the last read."""
+
+    lifecycle_state: Optional[LifecycleState] = None
+    """The state of the dashboard resource. Used for tracking trashed status."""
+
+    parent_path: Optional[str] = None
+    """The workspace path of the folder containing the dashboard. Includes leading slash and no
+    trailing slash."""
+
+    path: Optional[str] = None
+    """The workspace path of the dashboard asset, including the file name."""
+
+    serialized_dashboard: Optional[str] = None
+    """The contents of the dashboard in serialized string form."""
+
+    update_time: Optional[str] = None
+    """The timestamp of when the dashboard was last updated by the user."""
+
+    warehouse_id: Optional[str] = None
+    """The warehouse ID used to run the dashboard."""
+
+    def as_dict(self) -> dict:
+        """Serializes the Dashboard into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.create_time is not None: body['create_time'] = self.create_time
+        if self.dashboard_id is not None: body['dashboard_id'] = self.dashboard_id
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.etag is not None: body['etag'] = self.etag
+        if self.lifecycle_state is not None: body['lifecycle_state'] = self.lifecycle_state.value
+        if self.parent_path is not None: body['parent_path'] = self.parent_path
+        if self.path is not None: body['path'] = self.path
+        if self.serialized_dashboard is not None: body['serialized_dashboard'] = self.serialized_dashboard
+        if self.update_time is not None: body['update_time'] = self.update_time
+        if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> Dashboard:
+        """Deserializes the Dashboard from a dictionary."""
+        return cls(create_time=d.get('create_time', None),
+                   dashboard_id=d.get('dashboard_id', None),
+                   display_name=d.get('display_name', None),
+                   etag=d.get('etag', None),
+                   lifecycle_state=_enum(d, 'lifecycle_state', LifecycleState),
+                   parent_path=d.get('parent_path', None),
+                   path=d.get('path', None),
+                   serialized_dashboard=d.get('serialized_dashboard', None),
+                   update_time=d.get('update_time', None),
+                   warehouse_id=d.get('warehouse_id', None))
+
+
+class LifecycleState(Enum):
+
+    ACTIVE = 'ACTIVE'
+    TRASHED = 'TRASHED'
+
+
 @dataclass
 class PublishRequest:
     dashboard_id: Optional[str] = None
@@ -40,19 +146,89 @@ class PublishRequest:
 
 
 @dataclass
-class PublishResponse:
+class PublishedDashboard:
+    display_name: Optional[str] = None
+    """The display name of the published dashboard."""
+
+    embed_credentials: Optional[bool] = None
+    """Indicates whether credentials are embedded in the published dashboard."""
+
+    revision_create_time: Optional[str] = None
+    """The timestamp of when the published dashboard was last revised."""
+
+    warehouse_id: Optional[str] = None
+    """The warehouse ID used to run the published dashboard."""
+
+    def as_dict(self) -> dict:
+        """Serializes the PublishedDashboard into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.embed_credentials is not None: body['embed_credentials'] = self.embed_credentials
+        if self.revision_create_time is not None: body['revision_create_time'] = self.revision_create_time
+        if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> PublishedDashboard:
+        """Deserializes the PublishedDashboard from a dictionary."""
+        return cls(display_name=d.get('display_name', None),
+                   embed_credentials=d.get('embed_credentials', None),
+                   revision_create_time=d.get('revision_create_time', None),
+                   warehouse_id=d.get('warehouse_id', None))
+
+
+@dataclass
+class TrashDashboardResponse:
 
     def as_dict(self) -> dict:
-        """Serializes the PublishResponse into a dictionary suitable for use as a JSON request body."""
+        """Serializes the TrashDashboardResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> PublishResponse:
-        """Deserializes the PublishResponse from a dictionary."""
+    def from_dict(cls, d: Dict[str, any]) -> TrashDashboardResponse:
+        """Deserializes the TrashDashboardResponse from a dictionary."""
         return cls()
 
 
+@dataclass
+class UpdateDashboardRequest:
+    dashboard_id: Optional[str] = None
+    """UUID identifying the dashboard."""
+
+    display_name: Optional[str] = None
+    """The display name of the dashboard."""
+
+    etag: Optional[str] = None
+    """The etag for the dashboard. Can be optionally provided on updates to ensure that the dashboard
+    has not been modified since the last read."""
+
+    serialized_dashboard: Optional[str] = None
+    """The contents of the dashboard in serialized string form."""
+
+    warehouse_id: Optional[str] = None
+    """The warehouse ID used to run the dashboard."""
+
+    def as_dict(self) -> dict:
+        """Serializes the UpdateDashboardRequest 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.display_name is not None: body['display_name'] = self.display_name
+        if self.etag is not None: body['etag'] = self.etag
+        if self.serialized_dashboard is not None: body['serialized_dashboard'] = self.serialized_dashboard
+        if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> UpdateDashboardRequest:
+        """Deserializes the UpdateDashboardRequest from a dictionary."""
+        return cls(dashboard_id=d.get('dashboard_id', None),
+                   display_name=d.get('display_name', None),
+                   etag=d.get('etag', None),
+                   serialized_dashboard=d.get('serialized_dashboard', None),
+                   warehouse_id=d.get('warehouse_id', None))
+
+
 class LakeviewAPI:
     """These APIs provide specific management operations for Lakeview dashboards. Generic resource management can
     be done with Workspace API (import, export, get-status, list, delete)."""
@@ -60,11 +236,75 @@ class LakeviewAPI:
     def __init__(self, api_client):
         self._api = api_client
 
+    def create(self,
+               display_name: str,
+               *,
+               parent_path: Optional[str] = None,
+               serialized_dashboard: Optional[str] = None,
+               warehouse_id: Optional[str] = None) -> Dashboard:
+        """Create dashboard.
+        
+        Create a draft dashboard.
+        
+        :param display_name: str
+          The display name of the dashboard.
+        :param parent_path: str (optional)
+          The workspace path of the folder containing the dashboard. Includes leading slash and no trailing
+          slash.
+        :param serialized_dashboard: str (optional)
+          The contents of the dashboard in serialized string form.
+        :param warehouse_id: str (optional)
+          The warehouse ID used to run the dashboard.
+        
+        :returns: :class:`Dashboard`
+        """
+        body = {}
+        if display_name is not None: body['display_name'] = display_name
+        if parent_path is not None: body['parent_path'] = parent_path
+        if serialized_dashboard is not None: body['serialized_dashboard'] = serialized_dashboard
+        if warehouse_id is not None: body['warehouse_id'] = warehouse_id
+        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
+
+        res = self._api.do('POST', '/api/2.0/lakeview/dashboards', body=body, headers=headers)
+        return Dashboard.from_dict(res)
+
+    def get(self, dashboard_id: str) -> Dashboard:
+        """Get dashboard.
+        
+        Get a draft dashboard.
+        
+        :param dashboard_id: str
+          UUID identifying the dashboard.
+        
+        :returns: :class:`Dashboard`
+        """
+
+        headers = {'Accept': 'application/json', }
+
+        res = self._api.do('GET', f'/api/2.0/lakeview/dashboards/{dashboard_id}', headers=headers)
+        return Dashboard.from_dict(res)
+
+    def get_published(self, dashboard_id: str) -> PublishedDashboard:
+        """Get published dashboard.
+        
+        Get the current published dashboard.
+        
+        :param dashboard_id: str
+          UUID identifying the dashboard to be published.
+        
+        :returns: :class:`PublishedDashboard`
+        """
+
+        headers = {'Accept': 'application/json', }
+
+        res = self._api.do('GET', f'/api/2.0/lakeview/dashboards/{dashboard_id}/published', headers=headers)
+        return PublishedDashboard.from_dict(res)
+
     def publish(self,
                 dashboard_id: str,
                 *,
                 embed_credentials: Optional[bool] = None,
-                warehouse_id: Optional[str] = None):
+                warehouse_id: Optional[str] = None) -> PublishedDashboard:
         """Publish dashboard.
         
         Publish the current draft dashboard.
@@ -77,14 +317,68 @@ class LakeviewAPI:
         :param warehouse_id: str (optional)
           The ID of the warehouse that can be used to override the warehouse which was set in the draft.
         
-        
+        :returns: :class:`PublishedDashboard`
         """
         body = {}
         if embed_credentials is not None: body['embed_credentials'] = embed_credentials
         if warehouse_id is not None: body['warehouse_id'] = warehouse_id
         headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
 
-        self._api.do('POST',
-                     f'/api/2.0/lakeview/dashboards/{dashboard_id}/published',
-                     body=body,
-                     headers=headers)
+        res = self._api.do('POST',
+                           f'/api/2.0/lakeview/dashboards/{dashboard_id}/published',
+                           body=body,
+                           headers=headers)
+        return PublishedDashboard.from_dict(res)
+
+    def trash(self, dashboard_id: str):
+        """Trash dashboard.
+        
+        Trash a dashboard.
+        
+        :param dashboard_id: str
+          UUID identifying the dashboard.
+        
+        
+        """
+
+        headers = {'Accept': 'application/json', }
+
+        self._api.do('DELETE', f'/api/2.0/lakeview/dashboards/{dashboard_id}', headers=headers)
+
+    def update(self,
+               dashboard_id: str,
+               *,
+               display_name: Optional[str] = None,
+               etag: Optional[str] = None,
+               serialized_dashboard: Optional[str] = None,
+               warehouse_id: Optional[str] = None) -> Dashboard:
+        """Update dashboard.
+        
+        Update a draft dashboard.
+        
+        :param dashboard_id: str
+          UUID identifying the dashboard.
+        :param display_name: str (optional)
+          The display name of the dashboard.
+        :param etag: str (optional)
+          The etag for the dashboard. Can be optionally provided on updates to ensure that the dashboard has
+          not been modified since the last read.
+        :param serialized_dashboard: str (optional)
+          The contents of the dashboard in serialized string form.
+        :param warehouse_id: str (optional)
+          The warehouse ID used to run the dashboard.
+        
+        :returns: :class:`Dashboard`
+        """
+        body = {}
+        if display_name is not None: body['display_name'] = display_name
+        if etag is not None: body['etag'] = etag
+        if serialized_dashboard is not None: body['serialized_dashboard'] = serialized_dashboard
+        if warehouse_id is not None: body['warehouse_id'] = warehouse_id
+        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
+
+        res = self._api.do('PATCH',
+                           f'/api/2.0/lakeview/dashboards/{dashboard_id}',
+                           body=body,
+                           headers=headers)
+        return Dashboard.from_dict(res)

databricks/sdk/service/iam.py

@@ -777,6 +777,7 @@ class PermissionLevel(Enum):
     CAN_MANAGE_PRODUCTION_VERSIONS = 'CAN_MANAGE_PRODUCTION_VERSIONS'
     CAN_MANAGE_RUN = 'CAN_MANAGE_RUN'
     CAN_MANAGE_STAGING_VERSIONS = 'CAN_MANAGE_STAGING_VERSIONS'
+    CAN_QUERY = 'CAN_QUERY'
     CAN_READ = 'CAN_READ'
     CAN_RESTART = 'CAN_RESTART'
     CAN_RUN = 'CAN_RUN'

databricks/sdk/service/serving.py

@@ -567,12 +567,12 @@ class EndpointCoreConfigInput:
     """The name of the serving endpoint to update. This field is required."""
 
     served_entities: Optional[List[ServedEntityInput]] = None
-    """A list of served entities for the endpoint to serve. A serving endpoint can have up to 10 served
+    """A list of served entities for the endpoint to serve. A serving endpoint can have up to 15 served
     entities."""
 
     served_models: Optional[List[ServedModelInput]] = None
     """(Deprecated, use served_entities instead) A list of served models for the endpoint to serve. A
-    serving endpoint can have up to 10 served models."""
+    serving endpoint can have up to 15 served models."""
 
     traffic_config: Optional[TrafficConfig] = None
     """The traffic config defining how invocations to the serving endpoint should be routed."""
@@ -661,6 +661,10 @@ class EndpointCoreConfigSummary:
 
 @dataclass
 class EndpointPendingConfig:
+    auto_capture_config: Optional[AutoCaptureConfigOutput] = None
+    """Configuration for Inference Tables which automatically logs requests and responses to Unity
+    Catalog."""
+
     config_version: Optional[int] = None
     """The config version that the serving endpoint is currently serving."""
 
@@ -680,6 +684,7 @@ class EndpointPendingConfig:
     def as_dict(self) -> dict:
         """Serializes the EndpointPendingConfig into a dictionary suitable for use as a JSON request body."""
         body = {}
+        if self.auto_capture_config: body['auto_capture_config'] = self.auto_capture_config.as_dict()
         if self.config_version is not None: body['config_version'] = self.config_version
         if self.served_entities: body['served_entities'] = [v.as_dict() for v in self.served_entities]
         if self.served_models: body['served_models'] = [v.as_dict() for v in self.served_models]
@@ -690,7 +695,8 @@ class EndpointPendingConfig:
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EndpointPendingConfig:
         """Deserializes the EndpointPendingConfig from a dictionary."""
-        return cls(config_version=d.get('config_version', None),
+        return cls(auto_capture_config=_from_dict(d, 'auto_capture_config', AutoCaptureConfigOutput),
+                   config_version=d.get('config_version', None),
                    served_entities=_repeated_dict(d, 'served_entities', ServedEntityOutput),
                    served_models=_repeated_dict(d, 'served_models', ServedModelOutput),
                    start_time=d.get('start_time', None),
@@ -2438,8 +2444,7 @@ class ServingEndpointsAPI:
         raise TimeoutError(f'timed out after {timeout}: {status_message}')
 
     def build_logs(self, name: str, served_model_name: str) -> BuildLogsResponse:
-        """Retrieve the logs associated with building the model's environment for a given serving endpoint's
-        served model.
+        """Get build logs for a served model.
         
         Retrieves the build logs associated with the provided served model.
         
@@ -2518,7 +2523,7 @@ class ServingEndpointsAPI:
         self._api.do('DELETE', f'/api/2.0/serving-endpoints/{name}', headers=headers)
 
     def export_metrics(self, name: str):
-        """Retrieve the metrics associated with a serving endpoint.
+        """Get metrics of a serving endpoint.
         
         Retrieves the metrics associated with the provided serving endpoint in either Prometheus or
         OpenMetrics exposition format.
@@ -2587,7 +2592,7 @@ class ServingEndpointsAPI:
         return ServingEndpointPermissions.from_dict(res)
 
     def list(self) -> Iterator[ServingEndpoint]:
-        """Retrieve all serving endpoints.
+        """Get all serving endpoints.
         
         :returns: Iterator over :class:`ServingEndpoint`
         """
@@ -2599,7 +2604,7 @@ class ServingEndpointsAPI:
         return parsed if parsed is not None else []
 
     def logs(self, name: str, served_model_name: str) -> ServerLogsResponse:
-        """Retrieve the most recent log lines associated with a given serving endpoint's served model.
+        """Get the latest logs for a served model.
         
         Retrieves the service logs associated with the provided served model.
         
@@ -2623,7 +2628,7 @@ class ServingEndpointsAPI:
               *,
               add_tags: Optional[List[EndpointTag]] = None,
               delete_tags: Optional[List[str]] = None) -> Iterator[EndpointTag]:
-        """Patch the tags of a serving endpoint.
+        """Update tags of a serving endpoint.
         
         Used to batch add and delete tags from a serving endpoint with a single API call.
         
@@ -2645,7 +2650,7 @@ class ServingEndpointsAPI:
         return [EndpointTag.from_dict(v) for v in res]
 
     def put(self, name: str, *, rate_limits: Optional[List[RateLimit]] = None) -> PutResponse:
-        """Update the rate limits of a serving endpoint.
+        """Update rate limits of a serving endpoint.
         
         Used to update the rate limits of a serving endpoint. NOTE: only external and foundation model
         endpoints are supported as of now.
@@ -2683,7 +2688,7 @@ class ServingEndpointsAPI:
               stop: Optional[List[str]] = None,
               stream: Optional[bool] = None,
               temperature: Optional[float] = None) -> QueryEndpointResponse:
-        """Query a serving endpoint with provided model input.
+        """Query a serving endpoint.
         
         :param name: str
           The name of the serving endpoint. This field is required.
@@ -2789,7 +2794,7 @@ class ServingEndpointsAPI:
                       served_entities: Optional[List[ServedEntityInput]] = None,
                       served_models: Optional[List[ServedModelInput]] = None,
                       traffic_config: Optional[TrafficConfig] = None) -> Wait[ServingEndpointDetailed]:
-        """Update a serving endpoint with a new config.
+        """Update config of a serving endpoint.
         
         Updates any combination of the serving endpoint's served entities, the compute configuration of those
         served entities, and the endpoint's traffic config. An endpoint that already has an update in progress
@@ -2800,11 +2805,11 @@ class ServingEndpointsAPI:
         :param auto_capture_config: :class:`AutoCaptureConfigInput` (optional)
           Configuration for Inference Tables which automatically logs requests and responses to Unity Catalog.
         :param served_entities: List[:class:`ServedEntityInput`] (optional)
-          A list of served entities for the endpoint to serve. A serving endpoint can have up to 10 served
+          A list of served entities for the endpoint to serve. A serving endpoint can have up to 15 served
           entities.
         :param served_models: List[:class:`ServedModelInput`] (optional)
           (Deprecated, use served_entities instead) A list of served models for the endpoint to serve. A
-          serving endpoint can have up to 10 served models.
+          serving endpoint can have up to 15 served models.
         :param traffic_config: :class:`TrafficConfig` (optional)
           The traffic config defining how invocations to the serving endpoint should be routed.
         

databricks/sdk/service/settings.py

@@ -3271,10 +3271,10 @@ class NetworkConnectivityAPI:
                                      private_endpoint_rule_id: str) -> NccAzurePrivateEndpointRule:
         """Delete a private endpoint rule.
         
-        Initiates deleting a private endpoint rule. The private endpoint will be deactivated and will be
-        purged after seven days of deactivation. When a private endpoint is in deactivated state,
-        `deactivated` field is set to `true` and the private endpoint is not available to your serverless
-        compute resources.
+        Initiates deleting a private endpoint rule. If the connection state is PENDING or EXPIRED, the private
+        endpoint is immediately deleted. Otherwise, the private endpoint is deactivated and will be deleted
+        after seven days of deactivation. When a private endpoint is deactivated, the `deactivated` field is
+        set to `true` and the private endpoint is not available to your serverless compute resources.
         
         :param network_connectivity_config_id: str
           Your Network Connectvity Configuration ID.

databricks/sdk/service/sharing.py

@@ -1287,7 +1287,12 @@ class SharedDataObject:
     comment: Optional[str] = None
     """A user-provided comment when adding the data object to the share. [Update:OPT]"""
 
-    data_object_type: Optional[str] = None
+    content: Optional[str] = None
+    """The content of the notebook file when the data object type is NOTEBOOK_FILE. This should be
+    base64 encoded. Required for adding a NOTEBOOK_FILE, optional for updating, ignored for other
+    types."""
+
+    data_object_type: Optional[SharedDataObjectDataObjectType] = None
     """The type of the data object."""
 
     history_data_sharing_status: Optional[SharedDataObjectHistoryDataSharingStatus] = None
@@ -1326,7 +1331,8 @@ class SharedDataObject:
         if self.added_by is not None: body['added_by'] = self.added_by
         if self.cdf_enabled is not None: body['cdf_enabled'] = self.cdf_enabled
         if self.comment is not None: body['comment'] = self.comment
-        if self.data_object_type is not None: body['data_object_type'] = self.data_object_type
+        if self.content is not None: body['content'] = self.content
+        if self.data_object_type is not None: body['data_object_type'] = self.data_object_type.value
         if self.history_data_sharing_status is not None:
             body['history_data_sharing_status'] = self.history_data_sharing_status.value
         if self.name is not None: body['name'] = self.name
@@ -1344,7 +1350,8 @@ class SharedDataObject:
                    added_by=d.get('added_by', None),
                    cdf_enabled=d.get('cdf_enabled', None),
                    comment=d.get('comment', None),
-                   data_object_type=d.get('data_object_type', None),
+                   content=d.get('content', None),
+                   data_object_type=_enum(d, 'data_object_type', SharedDataObjectDataObjectType),
                    history_data_sharing_status=_enum(d, 'history_data_sharing_status',
                                                      SharedDataObjectHistoryDataSharingStatus),
                    name=d.get('name', None),
@@ -1355,6 +1362,18 @@ class SharedDataObject:
                    string_shared_as=d.get('string_shared_as', None))
 
 
+class SharedDataObjectDataObjectType(Enum):
+    """The type of the data object."""
+
+    MATERIALIZED_VIEW = 'MATERIALIZED_VIEW'
+    MODEL = 'MODEL'
+    NOTEBOOK_FILE = 'NOTEBOOK_FILE'
+    SCHEMA = 'SCHEMA'
+    STREAMING_TABLE = 'STREAMING_TABLE'
+    TABLE = 'TABLE'
+    VIEW = 'VIEW'
+
+
 class SharedDataObjectHistoryDataSharingStatus(Enum):
     """Whether to enable or disable sharing of data history. If not specified, the default is
     **DISABLED**."""

databricks/sdk/service/sql.py

@@ -220,7 +220,7 @@ class AlertQuery:
     """The timestamp at which this query was last updated."""
 
     user_id: Optional[int] = None
-    """The ID of the user who created this query."""
+    """The ID of the user who owns the query."""
 
     def as_dict(self) -> dict:
         """Serializes the AlertQuery into a dictionary suitable for use as a JSON request body."""
@@ -709,7 +709,7 @@ class Dashboard:
     user: Optional[User] = None
 
     user_id: Optional[int] = None
-    """The ID of the user that created and owns this dashboard."""
+    """The ID of the user who owns the dashboard."""
 
     widgets: Optional[List[Widget]] = None
 
@@ -2304,7 +2304,7 @@ class Query:
     user: Optional[User] = None
 
     user_id: Optional[int] = None
-    """The ID of the user who created this query."""
+    """The ID of the user who owns the query."""
 
     visualizations: Optional[List[Visualization]] = None
 

databricks/sdk/service/vectorsearch.py

@@ -320,6 +320,9 @@ class DeltaSyncVectorIndexSpecResponse:
 
 @dataclass
 class DirectAccessVectorIndexSpec:
+    embedding_source_columns: Optional[List[EmbeddingSourceColumn]] = None
+    """Contains the optional model endpoint to use during query time."""
+
     embedding_vector_columns: Optional[List[EmbeddingVectorColumn]] = None
 
     schema_json: Optional[str] = None
@@ -333,6 +336,8 @@ class DirectAccessVectorIndexSpec:
     def as_dict(self) -> dict:
         """Serializes the DirectAccessVectorIndexSpec into a dictionary suitable for use as a JSON request body."""
         body = {}
+        if self.embedding_source_columns:
+            body['embedding_source_columns'] = [v.as_dict() for v in self.embedding_source_columns]
         if self.embedding_vector_columns:
             body['embedding_vector_columns'] = [v.as_dict() for v in self.embedding_vector_columns]
         if self.schema_json is not None: body['schema_json'] = self.schema_json
@@ -341,7 +346,9 @@ class DirectAccessVectorIndexSpec:
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DirectAccessVectorIndexSpec:
         """Deserializes the DirectAccessVectorIndexSpec from a dictionary."""
-        return cls(embedding_vector_columns=_repeated_dict(d, 'embedding_vector_columns',
+        return cls(embedding_source_columns=_repeated_dict(d, 'embedding_source_columns',
+                                                           EmbeddingSourceColumn),
+                   embedding_vector_columns=_repeated_dict(d, 'embedding_vector_columns',
                                                            EmbeddingVectorColumn),
                    schema_json=d.get('schema_json', None))
 

databricks/sdk/version.py

@@ -1 +1 @@
-__version__ = '0.21.0'
+__version__ = '0.23.0'

{databricks_sdk-0.21.0.dist-info → databricks_sdk-0.23.0.dist-info}/METADATA

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