databricks-sdk 0.63.0__py3-none-any.whl → 0.65.0__py3-none-any.whl

databricks/sdk/service/sharing.py

@@ -1827,59 +1827,32 @@ class SecurablePropertiesKvPairs:
 
 @dataclass
 class Share:
-    comment: Optional[str] = None
-    """The comment of the share."""
-
-    display_name: Optional[str] = None
-    """The display name of the share. If defined, it will be shown in the UI."""
-
     id: Optional[str] = None
 
     name: Optional[str] = None
 
-    tags: Optional[List[catalog.TagKeyValue]] = None
-    """The tags of the share."""
-
     def as_dict(self) -> dict:
         """Serializes the Share into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.comment is not None:
-            body["comment"] = self.comment
-        if self.display_name is not None:
-            body["display_name"] = self.display_name
         if self.id is not None:
             body["id"] = self.id
         if self.name is not None:
             body["name"] = self.name
-        if self.tags:
-            body["tags"] = [v.as_dict() for v in self.tags]
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the Share into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.comment is not None:
-            body["comment"] = self.comment
-        if self.display_name is not None:
-            body["display_name"] = self.display_name
         if self.id is not None:
             body["id"] = self.id
         if self.name is not None:
             body["name"] = self.name
-        if self.tags:
-            body["tags"] = self.tags
         return body
 
     @classmethod
     def from_dict(cls, d: Dict[str, Any]) -> Share:
         """Deserializes the Share from a dictionary."""
-        return cls(
-            comment=d.get("comment", None),
-            display_name=d.get("display_name", None),
-            id=d.get("id", None),
-            name=d.get("name", None),
-            tags=_repeated_dict(d, "tags", catalog.TagKeyValue),
-        )
+        return cls(id=d.get("id", None), name=d.get("name", None))
 
 
 @dataclass

databricks/sdk/service/sql.py

@@ -646,6 +646,10 @@ class AlertV2:
     display_name: Optional[str] = None
     """The display name of the alert."""
 
+    effective_run_as: Optional[AlertV2RunAs] = None
+    """The actual identity that will be used to execute the alert. This is an output-only field that
+    shows the resolved run-as identity after applying permissions and defaults."""
+
     evaluation: Optional[AlertV2Evaluation] = None
 
     id: Optional[str] = None
@@ -664,10 +668,18 @@ class AlertV2:
     query_text: Optional[str] = None
     """Text of the query to be run."""
 
+    run_as: Optional[AlertV2RunAs] = None
+    """Specifies the identity that will be used to run the alert. This field allows you to configure
+    alerts to run as a specific user or service principal. - For user identity: Set `user_name` to
+    the email of an active workspace user. Users can only set this to their own email. - For service
+    principal: Set `service_principal_name` to the application ID. Requires the
+    `servicePrincipal/user` role. If not specified, the alert will run as the request user."""
+
     run_as_user_name: Optional[str] = None
     """The run as username or application ID of service principal. On Create and Update, this field can
     be set to application ID of an active service principal. Setting this field requires the
-    servicePrincipal/user role."""
+    servicePrincipal/user role. Deprecated: Use `run_as` field instead. This field will be removed
+    in a future release."""
 
     schedule: Optional[CronSchedule] = None
 
@@ -688,6 +700,8 @@ class AlertV2:
             body["custom_summary"] = self.custom_summary
         if self.display_name is not None:
             body["display_name"] = self.display_name
+        if self.effective_run_as:
+            body["effective_run_as"] = self.effective_run_as.as_dict()
         if self.evaluation:
             body["evaluation"] = self.evaluation.as_dict()
         if self.id is not None:
@@ -700,6 +714,8 @@ class AlertV2:
             body["parent_path"] = self.parent_path
         if self.query_text is not None:
             body["query_text"] = self.query_text
+        if self.run_as:
+            body["run_as"] = self.run_as.as_dict()
         if self.run_as_user_name is not None:
             body["run_as_user_name"] = self.run_as_user_name
         if self.schedule:
@@ -721,6 +737,8 @@ class AlertV2:
             body["custom_summary"] = self.custom_summary
         if self.display_name is not None:
             body["display_name"] = self.display_name
+        if self.effective_run_as:
+            body["effective_run_as"] = self.effective_run_as
         if self.evaluation:
             body["evaluation"] = self.evaluation
         if self.id is not None:
