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

databricks/sdk/service/apps.py

@@ -8,12 +8,13 @@ import time
 from dataclasses import dataclass
 from datetime import timedelta
 from enum import Enum
-from typing import Callable, Dict, Iterator, List, Optional
+from typing import Any, Callable, Dict, Iterator, List, Optional
 
 from ..errors import OperationFailed
 from ._internal import Wait, _enum, _from_dict, _repeated_dict
 
-_LOG = logging.getLogger('databricks.sdk')
+_LOG = logging.getLogger("databricks.sdk")
+
 
 # all definitions in this file are in alphabetical order
 
@@ -30,6 +31,8 @@ class App:
 
     app_status: Optional[ApplicationStatus] = None
 
+    budget_policy_id: Optional[str] = None
+
     compute_status: Optional[ComputeStatus] = None
 
     create_time: Optional[str] = None
@@ -45,6 +48,8 @@ class App:
     description: Optional[str] = None
     """The description of the app."""
 
+    effective_budget_policy_id: Optional[str] = None
+
     id: Optional[str] = None
     """The unique identifier of the app."""
 
@@ -73,73 +78,113 @@ class App:
     def as_dict(self) -> dict:
         """Serializes the App into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.active_deployment: body['active_deployment'] = self.active_deployment.as_dict()
-        if self.app_status: body['app_status'] = self.app_status.as_dict()
-        if self.compute_status: body['compute_status'] = self.compute_status.as_dict()
-        if self.create_time is not None: body['create_time'] = self.create_time
-        if self.creator is not None: body['creator'] = self.creator
+        if self.active_deployment:
+            body["active_deployment"] = self.active_deployment.as_dict()
+        if self.app_status:
+            body["app_status"] = self.app_status.as_dict()
+        if self.budget_policy_id is not None:
+            body["budget_policy_id"] = self.budget_policy_id
+        if self.compute_status:
+            body["compute_status"] = self.compute_status.as_dict()
+        if self.create_time is not None:
+            body["create_time"] = self.create_time
+        if self.creator is not None:
+            body["creator"] = self.creator
         if self.default_source_code_path is not None:
-            body['default_source_code_path'] = self.default_source_code_path
-        if self.description is not None: body['description'] = self.description
-        if self.id is not None: body['id'] = self.id
-        if self.name is not None: body['name'] = self.name
-        if self.pending_deployment: body['pending_deployment'] = self.pending_deployment.as_dict()
-        if self.resources: body['resources'] = [v.as_dict() for v in self.resources]
+            body["default_source_code_path"] = self.default_source_code_path
+        if self.description is not None:
+            body["description"] = self.description
+        if self.effective_budget_policy_id is not None:
+            body["effective_budget_policy_id"] = self.effective_budget_policy_id
+        if self.id is not None:
+            body["id"] = self.id
+        if self.name is not None:
+            body["name"] = self.name
+        if self.pending_deployment:
+            body["pending_deployment"] = self.pending_deployment.as_dict()
+        if self.resources:
+            body["resources"] = [v.as_dict() for v in self.resources]
         if self.service_principal_client_id is not None:
-            body['service_principal_client_id'] = self.service_principal_client_id
-        if self.service_principal_id is not None: body['service_principal_id'] = self.service_principal_id
+            body["service_principal_client_id"] = self.service_principal_client_id
+        if self.service_principal_id is not None:
+            body["service_principal_id"] = self.service_principal_id
         if self.service_principal_name is not None:
-            body['service_principal_name'] = self.service_principal_name
-        if self.update_time is not None: body['update_time'] = self.update_time
-        if self.updater is not None: body['updater'] = self.updater
-        if self.url is not None: body['url'] = self.url
+            body["service_principal_name"] = self.service_principal_name
+        if self.update_time is not None:
+            body["update_time"] = self.update_time
+        if self.updater is not None:
+            body["updater"] = self.updater
+        if self.url is not None:
+            body["url"] = self.url
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the App into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.active_deployment: body['active_deployment'] = self.active_deployment
-        if self.app_status: body['app_status'] = self.app_status
-        if self.compute_status: body['compute_status'] = self.compute_status
-        if self.create_time is not None: body['create_time'] = self.create_time
-        if self.creator is not None: body['creator'] = self.creator
+        if self.active_deployment:
+            body["active_deployment"] = self.active_deployment
+        if self.app_status:
+            body["app_status"] = self.app_status
+        if self.budget_policy_id is not None:
+            body["budget_policy_id"] = self.budget_policy_id
+        if self.compute_status:
+            body["compute_status"] = self.compute_status
+        if self.create_time is not None:
+            body["create_time"] = self.create_time
+        if self.creator is not None:
+            body["creator"] = self.creator
         if self.default_source_code_path is not None:
-            body['default_source_code_path'] = self.default_source_code_path
-        if self.description is not None: body['description'] = self.description
-        if self.id is not None: body['id'] = self.id
-        if self.name is not None: body['name'] = self.name
-        if self.pending_deployment: body['pending_deployment'] = self.pending_deployment
-        if self.resources: body['resources'] = self.resources
+            body["default_source_code_path"] = self.default_source_code_path
+        if self.description is not None:
+            body["description"] = self.description
+        if self.effective_budget_policy_id is not None:
+            body["effective_budget_policy_id"] = self.effective_budget_policy_id
+        if self.id is not None:
+            body["id"] = self.id
+        if self.name is not None:
+            body["name"] = self.name
+        if self.pending_deployment:
+            body["pending_deployment"] = self.pending_deployment
+        if self.resources:
+            body["resources"] = self.resources
         if self.service_principal_client_id is not None:
-            body['service_principal_client_id'] = self.service_principal_client_id
-        if self.service_principal_id is not None: body['service_principal_id'] = self.service_principal_id
+            body["service_principal_client_id"] = self.service_principal_client_id
+        if self.service_principal_id is not None:
+            body["service_principal_id"] = self.service_principal_id
         if self.service_principal_name is not None:
-            body['service_principal_name'] = self.service_principal_name
-        if self.update_time is not None: body['update_time'] = self.update_time
-        if self.updater is not None: body['updater'] = self.updater
-        if self.url is not None: body['url'] = self.url
+            body["service_principal_name"] = self.service_principal_name
+        if self.update_time is not None:
+            body["update_time"] = self.update_time
+        if self.updater is not None:
+            body["updater"] = self.updater
+        if self.url is not None:
+            body["url"] = self.url
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> App:
+    def from_dict(cls, d: Dict[str, Any]) -> App:
         """Deserializes the App from a dictionary."""
-        return cls(active_deployment=_from_dict(d, 'active_deployment', AppDeployment),
-                   app_status=_from_dict(d, 'app_status', ApplicationStatus),
-                   compute_status=_from_dict(d, 'compute_status', ComputeStatus),
-                   create_time=d.get('create_time', None),
-                   creator=d.get('creator', None),
-                   default_source_code_path=d.get('default_source_code_path', None),
-                   description=d.get('description', None),
-                   id=d.get('id', None),
-                   name=d.get('name', None),
-                   pending_deployment=_from_dict(d, 'pending_deployment', AppDeployment),
-                   resources=_repeated_dict(d, 'resources', AppResource),
-                   service_principal_client_id=d.get('service_principal_client_id', None),
-                   service_principal_id=d.get('service_principal_id', None),
-                   service_principal_name=d.get('service_principal_name', None),
-                   update_time=d.get('update_time', None),
-                   updater=d.get('updater', None),
-                   url=d.get('url', None))
+        return cls(
+            active_deployment=_from_dict(d, "active_deployment", AppDeployment),
+            app_status=_from_dict(d, "app_status", ApplicationStatus),
+            budget_policy_id=d.get("budget_policy_id", None),
+            compute_status=_from_dict(d, "compute_status", ComputeStatus),
+            create_time=d.get("create_time", None),
+            creator=d.get("creator", None),
+            default_source_code_path=d.get("default_source_code_path", None),
+            description=d.get("description", None),
+            effective_budget_policy_id=d.get("effective_budget_policy_id", None),
+            id=d.get("id", None),
+            name=d.get("name", None),
+            pending_deployment=_from_dict(d, "pending_deployment", AppDeployment),
+            resources=_repeated_dict(d, "resources", AppResource),
+            service_principal_client_id=d.get("service_principal_client_id", None),
+            service_principal_id=d.get("service_principal_id", None),
+            service_principal_name=d.get("service_principal_name", None),
+            update_time=d.get("update_time", None),
+            updater=d.get("updater", None),
+            url=d.get("url", None),
+        )
 
 
 @dataclass
@@ -159,30 +204,38 @@ class AppAccessControlRequest:
     def as_dict(self) -> dict:
         """Serializes the AppAccessControlRequest into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.group_name is not None: body['group_name'] = self.group_name
