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

databricks/sdk/service/cleanrooms.py

@@ -5,11 +5,12 @@ from __future__ import annotations
 import logging
 from dataclasses import dataclass
 from enum import Enum
-from typing import Dict, Iterator, List, Optional
+from typing import Any, Dict, Iterator, List, Optional
 
 from ._internal import _enum, _from_dict, _repeated_dict
 
-_LOG = logging.getLogger('databricks.sdk')
+_LOG = logging.getLogger("databricks.sdk")
+
 
 from databricks.sdk.service import catalog, jobs, settings, sharing
 
@@ -57,54 +58,74 @@ class CleanRoom:
     def as_dict(self) -> dict:
         """Serializes the CleanRoom into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.access_restricted is not None: body['access_restricted'] = self.access_restricted.value
-        if self.comment is not None: body['comment'] = self.comment
-        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.access_restricted is not None:
+            body["access_restricted"] = self.access_restricted.value
+        if self.comment is not None:
+            body["comment"] = self.comment
+        if self.created_at is not None:
+            body["created_at"] = self.created_at
         if self.local_collaborator_alias is not None:
-            body['local_collaborator_alias'] = self.local_collaborator_alias
-        if self.name is not None: body['name'] = self.name
-        if self.output_catalog: body['output_catalog'] = self.output_catalog.as_dict()
-        if self.owner is not None: body['owner'] = self.owner
-        if self.remote_detailed_info: body['remote_detailed_info'] = self.remote_detailed_info.as_dict()
-        if self.status is not None: body['status'] = self.status.value
-        if self.updated_at is not None: body['updated_at'] = self.updated_at
+            body["local_collaborator_alias"] = self.local_collaborator_alias
+        if self.name is not None:
+            body["name"] = self.name
+        if self.output_catalog:
+            body["output_catalog"] = self.output_catalog.as_dict()
+        if self.owner is not None:
+            body["owner"] = self.owner
+        if self.remote_detailed_info:
+            body["remote_detailed_info"] = self.remote_detailed_info.as_dict()
+        if self.status is not None:
+            body["status"] = self.status.value
+        if self.updated_at is not None:
+            body["updated_at"] = self.updated_at
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the CleanRoom into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.access_restricted is not None: body['access_restricted'] = self.access_restricted
-        if self.comment is not None: body['comment'] = self.comment
-        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.access_restricted is not None:
+            body["access_restricted"] = self.access_restricted
+        if self.comment is not None:
+            body["comment"] = self.comment
+        if self.created_at is not None:
+            body["created_at"] = self.created_at
         if self.local_collaborator_alias is not None:
-            body['local_collaborator_alias'] = self.local_collaborator_alias
-        if self.name is not None: body['name'] = self.name
-        if self.output_catalog: body['output_catalog'] = self.output_catalog
-        if self.owner is not None: body['owner'] = self.owner
-        if self.remote_detailed_info: body['remote_detailed_info'] = self.remote_detailed_info
-        if self.status is not None: body['status'] = self.status
-        if self.updated_at is not None: body['updated_at'] = self.updated_at
+            body["local_collaborator_alias"] = self.local_collaborator_alias
+        if self.name is not None:
+            body["name"] = self.name
+        if self.output_catalog:
+            body["output_catalog"] = self.output_catalog
+        if self.owner is not None:
+            body["owner"] = self.owner
+        if self.remote_detailed_info:
+            body["remote_detailed_info"] = self.remote_detailed_info
+        if self.status is not None:
+            body["status"] = self.status
+        if self.updated_at is not None:
+            body["updated_at"] = self.updated_at
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CleanRoom:
+    def from_dict(cls, d: Dict[str, Any]) -> CleanRoom:
         """Deserializes the CleanRoom from a dictionary."""
-        return cls(access_restricted=_enum(d, 'access_restricted', CleanRoomAccessRestricted),
-                   comment=d.get('comment', None),
-                   created_at=d.get('created_at', None),
-                   local_collaborator_alias=d.get('local_collaborator_alias', None),
-                   name=d.get('name', None),
-                   output_catalog=_from_dict(d, 'output_catalog', CleanRoomOutputCatalog),
-                   owner=d.get('owner', None),
-                   remote_detailed_info=_from_dict(d, 'remote_detailed_info', CleanRoomRemoteDetail),
-                   status=_enum(d, 'status', CleanRoomStatusEnum),
-                   updated_at=d.get('updated_at', None))
+        return cls(
+            access_restricted=_enum(d, "access_restricted", CleanRoomAccessRestricted),
+            comment=d.get("comment", None),
+            created_at=d.get("created_at", None),
+            local_collaborator_alias=d.get("local_collaborator_alias", None),
+            name=d.get("name", None),
+            output_catalog=_from_dict(d, "output_catalog", CleanRoomOutputCatalog),
+            owner=d.get("owner", None),
+            remote_detailed_info=_from_dict(d, "remote_detailed_info", CleanRoomRemoteDetail),
+            status=_enum(d, "status", CleanRoomStatusEnum),
+            updated_at=d.get("updated_at", None),
+        )
 
 
 class CleanRoomAccessRestricted(Enum):
 
-    CSP_MISMATCH = 'CSP_MISMATCH'
-    NO_RESTRICTION = 'NO_RESTRICTION'
+    CSP_MISMATCH = "CSP_MISMATCH"
+    NO_RESTRICTION = "NO_RESTRICTION"
 
 
 @dataclass
@@ -167,70 +188,94 @@ class CleanRoomAsset:
     def as_dict(self) -> dict:
         """Serializes the CleanRoomAsset into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.added_at is not None: body['added_at'] = self.added_at
-        if self.asset_type is not None: body['asset_type'] = self.asset_type.value
-        if self.foreign_table: body['foreign_table'] = self.foreign_table.as_dict()
+        if self.added_at is not None:
+            body["added_at"] = self.added_at
+        if self.asset_type is not None:
+            body["asset_type"] = self.asset_type.value
+        if self.foreign_table:
+            body["foreign_table"] = self.foreign_table.as_dict()
         if self.foreign_table_local_details:
-            body['foreign_table_local_details'] = self.foreign_table_local_details.as_dict()
-        if self.name is not None: body['name'] = self.name
-        if self.notebook: body['notebook'] = self.notebook.as_dict()
+            body["foreign_table_local_details"] = self.foreign_table_local_details.as_dict()
+        if self.name is not None:
+            body["name"] = self.name
+        if self.notebook:
+            body["notebook"] = self.notebook.as_dict()
         if self.owner_collaborator_alias is not None:
-            body['owner_collaborator_alias'] = self.owner_collaborator_alias
-        if self.status is not None: body['status'] = self.status.value
-        if self.table: body['table'] = self.table.as_dict()
-        if self.table_local_details: body['table_local_details'] = self.table_local_details.as_dict()
-        if self.view: body['view'] = self.view.as_dict()
-        if self.view_local_details: body['view_local_details'] = self.view_local_details.as_dict()
-        if self.volume_local_details: body['volume_local_details'] = self.volume_local_details.as_dict()
+            body["owner_collaborator_alias"] = self.owner_collaborator_alias
+        if self.status is not None:
+            body["status"] = self.status.value
+        if self.table:
+            body["table"] = self.table.as_dict()
+        if self.table_local_details:
+            body["table_local_details"] = self.table_local_details.as_dict()
+        if self.view:
+            body["view"] = self.view.as_dict()
+        if self.view_local_details:
+            body["view_local_details"] = self.view_local_details.as_dict()
+        if self.volume_local_details:
+            body["volume_local_details"] = self.volume_local_details.as_dict()
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the CleanRoomAsset into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.added_at is not None: body['added_at'] = self.added_at
-        if self.asset_type is not None: body['asset_type'] = self.asset_type
-        if self.foreign_table: body['foreign_table'] = self.foreign_table
+        if self.added_at is not None:
+            body["added_at"] = self.added_at
+        if self.asset_type is not None:
+            body["asset_type"] = self.asset_type
+        if self.foreign_table:
+            body["foreign_table"] = self.foreign_table
         if self.foreign_table_local_details:
