databricks-sdk 0.58.0__py3-none-any.whl → 0.60.0__py3-none-any.whl

databricks/sdk/__init__.py

@@ -13,7 +13,7 @@ from databricks.sdk.mixins.files import DbfsExt, FilesExt
 from databricks.sdk.mixins.jobs import JobsExt
 from databricks.sdk.mixins.open_ai_client import ServingEndpointsExt
 from databricks.sdk.mixins.workspace import WorkspaceExt
-from databricks.sdk.service import aibuilder as pkg_aibuilder
+from databricks.sdk.service import agentbricks as pkg_agentbricks
 from databricks.sdk.service import apps as pkg_apps
 from databricks.sdk.service import billing as pkg_billing
 from databricks.sdk.service import catalog as pkg_catalog
@@ -36,7 +36,7 @@ from databricks.sdk.service import sharing as pkg_sharing
 from databricks.sdk.service import sql as pkg_sql
 from databricks.sdk.service import vectorsearch as pkg_vectorsearch
 from databricks.sdk.service import workspace as pkg_workspace
-from databricks.sdk.service.aibuilder import AiBuilderAPI
+from databricks.sdk.service.agentbricks import AgentBricksAPI
 from databricks.sdk.service.apps import AppsAPI
 from databricks.sdk.service.billing import (BillableUsageAPI, BudgetPolicyAPI,
                                             BudgetsAPI, LogDeliveryAPI,
@@ -97,7 +97,8 @@ from databricks.sdk.service.oauth2 import (AccountFederationPolicyAPI,
                                            OAuthPublishedAppsAPI,
                                            PublishedAppIntegrationAPI,
                                            ServicePrincipalFederationPolicyAPI,
-                                           ServicePrincipalSecretsAPI)
+                                           ServicePrincipalSecretsAPI,
+                                           ServicePrincipalSecretsProxyAPI)
 from databricks.sdk.service.pipelines import PipelinesAPI
 from databricks.sdk.service.provisioning import (CredentialsAPI,
                                                  EncryptionKeysAPI,
@@ -113,10 +114,11 @@ from databricks.sdk.service.settings import (
     AibiDashboardEmbeddingApprovedDomainsAPI, AutomaticClusterUpdateAPI,
     ComplianceSecurityProfileAPI, CredentialsManagerAPI,
     CspEnablementAccountAPI, DashboardEmailSubscriptionsAPI,
-    DefaultNamespaceAPI, DisableLegacyAccessAPI, DisableLegacyDbfsAPI,
-    DisableLegacyFeaturesAPI, EnableExportNotebookAPI, EnableIpAccessListsAPI,
-    EnableNotebookTableClipboardAPI, EnableResultsDownloadingAPI,
-    EnhancedSecurityMonitoringAPI, EsmEnablementAccountAPI, IpAccessListsAPI,
+    DefaultNamespaceAPI, DefaultWarehouseIdAPI, DisableLegacyAccessAPI,
+    DisableLegacyDbfsAPI, DisableLegacyFeaturesAPI, EnableExportNotebookAPI,
+    EnableIpAccessListsAPI, EnableNotebookTableClipboardAPI,
+    EnableResultsDownloadingAPI, EnhancedSecurityMonitoringAPI,
+    EsmEnablementAccountAPI, IpAccessListsAPI,
     LlmProxyPartnerPoweredAccountAPI, LlmProxyPartnerPoweredEnforceAPI,
     LlmProxyPartnerPoweredWorkspaceAPI, NetworkConnectivityAPI,
     NetworkPoliciesAPI, NotificationDestinationsAPI, PersonalComputeAPI,
@@ -238,7 +240,7 @@ class WorkspaceClient:
         serving_endpoints = ServingEndpointsExt(self._api_client)
         self._access_control = pkg_iam.AccessControlAPI(self._api_client)
         self._account_access_control_proxy = pkg_iam.AccountAccessControlProxyAPI(self._api_client)
-        self._ai_builder = pkg_aibuilder.AiBuilderAPI(self._api_client)
+        self._agent_bricks = pkg_agentbricks.AgentBricksAPI(self._api_client)
         self._alerts = pkg_sql.AlertsAPI(self._api_client)
         self._alerts_legacy = pkg_sql.AlertsLegacyAPI(self._api_client)
         self._alerts_v2 = pkg_sql.AlertsV2API(self._api_client)
@@ -323,6 +325,7 @@ class WorkspaceClient:
         self._resource_quotas = pkg_catalog.ResourceQuotasAPI(self._api_client)
         self._schemas = pkg_catalog.SchemasAPI(self._api_client)
         self._secrets = pkg_workspace.SecretsAPI(self._api_client)
+        self._service_principal_secrets_proxy = pkg_oauth2.ServicePrincipalSecretsProxyAPI(self._api_client)
         self._service_principals = pkg_iam.ServicePrincipalsAPI(self._api_client)
         self._serving_endpoints = serving_endpoints
         serving_endpoints_data_plane_token_source = DataPlaneTokenSource(
@@ -374,9 +377,9 @@ class WorkspaceClient:
         return self._account_access_control_proxy
 
     @property
-    def ai_builder(self) -> pkg_aibuilder.AiBuilderAPI:
+    def agent_bricks(self) -> pkg_agentbricks.AgentBricksAPI:
         """The Custom LLMs service manages state and powers the UI for the Custom LLM product."""
-        return self._ai_builder
+        return self._agent_bricks
 
     @property
     def alerts(self) -> pkg_sql.AlertsAPI:
@@ -788,6 +791,11 @@ class WorkspaceClient:
         """The Secrets API allows you to manage secrets, secret scopes, and access permissions."""
         return self._secrets
 
+    @property
+    def service_principal_secrets_proxy(self) -> pkg_oauth2.ServicePrincipalSecretsProxyAPI:
+        """These APIs enable administrators to manage service principal secrets at the workspace level."""
+        return self._service_principal_secrets_proxy
+
     @property
     def service_principals(self) -> pkg_iam.ServicePrincipalsAPI:
         """Identities for use with jobs, automated tools, and systems such as scripts, apps, and CI/CD platforms."""

databricks/sdk/credentials_provider.py

@@ -331,7 +331,7 @@ def file_oidc(cfg) -> Optional[CredentialsProvider]:
 # that provides a Databricks token from an IdTokenSource.
 def _oidc_credentials_provider(cfg, id_token_source: oidc.IdTokenSource) -> Optional[CredentialsProvider]:
     try:
-        id_token = id_token_source.id_token()
+        id_token_source.id_token()  # validate the id_token_source
     except Exception as e:
         logger.debug(f"Failed to get OIDC token: {e}")
         return None
@@ -341,7 +341,7 @@ def _oidc_credentials_provider(cfg, id_token_source: oidc.IdTokenSource) -> Opti
         token_endpoint=cfg.oidc_endpoints.token_endpoint,
         client_id=cfg.client_id,
         account_id=cfg.account_id,
-        id_token=id_token,
+        id_token_source=id_token_source,
         disable_async=cfg.disable_async_token_refresh,
     )
 

databricks/sdk/mixins/files.py

@@ -28,7 +28,6 @@ from .._base_client import _BaseClient, _RawResponse, _StreamingResponse
 from .._property import _cached_property
 from ..config import Config
 from ..errors import AlreadyExists, NotFound
-from ..errors.customizer import _RetryAfterCustomizer
 from ..errors.mapper import _error_mapper
 from ..retries import retried
 from ..service import files
@@ -577,6 +576,27 @@ class _DbfsPath(_Path):
         return f"<_DbfsPath {self._path}>"
 
 
+class _RetryableException(Exception):
+    """Base class for retryable exceptions in DBFS operations."""
+
+    def __init__(self, message: str, http_status_code: int):
+        super().__init__()
+        self.message = message
+        self.http_status_code = http_status_code
+
+    def __str__(self) -> str:
+        return f"{self.message} (HTTP Status: {self.http_status_code})"
+
+    @staticmethod
+    def make_error(response: requests.Response) -> "_RetryableException":
+        """Map the response to a retryable exception."""
+
+        return _RetryableException(
+            message=response.text,
+            http_status_code=response.status_code,
+        )
+
+
 class DbfsExt(files.DbfsAPI):
     __doc__ = files.DbfsAPI.__doc__
 
@@ -885,7 +905,7 @@ class FilesExt(files.FilesAPI):
                         timeout=self._config.multipart_upload_single_chunk_upload_timeout_seconds,
                     )
 
-                upload_response = self._retry_idempotent_operation(perform, rewind)
+                upload_response = self._retry_cloud_idempotent_operation(perform, rewind)
 
                 if upload_response.status_code in (200, 201):
                     # Chunk upload successful
@@ -1097,7 +1117,7 @@ class FilesExt(files.FilesAPI):
                         )
 
                     try:
-                        return self._retry_idempotent_operation(perform)
+                        return self._retry_cloud_idempotent_operation(perform)
                     except RequestException:
                         _LOG.warning("Failed to retrieve upload status")
                         return None
@@ -1116,7 +1136,7 @@ class FilesExt(files.FilesAPI):
                     # a 503 or 500 response, then you need to resume the interrupted upload from where it left off.
 
                     # Let's follow that for all potentially retryable status codes.
-                    # Together with the catch block below we replicate the logic in _retry_idempotent_operation().
+                    # Together with the catch block below we replicate the logic in _retry_databricks_idempotent_operation().
                     if upload_response.status_code in self._RETRYABLE_STATUS_CODES:
                         if retry_count < self._config.multipart_upload_max_retries:
                             retry_count += 1
@@ -1243,7 +1263,7 @@ class FilesExt(files.FilesAPI):
                 timeout=self._config.multipart_upload_single_chunk_upload_timeout_seconds,
             )
 
-        abort_response = self._retry_idempotent_operation(perform)
+        abort_response = self._retry_cloud_idempotent_operation(perform)
 
         if abort_response.status_code not in (200, 201):
             raise ValueError(abort_response)
@@ -1265,7 +1285,7 @@ class FilesExt(files.FilesAPI):
                 timeout=self._config.multipart_upload_single_chunk_upload_timeout_seconds,
             )
 