-        if self.permission_level is not None: body['permission_level'] = self.permission_level.value
+        if self.group_name is not None:
+            body["group_name"] = self.group_name
+        if self.permission_level is not None:
+            body["permission_level"] = self.permission_level.value
         if self.service_principal_name is not None:
-            body['service_principal_name'] = self.service_principal_name
-        if self.user_name is not None: body['user_name'] = self.user_name
+            body["service_principal_name"] = self.service_principal_name
+        if self.user_name is not None:
+            body["user_name"] = self.user_name
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the AppAccessControlRequest into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.group_name is not None: body['group_name'] = self.group_name
-        if self.permission_level is not None: body['permission_level'] = self.permission_level
+        if self.group_name is not None:
+            body["group_name"] = self.group_name
+        if self.permission_level is not None:
+            body["permission_level"] = self.permission_level
         if self.service_principal_name is not None:
-            body['service_principal_name'] = self.service_principal_name
-        if self.user_name is not None: body['user_name'] = self.user_name
+            body["service_principal_name"] = self.service_principal_name
+        if self.user_name is not None:
+            body["user_name"] = self.user_name
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> AppAccessControlRequest:
+    def from_dict(cls, d: Dict[str, Any]) -> AppAccessControlRequest:
         """Deserializes the AppAccessControlRequest from a dictionary."""
-        return cls(group_name=d.get('group_name', None),
-                   permission_level=_enum(d, 'permission_level', AppPermissionLevel),
-                   service_principal_name=d.get('service_principal_name', None),
-                   user_name=d.get('user_name', None))
+        return cls(
+            group_name=d.get("group_name", None),
+            permission_level=_enum(d, "permission_level", AppPermissionLevel),
+            service_principal_name=d.get("service_principal_name", None),
+            user_name=d.get("user_name", None),
+        )
 
 
 @dataclass
@@ -205,33 +258,43 @@ class AppAccessControlResponse:
     def as_dict(self) -> dict:
         """Serializes the AppAccessControlResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.all_permissions: body['all_permissions'] = [v.as_dict() for v in self.all_permissions]
-        if self.display_name is not None: body['display_name'] = self.display_name
-        if self.group_name is not None: body['group_name'] = self.group_name
+        if self.all_permissions:
+            body["all_permissions"] = [v.as_dict() for v in self.all_permissions]
+        if self.display_name is not None:
+            body["display_name"] = self.display_name
+        if self.group_name is not None:
+            body["group_name"] = self.group_name
         if self.service_principal_name is not None:
-            body['service_principal_name'] = self.service_principal_name
-        if self.user_name is not None: body['user_name'] = self.user_name
+            body["service_principal_name"] = self.service_principal_name
+        if self.user_name is not None:
+            body["user_name"] = self.user_name
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the AppAccessControlResponse into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.all_permissions: body['all_permissions'] = self.all_permissions
-        if self.display_name is not None: body['display_name'] = self.display_name
-        if self.group_name is not None: body['group_name'] = self.group_name
+        if self.all_permissions:
+            body["all_permissions"] = self.all_permissions
+        if self.display_name is not None:
+            body["display_name"] = self.display_name
+        if self.group_name is not None:
+            body["group_name"] = self.group_name
         if self.service_principal_name is not None:
-            body['service_principal_name'] = self.service_principal_name
-        if self.user_name is not None: body['user_name'] = self.user_name
+            body["service_principal_name"] = self.service_principal_name
+        if self.user_name is not None:
+            body["user_name"] = self.user_name
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> AppAccessControlResponse:
+    def from_dict(cls, d: Dict[str, Any]) -> AppAccessControlResponse:
         """Deserializes the AppAccessControlResponse from a dictionary."""
-        return cls(all_permissions=_repeated_dict(d, 'all_permissions', AppPermission),
-                   display_name=d.get('display_name', None),
-                   group_name=d.get('group_name', None),
-                   service_principal_name=d.get('service_principal_name', None),
-                   user_name=d.get('user_name', None))
+        return cls(
+            all_permissions=_repeated_dict(d, "all_permissions", AppPermission),
+            display_name=d.get("display_name", None),
+            group_name=d.get("group_name", None),
+            service_principal_name=d.get("service_principal_name", None),
+            user_name=d.get("user_name", None),
+        )
 
 
 @dataclass
@@ -267,40 +330,58 @@ class AppDeployment:
     def as_dict(self) -> dict:
         """Serializes the AppDeployment into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.create_time is not None: body['create_time'] = self.create_time
-        if self.creator is not None: body['creator'] = self.creator
-        if self.deployment_artifacts: body['deployment_artifacts'] = self.deployment_artifacts.as_dict()
-        if self.deployment_id is not None: body['deployment_id'] = self.deployment_id
-        if self.mode is not None: body['mode'] = self.mode.value
-        if self.source_code_path is not None: body['source_code_path'] = self.source_code_path
-        if self.status: body['status'] = self.status.as_dict()
-        if self.update_time is not None: body['update_time'] = self.update_time
+        if self.create_time is not None:
+            body["create_time"] = self.create_time
+        if self.creator is not None:
+            body["creator"] = self.creator
+        if self.deployment_artifacts:
+            body["deployment_artifacts"] = self.deployment_artifacts.as_dict()
+        if self.deployment_id is not None:
+            body["deployment_id"] = self.deployment_id
+        if self.mode is not None:
+            body["mode"] = self.mode.value
+        if self.source_code_path is not None:
+            body["source_code_path"] = self.source_code_path
+        if self.status:
+            body["status"] = self.status.as_dict()
+        if self.update_time is not None:
+            body["update_time"] = self.update_time
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the AppDeployment into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.create_time is not None: body['create_time'] = self.create_time
-        if self.creator is not None: body['creator'] = self.creator
-        if self.deployment_artifacts: body['deployment_artifacts'] = self.deployment_artifacts
-        if self.deployment_id is not None: body['deployment_id'] = self.deployment_id
-        if self.mode is not None: body['mode'] = self.mode
-        if self.source_code_path is not None: body['source_code_path'] = self.source_code_path
-        if self.status: body['status'] = self.status
-        if self.update_time is not None: body['update_time'] = self.update_time
+        if self.create_time is not None:
+            body["create_time"] = self.create_time
+        if self.creator is not None:
+            body["creator"] = self.creator
+        if self.deployment_artifacts:
+            body["deployment_artifacts"] = self.deployment_artifacts
+        if self.deployment_id is not None:
+            body["deployment_id"] = self.deployment_id
+        if self.mode is not None:
+            body["mode"] = self.mode
+        if self.source_code_path is not None:
+            body["source_code_path"] = self.source_code_path
+        if self.status:
+            body["status"] = self.status
+        if self.update_time is not None:
+            body["update_time"] = self.update_time
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> AppDeployment:
+    def from_dict(cls, d: Dict[str, Any]) -> AppDeployment:
         """Deserializes the AppDeployment from a dictionary."""