@@ -733,6 +751,8 @@ class AlertV2:
             body["parent_path"] = self.parent_path
         if self.query_text is not None:
             body["query_text"] = self.query_text
+        if self.run_as:
+            body["run_as"] = self.run_as
         if self.run_as_user_name is not None:
             body["run_as_user_name"] = self.run_as_user_name
         if self.schedule:
@@ -751,12 +771,14 @@ class AlertV2:
             custom_description=d.get("custom_description", None),
             custom_summary=d.get("custom_summary", None),
             display_name=d.get("display_name", None),
+            effective_run_as=_from_dict(d, "effective_run_as", AlertV2RunAs),
             evaluation=_from_dict(d, "evaluation", AlertV2Evaluation),
             id=d.get("id", None),
             lifecycle_state=_enum(d, "lifecycle_state", LifecycleState),
             owner_user_name=d.get("owner_user_name", None),
             parent_path=d.get("parent_path", None),
             query_text=d.get("query_text", None),
+            run_as=_from_dict(d, "run_as", AlertV2RunAs),
             run_as_user_name=d.get("run_as_user_name", None),
             schedule=_from_dict(d, "schedule", CronSchedule),
             update_time=d.get("update_time", None),
@@ -992,6 +1014,39 @@ class AlertV2OperandValue:
         )
 
 