-        abort_response = self._retry_idempotent_operation(perform)
+        abort_response = self._retry_cloud_idempotent_operation(perform)
 
         if abort_response.status_code not in (200, 201):
             raise ValueError(abort_response)
@@ -1283,23 +1303,31 @@ class FilesExt(files.FilesAPI):
         session.mount("http://", http_adapter)
         return session
 
-    def _retry_idempotent_operation(
+    def _retry_cloud_idempotent_operation(
         self, operation: Callable[[], requests.Response], before_retry: Callable = None
     ) -> requests.Response:
-        """Perform given idempotent operation with necessary retries. Since operation is idempotent it's
-        safe to retry it for response codes where server state might have changed.
+        """Perform given idempotent operation with necessary retries for requests to non Databricks APIs.
+        For cloud APIs, we will retry on network errors and on server response codes.
+        Since operation is idempotent it's safe to retry it for response codes where server state might have changed.
         """
 
-        def delegate():
+        def delegate() -> requests.Response:
             response = operation()
             if response.status_code in self._RETRYABLE_STATUS_CODES:
-                attrs = {}
-                # this will assign "retry_after_secs" to the attrs, essentially making exception look retryable
-                _RetryAfterCustomizer().customize_error(response, attrs)
-                raise _error_mapper(response, attrs)
+                raise _RetryableException.make_error(response)
             else:
                 return response
 
+        def extended_is_retryable(e: BaseException) -> Optional[str]:
+            retry_reason_from_base = _BaseClient._is_retryable(e)
+            if retry_reason_from_base is not None:
+                return retry_reason_from_base
+
+            if isinstance(e, _RetryableException):
+                # this is a retriable exception, but not a network error
+                return f"retryable exception (status_code:{e.http_status_code})"
+            return None
+
         # following _BaseClient timeout
         retry_timeout_seconds = self._config.retry_timeout_seconds or 300
 
@@ -1307,7 +1335,7 @@ class FilesExt(files.FilesAPI):
             timeout=timedelta(seconds=retry_timeout_seconds),
             # also retry on network errors (connection error, connection timeout)
             # where we believe request didn't reach the server
-            is_retryable=_BaseClient._is_retryable,
+            is_retryable=extended_is_retryable,
             before_retry=before_retry,
         )(delegate)()
 

databricks/sdk/mixins/open_ai_client.py

@@ -4,6 +4,7 @@ from typing import Dict, Optional
 from requests import Response
 
 from databricks.sdk.service.serving import (ExternalFunctionRequestHttpMethod,
+                                            HttpRequestResponse,
                                             ServingEndpointsAPI)
 
 
@@ -88,15 +89,30 @@ class ServingEndpointsExt(ServingEndpointsAPI):
         """
         response = Response()
         response.status_code = 200
-        server_response = super().http_request(
-            connection_name=conn,
-            method=method,
-            path=path,
-            headers=js.dumps(headers) if headers is not None else None,
-            json=js.dumps(json) if json is not None else None,
-            params=js.dumps(params) if params is not None else None,
+
+        # We currently don't call super.http_request because we need to pass in response_headers
+        # This is a temporary fix to get the headers we need for the MCP session id
+        # TODO: Remove this once we have a better way to get back the response headers
+        headers_to_capture = ["mcp-session-id"]
+        res = self._api.do(
+            "POST",
+            "/api/2.0/external-function",
+            body={
+                "connection_name": conn,
+                "method": method.value,
+                "path": path,
+                "headers": js.dumps(headers) if headers is not None else None,
+                "json": js.dumps(json) if json is not None else None,
+                "params": js.dumps(params) if params is not None else None,
+            },
+            headers={"Accept": "text/plain", "Content-Type": "application/json"},
+            raw=True,
+            response_headers=headers_to_capture,
         )
 
+        # Create HttpRequestResponse from the raw response
+        server_response = HttpRequestResponse.from_dict(res)
+
         # Read the content from the HttpRequestResponse object
         if hasattr(server_response, "contents") and hasattr(server_response.contents, "read"):
             raw_content = server_response.contents.read()  # Read the bytes
@@ -109,4 +125,9 @@ class ServingEndpointsExt(ServingEndpointsAPI):
         else:
             raise ValueError("Contents must be bytes.")
 
+        # Copy headers from raw response to Response
+        for header_name in headers_to_capture:
+            if header_name in res:
+                response.headers[header_name] = res[header_name]
+
         return response

databricks/sdk/oidc.py

@@ -188,14 +188,18 @@ class DatabricksOidcTokenSource(oauth.TokenSource):
             logger.debug("Client ID provided, authenticating with Workload Identity Federation")
 
         id_token = self._id_token_source.id_token()
+        return self._exchange_id_token(id_token)
 
+    # This function is used to create the OAuth client.
+    # It exists to make it easier to test.
+    def _exchange_id_token(self, id_token: IdToken) -> oauth.Token:
         client = oauth.ClientCredentials(
             client_id=self._client_id,
-            client_secret="",  # we have no (rotatable) secrets in OIDC flow
+            client_secret="",  # there is no (rotatable) secrets in the OIDC flow
             token_url=self._token_endpoint,
             endpoint_params={
                 "subject_token_type": "urn:ietf:params:oauth:token-type:jwt",
-                "subject_token": id_token,
+                "subject_token": id_token.jwt,
                 "grant_type": "urn:ietf:params:oauth:grant-type:token-exchange",
             },
             scopes=["all-apis"],

databricks/sdk/service/{aibuilder.py → agentbricks.py}

@@ -15,73 +15,6 @@ _LOG = logging.getLogger("databricks.sdk")
 # all definitions in this file are in alphabetical order
 
 
-@dataclass
-class CancelCustomLlmOptimizationRunRequest:
-    id: Optional[str] = None
-
-
-@dataclass
-class CreateCustomLlmRequest:
-    name: str
-    """Name of the custom LLM. Only alphanumeric characters and dashes allowed."""
-
-    instructions: str
-    """Instructions for the custom LLM to follow"""
-
-    agent_artifact_path: Optional[str] = None
-    """Optional: UC path for agent artifacts. If you are using a dataset that you only have read
-    permissions, please provide a destination path where you have write permissions. Please provide
-    this in catalog.schema format."""
-
-    datasets: Optional[List[Dataset]] = None
-    """Datasets used for training and evaluating the model, not for inference. Currently, only 1
-    dataset is accepted."""
-
-    guidelines: Optional[List[str]] = None
-    """Guidelines for the custom LLM to adhere to"""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreateCustomLlmRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.agent_artifact_path is not None:
-            body["agent_artifact_path"] = self.agent_artifact_path
-        if self.datasets:
-            body["datasets"] = [v.as_dict() for v in self.datasets]
-        if self.guidelines:
-            body["guidelines"] = [v for v in self.guidelines]
-        if self.instructions is not None:
-            body["instructions"] = self.instructions
-        if self.name is not None:
-            body["name"] = self.name
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CreateCustomLlmRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.agent_artifact_path is not None:
-            body["agent_artifact_path"] = self.agent_artifact_path
-        if self.datasets:
-            body["datasets"] = self.datasets
-        if self.guidelines:
-            body["guidelines"] = self.guidelines
-        if self.instructions is not None:
-            body["instructions"] = self.instructions
-        if self.name is not None:
-            body["name"] = self.name
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreateCustomLlmRequest:
-        """Deserializes the CreateCustomLlmRequest from a dictionary."""
-        return cls(
-            agent_artifact_path=d.get("agent_artifact_path", None),
-            datasets=_repeated_dict(d, "datasets", Dataset),
-            guidelines=d.get("guidelines", None),
-            instructions=d.get("instructions", None),
-            name=d.get("name", None),
-        )
-
-
 @dataclass
 class CustomLlm:
     name: str
@@ -90,9 +23,6 @@ class CustomLlm:
     instructions: str
     """Instructions for the custom LLM to follow"""
 
-    optimization_state: State
-    """If optimization is kicked off, tracks the state of the custom LLM"""
-
     agent_artifact_path: Optional[str] = None
 
     creation_time: Optional[str] = None
@@ -112,6 +42,9 @@ class CustomLlm:
 
     id: Optional[str] = None
 
+    optimization_state: Optional[State] = None
+    """If optimization is kicked off, tracks the state of the custom LLM"""
+
     def as_dict(self) -> dict:
         """Serializes the CustomLlm into a dictionary suitable for use as a JSON request body."""
         body = {}
@@ -203,12 +136,6 @@ class Dataset:
         return cls(table=_from_dict(d, "table", Table))
 
 
-@dataclass
-class StartCustomLlmOptimizationRunRequest:
-    id: Optional[str] = None
-    """The Id of the tile."""
-
-
 class State(Enum):
     """States of Custom LLM optimization lifecycle."""
 
@@ -263,61 +190,7 @@ class Table:
         )
 
 
-@dataclass
-class UpdateCustomLlmRequest:
-    custom_llm: CustomLlm
-    """The CustomLlm containing the fields which should be updated."""
-
-    update_mask: str
-    """The list of the CustomLlm fields to update. These should correspond to the values (or lack
-    thereof) present in `custom_llm`.
-    
-    The field mask must be a single string, with multiple fields separated by commas (no spaces).
-    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
-    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
-    as only the entire collection field can be specified. Field names must exactly match the
-    resource field names.
-    
-    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
-    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
-    API changes in the future."""
-
-    id: Optional[str] = None
-    """The id of the custom llm"""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateCustomLlmRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.custom_llm:
-            body["custom_llm"] = self.custom_llm.as_dict()
-        if self.id is not None:
-            body["id"] = self.id
-        if self.update_mask is not None:
-            body["update_mask"] = self.update_mask
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateCustomLlmRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.custom_llm:
-            body["custom_llm"] = self.custom_llm
-        if self.id is not None:
-            body["id"] = self.id
-        if self.update_mask is not None:
-            body["update_mask"] = self.update_mask
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> UpdateCustomLlmRequest:
-        """Deserializes the UpdateCustomLlmRequest from a dictionary."""
-        return cls(
-            custom_llm=_from_dict(d, "custom_llm", CustomLlm),
-            id=d.get("id", None),
-            update_mask=d.get("update_mask", None),
-        )
-
-
-class AiBuilderAPI:
+class AgentBricksAPI:
     """The Custom LLMs service manages state and powers the UI for the Custom LLM product."""
 
     def __init__(self, api_client):
@@ -397,7 +270,7 @@ class AiBuilderAPI:
             "Accept": "application/json",
         }
 
-        self._api.do("DELETE", f"/api/2.0/custom-lms/{id}", headers=headers)
+        self._api.do("DELETE", f"/api/2.0/custom-llms/{id}", headers=headers)
 
     def get_custom_llm(self, id: str) -> CustomLlm:
         """Get a Custom LLM.

databricks/sdk/service/apps.py

@@ -602,45 +602,13 @@ class AppPermissionsDescription:
         )
 
 
-@dataclass
-class AppPermissionsRequest:
-    access_control_list: Optional[List[AppAccessControlRequest]] = None
-
-    app_name: Optional[str] = None
-    """The app for which to get or manage permissions."""
-
-    def as_dict(self) -> dict:
-        """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
-        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
-        return body
-
-    @classmethod
-    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),
-        )
-
-
 @dataclass
 class AppResource:
     name: str
     """Name of the App Resource."""
 