-        return cls(create_time=d.get('create_time', None),
-                   creator=d.get('creator', None),
-                   deployment_artifacts=_from_dict(d, 'deployment_artifacts', AppDeploymentArtifacts),
-                   deployment_id=d.get('deployment_id', None),
-                   mode=_enum(d, 'mode', AppDeploymentMode),
-                   source_code_path=d.get('source_code_path', None),
-                   status=_from_dict(d, 'status', AppDeploymentStatus),
-                   update_time=d.get('update_time', None))
+        return cls(
+            create_time=d.get("create_time", None),
+            creator=d.get("creator", None),
+            deployment_artifacts=_from_dict(d, "deployment_artifacts", AppDeploymentArtifacts),
+            deployment_id=d.get("deployment_id", None),
+            mode=_enum(d, "mode", AppDeploymentMode),
+            source_code_path=d.get("source_code_path", None),
+            status=_from_dict(d, "status", AppDeploymentStatus),
+            update_time=d.get("update_time", None),
+        )
 
 
 @dataclass
@@ -311,33 +392,35 @@ class AppDeploymentArtifacts:
     def as_dict(self) -> dict:
         """Serializes the AppDeploymentArtifacts into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.source_code_path is not None: body['source_code_path'] = self.source_code_path
+        if self.source_code_path is not None:
+            body["source_code_path"] = self.source_code_path
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the AppDeploymentArtifacts into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.source_code_path is not None: body['source_code_path'] = self.source_code_path
+        if self.source_code_path is not None:
+            body["source_code_path"] = self.source_code_path
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> AppDeploymentArtifacts:
+    def from_dict(cls, d: Dict[str, Any]) -> AppDeploymentArtifacts:
         """Deserializes the AppDeploymentArtifacts from a dictionary."""
-        return cls(source_code_path=d.get('source_code_path', None))
+        return cls(source_code_path=d.get("source_code_path", None))
 
 
 class AppDeploymentMode(Enum):
 
-    AUTO_SYNC = 'AUTO_SYNC'
-    SNAPSHOT = 'SNAPSHOT'
+    AUTO_SYNC = "AUTO_SYNC"
+    SNAPSHOT = "SNAPSHOT"
 
 
 class AppDeploymentState(Enum):
 
-    CANCELLED = 'CANCELLED'
-    FAILED = 'FAILED'
-    IN_PROGRESS = 'IN_PROGRESS'
-    SUCCEEDED = 'SUCCEEDED'
+    CANCELLED = "CANCELLED"
+    FAILED = "FAILED"
+    IN_PROGRESS = "IN_PROGRESS"
+    SUCCEEDED = "SUCCEEDED"
 
 
 @dataclass
@@ -351,21 +434,25 @@ class AppDeploymentStatus:
     def as_dict(self) -> dict:
         """Serializes the AppDeploymentStatus into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.message is not None: body['message'] = self.message
-        if self.state is not None: body['state'] = self.state.value
+        if self.message is not None:
+            body["message"] = self.message
+        if self.state is not None:
+            body["state"] = self.state.value
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the AppDeploymentStatus into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.message is not None: body['message'] = self.message
-        if self.state is not None: body['state'] = self.state
+        if self.message is not None:
+            body["message"] = self.message
+        if self.state is not None:
+            body["state"] = self.state
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> AppDeploymentStatus:
+    def from_dict(cls, d: Dict[str, Any]) -> AppDeploymentStatus:
         """Deserializes the AppDeploymentStatus from a dictionary."""
-        return cls(message=d.get('message', None), state=_enum(d, 'state', AppDeploymentState))
+        return cls(message=d.get("message", None), state=_enum(d, "state", AppDeploymentState))
 
 
 @dataclass
@@ -380,32 +467,40 @@ class AppPermission:
     def as_dict(self) -> dict:
         """Serializes the AppPermission into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.inherited is not None: body['inherited'] = self.inherited
-        if self.inherited_from_object: body['inherited_from_object'] = [v for v in self.inherited_from_object]
-        if self.permission_level is not None: body['permission_level'] = self.permission_level.value
+        if self.inherited is not None:
+            body["inherited"] = self.inherited
+        if self.inherited_from_object:
+            body["inherited_from_object"] = [v for v in self.inherited_from_object]
+        if self.permission_level is not None:
+            body["permission_level"] = self.permission_level.value
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the AppPermission into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.inherited is not None: body['inherited'] = self.inherited
-        if self.inherited_from_object: body['inherited_from_object'] = self.inherited_from_object
-        if self.permission_level is not None: body['permission_level'] = self.permission_level
+        if self.inherited is not None:
+            body["inherited"] = self.inherited
+        if self.inherited_from_object:
+            body["inherited_from_object"] = self.inherited_from_object
+        if self.permission_level is not None:
+            body["permission_level"] = self.permission_level
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> AppPermission:
+    def from_dict(cls, d: Dict[str, Any]) -> AppPermission:
         """Deserializes the AppPermission from a dictionary."""
-        return cls(inherited=d.get('inherited', None),
-                   inherited_from_object=d.get('inherited_from_object', None),
-                   permission_level=_enum(d, 'permission_level', AppPermissionLevel))
+        return cls(
+            inherited=d.get("inherited", None),
+            inherited_from_object=d.get("inherited_from_object", None),
+            permission_level=_enum(d, "permission_level", AppPermissionLevel),
+        )
 
 
 class AppPermissionLevel(Enum):
     """Permission level"""
 
-    CAN_MANAGE = 'CAN_MANAGE'
-    CAN_USE = 'CAN_USE'
+    CAN_MANAGE = "CAN_MANAGE"
+    CAN_USE = "CAN_USE"
 
 
 @dataclass
@@ -420,25 +515,32 @@ class AppPermissions:
         """Serializes the AppPermissions into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.access_control_list:
-            body['access_control_list'] = [v.as_dict() for v in self.access_control_list]
-        if self.object_id is not None: body['object_id'] = self.object_id
-        if self.object_type is not None: body['object_type'] = self.object_type
+            body["access_control_list"] = [v.as_dict() for v in self.access_control_list]
+        if self.object_id is not None:
+            body["object_id"] = self.object_id
+        if self.object_type is not None:
+            body["object_type"] = self.object_type
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the AppPermissions into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.access_control_list: body['access_control_list'] = self.access_control_list
-        if self.object_id is not None: body['object_id'] = self.object_id
-        if self.object_type is not None: body['object_type'] = self.object_type
+        if self.access_control_list:
+            body["access_control_list"] = self.access_control_list
+        if self.object_id is not None:
+            body["object_id"] = self.object_id
+        if self.object_type is not None:
+            body["object_type"] = self.object_type
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> AppPermissions:
+    def from_dict(cls, d: Dict[str, Any]) -> AppPermissions:
         """Deserializes the AppPermissions from a dictionary."""