+@dataclass
+class AlertV2RunAs:
+    service_principal_name: Optional[str] = None
+    """Application ID of an active service principal. Setting this field requires the
+    `servicePrincipal/user` role."""
+
+    user_name: Optional[str] = None
+    """The email of an active workspace user. Can only set this field to their own email."""
+
+    def as_dict(self) -> dict:
+        """Serializes the AlertV2RunAs into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.service_principal_name is not None:
+            body["service_principal_name"] = self.service_principal_name
+        if self.user_name is not None:
+            body["user_name"] = self.user_name
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AlertV2RunAs into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.service_principal_name is not None:
+            body["service_principal_name"] = self.service_principal_name
+        if self.user_name is not None:
+            body["user_name"] = self.user_name
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> AlertV2RunAs:
+        """Deserializes the AlertV2RunAs from a dictionary."""
+        return cls(service_principal_name=d.get("service_principal_name", None), user_name=d.get("user_name", None))
+
+
 @dataclass
 class AlertV2Subscription:
     destination_id: Optional[str] = None
@@ -4723,6 +4778,9 @@ class QueryFilter:
 
 @dataclass
 class QueryInfo:
+    cache_query_id: Optional[str] = None
+    """The ID of the cached query if this result retrieved from cache"""
+
     channel_used: Optional[ChannelInfo] = None
     """SQL Warehouse channel information at the time of query execution"""
 
@@ -4808,6 +4866,8 @@ class QueryInfo:
     def as_dict(self) -> dict:
         """Serializes the QueryInfo into a dictionary suitable for use as a JSON request body."""
         body = {}
+        if self.cache_query_id is not None:
+            body["cache_query_id"] = self.cache_query_id
         if self.channel_used:
             body["channel_used"] = self.channel_used.as_dict()
         if self.client_application is not None:
@@ -4861,6 +4921,8 @@ class QueryInfo:
     def as_shallow_dict(self) -> dict:
         """Serializes the QueryInfo into a shallow dictionary of its immediate attributes."""
         body = {}
+        if self.cache_query_id is not None:
+            body["cache_query_id"] = self.cache_query_id
         if self.channel_used:
             body["channel_used"] = self.channel_used
         if self.client_application is not None:
@@ -4915,6 +4977,7 @@ class QueryInfo:
     def from_dict(cls, d: Dict[str, Any]) -> QueryInfo:
         """Deserializes the QueryInfo from a dictionary."""
         return cls(
+            cache_query_id=d.get("cache_query_id", None),
             channel_used=_from_dict(d, "channel_used", ChannelInfo),
             client_application=d.get("client_application", None),
             duration=d.get("duration", None),

databricks/sdk/service/tags.py

@@ -0,0 +1,232 @@
+# Code generated from OpenAPI specs by Databricks SDK Generator. DO NOT EDIT.
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import Any, Dict, Iterator, List, Optional
+
+from ._internal import _repeated_dict
+
+_LOG = logging.getLogger("databricks.sdk")
+
+
+# all definitions in this file are in alphabetical order
+
+
+@dataclass
+class ListTagPoliciesResponse:
+    next_page_token: Optional[str] = None
+
+    tag_policies: Optional[List[TagPolicy]] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the ListTagPoliciesResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        if self.tag_policies:
+            body["tag_policies"] = [v.as_dict() for v in self.tag_policies]
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListTagPoliciesResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        if self.tag_policies:
+            body["tag_policies"] = self.tag_policies
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ListTagPoliciesResponse:
+        """Deserializes the ListTagPoliciesResponse from a dictionary."""
+        return cls(
+            next_page_token=d.get("next_page_token", None), tag_policies=_repeated_dict(d, "tag_policies", TagPolicy)
+        )
+
+
+@dataclass
+class TagPolicy:
+    tag_key: str
+
+    description: Optional[str] = None
+
+    id: Optional[str] = None
+
+    values: Optional[List[Value]] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the TagPolicy into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.description is not None:
+            body["description"] = self.description
+        if self.id is not None:
+            body["id"] = self.id
+        if self.tag_key is not None:
+            body["tag_key"] = self.tag_key
+        if self.values:
+            body["values"] = [v.as_dict() for v in self.values]
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the TagPolicy into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.description is not None:
+            body["description"] = self.description
+        if self.id is not None:
+            body["id"] = self.id
+        if self.tag_key is not None:
+            body["tag_key"] = self.tag_key
+        if self.values:
+            body["values"] = self.values
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> TagPolicy:
+        """Deserializes the TagPolicy from a dictionary."""
+        return cls(
+            description=d.get("description", None),
+            id=d.get("id", None),
+            tag_key=d.get("tag_key", None),
+            values=_repeated_dict(d, "values", Value),
+        )
+
+
+@dataclass
+class Value:
+    name: str
+
+    def as_dict(self) -> dict:
+        """Serializes the Value into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.name is not None:
+            body["name"] = self.name
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the Value into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.name is not None:
+            body["name"] = self.name
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> Value:
+        """Deserializes the Value from a dictionary."""
+        return cls(name=d.get("name", None))
+
+
+class TagPoliciesAPI:
+    """The Tag Policy API allows you to manage tag policies in Databricks."""
+
+    def __init__(self, api_client):
+        self._api = api_client
+
+    def create_tag_policy(self, tag_policy: TagPolicy) -> TagPolicy:
+        """Creates a new tag policy.
+
+        :param tag_policy: :class:`TagPolicy`
+
+        :returns: :class:`TagPolicy`
+        """
+        body = tag_policy.as_dict()
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        res = self._api.do("POST", "/api/2.1/tag-policies", body=body, headers=headers)
+        return TagPolicy.from_dict(res)
+
+    def delete_tag_policy(self, tag_key: str):
+        """Deletes a tag policy by its key.
+
+        :param tag_key: str
+
+
+        """
+
+        headers = {
+            "Accept": "application/json",
+        }
+
+        self._api.do("DELETE", f"/api/2.1/tag-policies/{tag_key}", headers=headers)
+
+    def get_tag_policy(self, tag_key: str) -> TagPolicy:
+        """Gets a single tag policy by its key.
+
+        :param tag_key: str
+
+        :returns: :class:`TagPolicy`
+        """
+
+        headers = {
+            "Accept": "application/json",
+        }
+
+        res = self._api.do("GET", f"/api/2.1/tag-policies/{tag_key}", headers=headers)
+        return TagPolicy.from_dict(res)
+
+    def list_tag_policies(
+        self, *, page_size: Optional[int] = None, page_token: Optional[str] = None
+    ) -> Iterator[TagPolicy]:
+        """Lists all tag policies in the account.
+
+        :param page_size: int (optional)
+          The maximum number of results to return in this request. Fewer results may be returned than
+          requested. If unspecified or set to 0, this defaults to 1000. The maximum value is 1000; values
+          above 1000 will be coerced down to 1000.
+        :param page_token: str (optional)
+          An optional page token received from a previous list tag policies call.
+
+        :returns: Iterator over :class:`TagPolicy`
+        """
+
+        query = {}
+        if page_size is not None:
+            query["page_size"] = page_size
+        if page_token is not None:
+            query["page_token"] = page_token
+        headers = {
+            "Accept": "application/json",
+        }
+
+        while True:
+            json = self._api.do("GET", "/api/2.1/tag-policies", query=query, headers=headers)
+            if "tag_policies" in json:
+                for v in json["tag_policies"]:
+                    yield TagPolicy.from_dict(v)
+            if "next_page_token" not in json or not json["next_page_token"]:
+                return
+            query["page_token"] = json["next_page_token"]
+
+    def update_tag_policy(self, tag_key: str, tag_policy: TagPolicy, update_mask: str) -> TagPolicy:
+        """Updates an existing tag policy.
+
+        :param tag_key: str
+        :param tag_policy: :class:`TagPolicy`
+        :param update_mask: str
+          The field mask must be a single string, with multiple fields separated by commas (no spaces). The
+          field path is relative to the resource object, using a dot (`.`) to navigate sub-fields (e.g.,
+          `author.given_name`). Specification of elements in sequence or map fields is not allowed, as only
+          the entire collection field can be specified. Field names must exactly match the resource field
+          names.
+
+          A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
+          fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the API
+          changes in the future.
+
+        :returns: :class:`TagPolicy`
+        """
+        body = tag_policy.as_dict()
+        query = {}
+        if update_mask is not None:
+            query["update_mask"] = update_mask
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        res = self._api.do("PATCH", f"/api/2.1/tag-policies/{tag_key}", query=query, body=body, headers=headers)
+        return TagPolicy.from_dict(res)

