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

databricks/sdk/service/cleanrooms.py

@@ -142,7 +142,8 @@ class CleanRoomAsset:
     For UC securable assets (tables, volumes, etc.), the format is
     *shared_catalog*.*shared_schema*.*asset_name*
     
-    For notebooks, the name is the notebook file name."""
+    For notebooks, the name is the notebook file name. For jar analyses, the name is the jar
+    analysis name."""
 
     asset_type: CleanRoomAssetAssetType
     """The type of the asset."""
@@ -351,7 +352,7 @@ class CleanRoomAssetNotebook:
     """Server generated etag that represents the notebook version."""
 
     review_state: Optional[CleanRoomNotebookReviewNotebookReviewState] = None
-    """top-level status derived from all reviews"""
+    """Top-level status derived from all reviews"""
 
     reviews: Optional[List[CleanRoomNotebookReview]] = None
     """All existing approvals or rejections"""
@@ -546,8 +547,12 @@ class CleanRoomAssetVolumeLocalDetails:
 @dataclass
 class CleanRoomAutoApprovalRule:
     author_collaborator_alias: Optional[str] = None
+    """Collaborator alias of the author covered by the rule. Only one of `author_collaborator_alias`
+    and `author_scope` can be set."""
 
     author_scope: Optional[CleanRoomAutoApprovalRuleAuthorScope] = None
+    """Scope of authors covered by the rule. Only one of `author_collaborator_alias` and `author_scope`
+    can be set."""
 
     clean_room_name: Optional[str] = None
     """The name of the clean room this auto-approval rule belongs to."""
@@ -562,6 +567,7 @@ class CleanRoomAutoApprovalRule:
     """The owner of the rule to whom the rule applies."""
 
     runner_collaborator_alias: Optional[str] = None
+    """Collaborator alias of the runner covered by the rule."""
 
     def as_dict(self) -> dict:
         """Serializes the CleanRoomAutoApprovalRule into a dictionary suitable for use as a JSON request body."""
@@ -704,19 +710,19 @@ class CleanRoomCollaborator:
 @dataclass
 class CleanRoomNotebookReview:
     comment: Optional[str] = None
-    """review comment"""
+    """Review comment"""
 
     created_at_millis: Optional[int] = None
-    """timestamp of when the review was submitted"""
+    """When the review was submitted, in epoch milliseconds"""
 
     review_state: Optional[CleanRoomNotebookReviewNotebookReviewState] = None
-    """review outcome"""
+    """Review outcome"""
 
     review_sub_reason: Optional[CleanRoomNotebookReviewNotebookReviewSubReason] = None
-    """specified when the review was not explicitly made by a user"""
+    """Specified when the review was not explicitly made by a user"""
 
     reviewer_collaborator_alias: Optional[str] = None
-    """collaborator alias of the reviewer"""
+    """Collaborator alias of the reviewer"""
 
     def as_dict(self) -> dict:
         """Serializes the CleanRoomNotebookReview into a dictionary suitable for use as a JSON request body."""
@@ -1100,7 +1106,7 @@ class ComplianceSecurityProfile:
 @dataclass
 class CreateCleanRoomAssetReviewResponse:
     notebook_review_state: Optional[CleanRoomNotebookReviewNotebookReviewState] = None
-    """top-level status derived from all reviews"""
+    """Top-level status derived from all reviews"""
 
     notebook_reviews: Optional[List[CleanRoomNotebookReview]] = None
     """All existing notebook approvals or rejections"""
@@ -1348,13 +1354,13 @@ class ListCleanRoomsResponse:
 @dataclass
 class NotebookVersionReview:
     etag: str
-    """etag that identifies the notebook version"""
+    """Etag identifying the notebook version"""
 
     review_state: CleanRoomNotebookReviewNotebookReviewState
-    """review outcome"""
+    """Review outcome"""
 
     comment: Optional[str] = None
-    """review comment"""
+    """Review comment"""
 
     def as_dict(self) -> dict:
         """Serializes the NotebookVersionReview into a dictionary suitable for use as a JSON request body."""
@@ -1505,12 +1511,12 @@ class CleanRoomAssetsAPI:
         name: str,
         notebook_review: NotebookVersionReview,
     ) -> CreateCleanRoomAssetReviewResponse:
-        """submit an asset review
+        """Submit an asset review
 
         :param clean_room_name: str
           Name of the clean room
         :param asset_type: :class:`CleanRoomAssetAssetType`
-          can only be NOTEBOOK_FILE for now
+          Asset type. Can only be NOTEBOOK_FILE.
         :param name: str
           Name of the asset
         :param notebook_review: :class:`NotebookVersionReview`