-        return cls(access_control_list=_repeated_dict(d, 'access_control_list', AppAccessControlResponse),
-                   object_id=d.get('object_id', None),
-                   object_type=d.get('object_type', None))
+        return cls(
+            access_control_list=_repeated_dict(d, "access_control_list", AppAccessControlResponse),
+            object_id=d.get("object_id", None),
+            object_type=d.get("object_type", None),
+        )
 
 
 @dataclass
@@ -451,22 +553,27 @@ class AppPermissionsDescription:
     def as_dict(self) -> dict:
         """Serializes the AppPermissionsDescription into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.description is not None: body['description'] = self.description
-        if self.permission_level is not None: body['permission_level'] = self.permission_level.value
+        if self.description is not None:
+            body["description"] = self.description
+        if self.permission_level is not None:
+            body["permission_level"] = self.permission_level.value
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the AppPermissionsDescription into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.description is not None: body['description'] = self.description
-        if self.permission_level is not None: body['permission_level'] = self.permission_level
+        if self.description is not None:
+            body["description"] = self.description
+        if self.permission_level is not None:
+            body["permission_level"] = self.permission_level
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> AppPermissionsDescription:
+    def from_dict(cls, d: Dict[str, Any]) -> AppPermissionsDescription:
         """Deserializes the AppPermissionsDescription from a dictionary."""
-        return cls(description=d.get('description', None),
-                   permission_level=_enum(d, 'permission_level', AppPermissionLevel))
+        return cls(
+            description=d.get("description", None), permission_level=_enum(d, "permission_level", AppPermissionLevel)
+        )
 
 
 @dataclass
@@ -480,22 +587,27 @@ class AppPermissionsRequest:
         """Serializes the AppPermissionsRequest into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.access_control_list:
-            body['access_control_list'] = [v.as_dict() for v in self.access_control_list]
-        if self.app_name is not None: body['app_name'] = self.app_name
+            body["access_control_list"] = [v.as_dict() for v in self.access_control_list]
+        if self.app_name is not None:
+            body["app_name"] = self.app_name
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the AppPermissionsRequest into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.access_control_list: body['access_control_list'] = self.access_control_list
-        if self.app_name is not None: body['app_name'] = self.app_name
+        if self.access_control_list:
+            body["access_control_list"] = self.access_control_list
+        if self.app_name is not None:
+            body["app_name"] = self.app_name
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> AppPermissionsRequest:
+    def from_dict(cls, d: Dict[str, Any]) -> AppPermissionsRequest:
         """Deserializes the AppPermissionsRequest from a dictionary."""
-        return cls(access_control_list=_repeated_dict(d, 'access_control_list', AppAccessControlRequest),
-                   app_name=d.get('app_name', None))
+        return cls(
+            access_control_list=_repeated_dict(d, "access_control_list", AppAccessControlRequest),
+            app_name=d.get("app_name", None),
+        )
 
 
 @dataclass
@@ -517,34 +629,48 @@ class AppResource:
     def as_dict(self) -> dict:
         """Serializes the AppResource into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.description is not None: body['description'] = self.description
-        if self.job: body['job'] = self.job.as_dict()
-        if self.name is not None: body['name'] = self.name
-        if self.secret: body['secret'] = self.secret.as_dict()
-        if self.serving_endpoint: body['serving_endpoint'] = self.serving_endpoint.as_dict()
-        if self.sql_warehouse: body['sql_warehouse'] = self.sql_warehouse.as_dict()
+        if self.description is not None:
+            body["description"] = self.description
+        if self.job:
+            body["job"] = self.job.as_dict()
+        if self.name is not None:
+            body["name"] = self.name
+        if self.secret:
+            body["secret"] = self.secret.as_dict()
+        if self.serving_endpoint:
+            body["serving_endpoint"] = self.serving_endpoint.as_dict()
+        if self.sql_warehouse:
+            body["sql_warehouse"] = self.sql_warehouse.as_dict()
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the AppResource into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.description is not None: body['description'] = self.description
-        if self.job: body['job'] = self.job
-        if self.name is not None: body['name'] = self.name
-        if self.secret: body['secret'] = self.secret
-        if self.serving_endpoint: body['serving_endpoint'] = self.serving_endpoint
-        if self.sql_warehouse: body['sql_warehouse'] = self.sql_warehouse
+        if self.description is not None:
+            body["description"] = self.description
+        if self.job:
+            body["job"] = self.job
+        if self.name is not None:
+            body["name"] = self.name
+        if self.secret:
+            body["secret"] = self.secret
+        if self.serving_endpoint:
+            body["serving_endpoint"] = self.serving_endpoint
+        if self.sql_warehouse:
+            body["sql_warehouse"] = self.sql_warehouse
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> AppResource:
+    def from_dict(cls, d: Dict[str, Any]) -> AppResource:
         """Deserializes the AppResource from a dictionary."""
-        return cls(description=d.get('description', None),
-                   job=_from_dict(d, 'job', AppResourceJob),
-                   name=d.get('name', None),
-                   secret=_from_dict(d, 'secret', AppResourceSecret),
-                   serving_endpoint=_from_dict(d, 'serving_endpoint', AppResourceServingEndpoint),
-                   sql_warehouse=_from_dict(d, 'sql_warehouse', AppResourceSqlWarehouse))
+        return cls(
+            description=d.get("description", None),
+            job=_from_dict(d, "job", AppResourceJob),
+            name=d.get("name", None),
+            secret=_from_dict(d, "secret", AppResourceSecret),
+            serving_endpoint=_from_dict(d, "serving_endpoint", AppResourceServingEndpoint),
+            sql_warehouse=_from_dict(d, "sql_warehouse", AppResourceSqlWarehouse),
+        )
 
 
 @dataclass
@@ -559,29 +685,33 @@ class AppResourceJob:
     def as_dict(self) -> dict:
         """Serializes the AppResourceJob into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.id is not None: body['id'] = self.id
-        if self.permission is not None: body['permission'] = self.permission.value
+        if self.id is not None:
+            body["id"] = self.id
+        if self.permission is not None:
+            body["permission"] = self.permission.value
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the AppResourceJob into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.id is not None: body['id'] = self.id
-        if self.permission is not None: body['permission'] = self.permission
+        if self.id is not None:
+            body["id"] = self.id
+        if self.permission is not None:
+            body["permission"] = self.permission
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> AppResourceJob:
+    def from_dict(cls, d: Dict[str, Any]) -> AppResourceJob:
         """Deserializes the AppResourceJob from a dictionary."""
-        return cls(id=d.get('id', None), permission=_enum(d, 'permission', AppResourceJobJobPermission))
+        return cls(id=d.get("id", None), permission=_enum(d, "permission", AppResourceJobJobPermission))
 
 
 class AppResourceJobJobPermission(Enum):
 
-    CAN_MANAGE = 'CAN_MANAGE'
-    CAN_MANAGE_RUN = 'CAN_MANAGE_RUN'
-    CAN_VIEW = 'CAN_VIEW'
-    IS_OWNER = 'IS_OWNER'
+    CAN_MANAGE = "CAN_MANAGE"
+    CAN_MANAGE_RUN = "CAN_MANAGE_RUN"
+    CAN_VIEW = "CAN_VIEW"
+    IS_OWNER = "IS_OWNER"
 
 
 @dataclass