-            body['foreign_table_local_details'] = self.foreign_table_local_details
-        if self.name is not None: body['name'] = self.name
-        if self.notebook: body['notebook'] = self.notebook
+            body["foreign_table_local_details"] = self.foreign_table_local_details
+        if self.name is not None:
+            body["name"] = self.name
+        if self.notebook:
+            body["notebook"] = self.notebook
         if self.owner_collaborator_alias is not None:
-            body['owner_collaborator_alias'] = self.owner_collaborator_alias
-        if self.status is not None: body['status'] = self.status
-        if self.table: body['table'] = self.table
-        if self.table_local_details: body['table_local_details'] = self.table_local_details
-        if self.view: body['view'] = self.view
-        if self.view_local_details: body['view_local_details'] = self.view_local_details
-        if self.volume_local_details: body['volume_local_details'] = self.volume_local_details
+            body["owner_collaborator_alias"] = self.owner_collaborator_alias
+        if self.status is not None:
+            body["status"] = self.status
+        if self.table:
+            body["table"] = self.table
+        if self.table_local_details:
+            body["table_local_details"] = self.table_local_details
+        if self.view:
+            body["view"] = self.view
+        if self.view_local_details:
+            body["view_local_details"] = self.view_local_details
+        if self.volume_local_details:
+            body["volume_local_details"] = self.volume_local_details
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CleanRoomAsset:
+    def from_dict(cls, d: Dict[str, Any]) -> CleanRoomAsset:
         """Deserializes the CleanRoomAsset from a dictionary."""
-        return cls(added_at=d.get('added_at', None),
-                   asset_type=_enum(d, 'asset_type', CleanRoomAssetAssetType),
-                   foreign_table=_from_dict(d, 'foreign_table', CleanRoomAssetForeignTable),
-                   foreign_table_local_details=_from_dict(d, 'foreign_table_local_details',
-                                                          CleanRoomAssetForeignTableLocalDetails),
-                   name=d.get('name', None),
-                   notebook=_from_dict(d, 'notebook', CleanRoomAssetNotebook),
-                   owner_collaborator_alias=d.get('owner_collaborator_alias', None),
-                   status=_enum(d, 'status', CleanRoomAssetStatusEnum),
-                   table=_from_dict(d, 'table', CleanRoomAssetTable),
-                   table_local_details=_from_dict(d, 'table_local_details', CleanRoomAssetTableLocalDetails),
-                   view=_from_dict(d, 'view', CleanRoomAssetView),
-                   view_local_details=_from_dict(d, 'view_local_details', CleanRoomAssetViewLocalDetails),
-                   volume_local_details=_from_dict(d, 'volume_local_details',
-                                                   CleanRoomAssetVolumeLocalDetails))
+        return cls(
+            added_at=d.get("added_at", None),
+            asset_type=_enum(d, "asset_type", CleanRoomAssetAssetType),
+            foreign_table=_from_dict(d, "foreign_table", CleanRoomAssetForeignTable),
+            foreign_table_local_details=_from_dict(
+                d, "foreign_table_local_details", CleanRoomAssetForeignTableLocalDetails
+            ),
+            name=d.get("name", None),
+            notebook=_from_dict(d, "notebook", CleanRoomAssetNotebook),
+            owner_collaborator_alias=d.get("owner_collaborator_alias", None),
+            status=_enum(d, "status", CleanRoomAssetStatusEnum),
+            table=_from_dict(d, "table", CleanRoomAssetTable),
+            table_local_details=_from_dict(d, "table_local_details", CleanRoomAssetTableLocalDetails),
+            view=_from_dict(d, "view", CleanRoomAssetView),
+            view_local_details=_from_dict(d, "view_local_details", CleanRoomAssetViewLocalDetails),
+            volume_local_details=_from_dict(d, "volume_local_details", CleanRoomAssetVolumeLocalDetails),
+        )
 
 
 class CleanRoomAssetAssetType(Enum):
 
-    FOREIGN_TABLE = 'FOREIGN_TABLE'
-    NOTEBOOK_FILE = 'NOTEBOOK_FILE'
-    TABLE = 'TABLE'
-    VIEW = 'VIEW'
-    VOLUME = 'VOLUME'
+    FOREIGN_TABLE = "FOREIGN_TABLE"
+    NOTEBOOK_FILE = "NOTEBOOK_FILE"
+    TABLE = "TABLE"
+    VIEW = "VIEW"
+    VOLUME = "VOLUME"
 
 
 @dataclass
@@ -241,19 +286,21 @@ class CleanRoomAssetForeignTable:
     def as_dict(self) -> dict:
         """Serializes the CleanRoomAssetForeignTable into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.columns: body['columns'] = [v.as_dict() for v in self.columns]
+        if self.columns:
+            body["columns"] = [v.as_dict() for v in self.columns]
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the CleanRoomAssetForeignTable into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.columns: body['columns'] = self.columns
+        if self.columns:
+            body["columns"] = self.columns
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CleanRoomAssetForeignTable:
+    def from_dict(cls, d: Dict[str, Any]) -> CleanRoomAssetForeignTable:
         """Deserializes the CleanRoomAssetForeignTable from a dictionary."""
-        return cls(columns=_repeated_dict(d, 'columns', catalog.ColumnInfo))
+        return cls(columns=_repeated_dict(d, "columns", catalog.ColumnInfo))
 
 
 @dataclass
@@ -265,19 +312,21 @@ class CleanRoomAssetForeignTableLocalDetails:
     def as_dict(self) -> dict:
         """Serializes the CleanRoomAssetForeignTableLocalDetails into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.local_name is not None: body['local_name'] = self.local_name
+        if self.local_name is not None:
+            body["local_name"] = self.local_name
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the CleanRoomAssetForeignTableLocalDetails into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.local_name is not None: body['local_name'] = self.local_name
+        if self.local_name is not None:
+            body["local_name"] = self.local_name
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CleanRoomAssetForeignTableLocalDetails:
+    def from_dict(cls, d: Dict[str, Any]) -> CleanRoomAssetForeignTableLocalDetails:
         """Deserializes the CleanRoomAssetForeignTableLocalDetails from a dictionary."""
-        return cls(local_name=d.get('local_name', None))
+        return cls(local_name=d.get("local_name", None))
 
 
 @dataclass