databricks/sdk/service/vectorsearch.py

@@ -377,7 +377,10 @@ class DirectAccessVectorIndexSpec:
 @dataclass
 class EmbeddingSourceColumn:
     embedding_model_endpoint_name: Optional[str] = None
-    """Name of the embedding model endpoint"""
+    """Name of the embedding model endpoint, used by default for both ingestion and querying."""
+
+    model_endpoint_name_for_query: Optional[str] = None
+    """Name of the embedding model endpoint which, if specified, is used for querying (not ingestion)."""
 
     name: Optional[str] = None
     """Name of the column"""
@@ -387,6 +390,8 @@ class EmbeddingSourceColumn:
         body = {}
         if self.embedding_model_endpoint_name is not None:
             body["embedding_model_endpoint_name"] = self.embedding_model_endpoint_name
+        if self.model_endpoint_name_for_query is not None:
+            body["model_endpoint_name_for_query"] = self.model_endpoint_name_for_query
         if self.name is not None:
             body["name"] = self.name
         return body
@@ -396,6 +401,8 @@ class EmbeddingSourceColumn:
         body = {}
         if self.embedding_model_endpoint_name is not None:
             body["embedding_model_endpoint_name"] = self.embedding_model_endpoint_name
+        if self.model_endpoint_name_for_query is not None:
+            body["model_endpoint_name_for_query"] = self.model_endpoint_name_for_query
         if self.name is not None:
             body["name"] = self.name
         return body
@@ -403,7 +410,11 @@ class EmbeddingSourceColumn:
     @classmethod
     def from_dict(cls, d: Dict[str, Any]) -> EmbeddingSourceColumn:
         """Deserializes the EmbeddingSourceColumn from a dictionary."""
-        return cls(embedding_model_endpoint_name=d.get("embedding_model_endpoint_name", None), name=d.get("name", None))
+        return cls(
+            embedding_model_endpoint_name=d.get("embedding_model_endpoint_name", None),
+            model_endpoint_name_for_query=d.get("model_endpoint_name_for_query", None),
+            name=d.get("name", None),
+        )
 
 
 @dataclass
@@ -861,6 +872,60 @@ class QueryVectorIndexResponse:
         )
 
 
+@dataclass
+class RerankerConfig:
+    model: Optional[str] = None
+
+    parameters: Optional[RerankerConfigRerankerParameters] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the RerankerConfig into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.model is not None:
+            body["model"] = self.model
+        if self.parameters:
+            body["parameters"] = self.parameters.as_dict()
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the RerankerConfig into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.model is not None:
+            body["model"] = self.model
+        if self.parameters:
+            body["parameters"] = self.parameters
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> RerankerConfig:
+        """Deserializes the RerankerConfig from a dictionary."""
+        return cls(model=d.get("model", None), parameters=_from_dict(d, "parameters", RerankerConfigRerankerParameters))
+
+
+@dataclass
+class RerankerConfigRerankerParameters:
+    columns_to_rerank: Optional[List[str]] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the RerankerConfigRerankerParameters into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.columns_to_rerank:
+            body["columns_to_rerank"] = [v for v in self.columns_to_rerank]
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the RerankerConfigRerankerParameters into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.columns_to_rerank:
+            body["columns_to_rerank"] = self.columns_to_rerank
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> RerankerConfigRerankerParameters:
+        """Deserializes the RerankerConfigRerankerParameters from a dictionary."""
+        return cls(columns_to_rerank=d.get("columns_to_rerank", None))
+
+
 @dataclass
 class ResultData:
     """Data returned in the query result."""