@@ -599,33 +729,41 @@ class AppResourceSecret:
     def as_dict(self) -> dict:
         """Serializes the AppResourceSecret into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.key is not None: body['key'] = self.key
-        if self.permission is not None: body['permission'] = self.permission.value
-        if self.scope is not None: body['scope'] = self.scope
+        if self.key is not None:
+            body["key"] = self.key
+        if self.permission is not None:
+            body["permission"] = self.permission.value
+        if self.scope is not None:
+            body["scope"] = self.scope
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the AppResourceSecret into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.key is not None: body['key'] = self.key
-        if self.permission is not None: body['permission'] = self.permission
-        if self.scope is not None: body['scope'] = self.scope
+        if self.key is not None:
+            body["key"] = self.key
+        if self.permission is not None:
+            body["permission"] = self.permission
+        if self.scope is not None:
+            body["scope"] = self.scope
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> AppResourceSecret:
+    def from_dict(cls, d: Dict[str, Any]) -> AppResourceSecret:
         """Deserializes the AppResourceSecret from a dictionary."""
-        return cls(key=d.get('key', None),
-                   permission=_enum(d, 'permission', AppResourceSecretSecretPermission),
-                   scope=d.get('scope', None))
+        return cls(
+            key=d.get("key", None),
+            permission=_enum(d, "permission", AppResourceSecretSecretPermission),
+            scope=d.get("scope", None),
+        )
 
 
 class AppResourceSecretSecretPermission(Enum):
     """Permission to grant on the secret scope. Supported permissions are: "READ", "WRITE", "MANAGE"."""
 
-    MANAGE = 'MANAGE'
-    READ = 'READ'
-    WRITE = 'WRITE'
+    MANAGE = "MANAGE"
+    READ = "READ"
+    WRITE = "WRITE"
 
 
 @dataclass
@@ -640,29 +778,35 @@ class AppResourceServingEndpoint:
     def as_dict(self) -> dict:
         """Serializes the AppResourceServingEndpoint into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.name is not None: body['name'] = self.name
-        if self.permission is not None: body['permission'] = self.permission.value
+        if self.name is not None:
+            body["name"] = self.name
+        if self.permission is not None:
+            body["permission"] = self.permission.value
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the AppResourceServingEndpoint into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.name is not None: body['name'] = self.name
-        if self.permission is not None: body['permission'] = self.permission
+        if self.name is not None:
+            body["name"] = self.name
+        if self.permission is not None:
+            body["permission"] = self.permission
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> AppResourceServingEndpoint:
+    def from_dict(cls, d: Dict[str, Any]) -> AppResourceServingEndpoint:
         """Deserializes the AppResourceServingEndpoint from a dictionary."""
-        return cls(name=d.get('name', None),
-                   permission=_enum(d, 'permission', AppResourceServingEndpointServingEndpointPermission))
+        return cls(
+            name=d.get("name", None),
+            permission=_enum(d, "permission", AppResourceServingEndpointServingEndpointPermission),
+        )
 
 
 class AppResourceServingEndpointServingEndpointPermission(Enum):
 
-    CAN_MANAGE = 'CAN_MANAGE'
-    CAN_QUERY = 'CAN_QUERY'
-    CAN_VIEW = 'CAN_VIEW'
+    CAN_MANAGE = "CAN_MANAGE"
+    CAN_QUERY = "CAN_QUERY"
+    CAN_VIEW = "CAN_VIEW"
 
 
 @dataclass
@@ -677,37 +821,42 @@ class AppResourceSqlWarehouse:
     def as_dict(self) -> dict:
         """Serializes the AppResourceSqlWarehouse into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.id is not None: body['id'] = self.id
-        if self.permission is not None: body['permission'] = self.permission.value
+        if self.id is not None:
+            body["id"] = self.id
+        if self.permission is not None:
+            body["permission"] = self.permission.value
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the AppResourceSqlWarehouse into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.id is not None: body['id'] = self.id
-        if self.permission is not None: body['permission'] = self.permission
+        if self.id is not None:
+            body["id"] = self.id
+        if self.permission is not None:
+            body["permission"] = self.permission
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> AppResourceSqlWarehouse:
+    def from_dict(cls, d: Dict[str, Any]) -> AppResourceSqlWarehouse:
         """Deserializes the AppResourceSqlWarehouse from a dictionary."""
-        return cls(id=d.get('id', None),
-                   permission=_enum(d, 'permission', AppResourceSqlWarehouseSqlWarehousePermission))
+        return cls(
+            id=d.get("id", None), permission=_enum(d, "permission", AppResourceSqlWarehouseSqlWarehousePermission)
+        )
 
 
 class AppResourceSqlWarehouseSqlWarehousePermission(Enum):
 
-    CAN_MANAGE = 'CAN_MANAGE'
-    CAN_USE = 'CAN_USE'
-    IS_OWNER = 'IS_OWNER'
+    CAN_MANAGE = "CAN_MANAGE"
+    CAN_USE = "CAN_USE"
+    IS_OWNER = "IS_OWNER"
 
 
 class ApplicationState(Enum):
 
-    CRASHED = 'CRASHED'
-    DEPLOYING = 'DEPLOYING'
-    RUNNING = 'RUNNING'
-    UNAVAILABLE = 'UNAVAILABLE'
+    CRASHED = "CRASHED"
+    DEPLOYING = "DEPLOYING"
+    RUNNING = "RUNNING"
+    UNAVAILABLE = "UNAVAILABLE"
 
 
 @dataclass
@@ -721,32 +870,36 @@ class ApplicationStatus:
     def as_dict(self) -> dict:
         """Serializes the ApplicationStatus into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.message is not None: body['message'] = self.message
-        if self.state is not None: body['state'] = self.state.value
+        if self.message is not None:
+            body["message"] = self.message
+        if self.state is not None:
+            body["state"] = self.state.value
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the ApplicationStatus into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.message is not None: body['message'] = self.message
-        if self.state is not None: body['state'] = self.state
+        if self.message is not None:
+            body["message"] = self.message
+        if self.state is not None:
+            body["state"] = self.state
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> ApplicationStatus:
+    def from_dict(cls, d: Dict[str, Any]) -> ApplicationStatus:
         """Deserializes the ApplicationStatus from a dictionary."""
-        return cls(message=d.get('message', None), state=_enum(d, 'state', ApplicationState))
+        return cls(message=d.get("message", None), state=_enum(d, "state", ApplicationState))
 
 
 class ComputeState(Enum):
 
-    ACTIVE = 'ACTIVE'
-    DELETING = 'DELETING'
-    ERROR = 'ERROR'
-    STARTING = 'STARTING'
-    STOPPED = 'STOPPED'
-    STOPPING = 'STOPPING'
-    UPDATING = 'UPDATING'
+    ACTIVE = "ACTIVE"
+    DELETING = "DELETING"
+    ERROR = "ERROR"
+    STARTING = "STARTING"
+    STOPPED = "STOPPED"
+    STOPPING = "STOPPING"
+    UPDATING = "UPDATING"
 
 
 @dataclass