@@ -292,28 +341,32 @@ class CleanRoomAssetNotebook:
     def as_dict(self) -> dict:
         """Serializes the CleanRoomAssetNotebook into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.etag is not None: body['etag'] = self.etag
-        if self.notebook_content is not None: body['notebook_content'] = self.notebook_content
+        if self.etag is not None:
+            body["etag"] = self.etag
+        if self.notebook_content is not None:
+            body["notebook_content"] = self.notebook_content
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the CleanRoomAssetNotebook into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.etag is not None: body['etag'] = self.etag
-        if self.notebook_content is not None: body['notebook_content'] = self.notebook_content
+        if self.etag is not None:
+            body["etag"] = self.etag
+        if self.notebook_content is not None:
+            body["notebook_content"] = self.notebook_content
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CleanRoomAssetNotebook:
+    def from_dict(cls, d: Dict[str, Any]) -> CleanRoomAssetNotebook:
         """Deserializes the CleanRoomAssetNotebook from a dictionary."""
-        return cls(etag=d.get('etag', None), notebook_content=d.get('notebook_content', None))
+        return cls(etag=d.get("etag", None), notebook_content=d.get("notebook_content", None))
 
 
 class CleanRoomAssetStatusEnum(Enum):
 
-    ACTIVE = 'ACTIVE'
-    PENDING = 'PENDING'
-    PERMISSION_DENIED = 'PERMISSION_DENIED'
+    ACTIVE = "ACTIVE"
+    PENDING = "PENDING"
+    PERMISSION_DENIED = "PERMISSION_DENIED"
 
 
 @dataclass
@@ -324,19 +377,21 @@ class CleanRoomAssetTable:
     def as_dict(self) -> dict:
         """Serializes the CleanRoomAssetTable into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.columns: body['columns'] = [v.as_dict() for v in self.columns]
+        if self.columns:
+            body["columns"] = [v.as_dict() for v in self.columns]
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the CleanRoomAssetTable into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.columns: body['columns'] = self.columns
+        if self.columns:
+            body["columns"] = self.columns
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CleanRoomAssetTable:
+    def from_dict(cls, d: Dict[str, Any]) -> CleanRoomAssetTable:
         """Deserializes the CleanRoomAssetTable from a dictionary."""
-        return cls(columns=_repeated_dict(d, 'columns', catalog.ColumnInfo))
+        return cls(columns=_repeated_dict(d, "columns", catalog.ColumnInfo))
 
 
 @dataclass
@@ -345,28 +400,31 @@ class CleanRoomAssetTableLocalDetails:
     """The fully qualified name of the table in its owner's local metastore, in the format of
     *catalog*.*schema*.*table_name*"""
 
-    partitions: Optional[List[sharing.PartitionSpecificationPartition]] = None
+    partitions: Optional[List[sharing.Partition]] = None
     """Partition filtering specification for a shared table."""
 
     def as_dict(self) -> dict:
         """Serializes the CleanRoomAssetTableLocalDetails into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.local_name is not None: body['local_name'] = self.local_name
-        if self.partitions: body['partitions'] = [v.as_dict() for v in self.partitions]
+        if self.local_name is not None:
+            body["local_name"] = self.local_name
+        if self.partitions:
+            body["partitions"] = [v.as_dict() for v in self.partitions]
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the CleanRoomAssetTableLocalDetails into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.local_name is not None: body['local_name'] = self.local_name
-        if self.partitions: body['partitions'] = self.partitions
+        if self.local_name is not None:
+            body["local_name"] = self.local_name
+        if self.partitions:
+            body["partitions"] = self.partitions
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CleanRoomAssetTableLocalDetails:
+    def from_dict(cls, d: Dict[str, Any]) -> CleanRoomAssetTableLocalDetails:
         """Deserializes the CleanRoomAssetTableLocalDetails from a dictionary."""
-        return cls(local_name=d.get('local_name', None),
-                   partitions=_repeated_dict(d, 'partitions', sharing.PartitionSpecificationPartition))
+        return cls(local_name=d.get("local_name", None), partitions=_repeated_dict(d, "partitions", sharing.Partition))
 
 
 @dataclass
@@ -377,19 +435,21 @@ class CleanRoomAssetView:
     def as_dict(self) -> dict:
         """Serializes the CleanRoomAssetView into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.columns: body['columns'] = [v.as_dict() for v in self.columns]
+        if self.columns:
+            body["columns"] = [v.as_dict() for v in self.columns]
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the CleanRoomAssetView into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.columns: body['columns'] = self.columns
+        if self.columns:
+            body["columns"] = self.columns
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CleanRoomAssetView:
+    def from_dict(cls, d: Dict[str, Any]) -> CleanRoomAssetView:
         """Deserializes the CleanRoomAssetView from a dictionary."""
-        return cls(columns=_repeated_dict(d, 'columns', catalog.ColumnInfo))
+        return cls(columns=_repeated_dict(d, "columns", catalog.ColumnInfo))
 
 
 @dataclass
@@ -401,19 +461,21 @@ class CleanRoomAssetViewLocalDetails:
     def as_dict(self) -> dict:
         """Serializes the CleanRoomAssetViewLocalDetails into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.local_name is not None: body['local_name'] = self.local_name
+        if self.local_name is not None:
+            body["local_name"] = self.local_name
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the CleanRoomAssetViewLocalDetails into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.local_name is not None: body['local_name'] = self.local_name
+        if self.local_name is not None:
+            body["local_name"] = self.local_name
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CleanRoomAssetViewLocalDetails:
+    def from_dict(cls, d: Dict[str, Any]) -> CleanRoomAssetViewLocalDetails:
         """Deserializes the CleanRoomAssetViewLocalDetails from a dictionary."""
-        return cls(local_name=d.get('local_name', None))
+        return cls(local_name=d.get("local_name", None))
 
 
 @dataclass
@@ -425,19 +487,21 @@ class CleanRoomAssetVolumeLocalDetails:
     def as_dict(self) -> dict:
         """Serializes the CleanRoomAssetVolumeLocalDetails into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.local_name is not None: body['local_name'] = self.local_name
+        if self.local_name is not None:
+            body["local_name"] = self.local_name
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the CleanRoomAssetVolumeLocalDetails into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.local_name is not None: body['local_name'] = self.local_name
+        if self.local_name is not None:
+            body["local_name"] = self.local_name
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CleanRoomAssetVolumeLocalDetails:
+    def from_dict(cls, d: Dict[str, Any]) -> CleanRoomAssetVolumeLocalDetails:
         """Deserializes the CleanRoomAssetVolumeLocalDetails from a dictionary."""
-        return cls(local_name=d.get('local_name', None))
+        return cls(local_name=d.get("local_name", None))
 
 
 @dataclass