@@ -1620,7 +1626,8 @@ class CleanRoomAssetsAPI:
           For UC securable assets (tables, volumes, etc.), the format is
           *shared_catalog*.*shared_schema*.*asset_name*
 
-          For notebooks, the name is the notebook file name.
+          For notebooks, the name is the notebook file name. For jar analyses, the name is the jar analysis
+          name.
         :param asset: :class:`CleanRoomAsset`
           The asset to update. The asset's `name` and `asset_type` fields are used to identify the asset to
           update.

databricks/sdk/service/compute.py

@@ -3410,6 +3410,15 @@ class GcpAttributes:
     boot_disk_size: Optional[int] = None
     """Boot disk size in GB"""
 
+    first_on_demand: Optional[int] = None
+    """The first `first_on_demand` nodes of the cluster will be placed on on-demand instances. This
+    value should be greater than 0, to make sure the cluster driver node is placed on an on-demand
+    instance. If this value is greater than or equal to the current cluster size, all nodes will be
+    placed on on-demand instances. If this value is less than the current cluster size,
+    `first_on_demand` nodes will be placed on on-demand instances and the remainder will be placed
+    on `availability` instances. Note that this value does not affect cluster size and cannot
+    currently be mutated over the lifetime of a cluster."""
+
     google_service_account: Optional[str] = None
     """If provided, the cluster will impersonate the google service account when accessing gcloud
     services (like GCS). The google service account must have previously been added to the
@@ -3441,6 +3450,8 @@ class GcpAttributes:
             body["availability"] = self.availability.value
         if self.boot_disk_size is not None:
             body["boot_disk_size"] = self.boot_disk_size
+        if self.first_on_demand is not None:
+            body["first_on_demand"] = self.first_on_demand
         if self.google_service_account is not None:
             body["google_service_account"] = self.google_service_account
         if self.local_ssd_count is not None:
@@ -3458,6 +3469,8 @@ class GcpAttributes:
             body["availability"] = self.availability
         if self.boot_disk_size is not None:
             body["boot_disk_size"] = self.boot_disk_size
+        if self.first_on_demand is not None:
+            body["first_on_demand"] = self.first_on_demand
         if self.google_service_account is not None:
             body["google_service_account"] = self.google_service_account
         if self.local_ssd_count is not None:
@@ -3474,6 +3487,7 @@ class GcpAttributes:
         return cls(
             availability=_enum(d, "availability", GcpAvailability),
             boot_disk_size=d.get("boot_disk_size", None),
+            first_on_demand=d.get("first_on_demand", None),
             google_service_account=d.get("google_service_account", None),
             local_ssd_count=d.get("local_ssd_count", None),
             use_preemptible_executors=d.get("use_preemptible_executors", None),

databricks/sdk/service/dashboards.py

@@ -1148,6 +1148,9 @@ class Result:
     """Statement Execution API statement id. Use [Get status, manifest, and result first
     chunk](:method:statementexecution/getstatement) to get the full result data."""
 
+    statement_id_signature: Optional[str] = None
+    """JWT corresponding to the statement contained in this result"""
+
     def as_dict(self) -> dict:
         """Serializes the Result into a dictionary suitable for use as a JSON request body."""
         body = {}
@@ -1157,6 +1160,8 @@ class Result:
             body["row_count"] = self.row_count
         if self.statement_id is not None:
             body["statement_id"] = self.statement_id
+        if self.statement_id_signature is not None:
+            body["statement_id_signature"] = self.statement_id_signature
         return body
 
     def as_shallow_dict(self) -> dict:
@@ -1168,6 +1173,8 @@ class Result:
             body["row_count"] = self.row_count
         if self.statement_id is not None:
             body["statement_id"] = self.statement_id
+        if self.statement_id_signature is not None:
+            body["statement_id_signature"] = self.statement_id_signature
         return body
 
     @classmethod
@@ -1177,6 +1184,7 @@ class Result:
             is_truncated=d.get("is_truncated", None),
             row_count=d.get("row_count", None),
             statement_id=d.get("statement_id", None),
+            statement_id_signature=d.get("statement_id_signature", None),
         )
 
 

databricks/sdk/service/database.py

@@ -589,6 +589,40 @@ class DeltaTableSyncInfo:
         )
 
 
+@dataclass
+class ListDatabaseCatalogsResponse:
+    database_catalogs: Optional[List[DatabaseCatalog]] = None
+
+    next_page_token: Optional[str] = None
+    """Pagination token to request the next page of database catalogs."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ListDatabaseCatalogsResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.database_catalogs:
+            body["database_catalogs"] = [v.as_dict() for v in self.database_catalogs]
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListDatabaseCatalogsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.database_catalogs:
+            body["database_catalogs"] = self.database_catalogs
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ListDatabaseCatalogsResponse:
+        """Deserializes the ListDatabaseCatalogsResponse from a dictionary."""
+        return cls(
+            database_catalogs=_repeated_dict(d, "database_catalogs", DatabaseCatalog),
+            next_page_token=d.get("next_page_token", None),
+        )
+
+
 @dataclass
 class ListDatabaseInstanceRolesResponse:
     database_instance_roles: Optional[List[DatabaseInstanceRole]] = None