@@ -760,21 +913,25 @@ class ComputeStatus:
     def as_dict(self) -> dict:
         """Serializes the ComputeStatus into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.message is not None: body['message'] = self.message
-        if self.state is not None: body['state'] = self.state.value
+        if self.message is not None:
+            body["message"] = self.message
+        if self.state is not None:
+            body["state"] = self.state.value
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the ComputeStatus into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.message is not None: body['message'] = self.message
-        if self.state is not None: body['state'] = self.state
+        if self.message is not None:
+            body["message"] = self.message
+        if self.state is not None:
+            body["state"] = self.state
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> ComputeStatus:
+    def from_dict(cls, d: Dict[str, Any]) -> ComputeStatus:
         """Deserializes the ComputeStatus from a dictionary."""
-        return cls(message=d.get('message', None), state=_enum(d, 'state', ComputeState))
+        return cls(message=d.get("message", None), state=_enum(d, "state", ComputeState))
 
 
 @dataclass
@@ -785,19 +942,21 @@ class GetAppPermissionLevelsResponse:
     def as_dict(self) -> dict:
         """Serializes the GetAppPermissionLevelsResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.permission_levels: body['permission_levels'] = [v.as_dict() for v in self.permission_levels]
+        if self.permission_levels:
+            body["permission_levels"] = [v.as_dict() for v in self.permission_levels]
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the GetAppPermissionLevelsResponse into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.permission_levels: body['permission_levels'] = self.permission_levels
+        if self.permission_levels:
+            body["permission_levels"] = self.permission_levels
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> GetAppPermissionLevelsResponse:
+    def from_dict(cls, d: Dict[str, Any]) -> GetAppPermissionLevelsResponse:
         """Deserializes the GetAppPermissionLevelsResponse from a dictionary."""
-        return cls(permission_levels=_repeated_dict(d, 'permission_levels', AppPermissionsDescription))
+        return cls(permission_levels=_repeated_dict(d, "permission_levels", AppPermissionsDescription))
 
 
 @dataclass
@@ -811,22 +970,28 @@ class ListAppDeploymentsResponse:
     def as_dict(self) -> dict:
         """Serializes the ListAppDeploymentsResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.app_deployments: body['app_deployments'] = [v.as_dict() for v in self.app_deployments]
-        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        if self.app_deployments:
+            body["app_deployments"] = [v.as_dict() for v in self.app_deployments]
+        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 ListAppDeploymentsResponse into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.app_deployments: body['app_deployments'] = self.app_deployments
-        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        if self.app_deployments:
+            body["app_deployments"] = self.app_deployments
+        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]) -> ListAppDeploymentsResponse:
+    def from_dict(cls, d: Dict[str, Any]) -> ListAppDeploymentsResponse:
         """Deserializes the ListAppDeploymentsResponse from a dictionary."""
-        return cls(app_deployments=_repeated_dict(d, 'app_deployments', AppDeployment),
-                   next_page_token=d.get('next_page_token', None))
+        return cls(
+            app_deployments=_repeated_dict(d, "app_deployments", AppDeployment),
+            next_page_token=d.get("next_page_token", None),
+        )
 
 
 @dataclass
@@ -839,21 +1004,25 @@ class ListAppsResponse:
     def as_dict(self) -> dict:
         """Serializes the ListAppsResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.apps: body['apps'] = [v.as_dict() for v in self.apps]
-        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        if self.apps:
+            body["apps"] = [v.as_dict() for v in self.apps]
+        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 ListAppsResponse into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.apps: body['apps'] = self.apps
-        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        if self.apps:
+            body["apps"] = self.apps
+        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]) -> ListAppsResponse:
+    def from_dict(cls, d: Dict[str, Any]) -> ListAppsResponse:
         """Deserializes the ListAppsResponse from a dictionary."""
-        return cls(apps=_repeated_dict(d, 'apps', App), next_page_token=d.get('next_page_token', None))
+        return cls(apps=_repeated_dict(d, "apps", App), next_page_token=d.get("next_page_token", None))
 
 
 @dataclass
@@ -875,19 +1044,21 @@ class AppsAPI:
     def __init__(self, api_client):
         self._api = api_client
 
-    def wait_get_app_active(self,
-                            name: str,
-                            timeout=timedelta(minutes=20),
-                            callback: Optional[Callable[[App], None]] = None) -> App:
+    def wait_get_app_active(
+        self, name: str, timeout=timedelta(minutes=20), callback: Optional[Callable[[App], None]] = None
+    ) -> App:
         deadline = time.time() + timeout.total_seconds()
-        target_states = (ComputeState.ACTIVE, )
-        failure_states = (ComputeState.ERROR, ComputeState.STOPPED, )
-        status_message = 'polling...'
+        target_states = (ComputeState.ACTIVE,)
+        failure_states = (
+            ComputeState.ERROR,
+            ComputeState.STOPPED,
+        )
+        status_message = "polling..."
         attempt = 1
         while time.time() < deadline:
             poll = self.get(name=name)
             status = poll.compute_status.state
-            status_message = f'current status: {status}'
+            status_message = f"current status: {status}"
             if poll.compute_status:
                 status_message = poll.compute_status.message
             if status in target_states:
@@ -895,33 +1066,34 @@ class AppsAPI:
             if callback:
                 callback(poll)
             if status in failure_states:
-                msg = f'failed to reach ACTIVE, got {status}: {status_message}'
+                msg = f"failed to reach ACTIVE, got {status}: {status_message}"
                 raise OperationFailed(msg)
             prefix = f"name={name}"
             sleep = attempt
             if sleep > 10:
                 # sleep 10s max per attempt
                 sleep = 10
-            _LOG.debug(f'{prefix}: ({status}) {status_message} (sleeping ~{sleep}s)')
+            _LOG.debug(f"{prefix}: ({status}) {status_message} (sleeping ~{sleep}s)")
             time.sleep(sleep + random.random())
             attempt += 1
-        raise TimeoutError(f'timed out after {timeout}: {status_message}')
+        raise TimeoutError(f"timed out after {timeout}: {status_message}")
 
     def wait_get_deployment_app_succeeded(
-            self,
-            app_name: str,
-            deployment_id: str,
-            timeout=timedelta(minutes=20),
-            callback: Optional[Callable[[AppDeployment], None]] = None) -> AppDeployment:
+        self,
+        app_name: str,
+        deployment_id: str,
+        timeout=timedelta(minutes=20),
+        callback: Optional[Callable[[AppDeployment], None]] = None,
+    ) -> AppDeployment:
         deadline = time.time() + timeout.total_seconds()
-        target_states = (AppDeploymentState.SUCCEEDED, )
-        failure_states = (AppDeploymentState.FAILED, )
-        status_message = 'polling...'
+        target_states = (AppDeploymentState.SUCCEEDED,)
+        failure_states = (AppDeploymentState.FAILED,)
+        status_message = "polling..."
         attempt = 1
         while time.time() < deadline:
             poll = self.get_deployment(app_name=app_name, deployment_id=deployment_id)
             status = poll.status.state
-            status_message = f'current status: {status}'
+            status_message = f"current status: {status}"
             if poll.status:
                 status_message = poll.status.message
             if status in target_states:
@@ -929,31 +1101,30 @@ class AppsAPI:
             if callback:
                 callback(poll)
             if status in failure_states:
-                msg = f'failed to reach SUCCEEDED, got {status}: {status_message}'
+                msg = f"failed to reach SUCCEEDED, got {status}: {status_message}"
                 raise OperationFailed(msg)
             prefix = f"app_name={app_name}, deployment_id={deployment_id}"
             sleep = attempt
             if sleep > 10:
                 # sleep 10s max per attempt
                 sleep = 10
-            _LOG.debug(f'{prefix}: ({status}) {status_message} (sleeping ~{sleep}s)')
+            _LOG.debug(f"{prefix}: ({status}) {status_message} (sleeping ~{sleep}s)")
             time.sleep(sleep + random.random())
             attempt += 1