@@ -477,38 +541,48 @@ class CleanRoomCollaborator:
     def as_dict(self) -> dict:
         """Serializes the CleanRoomCollaborator into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.collaborator_alias is not None: body['collaborator_alias'] = self.collaborator_alias
-        if self.display_name is not None: body['display_name'] = self.display_name
-        if self.global_metastore_id is not None: body['global_metastore_id'] = self.global_metastore_id
+        if self.collaborator_alias is not None:
+            body["collaborator_alias"] = self.collaborator_alias
+        if self.display_name is not None:
+            body["display_name"] = self.display_name
+        if self.global_metastore_id is not None:
+            body["global_metastore_id"] = self.global_metastore_id
         if self.invite_recipient_email is not None:
-            body['invite_recipient_email'] = self.invite_recipient_email
+            body["invite_recipient_email"] = self.invite_recipient_email
         if self.invite_recipient_workspace_id is not None:
-            body['invite_recipient_workspace_id'] = self.invite_recipient_workspace_id
-        if self.organization_name is not None: body['organization_name'] = self.organization_name
+            body["invite_recipient_workspace_id"] = self.invite_recipient_workspace_id
+        if self.organization_name is not None:
+            body["organization_name"] = self.organization_name
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the CleanRoomCollaborator into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.collaborator_alias is not None: body['collaborator_alias'] = self.collaborator_alias
-        if self.display_name is not None: body['display_name'] = self.display_name
-        if self.global_metastore_id is not None: body['global_metastore_id'] = self.global_metastore_id
+        if self.collaborator_alias is not None:
+            body["collaborator_alias"] = self.collaborator_alias
+        if self.display_name is not None:
+            body["display_name"] = self.display_name
+        if self.global_metastore_id is not None:
+            body["global_metastore_id"] = self.global_metastore_id
         if self.invite_recipient_email is not None:
-            body['invite_recipient_email'] = self.invite_recipient_email
+            body["invite_recipient_email"] = self.invite_recipient_email
         if self.invite_recipient_workspace_id is not None:
-            body['invite_recipient_workspace_id'] = self.invite_recipient_workspace_id
-        if self.organization_name is not None: body['organization_name'] = self.organization_name
+            body["invite_recipient_workspace_id"] = self.invite_recipient_workspace_id
+        if self.organization_name is not None:
+            body["organization_name"] = self.organization_name
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CleanRoomCollaborator:
+    def from_dict(cls, d: Dict[str, Any]) -> CleanRoomCollaborator:
         """Deserializes the CleanRoomCollaborator from a dictionary."""
-        return cls(collaborator_alias=d.get('collaborator_alias', None),
-                   display_name=d.get('display_name', None),
-                   global_metastore_id=d.get('global_metastore_id', None),
-                   invite_recipient_email=d.get('invite_recipient_email', None),
-                   invite_recipient_workspace_id=d.get('invite_recipient_workspace_id', None),
-                   organization_name=d.get('organization_name', None))
+        return cls(
+            collaborator_alias=d.get("collaborator_alias", None),
+            display_name=d.get("display_name", None),
+            global_metastore_id=d.get("global_metastore_id", None),
+            invite_recipient_email=d.get("invite_recipient_email", None),
+            invite_recipient_workspace_id=d.get("invite_recipient_workspace_id", None),
+            organization_name=d.get("organization_name", None),
+        )
 
 
 @dataclass
@@ -542,40 +616,52 @@ class CleanRoomNotebookTaskRun:
         """Serializes the CleanRoomNotebookTaskRun into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.collaborator_job_run_info:
-            body['collaborator_job_run_info'] = self.collaborator_job_run_info.as_dict()
-        if self.notebook_job_run_state: body['notebook_job_run_state'] = self.notebook_job_run_state.as_dict()
-        if self.notebook_name is not None: body['notebook_name'] = self.notebook_name
+            body["collaborator_job_run_info"] = self.collaborator_job_run_info.as_dict()
+        if self.notebook_job_run_state:
+            body["notebook_job_run_state"] = self.notebook_job_run_state.as_dict()
+        if self.notebook_name is not None:
+            body["notebook_name"] = self.notebook_name
         if self.output_schema_expiration_time is not None:
-            body['output_schema_expiration_time'] = self.output_schema_expiration_time
-        if self.output_schema_name is not None: body['output_schema_name'] = self.output_schema_name
-        if self.run_duration is not None: body['run_duration'] = self.run_duration
-        if self.start_time is not None: body['start_time'] = self.start_time
+            body["output_schema_expiration_time"] = self.output_schema_expiration_time
+        if self.output_schema_name is not None:
+            body["output_schema_name"] = self.output_schema_name
+        if self.run_duration is not None:
+            body["run_duration"] = self.run_duration
+        if self.start_time is not None:
+            body["start_time"] = self.start_time
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the CleanRoomNotebookTaskRun into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.collaborator_job_run_info: body['collaborator_job_run_info'] = self.collaborator_job_run_info
-        if self.notebook_job_run_state: body['notebook_job_run_state'] = self.notebook_job_run_state
-        if self.notebook_name is not None: body['notebook_name'] = self.notebook_name
+        if self.collaborator_job_run_info:
+            body["collaborator_job_run_info"] = self.collaborator_job_run_info
+        if self.notebook_job_run_state:
+            body["notebook_job_run_state"] = self.notebook_job_run_state
+        if self.notebook_name is not None:
+            body["notebook_name"] = self.notebook_name
         if self.output_schema_expiration_time is not None:
-            body['output_schema_expiration_time'] = self.output_schema_expiration_time
-        if self.output_schema_name is not None: body['output_schema_name'] = self.output_schema_name
-        if self.run_duration is not None: body['run_duration'] = self.run_duration
-        if self.start_time is not None: body['start_time'] = self.start_time
+            body["output_schema_expiration_time"] = self.output_schema_expiration_time
+        if self.output_schema_name is not None:
+            body["output_schema_name"] = self.output_schema_name
+        if self.run_duration is not None:
+            body["run_duration"] = self.run_duration
+        if self.start_time is not None:
+            body["start_time"] = self.start_time
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CleanRoomNotebookTaskRun:
+    def from_dict(cls, d: Dict[str, Any]) -> CleanRoomNotebookTaskRun:
         """Deserializes the CleanRoomNotebookTaskRun from a dictionary."""
-        return cls(collaborator_job_run_info=_from_dict(d, 'collaborator_job_run_info',
-                                                        CollaboratorJobRunInfo),
-                   notebook_job_run_state=_from_dict(d, 'notebook_job_run_state', jobs.CleanRoomTaskRunState),
-                   notebook_name=d.get('notebook_name', None),
-                   output_schema_expiration_time=d.get('output_schema_expiration_time', None),
-                   output_schema_name=d.get('output_schema_name', None),
-                   run_duration=d.get('run_duration', None),
-                   start_time=d.get('start_time', None))
+        return cls(
+            collaborator_job_run_info=_from_dict(d, "collaborator_job_run_info", CollaboratorJobRunInfo),
+            notebook_job_run_state=_from_dict(d, "notebook_job_run_state", jobs.CleanRoomTaskRunState),
+            notebook_name=d.get("notebook_name", None),
+            output_schema_expiration_time=d.get("output_schema_expiration_time", None),
+            output_schema_name=d.get("output_schema_name", None),
+            run_duration=d.get("run_duration", None),
+            start_time=d.get("start_time", None),
+        )
 
 
 @dataclass
@@ -591,29 +677,35 @@ class CleanRoomOutputCatalog:
     def as_dict(self) -> dict:
         """Serializes the CleanRoomOutputCatalog into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.catalog_name is not None: body['catalog_name'] = self.catalog_name
-        if self.status is not None: body['status'] = self.status.value
+        if self.catalog_name is not None:
+            body["catalog_name"] = self.catalog_name
+        if self.status is not None:
+            body["status"] = self.status.value
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the CleanRoomOutputCatalog into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.catalog_name is not None: body['catalog_name'] = self.catalog_name
-        if self.status is not None: body['status'] = self.status
+        if self.catalog_name is not None:
+            body["catalog_name"] = self.catalog_name
+        if self.status is not None:
+            body["status"] = self.status
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CleanRoomOutputCatalog:
+    def from_dict(cls, d: Dict[str, Any]) -> CleanRoomOutputCatalog:
         """Deserializes the CleanRoomOutputCatalog from a dictionary."""
-        return cls(catalog_name=d.get('catalog_name', None),
-                   status=_enum(d, 'status', CleanRoomOutputCatalogOutputCatalogStatus))
+        return cls(
+            catalog_name=d.get("catalog_name", None),
+            status=_enum(d, "status", CleanRoomOutputCatalogOutputCatalogStatus),
+        )
 
 
 class CleanRoomOutputCatalogOutputCatalogStatus(Enum):
 
-    CREATED = 'CREATED'
-    NOT_CREATED = 'NOT_CREATED'
-    NOT_ELIGIBLE = 'NOT_ELIGIBLE'
+    CREATED = "CREATED"
+    NOT_CREATED = "NOT_CREATED"
+    NOT_ELIGIBLE = "NOT_ELIGIBLE"
 
 
 @dataclass
@@ -649,48 +741,61 @@ class CleanRoomRemoteDetail:
     def as_dict(self) -> dict:
         """Serializes the CleanRoomRemoteDetail into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.central_clean_room_id is not None: body['central_clean_room_id'] = self.central_clean_room_id
