1380 lines
68 KiB
Python
1380 lines
68 KiB
Python
# Code generated from OpenAPI specs by Databricks SDK Generator. DO NOT EDIT.
|
||
|
||
import json
|
||
import logging
|
||
from typing import List, Optional
|
||
|
||
import databricks.sdk.core as client
|
||
import databricks.sdk.dbutils as dbutils
|
||
from databricks.sdk import azure
|
||
from databricks.sdk.credentials_provider import CredentialsStrategy
|
||
from databricks.sdk.data_plane import DataPlaneTokenSource
|
||
from databricks.sdk.mixins.compute import ClustersExt
|
||
from databricks.sdk.mixins.files import DbfsExt, FilesExt
|
||
from databricks.sdk.mixins.jobs import JobsExt
|
||
from databricks.sdk.mixins.open_ai_client import ServingEndpointsExt
|
||
from databricks.sdk.mixins.workspace import WorkspaceExt
|
||
from databricks.sdk.oauth import AuthorizationDetail
|
||
from databricks.sdk.service import agentbricks as pkg_agentbricks
|
||
from databricks.sdk.service import apps as pkg_apps
|
||
from databricks.sdk.service import billing as pkg_billing
|
||
from databricks.sdk.service import catalog as pkg_catalog
|
||
from databricks.sdk.service import cleanrooms as pkg_cleanrooms
|
||
from databricks.sdk.service import compute as pkg_compute
|
||
from databricks.sdk.service import dashboards as pkg_dashboards
|
||
from databricks.sdk.service import database as pkg_database
|
||
from databricks.sdk.service import dataquality as pkg_dataquality
|
||
from databricks.sdk.service import files as pkg_files
|
||
from databricks.sdk.service import iam as pkg_iam
|
||
from databricks.sdk.service import iamv2 as pkg_iamv2
|
||
from databricks.sdk.service import jobs as pkg_jobs
|
||
from databricks.sdk.service import marketplace as pkg_marketplace
|
||
from databricks.sdk.service import ml as pkg_ml
|
||
from databricks.sdk.service import networking as pkg_networking
|
||
from databricks.sdk.service import oauth2 as pkg_oauth2
|
||
from databricks.sdk.service import pipelines as pkg_pipelines
|
||
from databricks.sdk.service import postgres as pkg_postgres
|
||
from databricks.sdk.service import provisioning as pkg_provisioning
|
||
from databricks.sdk.service import qualitymonitorv2 as pkg_qualitymonitorv2
|
||
from databricks.sdk.service import serving as pkg_serving
|
||
from databricks.sdk.service import settings as pkg_settings
|
||
from databricks.sdk.service import settingsv2 as pkg_settingsv2
|
||
from databricks.sdk.service import sharing as pkg_sharing
|
||
from databricks.sdk.service import sql as pkg_sql
|
||
from databricks.sdk.service import tags as pkg_tags
|
||
from databricks.sdk.service import vectorsearch as pkg_vectorsearch
|
||
from databricks.sdk.service import workspace as pkg_workspace
|
||
from databricks.sdk.service.agentbricks import AgentBricksAPI
|
||
from databricks.sdk.service.apps import AppsAPI, AppsSettingsAPI
|
||
from databricks.sdk.service.billing import (BillableUsageAPI, BudgetPolicyAPI,
|
||
BudgetsAPI, LogDeliveryAPI,
|
||
UsageDashboardsAPI)
|
||
from databricks.sdk.service.catalog import (AccountMetastoreAssignmentsAPI,
|
||
AccountMetastoresAPI,
|
||
AccountStorageCredentialsAPI,
|
||
ArtifactAllowlistsAPI, CatalogsAPI,
|
||
ConnectionsAPI, CredentialsAPI,
|
||
EntityTagAssignmentsAPI,
|
||
ExternalLineageAPI,
|
||
ExternalLocationsAPI,
|
||
ExternalMetadataAPI, FunctionsAPI,
|
||
GrantsAPI, MetastoresAPI,
|
||
ModelVersionsAPI, OnlineTablesAPI,
|
||
PoliciesAPI, QualityMonitorsAPI,
|
||
RegisteredModelsAPI,
|
||
ResourceQuotasAPI, RfaAPI,
|
||
SchemasAPI, StorageCredentialsAPI,
|
||
SystemSchemasAPI,
|
||
TableConstraintsAPI, TablesAPI,
|
||
TemporaryPathCredentialsAPI,
|
||
TemporaryTableCredentialsAPI,
|
||
VolumesAPI, WorkspaceBindingsAPI)
|
||
from databricks.sdk.service.cleanrooms import (CleanRoomAssetRevisionsAPI,
|
||
CleanRoomAssetsAPI,
|
||
CleanRoomAutoApprovalRulesAPI,
|
||
CleanRoomsAPI,
|
||
CleanRoomTaskRunsAPI)
|
||
from databricks.sdk.service.compute import (ClusterPoliciesAPI, ClustersAPI,
|
||
CommandExecutionAPI,
|
||
GlobalInitScriptsAPI,
|
||
InstancePoolsAPI,
|
||
InstanceProfilesAPI, LibrariesAPI,
|
||
PolicyComplianceForClustersAPI,
|
||
PolicyFamiliesAPI)
|
||
from databricks.sdk.service.dashboards import (GenieAPI, LakeviewAPI,
|
||
LakeviewEmbeddedAPI)
|
||
from databricks.sdk.service.database import DatabaseAPI
|
||
from databricks.sdk.service.dataquality import DataQualityAPI
|
||
from databricks.sdk.service.files import DbfsAPI, FilesAPI
|
||
from databricks.sdk.service.iam import (AccessControlAPI,
|
||
AccountAccessControlAPI,
|
||
AccountAccessControlProxyAPI,
|
||
AccountGroupsAPI, AccountGroupsV2API,
|
||
AccountServicePrincipalsAPI,
|
||
AccountServicePrincipalsV2API,
|
||
AccountUsersAPI, AccountUsersV2API,
|
||
CurrentUserAPI, GroupsAPI, GroupsV2API,
|
||
PermissionMigrationAPI, PermissionsAPI,
|
||
ServicePrincipalsAPI,
|
||
ServicePrincipalsV2API, UsersAPI,
|
||
UsersV2API, WorkspaceAssignmentAPI)
|
||
from databricks.sdk.service.iamv2 import AccountIamV2API, WorkspaceIamV2API
|
||
from databricks.sdk.service.jobs import JobsAPI, PolicyComplianceForJobsAPI
|
||
from databricks.sdk.service.marketplace import (
|
||
ConsumerFulfillmentsAPI, ConsumerInstallationsAPI, ConsumerListingsAPI,
|
||
ConsumerPersonalizationRequestsAPI, ConsumerProvidersAPI,
|
||
ProviderExchangeFiltersAPI, ProviderExchangesAPI, ProviderFilesAPI,
|
||
ProviderListingsAPI, ProviderPersonalizationRequestsAPI,
|
||
ProviderProviderAnalyticsDashboardsAPI, ProviderProvidersAPI)
|
||
from databricks.sdk.service.ml import (ExperimentsAPI, FeatureEngineeringAPI,
|
||
FeatureStoreAPI, ForecastingAPI,
|
||
MaterializedFeaturesAPI,
|
||
ModelRegistryAPI)
|
||
from databricks.sdk.service.networking import EndpointsAPI
|
||
from databricks.sdk.service.oauth2 import (AccountFederationPolicyAPI,
|
||
CustomAppIntegrationAPI,
|
||
OAuthPublishedAppsAPI,
|
||
PublishedAppIntegrationAPI,
|
||
ServicePrincipalFederationPolicyAPI,
|
||
ServicePrincipalSecretsAPI,
|
||
ServicePrincipalSecretsProxyAPI)
|
||
from databricks.sdk.service.pipelines import PipelinesAPI
|
||
from databricks.sdk.service.postgres import PostgresAPI
|
||
from databricks.sdk.service.provisioning import (CredentialsAPI,
|
||
EncryptionKeysAPI,
|
||
NetworksAPI, PrivateAccessAPI,
|
||
StorageAPI, VpcEndpointsAPI,
|
||
Workspace, WorkspacesAPI)
|
||
from databricks.sdk.service.qualitymonitorv2 import QualityMonitorV2API
|
||
from databricks.sdk.service.serving import (ServingEndpointsAPI,
|
||
ServingEndpointsDataPlaneAPI)
|
||
from databricks.sdk.service.settings import (
|
||
AccountIpAccessListsAPI, AccountSettingsAPI,
|
||
AibiDashboardEmbeddingAccessPolicyAPI,
|
||
AibiDashboardEmbeddingApprovedDomainsAPI, AutomaticClusterUpdateAPI,
|
||
ComplianceSecurityProfileAPI, CredentialsManagerAPI,
|
||
CspEnablementAccountAPI, DashboardEmailSubscriptionsAPI,
|
||
DefaultNamespaceAPI, DefaultWarehouseIdAPI, DisableLegacyAccessAPI,
|
||
DisableLegacyDbfsAPI, DisableLegacyFeaturesAPI, EnableExportNotebookAPI,
|
||
EnableIpAccessListsAPI, EnableNotebookTableClipboardAPI,
|
||
EnableResultsDownloadingAPI, EnhancedSecurityMonitoringAPI,
|
||
EsmEnablementAccountAPI, IpAccessListsAPI,
|
||
LlmProxyPartnerPoweredAccountAPI, LlmProxyPartnerPoweredEnforceAPI,
|
||
LlmProxyPartnerPoweredWorkspaceAPI, NetworkConnectivityAPI,
|
||
NetworkPoliciesAPI, NotificationDestinationsAPI, PersonalComputeAPI,
|
||
RestrictWorkspaceAdminsAPI, SettingsAPI, SqlResultsDownloadAPI,
|
||
TokenManagementAPI, TokensAPI, WorkspaceConfAPI,
|
||
WorkspaceNetworkConfigurationAPI)
|
||
from databricks.sdk.service.settingsv2 import (AccountSettingsV2API,
|
||
WorkspaceSettingsV2API)
|
||
from databricks.sdk.service.sharing import (ProvidersAPI,
|
||
RecipientActivationAPI,
|
||
RecipientFederationPoliciesAPI,
|
||
RecipientsAPI, SharesAPI)
|
||
from databricks.sdk.service.sql import (AlertsAPI, AlertsLegacyAPI,
|
||
AlertsV2API, DashboardsAPI,
|
||
DashboardWidgetsAPI, DataSourcesAPI,
|
||
DbsqlPermissionsAPI, QueriesAPI,
|
||
QueriesLegacyAPI, QueryHistoryAPI,
|
||
QueryVisualizationsAPI,
|
||
QueryVisualizationsLegacyAPI,
|
||
RedashConfigAPI, StatementExecutionAPI,
|
||
WarehousesAPI)
|
||
from databricks.sdk.service.tags import (TagPoliciesAPI,
|
||
WorkspaceEntityTagAssignmentsAPI)
|
||
from databricks.sdk.service.vectorsearch import (VectorSearchEndpointsAPI,
|
||
VectorSearchIndexesAPI)
|
||
from databricks.sdk.service.workspace import (GitCredentialsAPI, ReposAPI,
|
||
SecretsAPI, WorkspaceAPI)
|
||
|
||
_LOG = logging.getLogger(__name__)
|
||
|
||
|
||
def _make_dbutils(config: client.Config):
|
||
# We try to directly check if we are in runtime, instead of
|
||
# trying to import from databricks.sdk.runtime. This is to prevent
|
||
# remote dbutils from being created without the config, which is both
|
||
# expensive (will need to check all credential providers) and can
|
||
# throw errors (when no env vars are set).
|
||
try:
|
||
from dbruntime import UserNamespaceInitializer
|
||
except ImportError:
|
||
return dbutils.RemoteDbUtils(config)
|
||
|
||
# We are in runtime, so we can use the runtime dbutils
|
||
from databricks.sdk.runtime import dbutils as runtime_dbutils
|
||
|
||
return runtime_dbutils
|
||
|
||
|
||
def _make_files_client(apiClient: client.ApiClient, config: client.Config):
|
||
return FilesExt(apiClient, config)
|
||
|
||
|
||
class WorkspaceClient:
|
||
"""
|
||
The WorkspaceClient is a client for the workspace-level Databricks REST API.
|
||
"""
|
||
|
||
def __init__(
|
||
self,
|
||
*,
|
||
host: Optional[str] = None,
|
||
account_id: Optional[str] = None,
|
||
username: Optional[str] = None,
|
||
password: Optional[str] = None,
|
||
client_id: Optional[str] = None,
|
||
client_secret: Optional[str] = None,
|
||
token: Optional[str] = None,
|
||
profile: Optional[str] = None,
|
||
config_file: Optional[str] = None,
|
||
azure_workspace_resource_id: Optional[str] = None,
|
||
azure_client_secret: Optional[str] = None,
|
||
azure_client_id: Optional[str] = None,
|
||
azure_tenant_id: Optional[str] = None,
|
||
azure_environment: Optional[str] = None,
|
||
auth_type: Optional[str] = None,
|
||
cluster_id: Optional[str] = None,
|
||
google_credentials: Optional[str] = None,
|
||
google_service_account: Optional[str] = None,
|
||
debug_truncate_bytes: Optional[int] = None,
|
||
debug_headers: Optional[bool] = None,
|
||
product="unknown",
|
||
product_version="0.0.0",
|
||
credentials_strategy: Optional[CredentialsStrategy] = None,
|
||
credentials_provider: Optional[CredentialsStrategy] = None,
|
||
token_audience: Optional[str] = None,
|
||
config: Optional[client.Config] = None,
|
||
scopes: Optional[List[str]] = None,
|
||
authorization_details: Optional[List[AuthorizationDetail]] = None,
|
||
custom_headers: Optional[dict] = None,
|
||
):
|
||
if not config:
|
||
config = client.Config(
|
||
host=host,
|
||
account_id=account_id,
|
||
username=username,
|
||
password=password,
|
||
client_id=client_id,
|
||
client_secret=client_secret,
|
||
token=token,
|
||
profile=profile,
|
||
config_file=config_file,
|
||
azure_workspace_resource_id=azure_workspace_resource_id,
|
||
azure_client_secret=azure_client_secret,
|
||
azure_client_id=azure_client_id,
|
||
azure_tenant_id=azure_tenant_id,
|
||
azure_environment=azure_environment,
|
||
auth_type=auth_type,
|
||
cluster_id=cluster_id,
|
||
google_credentials=google_credentials,
|
||
google_service_account=google_service_account,
|
||
credentials_strategy=credentials_strategy,
|
||
credentials_provider=credentials_provider,
|
||
debug_truncate_bytes=debug_truncate_bytes,
|
||
debug_headers=debug_headers,
|
||
product=product,
|
||
product_version=product_version,
|
||
token_audience=token_audience,
|
||
scopes=scopes,
|
||
authorization_details=(
|
||
json.dumps([detail.as_dict() for detail in authorization_details])
|
||
if authorization_details
|
||
else None
|
||
),
|
||
custom_headers=custom_headers,
|
||
)
|
||
self._config = config.copy()
|
||
self._dbutils = _make_dbutils(self._config)
|
||
self._api_client = client.ApiClient(self._config)
|
||
serving_endpoints = ServingEndpointsExt(self._api_client)
|
||
self._access_control = pkg_iam.AccessControlAPI(self._api_client)
|
||
self._account_access_control_proxy = pkg_iam.AccountAccessControlProxyAPI(self._api_client)
|
||
self._agent_bricks = pkg_agentbricks.AgentBricksAPI(self._api_client)
|
||
self._alerts = pkg_sql.AlertsAPI(self._api_client)
|
||
self._alerts_legacy = pkg_sql.AlertsLegacyAPI(self._api_client)
|
||
self._alerts_v2 = pkg_sql.AlertsV2API(self._api_client)
|
||
self._apps = pkg_apps.AppsAPI(self._api_client)
|
||
self._apps_settings = pkg_apps.AppsSettingsAPI(self._api_client)
|
||
self._artifact_allowlists = pkg_catalog.ArtifactAllowlistsAPI(self._api_client)
|
||
self._catalogs = pkg_catalog.CatalogsAPI(self._api_client)
|
||
self._clean_room_asset_revisions = pkg_cleanrooms.CleanRoomAssetRevisionsAPI(self._api_client)
|
||
self._clean_room_assets = pkg_cleanrooms.CleanRoomAssetsAPI(self._api_client)
|
||
self._clean_room_auto_approval_rules = pkg_cleanrooms.CleanRoomAutoApprovalRulesAPI(self._api_client)
|
||
self._clean_room_task_runs = pkg_cleanrooms.CleanRoomTaskRunsAPI(self._api_client)
|
||
self._clean_rooms = pkg_cleanrooms.CleanRoomsAPI(self._api_client)
|
||
self._cluster_policies = pkg_compute.ClusterPoliciesAPI(self._api_client)
|
||
self._clusters = ClustersExt(self._api_client)
|
||
self._command_execution = pkg_compute.CommandExecutionAPI(self._api_client)
|
||
self._connections = pkg_catalog.ConnectionsAPI(self._api_client)
|
||
self._consumer_fulfillments = pkg_marketplace.ConsumerFulfillmentsAPI(self._api_client)
|
||
self._consumer_installations = pkg_marketplace.ConsumerInstallationsAPI(self._api_client)
|
||
self._consumer_listings = pkg_marketplace.ConsumerListingsAPI(self._api_client)
|
||
self._consumer_personalization_requests = pkg_marketplace.ConsumerPersonalizationRequestsAPI(self._api_client)
|
||
self._consumer_providers = pkg_marketplace.ConsumerProvidersAPI(self._api_client)
|
||
self._credentials = pkg_catalog.CredentialsAPI(self._api_client)
|
||
self._credentials_manager = pkg_settings.CredentialsManagerAPI(self._api_client)
|
||
self._current_user = pkg_iam.CurrentUserAPI(self._api_client)
|
||
self._dashboard_widgets = pkg_sql.DashboardWidgetsAPI(self._api_client)
|
||
self._dashboards = pkg_sql.DashboardsAPI(self._api_client)
|
||
self._data_quality = pkg_dataquality.DataQualityAPI(self._api_client)
|
||
self._data_sources = pkg_sql.DataSourcesAPI(self._api_client)
|
||
self._database = pkg_database.DatabaseAPI(self._api_client)
|
||
self._dbfs = DbfsExt(self._api_client)
|
||
self._dbsql_permissions = pkg_sql.DbsqlPermissionsAPI(self._api_client)
|
||
self._entity_tag_assignments = pkg_catalog.EntityTagAssignmentsAPI(self._api_client)
|
||
self._experiments = pkg_ml.ExperimentsAPI(self._api_client)
|
||
self._external_lineage = pkg_catalog.ExternalLineageAPI(self._api_client)
|
||
self._external_locations = pkg_catalog.ExternalLocationsAPI(self._api_client)
|
||
self._external_metadata = pkg_catalog.ExternalMetadataAPI(self._api_client)
|
||
self._feature_engineering = pkg_ml.FeatureEngineeringAPI(self._api_client)
|
||
self._feature_store = pkg_ml.FeatureStoreAPI(self._api_client)
|
||
self._files = _make_files_client(self._api_client, self._config)
|
||
self._forecasting = pkg_ml.ForecastingAPI(self._api_client)
|
||
self._functions = pkg_catalog.FunctionsAPI(self._api_client)
|
||
self._genie = pkg_dashboards.GenieAPI(self._api_client)
|
||
self._git_credentials = pkg_workspace.GitCredentialsAPI(self._api_client)
|
||
self._global_init_scripts = pkg_compute.GlobalInitScriptsAPI(self._api_client)
|
||
self._grants = pkg_catalog.GrantsAPI(self._api_client)
|
||
self._groups_v2 = pkg_iam.GroupsV2API(self._api_client)
|
||
self._instance_pools = pkg_compute.InstancePoolsAPI(self._api_client)
|
||
self._instance_profiles = pkg_compute.InstanceProfilesAPI(self._api_client)
|
||
self._ip_access_lists = pkg_settings.IpAccessListsAPI(self._api_client)
|
||
self._jobs = JobsExt(self._api_client)
|
||
self._lakeview = pkg_dashboards.LakeviewAPI(self._api_client)
|
||
self._lakeview_embedded = pkg_dashboards.LakeviewEmbeddedAPI(self._api_client)
|
||
self._libraries = pkg_compute.LibrariesAPI(self._api_client)
|
||
self._materialized_features = pkg_ml.MaterializedFeaturesAPI(self._api_client)
|
||
self._metastores = pkg_catalog.MetastoresAPI(self._api_client)
|
||
self._model_registry = pkg_ml.ModelRegistryAPI(self._api_client)
|
||
self._model_versions = pkg_catalog.ModelVersionsAPI(self._api_client)
|
||
self._notification_destinations = pkg_settings.NotificationDestinationsAPI(self._api_client)
|
||
self._online_tables = pkg_catalog.OnlineTablesAPI(self._api_client)
|
||
self._permission_migration = pkg_iam.PermissionMigrationAPI(self._api_client)
|
||
self._permissions = pkg_iam.PermissionsAPI(self._api_client)
|
||
self._pipelines = pkg_pipelines.PipelinesAPI(self._api_client)
|
||
self._policies = pkg_catalog.PoliciesAPI(self._api_client)
|
||
self._policy_compliance_for_clusters = pkg_compute.PolicyComplianceForClustersAPI(self._api_client)
|
||
self._policy_compliance_for_jobs = pkg_jobs.PolicyComplianceForJobsAPI(self._api_client)
|
||
self._policy_families = pkg_compute.PolicyFamiliesAPI(self._api_client)
|
||
self._postgres = pkg_postgres.PostgresAPI(self._api_client)
|
||
self._provider_exchange_filters = pkg_marketplace.ProviderExchangeFiltersAPI(self._api_client)
|
||
self._provider_exchanges = pkg_marketplace.ProviderExchangesAPI(self._api_client)
|
||
self._provider_files = pkg_marketplace.ProviderFilesAPI(self._api_client)
|
||
self._provider_listings = pkg_marketplace.ProviderListingsAPI(self._api_client)
|
||
self._provider_personalization_requests = pkg_marketplace.ProviderPersonalizationRequestsAPI(self._api_client)
|
||
self._provider_provider_analytics_dashboards = pkg_marketplace.ProviderProviderAnalyticsDashboardsAPI(
|
||
self._api_client
|
||
)
|
||
self._provider_providers = pkg_marketplace.ProviderProvidersAPI(self._api_client)
|
||
self._providers = pkg_sharing.ProvidersAPI(self._api_client)
|
||
self._quality_monitor_v2 = pkg_qualitymonitorv2.QualityMonitorV2API(self._api_client)
|
||
self._quality_monitors = pkg_catalog.QualityMonitorsAPI(self._api_client)
|
||
self._queries = pkg_sql.QueriesAPI(self._api_client)
|
||
self._queries_legacy = pkg_sql.QueriesLegacyAPI(self._api_client)
|
||
self._query_history = pkg_sql.QueryHistoryAPI(self._api_client)
|
||
self._query_visualizations = pkg_sql.QueryVisualizationsAPI(self._api_client)
|
||
self._query_visualizations_legacy = pkg_sql.QueryVisualizationsLegacyAPI(self._api_client)
|
||
self._recipient_activation = pkg_sharing.RecipientActivationAPI(self._api_client)
|
||
self._recipient_federation_policies = pkg_sharing.RecipientFederationPoliciesAPI(self._api_client)
|
||
self._recipients = pkg_sharing.RecipientsAPI(self._api_client)
|
||
self._redash_config = pkg_sql.RedashConfigAPI(self._api_client)
|
||
self._registered_models = pkg_catalog.RegisteredModelsAPI(self._api_client)
|
||
self._repos = pkg_workspace.ReposAPI(self._api_client)
|
||
self._resource_quotas = pkg_catalog.ResourceQuotasAPI(self._api_client)
|
||
self._rfa = pkg_catalog.RfaAPI(self._api_client)
|
||
self._schemas = pkg_catalog.SchemasAPI(self._api_client)
|
||
self._secrets = pkg_workspace.SecretsAPI(self._api_client)
|
||
self._service_principal_secrets_proxy = pkg_oauth2.ServicePrincipalSecretsProxyAPI(self._api_client)
|
||
self._service_principals_v2 = pkg_iam.ServicePrincipalsV2API(self._api_client)
|
||
self._serving_endpoints = serving_endpoints
|
||
serving_endpoints_data_plane_token_source = DataPlaneTokenSource(
|
||
self._config.host, self._config.oauth_token, self._config.disable_async_token_refresh
|
||
)
|
||
self._serving_endpoints_data_plane = pkg_serving.ServingEndpointsDataPlaneAPI(
|
||
self._api_client, serving_endpoints, serving_endpoints_data_plane_token_source
|
||
)
|
||
self._settings = pkg_settings.SettingsAPI(self._api_client)
|
||
self._shares = pkg_sharing.SharesAPI(self._api_client)
|
||
self._statement_execution = pkg_sql.StatementExecutionAPI(self._api_client)
|
||
self._storage_credentials = pkg_catalog.StorageCredentialsAPI(self._api_client)
|
||
self._system_schemas = pkg_catalog.SystemSchemasAPI(self._api_client)
|
||
self._table_constraints = pkg_catalog.TableConstraintsAPI(self._api_client)
|
||
self._tables = pkg_catalog.TablesAPI(self._api_client)
|
||
self._tag_policies = pkg_tags.TagPoliciesAPI(self._api_client)
|
||
self._temporary_path_credentials = pkg_catalog.TemporaryPathCredentialsAPI(self._api_client)
|
||
self._temporary_table_credentials = pkg_catalog.TemporaryTableCredentialsAPI(self._api_client)
|
||
self._token_management = pkg_settings.TokenManagementAPI(self._api_client)
|
||
self._tokens = pkg_settings.TokensAPI(self._api_client)
|
||
self._users_v2 = pkg_iam.UsersV2API(self._api_client)
|
||
self._vector_search_endpoints = pkg_vectorsearch.VectorSearchEndpointsAPI(self._api_client)
|
||
self._vector_search_indexes = pkg_vectorsearch.VectorSearchIndexesAPI(self._api_client)
|
||
self._volumes = pkg_catalog.VolumesAPI(self._api_client)
|
||
self._warehouses = pkg_sql.WarehousesAPI(self._api_client)
|
||
self._workspace = WorkspaceExt(self._api_client)
|
||
self._workspace_bindings = pkg_catalog.WorkspaceBindingsAPI(self._api_client)
|
||
self._workspace_conf = pkg_settings.WorkspaceConfAPI(self._api_client)
|
||
self._workspace_entity_tag_assignments = pkg_tags.WorkspaceEntityTagAssignmentsAPI(self._api_client)
|
||
self._workspace_iam_v2 = pkg_iamv2.WorkspaceIamV2API(self._api_client)
|
||
self._workspace_settings_v2 = pkg_settingsv2.WorkspaceSettingsV2API(self._api_client)
|
||
self._groups = pkg_iam.GroupsAPI(self._api_client)
|
||
self._service_principals = pkg_iam.ServicePrincipalsAPI(self._api_client)
|
||
self._users = pkg_iam.UsersAPI(self._api_client)
|
||
|
||
@property
|
||
def config(self) -> client.Config:
|
||
return self._config
|
||
|
||
@property
|
||
def api_client(self) -> client.ApiClient:
|
||
return self._api_client
|
||
|
||
@property
|
||
def dbutils(self) -> dbutils.RemoteDbUtils:
|
||
return self._dbutils
|
||
|
||
@property
|
||
def access_control(self) -> pkg_iam.AccessControlAPI:
|
||
"""Rule based Access Control for Databricks Resources."""
|
||
return self._access_control
|
||
|
||
@property
|
||
def account_access_control_proxy(self) -> pkg_iam.AccountAccessControlProxyAPI:
|
||
"""These APIs manage access rules on resources in an account."""
|
||
return self._account_access_control_proxy
|
||
|
||
@property
|
||
def agent_bricks(self) -> pkg_agentbricks.AgentBricksAPI:
|
||
"""The Custom LLMs service manages state and powers the UI for the Custom LLM product."""
|
||
return self._agent_bricks
|
||
|
||
@property
|
||
def alerts(self) -> pkg_sql.AlertsAPI:
|
||
"""The alerts API can be used to perform CRUD operations on alerts."""
|
||
return self._alerts
|
||
|
||
@property
|
||
def alerts_legacy(self) -> pkg_sql.AlertsLegacyAPI:
|
||
"""The alerts API can be used to perform CRUD operations on alerts."""
|
||
return self._alerts_legacy
|
||
|
||
@property
|
||
def alerts_v2(self) -> pkg_sql.AlertsV2API:
|
||
"""New version of SQL Alerts."""
|
||
return self._alerts_v2
|
||
|
||
@property
|
||
def apps(self) -> pkg_apps.AppsAPI:
|
||
"""Apps run directly on a customer's Databricks instance, integrate with their data, use and extend Databricks services, and enable users to interact through single sign-on."""
|
||
return self._apps
|
||
|
||
@property
|
||
def apps_settings(self) -> pkg_apps.AppsSettingsAPI:
|
||
"""Apps Settings manage the settings for the Apps service on a customer's Databricks instance."""
|
||
return self._apps_settings
|
||
|
||
@property
|
||
def artifact_allowlists(self) -> pkg_catalog.ArtifactAllowlistsAPI:
|
||
"""In Databricks Runtime 13.3 and above, you can add libraries and init scripts to the `allowlist` in UC so that users can leverage these artifacts on compute configured with shared access mode."""
|
||
return self._artifact_allowlists
|
||
|
||
@property
|
||
def catalogs(self) -> pkg_catalog.CatalogsAPI:
|
||
"""A catalog is the first layer of Unity Catalog’s three-level namespace."""
|
||
return self._catalogs
|
||
|
||
@property
|
||
def clean_room_asset_revisions(self) -> pkg_cleanrooms.CleanRoomAssetRevisionsAPI:
|
||
"""Clean Room Asset Revisions denote new versions of uploaded assets (e.g."""
|
||
return self._clean_room_asset_revisions
|
||
|
||
@property
|
||
def clean_room_assets(self) -> pkg_cleanrooms.CleanRoomAssetsAPI:
|
||
"""Clean room assets are data and code objects — Tables, volumes, and notebooks that are shared with the clean room."""
|
||
return self._clean_room_assets
|
||
|
||
@property
|
||
def clean_room_auto_approval_rules(self) -> pkg_cleanrooms.CleanRoomAutoApprovalRulesAPI:
|
||
"""Clean room auto-approval rules automatically create an approval on your behalf when an asset (e.g."""
|
||
return self._clean_room_auto_approval_rules
|
||
|
||
@property
|
||
def clean_room_task_runs(self) -> pkg_cleanrooms.CleanRoomTaskRunsAPI:
|
||
"""Clean room task runs are the executions of notebooks in a clean room."""
|
||
return self._clean_room_task_runs
|
||
|
||
@property
|
||
def clean_rooms(self) -> pkg_cleanrooms.CleanRoomsAPI:
|
||
"""A clean room uses Delta Sharing and serverless compute to provide a secure and privacy-protecting environment where multiple parties can work together on sensitive enterprise data without direct access to each other's data."""
|
||
return self._clean_rooms
|
||
|
||
@property
|
||
def cluster_policies(self) -> pkg_compute.ClusterPoliciesAPI:
|
||
"""You can use cluster policies to control users' ability to configure clusters based on a set of rules."""
|
||
return self._cluster_policies
|
||
|
||
@property
|
||
def clusters(self) -> ClustersExt:
|
||
"""The Clusters API allows you to create, start, edit, list, terminate, and delete clusters."""
|
||
return self._clusters
|
||
|
||
@property
|
||
def command_execution(self) -> pkg_compute.CommandExecutionAPI:
|
||
"""This API allows execution of Python, Scala, SQL, or R commands on running Databricks Clusters."""
|
||
return self._command_execution
|
||
|
||
@property
|
||
def connections(self) -> pkg_catalog.ConnectionsAPI:
|
||
"""Connections allow for creating a connection to an external data source."""
|
||
return self._connections
|
||
|
||
@property
|
||
def consumer_fulfillments(self) -> pkg_marketplace.ConsumerFulfillmentsAPI:
|
||
"""Fulfillments are entities that allow consumers to preview installations."""
|
||
return self._consumer_fulfillments
|
||
|
||
@property
|
||
def consumer_installations(self) -> pkg_marketplace.ConsumerInstallationsAPI:
|
||
"""Installations are entities that allow consumers to interact with Databricks Marketplace listings."""
|
||
return self._consumer_installations
|
||
|
||
@property
|
||
def consumer_listings(self) -> pkg_marketplace.ConsumerListingsAPI:
|
||
"""Listings are the core entities in the Marketplace."""
|
||
return self._consumer_listings
|
||
|
||
@property
|
||
def consumer_personalization_requests(self) -> pkg_marketplace.ConsumerPersonalizationRequestsAPI:
|
||
"""Personalization Requests allow customers to interact with the individualized Marketplace listing flow."""
|
||
return self._consumer_personalization_requests
|
||
|
||
@property
|
||
def consumer_providers(self) -> pkg_marketplace.ConsumerProvidersAPI:
|
||
"""Providers are the entities that publish listings to the Marketplace."""
|
||
return self._consumer_providers
|
||
|
||
@property
|
||
def credentials(self) -> pkg_catalog.CredentialsAPI:
|
||
"""A credential represents an authentication and authorization mechanism for accessing services on your cloud tenant."""
|
||
return self._credentials
|
||
|
||
@property
|
||
def credentials_manager(self) -> pkg_settings.CredentialsManagerAPI:
|
||
"""Credentials manager interacts with with Identity Providers to to perform token exchanges using stored credentials and refresh tokens."""
|
||
return self._credentials_manager
|
||
|
||
@property
|
||
def current_user(self) -> pkg_iam.CurrentUserAPI:
|
||
"""This API allows retrieving information about currently authenticated user or service principal."""
|
||
return self._current_user
|
||
|
||
@property
|
||
def dashboard_widgets(self) -> pkg_sql.DashboardWidgetsAPI:
|
||
"""This is an evolving API that facilitates the addition and removal of widgets from existing dashboards within the Databricks Workspace."""
|
||
return self._dashboard_widgets
|
||
|
||
@property
|
||
def dashboards(self) -> pkg_sql.DashboardsAPI:
|
||
"""In general, there is little need to modify dashboards using the API."""
|
||
return self._dashboards
|
||
|
||
@property
|
||
def data_quality(self) -> pkg_dataquality.DataQualityAPI:
|
||
"""Manage the data quality of Unity Catalog objects (currently support `schema` and `table`)."""
|
||
return self._data_quality
|
||
|
||
@property
|
||
def data_sources(self) -> pkg_sql.DataSourcesAPI:
|
||
"""This API is provided to assist you in making new query objects."""
|
||
return self._data_sources
|
||
|
||
@property
|
||
def database(self) -> pkg_database.DatabaseAPI:
|
||
"""Database Instances provide access to a database via REST API or direct SQL."""
|
||
return self._database
|
||
|
||
@property
|
||
def dbfs(self) -> DbfsExt:
|
||
"""DBFS API makes it simple to interact with various data sources without having to include a users credentials every time to read a file."""
|
||
return self._dbfs
|
||
|
||
@property
|
||
def dbsql_permissions(self) -> pkg_sql.DbsqlPermissionsAPI:
|
||
"""The SQL Permissions API is similar to the endpoints of the :method:permissions/set."""
|
||
return self._dbsql_permissions
|
||
|
||
@property
|
||
def entity_tag_assignments(self) -> pkg_catalog.EntityTagAssignmentsAPI:
|
||
"""Tags are attributes that include keys and optional values that you can use to organize and categorize entities in Unity Catalog."""
|
||
return self._entity_tag_assignments
|
||
|
||
@property
|
||
def experiments(self) -> pkg_ml.ExperimentsAPI:
|
||
"""Experiments are the primary unit of organization in MLflow; all MLflow runs belong to an experiment."""
|
||
return self._experiments
|
||
|
||
@property
|
||
def external_lineage(self) -> pkg_catalog.ExternalLineageAPI:
|
||
"""External Lineage APIs enable defining and managing lineage relationships between Databricks objects and external systems."""
|
||
return self._external_lineage
|
||
|
||
@property
|
||
def external_locations(self) -> pkg_catalog.ExternalLocationsAPI:
|
||
"""An external location is an object that combines a cloud storage path with a storage credential that authorizes access to the cloud storage path."""
|
||
return self._external_locations
|
||
|
||
@property
|
||
def external_metadata(self) -> pkg_catalog.ExternalMetadataAPI:
|
||
"""External Metadata objects enable customers to register and manage metadata about external systems within Unity Catalog."""
|
||
return self._external_metadata
|
||
|
||
@property
|
||
def feature_engineering(self) -> pkg_ml.FeatureEngineeringAPI:
|
||
"""[description]."""
|
||
return self._feature_engineering
|
||
|
||
@property
|
||
def feature_store(self) -> pkg_ml.FeatureStoreAPI:
|
||
"""A feature store is a centralized repository that enables data scientists to find and share features."""
|
||
return self._feature_store
|
||
|
||
@property
|
||
def forecasting(self) -> pkg_ml.ForecastingAPI:
|
||
"""The Forecasting API allows you to create and get serverless forecasting experiments."""
|
||
return self._forecasting
|
||
|
||
@property
|
||
def functions(self) -> pkg_catalog.FunctionsAPI:
|
||
"""Functions implement User-Defined Functions (UDFs) in Unity Catalog."""
|
||
return self._functions
|
||
|
||
@property
|
||
def genie(self) -> pkg_dashboards.GenieAPI:
|
||
"""Genie provides a no-code experience for business users, powered by AI/BI."""
|
||
return self._genie
|
||
|
||
@property
|
||
def git_credentials(self) -> pkg_workspace.GitCredentialsAPI:
|
||
"""Registers personal access token for Databricks to do operations on behalf of the user."""
|
||
return self._git_credentials
|
||
|
||
@property
|
||
def global_init_scripts(self) -> pkg_compute.GlobalInitScriptsAPI:
|
||
"""The Global Init Scripts API enables Workspace administrators to configure global initialization scripts for their workspace."""
|
||
return self._global_init_scripts
|
||
|
||
@property
|
||
def grants(self) -> pkg_catalog.GrantsAPI:
|
||
"""In Unity Catalog, data is secure by default."""
|
||
return self._grants
|
||
|
||
@property
|
||
def groups_v2(self) -> pkg_iam.GroupsV2API:
|
||
"""Groups simplify identity management, making it easier to assign access to Databricks workspace, data, and other securable objects."""
|
||
return self._groups_v2
|
||
|
||
@property
|
||
def instance_pools(self) -> pkg_compute.InstancePoolsAPI:
|
||
"""Instance Pools API are used to create, edit, delete and list instance pools by using ready-to-use cloud instances which reduces a cluster start and auto-scaling times."""
|
||
return self._instance_pools
|
||
|
||
@property
|
||
def instance_profiles(self) -> pkg_compute.InstanceProfilesAPI:
|
||
"""The Instance Profiles API allows admins to add, list, and remove instance profiles that users can launch clusters with."""
|
||
return self._instance_profiles
|
||
|
||
@property
|
||
def ip_access_lists(self) -> pkg_settings.IpAccessListsAPI:
|
||
"""IP Access List enables admins to configure IP access lists."""
|
||
return self._ip_access_lists
|
||
|
||
@property
|
||
def jobs(self) -> JobsExt:
|
||
"""The Jobs API allows you to create, edit, and delete jobs."""
|
||
return self._jobs
|
||
|
||
@property
|
||
def lakeview(self) -> pkg_dashboards.LakeviewAPI:
|
||
"""These APIs provide specific management operations for Lakeview dashboards."""
|
||
return self._lakeview
|
||
|
||
@property
|
||
def lakeview_embedded(self) -> pkg_dashboards.LakeviewEmbeddedAPI:
|
||
"""Token-based Lakeview APIs for embedding dashboards in external applications."""
|
||
return self._lakeview_embedded
|
||
|
||
@property
|
||
def libraries(self) -> pkg_compute.LibrariesAPI:
|
||
"""The Libraries API allows you to install and uninstall libraries and get the status of libraries on a cluster."""
|
||
return self._libraries
|
||
|
||
@property
|
||
def materialized_features(self) -> pkg_ml.MaterializedFeaturesAPI:
|
||
"""Materialized Features are columns in tables and views that can be directly used as features to train and serve ML models."""
|
||
return self._materialized_features
|
||
|
||
@property
|
||
def metastores(self) -> pkg_catalog.MetastoresAPI:
|
||
"""A metastore is the top-level container of objects in Unity Catalog."""
|
||
return self._metastores
|
||
|
||
@property
|
||
def model_registry(self) -> pkg_ml.ModelRegistryAPI:
|
||
"""Note: This API reference documents APIs for the Workspace Model Registry."""
|
||
return self._model_registry
|
||
|
||
@property
|
||
def model_versions(self) -> pkg_catalog.ModelVersionsAPI:
|
||
"""Databricks provides a hosted version of MLflow Model Registry in Unity Catalog."""
|
||
return self._model_versions
|
||
|
||
@property
|
||
def notification_destinations(self) -> pkg_settings.NotificationDestinationsAPI:
|
||
"""The notification destinations API lets you programmatically manage a workspace's notification destinations."""
|
||
return self._notification_destinations
|
||
|
||
@property
|
||
def online_tables(self) -> pkg_catalog.OnlineTablesAPI:
|
||
"""Online tables provide lower latency and higher QPS access to data from Delta tables."""
|
||
return self._online_tables
|
||
|
||
@property
|
||
def permission_migration(self) -> pkg_iam.PermissionMigrationAPI:
|
||
"""APIs for migrating acl permissions, used only by the ucx tool: https://github.com/databrickslabs/ucx."""
|
||
return self._permission_migration
|
||
|
||
@property
|
||
def permissions(self) -> pkg_iam.PermissionsAPI:
|
||
"""Permissions API are used to create read, write, edit, update and manage access for various users on different objects and endpoints."""
|
||
return self._permissions
|
||
|
||
@property
|
||
def pipelines(self) -> pkg_pipelines.PipelinesAPI:
|
||
"""The Lakeflow Spark Declarative Pipelines API allows you to create, edit, delete, start, and view details about pipelines."""
|
||
return self._pipelines
|
||
|
||
@property
|
||
def policies(self) -> pkg_catalog.PoliciesAPI:
|
||
"""Attribute-Based Access Control (ABAC) provides high leverage governance for enforcing compliance policies in Unity Catalog."""
|
||
return self._policies
|
||
|
||
@property
|
||
def policy_compliance_for_clusters(self) -> pkg_compute.PolicyComplianceForClustersAPI:
|
||
"""The policy compliance APIs allow you to view and manage the policy compliance status of clusters in your workspace."""
|
||
return self._policy_compliance_for_clusters
|
||
|
||
@property
|
||
def policy_compliance_for_jobs(self) -> pkg_jobs.PolicyComplianceForJobsAPI:
|
||
"""The compliance APIs allow you to view and manage the policy compliance status of jobs in your workspace."""
|
||
return self._policy_compliance_for_jobs
|
||
|
||
@property
|
||
def policy_families(self) -> pkg_compute.PolicyFamiliesAPI:
|
||
"""View available policy families."""
|
||
return self._policy_families
|
||
|
||
@property
|
||
def postgres(self) -> pkg_postgres.PostgresAPI:
|
||
"""Use the Postgres API to create and manage Lakebase Autoscaling Postgres infrastructure, including projects, branches, compute endpoints, and roles."""
|
||
return self._postgres
|
||
|
||
@property
|
||
def provider_exchange_filters(self) -> pkg_marketplace.ProviderExchangeFiltersAPI:
|
||
"""Marketplace exchanges filters curate which groups can access an exchange."""
|
||
return self._provider_exchange_filters
|
||
|
||
@property
|
||
def provider_exchanges(self) -> pkg_marketplace.ProviderExchangesAPI:
|
||
"""Marketplace exchanges allow providers to share their listings with a curated set of customers."""
|
||
return self._provider_exchanges
|
||
|
||
@property
|
||
def provider_files(self) -> pkg_marketplace.ProviderFilesAPI:
|
||
"""Marketplace offers a set of file APIs for various purposes such as preview notebooks and provider icons."""
|
||
return self._provider_files
|
||
|
||
@property
|
||
def provider_listings(self) -> pkg_marketplace.ProviderListingsAPI:
|
||
"""Listings are the core entities in the Marketplace."""
|
||
return self._provider_listings
|
||
|
||
@property
|
||
def provider_personalization_requests(self) -> pkg_marketplace.ProviderPersonalizationRequestsAPI:
|
||
"""Personalization requests are an alternate to instantly available listings."""
|
||
return self._provider_personalization_requests
|
||
|
||
@property
|
||
def provider_provider_analytics_dashboards(self) -> pkg_marketplace.ProviderProviderAnalyticsDashboardsAPI:
|
||
"""Manage templated analytics solution for providers."""
|
||
return self._provider_provider_analytics_dashboards
|
||
|
||
@property
|
||
def provider_providers(self) -> pkg_marketplace.ProviderProvidersAPI:
|
||
"""Providers are entities that manage assets in Marketplace."""
|
||
return self._provider_providers
|
||
|
||
@property
|
||
def providers(self) -> pkg_sharing.ProvidersAPI:
|
||
"""A data provider is an object representing the organization in the real world who shares the data."""
|
||
return self._providers
|
||
|
||
@property
|
||
def quality_monitor_v2(self) -> pkg_qualitymonitorv2.QualityMonitorV2API:
|
||
"""Deprecated: Please use the Data Quality Monitoring API instead (REST: /api/data-quality/v1/monitors)."""
|
||
return self._quality_monitor_v2
|
||
|
||
@property
|
||
def quality_monitors(self) -> pkg_catalog.QualityMonitorsAPI:
|
||
"""Deprecated: Please use the Data Quality Monitors API instead (REST: /api/data-quality/v1/monitors), which manages both Data Profiling and Anomaly Detection."""
|
||
return self._quality_monitors
|
||
|
||
@property
|
||
def queries(self) -> pkg_sql.QueriesAPI:
|
||
"""The queries API can be used to perform CRUD operations on queries."""
|
||
return self._queries
|
||
|
||
@property
|
||
def queries_legacy(self) -> pkg_sql.QueriesLegacyAPI:
|
||
"""These endpoints are used for CRUD operations on query definitions."""
|
||
return self._queries_legacy
|
||
|
||
@property
|
||
def query_history(self) -> pkg_sql.QueryHistoryAPI:
|
||
"""A service responsible for storing and retrieving the list of queries run against SQL endpoints and serverless compute."""
|
||
return self._query_history
|
||
|
||
@property
|
||
def query_visualizations(self) -> pkg_sql.QueryVisualizationsAPI:
|
||
"""This is an evolving API that facilitates the addition and removal of visualizations from existing queries in the Databricks Workspace."""
|
||
return self._query_visualizations
|
||
|
||
@property
|
||
def query_visualizations_legacy(self) -> pkg_sql.QueryVisualizationsLegacyAPI:
|
||
"""This is an evolving API that facilitates the addition and removal of vizualisations from existing queries within the Databricks Workspace."""
|
||
return self._query_visualizations_legacy
|
||
|
||
@property
|
||
def recipient_activation(self) -> pkg_sharing.RecipientActivationAPI:
|
||
"""The Recipient Activation API is only applicable in the open sharing model where the recipient object has the authentication type of `TOKEN`."""
|
||
return self._recipient_activation
|
||
|
||
@property
|
||
def recipient_federation_policies(self) -> pkg_sharing.RecipientFederationPoliciesAPI:
|
||
"""The Recipient Federation Policies APIs are only applicable in the open sharing model where the recipient object has the authentication type of `OIDC_RECIPIENT`, enabling data sharing from Databricks to non-Databricks recipients."""
|
||
return self._recipient_federation_policies
|
||
|
||
@property
|
||
def recipients(self) -> pkg_sharing.RecipientsAPI:
|
||
"""A recipient is an object you create using :method:recipients/create to represent an organization which you want to allow access shares."""
|
||
return self._recipients
|
||
|
||
@property
|
||
def redash_config(self) -> pkg_sql.RedashConfigAPI:
|
||
"""Redash V2 service for workspace configurations (internal)."""
|
||
return self._redash_config
|
||
|
||
@property
|
||
def registered_models(self) -> pkg_catalog.RegisteredModelsAPI:
|
||
"""Databricks provides a hosted version of MLflow Model Registry in Unity Catalog."""
|
||
return self._registered_models
|
||
|
||
@property
|
||
def repos(self) -> pkg_workspace.ReposAPI:
|
||
"""The Repos API allows users to manage their git repos."""
|
||
return self._repos
|
||
|
||
@property
|
||
def resource_quotas(self) -> pkg_catalog.ResourceQuotasAPI:
|
||
"""Unity Catalog enforces resource quotas on all securable objects, which limits the number of resources that can be created."""
|
||
return self._resource_quotas
|
||
|
||
@property
|
||
def rfa(self) -> pkg_catalog.RfaAPI:
|
||
"""Request for Access enables users to request access for Unity Catalog securables."""
|
||
return self._rfa
|
||
|
||
@property
|
||
def schemas(self) -> pkg_catalog.SchemasAPI:
|
||
"""A schema (also called a database) is the second layer of Unity Catalog’s three-level namespace."""
|
||
return self._schemas
|
||
|
||
@property
|
||
def secrets(self) -> pkg_workspace.SecretsAPI:
|
||
"""The Secrets API allows you to manage secrets, secret scopes, and access permissions."""
|
||
return self._secrets
|
||
|
||
@property
|
||
def service_principal_secrets_proxy(self) -> pkg_oauth2.ServicePrincipalSecretsProxyAPI:
|
||
"""These APIs enable administrators to manage service principal secrets at the workspace level."""
|
||
return self._service_principal_secrets_proxy
|
||
|
||
@property
|
||
def service_principals_v2(self) -> pkg_iam.ServicePrincipalsV2API:
|
||
"""Identities for use with jobs, automated tools, and systems such as scripts, apps, and CI/CD platforms."""
|
||
return self._service_principals_v2
|
||
|
||
@property
|
||
def serving_endpoints(self) -> ServingEndpointsExt:
|
||
"""The Serving Endpoints API allows you to create, update, and delete model serving endpoints."""
|
||
return self._serving_endpoints
|
||
|
||
@property
|
||
def serving_endpoints_data_plane(self) -> pkg_serving.ServingEndpointsDataPlaneAPI:
|
||
"""Serving endpoints DataPlane provides a set of operations to interact with data plane endpoints for Serving endpoints service."""
|
||
return self._serving_endpoints_data_plane
|
||
|
||
@property
|
||
def settings(self) -> pkg_settings.SettingsAPI:
|
||
"""Workspace Settings API allows users to manage settings at the workspace level."""
|
||
return self._settings
|
||
|
||
@property
|
||
def shares(self) -> pkg_sharing.SharesAPI:
|
||
"""A share is a container instantiated with :method:shares/create."""
|
||
return self._shares
|
||
|
||
@property
|
||
def statement_execution(self) -> pkg_sql.StatementExecutionAPI:
|
||
"""The Databricks SQL Statement Execution API can be used to execute SQL statements on a SQL warehouse and fetch the result."""
|
||
return self._statement_execution
|
||
|
||
@property
|
||
def storage_credentials(self) -> pkg_catalog.StorageCredentialsAPI:
|
||
"""A storage credential represents an authentication and authorization mechanism for accessing data stored on your cloud tenant."""
|
||
return self._storage_credentials
|
||
|
||
@property
|
||
def system_schemas(self) -> pkg_catalog.SystemSchemasAPI:
|
||
"""A system schema is a schema that lives within the system catalog."""
|
||
return self._system_schemas
|
||
|
||
@property
|
||
def table_constraints(self) -> pkg_catalog.TableConstraintsAPI:
|
||
"""Primary key and foreign key constraints encode relationships between fields in tables."""
|
||
return self._table_constraints
|
||
|
||
@property
|
||
def tables(self) -> pkg_catalog.TablesAPI:
|
||
"""A table resides in the third layer of Unity Catalog’s three-level namespace."""
|
||
return self._tables
|
||
|
||
@property
|
||
def tag_policies(self) -> pkg_tags.TagPoliciesAPI:
|
||
"""The Tag Policy API allows you to manage policies for governed tags in Databricks."""
|
||
return self._tag_policies
|
||
|
||
@property
|
||
def temporary_path_credentials(self) -> pkg_catalog.TemporaryPathCredentialsAPI:
|
||
"""Temporary Path Credentials refer to short-lived, downscoped credentials used to access external cloud storage locations registered in Databricks."""
|
||
return self._temporary_path_credentials
|
||
|
||
@property
|
||
def temporary_table_credentials(self) -> pkg_catalog.TemporaryTableCredentialsAPI:
|
||
"""Temporary Table Credentials refer to short-lived, downscoped credentials used to access cloud storage locations where table data is stored in Databricks."""
|
||
return self._temporary_table_credentials
|
||
|
||
@property
|
||
def token_management(self) -> pkg_settings.TokenManagementAPI:
|
||
"""Enables administrators to get all tokens and delete tokens for other users."""
|
||
return self._token_management
|
||
|
||
@property
|
||
def tokens(self) -> pkg_settings.TokensAPI:
|
||
"""The Token API allows you to create, list, and revoke tokens that can be used to authenticate and access Databricks REST APIs."""
|
||
return self._tokens
|
||
|
||
@property
|
||
def users_v2(self) -> pkg_iam.UsersV2API:
|
||
"""User identities recognized by Databricks and represented by email addresses."""
|
||
return self._users_v2
|
||
|
||
@property
|
||
def vector_search_endpoints(self) -> pkg_vectorsearch.VectorSearchEndpointsAPI:
|
||
"""**Endpoint**: Represents the compute resources to host vector search indexes."""
|
||
return self._vector_search_endpoints
|
||
|
||
@property
|
||
def vector_search_indexes(self) -> pkg_vectorsearch.VectorSearchIndexesAPI:
|
||
"""**Index**: An efficient representation of your embedding vectors that supports real-time and efficient approximate nearest neighbor (ANN) search queries."""
|
||
return self._vector_search_indexes
|
||
|
||
@property
|
||
def volumes(self) -> pkg_catalog.VolumesAPI:
|
||
"""Volumes are a Unity Catalog (UC) capability for accessing, storing, governing, organizing and processing files."""
|
||
return self._volumes
|
||
|
||
@property
|
||
def warehouses(self) -> pkg_sql.WarehousesAPI:
|
||
"""A SQL warehouse is a compute resource that lets you run SQL commands on data objects within Databricks SQL."""
|
||
return self._warehouses
|
||
|
||
@property
|
||
def workspace(self) -> WorkspaceExt:
|
||
"""The Workspace API allows you to list, import, export, and delete notebooks and folders."""
|
||
return self._workspace
|
||
|
||
@property
|
||
def workspace_bindings(self) -> pkg_catalog.WorkspaceBindingsAPI:
|
||
"""A securable in Databricks can be configured as __OPEN__ or __ISOLATED__."""
|
||
return self._workspace_bindings
|
||
|
||
@property
|
||
def workspace_conf(self) -> pkg_settings.WorkspaceConfAPI:
|
||
"""This API allows updating known workspace settings for advanced users."""
|
||
return self._workspace_conf
|
||
|
||
@property
|
||
def workspace_entity_tag_assignments(self) -> pkg_tags.WorkspaceEntityTagAssignmentsAPI:
|
||
"""Manage tag assignments on workspace-scoped objects."""
|
||
return self._workspace_entity_tag_assignments
|
||
|
||
@property
|
||
def workspace_iam_v2(self) -> pkg_iamv2.WorkspaceIamV2API:
|
||
"""These APIs are used to manage identities and the workspace access of these identities in <Databricks>."""
|
||
return self._workspace_iam_v2
|
||
|
||
@property
|
||
def workspace_settings_v2(self) -> pkg_settingsv2.WorkspaceSettingsV2API:
|
||
"""APIs to manage workspace level settings."""
|
||
return self._workspace_settings_v2
|
||
|
||
@property
|
||
def groups(self) -> pkg_iam.GroupsAPI:
|
||
"""Groups simplify identity management, making it easier to assign access to Databricks workspace, data, and other securable objects."""
|
||
return self._groups
|
||
|
||
@property
|
||
def service_principals(self) -> pkg_iam.ServicePrincipalsAPI:
|
||
"""Identities for use with jobs, automated tools, and systems such as scripts, apps, and CI/CD platforms."""
|
||
return self._service_principals
|
||
|
||
@property
|
||
def users(self) -> pkg_iam.UsersAPI:
|
||
"""User identities recognized by Databricks and represented by email addresses."""
|
||
return self._users
|
||
|
||
@property
|
||
def files(self) -> FilesExt:
|
||
"""The Files API is a standard HTTP API that allows you to read, write, list, and delete files and directories by referring to their URI."""
|
||
return self._files
|
||
|
||
def get_workspace_id(self) -> int:
|
||
"""Get the workspace ID of the workspace that this client is connected to."""
|
||
response = self._api_client.do("GET", "/api/2.0/preview/scim/v2/Me", response_headers=["X-Databricks-Org-Id"])
|
||
return int(response["X-Databricks-Org-Id"])
|
||
|
||
def __repr__(self):
|
||
return f"WorkspaceClient(host='{self._config.host}', auth_type='{self._config.auth_type}', ...)"
|
||
|
||
|
||
class AccountClient:
|
||
"""
|
||
The AccountClient is a client for the account-level Databricks REST API.
|
||
"""
|
||
|
||
def __init__(
|
||
self,
|
||
*,
|
||
host: Optional[str] = None,
|
||
account_id: Optional[str] = None,
|
||
username: Optional[str] = None,
|
||
password: Optional[str] = None,
|
||
client_id: Optional[str] = None,
|
||
client_secret: Optional[str] = None,
|
||
token: Optional[str] = None,
|
||
profile: Optional[str] = None,
|
||
config_file: Optional[str] = None,
|
||
azure_workspace_resource_id: Optional[str] = None,
|
||
azure_client_secret: Optional[str] = None,
|
||
azure_client_id: Optional[str] = None,
|
||
azure_tenant_id: Optional[str] = None,
|
||
azure_environment: Optional[str] = None,
|
||
auth_type: Optional[str] = None,
|
||
cluster_id: Optional[str] = None,
|
||
google_credentials: Optional[str] = None,
|
||
google_service_account: Optional[str] = None,
|
||
debug_truncate_bytes: Optional[int] = None,
|
||
debug_headers: Optional[bool] = None,
|
||
product="unknown",
|
||
product_version="0.0.0",
|
||
credentials_strategy: Optional[CredentialsStrategy] = None,
|
||
credentials_provider: Optional[CredentialsStrategy] = None,
|
||
token_audience: Optional[str] = None,
|
||
config: Optional[client.Config] = None,
|
||
custom_headers: Optional[dict] = None,
|
||
):
|
||
if not config:
|
||
config = client.Config(
|
||
host=host,
|
||
account_id=account_id,
|
||
username=username,
|
||
password=password,
|
||
client_id=client_id,
|
||
client_secret=client_secret,
|
||
token=token,
|
||
profile=profile,
|
||
config_file=config_file,
|
||
azure_workspace_resource_id=azure_workspace_resource_id,
|
||
azure_client_secret=azure_client_secret,
|
||
azure_client_id=azure_client_id,
|
||
azure_tenant_id=azure_tenant_id,
|
||
azure_environment=azure_environment,
|
||
auth_type=auth_type,
|
||
cluster_id=cluster_id,
|
||
google_credentials=google_credentials,
|
||
google_service_account=google_service_account,
|
||
credentials_strategy=credentials_strategy,
|
||
credentials_provider=credentials_provider,
|
||
debug_truncate_bytes=debug_truncate_bytes,
|
||
debug_headers=debug_headers,
|
||
product=product,
|
||
product_version=product_version,
|
||
token_audience=token_audience,
|
||
custom_headers=custom_headers,
|
||
)
|
||
self._config = config.copy()
|
||
self._api_client = client.ApiClient(self._config)
|
||
self._access_control = pkg_iam.AccountAccessControlAPI(self._api_client)
|
||
self._billable_usage = pkg_billing.BillableUsageAPI(self._api_client)
|
||
self._budget_policy = pkg_billing.BudgetPolicyAPI(self._api_client)
|
||
self._budgets = pkg_billing.BudgetsAPI(self._api_client)
|
||
self._credentials = pkg_provisioning.CredentialsAPI(self._api_client)
|
||
self._custom_app_integration = pkg_oauth2.CustomAppIntegrationAPI(self._api_client)
|
||
self._encryption_keys = pkg_provisioning.EncryptionKeysAPI(self._api_client)
|
||
self._endpoints = pkg_networking.EndpointsAPI(self._api_client)
|
||
self._federation_policy = pkg_oauth2.AccountFederationPolicyAPI(self._api_client)
|
||
self._groups_v2 = pkg_iam.AccountGroupsV2API(self._api_client)
|
||
self._iam_v2 = pkg_iamv2.AccountIamV2API(self._api_client)
|
||
self._ip_access_lists = pkg_settings.AccountIpAccessListsAPI(self._api_client)
|
||
self._log_delivery = pkg_billing.LogDeliveryAPI(self._api_client)
|
||
self._metastore_assignments = pkg_catalog.AccountMetastoreAssignmentsAPI(self._api_client)
|
||
self._metastores = pkg_catalog.AccountMetastoresAPI(self._api_client)
|
||
self._network_connectivity = pkg_settings.NetworkConnectivityAPI(self._api_client)
|
||
self._network_policies = pkg_settings.NetworkPoliciesAPI(self._api_client)
|
||
self._networks = pkg_provisioning.NetworksAPI(self._api_client)
|
||
self._o_auth_published_apps = pkg_oauth2.OAuthPublishedAppsAPI(self._api_client)
|
||
self._private_access = pkg_provisioning.PrivateAccessAPI(self._api_client)
|
||
self._published_app_integration = pkg_oauth2.PublishedAppIntegrationAPI(self._api_client)
|
||
self._service_principal_federation_policy = pkg_oauth2.ServicePrincipalFederationPolicyAPI(self._api_client)
|
||
self._service_principal_secrets = pkg_oauth2.ServicePrincipalSecretsAPI(self._api_client)
|
||
self._service_principals_v2 = pkg_iam.AccountServicePrincipalsV2API(self._api_client)
|
||
self._settings = pkg_settings.AccountSettingsAPI(self._api_client)
|
||
self._settings_v2 = pkg_settingsv2.AccountSettingsV2API(self._api_client)
|
||
self._storage = pkg_provisioning.StorageAPI(self._api_client)
|
||
self._storage_credentials = pkg_catalog.AccountStorageCredentialsAPI(self._api_client)
|
||
self._usage_dashboards = pkg_billing.UsageDashboardsAPI(self._api_client)
|
||
self._users_v2 = pkg_iam.AccountUsersV2API(self._api_client)
|
||
self._vpc_endpoints = pkg_provisioning.VpcEndpointsAPI(self._api_client)
|
||
self._workspace_assignment = pkg_iam.WorkspaceAssignmentAPI(self._api_client)
|
||
self._workspace_network_configuration = pkg_settings.WorkspaceNetworkConfigurationAPI(self._api_client)
|
||
self._workspaces = pkg_provisioning.WorkspacesAPI(self._api_client)
|
||
self._groups = pkg_iam.AccountGroupsAPI(self._api_client)
|
||
self._service_principals = pkg_iam.AccountServicePrincipalsAPI(self._api_client)
|
||
self._users = pkg_iam.AccountUsersAPI(self._api_client)
|
||
|
||
@property
|
||
def config(self) -> client.Config:
|
||
return self._config
|
||
|
||
@property
|
||
def api_client(self) -> client.ApiClient:
|
||
return self._api_client
|
||
|
||
@property
|
||
def access_control(self) -> pkg_iam.AccountAccessControlAPI:
|
||
"""These APIs manage access rules on resources in an account."""
|
||
return self._access_control
|
||
|
||
@property
|
||
def billable_usage(self) -> pkg_billing.BillableUsageAPI:
|
||
"""This API allows you to download billable usage logs for the specified account and date range."""
|
||
return self._billable_usage
|
||
|
||
@property
|
||
def budget_policy(self) -> pkg_billing.BudgetPolicyAPI:
|
||
"""A service serves REST API about Budget policies."""
|
||
return self._budget_policy
|
||
|
||
@property
|
||
def budgets(self) -> pkg_billing.BudgetsAPI:
|
||
"""These APIs manage budget configurations for this account."""
|
||
return self._budgets
|
||
|
||
@property
|
||
def credentials(self) -> pkg_provisioning.CredentialsAPI:
|
||
"""These APIs manage credential configurations for this workspace."""
|
||
return self._credentials
|
||
|
||
@property
|
||
def custom_app_integration(self) -> pkg_oauth2.CustomAppIntegrationAPI:
|
||
"""These APIs enable administrators to manage custom OAuth app integrations, which is required for adding/using Custom OAuth App Integration like Tableau Cloud for Databricks in AWS cloud."""
|
||
return self._custom_app_integration
|
||
|
||
@property
|
||
def encryption_keys(self) -> pkg_provisioning.EncryptionKeysAPI:
|
||
"""These APIs manage encryption key configurations for this workspace (optional)."""
|
||
return self._encryption_keys
|
||
|
||
@property
|
||
def endpoints(self) -> pkg_networking.EndpointsAPI:
|
||
"""These APIs manage endpoint configurations for this account."""
|
||
return self._endpoints
|
||
|
||
@property
|
||
def federation_policy(self) -> pkg_oauth2.AccountFederationPolicyAPI:
|
||
"""These APIs manage account federation policies."""
|
||
return self._federation_policy
|
||
|
||
@property
|
||
def groups_v2(self) -> pkg_iam.AccountGroupsV2API:
|
||
"""Groups simplify identity management, making it easier to assign access to Databricks account, data, and other securable objects."""
|
||
return self._groups_v2
|
||
|
||
@property
|
||
def iam_v2(self) -> pkg_iamv2.AccountIamV2API:
|
||
"""These APIs are used to manage identities and the workspace access of these identities in <Databricks>."""
|
||
return self._iam_v2
|
||
|
||
@property
|
||
def ip_access_lists(self) -> pkg_settings.AccountIpAccessListsAPI:
|
||
"""The Accounts IP Access List API enables account admins to configure IP access lists for access to the account console."""
|
||
return self._ip_access_lists
|
||
|
||
@property
|
||
def log_delivery(self) -> pkg_billing.LogDeliveryAPI:
|
||
"""These APIs manage log delivery configurations for this account."""
|
||
return self._log_delivery
|
||
|
||
@property
|
||
def metastore_assignments(self) -> pkg_catalog.AccountMetastoreAssignmentsAPI:
|
||
"""These APIs manage metastore assignments to a workspace."""
|
||
return self._metastore_assignments
|
||
|
||
@property
|
||
def metastores(self) -> pkg_catalog.AccountMetastoresAPI:
|
||
"""These APIs manage Unity Catalog metastores for an account."""
|
||
return self._metastores
|
||
|
||
@property
|
||
def network_connectivity(self) -> pkg_settings.NetworkConnectivityAPI:
|
||
"""These APIs provide configurations for the network connectivity of your workspaces for serverless compute resources."""
|
||
return self._network_connectivity
|
||
|
||
@property
|
||
def network_policies(self) -> pkg_settings.NetworkPoliciesAPI:
|
||
"""These APIs manage network policies for this account."""
|
||
return self._network_policies
|
||
|
||
@property
|
||
def networks(self) -> pkg_provisioning.NetworksAPI:
|
||
"""These APIs manage network configurations for customer-managed VPCs (optional)."""
|
||
return self._networks
|
||
|
||
@property
|
||
def o_auth_published_apps(self) -> pkg_oauth2.OAuthPublishedAppsAPI:
|
||
"""These APIs enable administrators to view all the available published OAuth applications in Databricks."""
|
||
return self._o_auth_published_apps
|
||
|
||
@property
|
||
def private_access(self) -> pkg_provisioning.PrivateAccessAPI:
|
||
"""These APIs manage private access settings for this account."""
|
||
return self._private_access
|
||
|
||
@property
|
||
def published_app_integration(self) -> pkg_oauth2.PublishedAppIntegrationAPI:
|
||
"""These APIs enable administrators to manage published OAuth app integrations, which is required for adding/using Published OAuth App Integration like Tableau Desktop for Databricks in AWS cloud."""
|
||
return self._published_app_integration
|
||
|
||
@property
|
||
def service_principal_federation_policy(self) -> pkg_oauth2.ServicePrincipalFederationPolicyAPI:
|
||
"""These APIs manage service principal federation policies."""
|
||
return self._service_principal_federation_policy
|
||
|
||
@property
|
||
def service_principal_secrets(self) -> pkg_oauth2.ServicePrincipalSecretsAPI:
|
||
"""These APIs enable administrators to manage service principal secrets."""
|
||
return self._service_principal_secrets
|
||
|
||
@property
|
||
def service_principals_v2(self) -> pkg_iam.AccountServicePrincipalsV2API:
|
||
"""Identities for use with jobs, automated tools, and systems such as scripts, apps, and CI/CD platforms."""
|
||
return self._service_principals_v2
|
||
|
||
@property
|
||
def settings(self) -> pkg_settings.AccountSettingsAPI:
|
||
"""Accounts Settings API allows users to manage settings at the account level."""
|
||
return self._settings
|
||
|
||
@property
|
||
def settings_v2(self) -> pkg_settingsv2.AccountSettingsV2API:
|
||
"""APIs to manage account level settings."""
|
||
return self._settings_v2
|
||
|
||
@property
|
||
def storage(self) -> pkg_provisioning.StorageAPI:
|
||
"""These APIs manage storage configurations for this workspace."""
|
||
return self._storage
|
||
|
||
@property
|
||
def storage_credentials(self) -> pkg_catalog.AccountStorageCredentialsAPI:
|
||
"""These APIs manage storage credentials for a particular metastore."""
|
||
return self._storage_credentials
|
||
|
||
@property
|
||
def usage_dashboards(self) -> pkg_billing.UsageDashboardsAPI:
|
||
"""These APIs manage usage dashboards for this account."""
|
||
return self._usage_dashboards
|
||
|
||
@property
|
||
def users_v2(self) -> pkg_iam.AccountUsersV2API:
|
||
"""User identities recognized by Databricks and represented by email addresses."""
|
||
return self._users_v2
|
||
|
||
@property
|
||
def vpc_endpoints(self) -> pkg_provisioning.VpcEndpointsAPI:
|
||
"""These APIs manage VPC endpoint configurations for this account."""
|
||
return self._vpc_endpoints
|
||
|
||
@property
|
||
def workspace_assignment(self) -> pkg_iam.WorkspaceAssignmentAPI:
|
||
"""The Workspace Permission Assignment API allows you to manage workspace permissions for principals in your account."""
|
||
return self._workspace_assignment
|
||
|
||
@property
|
||
def workspace_network_configuration(self) -> pkg_settings.WorkspaceNetworkConfigurationAPI:
|
||
"""These APIs allow configuration of network settings for Databricks workspaces by selecting which network policy to associate with the workspace."""
|
||
return self._workspace_network_configuration
|
||
|
||
@property
|
||
def workspaces(self) -> pkg_provisioning.WorkspacesAPI:
|
||
"""These APIs manage workspaces for this account."""
|
||
return self._workspaces
|
||
|
||
@property
|
||
def groups(self) -> pkg_iam.AccountGroupsAPI:
|
||
"""Groups simplify identity management, making it easier to assign access to Databricks account, data, and other securable objects."""
|
||
return self._groups
|
||
|
||
@property
|
||
def service_principals(self) -> pkg_iam.AccountServicePrincipalsAPI:
|
||
"""Identities for use with jobs, automated tools, and systems such as scripts, apps, and CI/CD platforms."""
|
||
return self._service_principals
|
||
|
||
@property
|
||
def users(self) -> pkg_iam.AccountUsersAPI:
|
||
"""User identities recognized by Databricks and represented by email addresses."""
|
||
return self._users
|
||
|
||
def get_workspace_client(self, workspace: Workspace) -> WorkspaceClient:
|
||
"""Constructs a ``WorkspaceClient`` for the given workspace.
|
||
|
||
Returns a ``WorkspaceClient`` that is configured to use the same
|
||
credentials as this ``AccountClient``. The underlying config is
|
||
copied from this ``AccountClient``, but the ``host`` and
|
||
``azure_workspace_resource_id`` are overridden to match the
|
||
given workspace, and the ``account_id`` field is cleared.
|
||
|
||
Usage:
|
||
|
||
.. code-block::
|
||
|
||
wss = list(a.workspaces.list())
|
||
if len(wss) == 0:
|
||
pytest.skip("no workspaces")
|
||
w = a.get_workspace_client(wss[0])
|
||
assert w.current_user.me().active
|
||
|
||
:param workspace: The workspace to construct a client for.
|
||
:return: A ``WorkspaceClient`` for the given workspace.
|
||
"""
|
||
config = self._config.deep_copy()
|
||
config.host = config.environment.deployment_url(workspace.deployment_name)
|
||
config.azure_workspace_resource_id = azure.get_azure_resource_id(workspace)
|
||
config.account_id = None
|
||
config.workspace_id = workspace.workspace_id
|
||
config.init_auth()
|
||
return WorkspaceClient(config=config)
|
||
|
||
def __repr__(self):
|
||
return f"AccountClient(account_id='{self._config.account_id}', auth_type='{self._config.auth_type}', ...)"
|