-        raise TimeoutError(f'timed out after {timeout}: {status_message}')
+        raise TimeoutError(f"timed out after {timeout}: {status_message}")
 
-    def wait_get_app_stopped(self,
-                             name: str,
-                             timeout=timedelta(minutes=20),
-                             callback: Optional[Callable[[App], None]] = None) -> App:
+    def wait_get_app_stopped(
+        self, name: str, timeout=timedelta(minutes=20), callback: Optional[Callable[[App], None]] = None
+    ) -> App:
         deadline = time.time() + timeout.total_seconds()
-        target_states = (ComputeState.STOPPED, )
-        failure_states = (ComputeState.ERROR, )
-        status_message = 'polling...'
+        target_states = (ComputeState.STOPPED,)
+        failure_states = (ComputeState.ERROR,)
+        status_message = "polling..."
         attempt = 1
         while time.time() < deadline:
             poll = self.get(name=name)
             status = poll.compute_status.state
-            status_message = f'current status: {status}'
+            status_message = f"current status: {status}"
             if poll.compute_status:
                 status_message = poll.compute_status.message
             if status in target_states:
@@ -961,323 +1132,352 @@ class AppsAPI:
             if callback:
                 callback(poll)
             if status in failure_states:
-                msg = f'failed to reach STOPPED, got {status}: {status_message}'
+                msg = f"failed to reach STOPPED, got {status}: {status_message}"
                 raise OperationFailed(msg)
             prefix = f"name={name}"
             sleep = attempt
             if sleep > 10:
                 # sleep 10s max per attempt
                 sleep = 10
-            _LOG.debug(f'{prefix}: ({status}) {status_message} (sleeping ~{sleep}s)')
+            _LOG.debug(f"{prefix}: ({status}) {status_message} (sleeping ~{sleep}s)")
             time.sleep(sleep + random.random())
             attempt += 1
-        raise TimeoutError(f'timed out after {timeout}: {status_message}')
+        raise TimeoutError(f"timed out after {timeout}: {status_message}")
 
     def create(self, *, app: Optional[App] = None, no_compute: Optional[bool] = None) -> Wait[App]:
         """Create an app.
-        
+
         Creates a new app.
-        
+
         :param app: :class:`App` (optional)
         :param no_compute: bool (optional)
           If true, the app will not be started after creation.
-        
+
         :returns:
           Long-running operation waiter for :class:`App`.
           See :method:wait_get_app_active for more details.
         """
         body = app.as_dict()
         query = {}
-        if no_compute is not None: query['no_compute'] = no_compute
-        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
-
-        op_response = self._api.do('POST', '/api/2.0/apps', query=query, body=body, headers=headers)
-        return Wait(self.wait_get_app_active, response=App.from_dict(op_response), name=op_response['name'])
-
-    def create_and_wait(self,
-                        *,
-                        app: Optional[App] = None,
-                        no_compute: Optional[bool] = None,
-                        timeout=timedelta(minutes=20)) -> App:
+        if no_compute is not None:
+            query["no_compute"] = no_compute
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        op_response = self._api.do("POST", "/api/2.0/apps", query=query, body=body, headers=headers)
+        return Wait(self.wait_get_app_active, response=App.from_dict(op_response), name=op_response["name"])
+
+    def create_and_wait(
+        self, *, app: Optional[App] = None, no_compute: Optional[bool] = None, timeout=timedelta(minutes=20)
+    ) -> App:
         return self.create(app=app, no_compute=no_compute).result(timeout=timeout)
 
     def delete(self, name: str) -> App:
         """Delete an app.
-        
+
         Deletes an app.
-        
+
         :param name: str
           The name of the app.
-        
+
         :returns: :class:`App`
         """
 
-        headers = {'Accept': 'application/json', }
+        headers = {
+            "Accept": "application/json",
+        }
 
-        res = self._api.do('DELETE', f'/api/2.0/apps/{name}', headers=headers)
+        res = self._api.do("DELETE", f"/api/2.0/apps/{name}", headers=headers)
         return App.from_dict(res)
 
     def deploy(self, app_name: str, *, app_deployment: Optional[AppDeployment] = None) -> Wait[AppDeployment]:
         """Create an app deployment.
-        
+
         Creates an app deployment for the app with the supplied name.
-        
+
         :param app_name: str
           The name of the app.
         :param app_deployment: :class:`AppDeployment` (optional)
-        
+
         :returns:
           Long-running operation waiter for :class:`AppDeployment`.
           See :method:wait_get_deployment_app_succeeded for more details.
         """
         body = app_deployment.as_dict()
-        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
-
-        op_response = self._api.do('POST',
-                                   f'/api/2.0/apps/{app_name}/deployments',
-                                   body=body,
-                                   headers=headers)
-        return Wait(self.wait_get_deployment_app_succeeded,
-                    response=AppDeployment.from_dict(op_response),
-                    app_name=app_name,
-                    deployment_id=op_response['deployment_id'])
-
-    def deploy_and_wait(self,
-                        app_name: str,
-                        *,
-                        app_deployment: Optional[AppDeployment] = None,
-                        timeout=timedelta(minutes=20)) -> AppDeployment:
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        op_response = self._api.do("POST", f"/api/2.0/apps/{app_name}/deployments", body=body, headers=headers)
+        return Wait(
+            self.wait_get_deployment_app_succeeded,
+            response=AppDeployment.from_dict(op_response),
+            app_name=app_name,
+            deployment_id=op_response["deployment_id"],
+        )
+
+    def deploy_and_wait(
+        self, app_name: str, *, app_deployment: Optional[AppDeployment] = None, timeout=timedelta(minutes=20)
+    ) -> AppDeployment:
         return self.deploy(app_deployment=app_deployment, app_name=app_name).result(timeout=timeout)
 
     def get(self, name: str) -> App:
         """Get an app.
-        
+
         Retrieves information for the app with the supplied name.
-        
+
         :param name: str
           The name of the app.
-        
+
         :returns: :class:`App`
         """
 
-        headers = {'Accept': 'application/json', }
+        headers = {
+            "Accept": "application/json",
+        }
 
-        res = self._api.do('GET', f'/api/2.0/apps/{name}', headers=headers)
+        res = self._api.do("GET", f"/api/2.0/apps/{name}", headers=headers)
         return App.from_dict(res)
 
     def get_deployment(self, app_name: str, deployment_id: str) -> AppDeployment:
         """Get an app deployment.
-        
+
         Retrieves information for the app deployment with the supplied name and deployment id.
-        
+
         :param app_name: str
           The name of the app.
         :param deployment_id: str
           The unique id of the deployment.
-        
+
         :returns: :class:`AppDeployment`
         """
 
-        headers = {'Accept': 'application/json', }
+        headers = {
+            "Accept": "application/json",
+        }
 
-        res = self._api.do('GET', f'/api/2.0/apps/{app_name}/deployments/{deployment_id}', headers=headers)
+        res = self._api.do("GET", f"/api/2.0/apps/{app_name}/deployments/{deployment_id}", headers=headers)
         return AppDeployment.from_dict(res)
 
     def get_permission_levels(self, app_name: str) -> GetAppPermissionLevelsResponse:
         """Get app permission levels.
-        
+
         Gets the permission levels that a user can have on an object.
-        
+
         :param app_name: str
           The app for which to get or manage permissions.
-        
+
         :returns: :class:`GetAppPermissionLevelsResponse`
         """
 
-        headers = {'Accept': 'application/json', }
+        headers = {
+            "Accept": "application/json",
+        }
 