-        if self.cloud_vendor is not None: body['cloud_vendor'] = self.cloud_vendor
-        if self.collaborators: body['collaborators'] = [v.as_dict() for v in self.collaborators]
+        if self.central_clean_room_id is not None:
+            body["central_clean_room_id"] = self.central_clean_room_id
+        if self.cloud_vendor is not None:
+            body["cloud_vendor"] = self.cloud_vendor
+        if self.collaborators:
+            body["collaborators"] = [v.as_dict() for v in self.collaborators]
         if self.compliance_security_profile:
-            body['compliance_security_profile'] = self.compliance_security_profile.as_dict()
-        if self.creator: body['creator'] = self.creator.as_dict()
-        if self.egress_network_policy: body['egress_network_policy'] = self.egress_network_policy.as_dict()
-        if self.region is not None: body['region'] = self.region
+            body["compliance_security_profile"] = self.compliance_security_profile.as_dict()
+        if self.creator:
+            body["creator"] = self.creator.as_dict()
+        if self.egress_network_policy:
+            body["egress_network_policy"] = self.egress_network_policy.as_dict()
+        if self.region is not None:
+            body["region"] = self.region
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the CleanRoomRemoteDetail into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.central_clean_room_id is not None: body['central_clean_room_id'] = self.central_clean_room_id
-        if self.cloud_vendor is not None: body['cloud_vendor'] = self.cloud_vendor
-        if self.collaborators: body['collaborators'] = self.collaborators
+        if self.central_clean_room_id is not None:
+            body["central_clean_room_id"] = self.central_clean_room_id
+        if self.cloud_vendor is not None:
+            body["cloud_vendor"] = self.cloud_vendor
+        if self.collaborators:
+            body["collaborators"] = self.collaborators
         if self.compliance_security_profile:
-            body['compliance_security_profile'] = self.compliance_security_profile
-        if self.creator: body['creator'] = self.creator
-        if self.egress_network_policy: body['egress_network_policy'] = self.egress_network_policy
-        if self.region is not None: body['region'] = self.region
+            body["compliance_security_profile"] = self.compliance_security_profile
+        if self.creator:
+            body["creator"] = self.creator
+        if self.egress_network_policy:
+            body["egress_network_policy"] = self.egress_network_policy
+        if self.region is not None:
+            body["region"] = self.region
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CleanRoomRemoteDetail:
+    def from_dict(cls, d: Dict[str, Any]) -> CleanRoomRemoteDetail:
         """Deserializes the CleanRoomRemoteDetail from a dictionary."""
-        return cls(central_clean_room_id=d.get('central_clean_room_id', None),
-                   cloud_vendor=d.get('cloud_vendor', None),
-                   collaborators=_repeated_dict(d, 'collaborators', CleanRoomCollaborator),
-                   compliance_security_profile=_from_dict(d, 'compliance_security_profile',
-                                                          ComplianceSecurityProfile),
-                   creator=_from_dict(d, 'creator', CleanRoomCollaborator),
-                   egress_network_policy=_from_dict(d, 'egress_network_policy', settings.EgressNetworkPolicy),
-                   region=d.get('region', None))
+        return cls(
+            central_clean_room_id=d.get("central_clean_room_id", None),
+            cloud_vendor=d.get("cloud_vendor", None),
+            collaborators=_repeated_dict(d, "collaborators", CleanRoomCollaborator),
+            compliance_security_profile=_from_dict(d, "compliance_security_profile", ComplianceSecurityProfile),
+            creator=_from_dict(d, "creator", CleanRoomCollaborator),
+            egress_network_policy=_from_dict(d, "egress_network_policy", settings.EgressNetworkPolicy),
+            region=d.get("region", None),
+        )
 
 
 class CleanRoomStatusEnum(Enum):
 
-    ACTIVE = 'ACTIVE'
-    DELETED = 'DELETED'
-    FAILED = 'FAILED'
-    PROVISIONING = 'PROVISIONING'
+    ACTIVE = "ACTIVE"
+    DELETED = "DELETED"
+    FAILED = "FAILED"
+    PROVISIONING = "PROVISIONING"
 
 
 @dataclass
@@ -713,37 +818,43 @@ class CollaboratorJobRunInfo:
     def as_dict(self) -> dict:
         """Serializes the CollaboratorJobRunInfo into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.collaborator_alias is not None: body['collaborator_alias'] = self.collaborator_alias
-        if self.collaborator_job_id is not None: body['collaborator_job_id'] = self.collaborator_job_id
+        if self.collaborator_alias is not None:
+            body["collaborator_alias"] = self.collaborator_alias
+        if self.collaborator_job_id is not None:
+            body["collaborator_job_id"] = self.collaborator_job_id
         if self.collaborator_job_run_id is not None:
-            body['collaborator_job_run_id'] = self.collaborator_job_run_id
+            body["collaborator_job_run_id"] = self.collaborator_job_run_id
         if self.collaborator_task_run_id is not None:
-            body['collaborator_task_run_id'] = self.collaborator_task_run_id
+            body["collaborator_task_run_id"] = self.collaborator_task_run_id
         if self.collaborator_workspace_id is not None:
-            body['collaborator_workspace_id'] = self.collaborator_workspace_id
+            body["collaborator_workspace_id"] = self.collaborator_workspace_id
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the CollaboratorJobRunInfo into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.collaborator_alias is not None: body['collaborator_alias'] = self.collaborator_alias
-        if self.collaborator_job_id is not None: body['collaborator_job_id'] = self.collaborator_job_id
+        if self.collaborator_alias is not None:
+            body["collaborator_alias"] = self.collaborator_alias
+        if self.collaborator_job_id is not None:
+            body["collaborator_job_id"] = self.collaborator_job_id
         if self.collaborator_job_run_id is not None:
-            body['collaborator_job_run_id'] = self.collaborator_job_run_id
+            body["collaborator_job_run_id"] = self.collaborator_job_run_id
         if self.collaborator_task_run_id is not None:
-            body['collaborator_task_run_id'] = self.collaborator_task_run_id
+            body["collaborator_task_run_id"] = self.collaborator_task_run_id
         if self.collaborator_workspace_id is not None:
-            body['collaborator_workspace_id'] = self.collaborator_workspace_id
+            body["collaborator_workspace_id"] = self.collaborator_workspace_id
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CollaboratorJobRunInfo:
+    def from_dict(cls, d: Dict[str, Any]) -> CollaboratorJobRunInfo:
         """Deserializes the CollaboratorJobRunInfo from a dictionary."""
-        return cls(collaborator_alias=d.get('collaborator_alias', None),
-                   collaborator_job_id=d.get('collaborator_job_id', None),
-                   collaborator_job_run_id=d.get('collaborator_job_run_id', None),
-                   collaborator_task_run_id=d.get('collaborator_task_run_id', None),
-                   collaborator_workspace_id=d.get('collaborator_workspace_id', None))
+        return cls(
+            collaborator_alias=d.get("collaborator_alias", None),
+            collaborator_job_id=d.get("collaborator_job_id", None),
+            collaborator_job_run_id=d.get("collaborator_job_run_id", None),
+            collaborator_task_run_id=d.get("collaborator_task_run_id", None),
+            collaborator_workspace_id=d.get("collaborator_workspace_id", None),
+        )
 
 
 @dataclass
@@ -760,23 +871,27 @@ class ComplianceSecurityProfile:
         """Serializes the ComplianceSecurityProfile into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.compliance_standards:
-            body['compliance_standards'] = [v.as_dict() for v in self.compliance_standards]
-        if self.is_enabled is not None: body['is_enabled'] = self.is_enabled
+            body["compliance_standards"] = [v.as_dict() for v in self.compliance_standards]
+        if self.is_enabled is not None:
+            body["is_enabled"] = self.is_enabled
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the ComplianceSecurityProfile into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.compliance_standards: body['compliance_standards'] = self.compliance_standards
-        if self.is_enabled is not None: body['is_enabled'] = self.is_enabled
+        if self.compliance_standards:
+            body["compliance_standards"] = self.compliance_standards
+        if self.is_enabled is not None:
+            body["is_enabled"] = self.is_enabled
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> ComplianceSecurityProfile:
+    def from_dict(cls, d: Dict[str, Any]) -> ComplianceSecurityProfile:
         """Deserializes the ComplianceSecurityProfile from a dictionary."""
-        return cls(compliance_standards=_repeated_dict(d, 'compliance_standards',
-                                                       settings.ComplianceStandard),
-                   is_enabled=d.get('is_enabled', None))
+        return cls(
+            compliance_standards=_repeated_dict(d, "compliance_standards", settings.ComplianceStandard),
+            is_enabled=d.get("is_enabled", None),
+        )
 
 
 @dataclass
@@ -786,19 +901,21 @@ class CreateCleanRoomOutputCatalogResponse:
     def as_dict(self) -> dict:
         """Serializes the CreateCleanRoomOutputCatalogResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.output_catalog: body['output_catalog'] = self.output_catalog.as_dict()
+        if self.output_catalog:
+            body["output_catalog"] = self.output_catalog.as_dict()
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the CreateCleanRoomOutputCatalogResponse into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.output_catalog: body['output_catalog'] = self.output_catalog
+        if self.output_catalog:
+            body["output_catalog"] = self.output_catalog
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CreateCleanRoomOutputCatalogResponse:
+    def from_dict(cls, d: Dict[str, Any]) -> CreateCleanRoomOutputCatalogResponse:
         """Deserializes the CreateCleanRoomOutputCatalogResponse from a dictionary."""
-        return cls(output_catalog=_from_dict(d, 'output_catalog', CleanRoomOutputCatalog))
+        return cls(output_catalog=_from_dict(d, "output_catalog", CleanRoomOutputCatalog))
 
 
 @dataclass
@@ -817,14 +934,13 @@ class DeleteCleanRoomAssetResponse:
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> DeleteCleanRoomAssetResponse:
+    def from_dict(cls, d: Dict[str, Any]) -> DeleteCleanRoomAssetResponse:
         """Deserializes the DeleteCleanRoomAssetResponse from a dictionary."""
         return cls()
 
 
 @dataclass
 class DeleteResponse:
-
     def as_dict(self) -> dict:
         """Serializes the DeleteResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
@@ -836,7 +952,7 @@ class DeleteResponse:
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> DeleteResponse:
+    def from_dict(cls, d: Dict[str, Any]) -> DeleteResponse:
         """Deserializes the DeleteResponse from a dictionary."""
         return cls()
 
@@ -853,22 +969,25 @@ class ListCleanRoomAssetsResponse:
     def as_dict(self) -> dict:
         """Serializes the ListCleanRoomAssetsResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.assets: body['assets'] = [v.as_dict() for v in self.assets]
-        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        if self.assets:
+            body["assets"] = [v.as_dict() for v in self.assets]
+        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 ListCleanRoomAssetsResponse into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.assets: body['assets'] = self.assets
-        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        if self.assets:
+            body["assets"] = self.assets
+        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]) -> ListCleanRoomAssetsResponse:
+    def from_dict(cls, d: Dict[str, Any]) -> ListCleanRoomAssetsResponse:
         """Deserializes the ListCleanRoomAssetsResponse from a dictionary."""
-        return cls(assets=_repeated_dict(d, 'assets', CleanRoomAsset),
-                   next_page_token=d.get('next_page_token', None))
+        return cls(assets=_repeated_dict(d, "assets", CleanRoomAsset), next_page_token=d.get("next_page_token", None))
 
 
 @dataclass
@@ -883,22 +1002,27 @@ class ListCleanRoomNotebookTaskRunsResponse:
     def as_dict(self) -> dict:
         """Serializes the ListCleanRoomNotebookTaskRunsResponse 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.runs: body['runs'] = [v.as_dict() for v in self.runs]
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        if self.runs:
+            body["runs"] = [v.as_dict() for v in self.runs]
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the ListCleanRoomNotebookTaskRunsResponse 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.runs: body['runs'] = self.runs
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        if self.runs:
+            body["runs"] = self.runs
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> ListCleanRoomNotebookTaskRunsResponse:
+    def from_dict(cls, d: Dict[str, Any]) -> ListCleanRoomNotebookTaskRunsResponse:
         """Deserializes the ListCleanRoomNotebookTaskRunsResponse from a dictionary."""
-        return cls(next_page_token=d.get('next_page_token', None),
-                   runs=_repeated_dict(d, 'runs', CleanRoomNotebookTaskRun))
+        return cls(
+            next_page_token=d.get("next_page_token", None), runs=_repeated_dict(d, "runs", CleanRoomNotebookTaskRun)
+        )
 
 
 @dataclass
@@ -912,22 +1036,27 @@ class ListCleanRoomsResponse:
     def as_dict(self) -> dict:
         """Serializes the ListCleanRoomsResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.clean_rooms: body['clean_rooms'] = [v.as_dict() for v in self.clean_rooms]
-        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        if self.clean_rooms:
+            body["clean_rooms"] = [v.as_dict() for v in self.clean_rooms]
+        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 ListCleanRoomsResponse into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.clean_rooms: body['clean_rooms'] = self.clean_rooms
-        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        if self.clean_rooms:
+            body["clean_rooms"] = self.clean_rooms
+        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]) -> ListCleanRoomsResponse:
+    def from_dict(cls, d: Dict[str, Any]) -> ListCleanRoomsResponse:
         """Deserializes the ListCleanRoomsResponse from a dictionary."""
-        return cls(clean_rooms=_repeated_dict(d, 'clean_rooms', CleanRoom),
-                   next_page_token=d.get('next_page_token', None))
+        return cls(
+            clean_rooms=_repeated_dict(d, "clean_rooms", CleanRoom), next_page_token=d.get("next_page_token", None)
+        )
 
 
 @dataclass
@@ -940,21 +1069,25 @@ class UpdateCleanRoomRequest:
     def as_dict(self) -> dict:
         """Serializes the UpdateCleanRoomRequest into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.clean_room: body['clean_room'] = self.clean_room.as_dict()