@@ -1457,7 +1522,8 @@ class VectorSearchEndpointsAPI:
         :param endpoint_name: str
           Name of the vector search endpoint
         :param budget_policy_id: str
-          The budget policy id to be applied
+          The budget policy id to be applied (hima-sheth) TODO: remove this once we've migrated to usage
+          policies
 
         :returns: :class:`PatchEndpointBudgetPolicyResponse`
         """
@@ -1597,20 +1663,27 @@ class VectorSearchIndexesAPI:
 
         self._api.do("DELETE", f"/api/2.0/vector-search/indexes/{index_name}", headers=headers)
 
-    def get_index(self, index_name: str) -> VectorIndex:
+    def get_index(self, index_name: str, *, ensure_reranker_compatible: Optional[bool] = None) -> VectorIndex:
         """Get an index.
 
         :param index_name: str
           Name of the index
+        :param ensure_reranker_compatible: bool (optional)
+          If true, the URL returned for the index is guaranteed to be compatible with the reranker. Currently
+          this means we return the CP URL regardless of how the index is being accessed. If not set or set to
+          false, the URL may still be compatible with the reranker depending on what URL we return.
 
         :returns: :class:`VectorIndex`
         """
 
+        query = {}
+        if ensure_reranker_compatible is not None:
+            query["ensure_reranker_compatible"] = ensure_reranker_compatible
         headers = {
             "Accept": "application/json",
         }
 
-        res = self._api.do("GET", f"/api/2.0/vector-search/indexes/{index_name}", headers=headers)
+        res = self._api.do("GET", f"/api/2.0/vector-search/indexes/{index_name}", query=query, headers=headers)
         return VectorIndex.from_dict(res)
 
     def list_indexes(self, endpoint_name: str, *, page_token: Optional[str] = None) -> Iterator[MiniVectorIndex]:
@@ -1653,6 +1726,7 @@ class VectorSearchIndexesAPI:
         query_text: Optional[str] = None,
         query_type: Optional[str] = None,
         query_vector: Optional[List[float]] = None,
+        reranker: Optional[RerankerConfig] = None,
         score_threshold: Optional[float] = None,
     ) -> QueryVectorIndexResponse:
         """Query the specified vector index.
@@ -1680,6 +1754,7 @@ class VectorSearchIndexesAPI:
         :param query_vector: List[float] (optional)
           Query vector. Required for Direct Vector Access Index and Delta Sync Index using self-managed
           vectors.
+        :param reranker: :class:`RerankerConfig` (optional)
         :param score_threshold: float (optional)
           Threshold for the approximate nearest neighbor search. Defaults to 0.0.
 
@@ -1700,6 +1775,8 @@ class VectorSearchIndexesAPI:
             body["query_type"] = query_type
         if query_vector is not None:
             body["query_vector"] = [v for v in query_vector]
+        if reranker is not None:
+            body["reranker"] = reranker.as_dict()
         if score_threshold is not None:
             body["score_threshold"] = score_threshold
         headers = {

databricks/sdk/version.py

@@ -1 +1 @@
-__version__ = "0.63.0"
+__version__ = "0.65.0"

{databricks_sdk-0.63.0.dist-info → databricks_sdk-0.65.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: databricks-sdk
-Version: 0.63.0
+Version: 0.65.0
 Summary: Databricks SDK for Python (Beta)
 Project-URL: Documentation, https://databricks-sdk-py.readthedocs.io
 Keywords: databricks,sdk
@@ -26,7 +26,7 @@ Requires-Dist: google-auth~=2.0
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
-Requires-Dist: pytest-xdist; extra == "dev"
+Requires-Dist: pytest-xdist<4.0,>=3.6.1; extra == "dev"
 Requires-Dist: pytest-mock; extra == "dev"
 Requires-Dist: black; extra == "dev"
 Requires-Dist: pycodestyle; extra == "dev"