-        res = self._api.do('GET', f'/api/2.0/permissions/apps/{app_name}/permissionLevels', headers=headers)
+        res = self._api.do("GET", f"/api/2.0/permissions/apps/{app_name}/permissionLevels", headers=headers)
         return GetAppPermissionLevelsResponse.from_dict(res)
 
     def get_permissions(self, app_name: str) -> AppPermissions:
         """Get app permissions.
-        
+
         Gets the permissions of an app. Apps can inherit permissions from their root object.
-        
+
         :param app_name: str
           The app for which to get or manage permissions.
-        
+
         :returns: :class:`AppPermissions`
         """
 
-        headers = {'Accept': 'application/json', }
+        headers = {
+            "Accept": "application/json",
+        }
 
-        res = self._api.do('GET', f'/api/2.0/permissions/apps/{app_name}', headers=headers)
+        res = self._api.do("GET", f"/api/2.0/permissions/apps/{app_name}", headers=headers)
         return AppPermissions.from_dict(res)
 
     def list(self, *, page_size: Optional[int] = None, page_token: Optional[str] = None) -> Iterator[App]:
         """List apps.
-        
+
         Lists all apps in the workspace.
-        
+
         :param page_size: int (optional)
           Upper bound for items returned.
         :param page_token: str (optional)
           Pagination token to go to the next page of apps. Requests first page if absent.
-        
+
         :returns: Iterator over :class:`App`
         """
 
         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/apps', query=query, headers=headers)
-            if 'apps' in json:
-                for v in json['apps']:
+            json = self._api.do("GET", "/api/2.0/apps", query=query, headers=headers)
+            if "apps" in json:
+                for v in json["apps"]:
                     yield App.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 list_deployments(self,
-                         app_name: str,
-                         *,
-                         page_size: Optional[int] = None,
-                         page_token: Optional[str] = None) -> Iterator[AppDeployment]:
+    def list_deployments(
+        self, app_name: str, *, page_size: Optional[int] = None, page_token: Optional[str] = None
+    ) -> Iterator[AppDeployment]:
         """List app deployments.
-        
+
         Lists all app deployments for the app with the supplied name.
-        
+
         :param app_name: str
           The name of the app.
         :param page_size: int (optional)
           Upper bound for items returned.
         :param page_token: str (optional)
           Pagination token to go to the next page of apps. Requests first page if absent.
-        
+
         :returns: Iterator over :class:`AppDeployment`
         """
 
         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', f'/api/2.0/apps/{app_name}/deployments', query=query, headers=headers)
-            if 'app_deployments' in json:
-                for v in json['app_deployments']:
+            json = self._api.do("GET", f"/api/2.0/apps/{app_name}/deployments", query=query, headers=headers)
+            if "app_deployments" in json:
+                for v in json["app_deployments"]:
                     yield AppDeployment.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 set_permissions(
-            self,
-            app_name: str,
-            *,
-            access_control_list: Optional[List[AppAccessControlRequest]] = None) -> AppPermissions:
+        self, app_name: str, *, access_control_list: Optional[List[AppAccessControlRequest]] = None
+    ) -> AppPermissions:
         """Set app permissions.
-        
+
         Sets permissions on an object, replacing existing permissions if they exist. Deletes all direct
         permissions if none are specified. Objects can inherit permissions from their root object.
-        
+
         :param app_name: str
           The app for which to get or manage permissions.
         :param access_control_list: List[:class:`AppAccessControlRequest`] (optional)
-        
+
         :returns: :class:`AppPermissions`
         """
         body = {}
         if access_control_list is not None:
-            body['access_control_list'] = [v.as_dict() for v in access_control_list]
-        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
+            body["access_control_list"] = [v.as_dict() for v in access_control_list]
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
 
-        res = self._api.do('PUT', f'/api/2.0/permissions/apps/{app_name}', body=body, headers=headers)
+        res = self._api.do("PUT", f"/api/2.0/permissions/apps/{app_name}", body=body, headers=headers)
         return AppPermissions.from_dict(res)
 
     def start(self, name: str) -> Wait[App]:
         """Start an app.
-        
+
         Start the last active deployment of the app in the workspace.
-        
+
         :param name: str
           The name of the app.
-        
+
         :returns:
           Long-running operation waiter for :class:`App`.
           See :method:wait_get_app_active for more details.
         """
 
-        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
 
-        op_response = self._api.do('POST', f'/api/2.0/apps/{name}/start', headers=headers)
-        return Wait(self.wait_get_app_active, response=App.from_dict(op_response), name=op_response['name'])
+        op_response = self._api.do("POST", f"/api/2.0/apps/{name}/start", headers=headers)
+        return Wait(self.wait_get_app_active, response=App.from_dict(op_response), name=op_response["name"])
 
     def start_and_wait(self, name: str, timeout=timedelta(minutes=20)) -> App:
         return self.start(name=name).result(timeout=timeout)
 
     def stop(self, name: str) -> Wait[App]:
         """Stop an app.
-        
+
         Stops the active deployment of the app in the workspace.
-        
+
         :param name: str
           The name of the app.
-        
+
         :returns:
           Long-running operation waiter for :class:`App`.
           See :method:wait_get_app_stopped for more details.
         """
 
-        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
 
-        op_response = self._api.do('POST', f'/api/2.0/apps/{name}/stop', headers=headers)
-        return Wait(self.wait_get_app_stopped, response=App.from_dict(op_response), name=op_response['name'])
+        op_response = self._api.do("POST", f"/api/2.0/apps/{name}/stop", headers=headers)
+        return Wait(self.wait_get_app_stopped, response=App.from_dict(op_response), name=op_response["name"])
 
     def stop_and_wait(self, name: str, timeout=timedelta(minutes=20)) -> App:
         return self.stop(name=name).result(timeout=timeout)
 
     def update(self, name: str, *, app: Optional[App] = None) -> App:
         """Update an app.
-        
+
         Updates the app with the supplied name.
-        
+
         :param name: str
           The name of the app. The name must contain only lowercase alphanumeric characters and hyphens. It
           must be unique within the workspace.
         :param app: :class:`App` (optional)
-        
+
         :returns: :class:`App`
         """
         body = app.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/apps/{name}', body=body, headers=headers)
+        res = self._api.do("PATCH", f"/api/2.0/apps/{name}", body=body, headers=headers)
         return App.from_dict(res)
 
     def update_permissions(
-            self,
-            app_name: str,
-            *,
-            access_control_list: Optional[List[AppAccessControlRequest]] = None) -> AppPermissions:
+        self, app_name: str, *, access_control_list: Optional[List[AppAccessControlRequest]] = None
+    ) -> AppPermissions:
         """Update app permissions.
-        
+
         Updates the permissions on an app. Apps can inherit permissions from their root object.
-        
+
         :param app_name: str
           The app for which to get or manage permissions.
         :param access_control_list: List[:class:`AppAccessControlRequest`] (optional)
-        
+
         :returns: :class:`AppPermissions`
         """
         body = {}
         if access_control_list is not None:
-            body['access_control_list'] = [v.as_dict() for v in access_control_list]
-        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
+            body["access_control_list"] = [v.as_dict() for v in access_control_list]
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
 
-        res = self._api.do('PATCH', f'/api/2.0/permissions/apps/{app_name}', body=body, headers=headers)
+        res = self._api.do("PATCH", f"/api/2.0/permissions/apps/{app_name}", body=body, headers=headers)
         return AppPermissions.from_dict(res)