-        if self.name is not None: body['name'] = self.name
+        if self.clean_room:
+            body["clean_room"] = self.clean_room.as_dict()
+        if self.name is not None:
+            body["name"] = self.name
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the UpdateCleanRoomRequest into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.clean_room: body['clean_room'] = self.clean_room
-        if self.name is not None: body['name'] = self.name
+        if self.clean_room:
+            body["clean_room"] = self.clean_room
+        if self.name is not None:
+            body["name"] = self.name
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> UpdateCleanRoomRequest:
+    def from_dict(cls, d: Dict[str, Any]) -> UpdateCleanRoomRequest:
         """Deserializes the UpdateCleanRoomRequest from a dictionary."""
-        return cls(clean_room=_from_dict(d, 'clean_room', CleanRoom), name=d.get('name', None))
+        return cls(clean_room=_from_dict(d, "clean_room", CleanRoom), name=d.get("name", None))
 
 
 class CleanRoomAssetsAPI:
@@ -966,111 +1099,119 @@ class CleanRoomAssetsAPI:
 
     def create(self, clean_room_name: str, *, asset: Optional[CleanRoomAsset] = None) -> CleanRoomAsset:
         """Create an asset.
-        
+
         Create a clean room asset —share an asset like a notebook or table into the clean room. For each UC
         asset that is added through this method, the clean room owner must also have enough privilege on the
         asset to consume it. The privilege must be maintained indefinitely for the clean room to be able to
         access the asset. Typically, you should use a group as the clean room owner.
-        
+
         :param clean_room_name: str
           Name of the clean room.
         :param asset: :class:`CleanRoomAsset` (optional)
           Metadata of the clean room asset
-        
+
         :returns: :class:`CleanRoomAsset`
         """
         body = asset.as_dict()
-        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
 
-        res = self._api.do('POST',
-                           f'/api/2.0/clean-rooms/{clean_room_name}/assets',
-                           body=body,
-                           headers=headers)
+        res = self._api.do("POST", f"/api/2.0/clean-rooms/{clean_room_name}/assets", body=body, headers=headers)
         return CleanRoomAsset.from_dict(res)
 
     def delete(self, clean_room_name: str, asset_type: CleanRoomAssetAssetType, asset_full_name: str):
         """Delete an asset.
-        
+
         Delete a clean room asset - unshare/remove the asset from the clean room
-        
+
         :param clean_room_name: str
           Name of the clean room.
         :param asset_type: :class:`CleanRoomAssetAssetType`
           The type of the asset.
         :param asset_full_name: str
           The fully qualified name of the asset, it is same as the name field in CleanRoomAsset.
-        
-        
+
+
         """
 
-        headers = {'Accept': 'application/json', }
+        headers = {
+            "Accept": "application/json",
+        }
 
-        self._api.do('DELETE',
-                     f'/api/2.0/clean-rooms/{clean_room_name}/assets/{asset_type.value}/{asset_full_name}',
-                     headers=headers)
+        self._api.do(
+            "DELETE",
+            f"/api/2.0/clean-rooms/{clean_room_name}/assets/{asset_type.value}/{asset_full_name}",
+            headers=headers,
+        )
 
-    def get(self, clean_room_name: str, asset_type: CleanRoomAssetAssetType,
-            asset_full_name: str) -> CleanRoomAsset:
+    def get(self, clean_room_name: str, asset_type: CleanRoomAssetAssetType, asset_full_name: str) -> CleanRoomAsset:
         """Get an asset.
-        
+
         Get the details of a clean room asset by its type and full name.
-        
+
         :param clean_room_name: str
           Name of the clean room.
         :param asset_type: :class:`CleanRoomAssetAssetType`
           The type of the asset.
         :param asset_full_name: str
           The fully qualified name of the asset, it is same as the name field in CleanRoomAsset.
-        
+
         :returns: :class:`CleanRoomAsset`
         """
 
-        headers = {'Accept': 'application/json', }
+        headers = {
+            "Accept": "application/json",
+        }
 
         res = self._api.do(
-            'GET',
-            f'/api/2.0/clean-rooms/{clean_room_name}/assets/{asset_type.value}/{asset_full_name}',
-            headers=headers)
+            "GET",
+            f"/api/2.0/clean-rooms/{clean_room_name}/assets/{asset_type.value}/{asset_full_name}",
+            headers=headers,
+        )
         return CleanRoomAsset.from_dict(res)
 
     def list(self, clean_room_name: str, *, page_token: Optional[str] = None) -> Iterator[CleanRoomAsset]:
         """List assets.
-        
+
         :param clean_room_name: str
           Name of the clean room.
         :param page_token: str (optional)
           Opaque pagination token to go to next page based on previous query.
-        
+
         :returns: Iterator over :class:`CleanRoomAsset`
         """
 
         query = {}
-        if page_token is not None: query['page_token'] = page_token
-        headers = {'Accept': 'application/json', }
+        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/clean-rooms/{clean_room_name}/assets',
-                                query=query,
-                                headers=headers)
-            if 'assets' in json:
-                for v in json['assets']:
+            json = self._api.do("GET", f"/api/2.0/clean-rooms/{clean_room_name}/assets", query=query, headers=headers)
+            if "assets" in json:
+                for v in json["assets"]:
                     yield CleanRoomAsset.from_dict(v)
-            if 'next_page_token' not in json or not json['next_page_token']:
+            if "next_page_token" not in json or not json["next_page_token"]:
                 return
-            query['page_token'] = json['next_page_token']
-
-    def update(self,
-               clean_room_name: str,
-               asset_type: CleanRoomAssetAssetType,
-               name: str,
-               *,
-               asset: Optional[CleanRoomAsset] = None) -> CleanRoomAsset:
+            query["page_token"] = json["next_page_token"]
+
+    def update(
+        self,
+        clean_room_name: str,
+        asset_type: CleanRoomAssetAssetType,
+        name: str,
+        *,
+        asset: Optional[CleanRoomAsset] = None,
+    ) -> CleanRoomAsset:
         """Update an asset.
-        
+
         Update a clean room asset. For example, updating the content of a notebook; changing the shared
         partitions of a table; etc.
-        
+
         :param clean_room_name: str
           Name of the clean room.
         :param asset_type: :class:`CleanRoomAssetAssetType`
@@ -1078,23 +1219,28 @@ class CleanRoomAssetsAPI:
         :param name: str
           A fully qualified name that uniquely identifies the asset within the clean room. This is also the
           name displayed in the clean room UI.
-          
+
           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.
         :param asset: :class:`CleanRoomAsset` (optional)
           Metadata of the clean room asset
-        
+
         :returns: :class:`CleanRoomAsset`
         """
         body = asset.as_dict()
-        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
 
-        res = self._api.do('PATCH',
-                           f'/api/2.0/clean-rooms/{clean_room_name}/assets/{asset_type.value}/{name}',
-                           body=body,
-                           headers=headers)
+        res = self._api.do(
+            "PATCH",
+            f"/api/2.0/clean-rooms/{clean_room_name}/assets/{asset_type.value}/{name}",
+            body=body,
+            headers=headers,
+        )
         return CleanRoomAsset.from_dict(res)
 
 
@@ -1104,45 +1250,49 @@ class CleanRoomTaskRunsAPI:
     def __init__(self, api_client):
         self._api = api_client
 