+    database: Optional[AppResourceDatabase] = None
+
     description: Optional[str] = None
     """Description of the App Resource."""
 
@@ -657,6 +625,8 @@ class AppResource:
     def as_dict(self) -> dict:
         """Serializes the AppResource into a dictionary suitable for use as a JSON request body."""
         body = {}
+        if self.database:
+            body["database"] = self.database.as_dict()
         if self.description is not None:
             body["description"] = self.description
         if self.job:
@@ -676,6 +646,8 @@ class AppResource:
     def as_shallow_dict(self) -> dict:
         """Serializes the AppResource into a shallow dictionary of its immediate attributes."""
         body = {}
+        if self.database:
+            body["database"] = self.database
         if self.description is not None:
             body["description"] = self.description
         if self.job:
@@ -696,6 +668,7 @@ class AppResource:
     def from_dict(cls, d: Dict[str, Any]) -> AppResource:
         """Deserializes the AppResource from a dictionary."""
         return cls(
+            database=_from_dict(d, "database", AppResourceDatabase),
             description=d.get("description", None),
             job=_from_dict(d, "job", AppResourceJob),
             name=d.get("name", None),
@@ -706,6 +679,51 @@ class AppResource:
         )
 
 
+@dataclass
+class AppResourceDatabase:
+    instance_name: str
+
+    database_name: str
+
+    permission: AppResourceDatabaseDatabasePermission
+
+    def as_dict(self) -> dict:
+        """Serializes the AppResourceDatabase into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.database_name is not None:
+            body["database_name"] = self.database_name
+        if self.instance_name is not None:
+            body["instance_name"] = self.instance_name
+        if self.permission is not None:
+            body["permission"] = self.permission.value
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AppResourceDatabase into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.database_name is not None:
+            body["database_name"] = self.database_name
+        if self.instance_name is not None:
+            body["instance_name"] = self.instance_name
+        if self.permission is not None:
+            body["permission"] = self.permission
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> AppResourceDatabase:
+        """Deserializes the AppResourceDatabase from a dictionary."""
+        return cls(
+            database_name=d.get("database_name", None),
+            instance_name=d.get("instance_name", None),
+            permission=_enum(d, "permission", AppResourceDatabaseDatabasePermission),
+        )
+
+
+class AppResourceDatabaseDatabasePermission(Enum):
+
+    CAN_CONNECT_AND_CREATE = "CAN_CONNECT_AND_CREATE"
+
+
 @dataclass
 class AppResourceJob:
     id: str
@@ -1109,18 +1127,6 @@ class ListAppsResponse:
         return cls(apps=_repeated_dict(d, "apps", App), next_page_token=d.get("next_page_token", None))
 
 
-@dataclass
-class StartAppRequest:
-    name: Optional[str] = None
-    """The name of the app."""
-
-
-@dataclass
-class StopAppRequest:
-    name: Optional[str] = None
-    """The name of the app."""
-
-
 class AppsAPI:
     """Apps run directly on a customer’s Databricks instance, integrate with their data, use and extend
     Databricks services, and enable users to interact through single sign-on."""