chmantha/zenml
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
2ca0b9ef7c3c9284e56d999675a22964f88d49db
zenml/venv/lib/python3.9/site-packages/databricks/sdk/service/workspace.py
Christian Mantha 2ca0b9ef7c star
2026-03-02 19:10:52 -05:00

3073 lines
117 KiB
Python
Raw Blame History

# Code generated from OpenAPI specs by Databricks SDK Generator. DO NOT EDIT.
from __future__ import annotations
import logging
from dataclasses import dataclass
from enum import Enum
from typing import Any, Dict, Iterator, List, Optional
from databricks.sdk.client_types import HostType
from databricks.sdk.service._internal import _enum, _from_dict, _repeated_dict
_LOG = logging.getLogger("databricks.sdk")
# all definitions in this file are in alphabetical order
@dataclass
class AclItem:
"""An item representing an ACL rule applied to the given principal (user or group) on the
associated scope point."""
principal: str
"""The principal in which the permission is applied."""
permission: AclPermission
"""The permission level applied to the principal."""
def as_dict(self) -> dict:
"""Serializes the AclItem into a dictionary suitable for use as a JSON request body."""
body = {}
if self.permission is not None:
body["permission"] = self.permission.value
if self.principal is not None:
body["principal"] = self.principal
return body
def as_shallow_dict(self) -> dict:
"""Serializes the AclItem into a shallow dictionary of its immediate attributes."""
body = {}
if self.permission is not None:
body["permission"] = self.permission
if self.principal is not None:
body["principal"] = self.principal
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> AclItem:
"""Deserializes the AclItem from a dictionary."""
return cls(permission=_enum(d, "permission", AclPermission), principal=d.get("principal", None))
class AclPermission(Enum):
"""The ACL permission levels for Secret ACLs applied to secret scopes."""
MANAGE = "MANAGE"
READ = "READ"
WRITE = "WRITE"
@dataclass
class AzureKeyVaultSecretScopeMetadata:
"""The metadata of the Azure KeyVault for a secret scope of type `AZURE_KEYVAULT`"""
resource_id: str
"""The resource id of the azure KeyVault that user wants to associate the scope with."""
dns_name: str
"""The DNS of the KeyVault"""
def as_dict(self) -> dict:
"""Serializes the AzureKeyVaultSecretScopeMetadata into a dictionary suitable for use as a JSON request body."""
body = {}
if self.dns_name is not None:
body["dns_name"] = self.dns_name
if self.resource_id is not None:
body["resource_id"] = self.resource_id
return body
def as_shallow_dict(self) -> dict:
"""Serializes the AzureKeyVaultSecretScopeMetadata into a shallow dictionary of its immediate attributes."""
body = {}
if self.dns_name is not None:
body["dns_name"] = self.dns_name
if self.resource_id is not None:
body["resource_id"] = self.resource_id
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> AzureKeyVaultSecretScopeMetadata:
"""Deserializes the AzureKeyVaultSecretScopeMetadata from a dictionary."""
return cls(dns_name=d.get("dns_name", None), resource_id=d.get("resource_id", None))
@dataclass
class CreateCredentialsResponse:
credential_id: int
"""ID of the credential object in the workspace."""
git_provider: str
"""The Git provider associated with the credential."""
git_email: Optional[str] = None
"""The authenticating email associated with your Git provider user account. Used for authentication
with the remote repository and also sets the author & committer identity for commits. Required
for most Git providers except AWS CodeCommit. Learn more at
https://docs.databricks.com/aws/en/repos/get-access-tokens-from-git-provider"""
git_username: Optional[str] = None
"""The username provided with your Git provider account and associated with the credential. For
most Git providers it is only used to set the Git committer & author names for commits, however
it may be required for authentication depending on your Git provider / token requirements.
Required for AWS CodeCommit."""
is_default_for_provider: Optional[bool] = None
"""if the credential is the default for the given provider"""
name: Optional[str] = None
"""the name of the git credential, used for identification and ease of lookup"""
def as_dict(self) -> dict:
"""Serializes the CreateCredentialsResponse into a dictionary suitable for use as a JSON request body."""
body = {}
if self.credential_id is not None:
body["credential_id"] = self.credential_id
if self.git_email is not None:
body["git_email"] = self.git_email
if self.git_provider is not None:
body["git_provider"] = self.git_provider
if self.git_username is not None:
body["git_username"] = self.git_username
if self.is_default_for_provider is not None:
body["is_default_for_provider"] = self.is_default_for_provider
if self.name is not None:
body["name"] = self.name
return body
def as_shallow_dict(self) -> dict:
"""Serializes the CreateCredentialsResponse into a shallow dictionary of its immediate attributes."""
body = {}
if self.credential_id is not None:
body["credential_id"] = self.credential_id
if self.git_email is not None:
body["git_email"] = self.git_email
if self.git_provider is not None:
body["git_provider"] = self.git_provider
if self.git_username is not None:
body["git_username"] = self.git_username
if self.is_default_for_provider is not None:
body["is_default_for_provider"] = self.is_default_for_provider
if self.name is not None:
body["name"] = self.name
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> CreateCredentialsResponse:
"""Deserializes the CreateCredentialsResponse from a dictionary."""
return cls(
credential_id=d.get("credential_id", None),
git_email=d.get("git_email", None),
git_provider=d.get("git_provider", None),
git_username=d.get("git_username", None),
is_default_for_provider=d.get("is_default_for_provider", None),
name=d.get("name", None),
)
@dataclass
class CreateRepoResponse:
branch: Optional[str] = None
"""Branch that the Git folder (repo) is checked out to."""
head_commit_id: Optional[str] = None
"""SHA-1 hash representing the commit ID of the current HEAD of the Git folder (repo)."""
id: Optional[int] = None
"""ID of the Git folder (repo) object in the workspace."""
path: Optional[str] = None
"""Path of the Git folder (repo) in the workspace."""
provider: Optional[str] = None
"""Git provider of the linked Git repository."""
sparse_checkout: Optional[SparseCheckout] = None
"""Sparse checkout settings for the Git folder (repo)."""
url: Optional[str] = None
"""URL of the linked Git repository."""
def as_dict(self) -> dict:
"""Serializes the CreateRepoResponse into a dictionary suitable for use as a JSON request body."""
body = {}
if self.branch is not None:
body["branch"] = self.branch
if self.head_commit_id is not None:
body["head_commit_id"] = self.head_commit_id
if self.id is not None:
body["id"] = self.id
if self.path is not None:
body["path"] = self.path
if self.provider is not None:
body["provider"] = self.provider
if self.sparse_checkout:
body["sparse_checkout"] = self.sparse_checkout.as_dict()
if self.url is not None:
body["url"] = self.url
return body
def as_shallow_dict(self) -> dict:
"""Serializes the CreateRepoResponse into a shallow dictionary of its immediate attributes."""
body = {}
if self.branch is not None:
body["branch"] = self.branch
if self.head_commit_id is not None:
body["head_commit_id"] = self.head_commit_id
if self.id is not None:
body["id"] = self.id
if self.path is not None:
body["path"] = self.path
if self.provider is not None:
body["provider"] = self.provider
if self.sparse_checkout:
body["sparse_checkout"] = self.sparse_checkout
if self.url is not None:
body["url"] = self.url
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> CreateRepoResponse:
"""Deserializes the CreateRepoResponse from a dictionary."""
return cls(
branch=d.get("branch", None),
head_commit_id=d.get("head_commit_id", None),
id=d.get("id", None),
path=d.get("path", None),
provider=d.get("provider", None),
sparse_checkout=_from_dict(d, "sparse_checkout", SparseCheckout),
url=d.get("url", None),
)
@dataclass
class CredentialInfo:
credential_id: int
"""ID of the credential object in the workspace."""
git_email: Optional[str] = None
"""The authenticating email associated with your Git provider user account. Used for authentication
with the remote repository and also sets the author & committer identity for commits. Required
for most Git providers except AWS CodeCommit. Learn more at
https://docs.databricks.com/aws/en/repos/get-access-tokens-from-git-provider"""
git_provider: Optional[str] = None
"""The Git provider associated with the credential."""
git_username: Optional[str] = None
"""The username provided with your Git provider account and associated with the credential. For
most Git providers it is only used to set the Git committer & author names for commits, however
it may be required for authentication depending on your Git provider / token requirements.
Required for AWS CodeCommit."""
is_default_for_provider: Optional[bool] = None
"""if the credential is the default for the given provider"""
name: Optional[str] = None
"""the name of the git credential, used for identification and ease of lookup"""
def as_dict(self) -> dict:
"""Serializes the CredentialInfo into a dictionary suitable for use as a JSON request body."""
body = {}
if self.credential_id is not None:
body["credential_id"] = self.credential_id
if self.git_email is not None:
body["git_email"] = self.git_email
if self.git_provider is not None:
body["git_provider"] = self.git_provider
if self.git_username is not None:
body["git_username"] = self.git_username
if self.is_default_for_provider is not None:
body["is_default_for_provider"] = self.is_default_for_provider
if self.name is not None:
body["name"] = self.name
return body
def as_shallow_dict(self) -> dict:
"""Serializes the CredentialInfo into a shallow dictionary of its immediate attributes."""
body = {}
if self.credential_id is not None:
body["credential_id"] = self.credential_id
if self.git_email is not None:
body["git_email"] = self.git_email
if self.git_provider is not None:
body["git_provider"] = self.git_provider
if self.git_username is not None:
body["git_username"] = self.git_username
if self.is_default_for_provider is not None:
body["is_default_for_provider"] = self.is_default_for_provider
if self.name is not None:
body["name"] = self.name
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> CredentialInfo:
"""Deserializes the CredentialInfo from a dictionary."""
return cls(
credential_id=d.get("credential_id", None),
git_email=d.get("git_email", None),
git_provider=d.get("git_provider", None),
git_username=d.get("git_username", None),
is_default_for_provider=d.get("is_default_for_provider", None),
name=d.get("name", None),
)
@dataclass
class DeleteCredentialsResponse:
def as_dict(self) -> dict:
"""Serializes the DeleteCredentialsResponse into a dictionary suitable for use as a JSON request body."""
body = {}
return body
def as_shallow_dict(self) -> dict:
"""Serializes the DeleteCredentialsResponse into a shallow dictionary of its immediate attributes."""
body = {}
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> DeleteCredentialsResponse:
"""Deserializes the DeleteCredentialsResponse from a dictionary."""
return cls()
@dataclass
class DeleteRepoResponse:
def as_dict(self) -> dict:
"""Serializes the DeleteRepoResponse into a dictionary suitable for use as a JSON request body."""
body = {}
return body
def as_shallow_dict(self) -> dict:
"""Serializes the DeleteRepoResponse into a shallow dictionary of its immediate attributes."""
body = {}
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> DeleteRepoResponse:
"""Deserializes the DeleteRepoResponse from a dictionary."""
return cls()
@dataclass
class DeleteResponse:
def as_dict(self) -> dict:
"""Serializes the DeleteResponse into a dictionary suitable for use as a JSON request body."""
body = {}
return body
def as_shallow_dict(self) -> dict:
"""Serializes the DeleteResponse into a shallow dictionary of its immediate attributes."""
body = {}
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> DeleteResponse:
"""Deserializes the DeleteResponse from a dictionary."""
return cls()
@dataclass
class DeleteSecretResponse:
def as_dict(self) -> dict:
"""Serializes the DeleteSecretResponse into a dictionary suitable for use as a JSON request body."""
body = {}
return body
def as_shallow_dict(self) -> dict:
"""Serializes the DeleteSecretResponse into a shallow dictionary of its immediate attributes."""
body = {}
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> DeleteSecretResponse:
"""Deserializes the DeleteSecretResponse from a dictionary."""
return cls()
class ExportFormat(Enum):
"""The format for workspace import and export."""
AUTO = "AUTO"
DBC = "DBC"
HTML = "HTML"
JUPYTER = "JUPYTER"
RAW = "RAW"
R_MARKDOWN = "R_MARKDOWN"
SOURCE = "SOURCE"
@dataclass
class ExportResponse:
"""The request field `direct_download` determines whether a JSON response or binary contents are
returned by this endpoint."""
content: Optional[str] = None
"""The base64-encoded content. If the limit (10MB) is exceeded, exception with error code
**MAX_NOTEBOOK_SIZE_EXCEEDED** is thrown."""
file_type: Optional[str] = None
"""The file type of the exported file."""
def as_dict(self) -> dict:
"""Serializes the ExportResponse into a dictionary suitable for use as a JSON request body."""
body = {}
if self.content is not None:
body["content"] = self.content
if self.file_type is not None:
body["file_type"] = self.file_type
return body
def as_shallow_dict(self) -> dict:
"""Serializes the ExportResponse into a shallow dictionary of its immediate attributes."""
body = {}
if self.content is not None:
body["content"] = self.content
if self.file_type is not None:
body["file_type"] = self.file_type
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> ExportResponse:
"""Deserializes the ExportResponse from a dictionary."""
return cls(content=d.get("content", None), file_type=d.get("file_type", None))
@dataclass
class GetCredentialsResponse:
credential_id: int
"""ID of the credential object in the workspace."""
git_email: Optional[str] = None
"""The authenticating email associated with your Git provider user account. Used for authentication
with the remote repository and also sets the author & committer identity for commits. Required
for most Git providers except AWS CodeCommit. Learn more at
https://docs.databricks.com/aws/en/repos/get-access-tokens-from-git-provider"""
git_provider: Optional[str] = None
"""The Git provider associated with the credential."""
git_username: Optional[str] = None
"""The username provided with your Git provider account and associated with the credential. For
most Git providers it is only used to set the Git committer & author names for commits, however
it may be required for authentication depending on your Git provider / token requirements.
Required for AWS CodeCommit."""
is_default_for_provider: Optional[bool] = None
"""if the credential is the default for the given provider"""
name: Optional[str] = None
"""the name of the git credential, used for identification and ease of lookup"""
def as_dict(self) -> dict:
"""Serializes the GetCredentialsResponse into a dictionary suitable for use as a JSON request body."""
body = {}
if self.credential_id is not None:
body["credential_id"] = self.credential_id
if self.git_email is not None:
body["git_email"] = self.git_email
if self.git_provider is not None:
body["git_provider"] = self.git_provider
if self.git_username is not None:
body["git_username"] = self.git_username
if self.is_default_for_provider is not None:
body["is_default_for_provider"] = self.is_default_for_provider
if self.name is not None:
body["name"] = self.name
return body
def as_shallow_dict(self) -> dict:
"""Serializes the GetCredentialsResponse into a shallow dictionary of its immediate attributes."""
body = {}
if self.credential_id is not None:
body["credential_id"] = self.credential_id
if self.git_email is not None:
body["git_email"] = self.git_email
if self.git_provider is not None:
body["git_provider"] = self.git_provider
if self.git_username is not None:
body["git_username"] = self.git_username
if self.is_default_for_provider is not None:
body["is_default_for_provider"] = self.is_default_for_provider
if self.name is not None:
body["name"] = self.name
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> GetCredentialsResponse:
"""Deserializes the GetCredentialsResponse from a dictionary."""
return cls(
credential_id=d.get("credential_id", None),
git_email=d.get("git_email", None),
git_provider=d.get("git_provider", None),
git_username=d.get("git_username", None),
is_default_for_provider=d.get("is_default_for_provider", None),
name=d.get("name", None),
)
@dataclass
class GetRepoPermissionLevelsResponse:
permission_levels: Optional[List[RepoPermissionsDescription]] = None
"""Specific permission levels"""
def as_dict(self) -> dict:
"""Serializes the GetRepoPermissionLevelsResponse 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]
return body
def as_shallow_dict(self) -> dict:
"""Serializes the GetRepoPermissionLevelsResponse into a shallow dictionary of its immediate attributes."""
body = {}
if self.permission_levels:
body["permission_levels"] = self.permission_levels
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> GetRepoPermissionLevelsResponse:
"""Deserializes the GetRepoPermissionLevelsResponse from a dictionary."""
return cls(permission_levels=_repeated_dict(d, "permission_levels", RepoPermissionsDescription))
@dataclass
class GetRepoResponse:
branch: Optional[str] = None
"""Branch that the local version of the repo is checked out to."""
head_commit_id: Optional[str] = None
"""SHA-1 hash representing the commit ID of the current HEAD of the repo."""
id: Optional[int] = None
"""ID of the Git folder (repo) object in the workspace."""
path: Optional[str] = None
"""Path of the Git folder (repo) in the workspace."""
provider: Optional[str] = None
"""Git provider of the linked Git repository."""
sparse_checkout: Optional[SparseCheckout] = None
"""Sparse checkout settings for the Git folder (repo)."""
url: Optional[str] = None
"""URL of the linked Git repository."""
def as_dict(self) -> dict:
"""Serializes the GetRepoResponse into a dictionary suitable for use as a JSON request body."""
body = {}
if self.branch is not None:
body["branch"] = self.branch
if self.head_commit_id is not None:
body["head_commit_id"] = self.head_commit_id
if self.id is not None:
body["id"] = self.id
if self.path is not None:
body["path"] = self.path
if self.provider is not None:
body["provider"] = self.provider
if self.sparse_checkout:
body["sparse_checkout"] = self.sparse_checkout.as_dict()
if self.url is not None:
body["url"] = self.url
return body
def as_shallow_dict(self) -> dict:
"""Serializes the GetRepoResponse into a shallow dictionary of its immediate attributes."""
body = {}
if self.branch is not None:
body["branch"] = self.branch
if self.head_commit_id is not None:
body["head_commit_id"] = self.head_commit_id
if self.id is not None:
body["id"] = self.id
if self.path is not None:
body["path"] = self.path
if self.provider is not None:
body["provider"] = self.provider
if self.sparse_checkout:
body["sparse_checkout"] = self.sparse_checkout
if self.url is not None:
body["url"] = self.url
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> GetRepoResponse:
"""Deserializes the GetRepoResponse from a dictionary."""
return cls(
branch=d.get("branch", None),
head_commit_id=d.get("head_commit_id", None),
id=d.get("id", None),
path=d.get("path", None),
provider=d.get("provider", None),
sparse_checkout=_from_dict(d, "sparse_checkout", SparseCheckout),
url=d.get("url", None),
)
@dataclass
class GetSecretResponse:
key: Optional[str] = None
"""A unique name to identify the secret."""
value: Optional[str] = None
"""The value of the secret in its byte representation."""
def as_dict(self) -> dict:
"""Serializes the GetSecretResponse into a dictionary suitable for use as a JSON request body."""
body = {}
if self.key is not None:
body["key"] = self.key
if self.value is not None:
body["value"] = self.value
return body
def as_shallow_dict(self) -> dict:
"""Serializes the GetSecretResponse into a shallow dictionary of its immediate attributes."""
body = {}
if self.key is not None:
body["key"] = self.key
if self.value is not None:
body["value"] = self.value
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> GetSecretResponse:
"""Deserializes the GetSecretResponse from a dictionary."""
return cls(key=d.get("key", None), value=d.get("value", None))
@dataclass
class GetWorkspaceObjectPermissionLevelsResponse:
permission_levels: Optional[List[WorkspaceObjectPermissionsDescription]] = None
"""Specific permission levels"""
def as_dict(self) -> dict:
"""Serializes the GetWorkspaceObjectPermissionLevelsResponse 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]
return body
def as_shallow_dict(self) -> dict:
"""Serializes the GetWorkspaceObjectPermissionLevelsResponse into a shallow dictionary of its immediate attributes."""
body = {}
if self.permission_levels:
body["permission_levels"] = self.permission_levels
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> GetWorkspaceObjectPermissionLevelsResponse:
"""Deserializes the GetWorkspaceObjectPermissionLevelsResponse from a dictionary."""
return cls(permission_levels=_repeated_dict(d, "permission_levels", WorkspaceObjectPermissionsDescription))
class ImportFormat(Enum):
"""The format for workspace import and export."""
AUTO = "AUTO"
DBC = "DBC"
HTML = "HTML"
JUPYTER = "JUPYTER"
RAW = "RAW"
R_MARKDOWN = "R_MARKDOWN"
SOURCE = "SOURCE"
@dataclass
class ImportResponse:
def as_dict(self) -> dict:
"""Serializes the ImportResponse into a dictionary suitable for use as a JSON request body."""
body = {}
return body
def as_shallow_dict(self) -> dict:
"""Serializes the ImportResponse into a shallow dictionary of its immediate attributes."""
body = {}
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> ImportResponse:
"""Deserializes the ImportResponse from a dictionary."""
return cls()
class Language(Enum):
"""The language of notebook."""
PYTHON = "PYTHON"
R = "R"
SCALA = "SCALA"
SQL = "SQL"
@dataclass
class ListAclsResponse:
items: Optional[List[AclItem]] = None
"""The associated ACLs rule applied to principals in the given scope."""
def as_dict(self) -> dict:
"""Serializes the ListAclsResponse into a dictionary suitable for use as a JSON request body."""
body = {}
if self.items:
body["items"] = [v.as_dict() for v in self.items]
return body
def as_shallow_dict(self) -> dict:
"""Serializes the ListAclsResponse into a shallow dictionary of its immediate attributes."""
body = {}
if self.items:
body["items"] = self.items
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> ListAclsResponse:
"""Deserializes the ListAclsResponse from a dictionary."""
return cls(items=_repeated_dict(d, "items", AclItem))
@dataclass
class ListCredentialsResponse:
credentials: Optional[List[CredentialInfo]] = None
"""List of credentials."""
def as_dict(self) -> dict:
"""Serializes the ListCredentialsResponse into a dictionary suitable for use as a JSON request body."""
body = {}
if self.credentials:
body["credentials"] = [v.as_dict() for v in self.credentials]
return body
def as_shallow_dict(self) -> dict:
"""Serializes the ListCredentialsResponse into a shallow dictionary of its immediate attributes."""
body = {}
if self.credentials:
body["credentials"] = self.credentials
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> ListCredentialsResponse:
"""Deserializes the ListCredentialsResponse from a dictionary."""
return cls(credentials=_repeated_dict(d, "credentials", CredentialInfo))
@dataclass
class ListReposResponse:
next_page_token: Optional[str] = None
"""Token that can be specified as a query parameter to the `GET /repos` endpoint to retrieve the
next page of results."""
repos: Optional[List[RepoInfo]] = None
"""List of Git folders (repos)."""
def as_dict(self) -> dict:
"""Serializes the ListReposResponse into a dictionary suitable for use as a JSON request body."""
body = {}
if self.next_page_token is not None:
body["next_page_token"] = self.next_page_token
if self.repos:
body["repos"] = [v.as_dict() for v in self.repos]
return body
def as_shallow_dict(self) -> dict:
"""Serializes the ListReposResponse into a shallow dictionary of its immediate attributes."""
body = {}
if self.next_page_token is not None:
body["next_page_token"] = self.next_page_token
if self.repos:
body["repos"] = self.repos
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> ListReposResponse:
"""Deserializes the ListReposResponse from a dictionary."""
return cls(next_page_token=d.get("next_page_token", None), repos=_repeated_dict(d, "repos", RepoInfo))
@dataclass
class ListResponse:
objects: Optional[List[ObjectInfo]] = None
"""List of objects."""
def as_dict(self) -> dict:
"""Serializes the ListResponse into a dictionary suitable for use as a JSON request body."""
body = {}
if self.objects:
body["objects"] = [v.as_dict() for v in self.objects]
return body
def as_shallow_dict(self) -> dict:
"""Serializes the ListResponse into a shallow dictionary of its immediate attributes."""
body = {}
if self.objects:
body["objects"] = self.objects
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> ListResponse:
"""Deserializes the ListResponse from a dictionary."""
return cls(objects=_repeated_dict(d, "objects", ObjectInfo))
@dataclass
class ListScopesResponse:
scopes: Optional[List[SecretScope]] = None
"""The available secret scopes."""
def as_dict(self) -> dict:
"""Serializes the ListScopesResponse into a dictionary suitable for use as a JSON request body."""
body = {}
if self.scopes:
body["scopes"] = [v.as_dict() for v in self.scopes]
return body
def as_shallow_dict(self) -> dict:
"""Serializes the ListScopesResponse into a shallow dictionary of its immediate attributes."""
body = {}
if self.scopes:
body["scopes"] = self.scopes
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> ListScopesResponse:
"""Deserializes the ListScopesResponse from a dictionary."""
return cls(scopes=_repeated_dict(d, "scopes", SecretScope))
@dataclass
class ListSecretsResponse:
secrets: Optional[List[SecretMetadata]] = None
"""Metadata information of all secrets contained within the given scope."""
def as_dict(self) -> dict:
"""Serializes the ListSecretsResponse into a dictionary suitable for use as a JSON request body."""
body = {}
if self.secrets:
body["secrets"] = [v.as_dict() for v in self.secrets]
return body
def as_shallow_dict(self) -> dict:
"""Serializes the ListSecretsResponse into a shallow dictionary of its immediate attributes."""
body = {}
if self.secrets:
body["secrets"] = self.secrets
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> ListSecretsResponse:
"""Deserializes the ListSecretsResponse from a dictionary."""
return cls(secrets=_repeated_dict(d, "secrets", SecretMetadata))
@dataclass
class MkdirsResponse:
def as_dict(self) -> dict:
"""Serializes the MkdirsResponse into a dictionary suitable for use as a JSON request body."""
body = {}
return body
def as_shallow_dict(self) -> dict:
"""Serializes the MkdirsResponse into a shallow dictionary of its immediate attributes."""
body = {}
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> MkdirsResponse:
"""Deserializes the MkdirsResponse from a dictionary."""
return cls()
@dataclass
class ObjectInfo:
"""The information of the object in workspace. It will be returned by ``list`` and ``get-status``."""
created_at: Optional[int] = None
"""Only applicable to files. The creation UTC timestamp."""
language: Optional[Language] = None
"""The language of the object. This value is set only if the object type is ``NOTEBOOK``."""
modified_at: Optional[int] = None
"""Only applicable to files, the last modified UTC timestamp."""
object_id: Optional[int] = None
"""Unique identifier for the object."""
object_type: Optional[ObjectType] = None
"""The type of the object in workspace.
- `NOTEBOOK`: document that contains runnable code, visualizations, and explanatory text. -
`DIRECTORY`: directory - `LIBRARY`: library - `FILE`: file - `REPO`: repository - `DASHBOARD`:
Lakeview dashboard"""
path: Optional[str] = None
"""The absolute path of the object."""
resource_id: Optional[str] = None
"""A unique identifier for the object that is consistent across all Databricks APIs."""
size: Optional[int] = None
"""Only applicable to files. The file size in bytes can be returned."""
def as_dict(self) -> dict:
"""Serializes the ObjectInfo into a dictionary suitable for use as a JSON request body."""
body = {}
if self.created_at is not None:
body["created_at"] = self.created_at
if self.language is not None:
body["language"] = self.language.value
if self.modified_at is not None:
body["modified_at"] = self.modified_at
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.value
if self.path is not None:
body["path"] = self.path
if self.resource_id is not None:
body["resource_id"] = self.resource_id
if self.size is not None:
body["size"] = self.size
return body
def as_shallow_dict(self) -> dict:
"""Serializes the ObjectInfo into a shallow dictionary of its immediate attributes."""
body = {}
if self.created_at is not None:
body["created_at"] = self.created_at
if self.language is not None:
body["language"] = self.language
if self.modified_at is not None:
body["modified_at"] = self.modified_at
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.path is not None:
body["path"] = self.path
if self.resource_id is not None:
body["resource_id"] = self.resource_id
if self.size is not None:
body["size"] = self.size
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> ObjectInfo:
"""Deserializes the ObjectInfo from a dictionary."""
return cls(
created_at=d.get("created_at", None),
language=_enum(d, "language", Language),
modified_at=d.get("modified_at", None),
object_id=d.get("object_id", None),
object_type=_enum(d, "object_type", ObjectType),
path=d.get("path", None),
resource_id=d.get("resource_id", None),
size=d.get("size", None),
)
class ObjectType(Enum):
"""The type of the object in workspace."""
DASHBOARD = "DASHBOARD"
DIRECTORY = "DIRECTORY"
FILE = "FILE"
LIBRARY = "LIBRARY"
NOTEBOOK = "NOTEBOOK"
REPO = "REPO"
@dataclass
class RepoAccessControlRequest:
group_name: Optional[str] = None
"""name of the group"""
permission_level: Optional[RepoPermissionLevel] = None
service_principal_name: Optional[str] = None
"""application ID of a service principal"""
user_name: Optional[str] = None
"""name of the user"""
def as_dict(self) -> dict:
"""Serializes the RepoAccessControlRequest 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.service_principal_name is not None:
body["service_principal_name"] = self.service_principal_name
if self.user_name is not None:
body["user_name"] = self.user_name
return body
def as_shallow_dict(self) -> dict:
"""Serializes the RepoAccessControlRequest 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.service_principal_name is not None:
body["service_principal_name"] = self.service_principal_name
if self.user_name is not None:
body["user_name"] = self.user_name
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> RepoAccessControlRequest:
"""Deserializes the RepoAccessControlRequest from a dictionary."""
return cls(
group_name=d.get("group_name", None),
permission_level=_enum(d, "permission_level", RepoPermissionLevel),
service_principal_name=d.get("service_principal_name", None),
user_name=d.get("user_name", None),
)
@dataclass
class RepoAccessControlResponse:
all_permissions: Optional[List[RepoPermission]] = None
"""All permissions."""
display_name: Optional[str] = None
"""Display name of the user or service principal."""
group_name: Optional[str] = None
"""name of the group"""
service_principal_name: Optional[str] = None
"""Name of the service principal."""
user_name: Optional[str] = None
"""name of the user"""
def as_dict(self) -> dict:
"""Serializes the RepoAccessControlResponse 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.service_principal_name is not None:
body["service_principal_name"] = self.service_principal_name
if self.user_name is not None:
body["user_name"] = self.user_name
return body
def as_shallow_dict(self) -> dict:
"""Serializes the RepoAccessControlResponse 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.service_principal_name is not None:
body["service_principal_name"] = self.service_principal_name
if self.user_name is not None:
body["user_name"] = self.user_name
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> RepoAccessControlResponse:
"""Deserializes the RepoAccessControlResponse from a dictionary."""
return cls(
all_permissions=_repeated_dict(d, "all_permissions", RepoPermission),
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
class RepoInfo:
"""Git folder (repo) information."""
branch: Optional[str] = None
"""Name of the current git branch of the git folder (repo)."""
head_commit_id: Optional[str] = None
"""Current git commit id of the git folder (repo)."""
id: Optional[int] = None
"""Id of the git folder (repo) in the Workspace."""
path: Optional[str] = None
"""Root path of the git folder (repo) in the Workspace."""
provider: Optional[str] = None
"""Git provider of the remote git repository, e.g. `gitHub`."""
sparse_checkout: Optional[SparseCheckout] = None
"""Sparse checkout config for the git folder (repo)."""
url: Optional[str] = None
"""URL of the remote git repository."""
def as_dict(self) -> dict:
"""Serializes the RepoInfo into a dictionary suitable for use as a JSON request body."""
body = {}
if self.branch is not None:
body["branch"] = self.branch
if self.head_commit_id is not None:
body["head_commit_id"] = self.head_commit_id
if self.id is not None:
body["id"] = self.id
if self.path is not None:
body["path"] = self.path
if self.provider is not None:
body["provider"] = self.provider
if self.sparse_checkout:
body["sparse_checkout"] = self.sparse_checkout.as_dict()
if self.url is not None:
body["url"] = self.url
return body
def as_shallow_dict(self) -> dict:
"""Serializes the RepoInfo into a shallow dictionary of its immediate attributes."""
body = {}
if self.branch is not None:
body["branch"] = self.branch
if self.head_commit_id is not None:
body["head_commit_id"] = self.head_commit_id
if self.id is not None:
body["id"] = self.id
if self.path is not None:
body["path"] = self.path
if self.provider is not None:
body["provider"] = self.provider
if self.sparse_checkout:
body["sparse_checkout"] = self.sparse_checkout
if self.url is not None:
body["url"] = self.url
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> RepoInfo:
"""Deserializes the RepoInfo from a dictionary."""
return cls(
branch=d.get("branch", None),
head_commit_id=d.get("head_commit_id", None),
id=d.get("id", None),
path=d.get("path", None),
provider=d.get("provider", None),
sparse_checkout=_from_dict(d, "sparse_checkout", SparseCheckout),
url=d.get("url", None),
)
@dataclass
class RepoPermission:
inherited: Optional[bool] = None
inherited_from_object: Optional[List[str]] = None
permission_level: Optional[RepoPermissionLevel] = None
def as_dict(self) -> dict:
"""Serializes the RepoPermission 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
return body
def as_shallow_dict(self) -> dict:
"""Serializes the RepoPermission 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
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> RepoPermission:
"""Deserializes the RepoPermission 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", RepoPermissionLevel),
)
class RepoPermissionLevel(Enum):
"""Permission level"""
CAN_EDIT = "CAN_EDIT"
CAN_MANAGE = "CAN_MANAGE"
CAN_READ = "CAN_READ"
CAN_RUN = "CAN_RUN"
@dataclass
class RepoPermissions:
access_control_list: Optional[List[RepoAccessControlResponse]] = None
object_id: Optional[str] = None
object_type: Optional[str] = None
def as_dict(self) -> dict:
"""Serializes the RepoPermissions 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
return body
def as_shallow_dict(self) -> dict:
"""Serializes the RepoPermissions 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
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> RepoPermissions:
"""Deserializes the RepoPermissions from a dictionary."""
return cls(
access_control_list=_repeated_dict(d, "access_control_list", RepoAccessControlResponse),
object_id=d.get("object_id", None),
object_type=d.get("object_type", None),
)
@dataclass
class RepoPermissionsDescription:
description: Optional[str] = None
permission_level: Optional[RepoPermissionLevel] = None
def as_dict(self) -> dict:
"""Serializes the RepoPermissionsDescription 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
return body
def as_shallow_dict(self) -> dict:
"""Serializes the RepoPermissionsDescription 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
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> RepoPermissionsDescription:
"""Deserializes the RepoPermissionsDescription from a dictionary."""
return cls(
description=d.get("description", None), permission_level=_enum(d, "permission_level", RepoPermissionLevel)
)
class ScopeBackendType(Enum):
"""The types of secret scope backends in the Secret Manager. Azure KeyVault backed secret scopes
will be supported in a later release."""
AZURE_KEYVAULT = "AZURE_KEYVAULT"
DATABRICKS = "DATABRICKS"
@dataclass
class SecretMetadata:
"""The metadata about a secret. Returned when listing secrets. Does not contain the actual secret
value."""
key: Optional[str] = None
"""A unique name to identify the secret."""
last_updated_timestamp: Optional[int] = None
"""The last updated timestamp (in milliseconds) for the secret."""
def as_dict(self) -> dict:
"""Serializes the SecretMetadata into a dictionary suitable for use as a JSON request body."""
body = {}
if self.key is not None:
body["key"] = self.key
if self.last_updated_timestamp is not None:
body["last_updated_timestamp"] = self.last_updated_timestamp
return body
def as_shallow_dict(self) -> dict:
"""Serializes the SecretMetadata into a shallow dictionary of its immediate attributes."""
body = {}
if self.key is not None:
body["key"] = self.key
if self.last_updated_timestamp is not None:
body["last_updated_timestamp"] = self.last_updated_timestamp
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> SecretMetadata:
"""Deserializes the SecretMetadata from a dictionary."""
return cls(key=d.get("key", None), last_updated_timestamp=d.get("last_updated_timestamp", None))
@dataclass
class SecretScope:
"""An organizational resource for storing secrets. Secret scopes can be different types
(Databricks-managed, Azure KeyVault backed, etc), and ACLs can be applied to control permissions
for all secrets within a scope."""
backend_type: Optional[ScopeBackendType] = None
"""The type of secret scope backend."""
keyvault_metadata: Optional[AzureKeyVaultSecretScopeMetadata] = None
"""The metadata for the secret scope if the type is ``AZURE_KEYVAULT``"""
name: Optional[str] = None
"""A unique name to identify the secret scope."""
def as_dict(self) -> dict:
"""Serializes the SecretScope into a dictionary suitable for use as a JSON request body."""
body = {}
if self.backend_type is not None:
body["backend_type"] = self.backend_type.value
if self.keyvault_metadata:
body["keyvault_metadata"] = self.keyvault_metadata.as_dict()
if self.name is not None:
body["name"] = self.name
return body
def as_shallow_dict(self) -> dict:
"""Serializes the SecretScope into a shallow dictionary of its immediate attributes."""
body = {}
if self.backend_type is not None:
body["backend_type"] = self.backend_type
if self.keyvault_metadata:
body["keyvault_metadata"] = self.keyvault_metadata
if self.name is not None:
body["name"] = self.name
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> SecretScope:
"""Deserializes the SecretScope from a dictionary."""
return cls(
backend_type=_enum(d, "backend_type", ScopeBackendType),
keyvault_metadata=_from_dict(d, "keyvault_metadata", AzureKeyVaultSecretScopeMetadata),
name=d.get("name", None),
)
@dataclass
class SparseCheckout:
"""Sparse checkout configuration, it contains options like cone patterns."""
patterns: Optional[List[str]] = None
"""List of sparse checkout cone patterns, see [cone mode handling] for details.
[cone mode handling]: https://git-scm.com/docs/git-sparse-checkout#_internalscone_mode_handling"""
def as_dict(self) -> dict:
"""Serializes the SparseCheckout into a dictionary suitable for use as a JSON request body."""
body = {}
if self.patterns:
body["patterns"] = [v for v in self.patterns]
return body
def as_shallow_dict(self) -> dict:
"""Serializes the SparseCheckout into a shallow dictionary of its immediate attributes."""
body = {}
if self.patterns:
body["patterns"] = self.patterns
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> SparseCheckout:
"""Deserializes the SparseCheckout from a dictionary."""
return cls(patterns=d.get("patterns", None))
@dataclass
class SparseCheckoutUpdate:
"""Sparse checkout configuration, it contains options like cone patterns."""
patterns: Optional[List[str]] = None
"""List of sparse checkout cone patterns, see [cone mode handling] for details.
[cone mode handling]: https://git-scm.com/docs/git-sparse-checkout#_internalscone_mode_handling"""
def as_dict(self) -> dict:
"""Serializes the SparseCheckoutUpdate into a dictionary suitable for use as a JSON request body."""
body = {}
if self.patterns:
body["patterns"] = [v for v in self.patterns]
return body
def as_shallow_dict(self) -> dict:
"""Serializes the SparseCheckoutUpdate into a shallow dictionary of its immediate attributes."""
body = {}
if self.patterns:
body["patterns"] = self.patterns
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> SparseCheckoutUpdate:
"""Deserializes the SparseCheckoutUpdate from a dictionary."""
return cls(patterns=d.get("patterns", None))
@dataclass
class UpdateCredentialsResponse:
def as_dict(self) -> dict:
"""Serializes the UpdateCredentialsResponse into a dictionary suitable for use as a JSON request body."""
body = {}
return body
def as_shallow_dict(self) -> dict:
"""Serializes the UpdateCredentialsResponse into a shallow dictionary of its immediate attributes."""
body = {}
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> UpdateCredentialsResponse:
"""Deserializes the UpdateCredentialsResponse from a dictionary."""
return cls()
@dataclass
class UpdateRepoResponse:
def as_dict(self) -> dict:
"""Serializes the UpdateRepoResponse into a dictionary suitable for use as a JSON request body."""
body = {}
return body
def as_shallow_dict(self) -> dict:
"""Serializes the UpdateRepoResponse into a shallow dictionary of its immediate attributes."""
body = {}
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> UpdateRepoResponse:
"""Deserializes the UpdateRepoResponse from a dictionary."""
return cls()
@dataclass
class WorkspaceObjectAccessControlRequest:
group_name: Optional[str] = None
"""name of the group"""
permission_level: Optional[WorkspaceObjectPermissionLevel] = None
service_principal_name: Optional[str] = None
"""application ID of a service principal"""
user_name: Optional[str] = None
"""name of the user"""
def as_dict(self) -> dict:
"""Serializes the WorkspaceObjectAccessControlRequest 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.service_principal_name is not None:
body["service_principal_name"] = self.service_principal_name
if self.user_name is not None:
body["user_name"] = self.user_name
return body
def as_shallow_dict(self) -> dict:
"""Serializes the WorkspaceObjectAccessControlRequest 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.service_principal_name is not None:
body["service_principal_name"] = self.service_principal_name
if self.user_name is not None:
body["user_name"] = self.user_name
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> WorkspaceObjectAccessControlRequest:
"""Deserializes the WorkspaceObjectAccessControlRequest from a dictionary."""
return cls(
group_name=d.get("group_name", None),
permission_level=_enum(d, "permission_level", WorkspaceObjectPermissionLevel),
service_principal_name=d.get("service_principal_name", None),
user_name=d.get("user_name", None),
)
@dataclass
class WorkspaceObjectAccessControlResponse:
all_permissions: Optional[List[WorkspaceObjectPermission]] = None
"""All permissions."""
display_name: Optional[str] = None
"""Display name of the user or service principal."""
group_name: Optional[str] = None
"""name of the group"""
service_principal_name: Optional[str] = None
"""Name of the service principal."""
user_name: Optional[str] = None
"""name of the user"""
def as_dict(self) -> dict:
"""Serializes the WorkspaceObjectAccessControlResponse 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.service_principal_name is not None:
body["service_principal_name"] = self.service_principal_name
if self.user_name is not None:
body["user_name"] = self.user_name
return body
def as_shallow_dict(self) -> dict:
"""Serializes the WorkspaceObjectAccessControlResponse 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.service_principal_name is not None:
body["service_principal_name"] = self.service_principal_name
if self.user_name is not None:
body["user_name"] = self.user_name
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> WorkspaceObjectAccessControlResponse:
"""Deserializes the WorkspaceObjectAccessControlResponse from a dictionary."""
return cls(
all_permissions=_repeated_dict(d, "all_permissions", WorkspaceObjectPermission),
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
class WorkspaceObjectPermission:
inherited: Optional[bool] = None
inherited_from_object: Optional[List[str]] = None
permission_level: Optional[WorkspaceObjectPermissionLevel] = None
def as_dict(self) -> dict:
"""Serializes the WorkspaceObjectPermission 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
return body
def as_shallow_dict(self) -> dict:
"""Serializes the WorkspaceObjectPermission 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
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> WorkspaceObjectPermission:
"""Deserializes the WorkspaceObjectPermission 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", WorkspaceObjectPermissionLevel),
)
class WorkspaceObjectPermissionLevel(Enum):
"""Permission level"""
CAN_EDIT = "CAN_EDIT"
CAN_MANAGE = "CAN_MANAGE"
CAN_READ = "CAN_READ"
CAN_RUN = "CAN_RUN"
@dataclass
class WorkspaceObjectPermissions:
access_control_list: Optional[List[WorkspaceObjectAccessControlResponse]] = None
object_id: Optional[str] = None
object_type: Optional[str] = None
def as_dict(self) -> dict:
"""Serializes the WorkspaceObjectPermissions 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
return body
def as_shallow_dict(self) -> dict:
"""Serializes the WorkspaceObjectPermissions 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
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> WorkspaceObjectPermissions:
"""Deserializes the WorkspaceObjectPermissions from a dictionary."""
return cls(
access_control_list=_repeated_dict(d, "access_control_list", WorkspaceObjectAccessControlResponse),
object_id=d.get("object_id", None),
object_type=d.get("object_type", None),
)
@dataclass
class WorkspaceObjectPermissionsDescription:
description: Optional[str] = None
permission_level: Optional[WorkspaceObjectPermissionLevel] = None
def as_dict(self) -> dict:
"""Serializes the WorkspaceObjectPermissionsDescription 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
return body
def as_shallow_dict(self) -> dict:
"""Serializes the WorkspaceObjectPermissionsDescription 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
return body
@classmethod
def from_dict(cls, d: Dict[str, Any]) -> WorkspaceObjectPermissionsDescription:
"""Deserializes the WorkspaceObjectPermissionsDescription from a dictionary."""
return cls(
description=d.get("description", None),
permission_level=_enum(d, "permission_level", WorkspaceObjectPermissionLevel),
)
class GitCredentialsAPI:
"""Registers personal access token for Databricks to do operations on behalf of the user.
See [more info].
[more info]: https://docs.databricks.com/repos/get-access-tokens-from-git-provider.html"""
def __init__(self, api_client):
self._api = api_client
def create(
self,
git_provider: str,
*,
git_email: Optional[str] = None,
git_username: Optional[str] = None,
is_default_for_provider: Optional[bool] = None,
name: Optional[str] = None,
personal_access_token: Optional[str] = None,
principal_id: Optional[int] = None,
) -> CreateCredentialsResponse:
"""Creates a Git credential entry for the user. Use the PATCH endpoint to update existing credentials, or
the DELETE endpoint to delete existing credentials.
:param git_provider: str
Git provider. This field is case-insensitive. The available Git providers are `gitHub`,
`bitbucketCloud`, `gitLab`, `azureDevOpsServices`, `gitHubEnterprise`, `bitbucketServer`,
`gitLabEnterpriseEdition` and `awsCodeCommit`.
:param git_email: str (optional)
The authenticating email associated with your Git provider user account. Used for authentication
with the remote repository and also sets the author & committer identity for commits. Required for
most Git providers except AWS CodeCommit. Learn more at
https://docs.databricks.com/aws/en/repos/get-access-tokens-from-git-provider
:param git_username: str (optional)
The username provided with your Git provider account and associated with the credential. For most
Git providers it is only used to set the Git committer & author names for commits, however it may be
required for authentication depending on your Git provider / token requirements. Required for AWS
CodeCommit.
:param is_default_for_provider: bool (optional)
if the credential is the default for the given provider
:param name: str (optional)
the name of the git credential, used for identification and ease of lookup
:param personal_access_token: str (optional)
The personal access token used to authenticate to the corresponding Git provider. For certain
providers, support may exist for other types of scoped access tokens. [Learn more].
[Learn more]: https://docs.databricks.com/repos/get-access-tokens-from-git-provider.html
:param principal_id: int (optional)
The ID of the service principal whose credentials will be modified. Only service principal managers
can perform this action.
:returns: :class:`CreateCredentialsResponse`
"""
body = {}
if git_email is not None:
body["git_email"] = git_email
if git_provider is not None:
body["git_provider"] = git_provider
if git_username is not None:
body["git_username"] = git_username
if is_default_for_provider is not None:
body["is_default_for_provider"] = is_default_for_provider
if name is not None:
body["name"] = name
if personal_access_token is not None:
body["personal_access_token"] = personal_access_token
if principal_id is not None:
body["principal_id"] = principal_id
headers = {
"Accept": "application/json",
"Content-Type": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
res = self._api.do("POST", "/api/2.0/git-credentials", body=body, headers=headers)
return CreateCredentialsResponse.from_dict(res)
def delete(self, credential_id: int, *, principal_id: Optional[int] = None):
"""Deletes the specified Git credential.
:param credential_id: int
The ID for the corresponding credential to access.
:param principal_id: int (optional)
The ID of the service principal whose credentials will be modified. Only service principal managers
can perform this action.
"""
query = {}
if principal_id is not None:
query["principal_id"] = principal_id
headers = {
"Accept": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
self._api.do("DELETE", f"/api/2.0/git-credentials/{credential_id}", query=query, headers=headers)
def get(self, credential_id: int, *, principal_id: Optional[int] = None) -> GetCredentialsResponse:
"""Gets the Git credential with the specified credential ID.
:param credential_id: int
The ID for the corresponding credential to access.
:param principal_id: int (optional)
The ID of the service principal whose credentials will be modified. Only service principal managers
can perform this action.
:returns: :class:`GetCredentialsResponse`
"""
query = {}
if principal_id is not None:
query["principal_id"] = principal_id
headers = {
"Accept": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
res = self._api.do("GET", f"/api/2.0/git-credentials/{credential_id}", query=query, headers=headers)
return GetCredentialsResponse.from_dict(res)
def list(self, *, principal_id: Optional[int] = None) -> Iterator[CredentialInfo]:
"""Lists the calling user's Git credentials.
:param principal_id: int (optional)
The ID of the service principal whose credentials will be listed. Only service principal managers
can perform this action.
:returns: Iterator over :class:`CredentialInfo`
"""
query = {}
if principal_id is not None:
query["principal_id"] = principal_id
headers = {
"Accept": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
json = self._api.do("GET", "/api/2.0/git-credentials", query=query, headers=headers)
parsed = ListCredentialsResponse.from_dict(json).credentials
return parsed if parsed is not None else []
def update(
self,
credential_id: int,
git_provider: str,
*,
git_email: Optional[str] = None,
git_username: Optional[str] = None,
is_default_for_provider: Optional[bool] = None,
name: Optional[str] = None,
personal_access_token: Optional[str] = None,
principal_id: Optional[int] = None,
):
"""Updates the specified Git credential.
:param credential_id: int
The ID for the corresponding credential to access.
:param git_provider: str
Git provider. This field is case-insensitive. The available Git providers are `gitHub`,
`bitbucketCloud`, `gitLab`, `azureDevOpsServices`, `gitHubEnterprise`, `bitbucketServer`,
`gitLabEnterpriseEdition` and `awsCodeCommit`.
:param git_email: str (optional)
The authenticating email associated with your Git provider user account. Used for authentication
with the remote repository and also sets the author & committer identity for commits. Required for
most Git providers except AWS CodeCommit. Learn more at
https://docs.databricks.com/aws/en/repos/get-access-tokens-from-git-provider
:param git_username: str (optional)
The username provided with your Git provider account and associated with the credential. For most
Git providers it is only used to set the Git committer & author names for commits, however it may be
required for authentication depending on your Git provider / token requirements. Required for AWS
CodeCommit.
:param is_default_for_provider: bool (optional)
if the credential is the default for the given provider
:param name: str (optional)
the name of the git credential, used for identification and ease of lookup
:param personal_access_token: str (optional)
The personal access token used to authenticate to the corresponding Git provider. For certain
providers, support may exist for other types of scoped access tokens. [Learn more].
[Learn more]: https://docs.databricks.com/repos/get-access-tokens-from-git-provider.html
:param principal_id: int (optional)
The ID of the service principal whose credentials will be modified. Only service principal managers
can perform this action.
"""
body = {}
if git_email is not None:
body["git_email"] = git_email
if git_provider is not None:
body["git_provider"] = git_provider
if git_username is not None:
body["git_username"] = git_username
if is_default_for_provider is not None:
body["is_default_for_provider"] = is_default_for_provider
if name is not None:
body["name"] = name
if personal_access_token is not None:
body["personal_access_token"] = personal_access_token
if principal_id is not None:
body["principal_id"] = principal_id
headers = {
"Accept": "application/json",
"Content-Type": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
self._api.do("PATCH", f"/api/2.0/git-credentials/{credential_id}", body=body, headers=headers)
class ReposAPI:
"""The Repos API allows users to manage their git repos. Users can use the API to access all repos that they
have manage permissions on.
Databricks Repos is a visual Git client in Databricks. It supports common Git operations such a cloning a
repository, committing and pushing, pulling, branch management, and visual comparison of diffs when
committing.
Within Repos you can develop code in notebooks or other files and follow data science and engineering code
development best practices using Git for version control, collaboration, and CI/CD."""
def __init__(self, api_client):
self._api = api_client
def create(
self, url: str, provider: str, *, path: Optional[str] = None, sparse_checkout: Optional[SparseCheckout] = None
) -> CreateRepoResponse:
"""Creates a repo in the workspace and links it to the remote Git repo specified. Note that repos created
programmatically must be linked to a remote Git repo, unlike repos created in the browser.
:param url: str
URL of the Git repository to be linked.
:param provider: str
Git provider. This field is case-insensitive. The available Git providers are `gitHub`,
`bitbucketCloud`, `gitLab`, `azureDevOpsServices`, `gitHubEnterprise`, `bitbucketServer`,
`gitLabEnterpriseEdition` and `awsCodeCommit`.
:param path: str (optional)
Desired path for the repo in the workspace. Almost any path in the workspace can be chosen. If repo
is created in `/Repos`, path must be in the format `/Repos/{folder}/{repo-name}`.
:param sparse_checkout: :class:`SparseCheckout` (optional)
If specified, the repo will be created with sparse checkout enabled. You cannot enable/disable
sparse checkout after the repo is created.
:returns: :class:`CreateRepoResponse`
"""
body = {}
if path is not None:
body["path"] = path
if provider is not None:
body["provider"] = provider
if sparse_checkout is not None:
body["sparse_checkout"] = sparse_checkout.as_dict()
if url is not None:
body["url"] = url
headers = {
"Accept": "application/json",
"Content-Type": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
res = self._api.do("POST", "/api/2.0/repos", body=body, headers=headers)
return CreateRepoResponse.from_dict(res)
def delete(self, repo_id: int):
"""Deletes the specified repo.
:param repo_id: int
The ID for the corresponding repo to delete.
"""
headers = {
"Accept": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
self._api.do("DELETE", f"/api/2.0/repos/{repo_id}", headers=headers)
def get(self, repo_id: int) -> GetRepoResponse:
"""Returns the repo with the given repo ID.
:param repo_id: int
ID of the Git folder (repo) object in the workspace.
:returns: :class:`GetRepoResponse`
"""
headers = {
"Accept": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
res = self._api.do("GET", f"/api/2.0/repos/{repo_id}", headers=headers)
return GetRepoResponse.from_dict(res)
def get_permission_levels(self, repo_id: str) -> GetRepoPermissionLevelsResponse:
"""Gets the permission levels that a user can have on an object.
:param repo_id: str
The repo for which to get or manage permissions.
:returns: :class:`GetRepoPermissionLevelsResponse`
"""
headers = {
"Accept": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
res = self._api.do("GET", f"/api/2.0/permissions/repos/{repo_id}/permissionLevels", headers=headers)
return GetRepoPermissionLevelsResponse.from_dict(res)
def get_permissions(self, repo_id: str) -> RepoPermissions:
"""Gets the permissions of a repo. Repos can inherit permissions from their root object.
:param repo_id: str
The repo for which to get or manage permissions.
:returns: :class:`RepoPermissions`
"""
headers = {
"Accept": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
res = self._api.do("GET", f"/api/2.0/permissions/repos/{repo_id}", headers=headers)
return RepoPermissions.from_dict(res)
def list(self, *, next_page_token: Optional[str] = None, path_prefix: Optional[str] = None) -> Iterator[RepoInfo]:
"""Returns repos that the calling user has Manage permissions on. Use `next_page_token` to iterate
through additional pages.
:param next_page_token: str (optional)
Token used to get the next page of results. If not specified, returns the first page of results as
well as a next page token if there are more results.
:param path_prefix: str (optional)
Filters repos that have paths starting with the given path prefix. If not provided or when provided
an effectively empty prefix (`/` or `/Workspace`) Git folders (repos) from `/Workspace/Repos` will
be served.
:returns: Iterator over :class:`RepoInfo`
"""
query = {}
if next_page_token is not None:
query["next_page_token"] = next_page_token
if path_prefix is not None:
query["path_prefix"] = path_prefix
headers = {
"Accept": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
while True:
json = self._api.do("GET", "/api/2.0/repos", query=query, headers=headers)
if "repos" in json:
for v in json["repos"]:
yield RepoInfo.from_dict(v)
if "next_page_token" not in json or not json["next_page_token"]:
return
query["next_page_token"] = json["next_page_token"]
def set_permissions(
self, repo_id: str, *, access_control_list: Optional[List[RepoAccessControlRequest]] = None
) -> RepoPermissions:
"""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 repo_id: str
The repo for which to get or manage permissions.
:param access_control_list: List[:class:`RepoAccessControlRequest`] (optional)
:returns: :class:`RepoPermissions`
"""
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",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
res = self._api.do("PUT", f"/api/2.0/permissions/repos/{repo_id}", body=body, headers=headers)
return RepoPermissions.from_dict(res)
def update(
self,
repo_id: int,
*,
branch: Optional[str] = None,
sparse_checkout: Optional[SparseCheckoutUpdate] = None,
tag: Optional[str] = None,
):
"""Updates the repo to a different branch or tag, or updates the repo to the latest commit on the same
branch.
:param repo_id: int
ID of the Git folder (repo) object in the workspace.
:param branch: str (optional)
Branch that the local version of the repo is checked out to.
:param sparse_checkout: :class:`SparseCheckoutUpdate` (optional)
If specified, update the sparse checkout settings. The update will fail if sparse checkout is not
enabled for the repo.
:param tag: str (optional)
Tag that the local version of the repo is checked out to. Updating the repo to a tag puts the repo
in a detached HEAD state. Before committing new changes, you must update the repo to a branch
instead of the detached HEAD.
"""
body = {}
if branch is not None:
body["branch"] = branch
if sparse_checkout is not None:
body["sparse_checkout"] = sparse_checkout.as_dict()
if tag is not None:
body["tag"] = tag
headers = {
"Accept": "application/json",
"Content-Type": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
self._api.do("PATCH", f"/api/2.0/repos/{repo_id}", body=body, headers=headers)
def update_permissions(
self, repo_id: str, *, access_control_list: Optional[List[RepoAccessControlRequest]] = None
) -> RepoPermissions:
"""Updates the permissions on a repo. Repos can inherit permissions from their root object.
:param repo_id: str
The repo for which to get or manage permissions.
:param access_control_list: List[:class:`RepoAccessControlRequest`] (optional)
:returns: :class:`RepoPermissions`
"""
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",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
res = self._api.do("PATCH", f"/api/2.0/permissions/repos/{repo_id}", body=body, headers=headers)
return RepoPermissions.from_dict(res)
class SecretsAPI:
"""The Secrets API allows you to manage secrets, secret scopes, and access permissions.
Sometimes accessing data requires that you authenticate to external data sources through JDBC. Instead of
directly entering your credentials into a notebook, use Databricks secrets to store your credentials and
reference them in notebooks and jobs.
Administrators, secret creators, and users granted permission can read Databricks secrets. While
Databricks makes an effort to redact secret values that might be displayed in notebooks, it is not
possible to prevent such users from reading secrets."""
def __init__(self, api_client):
self._api = api_client
def create_scope(
self,
scope: str,
*,
backend_azure_keyvault: Optional[AzureKeyVaultSecretScopeMetadata] = None,
initial_manage_principal: Optional[str] = None,
scope_backend_type: Optional[ScopeBackendType] = None,
):
"""Creates a new secret scope.
The scope name must consist of alphanumeric characters, dashes, underscores, and periods, and may not
exceed 128 characters.
Example request:
.. code::
{ "scope": "my-simple-databricks-scope", "initial_manage_principal": "users" "scope_backend_type":
"databricks|azure_keyvault", # below is only required if scope type is azure_keyvault
"backend_azure_keyvault": { "resource_id":
"/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/xxxx/providers/Microsoft.KeyVault/vaults/xxxx",
"tenant_id": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", "dns_name": "https://xxxx.vault.azure.net/", } }
If ``initial_manage_principal`` is specified, the initial ACL applied to the scope is applied to the
supplied principal (user or group) with ``MANAGE`` permissions. The only supported principal for this
option is the group ``users``, which contains all users in the workspace. If
``initial_manage_principal`` is not specified, the initial ACL with ``MANAGE`` permission applied to
the scope is assigned to the API request issuer's user identity.
If ``scope_backend_type`` is ``azure_keyvault``, a secret scope is created with secrets from a given
Azure KeyVault. The caller must provide the keyvault_resource_id and the tenant_id for the key vault.
If ``scope_backend_type`` is ``databricks`` or is unspecified, an empty secret scope is created and
stored in Databricks's own storage.
Throws ``RESOURCE_ALREADY_EXISTS`` if a scope with the given name already exists. Throws
``RESOURCE_LIMIT_EXCEEDED`` if maximum number of scopes in the workspace is exceeded. Throws
``INVALID_PARAMETER_VALUE`` if the scope name is invalid. Throws ``BAD_REQUEST`` if request violated
constraints. Throws ``CUSTOMER_UNAUTHORIZED`` if normal user attempts to create a scope with name
reserved for databricks internal usage. Throws ``UNAUTHENTICATED`` if unable to verify user access
permission on Azure KeyVault
:param scope: str
Scope name requested by the user. Scope names are unique.
:param backend_azure_keyvault: :class:`AzureKeyVaultSecretScopeMetadata` (optional)
The metadata for the secret scope if the type is ``AZURE_KEYVAULT``
:param initial_manage_principal: str (optional)
The principal that is initially granted ``MANAGE`` permission to the created scope.
:param scope_backend_type: :class:`ScopeBackendType` (optional)
The backend type the scope will be created with. If not specified, will default to ``DATABRICKS``
"""
body = {}
if backend_azure_keyvault is not None:
body["backend_azure_keyvault"] = backend_azure_keyvault.as_dict()
if initial_manage_principal is not None:
body["initial_manage_principal"] = initial_manage_principal
if scope is not None:
body["scope"] = scope
if scope_backend_type is not None:
body["scope_backend_type"] = scope_backend_type.value
headers = {
"Content-Type": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
self._api.do("POST", "/api/2.0/secrets/scopes/create", body=body, headers=headers)
def delete_acl(self, scope: str, principal: str):
"""Deletes the given ACL on the given scope.
Users must have the ``MANAGE`` permission to invoke this API.
Example request:
.. code::
{ "scope": "my-secret-scope", "principal": "data-scientists" }
Throws ``RESOURCE_DOES_NOT_EXIST`` if no such secret scope, principal, or ACL exists. Throws
``PERMISSION_DENIED`` if the user does not have permission to make this API call. Throws
``INVALID_PARAMETER_VALUE`` if the permission or principal is invalid.
:param scope: str
The name of the scope to remove permissions from.
:param principal: str
The principal to remove an existing ACL from.
"""
body = {}
if principal is not None:
body["principal"] = principal
if scope is not None:
body["scope"] = scope
headers = {
"Content-Type": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
self._api.do("POST", "/api/2.0/secrets/acls/delete", body=body, headers=headers)
def delete_scope(self, scope: str):
"""Deletes a secret scope.
Example request:
.. code::
{ "scope": "my-secret-scope" }
Throws ``RESOURCE_DOES_NOT_EXIST`` if the scope does not exist. Throws ``PERMISSION_DENIED`` if the
user does not have permission to make this API call. Throws ``BAD_REQUEST`` if system user attempts to
delete internal secret scope.
:param scope: str
Name of the scope to delete.
"""
body = {}
if scope is not None:
body["scope"] = scope
headers = {
"Content-Type": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
self._api.do("POST", "/api/2.0/secrets/scopes/delete", body=body, headers=headers)
def delete_secret(self, scope: str, key: str):
"""Deletes the secret stored in this secret scope. You must have ``WRITE`` or ``MANAGE`` permission on
the Secret Scope.
Example request:
.. code::
{ "scope": "my-secret-scope", "key": "my-secret-key" }
Throws ``RESOURCE_DOES_NOT_EXIST`` if no such secret scope or secret exists. Throws
``PERMISSION_DENIED`` if the user does not have permission to make this API call. Throws
``BAD_REQUEST`` if system user attempts to delete an internal secret, or request is made against Azure
KeyVault backed scope.
:param scope: str
The name of the scope that contains the secret to delete.
:param key: str
Name of the secret to delete.
"""
body = {}
if key is not None:
body["key"] = key
if scope is not None:
body["scope"] = scope
headers = {
"Accept": "application/json",
"Content-Type": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
self._api.do("POST", "/api/2.0/secrets/delete", body=body, headers=headers)
def get_acl(self, scope: str, principal: str) -> AclItem:
"""Describes the details about the given ACL, such as the group and permission.
Users must have the ``MANAGE`` permission to invoke this API.
Example response:
.. code::
{ "principal": "data-scientists", "permission": "READ" }
Throws ``RESOURCE_DOES_NOT_EXIST`` if no such secret scope exists. Throws ``PERMISSION_DENIED`` if the
user does not have permission to make this API call. Throws ``INVALID_PARAMETER_VALUE`` if the
permission or principal is invalid.
:param scope: str
The name of the scope to fetch ACL information from.
:param principal: str
The principal to fetch ACL information for.
:returns: :class:`AclItem`
"""
query = {}
if principal is not None:
query["principal"] = principal
if scope is not None:
query["scope"] = scope
headers = {
"Accept": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
res = self._api.do("GET", "/api/2.0/secrets/acls/get", query=query, headers=headers)
return AclItem.from_dict(res)
def get_secret(self, scope: str, key: str) -> GetSecretResponse:
"""Gets a secret for a given key and scope. This API can only be called from the DBUtils interface. Users
need the READ permission to make this call.
Example response:
.. code::
{ "key": "my-string-key", "value": <bytes of the secret value> }
Note that the secret value returned is in bytes. The interpretation of the bytes is determined by the
caller in DBUtils and the type the data is decoded into.
Throws ``RESOURCE_DOES_NOT_EXIST`` if no such secret or secret scope exists. Throws
``PERMISSION_DENIED`` if the user does not have permission to make this API call.
Note: This is explicitly an undocumented API. It also doesn't need to be supported for the /preview
prefix, because it's not a customer-facing API (i.e. only used for DBUtils SecretUtils to fetch
secrets).
Throws ``RESOURCE_DOES_NOT_EXIST`` if no such secret scope or secret exists. Throws ``BAD_REQUEST`` if
normal user calls get secret outside of a notebook. AKV specific errors: Throws
``INVALID_PARAMETER_VALUE`` if secret name is not alphanumeric or too long. Throws
``PERMISSION_DENIED`` if secret manager cannot access AKV with 403 error Throws ``MALFORMED_REQUEST``
if secret manager cannot access AKV with any other 4xx error
:param scope: str
The name of the scope that contains the secret.
:param key: str
Name of the secret to fetch value information.
:returns: :class:`GetSecretResponse`
"""
query = {}
if key is not None:
query["key"] = key
if scope is not None:
query["scope"] = scope
headers = {
"Accept": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
res = self._api.do("GET", "/api/2.0/secrets/get", query=query, headers=headers)
return GetSecretResponse.from_dict(res)
def list_acls(self, scope: str) -> Iterator[AclItem]:
"""Lists the ACLs set on the given scope.
Users must have the ``MANAGE`` permission to invoke this API.
Example response:
.. code::
{ "acls": [{ "principal": "admins", "permission": "MANAGE" },{ "principal": "data-scientists",
"permission": "READ" }] }
Throws ``RESOURCE_DOES_NOT_EXIST`` if no such secret scope exists. Throws ``PERMISSION_DENIED`` if the
user does not have permission to make this API call.
:param scope: str
The name of the scope to fetch ACL information from.
:returns: Iterator over :class:`AclItem`
"""
query = {}
if scope is not None:
query["scope"] = scope
headers = {
"Accept": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
json = self._api.do("GET", "/api/2.0/secrets/acls/list", query=query, headers=headers)
parsed = ListAclsResponse.from_dict(json).items
return parsed if parsed is not None else []
def list_scopes(self) -> Iterator[SecretScope]:
"""Lists all secret scopes available in the workspace.
Example response:
.. code::
{ "scopes": [{ "name": "my-databricks-scope", "backend_type": "DATABRICKS" },{ "name": "mount-points",
"backend_type": "DATABRICKS" }] }
Throws ``PERMISSION_DENIED`` if the user does not have permission to make this API call.
:returns: Iterator over :class:`SecretScope`
"""
headers = {
"Accept": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
json = self._api.do("GET", "/api/2.0/secrets/scopes/list", headers=headers)
parsed = ListScopesResponse.from_dict(json).scopes
return parsed if parsed is not None else []
def list_secrets(self, scope: str) -> Iterator[SecretMetadata]:
"""Lists the secret keys that are stored at this scope. This is a metadata-only operation; secret data
cannot be retrieved using this API. Users need the READ permission to make this call.
Example response:
.. code::
{ "secrets": [ { "key": "my-string-key"", "last_updated_timestamp": "1520467595000" }, { "key":
"my-byte-key", "last_updated_timestamp": "1520467595000" }, ] }
The lastUpdatedTimestamp returned is in milliseconds since epoch.
Throws ``RESOURCE_DOES_NOT_EXIST`` if no such secret scope exists. Throws ``PERMISSION_DENIED`` if the
user does not have permission to make this API call.
:param scope: str
The name of the scope to list secrets within.
:returns: Iterator over :class:`SecretMetadata`
"""
query = {}
if scope is not None:
query["scope"] = scope
headers = {
"Accept": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
json = self._api.do("GET", "/api/2.0/secrets/list", query=query, headers=headers)
parsed = ListSecretsResponse.from_dict(json).secrets
return parsed if parsed is not None else []
def put_acl(self, scope: str, principal: str, permission: AclPermission):
"""Creates or overwrites the ACL associated with the given principal (user or group) on the specified
scope point. In general, a user or group will use the most powerful permission available to them, and
permissions are ordered as follows:
* ``MANAGE`` - Allowed to change ACLs, and read and write to this secret scope. * ``WRITE`` - Allowed
to read and write to this secret scope. * ``READ`` - Allowed to read this secret scope and list what
secrets are available.
Note that in general, secret values can only be read from within a command on a cluster (for example,
through a notebook). There is no API to read the actual secret value material outside of a cluster.
However, the user's permission will be applied based on who is executing the command, and they must
have at least READ permission.
Users must have the ``MANAGE`` permission to invoke this API.
Example request:
.. code::
{ "scope": "my-secret-scope", "principal": "data-scientists", "permission": "READ" }
The principal is a user or group name corresponding to an existing Databricks principal to be granted
or revoked access.
Throws ``RESOURCE_DOES_NOT_EXIST`` if no such secret scope exists. Throws ``RESOURCE_ALREADY_EXISTS``
if a permission for the principal already exists. Throws ``INVALID_PARAMETER_VALUE`` if the permission
or principal is invalid. Throws ``PERMISSION_DENIED`` if the user does not have permission to make
this API call.
:param scope: str
The name of the scope to apply permissions to.
:param principal: str
The principal in which the permission is applied.
:param permission: :class:`AclPermission`
The permission level applied to the principal.
"""
body = {}
if permission is not None:
body["permission"] = permission.value
if principal is not None:
body["principal"] = principal
if scope is not None:
body["scope"] = scope
headers = {
"Content-Type": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
self._api.do("POST", "/api/2.0/secrets/acls/put", body=body, headers=headers)
def put_secret(
self, scope: str, key: str, *, bytes_value: Optional[str] = None, string_value: Optional[str] = None
):
"""Inserts a secret under the provided scope with the given name. If a secret already exists with the
same name, this command overwrites the existing secret's value. The server encrypts the secret using
the secret scope's encryption settings before storing it. You must have ``WRITE`` or ``MANAGE``
permission on the secret scope.
The secret key must consist of alphanumeric characters, dashes, underscores, and periods, and cannot
exceed 128 characters. The maximum allowed secret value size is 128 KB. The maximum number of secrets
in a given scope is 1000.
Example request:
.. code::
{ "scope": "my-databricks-scope", "key": "my-string-key", "string_value": "foobar" }
The input fields "string_value" or "bytes_value" specify the type of the secret, which will determine
the value returned when the secret value is requested. Exactly one must be specified.
Throws ``RESOURCE_DOES_NOT_EXIST`` if no such secret scope exists. Throws ``RESOURCE_LIMIT_EXCEEDED``
if maximum number of secrets in scope is exceeded. Throws ``INVALID_PARAMETER_VALUE`` if the request
parameters are invalid. Throws ``PERMISSION_DENIED`` if the user does not have permission to make this
API call. Throws ``MALFORMED_REQUEST`` if request is incorrectly formatted or conflicting. Throws
``BAD_REQUEST`` if request is made against Azure KeyVault backed scope.
:param scope: str
The name of the scope to which the secret will be associated with.
:param key: str
A unique name to identify the secret.
:param bytes_value: str (optional)
If specified, value will be stored as bytes.
:param string_value: str (optional)
If specified, note that the value will be stored in UTF-8 (MB4) form.
"""
body = {}
if bytes_value is not None:
body["bytes_value"] = bytes_value
if key is not None:
body["key"] = key
if scope is not None:
body["scope"] = scope
if string_value is not None:
body["string_value"] = string_value
headers = {
"Content-Type": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
self._api.do("POST", "/api/2.0/secrets/put", body=body, headers=headers)
class WorkspaceAPI:
"""The Workspace API allows you to list, import, export, and delete notebooks and folders.
A notebook is a web-based interface to a document that contains runnable code, visualizations, and
explanatory text."""
def __init__(self, api_client):
self._api = api_client
def delete(self, path: str, *, recursive: Optional[bool] = None):
"""Deletes an object or a directory (and optionally recursively deletes all objects in the directory). *
If `path` does not exist, this call returns an error `RESOURCE_DOES_NOT_EXIST`. * If `path` is a
non-empty directory and `recursive` is set to `false`, this call returns an error
`DIRECTORY_NOT_EMPTY`.
Object deletion cannot be undone and deleting a directory recursively is not atomic.
:param path: str
The absolute path of the notebook or directory.
:param recursive: bool (optional)
The flag that specifies whether to delete the object recursively. It is `false` by default. Please
note this deleting directory is not atomic. If it fails in the middle, some of objects under this
directory may be deleted and cannot be undone.
"""
body = {}
if path is not None:
body["path"] = path
if recursive is not None:
body["recursive"] = recursive
headers = {
"Accept": "application/json",
"Content-Type": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
self._api.do("POST", "/api/2.0/workspace/delete", body=body, headers=headers)
def export(self, path: str, *, format: Optional[ExportFormat] = None) -> ExportResponse:
"""Exports an object or the contents of an entire directory.
If `path` does not exist, this call returns an error `RESOURCE_DOES_NOT_EXIST`.
If the exported data would exceed size limit, this call returns `MAX_NOTEBOOK_SIZE_EXCEEDED`.
Currently, this API does not support exporting a library.
:param path: str
The absolute path of the object or directory. Exporting a directory is only supported for the `DBC`,
`SOURCE`, and `AUTO` format.
:param format: :class:`ExportFormat` (optional)
This specifies the format of the exported file. By default, this is `SOURCE`.
The value is case sensitive.
- `SOURCE`: The notebook is exported as source code. Directory exports will not include non-notebook
entries. - `HTML`: The notebook is exported as an HTML file. - `JUPYTER`: The notebook is exported
as a Jupyter/IPython Notebook file. - `DBC`: The notebook is exported in Databricks archive format.
Directory exports will not include non-notebook entries. - `R_MARKDOWN`: The notebook is exported to
R Markdown format. - `AUTO`: The object or directory is exported depending on the objects type.
Directory exports will include notebooks and workspace files.
:returns: :class:`ExportResponse`
"""
query = {}
if format is not None:
query["format"] = format.value
if path is not None:
query["path"] = path
headers = {
"Accept": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
res = self._api.do("GET", "/api/2.0/workspace/export", query=query, headers=headers)
return ExportResponse.from_dict(res)
def get_permission_levels(
self, workspace_object_type: str, workspace_object_id: str
) -> GetWorkspaceObjectPermissionLevelsResponse:
"""Gets the permission levels that a user can have on an object.
:param workspace_object_type: str
The workspace object type for which to get or manage permissions. Could be one of the following:
alerts, alertsv2, dashboards, dbsql-dashboards, directories, experiments, files, genie, notebooks,
queries
:param workspace_object_id: str
The workspace object for which to get or manage permissions.
:returns: :class:`GetWorkspaceObjectPermissionLevelsResponse`
"""
headers = {
"Accept": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
res = self._api.do(
"GET",
f"/api/2.0/permissions/{workspace_object_type}/{workspace_object_id}/permissionLevels",
headers=headers,
)
return GetWorkspaceObjectPermissionLevelsResponse.from_dict(res)
def get_permissions(self, workspace_object_type: str, workspace_object_id: str) -> WorkspaceObjectPermissions:
"""Gets the permissions of a workspace object. Workspace objects can inherit permissions from their
parent objects or root object.
:param workspace_object_type: str
The workspace object type for which to get or manage permissions. Could be one of the following:
alerts, alertsv2, dashboards, dbsql-dashboards, directories, experiments, files, genie, notebooks,
queries
:param workspace_object_id: str
The workspace object for which to get or manage permissions.
:returns: :class:`WorkspaceObjectPermissions`
"""
headers = {
"Accept": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
res = self._api.do(
"GET", f"/api/2.0/permissions/{workspace_object_type}/{workspace_object_id}", headers=headers
)
return WorkspaceObjectPermissions.from_dict(res)
def get_status(self, path: str) -> ObjectInfo:
"""Gets the status of an object or a directory. If `path` does not exist, this call returns an error
`RESOURCE_DOES_NOT_EXIST`.
:param path: str
The absolute path of the notebook or directory.
:returns: :class:`ObjectInfo`
"""
query = {}
if path is not None:
query["path"] = path
headers = {
"Accept": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
res = self._api.do("GET", "/api/2.0/workspace/get-status", query=query, headers=headers)
return ObjectInfo.from_dict(res)
def import_(
self,
path: str,
*,
content: Optional[str] = None,
format: Optional[ImportFormat] = None,
language: Optional[Language] = None,
overwrite: Optional[bool] = None,
):
"""Imports a workspace object (for example, a notebook or file) or the contents of an entire directory.
If `path` already exists and `overwrite` is set to `false`, this call returns an error
`RESOURCE_ALREADY_EXISTS`. To import a directory, you can use either the `DBC` format or the `SOURCE`
format with the `language` field unset. To import a single file as `SOURCE`, you must set the
`language` field. Zip files within directories are not supported.
:param path: str
The absolute path of the object or directory. Importing a directory is only supported for the `DBC`
and `SOURCE` formats.
:param content: str (optional)
The base64-encoded content. This has a limit of 10 MB.
If the limit (10MB) is exceeded, exception with error code **MAX_NOTEBOOK_SIZE_EXCEEDED** is thrown.
This parameter might be absent, and instead a posted file is used.
:param format: :class:`ImportFormat` (optional)
This specifies the format of the file to be imported.
The value is case sensitive.
- `AUTO`: The item is imported depending on an analysis of the item's extension and the header
content provided in the request. If the item is imported as a notebook, then the item's extension is
automatically removed. - `SOURCE`: The notebook or directory is imported as source code. - `HTML`:
The notebook is imported as an HTML file. - `JUPYTER`: The notebook is imported as a Jupyter/IPython
Notebook file. - `DBC`: The notebook is imported in Databricks archive format. Required for
directories. - `R_MARKDOWN`: The notebook is imported from R Markdown format.
:param language: :class:`Language` (optional)
The language of the object. This value is set only if the object type is `NOTEBOOK`.
:param overwrite: bool (optional)
The flag that specifies whether to overwrite existing object. It is `false` by default. For `DBC`
format, `overwrite` is not supported since it may contain a directory.
"""
body = {}
if content is not None:
body["content"] = content
if format is not None:
body["format"] = format.value
if language is not None:
body["language"] = language.value
if overwrite is not None:
body["overwrite"] = overwrite
if path is not None:
body["path"] = path
headers = {
"Accept": "application/json",
"Content-Type": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
self._api.do("POST", "/api/2.0/workspace/import", body=body, headers=headers)
def list(self, path: str, *, notebooks_modified_after: Optional[int] = None) -> Iterator[ObjectInfo]:
"""Lists the contents of a directory, or the object if it is not a directory. If the input path does not
exist, this call returns an error `RESOURCE_DOES_NOT_EXIST`.
:param path: str
The absolute path of the notebook or directory.
:param notebooks_modified_after: int (optional)
UTC timestamp in milliseconds
:returns: Iterator over :class:`ObjectInfo`
"""
query = {}
if notebooks_modified_after is not None:
query["notebooks_modified_after"] = notebooks_modified_after
if path is not None:
query["path"] = path
headers = {
"Accept": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
json = self._api.do("GET", "/api/2.0/workspace/list", query=query, headers=headers)
parsed = ListResponse.from_dict(json).objects
return parsed if parsed is not None else []
def mkdirs(self, path: str):
"""Creates the specified directory (and necessary parent directories if they do not exist). If there is
an object (not a directory) at any prefix of the input path, this call returns an error
`RESOURCE_ALREADY_EXISTS`.
Note that if this operation fails it may have succeeded in creating some of the necessary parent
directories.
:param path: str
The absolute path of the directory. If the parent directories do not exist, it will also create
them. If the directory already exists, this command will do nothing and succeed.
"""
body = {}
if path is not None:
body["path"] = path
headers = {
"Accept": "application/json",
"Content-Type": "application/json",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
self._api.do("POST", "/api/2.0/workspace/mkdirs", body=body, headers=headers)
def set_permissions(
self,
workspace_object_type: str,
workspace_object_id: str,
*,
access_control_list: Optional[List[WorkspaceObjectAccessControlRequest]] = None,
) -> WorkspaceObjectPermissions:
"""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 parent objects or root
object.
:param workspace_object_type: str
The workspace object type for which to get or manage permissions. Could be one of the following:
alerts, alertsv2, dashboards, dbsql-dashboards, directories, experiments, files, genie, notebooks,
queries
:param workspace_object_id: str
The workspace object for which to get or manage permissions.
:param access_control_list: List[:class:`WorkspaceObjectAccessControlRequest`] (optional)
:returns: :class:`WorkspaceObjectPermissions`
"""
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",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
res = self._api.do(
"PUT", f"/api/2.0/permissions/{workspace_object_type}/{workspace_object_id}", body=body, headers=headers
)
return WorkspaceObjectPermissions.from_dict(res)
def update_permissions(
self,
workspace_object_type: str,
workspace_object_id: str,
*,
access_control_list: Optional[List[WorkspaceObjectAccessControlRequest]] = None,
) -> WorkspaceObjectPermissions:
"""Updates the permissions on a workspace object. Workspace objects can inherit permissions from their
parent objects or root object.
:param workspace_object_type: str
The workspace object type for which to get or manage permissions. Could be one of the following:
alerts, alertsv2, dashboards, dbsql-dashboards, directories, experiments, files, genie, notebooks,
queries
:param workspace_object_id: str
The workspace object for which to get or manage permissions.
:param access_control_list: List[:class:`WorkspaceObjectAccessControlRequest`] (optional)
:returns: :class:`WorkspaceObjectPermissions`
"""
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",
}
cfg = self._api._cfg
if cfg.host_type == HostType.UNIFIED and cfg.workspace_id:
headers["X-Databricks-Org-Id"] = cfg.workspace_id
res = self._api.do(
"PATCH", f"/api/2.0/permissions/{workspace_object_type}/{workspace_object_id}", body=body, headers=headers
)
return WorkspaceObjectPermissions.from_dict(res)
Reference in New Issue View Git Blame Copy Permalink