diff --git a/CHANGELOG.md b/CHANGELOG.md index ba19e3ef..9afd7acc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,50 @@ # Version changelog +## [Release] Release v0.42.0 + +### Bug Fixes + + * Fix docs generation when two services have the same name ([#872](https://github.com/databricks/databricks-sdk-py/pull/872)). + + +### Internal Changes + + * Add CICD environment to the User Agent ([#866](https://github.com/databricks/databricks-sdk-py/pull/866)). + * Add unit tests for retriable requests ([#879](https://github.com/databricks/databricks-sdk-py/pull/879)). + * Extract "before retry" handler, use it to rewind the stream ([#878](https://github.com/databricks/databricks-sdk-py/pull/878)). + * Update Model Serving `http_request` mixin to correctly use the underlying API. ([#876](https://github.com/databricks/databricks-sdk-py/pull/876)). + + +### API Changes: + + * Added [a.budget_policy](https://databricks-sdk-py.readthedocs.io/en/latest/account/budget_policy.html) account-level service. + * Added [a.enable_ip_access_lists](https://databricks-sdk-py.readthedocs.io/en/latest/account/account_settings/enable_ip_access_lists.html) account-level service. + * Added `review_state`, `reviews` and `runner_collaborators` fields for `databricks.sdk.service.cleanrooms.CleanRoomAssetNotebook`. + * Added `statement_id` field for `databricks.sdk.service.dashboards.QueryAttachment`. + * Added `effective_performance_target` field for `databricks.sdk.service.jobs.BaseRun`. + * Added `performance_target` field for `databricks.sdk.service.jobs.CreateJob`. + * Added `performance_target` field for `databricks.sdk.service.jobs.JobSettings`. + * Added `effective_performance_target` field for `databricks.sdk.service.jobs.Run`. + * Added `performance_target` field for `databricks.sdk.service.jobs.RunNow`. + * Added `effective_performance_target` field for `databricks.sdk.service.jobs.RunTask`. + * Added `run_as_repl` field for `databricks.sdk.service.jobs.SparkJarTask`. + * Added `user_authorized_scopes` field for `databricks.sdk.service.oauth2.CreateCustomAppIntegration`. + * Added `user_authorized_scopes` field for `databricks.sdk.service.oauth2.GetCustomAppIntegrationOutput`. + * Added `user_authorized_scopes` field for `databricks.sdk.service.oauth2.UpdateCustomAppIntegration`. + * Added `contents` field for `databricks.sdk.service.serving.HttpRequestResponse`. + * Added . + * Added . + * Added . + * Changed `create()` method for [w.serving_endpoints](https://databricks-sdk-py.readthedocs.io/en/latest/workspace/serving_endpoints.html) workspace-level service with new required argument order. + * Changed `http_request()` method for [w.serving_endpoints](https://databricks-sdk-py.readthedocs.io/en/latest/workspace/serving_endpoints.html) workspace-level service to type `http_request()` method for [w.serving_endpoints](https://databricks-sdk-py.readthedocs.io/en/latest/workspace/serving_endpoints.html) workspace-level service. + * Changed `http_request()` method for [w.serving_endpoints](https://databricks-sdk-py.readthedocs.io/en/latest/workspace/serving_endpoints.html) workspace-level service to return `databricks.sdk.service.serving.HttpRequestResponse` dataclass. + * Changed `config` field for `databricks.sdk.service.serving.CreateServingEndpoint` to no longer be required. + * Removed `securable_kind` field for `databricks.sdk.service.catalog.CatalogInfo`. + * Removed `securable_kind` field for `databricks.sdk.service.catalog.ConnectionInfo`. + * Removed `status_code` and `text` fields for `databricks.sdk.service.serving.ExternalFunctionResponse`. + +OpenAPI SHA: 840c660106f820a1a5dff931d51fa5f65cd9fdd9, Date: 2025-01-28 + ## [Release] Release v0.41.0 ### New Features and Improvements diff --git a/databricks/sdk/__init__.py b/databricks/sdk/__init__.py index c7f9295a..1892069c 100755 --- a/databricks/sdk/__init__.py +++ b/databricks/sdk/__init__.py @@ -5,6 +5,7 @@ import databricks.sdk.core as client import databricks.sdk.dbutils as dbutils +import databricks.sdk.service as service from databricks.sdk import azure from databricks.sdk.credentials_provider import CredentialsStrategy from databricks.sdk.mixins.compute import ClustersExt @@ -190,102 +191,106 @@ def __init__(self, self._dbutils = _make_dbutils(self._config) self._api_client = client.ApiClient(self._config) serving_endpoints = ServingEndpointsExt(self._api_client) - self._access_control = AccessControlAPI(self._api_client) - self._account_access_control_proxy = AccountAccessControlProxyAPI(self._api_client) - self._alerts = AlertsAPI(self._api_client) - self._alerts_legacy = AlertsLegacyAPI(self._api_client) - self._apps = AppsAPI(self._api_client) - self._artifact_allowlists = ArtifactAllowlistsAPI(self._api_client) - self._catalogs = CatalogsAPI(self._api_client) - self._clean_room_assets = CleanRoomAssetsAPI(self._api_client) - self._clean_room_task_runs = CleanRoomTaskRunsAPI(self._api_client) - self._clean_rooms = CleanRoomsAPI(self._api_client) - self._cluster_policies = ClusterPoliciesAPI(self._api_client) + self._access_control = service.iam.AccessControlAPI(self._api_client) + self._account_access_control_proxy = service.iam.AccountAccessControlProxyAPI(self._api_client) + self._alerts = service.sql.AlertsAPI(self._api_client) + self._alerts_legacy = service.sql.AlertsLegacyAPI(self._api_client) + self._apps = service.apps.AppsAPI(self._api_client) + self._artifact_allowlists = service.catalog.ArtifactAllowlistsAPI(self._api_client) + self._catalogs = service.catalog.CatalogsAPI(self._api_client) + self._clean_room_assets = service.cleanrooms.CleanRoomAssetsAPI(self._api_client) + self._clean_room_task_runs = service.cleanrooms.CleanRoomTaskRunsAPI(self._api_client) + self._clean_rooms = service.cleanrooms.CleanRoomsAPI(self._api_client) + self._cluster_policies = service.compute.ClusterPoliciesAPI(self._api_client) self._clusters = ClustersExt(self._api_client) - self._command_execution = CommandExecutionAPI(self._api_client) - self._connections = ConnectionsAPI(self._api_client) - self._consumer_fulfillments = ConsumerFulfillmentsAPI(self._api_client) - self._consumer_installations = ConsumerInstallationsAPI(self._api_client) - self._consumer_listings = ConsumerListingsAPI(self._api_client) - self._consumer_personalization_requests = ConsumerPersonalizationRequestsAPI(self._api_client) - self._consumer_providers = ConsumerProvidersAPI(self._api_client) - self._credentials = CredentialsAPI(self._api_client) - self._credentials_manager = CredentialsManagerAPI(self._api_client) - self._current_user = CurrentUserAPI(self._api_client) - self._dashboard_widgets = DashboardWidgetsAPI(self._api_client) - self._dashboards = DashboardsAPI(self._api_client) - self._data_sources = DataSourcesAPI(self._api_client) + self._command_execution = service.compute.CommandExecutionAPI(self._api_client) + self._connections = service.catalog.ConnectionsAPI(self._api_client) + self._consumer_fulfillments = service.marketplace.ConsumerFulfillmentsAPI(self._api_client) + self._consumer_installations = service.marketplace.ConsumerInstallationsAPI(self._api_client) + self._consumer_listings = service.marketplace.ConsumerListingsAPI(self._api_client) + self._consumer_personalization_requests = service.marketplace.ConsumerPersonalizationRequestsAPI( + self._api_client) + self._consumer_providers = service.marketplace.ConsumerProvidersAPI(self._api_client) + self._credentials = service.catalog.CredentialsAPI(self._api_client) + self._credentials_manager = service.settings.CredentialsManagerAPI(self._api_client) + self._current_user = service.iam.CurrentUserAPI(self._api_client) + self._dashboard_widgets = service.sql.DashboardWidgetsAPI(self._api_client) + self._dashboards = service.sql.DashboardsAPI(self._api_client) + self._data_sources = service.sql.DataSourcesAPI(self._api_client) self._dbfs = DbfsExt(self._api_client) - self._dbsql_permissions = DbsqlPermissionsAPI(self._api_client) - self._experiments = ExperimentsAPI(self._api_client) - self._external_locations = ExternalLocationsAPI(self._api_client) + self._dbsql_permissions = service.sql.DbsqlPermissionsAPI(self._api_client) + self._experiments = service.ml.ExperimentsAPI(self._api_client) + self._external_locations = service.catalog.ExternalLocationsAPI(self._api_client) self._files = _make_files_client(self._api_client, self._config) - self._functions = FunctionsAPI(self._api_client) - self._genie = GenieAPI(self._api_client) - self._git_credentials = GitCredentialsAPI(self._api_client) - self._global_init_scripts = GlobalInitScriptsAPI(self._api_client) - self._grants = GrantsAPI(self._api_client) - self._groups = GroupsAPI(self._api_client) - self._instance_pools = InstancePoolsAPI(self._api_client) - self._instance_profiles = InstanceProfilesAPI(self._api_client) - self._ip_access_lists = IpAccessListsAPI(self._api_client) + self._functions = service.catalog.FunctionsAPI(self._api_client) + self._genie = service.dashboards.GenieAPI(self._api_client) + self._git_credentials = service.workspace.GitCredentialsAPI(self._api_client) + self._global_init_scripts = service.compute.GlobalInitScriptsAPI(self._api_client) + self._grants = service.catalog.GrantsAPI(self._api_client) + self._groups = service.iam.GroupsAPI(self._api_client) + self._instance_pools = service.compute.InstancePoolsAPI(self._api_client) + self._instance_profiles = service.compute.InstanceProfilesAPI(self._api_client) + self._ip_access_lists = service.settings.IpAccessListsAPI(self._api_client) self._jobs = JobsExt(self._api_client) - self._lakeview = LakeviewAPI(self._api_client) - self._libraries = LibrariesAPI(self._api_client) - self._metastores = MetastoresAPI(self._api_client) - self._model_registry = ModelRegistryAPI(self._api_client) - self._model_versions = ModelVersionsAPI(self._api_client) - self._notification_destinations = NotificationDestinationsAPI(self._api_client) - self._online_tables = OnlineTablesAPI(self._api_client) - self._permission_migration = PermissionMigrationAPI(self._api_client) - self._permissions = PermissionsAPI(self._api_client) - self._pipelines = PipelinesAPI(self._api_client) - self._policy_compliance_for_clusters = PolicyComplianceForClustersAPI(self._api_client) - self._policy_compliance_for_jobs = PolicyComplianceForJobsAPI(self._api_client) - self._policy_families = PolicyFamiliesAPI(self._api_client) - self._provider_exchange_filters = ProviderExchangeFiltersAPI(self._api_client) - self._provider_exchanges = ProviderExchangesAPI(self._api_client) - self._provider_files = ProviderFilesAPI(self._api_client) - self._provider_listings = ProviderListingsAPI(self._api_client) - self._provider_personalization_requests = ProviderPersonalizationRequestsAPI(self._api_client) - self._provider_provider_analytics_dashboards = ProviderProviderAnalyticsDashboardsAPI( + self._lakeview = service.dashboards.LakeviewAPI(self._api_client) + self._libraries = service.compute.LibrariesAPI(self._api_client) + self._metastores = service.catalog.MetastoresAPI(self._api_client) + self._model_registry = service.ml.ModelRegistryAPI(self._api_client) + self._model_versions = service.catalog.ModelVersionsAPI(self._api_client) + self._notification_destinations = service.settings.NotificationDestinationsAPI(self._api_client) + self._online_tables = service.catalog.OnlineTablesAPI(self._api_client) + self._permission_migration = service.iam.PermissionMigrationAPI(self._api_client) + self._permissions = service.iam.PermissionsAPI(self._api_client) + self._pipelines = service.pipelines.PipelinesAPI(self._api_client) + self._policy_compliance_for_clusters = service.compute.PolicyComplianceForClustersAPI( + self._api_client) + self._policy_compliance_for_jobs = service.jobs.PolicyComplianceForJobsAPI(self._api_client) + self._policy_families = service.compute.PolicyFamiliesAPI(self._api_client) + self._provider_exchange_filters = service.marketplace.ProviderExchangeFiltersAPI(self._api_client) + self._provider_exchanges = service.marketplace.ProviderExchangesAPI(self._api_client) + self._provider_files = service.marketplace.ProviderFilesAPI(self._api_client) + self._provider_listings = service.marketplace.ProviderListingsAPI(self._api_client) + self._provider_personalization_requests = service.marketplace.ProviderPersonalizationRequestsAPI( self._api_client) - self._provider_providers = ProviderProvidersAPI(self._api_client) - self._providers = ProvidersAPI(self._api_client) - self._quality_monitors = QualityMonitorsAPI(self._api_client) - self._queries = QueriesAPI(self._api_client) - self._queries_legacy = QueriesLegacyAPI(self._api_client) - self._query_history = QueryHistoryAPI(self._api_client) - self._query_visualizations = QueryVisualizationsAPI(self._api_client) - self._query_visualizations_legacy = QueryVisualizationsLegacyAPI(self._api_client) - self._recipient_activation = RecipientActivationAPI(self._api_client) - self._recipients = RecipientsAPI(self._api_client) - self._registered_models = RegisteredModelsAPI(self._api_client) - self._repos = ReposAPI(self._api_client) - self._resource_quotas = ResourceQuotasAPI(self._api_client) - self._schemas = SchemasAPI(self._api_client) - self._secrets = SecretsAPI(self._api_client) - self._service_principals = ServicePrincipalsAPI(self._api_client) + self._provider_provider_analytics_dashboards = service.marketplace.ProviderProviderAnalyticsDashboardsAPI( + self._api_client) + self._provider_providers = service.marketplace.ProviderProvidersAPI(self._api_client) + self._providers = service.sharing.ProvidersAPI(self._api_client) + self._quality_monitors = service.catalog.QualityMonitorsAPI(self._api_client) + self._queries = service.sql.QueriesAPI(self._api_client) + self._queries_legacy = service.sql.QueriesLegacyAPI(self._api_client) + self._query_history = service.sql.QueryHistoryAPI(self._api_client) + self._query_visualizations = service.sql.QueryVisualizationsAPI(self._api_client) + self._query_visualizations_legacy = service.sql.QueryVisualizationsLegacyAPI(self._api_client) + self._recipient_activation = service.sharing.RecipientActivationAPI(self._api_client) + self._recipients = service.sharing.RecipientsAPI(self._api_client) + self._registered_models = service.catalog.RegisteredModelsAPI(self._api_client) + self._repos = service.workspace.ReposAPI(self._api_client) + self._resource_quotas = service.catalog.ResourceQuotasAPI(self._api_client) + self._schemas = service.catalog.SchemasAPI(self._api_client) + self._secrets = service.workspace.SecretsAPI(self._api_client) + self._service_principals = service.iam.ServicePrincipalsAPI(self._api_client) self._serving_endpoints = serving_endpoints - self._serving_endpoints_data_plane = ServingEndpointsDataPlaneAPI(self._api_client, serving_endpoints) - self._settings = SettingsAPI(self._api_client) - self._shares = SharesAPI(self._api_client) - self._statement_execution = StatementExecutionAPI(self._api_client) - self._storage_credentials = StorageCredentialsAPI(self._api_client) - self._system_schemas = SystemSchemasAPI(self._api_client) - self._table_constraints = TableConstraintsAPI(self._api_client) - self._tables = TablesAPI(self._api_client) - self._temporary_table_credentials = TemporaryTableCredentialsAPI(self._api_client) - self._token_management = TokenManagementAPI(self._api_client) - self._tokens = TokensAPI(self._api_client) - self._users = UsersAPI(self._api_client) - self._vector_search_endpoints = VectorSearchEndpointsAPI(self._api_client) - self._vector_search_indexes = VectorSearchIndexesAPI(self._api_client) - self._volumes = VolumesAPI(self._api_client) - self._warehouses = WarehousesAPI(self._api_client) + self._serving_endpoints_data_plane = service.serving.ServingEndpointsDataPlaneAPI( + self._api_client, serving_endpoints) + self._settings = service.settings.SettingsAPI(self._api_client) + self._shares = service.sharing.SharesAPI(self._api_client) + self._statement_execution = service.sql.StatementExecutionAPI(self._api_client) + self._storage_credentials = service.catalog.StorageCredentialsAPI(self._api_client) + self._system_schemas = service.catalog.SystemSchemasAPI(self._api_client) + self._table_constraints = service.catalog.TableConstraintsAPI(self._api_client) + self._tables = service.catalog.TablesAPI(self._api_client) + self._temporary_table_credentials = service.catalog.TemporaryTableCredentialsAPI(self._api_client) + self._token_management = service.settings.TokenManagementAPI(self._api_client) + self._tokens = service.settings.TokensAPI(self._api_client) + self._users = service.iam.UsersAPI(self._api_client) + self._vector_search_endpoints = service.vectorsearch.VectorSearchEndpointsAPI(self._api_client) + self._vector_search_indexes = service.vectorsearch.VectorSearchIndexesAPI(self._api_client) + self._volumes = service.catalog.VolumesAPI(self._api_client) + self._warehouses = service.sql.WarehousesAPI(self._api_client) self._workspace = WorkspaceExt(self._api_client) - self._workspace_bindings = WorkspaceBindingsAPI(self._api_client) - self._workspace_conf = WorkspaceConfAPI(self._api_client) + self._workspace_bindings = service.catalog.WorkspaceBindingsAPI(self._api_client) + self._workspace_conf = service.settings.WorkspaceConfAPI(self._api_client) @property def config(self) -> client.Config: @@ -300,57 +305,57 @@ def dbutils(self) -> dbutils.RemoteDbUtils: return self._dbutils @property - def access_control(self) -> AccessControlAPI: + def access_control(self) -> service.iam.AccessControlAPI: """Rule based Access Control for Databricks Resources.""" return self._access_control @property - def account_access_control_proxy(self) -> AccountAccessControlProxyAPI: + def account_access_control_proxy(self) -> service.iam.AccountAccessControlProxyAPI: """These APIs manage access rules on resources in an account.""" return self._account_access_control_proxy @property - def alerts(self) -> AlertsAPI: + def alerts(self) -> service.sql.AlertsAPI: """The alerts API can be used to perform CRUD operations on alerts.""" return self._alerts @property - def alerts_legacy(self) -> AlertsLegacyAPI: + def alerts_legacy(self) -> service.sql.AlertsLegacyAPI: """The alerts API can be used to perform CRUD operations on alerts.""" return self._alerts_legacy @property - def apps(self) -> AppsAPI: + def apps(self) -> service.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 artifact_allowlists(self) -> ArtifactAllowlistsAPI: + def artifact_allowlists(self) -> service.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) -> CatalogsAPI: + def catalogs(self) -> service.catalog.CatalogsAPI: """A catalog is the first layer of Unity Catalog’s three-level namespace.""" return self._catalogs @property - def clean_room_assets(self) -> CleanRoomAssetsAPI: + def clean_room_assets(self) -> service.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_task_runs(self) -> CleanRoomTaskRunsAPI: + def clean_room_task_runs(self) -> service.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) -> CleanRoomsAPI: + def clean_rooms(self) -> service.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) -> ClusterPoliciesAPI: + def cluster_policies(self) -> service.compute.ClusterPoliciesAPI: """You can use cluster policies to control users' ability to configure clusters based on a set of rules.""" return self._cluster_policies @@ -360,67 +365,67 @@ def clusters(self) -> ClustersExt: return self._clusters @property - def command_execution(self) -> CommandExecutionAPI: + def command_execution(self) -> service.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) -> ConnectionsAPI: + def connections(self) -> service.catalog.ConnectionsAPI: """Connections allow for creating a connection to an external data source.""" return self._connections @property - def consumer_fulfillments(self) -> ConsumerFulfillmentsAPI: + def consumer_fulfillments(self) -> service.marketplace.ConsumerFulfillmentsAPI: """Fulfillments are entities that allow consumers to preview installations.""" return self._consumer_fulfillments @property - def consumer_installations(self) -> ConsumerInstallationsAPI: + def consumer_installations(self) -> service.marketplace.ConsumerInstallationsAPI: """Installations are entities that allow consumers to interact with Databricks Marketplace listings.""" return self._consumer_installations @property - def consumer_listings(self) -> ConsumerListingsAPI: + def consumer_listings(self) -> service.marketplace.ConsumerListingsAPI: """Listings are the core entities in the Marketplace.""" return self._consumer_listings @property - def consumer_personalization_requests(self) -> ConsumerPersonalizationRequestsAPI: + def consumer_personalization_requests(self) -> service.marketplace.ConsumerPersonalizationRequestsAPI: """Personalization Requests allow customers to interact with the individualized Marketplace listing flow.""" return self._consumer_personalization_requests @property - def consumer_providers(self) -> ConsumerProvidersAPI: + def consumer_providers(self) -> service.marketplace.ConsumerProvidersAPI: """Providers are the entities that publish listings to the Marketplace.""" return self._consumer_providers @property - def credentials(self) -> CredentialsAPI: + def credentials(self) -> service.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) -> CredentialsManagerAPI: + def credentials_manager(self) -> service.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) -> CurrentUserAPI: + def current_user(self) -> service.iam.CurrentUserAPI: """This API allows retrieving information about currently authenticated user or service principal.""" return self._current_user @property - def dashboard_widgets(self) -> DashboardWidgetsAPI: + def dashboard_widgets(self) -> service.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) -> DashboardsAPI: + def dashboards(self) -> service.sql.DashboardsAPI: """In general, there is little need to modify dashboards using the API.""" return self._dashboards @property - def data_sources(self) -> DataSourcesAPI: + def data_sources(self) -> service.sql.DataSourcesAPI: """This API is provided to assist you in making new query objects.""" return self._data_sources @@ -430,67 +435,67 @@ def dbfs(self) -> DbfsExt: return self._dbfs @property - def dbsql_permissions(self) -> DbsqlPermissionsAPI: + def dbsql_permissions(self) -> service.sql.DbsqlPermissionsAPI: """The SQL Permissions API is similar to the endpoints of the :method:permissions/set.""" return self._dbsql_permissions @property - def experiments(self) -> ExperimentsAPI: + def experiments(self) -> service.ml.ExperimentsAPI: """Experiments are the primary unit of organization in MLflow; all MLflow runs belong to an experiment.""" return self._experiments @property - def external_locations(self) -> ExternalLocationsAPI: + def external_locations(self) -> service.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 files(self) -> FilesAPI: + def files(self) -> service.files.FilesAPI: """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 @property - def functions(self) -> FunctionsAPI: + def functions(self) -> service.catalog.FunctionsAPI: """Functions implement User-Defined Functions (UDFs) in Unity Catalog.""" return self._functions @property - def genie(self) -> GenieAPI: + def genie(self) -> service.dashboards.GenieAPI: """Genie provides a no-code experience for business users, powered by AI/BI.""" return self._genie @property - def git_credentials(self) -> GitCredentialsAPI: + def git_credentials(self) -> service.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) -> GlobalInitScriptsAPI: + def global_init_scripts(self) -> service.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) -> GrantsAPI: + def grants(self) -> service.catalog.GrantsAPI: """In Unity Catalog, data is secure by default.""" return self._grants @property - def groups(self) -> GroupsAPI: + def groups(self) -> service.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 instance_pools(self) -> InstancePoolsAPI: + def instance_pools(self) -> service.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) -> InstanceProfilesAPI: + def instance_profiles(self) -> service.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) -> IpAccessListsAPI: + def ip_access_lists(self) -> service.settings.IpAccessListsAPI: """IP Access List enables admins to configure IP access lists.""" return self._ip_access_lists @@ -500,177 +505,178 @@ def jobs(self) -> JobsExt: return self._jobs @property - def lakeview(self) -> LakeviewAPI: + def lakeview(self) -> service.dashboards.LakeviewAPI: """These APIs provide specific management operations for Lakeview dashboards.""" return self._lakeview @property - def libraries(self) -> LibrariesAPI: + def libraries(self) -> service.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 metastores(self) -> MetastoresAPI: + def metastores(self) -> service.catalog.MetastoresAPI: """A metastore is the top-level container of objects in Unity Catalog.""" return self._metastores @property - def model_registry(self) -> ModelRegistryAPI: + def model_registry(self) -> service.ml.ModelRegistryAPI: """Note: This API reference documents APIs for the Workspace Model Registry.""" return self._model_registry @property - def model_versions(self) -> ModelVersionsAPI: + def model_versions(self) -> service.catalog.ModelVersionsAPI: """Databricks provides a hosted version of MLflow Model Registry in Unity Catalog.""" return self._model_versions @property - def notification_destinations(self) -> NotificationDestinationsAPI: + def notification_destinations(self) -> service.settings.NotificationDestinationsAPI: """The notification destinations API lets you programmatically manage a workspace's notification destinations.""" return self._notification_destinations @property - def online_tables(self) -> OnlineTablesAPI: + def online_tables(self) -> service.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) -> PermissionMigrationAPI: + def permission_migration(self) -> service.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) -> PermissionsAPI: + def permissions(self) -> service.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) -> PipelinesAPI: + def pipelines(self) -> service.pipelines.PipelinesAPI: """The Delta Live Tables API allows you to create, edit, delete, start, and view details about pipelines.""" return self._pipelines @property - def policy_compliance_for_clusters(self) -> PolicyComplianceForClustersAPI: + def policy_compliance_for_clusters(self) -> service.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) -> PolicyComplianceForJobsAPI: + def policy_compliance_for_jobs(self) -> service.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) -> PolicyFamiliesAPI: + def policy_families(self) -> service.compute.PolicyFamiliesAPI: """View available policy families.""" return self._policy_families @property - def provider_exchange_filters(self) -> ProviderExchangeFiltersAPI: + def provider_exchange_filters(self) -> service.marketplace.ProviderExchangeFiltersAPI: """Marketplace exchanges filters curate which groups can access an exchange.""" return self._provider_exchange_filters @property - def provider_exchanges(self) -> ProviderExchangesAPI: + def provider_exchanges(self) -> service.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) -> ProviderFilesAPI: + def provider_files(self) -> service.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) -> ProviderListingsAPI: + def provider_listings(self) -> service.marketplace.ProviderListingsAPI: """Listings are the core entities in the Marketplace.""" return self._provider_listings @property - def provider_personalization_requests(self) -> ProviderPersonalizationRequestsAPI: + def provider_personalization_requests(self) -> service.marketplace.ProviderPersonalizationRequestsAPI: """Personalization requests are an alternate to instantly available listings.""" return self._provider_personalization_requests @property - def provider_provider_analytics_dashboards(self) -> ProviderProviderAnalyticsDashboardsAPI: + def provider_provider_analytics_dashboards( + self) -> service.marketplace.ProviderProviderAnalyticsDashboardsAPI: """Manage templated analytics solution for providers.""" return self._provider_provider_analytics_dashboards @property - def provider_providers(self) -> ProviderProvidersAPI: + def provider_providers(self) -> service.marketplace.ProviderProvidersAPI: """Providers are entities that manage assets in Marketplace.""" return self._provider_providers @property - def providers(self) -> ProvidersAPI: + def providers(self) -> service.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_monitors(self) -> QualityMonitorsAPI: + def quality_monitors(self) -> service.catalog.QualityMonitorsAPI: """A monitor computes and monitors data or model quality metrics for a table over time.""" return self._quality_monitors @property - def queries(self) -> QueriesAPI: + def queries(self) -> service.sql.QueriesAPI: """The queries API can be used to perform CRUD operations on queries.""" return self._queries @property - def queries_legacy(self) -> QueriesLegacyAPI: + def queries_legacy(self) -> service.sql.QueriesLegacyAPI: """These endpoints are used for CRUD operations on query definitions.""" return self._queries_legacy @property - def query_history(self) -> QueryHistoryAPI: + def query_history(self) -> service.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) -> QueryVisualizationsAPI: + def query_visualizations(self) -> service.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) -> QueryVisualizationsLegacyAPI: + def query_visualizations_legacy(self) -> service.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) -> RecipientActivationAPI: + def recipient_activation(self) -> service.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 recipients(self) -> RecipientsAPI: + def recipients(self) -> service.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 registered_models(self) -> RegisteredModelsAPI: + def registered_models(self) -> service.catalog.RegisteredModelsAPI: """Databricks provides a hosted version of MLflow Model Registry in Unity Catalog.""" return self._registered_models @property - def repos(self) -> ReposAPI: + def repos(self) -> service.workspace.ReposAPI: """The Repos API allows users to manage their git repos.""" return self._repos @property - def resource_quotas(self) -> ResourceQuotasAPI: + def resource_quotas(self) -> service.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 schemas(self) -> SchemasAPI: + def schemas(self) -> service.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) -> SecretsAPI: + def secrets(self) -> service.workspace.SecretsAPI: """The Secrets API allows you to manage secrets, secret scopes, and access permissions.""" return self._secrets @property - def service_principals(self) -> ServicePrincipalsAPI: + def service_principals(self) -> service.iam.ServicePrincipalsAPI: """Identities for use with jobs, automated tools, and systems such as scripts, apps, and CI/CD platforms.""" return self._service_principals @@ -680,82 +686,82 @@ def serving_endpoints(self) -> ServingEndpointsExt: return self._serving_endpoints @property - def serving_endpoints_data_plane(self) -> ServingEndpointsDataPlaneAPI: + def serving_endpoints_data_plane(self) -> service.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) -> SettingsAPI: + def settings(self) -> service.settings.SettingsAPI: """Workspace Settings API allows users to manage settings at the workspace level.""" return self._settings @property - def shares(self) -> SharesAPI: + def shares(self) -> service.sharing.SharesAPI: """A share is a container instantiated with :method:shares/create.""" return self._shares @property - def statement_execution(self) -> StatementExecutionAPI: + def statement_execution(self) -> service.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) -> StorageCredentialsAPI: + def storage_credentials(self) -> service.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) -> SystemSchemasAPI: + def system_schemas(self) -> service.catalog.SystemSchemasAPI: """A system schema is a schema that lives within the system catalog.""" return self._system_schemas @property - def table_constraints(self) -> TableConstraintsAPI: + def table_constraints(self) -> service.catalog.TableConstraintsAPI: """Primary key and foreign key constraints encode relationships between fields in tables.""" return self._table_constraints @property - def tables(self) -> TablesAPI: + def tables(self) -> service.catalog.TablesAPI: """A table resides in the third layer of Unity Catalog’s three-level namespace.""" return self._tables @property - def temporary_table_credentials(self) -> TemporaryTableCredentialsAPI: + def temporary_table_credentials(self) -> service.catalog.TemporaryTableCredentialsAPI: """Temporary Table Credentials refer to short-lived, downscoped credentials used to access cloud storage locationswhere table data is stored in Databricks.""" return self._temporary_table_credentials @property - def token_management(self) -> TokenManagementAPI: + def token_management(self) -> service.settings.TokenManagementAPI: """Enables administrators to get all tokens and delete tokens for other users.""" return self._token_management @property - def tokens(self) -> TokensAPI: + def tokens(self) -> service.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(self) -> UsersAPI: + def users(self) -> service.iam.UsersAPI: """User identities recognized by Databricks and represented by email addresses.""" return self._users @property - def vector_search_endpoints(self) -> VectorSearchEndpointsAPI: + def vector_search_endpoints(self) -> service.vectorsearch.VectorSearchEndpointsAPI: """**Endpoint**: Represents the compute resources to host vector search indexes.""" return self._vector_search_endpoints @property - def vector_search_indexes(self) -> VectorSearchIndexesAPI: + def vector_search_indexes(self) -> service.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) -> VolumesAPI: + def volumes(self) -> service.catalog.VolumesAPI: """Volumes are a Unity Catalog (UC) capability for accessing, storing, governing, organizing and processing files.""" return self._volumes @property - def warehouses(self) -> WarehousesAPI: + def warehouses(self) -> service.sql.WarehousesAPI: """A SQL warehouse is a compute resource that lets you run SQL commands on data objects within Databricks SQL.""" return self._warehouses @@ -765,12 +771,12 @@ def workspace(self) -> WorkspaceExt: return self._workspace @property - def workspace_bindings(self) -> WorkspaceBindingsAPI: + def workspace_bindings(self) -> service.catalog.WorkspaceBindingsAPI: """A securable in Databricks can be configured as __OPEN__ or __ISOLATED__.""" return self._workspace_bindings @property - def workspace_conf(self) -> WorkspaceConfAPI: + def workspace_conf(self) -> service.settings.WorkspaceConfAPI: """This API allows updating known workspace settings for advanced users.""" return self._workspace_conf @@ -844,35 +850,36 @@ def __init__(self, product_version=product_version) self._config = config.copy() self._api_client = client.ApiClient(self._config) - self._access_control = AccountAccessControlAPI(self._api_client) - self._billable_usage = BillableUsageAPI(self._api_client) - self._budget_policy = BudgetPolicyAPI(self._api_client) - self._credentials = CredentialsAPI(self._api_client) - self._custom_app_integration = CustomAppIntegrationAPI(self._api_client) - self._encryption_keys = EncryptionKeysAPI(self._api_client) - self._federation_policy = AccountFederationPolicyAPI(self._api_client) - self._groups = AccountGroupsAPI(self._api_client) - self._ip_access_lists = AccountIpAccessListsAPI(self._api_client) - self._log_delivery = LogDeliveryAPI(self._api_client) - self._metastore_assignments = AccountMetastoreAssignmentsAPI(self._api_client) - self._metastores = AccountMetastoresAPI(self._api_client) - self._network_connectivity = NetworkConnectivityAPI(self._api_client) - self._networks = NetworksAPI(self._api_client) - self._o_auth_published_apps = OAuthPublishedAppsAPI(self._api_client) - self._private_access = PrivateAccessAPI(self._api_client) - self._published_app_integration = PublishedAppIntegrationAPI(self._api_client) - self._service_principal_federation_policy = ServicePrincipalFederationPolicyAPI(self._api_client) - self._service_principal_secrets = ServicePrincipalSecretsAPI(self._api_client) - self._service_principals = AccountServicePrincipalsAPI(self._api_client) - self._settings = AccountSettingsAPI(self._api_client) - self._storage = StorageAPI(self._api_client) - self._storage_credentials = AccountStorageCredentialsAPI(self._api_client) - self._usage_dashboards = UsageDashboardsAPI(self._api_client) - self._users = AccountUsersAPI(self._api_client) - self._vpc_endpoints = VpcEndpointsAPI(self._api_client) - self._workspace_assignment = WorkspaceAssignmentAPI(self._api_client) - self._workspaces = WorkspacesAPI(self._api_client) - self._budgets = BudgetsAPI(self._api_client) + self._access_control = service.iam.AccountAccessControlAPI(self._api_client) + self._billable_usage = service.billing.BillableUsageAPI(self._api_client) + self._budget_policy = service.billing.BudgetPolicyAPI(self._api_client) + self._credentials = service.provisioning.CredentialsAPI(self._api_client) + self._custom_app_integration = service.oauth2.CustomAppIntegrationAPI(self._api_client) + self._encryption_keys = service.provisioning.EncryptionKeysAPI(self._api_client) + self._federation_policy = service.oauth2.AccountFederationPolicyAPI(self._api_client) + self._groups = service.iam.AccountGroupsAPI(self._api_client) + self._ip_access_lists = service.settings.AccountIpAccessListsAPI(self._api_client) + self._log_delivery = service.billing.LogDeliveryAPI(self._api_client) + self._metastore_assignments = service.catalog.AccountMetastoreAssignmentsAPI(self._api_client) + self._metastores = service.catalog.AccountMetastoresAPI(self._api_client) + self._network_connectivity = service.settings.NetworkConnectivityAPI(self._api_client) + self._networks = service.provisioning.NetworksAPI(self._api_client) + self._o_auth_published_apps = service.oauth2.OAuthPublishedAppsAPI(self._api_client) + self._private_access = service.provisioning.PrivateAccessAPI(self._api_client) + self._published_app_integration = service.oauth2.PublishedAppIntegrationAPI(self._api_client) + self._service_principal_federation_policy = service.oauth2.ServicePrincipalFederationPolicyAPI( + self._api_client) + self._service_principal_secrets = service.oauth2.ServicePrincipalSecretsAPI(self._api_client) + self._service_principals = service.iam.AccountServicePrincipalsAPI(self._api_client) + self._settings = service.settings.AccountSettingsAPI(self._api_client) + self._storage = service.provisioning.StorageAPI(self._api_client) + self._storage_credentials = service.catalog.AccountStorageCredentialsAPI(self._api_client) + self._usage_dashboards = service.billing.UsageDashboardsAPI(self._api_client) + self._users = service.iam.AccountUsersAPI(self._api_client) + self._vpc_endpoints = service.provisioning.VpcEndpointsAPI(self._api_client) + self._workspace_assignment = service.iam.WorkspaceAssignmentAPI(self._api_client) + self._workspaces = service.provisioning.WorkspacesAPI(self._api_client) + self._budgets = service.billing.BudgetsAPI(self._api_client) @property def config(self) -> client.Config: @@ -883,147 +890,147 @@ def api_client(self) -> client.ApiClient: return self._api_client @property - def access_control(self) -> AccountAccessControlAPI: + def access_control(self) -> service.iam.AccountAccessControlAPI: """These APIs manage access rules on resources in an account.""" return self._access_control @property - def billable_usage(self) -> BillableUsageAPI: + def billable_usage(self) -> service.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) -> BudgetPolicyAPI: + def budget_policy(self) -> service.billing.BudgetPolicyAPI: """A service serves REST API about Budget policies.""" return self._budget_policy @property - def credentials(self) -> CredentialsAPI: + def credentials(self) -> service.provisioning.CredentialsAPI: """These APIs manage credential configurations for this workspace.""" return self._credentials @property - def custom_app_integration(self) -> CustomAppIntegrationAPI: + def custom_app_integration(self) -> service.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) -> EncryptionKeysAPI: + def encryption_keys(self) -> service.provisioning.EncryptionKeysAPI: """These APIs manage encryption key configurations for this workspace (optional).""" return self._encryption_keys @property - def federation_policy(self) -> AccountFederationPolicyAPI: + def federation_policy(self) -> service.oauth2.AccountFederationPolicyAPI: """These APIs manage account federation policies.""" return self._federation_policy @property - def groups(self) -> AccountGroupsAPI: + def groups(self) -> service.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 ip_access_lists(self) -> AccountIpAccessListsAPI: + def ip_access_lists(self) -> service.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) -> LogDeliveryAPI: + def log_delivery(self) -> service.billing.LogDeliveryAPI: """These APIs manage log delivery configurations for this account.""" return self._log_delivery @property - def metastore_assignments(self) -> AccountMetastoreAssignmentsAPI: + def metastore_assignments(self) -> service.catalog.AccountMetastoreAssignmentsAPI: """These APIs manage metastore assignments to a workspace.""" return self._metastore_assignments @property - def metastores(self) -> AccountMetastoresAPI: + def metastores(self) -> service.catalog.AccountMetastoresAPI: """These APIs manage Unity Catalog metastores for an account.""" return self._metastores @property - def network_connectivity(self) -> NetworkConnectivityAPI: + def network_connectivity(self) -> service.settings.NetworkConnectivityAPI: """These APIs provide configurations for the network connectivity of your workspaces for serverless compute resources.""" return self._network_connectivity @property - def networks(self) -> NetworksAPI: + def networks(self) -> service.provisioning.NetworksAPI: """These APIs manage network configurations for customer-managed VPCs (optional).""" return self._networks @property - def o_auth_published_apps(self) -> OAuthPublishedAppsAPI: + def o_auth_published_apps(self) -> service.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) -> PrivateAccessAPI: + def private_access(self) -> service.provisioning.PrivateAccessAPI: """These APIs manage private access settings for this account.""" return self._private_access @property - def published_app_integration(self) -> PublishedAppIntegrationAPI: + def published_app_integration(self) -> service.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) -> ServicePrincipalFederationPolicyAPI: + def service_principal_federation_policy(self) -> service.oauth2.ServicePrincipalFederationPolicyAPI: """These APIs manage service principal federation policies.""" return self._service_principal_federation_policy @property - def service_principal_secrets(self) -> ServicePrincipalSecretsAPI: + def service_principal_secrets(self) -> service.oauth2.ServicePrincipalSecretsAPI: """These APIs enable administrators to manage service principal secrets.""" return self._service_principal_secrets @property - def service_principals(self) -> AccountServicePrincipalsAPI: + def service_principals(self) -> service.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 settings(self) -> AccountSettingsAPI: + def settings(self) -> service.settings.AccountSettingsAPI: """Accounts Settings API allows users to manage settings at the account level.""" return self._settings @property - def storage(self) -> StorageAPI: + def storage(self) -> service.provisioning.StorageAPI: """These APIs manage storage configurations for this workspace.""" return self._storage @property - def storage_credentials(self) -> AccountStorageCredentialsAPI: + def storage_credentials(self) -> service.catalog.AccountStorageCredentialsAPI: """These APIs manage storage credentials for a particular metastore.""" return self._storage_credentials @property - def usage_dashboards(self) -> UsageDashboardsAPI: + def usage_dashboards(self) -> service.billing.UsageDashboardsAPI: """These APIs manage usage dashboards for this account.""" return self._usage_dashboards @property - def users(self) -> AccountUsersAPI: + def users(self) -> service.iam.AccountUsersAPI: """User identities recognized by Databricks and represented by email addresses.""" return self._users @property - def vpc_endpoints(self) -> VpcEndpointsAPI: + def vpc_endpoints(self) -> service.provisioning.VpcEndpointsAPI: """These APIs manage VPC endpoint configurations for this account.""" return self._vpc_endpoints @property - def workspace_assignment(self) -> WorkspaceAssignmentAPI: + def workspace_assignment(self) -> service.iam.WorkspaceAssignmentAPI: """The Workspace Permission Assignment API allows you to manage workspace permissions for principals in your account.""" return self._workspace_assignment @property - def workspaces(self) -> WorkspacesAPI: + def workspaces(self) -> service.provisioning.WorkspacesAPI: """These APIs manage workspaces for this account.""" return self._workspaces @property - def budgets(self) -> BudgetsAPI: + def budgets(self) -> service.billing.BudgetsAPI: """These APIs manage budget configurations for this account.""" return self._budgets diff --git a/databricks/sdk/version.py b/databricks/sdk/version.py index 9f86a39e..ccd8b38e 100644 --- a/databricks/sdk/version.py +++ b/databricks/sdk/version.py @@ -1 +1 @@ -__version__ = '0.41.0' +__version__ = '0.42.0' diff --git a/docs/workspace/catalog/credentials.rst b/docs/workspace/catalog/credentials.rst index 54b55516..3927e635 100644 --- a/docs/workspace/catalog/credentials.rst +++ b/docs/workspace/catalog/credentials.rst @@ -4,65 +4,190 @@ .. py:class:: CredentialsAPI - These APIs manage credential configurations for this workspace. Databricks needs access to a cross-account - service IAM role in your AWS account so that Databricks can deploy clusters in the appropriate VPC for the - new workspace. A credential configuration encapsulates this role information, and its ID is used when - creating a new workspace. + A credential represents an authentication and authorization mechanism for accessing services on your cloud + tenant. Each credential is subject to Unity Catalog access-control policies that control which users and + groups can access the credential. + + To create credentials, you must be a Databricks account admin or have the `CREATE SERVICE CREDENTIAL` + privilege. The user who creates the credential can delegate ownership to another user or group to manage + permissions on it. - .. py:method:: create(credentials_name: str, aws_credentials: CreateCredentialAwsCredentials) -> Credential + .. py:method:: create_credential(name: str [, aws_iam_role: Optional[AwsIamRole], azure_managed_identity: Optional[AzureManagedIdentity], azure_service_principal: Optional[AzureServicePrincipal], comment: Optional[str], databricks_gcp_service_account: Optional[DatabricksGcpServiceAccount], purpose: Optional[CredentialPurpose], read_only: Optional[bool], skip_validation: Optional[bool]]) -> CredentialInfo - Create credential configuration. + Create a credential. + + Creates a new credential. The type of credential to be created is determined by the **purpose** field, + which should be either **SERVICE** or **STORAGE**. + + The caller must be a metastore admin or have the metastore privilege **CREATE_STORAGE_CREDENTIAL** for + storage credentials, or **CREATE_SERVICE_CREDENTIAL** for service credentials. + + :param name: str + The credential name. The name must be unique among storage and service credentials within the + metastore. + :param aws_iam_role: :class:`AwsIamRole` (optional) + The AWS IAM role configuration + :param azure_managed_identity: :class:`AzureManagedIdentity` (optional) + The Azure managed identity configuration. + :param azure_service_principal: :class:`AzureServicePrincipal` (optional) + The Azure service principal configuration. Only applicable when purpose is **STORAGE**. + :param comment: str (optional) + Comment associated with the credential. + :param databricks_gcp_service_account: :class:`DatabricksGcpServiceAccount` (optional) + GCP long-lived credential. Databricks-created Google Cloud Storage service account. + :param purpose: :class:`CredentialPurpose` (optional) + Indicates the purpose of the credential. + :param read_only: bool (optional) + Whether the credential is usable only for read operations. Only applicable when purpose is + **STORAGE**. + :param skip_validation: bool (optional) + Optional. Supplying true to this argument skips validation of the created set of credentials. + + :returns: :class:`CredentialInfo` - Creates a Databricks credential configuration that represents cloud cross-account credentials for a - specified account. Databricks uses this to set up network infrastructure properly to host Databricks - clusters. For your AWS IAM role, you need to trust the External ID (the Databricks Account API account - ID) in the returned credential object, and configure the required access policy. - - Save the response's `credentials_id` field, which is the ID for your new credential configuration - object. + + .. py:method:: delete_credential(name_arg: str [, force: Optional[bool]]) + + Delete a credential. - For information about how to create a new workspace with this API, see [Create a new workspace using - the Account API] + Deletes a service or storage credential from the metastore. The caller must be an owner of the + credential. - [Create a new workspace using the Account API]: http://docs.databricks.com/administration-guide/account-api/new-workspace.html + :param name_arg: str + Name of the credential. + :param force: bool (optional) + Force an update even if there are dependent services (when purpose is **SERVICE**) or dependent + external locations and external tables (when purpose is **STORAGE**). - :param credentials_name: str - The human-readable name of the credential configuration object. - :param aws_credentials: :class:`CreateCredentialAwsCredentials` - :returns: :class:`Credential` - .. py:method:: delete(credentials_id: str) + .. py:method:: generate_temporary_service_credential(credential_name: str [, azure_options: Optional[GenerateTemporaryServiceCredentialAzureOptions], gcp_options: Optional[GenerateTemporaryServiceCredentialGcpOptions]]) -> TemporaryCredentials - Delete credential configuration. + Generate a temporary service credential. - Deletes a Databricks credential configuration object for an account, both specified by ID. You cannot - delete a credential that is associated with any workspace. - - :param credentials_id: str - Databricks Account API credential configuration ID + Returns a set of temporary credentials generated using the specified service credential. The caller + must be a metastore admin or have the metastore privilege **ACCESS** on the service credential. + :param credential_name: str + The name of the service credential used to generate a temporary credential + :param azure_options: :class:`GenerateTemporaryServiceCredentialAzureOptions` (optional) + The Azure cloud options to customize the requested temporary credential + :param gcp_options: :class:`GenerateTemporaryServiceCredentialGcpOptions` (optional) + The GCP cloud options to customize the requested temporary credential + :returns: :class:`TemporaryCredentials` - .. py:method:: get(credentials_id: str) -> Credential + .. py:method:: get_credential(name_arg: str) -> CredentialInfo - Get credential configuration. + Get a credential. - Gets a Databricks credential configuration object for an account, both specified by ID. + Gets a service or storage credential from the metastore. The caller must be a metastore admin, the + owner of the credential, or have any permission on the credential. - :param credentials_id: str - Databricks Account API credential configuration ID + :param name_arg: str + Name of the credential. - :returns: :class:`Credential` + :returns: :class:`CredentialInfo` - .. py:method:: list() -> Iterator[Credential] + .. py:method:: list_credentials( [, max_results: Optional[int], page_token: Optional[str], purpose: Optional[CredentialPurpose]]) -> Iterator[CredentialInfo] - Get all credential configurations. + List credentials. + + Gets an array of credentials (as __CredentialInfo__ objects). + + The array is limited to only the credentials that the caller has permission to access. If the caller + is a metastore admin, retrieval of credentials is unrestricted. There is no guarantee of a specific + ordering of the elements in the array. - Gets all Databricks credential configurations associated with an account specified by ID. + :param max_results: int (optional) + Maximum number of credentials to return. - If not set, the default max page size is used. - When set + to a value greater than 0, the page length is the minimum of this value and a server-configured + value. - When set to 0, the page length is set to a server-configured value (recommended). - When + set to a value less than 0, an invalid parameter error is returned. + :param page_token: str (optional) + Opaque token to retrieve the next page of results. + :param purpose: :class:`CredentialPurpose` (optional) + Return only credentials for the specified purpose. - :returns: Iterator over :class:`Credential` + :returns: Iterator over :class:`CredentialInfo` + + + .. py:method:: update_credential(name_arg: str [, aws_iam_role: Optional[AwsIamRole], azure_managed_identity: Optional[AzureManagedIdentity], azure_service_principal: Optional[AzureServicePrincipal], comment: Optional[str], databricks_gcp_service_account: Optional[DatabricksGcpServiceAccount], force: Optional[bool], isolation_mode: Optional[IsolationMode], new_name: Optional[str], owner: Optional[str], read_only: Optional[bool], skip_validation: Optional[bool]]) -> CredentialInfo + + Update a credential. + + Updates a service or storage credential on the metastore. + + The caller must be the owner of the credential or a metastore admin or have the `MANAGE` permission. + If the caller is a metastore admin, only the __owner__ field can be changed. + + :param name_arg: str + Name of the credential. + :param aws_iam_role: :class:`AwsIamRole` (optional) + The AWS IAM role configuration + :param azure_managed_identity: :class:`AzureManagedIdentity` (optional) + The Azure managed identity configuration. + :param azure_service_principal: :class:`AzureServicePrincipal` (optional) + The Azure service principal configuration. Only applicable when purpose is **STORAGE**. + :param comment: str (optional) + Comment associated with the credential. + :param databricks_gcp_service_account: :class:`DatabricksGcpServiceAccount` (optional) + GCP long-lived credential. Databricks-created Google Cloud Storage service account. + :param force: bool (optional) + Force an update even if there are dependent services (when purpose is **SERVICE**) or dependent + external locations and external tables (when purpose is **STORAGE**). + :param isolation_mode: :class:`IsolationMode` (optional) + Whether the current securable is accessible from all workspaces or a specific set of workspaces. + :param new_name: str (optional) + New name of credential. + :param owner: str (optional) + Username of current owner of credential. + :param read_only: bool (optional) + Whether the credential is usable only for read operations. Only applicable when purpose is + **STORAGE**. + :param skip_validation: bool (optional) + Supply true to this argument to skip validation of the updated credential. + + :returns: :class:`CredentialInfo` + + + .. py:method:: validate_credential( [, aws_iam_role: Optional[AwsIamRole], azure_managed_identity: Optional[AzureManagedIdentity], credential_name: Optional[str], external_location_name: Optional[str], purpose: Optional[CredentialPurpose], read_only: Optional[bool], url: Optional[str]]) -> ValidateCredentialResponse + + Validate a credential. + + Validates a credential. + + For service credentials (purpose is **SERVICE**), either the __credential_name__ or the cloud-specific + credential must be provided. + + For storage credentials (purpose is **STORAGE**), at least one of __external_location_name__ and + __url__ need to be provided. If only one of them is provided, it will be used for validation. And if + both are provided, the __url__ will be used for validation, and __external_location_name__ will be + ignored when checking overlapping urls. Either the __credential_name__ or the cloud-specific + credential must be provided. + + The caller must be a metastore admin or the credential owner or have the required permission on the + metastore and the credential (e.g., **CREATE_EXTERNAL_LOCATION** when purpose is **STORAGE**). + + :param aws_iam_role: :class:`AwsIamRole` (optional) + The AWS IAM role configuration + :param azure_managed_identity: :class:`AzureManagedIdentity` (optional) + The Azure managed identity configuration. + :param credential_name: str (optional) + Required. The name of an existing credential or long-lived cloud credential to validate. + :param external_location_name: str (optional) + The name of an existing external location to validate. Only applicable for storage credentials + (purpose is **STORAGE**.) + :param purpose: :class:`CredentialPurpose` (optional) + The purpose of the credential. This should only be used when the credential is specified. + :param read_only: bool (optional) + Whether the credential is only usable for read operations. Only applicable for storage credentials + (purpose is **STORAGE**.) + :param url: str (optional) + The external location url to validate. Only applicable when purpose is **STORAGE**. + + :returns: :class:`ValidateCredentialResponse` \ No newline at end of file