@@ -659,6 +693,40 @@ class ListDatabaseInstancesResponse:
         )
 
 
+@dataclass
+class ListSyncedDatabaseTablesResponse:
+    next_page_token: Optional[str] = None
+    """Pagination token to request the next page of synced tables."""
+
+    synced_tables: Optional[List[SyncedDatabaseTable]] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the ListSyncedDatabaseTablesResponse 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.synced_tables:
+            body["synced_tables"] = [v.as_dict() for v in self.synced_tables]
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListSyncedDatabaseTablesResponse 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.synced_tables:
+            body["synced_tables"] = self.synced_tables
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ListSyncedDatabaseTablesResponse:
+        """Deserializes the ListSyncedDatabaseTablesResponse from a dictionary."""
+        return cls(
+            next_page_token=d.get("next_page_token", None),
+            synced_tables=_repeated_dict(d, "synced_tables", SyncedDatabaseTable),
+        )
+
+
 @dataclass
 class NewPipelineSpec:
     """Custom fields that user can set for pipeline while creating SyncedDatabaseTable. Note that other
@@ -790,7 +858,7 @@ class RequestedResource:
 
 @dataclass
 class SyncedDatabaseTable:
-    """Next field marker: 12"""
+    """Next field marker: 14"""
 
     name: str
     """Full three-part (catalog, schema, table) name of the table."""
@@ -805,6 +873,14 @@ class SyncedDatabaseTable:
     database instance name MUST match that of the registered catalog (or the request will be
     rejected)."""
 