-    def list(self,
-             clean_room_name: str,
-             *,
-             notebook_name: Optional[str] = None,
-             page_size: Optional[int] = None,
-             page_token: Optional[str] = None) -> Iterator[CleanRoomNotebookTaskRun]:
+    def list(
+        self,
+        clean_room_name: str,
+        *,
+        notebook_name: Optional[str] = None,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None,
+    ) -> Iterator[CleanRoomNotebookTaskRun]:
         """List notebook task runs.
-        
+
         List all the historical notebook task runs in a clean room.
-        
+
         :param clean_room_name: str
           Name of the clean room.
         :param notebook_name: str (optional)
           Notebook name
         :param page_size: int (optional)
-          The maximum number of task runs to return
+          The maximum number of task runs to return. Currently ignored - all runs will be returned.
         :param page_token: str (optional)
           Opaque pagination token to go to next page based on previous query.
-        
+
         :returns: Iterator over :class:`CleanRoomNotebookTaskRun`
         """
 
         query = {}
-        if notebook_name is not None: query['notebook_name'] = notebook_name
-        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', }
+        if notebook_name is not None:
+            query["notebook_name"] = notebook_name
+        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/clean-rooms/{clean_room_name}/runs',
-                                query=query,
-                                headers=headers)
-            if 'runs' in json:
-                for v in json['runs']:
+            json = self._api.do("GET", f"/api/2.0/clean-rooms/{clean_room_name}/runs", query=query, headers=headers)
+            if "runs" in json:
+                for v in json["runs"]:
                     yield CleanRoomNotebookTaskRun.from_dict(v)
-            if 'next_page_token' not in json or not json['next_page_token']:
+            if "next_page_token" not in json or not json["next_page_token"]:
                 return
-            query['page_token'] = json['next_page_token']
+            query["page_token"] = json["next_page_token"]
 
 
 class CleanRoomsAPI:
@@ -1155,129 +1305,141 @@ class CleanRoomsAPI:
 
     def create(self, *, clean_room: Optional[CleanRoom] = None) -> CleanRoom:
         """Create a clean room.
-        
+
         Create a new clean room with the specified collaborators. This method is asynchronous; the returned
         name field inside the clean_room field can be used to poll the clean room status, using the
         :method:cleanrooms/get method. When this method returns, the clean room will be in a PROVISIONING
         state, with only name, owner, comment, created_at and status populated. The clean room will be usable
         once it enters an ACTIVE state.
-        
+
         The caller must be a metastore admin or have the **CREATE_CLEAN_ROOM** privilege on the metastore.
-        
+
         :param clean_room: :class:`CleanRoom` (optional)
-        
+
         :returns: :class:`CleanRoom`
         """
         body = clean_room.as_dict()
-        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
 
-        res = self._api.do('POST', '/api/2.0/clean-rooms', body=body, headers=headers)
+        res = self._api.do("POST", "/api/2.0/clean-rooms", body=body, headers=headers)
         return CleanRoom.from_dict(res)
 
     def create_output_catalog(
-            self,
-            clean_room_name: str,
-            *,
-            output_catalog: Optional[CleanRoomOutputCatalog] = None) -> CreateCleanRoomOutputCatalogResponse:
+        self, clean_room_name: str, *, output_catalog: Optional[CleanRoomOutputCatalog] = None
+    ) -> CreateCleanRoomOutputCatalogResponse:
         """Create an output catalog.
-        
+
         Create the output catalog of the clean room.
-        
+
         :param clean_room_name: str
           Name of the clean room.
         :param output_catalog: :class:`CleanRoomOutputCatalog` (optional)
-        
+
         :returns: :class:`CreateCleanRoomOutputCatalogResponse`
         """
         body = output_catalog.as_dict()
-        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
 
-        res = self._api.do('POST',
-                           f'/api/2.0/clean-rooms/{clean_room_name}/output-catalogs',
-                           body=body,
-                           headers=headers)
+        res = self._api.do(
+            "POST", f"/api/2.0/clean-rooms/{clean_room_name}/output-catalogs", body=body, headers=headers
+        )
         return CreateCleanRoomOutputCatalogResponse.from_dict(res)
 
     def delete(self, name: str):
         """Delete a clean room.
-        
+
         Delete a clean room. After deletion, the clean room will be removed from the metastore. If the other
         collaborators have not deleted the clean room, they will still have the clean room in their metastore,
         but it will be in a DELETED state and no operations other than deletion can be performed on it.
-        
+
         :param name: str
           Name of the clean room.
-        
-        
+
+
         """
 
-        headers = {'Accept': 'application/json', }
+        headers = {
+            "Accept": "application/json",
+        }
 
-        self._api.do('DELETE', f'/api/2.0/clean-rooms/{name}', headers=headers)
+        self._api.do("DELETE", f"/api/2.0/clean-rooms/{name}", headers=headers)
 
     def get(self, name: str) -> CleanRoom:
         """Get a clean room.
-        
+
         Get the details of a clean room given its name.
-        
+
         :param name: str
-        
+
         :returns: :class:`CleanRoom`
         """
 
-        headers = {'Accept': 'application/json', }
+        headers = {
+            "Accept": "application/json",
+        }
 
-        res = self._api.do('GET', f'/api/2.0/clean-rooms/{name}', headers=headers)
+        res = self._api.do("GET", f"/api/2.0/clean-rooms/{name}", headers=headers)
         return CleanRoom.from_dict(res)
 
-    def list(self,
-             *,
-             page_size: Optional[int] = None,
-             page_token: Optional[str] = None) -> Iterator[CleanRoom]:
+    def list(self, *, page_size: Optional[int] = None, page_token: Optional[str] = None) -> Iterator[CleanRoom]:
         """List clean rooms.
-        
+
         Get a list of all clean rooms of the metastore. Only clean rooms the caller has access to are
         returned.
-        
+
         :param page_size: int (optional)
           Maximum number of clean rooms to return (i.e., the page length). Defaults to 100.
         :param page_token: str (optional)
           Opaque pagination token to go to next page based on previous query.
-        
+
         :returns: Iterator over :class:`CleanRoom`
         """
 
         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', }
+        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.0/clean-rooms', query=query, headers=headers)
-            if 'clean_rooms' in json:
-                for v in json['clean_rooms']:
+            json = self._api.do("GET", "/api/2.0/clean-rooms", query=query, headers=headers)
+            if "clean_rooms" in json:
+                for v in json["clean_rooms"]:
                     yield CleanRoom.from_dict(v)
-            if 'next_page_token' not in json or not json['next_page_token']:
+            if "next_page_token" not in json or not json["next_page_token"]:
                 return
-            query['page_token'] = json['next_page_token']
+            query["page_token"] = json["next_page_token"]
 
     def update(self, name: str, *, clean_room: Optional[CleanRoom] = None) -> CleanRoom:
         """Update a clean room.
-        
+
         Update a clean room. The caller must be the owner of the clean room, have **MODIFY_CLEAN_ROOM**
         privilege, or be metastore admin.
-        
+
         When the caller is a metastore admin, only the __owner__ field can be updated.
-        
+
         :param name: str
           Name of the clean room.
         :param clean_room: :class:`CleanRoom` (optional)
-        
+
         :returns: :class:`CleanRoom`
         """
         body = {}
-        if clean_room is not None: body['clean_room'] = clean_room.as_dict()
-        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
-
-        res = self._api.do('PATCH', f'/api/2.0/clean-rooms/{name}', body=body, headers=headers)
+        if clean_room is not None:
+            body["clean_room"] = clean_room.as_dict()
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        res = self._api.do("PATCH", f"/api/2.0/clean-rooms/{name}", body=body, headers=headers)
         return CleanRoom.from_dict(res)