+    effective_database_instance_name: Optional[str] = None
+    """The name of the database instance that this table is registered to. This field is always
+    returned, and for tables inside database catalogs is inferred database instance associated with
+    the catalog."""
+
+    effective_logical_database_name: Optional[str] = None
+    """The name of the logical database that this table is registered to."""
+
     logical_database_name: Optional[str] = None
     """Target Postgres database object (logical database) name for this table.
     
@@ -831,6 +907,10 @@ class SyncedDatabaseTable:
             body["data_synchronization_status"] = self.data_synchronization_status.as_dict()
         if self.database_instance_name is not None:
             body["database_instance_name"] = self.database_instance_name
+        if self.effective_database_instance_name is not None:
+            body["effective_database_instance_name"] = self.effective_database_instance_name
+        if self.effective_logical_database_name is not None:
+            body["effective_logical_database_name"] = self.effective_logical_database_name
         if self.logical_database_name is not None:
             body["logical_database_name"] = self.logical_database_name
         if self.name is not None:
@@ -848,6 +928,10 @@ class SyncedDatabaseTable:
             body["data_synchronization_status"] = self.data_synchronization_status
         if self.database_instance_name is not None:
             body["database_instance_name"] = self.database_instance_name
+        if self.effective_database_instance_name is not None:
+            body["effective_database_instance_name"] = self.effective_database_instance_name
+        if self.effective_logical_database_name is not None:
+            body["effective_logical_database_name"] = self.effective_logical_database_name
         if self.logical_database_name is not None:
             body["logical_database_name"] = self.logical_database_name
         if self.name is not None:
@@ -864,6 +948,8 @@ class SyncedDatabaseTable:
         return cls(
             data_synchronization_status=_from_dict(d, "data_synchronization_status", SyncedTableStatus),
             database_instance_name=d.get("database_instance_name", None),
+            effective_database_instance_name=d.get("effective_database_instance_name", None),
+            effective_logical_database_name=d.get("effective_logical_database_name", None),
             logical_database_name=d.get("logical_database_name", None),
             name=d.get("name", None),
             spec=_from_dict(d, "spec", SyncedTableSpec),
@@ -1715,10 +1801,47 @@ class DatabaseAPI:
         res = self._api.do("GET", f"/api/2.0/database/synced_tables/{name}", headers=headers)
         return SyncedDatabaseTable.from_dict(res)
 
+    def list_database_catalogs(
+        self, instance_name: str, *, page_size: Optional[int] = None, page_token: Optional[str] = None
+    ) -> Iterator[DatabaseCatalog]:
+        """This API is currently unimplemented, but exposed for Terraform support.
+
+        :param instance_name: str
+          Name of the instance to get database catalogs for.
+        :param page_size: int (optional)
+          Upper bound for items returned.
+        :param page_token: str (optional)
+          Pagination token to go to the next page of synced database tables. Requests first page if absent.
+
+        :returns: Iterator over :class:`DatabaseCatalog`
+        """
+
+        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", f"/api/2.0/database/instances/{instance_name}/catalogs", query=query, headers=headers
+            )
+            if "database_catalogs" in json:
+                for v in json["database_catalogs"]:
+                    yield DatabaseCatalog.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 list_database_instance_roles(
         self, instance_name: str, *, page_size: Optional[int] = None, page_token: Optional[str] = None
     ) -> Iterator[DatabaseInstanceRole]:
-        """START OF PG ROLE APIs Section
+        """START OF PG ROLE APIs Section These APIs are marked a PUBLIC with stage < PUBLIC_PREVIEW. With more
+        recent Lakebase V2 plans, we don't plan to ever advance these to PUBLIC_PREVIEW. These APIs will
+        remain effectively undocumented/UI-only and we'll aim for a new public roles API as part of V2 PuPr.
 
         :param instance_name: str
         :param page_size: int (optional)
@@ -1780,6 +1903,67 @@ class DatabaseAPI:
                 return
             query["page_token"] = json["next_page_token"]
 
+    def list_synced_database_tables(
+        self, instance_name: str, *, page_size: Optional[int] = None, page_token: Optional[str] = None
+    ) -> Iterator[SyncedDatabaseTable]:
+        """This API is currently unimplemented, but exposed for Terraform support.
+
+        :param instance_name: str
+          Name of the instance to get synced tables for.
+        :param page_size: int (optional)
+          Upper bound for items returned.
+        :param page_token: str (optional)
+          Pagination token to go to the next page of synced database tables. Requests first page if absent.
+
+        :returns: Iterator over :class:`SyncedDatabaseTable`
+        """
+
+        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", f"/api/2.0/database/instances/{instance_name}/synced_tables", query=query, headers=headers
+            )
+            if "synced_tables" in json:
+                for v in json["synced_tables"]:
+                    yield SyncedDatabaseTable.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_database_catalog(
+        self, name: str, database_catalog: DatabaseCatalog, update_mask: str
+    ) -> DatabaseCatalog:
+        """This API is currently unimplemented, but exposed for Terraform support.
+
+        :param name: str
+          The name of the catalog in UC.
+        :param database_catalog: :class:`DatabaseCatalog`
+          Note that updating a database catalog is not yet supported.
+        :param update_mask: str
+          The list of fields to update. Setting this field is not yet supported.
+
+        :returns: :class:`DatabaseCatalog`
+        """
+        body = database_catalog.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.0/database/catalogs/{name}", query=query, body=body, headers=headers)
+        return DatabaseCatalog.from_dict(res)
+
     def update_database_instance(
         self, name: str, database_instance: DatabaseInstance, update_mask: str
     ) -> DatabaseInstance:
@@ -1789,7 +1973,8 @@ class DatabaseAPI:
           The name of the instance. This is the unique identifier for the instance.
         :param database_instance: :class:`DatabaseInstance`
         :param update_mask: str
-          The list of fields to update. This field is not yet supported, and is ignored by the server.
+          The list of fields to update. If unspecified, all fields will be updated when possible. To wipe out
+          custom_tags, specify custom_tags in the update_mask with an empty custom_tags map.
 
         :returns: :class:`DatabaseInstance`
         """
@@ -1804,3 +1989,29 @@ class DatabaseAPI:
 
         res = self._api.do("PATCH", f"/api/2.0/database/instances/{name}", query=query, body=body, headers=headers)
         return DatabaseInstance.from_dict(res)
+
+    def update_synced_database_table(
+        self, name: str, synced_table: SyncedDatabaseTable, update_mask: str
+    ) -> SyncedDatabaseTable:
+        """This API is currently unimplemented, but exposed for Terraform support.
+
+        :param name: str
+          Full three-part (catalog, schema, table) name of the table.
+        :param synced_table: :class:`SyncedDatabaseTable`
+          Note that updating a synced database table is not yet supported.
+        :param update_mask: str
+          The list of fields to update. Setting this field is not yet supported.
+
+        :returns: :class:`SyncedDatabaseTable`
+        """
+        body = synced_table.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.0/database/synced_tables/{name}", query=query, body=body, headers=headers)
+        return SyncedDatabaseTable.from_dict(res)