diff --git a/.codegen/_openapi_sha b/.codegen/_openapi_sha index 62d390339..37b41dbfe 100755 --- a/.codegen/_openapi_sha +++ b/.codegen/_openapi_sha @@ -1 +1 @@ -9e9cd2a1a802f6df10f3a5ffe6aa97b588d5884a \ No newline at end of file +c23b88b906c9d262245e50038211199037d2ee9a \ No newline at end of file diff --git a/NEXT_CHANGELOG.md b/NEXT_CHANGELOG.md old mode 100644 new mode 100755 index f18331cd4..150c60b2e --- a/NEXT_CHANGELOG.md +++ b/NEXT_CHANGELOG.md @@ -15,3 +15,18 @@ ### Internal Changes ### API Changes +* Add [w.temporary_volume_credentials](https://databricks-sdk-py.readthedocs.io/en/latest/workspace/catalog/temporary_volume_credentials.html) workspace-level service. +* Add `get_permission_levels()`, `get_permissions()`, `set_permissions()` and `update_permissions()` methods for [w.knowledge_assistants](https://databricks-sdk-py.readthedocs.io/en/latest/workspace/knowledgeassistants/knowledge_assistants.html) workspace-level service. +* Add `undelete_project()` method for [w.postgres](https://databricks-sdk-py.readthedocs.io/en/latest/workspace/postgres/postgres.html) workspace-level service. +* Add `thumbnail_url` field for `databricks.sdk.service.apps.App`. +* Add `confidential_compute_type` field for `databricks.sdk.service.compute.GcpAttributes`. +* Add `jira_options`, `outlook_options` and `smartsheet_options` fields for `databricks.sdk.service.pipelines.ConnectorOptions`. +* Add `google_ads_config` field for `databricks.sdk.service.pipelines.SourceConfig`. +* Add `replace_existing` field for `databricks.sdk.service.postgres.CreateBranchRequest`. +* Add `replace_existing` field for `databricks.sdk.service.postgres.CreateEndpointRequest`. +* Add `purge` field for `databricks.sdk.service.postgres.DeleteProjectRequest`. +* Add `show_deleted` field for `databricks.sdk.service.postgres.ListProjectsRequest`. +* Add `delete_time` and `purge_time` fields for `databricks.sdk.service.postgres.Project`. +* Add `uc_connection` field for `databricks.sdk.service.supervisoragents.Tool`. +* Change `name` field for `databricks.sdk.service.supervisoragents.Connection` to no longer be required. +* [Breaking] Change `name` field for `databricks.sdk.service.supervisoragents.Connection` to no longer be required. \ No newline at end of file diff --git a/databricks/sdk/__init__.py b/databricks/sdk/__init__.py index b002b44f6..74765b5c4 100755 --- a/databricks/sdk/__init__.py +++ b/databricks/sdk/__init__.py @@ -74,6 +74,7 @@ TableConstraintsAPI, TablesAPI, TemporaryPathCredentialsAPI, TemporaryTableCredentialsAPI, + TemporaryVolumeCredentialsAPI, VolumesAPI, WorkspaceBindingsAPI) from databricks.sdk.service.cleanrooms import (CleanRoomAssetRevisionsAPI, CleanRoomAssetsAPI, @@ -401,6 +402,7 @@ def __init__( 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._temporary_volume_credentials = pkg_catalog.TemporaryVolumeCredentialsAPI(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) @@ -995,6 +997,11 @@ def temporary_table_credentials(self) -> pkg_catalog.TemporaryTableCredentialsAP """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 temporary_volume_credentials(self) -> pkg_catalog.TemporaryVolumeCredentialsAPI: + """Temporary Volume Credentials refer to short-lived, downscoped credentials used to access cloud storage locations where volume data is stored in Databricks.""" + return self._temporary_volume_credentials + @property def token_management(self) -> pkg_settings.TokenManagementAPI: """Enables administrators to get all tokens and delete tokens for other users.""" diff --git a/databricks/sdk/service/apps.py b/databricks/sdk/service/apps.py index caaed43c6..d7ddcfcb0 100755 --- a/databricks/sdk/service/apps.py +++ b/databricks/sdk/service/apps.py @@ -93,6 +93,9 @@ class App: telemetry_export_destinations: Optional[List[TelemetryExportDestination]] = None + thumbnail_url: Optional[str] = None + """The URL of the thumbnail image for the app.""" + update_time: Optional[str] = None """The update time of the app. Formatted timestamp in ISO 6801.""" @@ -157,6 +160,8 @@ def as_dict(self) -> dict: body["space"] = self.space if self.telemetry_export_destinations: body["telemetry_export_destinations"] = [v.as_dict() for v in self.telemetry_export_destinations] + if self.thumbnail_url is not None: + body["thumbnail_url"] = self.thumbnail_url if self.update_time is not None: body["update_time"] = self.update_time if self.updater is not None: @@ -220,6 +225,8 @@ def as_shallow_dict(self) -> dict: body["space"] = self.space if self.telemetry_export_destinations: body["telemetry_export_destinations"] = self.telemetry_export_destinations + if self.thumbnail_url is not None: + body["thumbnail_url"] = self.thumbnail_url if self.update_time is not None: body["update_time"] = self.update_time if self.updater is not None: @@ -262,6 +269,7 @@ def from_dict(cls, d: Dict[str, Any]) -> App: telemetry_export_destinations=_repeated_dict( d, "telemetry_export_destinations", TelemetryExportDestination ), + thumbnail_url=d.get("thumbnail_url", None), update_time=d.get("update_time", None), updater=d.get("updater", None), url=d.get("url", None), diff --git a/databricks/sdk/service/catalog.py b/databricks/sdk/service/catalog.py index 209c85878..9441e345d 100755 --- a/databricks/sdk/service/catalog.py +++ b/databricks/sdk/service/catalog.py @@ -1831,7 +1831,7 @@ def from_dict(cls, d: Dict[str, Any]) -> ConnectionInfo: class ConnectionType(Enum): - """Next Id: 77""" + """Next Id: 123""" BIGQUERY = "BIGQUERY" DATABRICKS = "DATABRICKS" @@ -5214,6 +5214,77 @@ def from_dict(cls, d: Dict[str, Any]) -> GenerateTemporaryTableCredentialRespons ) +@dataclass +class GenerateTemporaryVolumeCredentialResponse: + aws_temp_credentials: Optional[AwsCredentials] = None + + azure_aad: Optional[AzureActiveDirectoryToken] = None + + azure_user_delegation_sas: Optional[AzureUserDelegationSas] = None + + expiration_time: Optional[int] = None + """Server time when the credential will expire, in epoch milliseconds. The API client is advised to + cache the credential given this expiration time.""" + + gcp_oauth_token: Optional[GcpOauthToken] = None + + r2_temp_credentials: Optional[R2Credentials] = None + + url: Optional[str] = None + """The URL of the storage path accessible by the temporary credential.""" + + def as_dict(self) -> dict: + """Serializes the GenerateTemporaryVolumeCredentialResponse into a dictionary suitable for use as a JSON request body.""" + body = {} + if self.aws_temp_credentials: + body["aws_temp_credentials"] = self.aws_temp_credentials.as_dict() + if self.azure_aad: + body["azure_aad"] = self.azure_aad.as_dict() + if self.azure_user_delegation_sas: + body["azure_user_delegation_sas"] = self.azure_user_delegation_sas.as_dict() + if self.expiration_time is not None: + body["expiration_time"] = self.expiration_time + if self.gcp_oauth_token: + body["gcp_oauth_token"] = self.gcp_oauth_token.as_dict() + if self.r2_temp_credentials: + body["r2_temp_credentials"] = self.r2_temp_credentials.as_dict() + if self.url is not None: + body["url"] = self.url + return body + + def as_shallow_dict(self) -> dict: + """Serializes the GenerateTemporaryVolumeCredentialResponse into a shallow dictionary of its immediate attributes.""" + body = {} + if self.aws_temp_credentials: + body["aws_temp_credentials"] = self.aws_temp_credentials + if self.azure_aad: + body["azure_aad"] = self.azure_aad + if self.azure_user_delegation_sas: + body["azure_user_delegation_sas"] = self.azure_user_delegation_sas + if self.expiration_time is not None: + body["expiration_time"] = self.expiration_time + if self.gcp_oauth_token: + body["gcp_oauth_token"] = self.gcp_oauth_token + if self.r2_temp_credentials: + body["r2_temp_credentials"] = self.r2_temp_credentials + if self.url is not None: + body["url"] = self.url + return body + + @classmethod + def from_dict(cls, d: Dict[str, Any]) -> GenerateTemporaryVolumeCredentialResponse: + """Deserializes the GenerateTemporaryVolumeCredentialResponse from a dictionary.""" + return cls( + aws_temp_credentials=_from_dict(d, "aws_temp_credentials", AwsCredentials), + azure_aad=_from_dict(d, "azure_aad", AzureActiveDirectoryToken), + azure_user_delegation_sas=_from_dict(d, "azure_user_delegation_sas", AzureUserDelegationSas), + expiration_time=d.get("expiration_time", None), + gcp_oauth_token=_from_dict(d, "gcp_oauth_token", GcpOauthToken), + r2_temp_credentials=_from_dict(d, "r2_temp_credentials", R2Credentials), + url=d.get("url", None), + ) + + @dataclass class GetCatalogWorkspaceBindingsResponse: workspaces: Optional[List[int]] = None @@ -9176,7 +9247,7 @@ def from_dict(cls, d: Dict[str, Any]) -> Securable: class SecurableKind(Enum): - """Latest kind: ENDPOINT_LLM_PROVIDER = 317; Next id: 318""" + """Latest kind: TOOLSET_EXTERNAL_MCP = 318; Next id: 319""" TABLE_DB_STORAGE = "TABLE_DB_STORAGE" TABLE_DELTA = "TABLE_DELTA" @@ -10976,6 +11047,12 @@ def from_dict(cls, d: Dict[str, Any]) -> VolumeInfo: ) +class VolumeOperation(Enum): + + READ_VOLUME = "READ_VOLUME" + WRITE_VOLUME = "WRITE_VOLUME" + + class VolumeType(Enum): EXTERNAL = "EXTERNAL" @@ -17137,6 +17214,59 @@ def generate_temporary_table_credentials( return GenerateTemporaryTableCredentialResponse.from_dict(res) +class TemporaryVolumeCredentialsAPI: + """Temporary Volume Credentials refer to short-lived, downscoped credentials used to access cloud storage + locations where volume data is stored in Databricks. These credentials are employed to provide secure and + time-limited access to data in cloud environments such as AWS, Azure, and Google Cloud. Each cloud + provider has its own type of credentials: AWS uses temporary session tokens via AWS Security Token Service + (STS), Azure utilizes Shared Access Signatures (SAS) for its data storage services, and Google Cloud + supports temporary credentials through OAuth 2.0. + + Temporary volume credentials ensure that data access is limited in scope and duration, reducing the risk + of unauthorized access or misuse. To use the temporary volume credentials API, a metastore admin needs to + enable the external_access_enabled flag (off by default) at the metastore level, and user needs to be + granted the EXTERNAL USE SCHEMA permission at the schema level by catalog owner. Note that EXTERNAL USE + SCHEMA is a schema level permission that can only be granted by catalog owner explicitly and is not + included in schema ownership or ALL PRIVILEGES on the schema for security reasons.""" + + def __init__(self, api_client): + self._api = api_client + + def generate_temporary_volume_credentials( + self, *, operation: Optional[VolumeOperation] = None, volume_id: Optional[str] = None + ) -> GenerateTemporaryVolumeCredentialResponse: + """Get a short-lived credential for directly accessing the volume data on cloud storage. The metastore + must have **external_access_enabled** flag set to true (default false). The caller must have the + **EXTERNAL_USE_SCHEMA** privilege on the parent schema and this privilege can only be granted by + catalog owners. + + :param operation: :class:`VolumeOperation` (optional) + The operation performed against the volume data, either READ_VOLUME or WRITE_VOLUME. If WRITE_VOLUME + is specified, the credentials returned will have write permissions, otherwise, it will be read only. + :param volume_id: str (optional) + Id of the volume to read or write. + + :returns: :class:`GenerateTemporaryVolumeCredentialResponse` + """ + + body = {} + if operation is not None: + body["operation"] = operation.value + if volume_id is not None: + body["volume_id"] = volume_id + headers = { + "Accept": "application/json", + "Content-Type": "application/json", + } + + cfg = self._api._cfg + if cfg.workspace_id: + headers["X-Databricks-Org-Id"] = cfg.workspace_id + + res = self._api.do("POST", "/api/2.0/unity-catalog/temporary-volume-credentials", body=body, headers=headers) + return GenerateTemporaryVolumeCredentialResponse.from_dict(res) + + class VolumesAPI: """Volumes are a Unity Catalog (UC) capability for accessing, storing, governing, organizing and processing files. Use cases include running machine learning on unstructured data such as image, audio, video, or PDF diff --git a/databricks/sdk/service/compute.py b/databricks/sdk/service/compute.py index 4c58de059..8d046bd57 100755 --- a/databricks/sdk/service/compute.py +++ b/databricks/sdk/service/compute.py @@ -2453,6 +2453,16 @@ def from_dict(cls, d: Dict[str, Any]) -> CommandStatusResponse: ) +class ConfidentialComputeType(Enum): + """Confidential computing technology for GCP instances. Aligns with gcloud's + --confidential-compute-type flag and the REST API's + confidentialInstanceConfig.confidentialInstanceType field. See: + https://cloud.google.com/confidential-computing/confidential-vm/docs/create-a-confidential-vm-instance""" + + CONFIDENTIAL_COMPUTE_TYPE_NONE = "CONFIDENTIAL_COMPUTE_TYPE_NONE" + SEV_SNP = "SEV_SNP" + + class ContextStatus(Enum): ERROR = "Error" @@ -3477,6 +3487,10 @@ class GcpAttributes: boot_disk_size: Optional[int] = None """Boot disk size in GB""" + confidential_compute_type: Optional[ConfidentialComputeType] = None + """The confidential computing technology for this cluster's instances. Currently only SEV_SNP is + supported, and only on N2D instance types. When not set, no confidential computing is applied.""" + first_on_demand: Optional[int] = None """The first `first_on_demand` nodes of the cluster will be placed on on-demand instances. This value should be greater than 0, to make sure the cluster driver node is placed on an on-demand @@ -3517,6 +3531,8 @@ def as_dict(self) -> dict: body["availability"] = self.availability.value if self.boot_disk_size is not None: body["boot_disk_size"] = self.boot_disk_size + if self.confidential_compute_type is not None: + body["confidential_compute_type"] = self.confidential_compute_type.value if self.first_on_demand is not None: body["first_on_demand"] = self.first_on_demand if self.google_service_account is not None: @@ -3536,6 +3552,8 @@ def as_shallow_dict(self) -> dict: body["availability"] = self.availability if self.boot_disk_size is not None: body["boot_disk_size"] = self.boot_disk_size + if self.confidential_compute_type is not None: + body["confidential_compute_type"] = self.confidential_compute_type if self.first_on_demand is not None: body["first_on_demand"] = self.first_on_demand if self.google_service_account is not None: @@ -3554,6 +3572,7 @@ def from_dict(cls, d: Dict[str, Any]) -> GcpAttributes: return cls( availability=_enum(d, "availability", GcpAvailability), boot_disk_size=d.get("boot_disk_size", None), + confidential_compute_type=_enum(d, "confidential_compute_type", ConfidentialComputeType), first_on_demand=d.get("first_on_demand", None), google_service_account=d.get("google_service_account", None), local_ssd_count=d.get("local_ssd_count", None), diff --git a/databricks/sdk/service/iam.py b/databricks/sdk/service/iam.py index 1d20b457a..18d41d82d 100755 --- a/databricks/sdk/service/iam.py +++ b/databricks/sdk/service/iam.py @@ -3614,8 +3614,8 @@ def get(self, request_object_type: str, request_object_id: str) -> ObjectPermiss :param request_object_type: str The type of the request object. Can be one of the following: alerts, alertsv2, authorization, clusters, cluster-policies, dashboards, database-projects, dbsql-dashboards, directories, - experiments, files, genie, instance-pools, jobs, notebooks, pipelines, queries, registered-models, - repos, serving-endpoints, or warehouses. + experiments, files, genie, instance-pools, jobs, knowledge-assistants, notebooks, pipelines, + queries, registered-models, repos, serving-endpoints, or warehouses. :param request_object_id: str The id of the request object. @@ -3639,8 +3639,8 @@ def get_permission_levels(self, request_object_type: str, request_object_id: str :param request_object_type: str The type of the request object. Can be one of the following: alerts, alertsv2, authorization, clusters, cluster-policies, dashboards, database-projects, dbsql-dashboards, directories, - experiments, files, genie, instance-pools, jobs, notebooks, pipelines, queries, registered-models, - repos, serving-endpoints, or warehouses. + experiments, files, genie, instance-pools, jobs, knowledge-assistants, notebooks, pipelines, + queries, registered-models, repos, serving-endpoints, or warehouses. :param request_object_id: str :returns: :class:`GetPermissionLevelsResponse` @@ -3673,8 +3673,8 @@ def set( :param request_object_type: str The type of the request object. Can be one of the following: alerts, alertsv2, authorization, clusters, cluster-policies, dashboards, database-projects, dbsql-dashboards, directories, - experiments, files, genie, instance-pools, jobs, notebooks, pipelines, queries, registered-models, - repos, serving-endpoints, or warehouses. + experiments, files, genie, instance-pools, jobs, knowledge-assistants, notebooks, pipelines, + queries, registered-models, repos, serving-endpoints, or warehouses. :param request_object_id: str The id of the request object. :param access_control_list: List[:class:`AccessControlRequest`] (optional) @@ -3712,8 +3712,8 @@ def update( :param request_object_type: str The type of the request object. Can be one of the following: alerts, alertsv2, authorization, clusters, cluster-policies, dashboards, database-projects, dbsql-dashboards, directories, - experiments, files, genie, instance-pools, jobs, notebooks, pipelines, queries, registered-models, - repos, serving-endpoints, or warehouses. + experiments, files, genie, instance-pools, jobs, knowledge-assistants, notebooks, pipelines, + queries, registered-models, repos, serving-endpoints, or warehouses. :param request_object_id: str The id of the request object. :param access_control_list: List[:class:`AccessControlRequest`] (optional) diff --git a/databricks/sdk/service/knowledgeassistants.py b/databricks/sdk/service/knowledgeassistants.py index af30af57e..ea7d3ccef 100755 --- a/databricks/sdk/service/knowledgeassistants.py +++ b/databricks/sdk/service/knowledgeassistants.py @@ -80,6 +80,31 @@ def from_dict(cls, d: Dict[str, Any]) -> FilesSpec: return cls(path=d.get("path", None)) +@dataclass +class GetKnowledgeAssistantPermissionLevelsResponse: + permission_levels: Optional[List[KnowledgeAssistantPermissionsDescription]] = None + """Specific permission levels""" + + def as_dict(self) -> dict: + """Serializes the GetKnowledgeAssistantPermissionLevelsResponse into a dictionary suitable for use as a JSON request body.""" + body = {} + if self.permission_levels: + body["permission_levels"] = [v.as_dict() for v in self.permission_levels] + return body + + def as_shallow_dict(self) -> dict: + """Serializes the GetKnowledgeAssistantPermissionLevelsResponse into a shallow dictionary of its immediate attributes.""" + body = {} + if self.permission_levels: + body["permission_levels"] = self.permission_levels + return body + + @classmethod + def from_dict(cls, d: Dict[str, Any]) -> GetKnowledgeAssistantPermissionLevelsResponse: + """Deserializes the GetKnowledgeAssistantPermissionLevelsResponse from a dictionary.""" + return cls(permission_levels=_repeated_dict(d, "permission_levels", KnowledgeAssistantPermissionsDescription)) + + @dataclass class IndexSpec: """IndexSpec specifies a vector search index source configuration.""" @@ -240,6 +265,235 @@ def from_dict(cls, d: Dict[str, Any]) -> KnowledgeAssistant: ) +@dataclass +class KnowledgeAssistantAccessControlRequest: + group_name: Optional[str] = None + """name of the group""" + + permission_level: Optional[KnowledgeAssistantPermissionLevel] = None + + service_principal_name: Optional[str] = None + """application ID of a service principal""" + + user_name: Optional[str] = None + """name of the user""" + + def as_dict(self) -> dict: + """Serializes the KnowledgeAssistantAccessControlRequest into a dictionary suitable for use as a JSON request body.""" + body = {} + if self.group_name is not None: + body["group_name"] = self.group_name + if self.permission_level is not None: + body["permission_level"] = self.permission_level.value + if self.service_principal_name is not None: + body["service_principal_name"] = self.service_principal_name + if self.user_name is not None: + body["user_name"] = self.user_name + return body + + def as_shallow_dict(self) -> dict: + """Serializes the KnowledgeAssistantAccessControlRequest into a shallow dictionary of its immediate attributes.""" + body = {} + if self.group_name is not None: + body["group_name"] = self.group_name + if self.permission_level is not None: + body["permission_level"] = self.permission_level + if self.service_principal_name is not None: + body["service_principal_name"] = self.service_principal_name + if self.user_name is not None: + body["user_name"] = self.user_name + return body + + @classmethod + def from_dict(cls, d: Dict[str, Any]) -> KnowledgeAssistantAccessControlRequest: + """Deserializes the KnowledgeAssistantAccessControlRequest from a dictionary.""" + return cls( + group_name=d.get("group_name", None), + permission_level=_enum(d, "permission_level", KnowledgeAssistantPermissionLevel), + service_principal_name=d.get("service_principal_name", None), + user_name=d.get("user_name", None), + ) + + +@dataclass +class KnowledgeAssistantAccessControlResponse: + all_permissions: Optional[List[KnowledgeAssistantPermission]] = None + """All permissions.""" + + display_name: Optional[str] = None + """Display name of the user or service principal.""" + + group_name: Optional[str] = None + """name of the group""" + + service_principal_name: Optional[str] = None + """Name of the service principal.""" + + user_name: Optional[str] = None + """name of the user""" + + def as_dict(self) -> dict: + """Serializes the KnowledgeAssistantAccessControlResponse into a dictionary suitable for use as a JSON request body.""" + body = {} + if self.all_permissions: + body["all_permissions"] = [v.as_dict() for v in self.all_permissions] + if self.display_name is not None: + body["display_name"] = self.display_name + if self.group_name is not None: + body["group_name"] = self.group_name + if self.service_principal_name is not None: + body["service_principal_name"] = self.service_principal_name + if self.user_name is not None: + body["user_name"] = self.user_name + return body + + def as_shallow_dict(self) -> dict: + """Serializes the KnowledgeAssistantAccessControlResponse into a shallow dictionary of its immediate attributes.""" + body = {} + if self.all_permissions: + body["all_permissions"] = self.all_permissions + if self.display_name is not None: + body["display_name"] = self.display_name + if self.group_name is not None: + body["group_name"] = self.group_name + if self.service_principal_name is not None: + body["service_principal_name"] = self.service_principal_name + if self.user_name is not None: + body["user_name"] = self.user_name + return body + + @classmethod + def from_dict(cls, d: Dict[str, Any]) -> KnowledgeAssistantAccessControlResponse: + """Deserializes the KnowledgeAssistantAccessControlResponse from a dictionary.""" + return cls( + all_permissions=_repeated_dict(d, "all_permissions", KnowledgeAssistantPermission), + display_name=d.get("display_name", None), + group_name=d.get("group_name", None), + service_principal_name=d.get("service_principal_name", None), + user_name=d.get("user_name", None), + ) + + +@dataclass +class KnowledgeAssistantPermission: + inherited: Optional[bool] = None + + inherited_from_object: Optional[List[str]] = None + + permission_level: Optional[KnowledgeAssistantPermissionLevel] = None + + def as_dict(self) -> dict: + """Serializes the KnowledgeAssistantPermission into a dictionary suitable for use as a JSON request body.""" + body = {} + if self.inherited is not None: + body["inherited"] = self.inherited + if self.inherited_from_object: + body["inherited_from_object"] = [v for v in self.inherited_from_object] + if self.permission_level is not None: + body["permission_level"] = self.permission_level.value + return body + + def as_shallow_dict(self) -> dict: + """Serializes the KnowledgeAssistantPermission into a shallow dictionary of its immediate attributes.""" + body = {} + if self.inherited is not None: + body["inherited"] = self.inherited + if self.inherited_from_object: + body["inherited_from_object"] = self.inherited_from_object + if self.permission_level is not None: + body["permission_level"] = self.permission_level + return body + + @classmethod + def from_dict(cls, d: Dict[str, Any]) -> KnowledgeAssistantPermission: + """Deserializes the KnowledgeAssistantPermission from a dictionary.""" + return cls( + inherited=d.get("inherited", None), + inherited_from_object=d.get("inherited_from_object", None), + permission_level=_enum(d, "permission_level", KnowledgeAssistantPermissionLevel), + ) + + +class KnowledgeAssistantPermissionLevel(Enum): + """Permission level""" + + CAN_MANAGE = "CAN_MANAGE" + CAN_QUERY = "CAN_QUERY" + + +@dataclass +class KnowledgeAssistantPermissions: + access_control_list: Optional[List[KnowledgeAssistantAccessControlResponse]] = None + + object_id: Optional[str] = None + + object_type: Optional[str] = None + + def as_dict(self) -> dict: + """Serializes the KnowledgeAssistantPermissions into a dictionary suitable for use as a JSON request body.""" + body = {} + if self.access_control_list: + body["access_control_list"] = [v.as_dict() for v in self.access_control_list] + if self.object_id is not None: + body["object_id"] = self.object_id + if self.object_type is not None: + body["object_type"] = self.object_type + return body + + def as_shallow_dict(self) -> dict: + """Serializes the KnowledgeAssistantPermissions into a shallow dictionary of its immediate attributes.""" + body = {} + if self.access_control_list: + body["access_control_list"] = self.access_control_list + if self.object_id is not None: + body["object_id"] = self.object_id + if self.object_type is not None: + body["object_type"] = self.object_type + return body + + @classmethod + def from_dict(cls, d: Dict[str, Any]) -> KnowledgeAssistantPermissions: + """Deserializes the KnowledgeAssistantPermissions from a dictionary.""" + return cls( + access_control_list=_repeated_dict(d, "access_control_list", KnowledgeAssistantAccessControlResponse), + object_id=d.get("object_id", None), + object_type=d.get("object_type", None), + ) + + +@dataclass +class KnowledgeAssistantPermissionsDescription: + description: Optional[str] = None + + permission_level: Optional[KnowledgeAssistantPermissionLevel] = None + + def as_dict(self) -> dict: + """Serializes the KnowledgeAssistantPermissionsDescription into a dictionary suitable for use as a JSON request body.""" + body = {} + if self.description is not None: + body["description"] = self.description + if self.permission_level is not None: + body["permission_level"] = self.permission_level.value + return body + + def as_shallow_dict(self) -> dict: + """Serializes the KnowledgeAssistantPermissionsDescription into a shallow dictionary of its immediate attributes.""" + body = {} + if self.description is not None: + body["description"] = self.description + if self.permission_level is not None: + body["permission_level"] = self.permission_level + return body + + @classmethod + def from_dict(cls, d: Dict[str, Any]) -> KnowledgeAssistantPermissionsDescription: + """Deserializes the KnowledgeAssistantPermissionsDescription from a dictionary.""" + return cls( + description=d.get("description", None), + permission_level=_enum(d, "permission_level", KnowledgeAssistantPermissionLevel), + ) + + class KnowledgeAssistantState(Enum): ACTIVE = "ACTIVE" @@ -569,6 +823,53 @@ def get_knowledge_source(self, name: str) -> KnowledgeSource: res = self._api.do("GET", f"/api/2.1/{name}", headers=headers) return KnowledgeSource.from_dict(res) + def get_permission_levels(self, knowledge_assistant_id: str) -> GetKnowledgeAssistantPermissionLevelsResponse: + """Gets the permission levels that a user can have on an object. + + :param knowledge_assistant_id: str + The knowledge assistant for which to get or manage permissions. + + :returns: :class:`GetKnowledgeAssistantPermissionLevelsResponse` + """ + + headers = { + "Accept": "application/json", + } + + cfg = self._api._cfg + if cfg.workspace_id: + headers["X-Databricks-Org-Id"] = cfg.workspace_id + + res = self._api.do( + "GET", + f"/api/2.0/permissions/knowledge-assistants/{knowledge_assistant_id}/permissionLevels", + headers=headers, + ) + return GetKnowledgeAssistantPermissionLevelsResponse.from_dict(res) + + def get_permissions(self, knowledge_assistant_id: str) -> KnowledgeAssistantPermissions: + """Gets the permissions of a knowledge assistant. Knowledge assistants can inherit permissions from their + root object. + + :param knowledge_assistant_id: str + The knowledge assistant for which to get or manage permissions. + + :returns: :class:`KnowledgeAssistantPermissions` + """ + + headers = { + "Accept": "application/json", + } + + cfg = self._api._cfg + if cfg.workspace_id: + headers["X-Databricks-Org-Id"] = cfg.workspace_id + + res = self._api.do( + "GET", f"/api/2.0/permissions/knowledge-assistants/{knowledge_assistant_id}", headers=headers + ) + return KnowledgeAssistantPermissions.from_dict(res) + def list_knowledge_assistants( self, *, page_size: Optional[int] = None, page_token: Optional[str] = None ) -> Iterator[KnowledgeAssistant]: @@ -641,6 +942,39 @@ def list_knowledge_sources( return query["page_token"] = json["next_page_token"] + def set_permissions( + self, + knowledge_assistant_id: str, + *, + access_control_list: Optional[List[KnowledgeAssistantAccessControlRequest]] = None, + ) -> KnowledgeAssistantPermissions: + """Sets permissions on an object, replacing existing permissions if they exist. Deletes all direct + permissions if none are specified. Objects can inherit permissions from their root object. + + :param knowledge_assistant_id: str + The knowledge assistant for which to get or manage permissions. + :param access_control_list: List[:class:`KnowledgeAssistantAccessControlRequest`] (optional) + + :returns: :class:`KnowledgeAssistantPermissions` + """ + + body = {} + if access_control_list is not None: + body["access_control_list"] = [v.as_dict() for v in access_control_list] + headers = { + "Accept": "application/json", + "Content-Type": "application/json", + } + + cfg = self._api._cfg + if cfg.workspace_id: + headers["X-Databricks-Org-Id"] = cfg.workspace_id + + res = self._api.do( + "PUT", f"/api/2.0/permissions/knowledge-assistants/{knowledge_assistant_id}", body=body, headers=headers + ) + return KnowledgeAssistantPermissions.from_dict(res) + def sync_knowledge_sources(self, name: str): """Sync all non-index Knowledge Sources for a Knowledge Assistant (index sources do not require sync) @@ -729,3 +1063,36 @@ def update_knowledge_source( res = self._api.do("PATCH", f"/api/2.1/{name}", query=query, body=body, headers=headers) return KnowledgeSource.from_dict(res) + + def update_permissions( + self, + knowledge_assistant_id: str, + *, + access_control_list: Optional[List[KnowledgeAssistantAccessControlRequest]] = None, + ) -> KnowledgeAssistantPermissions: + """Updates the permissions on a knowledge assistant. Knowledge assistants can inherit permissions from + their root object. + + :param knowledge_assistant_id: str + The knowledge assistant for which to get or manage permissions. + :param access_control_list: List[:class:`KnowledgeAssistantAccessControlRequest`] (optional) + + :returns: :class:`KnowledgeAssistantPermissions` + """ + + body = {} + if access_control_list is not None: + body["access_control_list"] = [v.as_dict() for v in access_control_list] + headers = { + "Accept": "application/json", + "Content-Type": "application/json", + } + + cfg = self._api._cfg + if cfg.workspace_id: + headers["X-Databricks-Org-Id"] = cfg.workspace_id + + res = self._api.do( + "PATCH", f"/api/2.0/permissions/knowledge-assistants/{knowledge_assistant_id}", body=body, headers=headers + ) + return KnowledgeAssistantPermissions.from_dict(res) diff --git a/databricks/sdk/service/ml.py b/databricks/sdk/service/ml.py index 51a62f08a..3b48657d4 100755 --- a/databricks/sdk/service/ml.py +++ b/databricks/sdk/service/ml.py @@ -5901,7 +5901,7 @@ class ScalarDataType(Enum): @dataclass class SchemaConfig: json_schema: Optional[str] = None - """Schema of the JSON object in standard IETF JSON schema format (https://json-schema.org/)""" + """Schema of the JSON object in standard IETF JSON schema format (https://json-schema.org/).""" def as_dict(self) -> dict: """Serializes the SchemaConfig into a dictionary suitable for use as a JSON request body.""" diff --git a/databricks/sdk/service/pipelines.py b/databricks/sdk/service/pipelines.py index 6ff3782e9..36d55e7e6 100755 --- a/databricks/sdk/service/pipelines.py +++ b/databricks/sdk/service/pipelines.py @@ -142,8 +142,14 @@ class ConnectorOptions: google_ads_options: Optional[GoogleAdsOptions] = None + jira_options: Optional[JiraConnectorOptions] = None + + outlook_options: Optional[OutlookOptions] = None + sharepoint_options: Optional[SharepointOptions] = None + smartsheet_options: Optional[SmartsheetOptions] = None + tiktok_ads_options: Optional[TikTokAdsOptions] = None def as_dict(self) -> dict: @@ -153,8 +159,14 @@ def as_dict(self) -> dict: body["gdrive_options"] = self.gdrive_options.as_dict() if self.google_ads_options: body["google_ads_options"] = self.google_ads_options.as_dict() + if self.jira_options: + body["jira_options"] = self.jira_options.as_dict() + if self.outlook_options: + body["outlook_options"] = self.outlook_options.as_dict() if self.sharepoint_options: body["sharepoint_options"] = self.sharepoint_options.as_dict() + if self.smartsheet_options: + body["smartsheet_options"] = self.smartsheet_options.as_dict() if self.tiktok_ads_options: body["tiktok_ads_options"] = self.tiktok_ads_options.as_dict() return body @@ -166,8 +178,14 @@ def as_shallow_dict(self) -> dict: body["gdrive_options"] = self.gdrive_options if self.google_ads_options: body["google_ads_options"] = self.google_ads_options + if self.jira_options: + body["jira_options"] = self.jira_options + if self.outlook_options: + body["outlook_options"] = self.outlook_options if self.sharepoint_options: body["sharepoint_options"] = self.sharepoint_options + if self.smartsheet_options: + body["smartsheet_options"] = self.smartsheet_options if self.tiktok_ads_options: body["tiktok_ads_options"] = self.tiktok_ads_options return body @@ -178,7 +196,10 @@ def from_dict(cls, d: Dict[str, Any]) -> ConnectorOptions: return cls( gdrive_options=_from_dict(d, "gdrive_options", GoogleDriveOptions), google_ads_options=_from_dict(d, "google_ads_options", GoogleAdsOptions), + jira_options=_from_dict(d, "jira_options", JiraConnectorOptions), + outlook_options=_from_dict(d, "outlook_options", OutlookOptions), sharepoint_options=_from_dict(d, "sharepoint_options", SharepointOptions), + smartsheet_options=_from_dict(d, "smartsheet_options", SmartsheetOptions), tiktok_ads_options=_from_dict(d, "tiktok_ads_options", TikTokAdsOptions), ) @@ -898,6 +919,34 @@ def from_dict(cls, d: Dict[str, Any]) -> GetUpdateResponse: return cls(update=_from_dict(d, "update", UpdateInfo)) +@dataclass +class GoogleAdsConfig: + manager_account_id: Optional[str] = None + """(Required) Manager Account ID (also called MCC Account ID) used to list and access customer + accounts under this manager account. This is required for fetching the list of customer accounts + during source selection. If the same field is also set in the object-level GoogleAdsOptions + (connector_options), the object-level value takes precedence over this top-level config.""" + + def as_dict(self) -> dict: + """Serializes the GoogleAdsConfig into a dictionary suitable for use as a JSON request body.""" + body = {} + if self.manager_account_id is not None: + body["manager_account_id"] = self.manager_account_id + return body + + def as_shallow_dict(self) -> dict: + """Serializes the GoogleAdsConfig into a shallow dictionary of its immediate attributes.""" + body = {} + if self.manager_account_id is not None: + body["manager_account_id"] = self.manager_account_id + return body + + @classmethod + def from_dict(cls, d: Dict[str, Any]) -> GoogleAdsConfig: + """Deserializes the GoogleAdsConfig from a dictionary.""" + return cls(manager_account_id=d.get("manager_account_id", None)) + + @dataclass class GoogleAdsOptions: """Google Ads specific options for ingestion (object-level). When set, these values override the @@ -1400,6 +1449,33 @@ class IngestionSourceType(Enum): WORKDAY_RAAS = "WORKDAY_RAAS" +@dataclass +class JiraConnectorOptions: + """Jira specific options for ingestion""" + + include_jira_spaces: Optional[List[str]] = None + """(Optional) Projects to filter Jira data on""" + + def as_dict(self) -> dict: + """Serializes the JiraConnectorOptions into a dictionary suitable for use as a JSON request body.""" + body = {} + if self.include_jira_spaces: + body["include_jira_spaces"] = [v for v in self.include_jira_spaces] + return body + + def as_shallow_dict(self) -> dict: + """Serializes the JiraConnectorOptions into a shallow dictionary of its immediate attributes.""" + body = {} + if self.include_jira_spaces: + body["include_jira_spaces"] = self.include_jira_spaces + return body + + @classmethod + def from_dict(cls, d: Dict[str, Any]) -> JiraConnectorOptions: + """Deserializes the JiraConnectorOptions from a dictionary.""" + return cls(include_jira_spaces=d.get("include_jira_spaces", None)) + + @dataclass class ListPipelineEventsResponse: events: Optional[List[PipelineEvent]] = None @@ -1856,6 +1932,136 @@ def from_dict(cls, d: Dict[str, Any]) -> Origin: ) +class OutlookAttachmentMode(Enum): + """Attachment behavior mode for Outlook ingestion""" + + ALL = "ALL" + INLINE_ONLY = "INLINE_ONLY" + NONE = "NONE" + NON_INLINE_ONLY = "NON_INLINE_ONLY" + + +class OutlookBodyFormat(Enum): + """Body format for Outlook email content""" + + TEXT_HTML = "TEXT_HTML" + TEXT_PLAIN = "TEXT_PLAIN" + + +@dataclass +class OutlookOptions: + """Outlook specific options for ingestion""" + + attachment_mode: Optional[OutlookAttachmentMode] = None + """(Optional) Controls which attachments to ingest. If not specified, defaults to ALL.""" + + body_format: Optional[OutlookBodyFormat] = None + """(Optional) Defines how the body_content column is populated. TEXT_HTML: Preserves full + formatting, links, and styling. TEXT_PLAIN: Converts body to plain text. Recommended for AI/RAG + pipelines to reduce token usage and noise.""" + + folder_filter: Optional[List[str]] = None + """Deprecated. Use include_folders instead.""" + + include_folders: Optional[List[str]] = None + """(Optional) Filter mail folders to include in the sync. If not specified, all folders will be + synced. Examples: Inbox, Sent Items, Custom_Folder Filter semantics: OR between different + folders.""" + + include_mailboxes: Optional[List[str]] = None + """(Optional) List of mailboxes to sync (e.g. mailbox email addresses or identifiers). If not + specified, all accessible mailboxes are ingested. Filter semantics: OR between different + mailboxes.""" + + include_senders: Optional[List[str]] = None + """(Optional) Filter emails by sender address. Uses exact email match. Examples: user@vendor.com, + alerts@system.io, noreply@company.com If not specified, emails from all senders will be synced. + Filter semantics: OR between different senders.""" + + include_subjects: Optional[List[str]] = None + """(Optional) Filter emails by subject line. Values ending with "*" use prefix match (subject + starts with the part before "*"); otherwise substring match (subject contains the value). + Examples: "Invoice" (substring), "Re:*" (prefix), "Support Ticket", "URGENT*" If not specified, + emails with all subjects will be synced. Filter semantics: OR between different subjects.""" + + sender_filter: Optional[List[str]] = None + """Deprecated. Use include_senders instead.""" + + start_date: Optional[str] = None + """(Optional) Start date for the initial sync in YYYY-MM-DD format. Format: YYYY-MM-DD (e.g., + 2024-01-01) This determines the earliest date from which to sync historical data. If not + specified, complete history is ingested.""" + + subject_filter: Optional[List[str]] = None + """Deprecated. Use include_subjects instead.""" + + def as_dict(self) -> dict: + """Serializes the OutlookOptions into a dictionary suitable for use as a JSON request body.""" + body = {} + if self.attachment_mode is not None: + body["attachment_mode"] = self.attachment_mode.value + if self.body_format is not None: + body["body_format"] = self.body_format.value + if self.folder_filter: + body["folder_filter"] = [v for v in self.folder_filter] + if self.include_folders: + body["include_folders"] = [v for v in self.include_folders] + if self.include_mailboxes: + body["include_mailboxes"] = [v for v in self.include_mailboxes] + if self.include_senders: + body["include_senders"] = [v for v in self.include_senders] + if self.include_subjects: + body["include_subjects"] = [v for v in self.include_subjects] + if self.sender_filter: + body["sender_filter"] = [v for v in self.sender_filter] + if self.start_date is not None: + body["start_date"] = self.start_date + if self.subject_filter: + body["subject_filter"] = [v for v in self.subject_filter] + return body + + def as_shallow_dict(self) -> dict: + """Serializes the OutlookOptions into a shallow dictionary of its immediate attributes.""" + body = {} + if self.attachment_mode is not None: + body["attachment_mode"] = self.attachment_mode + if self.body_format is not None: + body["body_format"] = self.body_format + if self.folder_filter: + body["folder_filter"] = self.folder_filter + if self.include_folders: + body["include_folders"] = self.include_folders + if self.include_mailboxes: + body["include_mailboxes"] = self.include_mailboxes + if self.include_senders: + body["include_senders"] = self.include_senders + if self.include_subjects: + body["include_subjects"] = self.include_subjects + if self.sender_filter: + body["sender_filter"] = self.sender_filter + if self.start_date is not None: + body["start_date"] = self.start_date + if self.subject_filter: + body["subject_filter"] = self.subject_filter + return body + + @classmethod + def from_dict(cls, d: Dict[str, Any]) -> OutlookOptions: + """Deserializes the OutlookOptions from a dictionary.""" + return cls( + attachment_mode=_enum(d, "attachment_mode", OutlookAttachmentMode), + body_format=_enum(d, "body_format", OutlookBodyFormat), + folder_filter=d.get("folder_filter", None), + include_folders=d.get("include_folders", None), + include_mailboxes=d.get("include_mailboxes", None), + include_senders=d.get("include_senders", None), + include_subjects=d.get("include_subjects", None), + sender_filter=d.get("sender_filter", None), + start_date=d.get("start_date", None), + subject_filter=d.get("subject_filter", None), + ) + + @dataclass class PathPattern: include: Optional[str] = None @@ -3562,6 +3768,36 @@ class SharepointOptionsSharepointEntityType(Enum): PERMISSION = "PERMISSION" +@dataclass +class SmartsheetOptions: + """Smartsheet specific options for ingestion""" + + enforce_schema: Optional[bool] = None + """(Optional) When true, maps each column to its Smartsheet-declared type (Text/Number/Date/ + Checkbox/etc.). Cells that do not conform to the declared type are set to NULL. When false, all + columns land as STRING. Use false for sheets with irregular data or columns that frequently + violate their own declared type. If not specified, defaults to true.""" + + def as_dict(self) -> dict: + """Serializes the SmartsheetOptions into a dictionary suitable for use as a JSON request body.""" + body = {} + if self.enforce_schema is not None: + body["enforce_schema"] = self.enforce_schema + return body + + def as_shallow_dict(self) -> dict: + """Serializes the SmartsheetOptions into a shallow dictionary of its immediate attributes.""" + body = {} + if self.enforce_schema is not None: + body["enforce_schema"] = self.enforce_schema + return body + + @classmethod + def from_dict(cls, d: Dict[str, Any]) -> SmartsheetOptions: + """Deserializes the SmartsheetOptions from a dictionary.""" + return cls(enforce_schema=d.get("enforce_schema", None)) + + @dataclass class SourceCatalogConfig: """SourceCatalogConfig contains catalog-level custom configuration parameters for each source""" @@ -3603,11 +3839,15 @@ class SourceConfig: catalog: Optional[SourceCatalogConfig] = None """Catalog-level source configuration parameters""" + google_ads_config: Optional[GoogleAdsConfig] = None + def as_dict(self) -> dict: """Serializes the SourceConfig into a dictionary suitable for use as a JSON request body.""" body = {} if self.catalog: body["catalog"] = self.catalog.as_dict() + if self.google_ads_config: + body["google_ads_config"] = self.google_ads_config.as_dict() return body def as_shallow_dict(self) -> dict: @@ -3615,12 +3855,17 @@ def as_shallow_dict(self) -> dict: body = {} if self.catalog: body["catalog"] = self.catalog + if self.google_ads_config: + body["google_ads_config"] = self.google_ads_config return body @classmethod def from_dict(cls, d: Dict[str, Any]) -> SourceConfig: """Deserializes the SourceConfig from a dictionary.""" - return cls(catalog=_from_dict(d, "catalog", SourceCatalogConfig)) + return cls( + catalog=_from_dict(d, "catalog", SourceCatalogConfig), + google_ads_config=_from_dict(d, "google_ads_config", GoogleAdsConfig), + ) @dataclass diff --git a/databricks/sdk/service/postgres.py b/databricks/sdk/service/postgres.py index 180ca6caf..71b0ac4b5 100755 --- a/databricks/sdk/service/postgres.py +++ b/databricks/sdk/service/postgres.py @@ -1096,7 +1096,8 @@ class EndpointSpec: """The endpoint type. A branch can only have one READ_WRITE endpoint.""" autoscaling_limit_max_cu: Optional[float] = None - """The maximum number of Compute Units. Minimum value is 0.5.""" + """The maximum number of Compute Units. The maximum value is 64. The difference between the minimum + and maximum Compute Units (max - min) must not exceed 16.""" autoscaling_limit_min_cu: Optional[float] = None """The minimum number of Compute Units. Minimum value is 0.5.""" @@ -1181,7 +1182,8 @@ def from_dict(cls, d: Dict[str, Any]) -> EndpointSpec: @dataclass class EndpointStatus: autoscaling_limit_max_cu: Optional[float] = None - """The maximum number of Compute Units.""" + """The maximum number of Compute Units. The maximum value is 64. The difference between the minimum + and maximum Compute Units (max - min) must not exceed 16.""" autoscaling_limit_min_cu: Optional[float] = None """The minimum number of Compute Units.""" @@ -1395,8 +1397,10 @@ class ErrorCode(Enum): @dataclass class InitialEndpointSpec: + """Configuration for the initial Read/Write endpoint created during project creation.""" + group: Optional[EndpointGroupSpec] = None - """Settings for HA configuration of the endpoint""" + """Settings for HA configuration of the endpoint.""" def as_dict(self) -> dict: """Serializes the InitialEndpointSpec into a dictionary suitable for use as a JSON request body.""" @@ -1694,6 +1698,10 @@ class Project: create_time: Optional[Timestamp] = None """A timestamp indicating when the project was created.""" + delete_time: Optional[Timestamp] = None + """A timestamp indicating when the project was soft-deleted. Empty if the project is not deleted, + otherwise set to a timestamp in the past.""" + initial_endpoint_spec: Optional[InitialEndpointSpec] = None """Configuration settings for the initial Read/Write endpoint created inside the default branch for a newly created project. If omitted, the initial endpoint created will have default settings, @@ -1704,6 +1712,10 @@ class Project: name: Optional[str] = None """Output only. The full resource path of the project. Format: projects/{project_id}""" + purge_time: Optional[Timestamp] = None + """A timestamp indicating when the project is scheduled for permanent deletion. Empty if the + project is not deleted, otherwise set to a timestamp in the future.""" + spec: Optional[ProjectSpec] = None """The spec contains the project configuration, including display_name, pg_version (Postgres version), history_retention_duration, and default_endpoint_settings.""" @@ -1722,10 +1734,14 @@ def as_dict(self) -> dict: body = {} if self.create_time is not None: body["create_time"] = self.create_time.ToJsonString() + if self.delete_time is not None: + body["delete_time"] = self.delete_time.ToJsonString() if self.initial_endpoint_spec: body["initial_endpoint_spec"] = self.initial_endpoint_spec.as_dict() if self.name is not None: body["name"] = self.name + if self.purge_time is not None: + body["purge_time"] = self.purge_time.ToJsonString() if self.spec: body["spec"] = self.spec.as_dict() if self.status: @@ -1741,10 +1757,14 @@ def as_shallow_dict(self) -> dict: body = {} if self.create_time is not None: body["create_time"] = self.create_time + if self.delete_time is not None: + body["delete_time"] = self.delete_time if self.initial_endpoint_spec: body["initial_endpoint_spec"] = self.initial_endpoint_spec if self.name is not None: body["name"] = self.name + if self.purge_time is not None: + body["purge_time"] = self.purge_time if self.spec: body["spec"] = self.spec if self.status: @@ -1760,8 +1780,10 @@ def from_dict(cls, d: Dict[str, Any]) -> Project: """Deserializes the Project from a dictionary.""" return cls( create_time=_timestamp(d, "create_time"), + delete_time=_timestamp(d, "delete_time"), initial_endpoint_spec=_from_dict(d, "initial_endpoint_spec", InitialEndpointSpec), name=d.get("name", None), + purge_time=_timestamp(d, "purge_time"), spec=_from_dict(d, "spec", ProjectSpec), status=_from_dict(d, "status", ProjectStatus), uid=d.get("uid", None), @@ -1909,7 +1931,7 @@ class ProjectSpec: history_retention_duration: Optional[Duration] = None """The number of seconds to retain the shared history for point in time recovery for all branches - in this project. Value should be between 172800s (2 days) and 2592000s (30 days).""" + in this project. Value should be between 172800s (2 days) and 3024000s (35 days).""" pg_version: Optional[int] = None """The major Postgres version number. Supported versions are 16 and 17.""" @@ -2931,7 +2953,9 @@ class PostgresAPI: def __init__(self, api_client): self._api = api_client - def create_branch(self, parent: str, branch: Branch, branch_id: str) -> CreateBranchOperation: + def create_branch( + self, parent: str, branch: Branch, branch_id: str, *, replace_existing: Optional[bool] = None + ) -> CreateBranchOperation: """Creates a new database branch in the project. :param parent: str @@ -2943,6 +2967,8 @@ def create_branch(self, parent: str, branch: Branch, branch_id: str) -> CreateBr is required and must be 1-63 characters long, start with a lowercase letter, and contain only lowercase letters, numbers, and hyphens. For example, `development` becomes `projects/my-app/branches/development`. + :param replace_existing: bool (optional) + If true, update the branch if it already exists instead of returning an error. :returns: :class:`Operation` """ @@ -2951,6 +2977,8 @@ def create_branch(self, parent: str, branch: Branch, branch_id: str) -> CreateBr query = {} if branch_id is not None: query["branch_id"] = branch_id + if replace_existing is not None: + query["replace_existing"] = replace_existing headers = { "Accept": "application/json", "Content-Type": "application/json", @@ -3032,7 +3060,9 @@ def create_database( operation = Operation.from_dict(res) return CreateDatabaseOperation(self, operation) - def create_endpoint(self, parent: str, endpoint: Endpoint, endpoint_id: str) -> CreateEndpointOperation: + def create_endpoint( + self, parent: str, endpoint: Endpoint, endpoint_id: str, *, replace_existing: Optional[bool] = None + ) -> CreateEndpointOperation: """Creates a new compute endpoint in the branch. :param parent: str @@ -3044,6 +3074,8 @@ def create_endpoint(self, parent: str, endpoint: Endpoint, endpoint_id: str) -> The ID is required and must be 1-63 characters long, start with a lowercase letter, and contain only lowercase letters, numbers, and hyphens. For example, `primary` becomes `projects/my-app/branches/development/endpoints/primary`. + :param replace_existing: bool (optional) + If true, update the endpoint if it already exists instead of returning an error. :returns: :class:`Operation` """ @@ -3052,6 +3084,8 @@ def create_endpoint(self, parent: str, endpoint: Endpoint, endpoint_id: str) -> query = {} if endpoint_id is not None: query["endpoint_id"] = endpoint_id + if replace_existing is not None: + query["replace_existing"] = replace_existing headers = { "Accept": "application/json", "Content-Type": "application/json", @@ -3256,15 +3290,20 @@ def delete_endpoint(self, name: str) -> DeleteEndpointOperation: operation = Operation.from_dict(res) return DeleteEndpointOperation(self, operation) - def delete_project(self, name: str) -> DeleteProjectOperation: + def delete_project(self, name: str, *, purge: Optional[bool] = None) -> DeleteProjectOperation: """Deletes the specified database project. :param name: str The full resource path of the project to delete. Format: projects/{project_id} + :param purge: bool (optional) + If true, permanently deletes the project (hard delete). If false or unset, performs a soft delete. :returns: :class:`Operation` """ + query = {} + if purge is not None: + query["purge"] = purge headers = { "Accept": "application/json", } @@ -3273,7 +3312,7 @@ def delete_project(self, name: str) -> DeleteProjectOperation: if cfg.workspace_id: headers["X-Databricks-Org-Id"] = cfg.workspace_id - res = self._api.do("DELETE", f"/api/2.0/postgres/{name}", headers=headers) + res = self._api.do("DELETE", f"/api/2.0/postgres/{name}", query=query, headers=headers) operation = Operation.from_dict(res) return DeleteProjectOperation(self, operation) @@ -3641,13 +3680,18 @@ def list_endpoints( return query["page_token"] = json["next_page_token"] - def list_projects(self, *, page_size: Optional[int] = None, page_token: Optional[str] = None) -> Iterator[Project]: + def list_projects( + self, *, page_size: Optional[int] = None, page_token: Optional[str] = None, show_deleted: Optional[bool] = None + ) -> Iterator[Project]: """Returns a paginated list of database projects in the workspace that the user has permission to access. :param page_size: int (optional) Upper bound for items returned. Cannot be negative. The maximum value is 100. :param page_token: str (optional) Page token from a previous response. If not provided, returns the first page. + :param show_deleted: bool (optional) + Whether to include soft-deleted projects in the response. When true, soft-deleted projects are + included alongside active projects. Hard-deleted and already-purged projects are never returned. :returns: Iterator over :class:`Project` """ @@ -3657,6 +3701,8 @@ def list_projects(self, *, page_size: Optional[int] = None, page_token: Optional query["page_size"] = page_size if page_token is not None: query["page_token"] = page_token + if show_deleted is not None: + query["show_deleted"] = show_deleted headers = { "Accept": "application/json", } @@ -3711,6 +3757,28 @@ def list_roles( return query["page_token"] = json["next_page_token"] + def undelete_project(self, name: str) -> UndeleteProjectOperation: + """Undeletes a soft-deleted project. + + :param name: str + The full resource path of the project to undelete. Format: projects/{project_id} + + :returns: :class:`Operation` + """ + + headers = { + "Accept": "application/json", + "Content-Type": "application/json", + } + + cfg = self._api._cfg + if cfg.workspace_id: + headers["X-Databricks-Org-Id"] = cfg.workspace_id + + res = self._api.do("POST", f"/api/2.0/postgres/{name}/undelete", headers=headers) + operation = Operation.from_dict(res) + return UndeleteProjectOperation(self, operation) + def update_branch(self, name: str, branch: Branch, update_mask: FieldMask) -> UpdateBranchOperation: """Updates the specified database branch. You can set this branch as the project's default branch, or protect/unprotect it. @@ -4947,6 +5015,81 @@ def done(self) -> bool: return operation.done +class UndeleteProjectOperation: + """Long-running operation for undelete_project""" + + def __init__(self, impl: PostgresAPI, operation: Operation): + self._impl = impl + self._operation = operation + + def wait(self, opts: Optional[lro.LroOptions] = None): + """Wait blocks until the long-running operation is completed. If no timeout is + specified, this will poll indefinitely. If a timeout is provided and the operation + didn't finish within the timeout, this function will raise an error of type + TimeoutError, otherwise returns successful response and any errors encountered. + + :param opts: :class:`LroOptions` + Timeout options (default: polls indefinitely) + + :returns: :class:`Any /* MISSING TYPE */` + """ + + def poll_operation(): + operation = self._impl.get_operation(name=self._operation.name) + + # Update local operation state + self._operation = operation + + if not operation.done: + return None, RetryError.continues("operation still in progress") + + if operation.error: + error_msg = operation.error.message if operation.error.message else "unknown error" + if operation.error.error_code: + error_msg = f"[{operation.error.error_code}] {error_msg}" + return None, RetryError.halt(Exception(f"operation failed: {error_msg}")) + + # Operation completed successfully, unmarshal response. + if operation.response is None: + return None, RetryError.halt(Exception("operation completed but no response available")) + + return {}, None + + poll(poll_operation, timeout=opts.timeout if opts is not None else None) + + def name(self) -> str: + """Name returns the name of the long-running operation. The name is assigned + by the server and is unique within the service from which the operation is created. + + :returns: str + """ + return self._operation.name + + def metadata(self) -> ProjectOperationMetadata: + """Metadata returns metadata associated with the long-running operation. + If the metadata is not available, the returned metadata is None. + + :returns: :class:`ProjectOperationMetadata` or None + """ + if self._operation.metadata is None: + return None + + return ProjectOperationMetadata.from_dict(self._operation.metadata) + + def done(self) -> bool: + """Done reports whether the long-running operation has completed. + + :returns: bool + """ + # Refresh the operation state first + operation = self._impl.get_operation(name=self._operation.name) + + # Update local operation state + self._operation = operation + + return operation.done + + class UpdateBranchOperation: """Long-running operation for update_branch""" diff --git a/databricks/sdk/service/settings.py b/databricks/sdk/service/settings.py index e755fa707..adccc7da2 100755 --- a/databricks/sdk/service/settings.py +++ b/databricks/sdk/service/settings.py @@ -593,12 +593,14 @@ def from_dict(cls, d: Dict[str, Any]) -> ClusterAutoRestartMessageMaintenanceWin @dataclass class ComplianceSecurityProfile: - """SHIELD feature: CSP""" + """SHIELD feature: CSP Compliance Security Profile (CSP) enables enhanced compliance controls on + the workspace.""" compliance_standards: Optional[List[ComplianceStandard]] = None - """Set by customers when they request Compliance Security Profile (CSP)""" + """Compliance standards selected by the customer for this Compliance Security Profile.""" is_enabled: Optional[bool] = None + """Whether Compliance Security Profile (CSP) is enabled on the workspace.""" def as_dict(self) -> dict: """Serializes the ComplianceSecurityProfile into a dictionary suitable for use as a JSON request body.""" @@ -3103,9 +3105,11 @@ def from_dict(cls, d: Dict[str, Any]) -> EnableResultsDownloading: @dataclass class EnhancedSecurityMonitoring: - """SHIELD feature: ESM""" + """SHIELD feature: ESM Enhanced Security Monitoring (ESM) enables additional security monitoring on + the workspace.""" is_enabled: Optional[bool] = None + """Whether Enhanced Security Monitoring (ESM) is enabled on the workspace.""" def as_dict(self) -> dict: """Serializes the EnhancedSecurityMonitoring into a dictionary suitable for use as a JSON request body.""" @@ -8335,8 +8339,8 @@ def delete_private_endpoint_rule( ) -> NccPrivateEndpointRule: """Initiates deleting a private endpoint rule. If the connection state is PENDING or EXPIRED, the private endpoint is immediately deleted. Otherwise, the private endpoint is deactivated and will be deleted - after seven days of deactivation. When a private endpoint is deactivated, the `deactivated` field is - set to `true` and the private endpoint is not available to your serverless compute resources. + after one day of deactivation. When a private endpoint is deactivated, the `deactivated` field is set + to `true` and the private endpoint is not available to your serverless compute resources. :param network_connectivity_config_id: str Your Network Connectvity Configuration ID. diff --git a/databricks/sdk/service/supervisoragents.py b/databricks/sdk/service/supervisoragents.py index b76831d36..d87937662 100755 --- a/databricks/sdk/service/supervisoragents.py +++ b/databricks/sdk/service/supervisoragents.py @@ -47,9 +47,10 @@ def from_dict(cls, d: Dict[str, Any]) -> App: @dataclass class Connection: - """Databricks connection. Supported connection: external mcp server.""" + """Deprecated: Use UcConnection instead. Databricks connection. Supported connection: external mcp + server.""" - name: str + name: Optional[str] = None def as_dict(self) -> dict: """Serializes the Connection into a dictionary suitable for use as a JSON request body.""" @@ -298,8 +299,8 @@ def from_dict(cls, d: Dict[str, Any]) -> SupervisorAgent: @dataclass class Tool: tool_type: str - """Tool type. Must be one of: "genie_space", "knowledge_assistant", "uc_function", "connection", - "app", "volume", "lakeview_dashboard", "serving_endpoint".""" + """Tool type. Must be one of: "genie_space", "knowledge_assistant", "uc_function", "uc_connection", + "app", "volume", "lakeview_dashboard", "serving_endpoint", "uc_table", "vector_search_index".""" description: str """Description of what this tool does (user-facing).""" @@ -307,6 +308,7 @@ class Tool: app: Optional[App] = None connection: Optional[Connection] = None + """Deprecated: Use uc_connection instead.""" genie_space: Optional[GenieSpace] = None @@ -321,6 +323,8 @@ class Tool: tool_id: Optional[str] = None """User specified id of the Tool.""" + uc_connection: Optional[UcConnection] = None + uc_function: Optional[UcFunction] = None volume: Optional[Volume] = None @@ -346,6 +350,8 @@ def as_dict(self) -> dict: body["tool_id"] = self.tool_id if self.tool_type is not None: body["tool_type"] = self.tool_type + if self.uc_connection: + body["uc_connection"] = self.uc_connection.as_dict() if self.uc_function: body["uc_function"] = self.uc_function.as_dict() if self.volume: @@ -373,6 +379,8 @@ def as_shallow_dict(self) -> dict: body["tool_id"] = self.tool_id if self.tool_type is not None: body["tool_type"] = self.tool_type + if self.uc_connection: + body["uc_connection"] = self.uc_connection if self.uc_function: body["uc_function"] = self.uc_function if self.volume: @@ -392,11 +400,38 @@ def from_dict(cls, d: Dict[str, Any]) -> Tool: name=d.get("name", None), tool_id=d.get("tool_id", None), tool_type=d.get("tool_type", None), + uc_connection=_from_dict(d, "uc_connection", UcConnection), uc_function=_from_dict(d, "uc_function", UcFunction), volume=_from_dict(d, "volume", Volume), ) +@dataclass +class UcConnection: + """Databricks UC connection. Supported connection: external mcp server.""" + + name: str + + def as_dict(self) -> dict: + """Serializes the UcConnection into a dictionary suitable for use as a JSON request body.""" + body = {} + if self.name is not None: + body["name"] = self.name + return body + + def as_shallow_dict(self) -> dict: + """Serializes the UcConnection into a shallow dictionary of its immediate attributes.""" + body = {} + if self.name is not None: + body["name"] = self.name + return body + + @classmethod + def from_dict(cls, d: Dict[str, Any]) -> UcConnection: + """Deserializes the UcConnection from a dictionary.""" + return cls(name=d.get("name", None)) + + @dataclass class UcFunction: name: str @@ -477,7 +512,8 @@ def create_supervisor_agent(self, supervisor_agent: SupervisorAgent) -> Supervis def create_tool(self, parent: str, tool: Tool, tool_id: str) -> Tool: """Creates a Tool under a Supervisor Agent. Specify one of "genie_space", "knowledge_assistant", - "uc_function", "connection", "app", "volume", "lakeview_dashboard" in the request body. + "uc_function", "uc_connection", "app", "volume", "lakeview_dashboard", "uc_table", + "vector_search_index" in the request body. :param parent: str Parent resource where this tool will be created. Format: supervisor-agents/{supervisor_agent_id} diff --git a/databricks/sdk/service/vectorsearch.py b/databricks/sdk/service/vectorsearch.py index aefdb7959..bd3e4616f 100755 --- a/databricks/sdk/service/vectorsearch.py +++ b/databricks/sdk/service/vectorsearch.py @@ -596,7 +596,10 @@ def from_dict(cls, d: Dict[str, Any]) -> EndpointInfo: @dataclass class EndpointScalingInfo: requested_min_qps: Optional[int] = None - """The minimum QPS target requested for the endpoint.""" + """Deprecated: use requested_target_qps. Kept at PUBLIC_BETA with deprecated = true so generated + SDK surfaces (Go, Java, TypeScript, Terraform) keep exposing the field with a deprecation marker + rather than losing it on next regeneration. Hiding completely (visibility = PUBLIC_UNDOCUMENTED) + is a follow-up PR once downstream consumers have migrated.""" state: Optional[ScalingChangeState] = None """The current state of the scaling change request.""" @@ -1730,8 +1733,9 @@ def create_endpoint( :param budget_policy_id: str (optional) The budget policy id to be applied :param min_qps: int (optional) - Min QPS for the endpoint. Mutually exclusive with num_replicas. The actual replica count is - calculated at index creation/sync time based on this value. + Deprecated: use target_qps. Min QPS for the endpoint. Mutually exclusive with num_replicas. Kept at + PUBLIC_BETA with deprecated = true so generated SDK surfaces keep the field with a deprecation + marker; hiding completely is a follow-up PR. :param usage_policy_id: str (optional) The usage policy id to be applied once we've migrated to usage policies @@ -1859,7 +1863,9 @@ def patch_endpoint(self, endpoint_name: str, *, min_qps: Optional[int] = None) - :param endpoint_name: str Name of the vector search endpoint :param min_qps: int (optional) - Min QPS for the endpoint. Positive integer sets QPS target; -1 resets to default scaling behavior. + Deprecated: use target_qps. Min QPS for the endpoint. Positive integer sets QPS target; -1 resets to + default scaling behavior. Kept at PUBLIC_BETA with deprecated = true so generated SDK surfaces keep + the field with a deprecation marker; hiding completely is a follow-up PR. :returns: :class:`EndpointInfo` """ diff --git a/databricks/sdk/service/workspace.py b/databricks/sdk/service/workspace.py index 74157ef0e..2a1d70b7e 100755 --- a/databricks/sdk/service/workspace.py +++ b/databricks/sdk/service/workspace.py @@ -886,7 +886,8 @@ class ObjectInfo: """Only applicable to files. The creation UTC timestamp.""" language: Optional[Language] = None - """The language of the object. This value is set only if the object type is ``NOTEBOOK``.""" + """The language of the object. This value is set only if the object type is ``NOTEBOOK``. For + Jupyter (.ipynb) notebooks, this is always ``PYTHON``.""" modified_at: Optional[int] = None """Only applicable to files, the last modified UTC timestamp.""" diff --git a/docs/account/provisioning/encryption_keys.rst b/docs/account/provisioning/encryption_keys.rst old mode 100644 new mode 100755 index fc053d71c..7a3b75426 --- a/docs/account/provisioning/encryption_keys.rst +++ b/docs/account/provisioning/encryption_keys.rst @@ -57,6 +57,14 @@ This operation is available only if your account is on the E2 version of the platform or on a select custom plan that allows multiple workspaces per account. + **GCP only**: To create a customer-managed key on GCP, you must include the + `X-Databricks-GCP-SA-Access-Token` HTTP header in your request. This header must contain a Google + Cloud OAuth access token with the `cloud-platform` scope. The Google identity associated with the + token must also have the `setIamPermissions` and `getIamPermissions` IAM permissions on the key + resource. For details on obtaining this token, see [Authenticate with Google ID tokens]. + + [Authenticate with Google ID tokens]: https://docs.databricks.com/gcp/en/dev-tools/auth/authentication-google-id.html + :param use_cases: List[:class:`KeyUseCase`] The cases that the key can be used for. :param aws_key_info: :class:`CreateAwsKeyInfo` (optional) diff --git a/docs/account/settings/network_connectivity.rst b/docs/account/settings/network_connectivity.rst old mode 100644 new mode 100755 index 90c885c17..5e1db5aed --- a/docs/account/settings/network_connectivity.rst +++ b/docs/account/settings/network_connectivity.rst @@ -65,8 +65,8 @@ Initiates deleting a private endpoint rule. If the connection state is PENDING or EXPIRED, the private endpoint is immediately deleted. Otherwise, the private endpoint is deactivated and will be deleted - after seven days of deactivation. When a private endpoint is deactivated, the `deactivated` field is - set to `true` and the private endpoint is not available to your serverless compute resources. + after one day of deactivation. When a private endpoint is deactivated, the `deactivated` field is set + to `true` and the private endpoint is not available to your serverless compute resources. :param network_connectivity_config_id: str Your Network Connectvity Configuration ID. diff --git a/docs/dbdataclasses/catalog.rst b/docs/dbdataclasses/catalog.rst index 712f5d74f..f34f26920 100755 --- a/docs/dbdataclasses/catalog.rst +++ b/docs/dbdataclasses/catalog.rst @@ -283,7 +283,7 @@ These dataclasses are used in the SDK to represent API requests and responses fo .. py:class:: ConnectionType - Next Id: 75 + Next Id: 123 .. py:attribute:: BIGQUERY :value: "BIGQUERY" @@ -854,6 +854,10 @@ These dataclasses are used in the SDK to represent API requests and responses fo :members: :undoc-members: +.. autoclass:: GenerateTemporaryVolumeCredentialResponse + :members: + :undoc-members: + .. autoclass:: GetCatalogWorkspaceBindingsResponse :members: :undoc-members: @@ -954,6 +958,10 @@ These dataclasses are used in the SDK to represent API requests and responses fo :members: :undoc-members: +.. autoclass:: ListSecretsResponse + :members: + :undoc-members: + .. autoclass:: ListStorageCredentialsResponse :members: :undoc-members: @@ -1509,13 +1517,17 @@ These dataclasses are used in the SDK to represent API requests and responses fo :members: :undoc-members: +.. autoclass:: Secret + :members: + :undoc-members: + .. autoclass:: Securable :members: :undoc-members: .. py:class:: SecurableKind - Latest kind: CONNECTION_VEEVA_VAULT_OAUTH_M2M = 311; Next id: 312 + Latest kind: TOOLSET_EXTERNAL_MCP = 318; Next id: 319 .. py:attribute:: TABLE_DB_STORAGE :value: "TABLE_DB_STORAGE" @@ -2061,6 +2073,14 @@ These dataclasses are used in the SDK to represent API requests and responses fo :members: :undoc-members: +.. py:class:: VolumeOperation + + .. py:attribute:: READ_VOLUME + :value: "READ_VOLUME" + + .. py:attribute:: WRITE_VOLUME + :value: "WRITE_VOLUME" + .. py:class:: VolumeType .. py:attribute:: EXTERNAL diff --git a/docs/dbdataclasses/compute.rst b/docs/dbdataclasses/compute.rst index f88b5b201..42a8c8a6f 100755 --- a/docs/dbdataclasses/compute.rst +++ b/docs/dbdataclasses/compute.rst @@ -224,6 +224,16 @@ These dataclasses are used in the SDK to represent API requests and responses fo :members: :undoc-members: +.. py:class:: ConfidentialComputeType + + Confidential computing technology for GCP instances. Aligns with gcloud's --confidential-compute-type flag and the REST API's confidentialInstanceConfig.confidentialInstanceType field. See: https://cloud.google.com/confidential-computing/confidential-vm/docs/create-a-confidential-vm-instance + + .. py:attribute:: CONFIDENTIAL_COMPUTE_TYPE_NONE + :value: "CONFIDENTIAL_COMPUTE_TYPE_NONE" + + .. py:attribute:: SEV_SNP + :value: "SEV_SNP" + .. py:class:: ContextStatus .. py:attribute:: ERROR diff --git a/docs/dbdataclasses/index.rst b/docs/dbdataclasses/index.rst index 4214d9769..0bf3b115e 100755 --- a/docs/dbdataclasses/index.rst +++ b/docs/dbdataclasses/index.rst @@ -34,6 +34,7 @@ Dataclasses settingsv2 sharing sql + supervisoragents tags vectorsearch workspace \ No newline at end of file diff --git a/docs/dbdataclasses/jobs.rst b/docs/dbdataclasses/jobs.rst index 7442b03cc..538f1668a 100755 --- a/docs/dbdataclasses/jobs.rst +++ b/docs/dbdataclasses/jobs.rst @@ -1025,6 +1025,9 @@ These dataclasses are used in the SDK to represent API requests and responses fo The code indicates why the run was terminated. Additional codes might be introduced in future releases. * `SUCCESS`: The run was completed successfully. * `SUCCESS_WITH_FAILURES`: The run was completed successfully but some child runs failed. * `USER_CANCELED`: The run was successfully canceled during execution by a user. * `CANCELED`: The run was canceled during execution by the Databricks platform; for example, if the maximum run duration was exceeded. * `SKIPPED`: Run was never executed, for example, if the upstream task run failed, the dependency type condition was not met, or there were no material tasks to execute. * `INTERNAL_ERROR`: The run encountered an unexpected error. Refer to the state message for further details. * `DRIVER_ERROR`: The run encountered an error while communicating with the Spark Driver. * `CLUSTER_ERROR`: The run failed due to a cluster error. Refer to the state message for further details. * `REPOSITORY_CHECKOUT_FAILED`: Failed to complete the checkout due to an error when communicating with the third party service. * `INVALID_CLUSTER_REQUEST`: The run failed because it issued an invalid request to start the cluster. * `WORKSPACE_RUN_LIMIT_EXCEEDED`: The workspace has reached the quota for the maximum number of concurrent active runs. Consider scheduling the runs over a larger time frame. * `FEATURE_DISABLED`: The run failed because it tried to access a feature unavailable for the workspace. * `CLUSTER_REQUEST_LIMIT_EXCEEDED`: The number of cluster creation, start, and upsize requests have exceeded the allotted rate limit. Consider spreading the run execution over a larger time frame. * `STORAGE_ACCESS_ERROR`: The run failed due to an error when accessing the customer blob storage. Refer to the state message for further details. * `RUN_EXECUTION_ERROR`: The run was completed with task failures. For more details, refer to the state message or run output. * `UNAUTHORIZED_ERROR`: The run failed due to a permission issue while accessing a resource. Refer to the state message for further details. * `LIBRARY_INSTALLATION_ERROR`: The run failed while installing the user-requested library. Refer to the state message for further details. The causes might include, but are not limited to: The provided library is invalid, there are insufficient permissions to install the library, and so forth. * `MAX_CONCURRENT_RUNS_EXCEEDED`: The scheduled run exceeds the limit of maximum concurrent runs set for the job. * `MAX_SPARK_CONTEXTS_EXCEEDED`: The run is scheduled on a cluster that has already reached the maximum number of contexts it is configured to create. See: [Link]. * `RESOURCE_NOT_FOUND`: A resource necessary for run execution does not exist. Refer to the state message for further details. * `INVALID_RUN_CONFIGURATION`: The run failed due to an invalid configuration. Refer to the state message for further details. * `CLOUD_FAILURE`: The run failed due to a cloud provider issue. Refer to the state message for further details. * `MAX_JOB_QUEUE_SIZE_EXCEEDED`: The run was skipped due to reaching the job level queue size limit. * `DISABLED`: The run was never executed because it was disabled explicitly by the user. * `BREAKING_CHANGE`: Run failed because of an intentional breaking change in Spark, but it will be retried with a mitigation config. * `CLUSTER_TERMINATED_BY_USER`: The run failed because the externally managed cluster entered an unusable state, likely due to the user terminating or restarting it outside the jobs service. [Link]: https://kb.databricks.com/en_US/notebooks/too-many-execution-contexts-are-open-right-now + .. py:attribute:: BREAKING_CHANGE + :value: "BREAKING_CHANGE" + .. py:attribute:: BUDGET_POLICY_LIMIT_EXCEEDED :value: "BUDGET_POLICY_LIMIT_EXCEEDED" diff --git a/docs/dbdataclasses/knowledgeassistants.rst b/docs/dbdataclasses/knowledgeassistants.rst index 9d5b63ed0..f69c68a7e 100755 --- a/docs/dbdataclasses/knowledgeassistants.rst +++ b/docs/dbdataclasses/knowledgeassistants.rst @@ -12,6 +12,10 @@ These dataclasses are used in the SDK to represent API requests and responses fo :members: :undoc-members: +.. autoclass:: GetKnowledgeAssistantPermissionLevelsResponse + :members: + :undoc-members: + .. autoclass:: IndexSpec :members: :undoc-members: @@ -20,6 +24,36 @@ These dataclasses are used in the SDK to represent API requests and responses fo :members: :undoc-members: +.. autoclass:: KnowledgeAssistantAccessControlRequest + :members: + :undoc-members: + +.. autoclass:: KnowledgeAssistantAccessControlResponse + :members: + :undoc-members: + +.. autoclass:: KnowledgeAssistantPermission + :members: + :undoc-members: + +.. py:class:: KnowledgeAssistantPermissionLevel + + Permission level + + .. py:attribute:: CAN_MANAGE + :value: "CAN_MANAGE" + + .. py:attribute:: CAN_QUERY + :value: "CAN_QUERY" + +.. autoclass:: KnowledgeAssistantPermissions + :members: + :undoc-members: + +.. autoclass:: KnowledgeAssistantPermissionsDescription + :members: + :undoc-members: + .. py:class:: KnowledgeAssistantState .. py:attribute:: ACTIVE diff --git a/docs/dbdataclasses/pipelines.rst b/docs/dbdataclasses/pipelines.rst index d295210bc..2dd2355d5 100755 --- a/docs/dbdataclasses/pipelines.rst +++ b/docs/dbdataclasses/pipelines.rst @@ -1,5 +1,5 @@ -Delta Live Tables -================= +Spark Declarative Pipelines +=========================== These dataclasses are used in the SDK to represent API requests and responses for services in the ``databricks.sdk.service.pipelines`` module. @@ -204,6 +204,10 @@ These dataclasses are used in the SDK to represent API requests and responses fo :members: :undoc-members: +.. autoclass:: GoogleAdsConfig + :members: + :undoc-members: + .. autoclass:: GoogleAdsOptions :members: :undoc-members: @@ -297,6 +301,10 @@ These dataclasses are used in the SDK to represent API requests and responses fo .. py:attribute:: WORKDAY_RAAS :value: "WORKDAY_RAAS" +.. autoclass:: JiraConnectorOptions + :members: + :undoc-members: + .. autoclass:: ListPipelineEventsResponse :members: :undoc-members: @@ -342,6 +350,36 @@ These dataclasses are used in the SDK to represent API requests and responses fo :members: :undoc-members: +.. py:class:: OutlookAttachmentMode + + Attachment behavior mode for Outlook ingestion + + .. py:attribute:: ALL + :value: "ALL" + + .. py:attribute:: INLINE_ONLY + :value: "INLINE_ONLY" + + .. py:attribute:: NONE + :value: "NONE" + + .. py:attribute:: NON_INLINE_ONLY + :value: "NON_INLINE_ONLY" + +.. py:class:: OutlookBodyFormat + + Body format for Outlook email content + + .. py:attribute:: TEXT_HTML + :value: "TEXT_HTML" + + .. py:attribute:: TEXT_PLAIN + :value: "TEXT_PLAIN" + +.. autoclass:: OutlookOptions + :members: + :undoc-members: + .. autoclass:: PathPattern :members: :undoc-members: @@ -541,6 +579,10 @@ These dataclasses are used in the SDK to represent API requests and responses fo .. py:attribute:: PERMISSION :value: "PERMISSION" +.. autoclass:: SmartsheetOptions + :members: + :undoc-members: + .. autoclass:: SourceCatalogConfig :members: :undoc-members: diff --git a/docs/dbdataclasses/settings.rst b/docs/dbdataclasses/settings.rst index fa86225be..6ed0b5a45 100755 --- a/docs/dbdataclasses/settings.rst +++ b/docs/dbdataclasses/settings.rst @@ -206,6 +206,10 @@ These dataclasses are used in the SDK to represent API requests and responses fo :members: :undoc-members: +.. autoclass:: CustomerFacingIngressNetworkPolicyAppsRuntimeDestination + :members: + :undoc-members: + .. autoclass:: CustomerFacingIngressNetworkPolicyAuthentication :members: :undoc-members: @@ -237,6 +241,10 @@ These dataclasses are used in the SDK to represent API requests and responses fo :members: :undoc-members: +.. autoclass:: CustomerFacingIngressNetworkPolicyLakebaseRuntimeDestination + :members: + :undoc-members: + .. autoclass:: CustomerFacingIngressNetworkPolicyPublicAccess :members: :undoc-members: @@ -873,6 +881,10 @@ These dataclasses are used in the SDK to represent API requests and responses fo :members: :undoc-members: +.. autoclass:: UpdateTokenResponse + :members: + :undoc-members: + .. autoclass:: WorkspaceNetworkOption :members: :undoc-members: diff --git a/docs/dbdataclasses/supervisoragents.rst b/docs/dbdataclasses/supervisoragents.rst new file mode 100755 index 000000000..116fc82e4 --- /dev/null +++ b/docs/dbdataclasses/supervisoragents.rst @@ -0,0 +1,49 @@ +Supervisor Agents +================= + +These dataclasses are used in the SDK to represent API requests and responses for services in the ``databricks.sdk.service.supervisoragents`` module. + +.. py:currentmodule:: databricks.sdk.service.supervisoragents +.. autoclass:: App + :members: + :undoc-members: + +.. autoclass:: Connection + :members: + :undoc-members: + +.. autoclass:: GenieSpace + :members: + :undoc-members: + +.. autoclass:: KnowledgeAssistant + :members: + :undoc-members: + +.. autoclass:: ListSupervisorAgentsResponse + :members: + :undoc-members: + +.. autoclass:: ListToolsResponse + :members: + :undoc-members: + +.. autoclass:: SupervisorAgent + :members: + :undoc-members: + +.. autoclass:: Tool + :members: + :undoc-members: + +.. autoclass:: UcConnection + :members: + :undoc-members: + +.. autoclass:: UcFunction + :members: + :undoc-members: + +.. autoclass:: Volume + :members: + :undoc-members: diff --git a/docs/packages.py b/docs/packages.py index aeb245468..48b0331ef 100755 --- a/docs/packages.py +++ b/docs/packages.py @@ -87,6 +87,11 @@ class Package: "Knowledge Assistants", "Manage Knowledge Assistants and related resources.", ), + Package( + "supervisoragents", + "Supervisor Agents", + "Manage Supervisor Agents and related resources.", + ), Package( "dataclassification", "Data Classification", diff --git a/docs/workspace/catalog/catalogs.rst b/docs/workspace/catalog/catalogs.rst index e278d0bf7..22de6e65c 100755 --- a/docs/workspace/catalog/catalogs.rst +++ b/docs/workspace/catalog/catalogs.rst @@ -24,10 +24,10 @@ w = WorkspaceClient() - new_catalog = w.catalogs.create(name=f"sdk-{time.time_ns()}") + created_catalog = w.catalogs.create(name=f"sdk-{time.time_ns()}") # cleanup - w.catalogs.delete(name=new_catalog.name, force=True) + w.catalogs.delete(name=created_catalog.name, force=True) Creates a new catalog instance in the parent metastore if the caller is a metastore admin or has the **CREATE_CATALOG** privilege. diff --git a/docs/workspace/catalog/external_locations.rst b/docs/workspace/catalog/external_locations.rst index 41716522a..0578df8b4 100755 --- a/docs/workspace/catalog/external_locations.rst +++ b/docs/workspace/catalog/external_locations.rst @@ -115,20 +115,20 @@ credential = w.storage_credentials.create( name=f"sdk-{time.time_ns()}", - aws_iam_role=catalog.AwsIamRole(role_arn=os.environ["TEST_METASTORE_DATA_ACCESS_ARN"]), + aws_iam_role=catalog.AwsIamRoleRequest(role_arn=os.environ["TEST_METASTORE_DATA_ACCESS_ARN"]), ) created = w.external_locations.create( name=f"sdk-{time.time_ns()}", credential_name=credential.name, - url=f's3://{os.environ["TEST_BUCKET"]}/sdk-{time.time_ns()}', + url="s3://%s/%s" % (os.environ["TEST_BUCKET"], f"sdk-{time.time_ns()}"), ) - _ = w.external_locations.get(get=created.name) + _ = w.external_locations.get(name=created.name) # cleanup - w.storage_credentials.delete(delete=credential.name) - w.external_locations.delete(delete=created.name) + w.storage_credentials.delete(name=credential.name) + w.external_locations.delete(name=created.name) Gets an external location from the metastore. The caller must be either a metastore admin, the owner of the external location, or a user that has some privilege on the external location. @@ -200,24 +200,24 @@ credential = w.storage_credentials.create( name=f"sdk-{time.time_ns()}", - aws_iam_role=catalog.AwsIamRole(role_arn=os.environ["TEST_METASTORE_DATA_ACCESS_ARN"]), + aws_iam_role=catalog.AwsIamRoleRequest(role_arn=os.environ["TEST_METASTORE_DATA_ACCESS_ARN"]), ) created = w.external_locations.create( name=f"sdk-{time.time_ns()}", credential_name=credential.name, - url=f's3://{os.environ["TEST_BUCKET"]}/sdk-{time.time_ns()}', + url="s3://%s/%s" % (os.environ["TEST_BUCKET"], f"sdk-{time.time_ns()}"), ) _ = w.external_locations.update( name=created.name, credential_name=credential.name, - url=f's3://{os.environ["TEST_BUCKET"]}/sdk-{time.time_ns()}', + url="s3://%s/%s" % (os.environ["TEST_BUCKET"], f"sdk-{time.time_ns()}"), ) # cleanup - w.storage_credentials.delete(delete=credential.name) - w.external_locations.delete(delete=created.name) + w.storage_credentials.delete(name=credential.name) + w.external_locations.delete(name=created.name) Updates an external location in the metastore. The caller must be the owner of the external location, or be a metastore admin. In the second case, the admin can only update the name of the external diff --git a/docs/workspace/catalog/index.rst b/docs/workspace/catalog/index.rst old mode 100644 new mode 100755 index 1cdb8fc69..5bc5c82ff --- a/docs/workspace/catalog/index.rst +++ b/docs/workspace/catalog/index.rst @@ -26,11 +26,13 @@ Configure data governance with Unity Catalog for metastores, catalogs, schemas, resource_quotas rfa schemas + secrets_uc storage_credentials system_schemas table_constraints tables temporary_path_credentials temporary_table_credentials + temporary_volume_credentials volumes workspace_bindings \ No newline at end of file diff --git a/docs/workspace/catalog/schemas.rst b/docs/workspace/catalog/schemas.rst old mode 100644 new mode 100755 index fd1479c78..719d5a156 --- a/docs/workspace/catalog/schemas.rst +++ b/docs/workspace/catalog/schemas.rst @@ -22,13 +22,13 @@ w = WorkspaceClient() - new_catalog = w.catalogs.create(name=f"sdk-{time.time_ns()}") + created_catalog = w.catalogs.create(name=f"sdk-{time.time_ns()}") - created = w.schemas.create(name=f"sdk-{time.time_ns()}", catalog_name=new_catalog.name) + created_schema = w.schemas.create(name=f"sdk-{time.time_ns()}", catalog_name=created_catalog.name) # cleanup - w.catalogs.delete(name=new_catalog.name, force=True) - w.schemas.delete(full_name=created.full_name) + w.catalogs.delete(name=created_catalog.name, force=True) + w.schemas.delete(full_name=created_schema.full_name) Creates a new schema for catalog in the Metastore. The caller must be a metastore admin, or have the **CREATE_SCHEMA** privilege in the parent catalog. diff --git a/docs/workspace/catalog/secrets_uc.rst b/docs/workspace/catalog/secrets_uc.rst new file mode 100755 index 000000000..1b61643f8 --- /dev/null +++ b/docs/workspace/catalog/secrets_uc.rst @@ -0,0 +1,117 @@ +``w.secrets_uc``: Secrets +========================= +.. currentmodule:: databricks.sdk.service.catalog + +.. py:class:: SecretsUcAPI + + A secret is a Unity Catalog securable object that stores sensitive credential data (such as passwords, + tokens, and keys) within a three-level namespace (**catalog_name.schema_name.secret_name**). + + Secrets can be managed using standard Unity Catalog permissions and are scoped to a schema within a + catalog. + + .. py:method:: create_secret(secret: Secret) -> Secret + + Creates a new secret in Unity Catalog. + + You must be the owner of the parent schema or have the **CREATE_SECRET** and **USE SCHEMA** privileges + on the parent schema and **USE CATALOG** on the parent catalog. + + The secret is stored in the specified catalog and schema, and the **value** field contains the + sensitive data to be securely stored. + + :param secret: :class:`Secret` + The secret object to create. The **name**, **catalog_name**, **schema_name**, and **value** fields + are required. + + :returns: :class:`Secret` + + + .. py:method:: delete_secret(full_name: str) + + Deletes a secret by its three-level (fully qualified) name. + + You must be the owner of the secret or a metastore admin. + + :param full_name: str + The three-level (fully qualified) name of the secret (for example, + **catalog_name.schema_name.secret_name**). + + + + + .. py:method:: get_secret(full_name: str [, include_browse: Optional[bool]]) -> Secret + + Gets a secret by its three-level (fully qualified) name. + + You must be a metastore admin, the owner of the secret, or have the **MANAGE** privilege on the + secret. + + The secret value isn't returned by default. To retrieve it, you must also have the **READ_SECRET** + privilege and set **include_value** to true in the request. + + :param full_name: str + The three-level (fully qualified) name of the secret (for example, + **catalog_name.schema_name.secret_name**). + :param include_browse: bool (optional) + Whether to include secrets in the response for which you only have the **BROWSE** privilege, which + limits access to metadata. + + :returns: :class:`Secret` + + + .. py:method:: list_secrets( [, catalog_name: Optional[str], include_browse: Optional[bool], page_size: Optional[int], page_token: Optional[str], schema_name: Optional[str]]) -> Iterator[Secret] + + Lists secrets in Unity Catalog. + + You must be a metastore admin, the owner of the secret, or have the **MANAGE** privilege on the + secret. + + Both **catalog_name** and **schema_name** must be specified together to filter secrets within a + specific schema. Results are paginated; use the **page_token** field from the response to retrieve + subsequent pages. + + :param catalog_name: str (optional) + The name of the catalog under which to list secrets. Both **catalog_name** and **schema_name** must + be specified together. + :param include_browse: bool (optional) + Whether to include secrets in the response for which you only have the **BROWSE** privilege, which + limits access to metadata. + :param page_size: int (optional) + Maximum number of secrets to return. + + - If not specified, at most 10000 secrets are returned. - If set to a value greater than 0, the page + length is the minimum of this value and 10000. - If set to 0, the page length is set to 10000. - If + set to a value less than 0, an invalid parameter error is returned. + :param page_token: str (optional) + Opaque pagination token to go to the next page based on previous query. The maximum page length is + determined by a server configured value. + :param schema_name: str (optional) + The name of the schema under which to list secrets. Both **catalog_name** and **schema_name** must + be specified together. + + :returns: Iterator over :class:`Secret` + + + .. py:method:: update_secret(full_name: str, secret: Secret, update_mask: FieldMask) -> Secret + + Updates an existing secret in Unity Catalog. + + You must be the owner of the secret or a metastore admin. If you are a metastore admin, only the + **owner** field can be changed. + + Use the **update_mask** field to specify which fields to update. Supported updatable fields include + **value**, **comment**, **owner**, and **expire_time**. + + :param full_name: str + The three-level (fully qualified) name of the secret (for example, + **catalog_name.schema_name.secret_name**). + :param secret: :class:`Secret` + The secret object containing the fields to update. Only fields specified in **update_mask** will be + updated. + :param update_mask: FieldMask + The field mask specifying which fields of the secret to update. Supported fields: **value**, + **comment**, **owner**, **expire_time**. + + :returns: :class:`Secret` + \ No newline at end of file diff --git a/docs/workspace/catalog/storage_credentials.rst b/docs/workspace/catalog/storage_credentials.rst index 92da2c568..c174e87a3 100755 --- a/docs/workspace/catalog/storage_credentials.rst +++ b/docs/workspace/catalog/storage_credentials.rst @@ -30,13 +30,14 @@ w = WorkspaceClient() - created = w.storage_credentials.create( + storage_credential = w.storage_credentials.create( name=f"sdk-{time.time_ns()}", aws_iam_role=catalog.AwsIamRoleRequest(role_arn=os.environ["TEST_METASTORE_DATA_ACCESS_ARN"]), + comment="created via SDK", ) # cleanup - w.storage_credentials.delete(name=created.name) + w.storage_credentials.delete(name=storage_credential.name) Creates a new storage credential. @@ -98,13 +99,13 @@ created = w.storage_credentials.create( name=f"sdk-{time.time_ns()}", - aws_iam_role=catalog.AwsIamRole(role_arn=os.environ["TEST_METASTORE_DATA_ACCESS_ARN"]), + aws_iam_role=catalog.AwsIamRoleRequest(role_arn=os.environ["TEST_METASTORE_DATA_ACCESS_ARN"]), ) - by_name = w.storage_credentials.get(get=created.name) + by_name = w.storage_credentials.get(name=created.name) # cleanup - w.storage_credentials.delete(delete=created.name) + w.storage_credentials.delete(name=created.name) Gets a storage credential from the metastore. The caller must be a metastore admin, the owner of the storage credential, or have some permission on the storage credential. @@ -123,10 +124,11 @@ .. code-block:: from databricks.sdk import WorkspaceClient + from databricks.sdk.service import catalog w = WorkspaceClient() - all = w.storage_credentials.list() + all = w.storage_credentials.list(catalog.ListStorageCredentialsRequest()) Gets an array of storage credentials (as __StorageCredentialInfo__ objects). The array is limited to only those storage credentials the caller has permission to access. If the caller is a metastore diff --git a/docs/workspace/catalog/temporary_path_credentials.rst b/docs/workspace/catalog/temporary_path_credentials.rst old mode 100644 new mode 100755 index 6694f39f8..66f94fd64 --- a/docs/workspace/catalog/temporary_path_credentials.rst +++ b/docs/workspace/catalog/temporary_path_credentials.rst @@ -16,9 +16,9 @@ enable the external_access_enabled flag (off by default) at the metastore level. A user needs to be granted the EXTERNAL USE LOCATION permission by external location owner. For requests on existing external tables, user also needs to be granted the EXTERNAL USE SCHEMA permission at the schema level by catalog - admin. + owner. - Note that EXTERNAL USE SCHEMA is a schema level permission that can only be granted by catalog admin + Note that EXTERNAL USE SCHEMA is a schema level permission that can only be granted by catalog owner explicitly and is not included in schema ownership or ALL PRIVILEGES on the schema for security reasons. Similarly, EXTERNAL USE LOCATION is an external location level permission that can only be granted by external location owner explicitly and is not included in external location ownership or ALL PRIVILEGES on diff --git a/docs/workspace/catalog/temporary_table_credentials.rst b/docs/workspace/catalog/temporary_table_credentials.rst old mode 100644 new mode 100755 index 54ccd79b0..36a31c29f --- a/docs/workspace/catalog/temporary_table_credentials.rst +++ b/docs/workspace/catalog/temporary_table_credentials.rst @@ -14,8 +14,8 @@ Temporary table credentials ensure that data access is limited in scope and duration, reducing the risk of unauthorized access or misuse. To use the temporary table credentials API, a metastore admin needs to enable the external_access_enabled flag (off by default) at the metastore level, and user needs to be - granted the EXTERNAL USE SCHEMA permission at the schema level by catalog admin. Note that EXTERNAL USE - SCHEMA is a schema level permission that can only be granted by catalog admin explicitly and is not + granted the EXTERNAL USE SCHEMA permission at the schema level by catalog owner. Note that EXTERNAL USE + SCHEMA is a schema level permission that can only be granted by catalog owner explicitly and is not included in schema ownership or ALL PRIVILEGES on the schema for security reasons. .. py:method:: generate_temporary_table_credentials( [, operation: Optional[TableOperation], table_id: Optional[str]]) -> GenerateTemporaryTableCredentialResponse diff --git a/docs/workspace/catalog/temporary_volume_credentials.rst b/docs/workspace/catalog/temporary_volume_credentials.rst new file mode 100755 index 000000000..8a5412a5c --- /dev/null +++ b/docs/workspace/catalog/temporary_volume_credentials.rst @@ -0,0 +1,35 @@ +``w.temporary_volume_credentials``: Temporary Volume Credentials +================================================================ +.. currentmodule:: databricks.sdk.service.catalog + +.. py:class:: TemporaryVolumeCredentialsAPI + + Temporary Volume Credentials refer to short-lived, downscoped credentials used to access cloud storage + locations where volume data is stored in Databricks. These credentials are employed to provide secure and + time-limited access to data in cloud environments such as AWS, Azure, and Google Cloud. Each cloud + provider has its own type of credentials: AWS uses temporary session tokens via AWS Security Token Service + (STS), Azure utilizes Shared Access Signatures (SAS) for its data storage services, and Google Cloud + supports temporary credentials through OAuth 2.0. + + Temporary volume credentials ensure that data access is limited in scope and duration, reducing the risk + of unauthorized access or misuse. To use the temporary volume credentials API, a metastore admin needs to + enable the external_access_enabled flag (off by default) at the metastore level, and user needs to be + granted the EXTERNAL USE SCHEMA permission at the schema level by catalog owner. Note that EXTERNAL USE + SCHEMA is a schema level permission that can only be granted by catalog owner explicitly and is not + included in schema ownership or ALL PRIVILEGES on the schema for security reasons. + + .. py:method:: generate_temporary_volume_credentials( [, operation: Optional[VolumeOperation], volume_id: Optional[str]]) -> GenerateTemporaryVolumeCredentialResponse + + Get a short-lived credential for directly accessing the volume data on cloud storage. The metastore + must have **external_access_enabled** flag set to true (default false). The caller must have the + **EXTERNAL_USE_SCHEMA** privilege on the parent schema and this privilege can only be granted by + catalog owners. + + :param operation: :class:`VolumeOperation` (optional) + The operation performed against the volume data, either READ_VOLUME or WRITE_VOLUME. If WRITE_VOLUME + is specified, the credentials returned will have write permissions, otherwise, it will be read only. + :param volume_id: str (optional) + Id of the volume to read or write. + + :returns: :class:`GenerateTemporaryVolumeCredentialResponse` + \ No newline at end of file diff --git a/docs/workspace/compute/policy_compliance_for_clusters.rst b/docs/workspace/compute/policy_compliance_for_clusters.rst old mode 100644 new mode 100755 index 92c1fc4cb..c008ce7a1 --- a/docs/workspace/compute/policy_compliance_for_clusters.rst +++ b/docs/workspace/compute/policy_compliance_for_clusters.rst @@ -24,7 +24,7 @@ If a cluster is updated while in a `TERMINATED` state, it will remain `TERMINATED`. The next time the cluster is started, the new attributes will take effect. - Clusters created by the Databricks Jobs, DLT, or Models services cannot be enforced by this API. + Clusters created by the Databricks Jobs, SDP, or Models services cannot be enforced by this API. Instead, use the "Enforce job policy compliance" API to enforce policy compliance on jobs. :param cluster_id: str diff --git a/docs/workspace/dashboards/genie.rst b/docs/workspace/dashboards/genie.rst index 114093512..4c62799cc 100755 --- a/docs/workspace/dashboards/genie.rst +++ b/docs/workspace/dashboards/genie.rst @@ -468,7 +468,7 @@ - .. py:method:: update_space(space_id: str [, description: Optional[str], serialized_space: Optional[str], title: Optional[str], warehouse_id: Optional[str]]) -> GenieSpace + .. py:method:: update_space(space_id: str [, description: Optional[str], etag: Optional[str], serialized_space: Optional[str], title: Optional[str], warehouse_id: Optional[str]]) -> GenieSpace Updates a Genie space with a serialized payload. @@ -476,6 +476,9 @@ Genie space ID :param description: str (optional) Optional description + :param etag: str (optional) + ETag returned by a previous GET or UPDATE. When set, the update will fail if the space has been + modified since. Omit to apply the update unconditionally. :param serialized_space: str (optional) The contents of the Genie Space in serialized string form (full replacement). Use the [Get Genie Space](:method:genie/getspace) API to retrieve an example response, which includes the diff --git a/docs/workspace/files/files.rst b/docs/workspace/files/files.rst old mode 100644 new mode 100755 index 97178aa77..279788e75 --- a/docs/workspace/files/files.rst +++ b/docs/workspace/files/files.rst @@ -16,10 +16,6 @@ working with directories (`/fs/directories`). Both endpoints use the standard HTTP methods GET, HEAD, PUT, and DELETE to manage files and directories specified using their URI path. The path is always absolute. - Some Files API client features are currently experimental. To enable them, set - `enable_experimental_files_api_client = True` in your configuration profile or use the environment - variable `DATABRICKS_ENABLE_EXPERIMENTAL_FILES_API_CLIENT=True`. - Use of Files API may incur Databricks data transfer charges. [Unity Catalog volumes]: https://docs.databricks.com/en/connect/unity-catalog/volumes.html diff --git a/docs/workspace/iam/permissions.rst b/docs/workspace/iam/permissions.rst index 98142aeb7..4a9cd1813 100755 --- a/docs/workspace/iam/permissions.rst +++ b/docs/workspace/iam/permissions.rst @@ -8,8 +8,8 @@ different objects and endpoints. * **[Apps permissions](:service:apps)** — Manage which users can manage or use apps. * **[Cluster permissions](:service:clusters)** — Manage which users can manage, restart, or attach to clusters. * **[Cluster policy permissions](:service:clusterpolicies)** — Manage which users - can use cluster policies. * **[Delta Live Tables pipeline permissions](:service:pipelines)** — Manage - which users can view, manage, run, cancel, or own a Delta Live Tables pipeline. * **[Job + can use cluster policies. * **[Spark Declarative Pipelines permissions](:service:pipelines)** — Manage + which users can view, manage, run, cancel, or own a Spark Declarative Pipeline. * **[Job permissions](:service:jobs)** — Manage which users can view, manage, trigger, cancel, or own a job. * **[MLflow experiment permissions](:service:experiments)** — Manage which users can read, edit, or manage MLflow experiments. * **[MLflow registered model permissions](:service:modelregistry)** — Manage which @@ -44,7 +44,7 @@ obj = w.workspace.get_status(path=notebook_path) - _ = w.permissions.get(request_object_type="notebooks", request_object_id="%d" % (obj.object_id)) + levels = w.permissions.get_permission_levels(request_object_type="notebooks", request_object_id="%d" % (obj.object_id)) Gets the permissions of an object. Objects can inherit permissions from their parent objects or root object. @@ -52,8 +52,8 @@ :param request_object_type: str The type of the request object. Can be one of the following: alerts, alertsv2, authorization, clusters, cluster-policies, dashboards, database-projects, dbsql-dashboards, directories, - experiments, files, genie, instance-pools, jobs, notebooks, pipelines, queries, registered-models, - repos, serving-endpoints, or warehouses. + experiments, files, genie, instance-pools, jobs, knowledge-assistants, notebooks, pipelines, + queries, registered-models, repos, serving-endpoints, or warehouses. :param request_object_id: str The id of the request object. @@ -84,8 +84,8 @@ :param request_object_type: str The type of the request object. Can be one of the following: alerts, alertsv2, authorization, clusters, cluster-policies, dashboards, database-projects, dbsql-dashboards, directories, - experiments, files, genie, instance-pools, jobs, notebooks, pipelines, queries, registered-models, - repos, serving-endpoints, or warehouses. + experiments, files, genie, instance-pools, jobs, knowledge-assistants, notebooks, pipelines, + queries, registered-models, repos, serving-endpoints, or warehouses. :param request_object_id: str :returns: :class:`GetPermissionLevelsResponse` @@ -132,8 +132,8 @@ :param request_object_type: str The type of the request object. Can be one of the following: alerts, alertsv2, authorization, clusters, cluster-policies, dashboards, database-projects, dbsql-dashboards, directories, - experiments, files, genie, instance-pools, jobs, notebooks, pipelines, queries, registered-models, - repos, serving-endpoints, or warehouses. + experiments, files, genie, instance-pools, jobs, knowledge-assistants, notebooks, pipelines, + queries, registered-models, repos, serving-endpoints, or warehouses. :param request_object_id: str The id of the request object. :param access_control_list: List[:class:`AccessControlRequest`] (optional) @@ -149,8 +149,8 @@ :param request_object_type: str The type of the request object. Can be one of the following: alerts, alertsv2, authorization, clusters, cluster-policies, dashboards, database-projects, dbsql-dashboards, directories, - experiments, files, genie, instance-pools, jobs, notebooks, pipelines, queries, registered-models, - repos, serving-endpoints, or warehouses. + experiments, files, genie, instance-pools, jobs, knowledge-assistants, notebooks, pipelines, + queries, registered-models, repos, serving-endpoints, or warehouses. :param request_object_id: str The id of the request object. :param access_control_list: List[:class:`AccessControlRequest`] (optional) diff --git a/docs/workspace/index.rst b/docs/workspace/index.rst index 0bc4e69a7..3430d2c0e 100755 --- a/docs/workspace/index.rst +++ b/docs/workspace/index.rst @@ -33,6 +33,7 @@ These APIs are available from WorkspaceClient settingsv2/index sharing/index sql/index + supervisoragents/index tags/index vectorsearch/index workspace/index \ No newline at end of file diff --git a/docs/workspace/knowledgeassistants/knowledge_assistants.rst b/docs/workspace/knowledgeassistants/knowledge_assistants.rst index 292043797..b6dd30101 100755 --- a/docs/workspace/knowledgeassistants/knowledge_assistants.rst +++ b/docs/workspace/knowledgeassistants/knowledge_assistants.rst @@ -71,6 +71,27 @@ :returns: :class:`KnowledgeSource` + .. py:method:: get_permission_levels(knowledge_assistant_id: str) -> GetKnowledgeAssistantPermissionLevelsResponse + + Gets the permission levels that a user can have on an object. + + :param knowledge_assistant_id: str + The knowledge assistant for which to get or manage permissions. + + :returns: :class:`GetKnowledgeAssistantPermissionLevelsResponse` + + + .. py:method:: get_permissions(knowledge_assistant_id: str) -> KnowledgeAssistantPermissions + + Gets the permissions of a knowledge assistant. Knowledge assistants can inherit permissions from their + root object. + + :param knowledge_assistant_id: str + The knowledge assistant for which to get or manage permissions. + + :returns: :class:`KnowledgeAssistantPermissions` + + .. py:method:: list_knowledge_assistants( [, page_size: Optional[int], page_token: Optional[str]]) -> Iterator[KnowledgeAssistant] List Knowledge Assistants @@ -97,6 +118,18 @@ :returns: Iterator over :class:`KnowledgeSource` + .. py:method:: set_permissions(knowledge_assistant_id: str [, access_control_list: Optional[List[KnowledgeAssistantAccessControlRequest]]]) -> KnowledgeAssistantPermissions + + Sets permissions on an object, replacing existing permissions if they exist. Deletes all direct + permissions if none are specified. Objects can inherit permissions from their root object. + + :param knowledge_assistant_id: str + The knowledge assistant for which to get or manage permissions. + :param access_control_list: List[:class:`KnowledgeAssistantAccessControlRequest`] (optional) + + :returns: :class:`KnowledgeAssistantPermissions` + + .. py:method:: sync_knowledge_sources(name: str) Sync all non-index Knowledge Sources for a Knowledge Assistant (index sources do not require sync) @@ -140,4 +173,16 @@ `description`. Examples: - `display_name` - `display_name,description` :returns: :class:`KnowledgeSource` + + + .. py:method:: update_permissions(knowledge_assistant_id: str [, access_control_list: Optional[List[KnowledgeAssistantAccessControlRequest]]]) -> KnowledgeAssistantPermissions + + Updates the permissions on a knowledge assistant. Knowledge assistants can inherit permissions from + their root object. + + :param knowledge_assistant_id: str + The knowledge assistant for which to get or manage permissions. + :param access_control_list: List[:class:`KnowledgeAssistantAccessControlRequest`] (optional) + + :returns: :class:`KnowledgeAssistantPermissions` \ No newline at end of file diff --git a/docs/workspace/ml/model_registry.rst b/docs/workspace/ml/model_registry.rst index c528f4329..46c3a4565 100755 --- a/docs/workspace/ml/model_registry.rst +++ b/docs/workspace/ml/model_registry.rst @@ -90,7 +90,9 @@ w = WorkspaceClient() - created = w.model_registry.create_model(name=f"sdk-{time.time_ns()}") + model = w.model_registry.create_model(name=f"sdk-{time.time_ns()}") + + created = w.model_registry.create_model_version(name=model.registered_model.name, source="dbfs:/tmp") Creates a new registered model with the name specified in the request body. Throws `RESOURCE_ALREADY_EXISTS` if a registered model with the given name exists. @@ -120,7 +122,7 @@ model = w.model_registry.create_model(name=f"sdk-{time.time_ns()}") - mv = w.model_registry.create_model_version(name=model.registered_model.name, source="dbfs:/tmp") + created = w.model_registry.create_model_version(name=model.registered_model.name, source="dbfs:/tmp") Creates a model version. @@ -734,14 +736,13 @@ w = WorkspaceClient() - model = w.model_registry.create_model(name=f"sdk-{time.time_ns()}") + created = w.model_registry.create_model(name=f"sdk-{time.time_ns()}") - created = w.model_registry.create_model_version(name=model.registered_model.name, source="dbfs:/tmp") + model = w.model_registry.get_model(name=created.registered_model.name) - w.model_registry.update_model_version( + w.model_registry.update_model( + name=model.registered_model_databricks.name, description=f"sdk-{time.time_ns()}", - name=created.model_version.name, - version=created.model_version.version, ) Updates a registered model. diff --git a/docs/workspace/pipelines/index.rst b/docs/workspace/pipelines/index.rst old mode 100644 new mode 100755 index 83aaafe99..d4c7fb133 --- a/docs/workspace/pipelines/index.rst +++ b/docs/workspace/pipelines/index.rst @@ -1,8 +1,8 @@ -Delta Live Tables -================= +Spark Declarative Pipelines +=========================== -Manage pipelines, runs, and other Delta Live Table resources +Manage pipelines, runs, and other Spark Declarative Pipeline resources .. toctree:: :maxdepth: 1 diff --git a/docs/workspace/pipelines/pipelines.rst b/docs/workspace/pipelines/pipelines.rst index b4666a1b6..b4c1fc8b2 100755 --- a/docs/workspace/pipelines/pipelines.rst +++ b/docs/workspace/pipelines/pipelines.rst @@ -43,7 +43,7 @@ in this pipeline are published to a `target` schema inside `catalog` (for example, `catalog`.`target`.`table`). If `target` is not specified, no data is published to Unity Catalog. :param channel: str (optional) - DLT Release Channel that specifies which version to use. + SDP Release Channel that specifies which version to use. :param clone_mode: :class:`CloneMode` (optional) The type of clone to perform. Currently, only deep copies are supported :param clusters: List[:class:`PipelineCluster`] (optional) @@ -157,7 +157,7 @@ in this pipeline are published to a `target` schema inside `catalog` (for example, `catalog`.`target`.`table`). If `target` is not specified, no data is published to Unity Catalog. :param channel: str (optional) - DLT Release Channel that specifies which version to use. + SDP Release Channel that specifies which version to use. :param clusters: List[:class:`PipelineCluster`] (optional) Cluster settings for this pipeline deployment. :param configuration: Dict[str,str] (optional) @@ -558,7 +558,7 @@ in this pipeline are published to a `target` schema inside `catalog` (for example, `catalog`.`target`.`table`). If `target` is not specified, no data is published to Unity Catalog. :param channel: str (optional) - DLT Release Channel that specifies which version to use. + SDP Release Channel that specifies which version to use. :param clusters: List[:class:`PipelineCluster`] (optional) Cluster settings for this pipeline deployment. :param configuration: Dict[str,str] (optional) diff --git a/docs/workspace/postgres/postgres.rst b/docs/workspace/postgres/postgres.rst index a0a8290c8..ffcc0b993 100755 --- a/docs/workspace/postgres/postgres.rst +++ b/docs/workspace/postgres/postgres.rst @@ -17,7 +17,7 @@ contains this full path and is output-only. Note that `name` refers to this resource path, not the user-visible `display_name`. - .. py:method:: create_branch(parent: str, branch: Branch, branch_id: str) -> CreateBranchOperation + .. py:method:: create_branch(parent: str, branch: Branch, branch_id: str [, replace_existing: Optional[bool]]) -> CreateBranchOperation Creates a new database branch in the project. @@ -30,6 +30,8 @@ is required and must be 1-63 characters long, start with a lowercase letter, and contain only lowercase letters, numbers, and hyphens. For example, `development` becomes `projects/my-app/branches/development`. + :param replace_existing: bool (optional) + If true, update the branch if it already exists instead of returning an error. :returns: :class:`Operation` @@ -68,7 +70,7 @@ :returns: :class:`Operation` - .. py:method:: create_endpoint(parent: str, endpoint: Endpoint, endpoint_id: str) -> CreateEndpointOperation + .. py:method:: create_endpoint(parent: str, endpoint: Endpoint, endpoint_id: str [, replace_existing: Optional[bool]]) -> CreateEndpointOperation Creates a new compute endpoint in the branch. @@ -81,6 +83,8 @@ The ID is required and must be 1-63 characters long, start with a lowercase letter, and contain only lowercase letters, numbers, and hyphens. For example, `primary` becomes `projects/my-app/branches/development/endpoints/primary`. + :param replace_existing: bool (optional) + If true, update the endpoint if it already exists instead of returning an error. :returns: :class:`Operation` @@ -184,12 +188,14 @@ :returns: :class:`Operation` - .. py:method:: delete_project(name: str) -> DeleteProjectOperation + .. py:method:: delete_project(name: str [, purge: Optional[bool]]) -> DeleteProjectOperation Deletes the specified database project. :param name: str The full resource path of the project to delete. Format: projects/{project_id} + :param purge: bool (optional) + If true, permanently deletes the project (hard delete). If false or unset, performs a soft delete. :returns: :class:`Operation` @@ -366,7 +372,7 @@ :returns: Iterator over :class:`Endpoint` - .. py:method:: list_projects( [, page_size: Optional[int], page_token: Optional[str]]) -> Iterator[Project] + .. py:method:: list_projects( [, page_size: Optional[int], page_token: Optional[str], show_deleted: Optional[bool]]) -> Iterator[Project] Returns a paginated list of database projects in the workspace that the user has permission to access. @@ -374,6 +380,9 @@ Upper bound for items returned. Cannot be negative. The maximum value is 100. :param page_token: str (optional) Page token from a previous response. If not provided, returns the first page. + :param show_deleted: bool (optional) + Whether to include soft-deleted projects in the response. When true, soft-deleted projects are + included alongside active projects. Hard-deleted and already-purged projects are never returned. :returns: Iterator over :class:`Project` @@ -392,6 +401,16 @@ :returns: Iterator over :class:`Role` + .. py:method:: undelete_project(name: str) -> UndeleteProjectOperation + + Undeletes a soft-deleted project. + + :param name: str + The full resource path of the project to undelete. Format: projects/{project_id} + + :returns: :class:`Operation` + + .. py:method:: update_branch(name: str, branch: Branch, update_mask: FieldMask) -> UpdateBranchOperation Updates the specified database branch. You can set this branch as the project's default branch, or diff --git a/docs/workspace/settings/tokens.rst b/docs/workspace/settings/tokens.rst index 1e7abd3cd..c820eb848 100755 --- a/docs/workspace/settings/tokens.rst +++ b/docs/workspace/settings/tokens.rst @@ -70,4 +70,30 @@ :returns: Iterator over :class:`PublicTokenInfo` + + + .. py:method:: update(token_id: str, token: PublicTokenInfo, update_mask: FieldMask) -> UpdateTokenResponse + + Updates the comment or scopes of a token. + + If a token with the specified ID is not valid, this call returns an error **RESOURCE_DOES_NOT_EXIST**. + + :param token_id: str + The SHA-256 hash of the token to be updated. + :param token: :class:`PublicTokenInfo` + :param update_mask: FieldMask + A list of field name under PublicTokenInfo, For example in request use {"update_mask": + "comment,scopes"} + + The field mask must be a single string, with multiple fields separated by commas (no spaces). The + field path is relative to the resource object, using a dot (`.`) to navigate sub-fields (e.g., + `author.given_name`). Specification of elements in sequence or map fields is not allowed, as only + the entire collection field can be specified. Field names must exactly match the resource field + names. + + A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the + fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the API + changes in the future. + + :returns: :class:`UpdateTokenResponse` \ No newline at end of file diff --git a/docs/workspace/supervisoragents/index.rst b/docs/workspace/supervisoragents/index.rst new file mode 100755 index 000000000..cb807baaa --- /dev/null +++ b/docs/workspace/supervisoragents/index.rst @@ -0,0 +1,10 @@ + +Supervisor Agents +================= + +Manage Supervisor Agents and related resources. + +.. toctree:: + :maxdepth: 1 + + supervisor_agents \ No newline at end of file diff --git a/docs/workspace/supervisoragents/supervisor_agents.rst b/docs/workspace/supervisoragents/supervisor_agents.rst new file mode 100755 index 000000000..c8515e69b --- /dev/null +++ b/docs/workspace/supervisoragents/supervisor_agents.rst @@ -0,0 +1,128 @@ +``w.supervisor_agents``: SupervisorAgents.v1 +============================================ +.. currentmodule:: databricks.sdk.service.supervisoragents + +.. py:class:: SupervisorAgentsAPI + + Manage Supervisor Agents and related resources. + + .. py:method:: create_supervisor_agent(supervisor_agent: SupervisorAgent) -> SupervisorAgent + + Creates a new Supervisor Agent. + + :param supervisor_agent: :class:`SupervisorAgent` + The Supervisor Agent to create. + + :returns: :class:`SupervisorAgent` + + + .. py:method:: create_tool(parent: str, tool: Tool, tool_id: str) -> Tool + + Creates a Tool under a Supervisor Agent. Specify one of "genie_space", "knowledge_assistant", + "uc_function", "uc_connection", "app", "volume", "lakeview_dashboard", "uc_table", + "vector_search_index" in the request body. + + :param parent: str + Parent resource where this tool will be created. Format: supervisor-agents/{supervisor_agent_id} + :param tool: :class:`Tool` + :param tool_id: str + The ID to use for the tool, which will become the final component of the tool's resource name. + + :returns: :class:`Tool` + + + .. py:method:: delete_supervisor_agent(name: str) + + Deletes a Supervisor Agent. + + :param name: str + The resource name of the Supervisor Agent. Format: supervisor-agents/{supervisor_agent_id} + + + + + .. py:method:: delete_tool(name: str) + + Deletes a Tool. + + :param name: str + The resource name of the Tool. Format: supervisor-agents/{supervisor_agent_id}/tools/{tool_id} + + + + + .. py:method:: get_supervisor_agent(name: str) -> SupervisorAgent + + Gets a Supervisor Agent. + + :param name: str + The resource name of the Supervisor Agent. Format: supervisor-agents/{supervisor_agent_id} + + :returns: :class:`SupervisorAgent` + + + .. py:method:: get_tool(name: str) -> Tool + + Gets a Tool. + + :param name: str + The resource name of the Tool. Format: supervisor-agents/{supervisor_agent_id}/tools/{tool_id} + + :returns: :class:`Tool` + + + .. py:method:: list_supervisor_agents( [, page_size: Optional[int], page_token: Optional[str]]) -> Iterator[SupervisorAgent] + + Lists Supervisor Agents. + + :param page_size: int (optional) + The maximum number of supervisor agents to return. If unspecified, at most 100 supervisor agents + will be returned. The maximum value is 100; values above 100 will be coerced to 100. + :param page_token: str (optional) + A page token, received from a previous `ListSupervisorAgents` call. Provide this to retrieve the + subsequent page. If unspecified, the first page will be returned. + + :returns: Iterator over :class:`SupervisorAgent` + + + .. py:method:: list_tools(parent: str [, page_size: Optional[int], page_token: Optional[str]]) -> Iterator[Tool] + + Lists Tools under a Supervisor Agent. + + :param parent: str + Parent resource to list from. Format: supervisor-agents/{supervisor_agent_id} + :param page_size: int (optional) + :param page_token: str (optional) + + :returns: Iterator over :class:`Tool` + + + .. py:method:: update_supervisor_agent(name: str, supervisor_agent: SupervisorAgent, update_mask: FieldMask) -> SupervisorAgent + + Updates a Supervisor Agent. The fields that are required depend on the paths specified in + `update_mask`. Only fields included in the mask will be updated. + + :param name: str + The resource name of the SupervisorAgent. Format: supervisor-agents/{supervisor_agent_id} + :param supervisor_agent: :class:`SupervisorAgent` + The SupervisorAgent to update. + :param update_mask: FieldMask + Field mask for fields to be updated. + + :returns: :class:`SupervisorAgent` + + + .. py:method:: update_tool(name: str, tool: Tool, update_mask: FieldMask) -> Tool + + Updates a Tool. Only the `description` field can be updated. To change immutable fields such as tool + type, spec, or tool ID, delete the tool and recreate it. + + :param name: str + Full resource name: supervisor-agents/{supervisor_agent_id}/tools/{tool_id} + :param tool: :class:`Tool` + The Tool to update. + :param update_mask: FieldMask + Field mask for fields to be updated. + + :returns: :class:`Tool` + \ No newline at end of file diff --git a/docs/workspace/vectorsearch/vector_search_endpoints.rst b/docs/workspace/vectorsearch/vector_search_endpoints.rst index fe226147f..ccf0ff6e0 100755 --- a/docs/workspace/vectorsearch/vector_search_endpoints.rst +++ b/docs/workspace/vectorsearch/vector_search_endpoints.rst @@ -17,8 +17,9 @@ :param budget_policy_id: str (optional) The budget policy id to be applied :param min_qps: int (optional) - Min QPS for the endpoint. Mutually exclusive with num_replicas. The actual replica count is - calculated at index creation/sync time based on this value. + Deprecated: use target_qps. Min QPS for the endpoint. Mutually exclusive with num_replicas. Kept at + PUBLIC_BETA with deprecated = true so generated SDK surfaces keep the field with a deprecation + marker; hiding completely is a follow-up PR. :param usage_policy_id: str (optional) The usage policy id to be applied once we've migrated to usage policies @@ -67,7 +68,9 @@ :param endpoint_name: str Name of the vector search endpoint :param min_qps: int (optional) - Min QPS for the endpoint. Positive integer sets QPS target; -1 resets to default scaling behavior. + Deprecated: use target_qps. Min QPS for the endpoint. Positive integer sets QPS target; -1 resets to + default scaling behavior. Kept at PUBLIC_BETA with deprecated = true so generated SDK surfaces keep + the field with a deprecation marker; hiding completely is a follow-up PR. :returns: :class:`EndpointInfo` diff --git a/docs/workspace/workspace/workspace.rst b/docs/workspace/workspace/workspace.rst index 7e0841f51..23362f2fd 100755 --- a/docs/workspace/workspace/workspace.rst +++ b/docs/workspace/workspace/workspace.rst @@ -13,10 +13,10 @@ .. py:method:: delete(path: str [, recursive: Optional[bool]]) - Deprecated: use WorkspaceHierarchyService.DeleteTreeNode instead. Deletes an object or a directory - (and optionally recursively deletes all objects in the directory). * If `path` does not exist, this - call returns an error `RESOURCE_DOES_NOT_EXIST`. * If `path` is a non-empty directory and `recursive` - is set to `false`, this call returns an error `DIRECTORY_NOT_EMPTY`. + Deletes an object or a directory (and optionally recursively deletes all objects in the directory). * + If `path` does not exist, this call returns an error `RESOURCE_DOES_NOT_EXIST`. * If `path` is a + non-empty directory and `recursive` is set to `false`, this call returns an error + `DIRECTORY_NOT_EMPTY`. Object deletion cannot be undone and deleting a directory recursively is not atomic. @@ -150,12 +150,12 @@ w = WorkspaceClient() - notebook_path = f"/Users/{w.current_user.me().user_name}/sdk-{time.time_ns()}" + notebook = f"/Users/{w.current_user.me().user_name}/sdk-{time.time_ns()}" - obj = w.workspace.get_status(path=notebook_path) + get_status_response = w.workspace.get_status(path=notebook) - Deprecated: use WorkspaceHierarchyService.GetTreeNode instead. Gets the status of an object or a - directory. If `path` does not exist, this call returns an error `RESOURCE_DOES_NOT_EXIST`. + Gets the status of an object or a directory. If `path` does not exist, this call returns an error + `RESOURCE_DOES_NOT_EXIST`. :param path: str The absolute path of the notebook or directory. @@ -181,11 +181,18 @@ notebook_path = f"/Users/{w.current_user.me().user_name}/sdk-{time.time_ns()}" w.workspace.import_( - content=base64.b64encode(("CREATE LIVE TABLE dlt_sample AS SELECT 1").encode()).decode(), - format=workspace.ImportFormat.SOURCE, - language=workspace.Language.SQL, - overwrite=true_, path=notebook_path, + overwrite=true_, + format=workspace.ImportFormat.SOURCE, + language=workspace.Language.PYTHON, + content=base64.b64encode( + ( + """import time + time.sleep(10) + dbutils.notebook.exit('hello') + """ + ).encode() + ).decode(), ) Imports a workspace object (for example, a notebook or file) or the contents of an entire directory. @@ -229,16 +236,14 @@ .. code-block:: - import os - import time - from databricks.sdk import WorkspaceClient w = WorkspaceClient() - notebook = f"/Users/{w.current_user.me().user_name}/sdk-{time.time_ns()}" - - objects = w.workspace.list(path=os.path.dirname(notebook)) + names = [] + for i in w.workspace.list(f"/Users/{w.current_user.me().user_name}", recursive=True): + names.append(i.path) + assert len(names) > 0 List workspace objects @@ -250,9 +255,9 @@ .. py:method:: mkdirs(path: str) - Deprecated: use WorkspaceHierarchyService.CreateTreeNode instead. Creates the specified directory (and - necessary parent directories if they do not exist). If there is an object (not a directory) at any - prefix of the input path, this call returns an error `RESOURCE_ALREADY_EXISTS`. + Creates the specified directory (and necessary parent directories if they do not exist). If there is + an object (not a directory) at any prefix of the input path, this call returns an error + `RESOURCE_ALREADY_EXISTS`. Note that if this operation fails it may have succeeded in creating some of the necessary parent directories. diff --git a/uv.lock b/uv.lock old mode 100644 new mode 100755 index e73041100..6701d54f3 --- a/uv.lock +++ b/uv.lock @@ -11,7 +11,7 @@ resolution-markers = [ [[package]] name = "annotated-types" version = "0.7.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" }, @@ -20,7 +20,7 @@ wheels = [ [[package]] name = "anyio" version = "4.12.1" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, { name = "idna" }, @@ -34,7 +34,7 @@ wheels = [ [[package]] name = "asttokens" version = "3.0.1" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/be/a5/8e3f9b6771b0b408517c82d97aed8f2036509bc247d46114925e32fe33f0/asttokens-3.0.1.tar.gz", hash = "sha256:71a4ee5de0bde6a31d64f6b13f2293ac190344478f081c3d1bccfcf5eacb0cb7", size = 62308, upload-time = "2025-11-15T16:43:48.578Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/d2/39/e7eaf1799466a4aef85b6a4fe7bd175ad2b1c6345066aa33f1f58d4b18d0/asttokens-3.0.1-py3-none-any.whl", hash = "sha256:15a3ebc0f43c2d0a50eeafea25e19046c68398e487b9f1f5b517f7c0f40f976a", size = 27047, upload-time = "2025-11-15T16:43:16.109Z" }, @@ -43,7 +43,7 @@ wheels = [ [[package]] name = "autoflake" version = "2.3.1" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "pyflakes" }, { name = "tomli", marker = "python_full_version < '3.11'" }, @@ -56,7 +56,7 @@ wheels = [ [[package]] name = "black" version = "24.8.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "click" }, { name = "mypy-extensions" }, @@ -86,7 +86,7 @@ wheels = [ [[package]] name = "build" version = "1.4.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "colorama", marker = "os_name == 'nt'" }, { name = "importlib-metadata", marker = "python_full_version < '3.10.2'" }, @@ -102,7 +102,7 @@ wheels = [ [[package]] name = "certifi" version = "2026.2.25" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" }, @@ -111,7 +111,7 @@ wheels = [ [[package]] name = "cffi" version = "2.0.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "pycparser", marker = "implementation_name != 'PyPy'" }, ] @@ -193,7 +193,7 @@ wheels = [ [[package]] name = "charset-normalizer" version = "3.4.5" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/1d/35/02daf95b9cd686320bb622eb148792655c9412dbb9b67abb5694e5910a24/charset_normalizer-3.4.5.tar.gz", hash = "sha256:95adae7b6c42a6c5b5b559b1a99149f090a57128155daeea91732c8d970d8644", size = 134804, upload-time = "2026-03-06T06:03:19.46Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/a7/21/a2b1505639008ba2e6ef03733a81fc6cfd6a07ea6139a2b76421230b8dad/charset_normalizer-3.4.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:4167a621a9a1a986c73777dbc15d4b5eac8ac5c10393374109a343d4013ec765", size = 283319, upload-time = "2026-03-06T06:00:26.433Z" }, @@ -282,7 +282,7 @@ wheels = [ [[package]] name = "check-manifest" version = "0.51" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "build" }, { name = "setuptools" }, @@ -296,7 +296,7 @@ wheels = [ [[package]] name = "click" version = "8.3.1" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "colorama", marker = "sys_platform == 'win32'" }, ] @@ -308,7 +308,7 @@ wheels = [ [[package]] name = "colorama" version = "0.4.6" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, @@ -317,7 +317,7 @@ wheels = [ [[package]] name = "comm" version = "0.2.3" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/4c/13/7d740c5849255756bc17888787313b61fd38a0a8304fc4f073dfc46122aa/comm-0.2.3.tar.gz", hash = "sha256:2dc8048c10962d55d7ad693be1e7045d891b7ce8d999c97963a5e3e99c055971", size = 6319, upload-time = "2025-07-25T14:02:04.452Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/60/97/891a0971e1e4a8c5d2b20bbe0e524dc04548d2307fee33cdeba148fd4fc7/comm-0.2.3-py3-none-any.whl", hash = "sha256:c615d91d75f7f04f095b30d1c1711babd43bdc6419c1be9886a85f2f4e489417", size = 7294, upload-time = "2025-07-25T14:02:02.896Z" }, @@ -326,7 +326,7 @@ wheels = [ [[package]] name = "coverage" version = "7.13.4" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/24/56/95b7e30fa389756cb56630faa728da46a27b8c6eb46f9d557c68fff12b65/coverage-7.13.4.tar.gz", hash = "sha256:e5c8f6ed1e61a8b2dcdf31eb0b9bbf0130750ca79c1c49eb898e2ad86f5ccc91", size = 827239, upload-time = "2026-02-09T12:59:03.86Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/44/d4/7827d9ffa34d5d4d752eec907022aa417120936282fc488306f5da08c292/coverage-7.13.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0fc31c787a84f8cd6027eba44010517020e0d18487064cd3d8968941856d1415", size = 219152, upload-time = "2026-02-09T12:56:11.974Z" }, @@ -444,7 +444,7 @@ toml = [ [[package]] name = "cryptography" version = "46.0.5" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "cffi", marker = "platform_python_implementation != 'PyPy'" }, { name = "typing-extensions", marker = "python_full_version < '3.11'" }, @@ -504,7 +504,7 @@ wheels = [ [[package]] name = "databricks-connect" version = "16.1.7" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } resolution-markers = [ "python_full_version == '3.11.*'", "python_full_version < '3.11'", @@ -514,10 +514,10 @@ dependencies = [ { name = "googleapis-common-protos", marker = "python_full_version < '3.12'" }, { name = "grpcio", marker = "python_full_version < '3.12'" }, { name = "grpcio-status", marker = "python_full_version < '3.12'" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" }, marker = "python_full_version < '3.12'" }, { name = "packaging", marker = "python_full_version < '3.12'" }, { name = "pandas", marker = "python_full_version < '3.12'" }, - { name = "py4j", version = "0.10.9.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" }, + { name = "py4j", version = "0.10.9.7", source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" }, marker = "python_full_version < '3.12'" }, { name = "pyarrow", marker = "python_full_version < '3.12'" }, { name = "setuptools", marker = "python_full_version < '3.12'" }, { name = "six", marker = "python_full_version < '3.12'" }, @@ -529,7 +529,7 @@ wheels = [ [[package]] name = "databricks-connect" version = "18.1.1" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } resolution-markers = [ "python_full_version >= '3.12'", ] @@ -538,10 +538,10 @@ dependencies = [ { name = "googleapis-common-protos", marker = "python_full_version >= '3.12'" }, { name = "grpcio", marker = "python_full_version >= '3.12'" }, { name = "grpcio-status", marker = "python_full_version >= '3.12'" }, - { name = "numpy", version = "2.4.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, + { name = "numpy", version = "2.4.3", source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" }, marker = "python_full_version >= '3.12'" }, { name = "packaging", marker = "python_full_version >= '3.12'" }, { name = "pandas", marker = "python_full_version >= '3.12'" }, - { name = "py4j", version = "0.10.9.9", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, + { name = "py4j", version = "0.10.9.9", source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" }, marker = "python_full_version >= '3.12'" }, { name = "pyarrow", marker = "python_full_version >= '3.12'" }, { name = "setuptools", marker = "python_full_version >= '3.12'" }, { name = "six", marker = "python_full_version >= '3.12'" }, @@ -566,12 +566,12 @@ dev = [ { name = "black" }, { name = "build" }, { name = "check-manifest" }, - { name = "databricks-connect", version = "16.1.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" }, - { name = "databricks-connect", version = "18.1.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, + { name = "databricks-connect", version = "16.1.7", source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" }, marker = "python_full_version < '3.12'" }, + { name = "databricks-connect", version = "18.1.1", source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" }, marker = "python_full_version >= '3.12'" }, { name = "httpx" }, - { name = "ipython", version = "8.38.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, - { name = "ipython", version = "9.10.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" }, - { name = "ipython", version = "9.11.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, + { name = "ipython", version = "8.38.0", source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" }, marker = "python_full_version < '3.11'" }, + { name = "ipython", version = "9.10.0", source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" }, marker = "python_full_version == '3.11.*'" }, + { name = "ipython", version = "9.11.0", source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" }, marker = "python_full_version >= '3.12'" }, { name = "ipywidgets" }, { name = "isort" }, { name = "langchain-openai" }, @@ -587,9 +587,9 @@ dev = [ { name = "wheel" }, ] notebook = [ - { name = "ipython", version = "8.38.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, - { name = "ipython", version = "9.10.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" }, - { name = "ipython", version = "9.11.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, + { name = "ipython", version = "8.38.0", source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" }, marker = "python_full_version < '3.11'" }, + { name = "ipython", version = "9.10.0", source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" }, marker = "python_full_version == '3.11.*'" }, + { name = "ipython", version = "9.11.0", source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" }, marker = "python_full_version >= '3.12'" }, { name = "ipywidgets" }, ] openai = [ @@ -634,7 +634,7 @@ provides-extras = ["dev", "notebook", "openai"] [[package]] name = "decorator" version = "5.2.1" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360", size = 56711, upload-time = "2025-02-24T04:41:34.073Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190, upload-time = "2025-02-24T04:41:32.565Z" }, @@ -643,7 +643,7 @@ wheels = [ [[package]] name = "distro" version = "1.9.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed", size = 60722, upload-time = "2023-12-24T09:54:32.31Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277, upload-time = "2023-12-24T09:54:30.421Z" }, @@ -652,7 +652,7 @@ wheels = [ [[package]] name = "exceptiongroup" version = "1.3.1" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "typing-extensions", marker = "python_full_version < '3.11'" }, ] @@ -664,7 +664,7 @@ wheels = [ [[package]] name = "execnet" version = "2.1.2" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/bf/89/780e11f9588d9e7128a3f87788354c7946a9cbb1401ad38a48c4db9a4f07/execnet-2.1.2.tar.gz", hash = "sha256:63d83bfdd9a23e35b9c6a3261412324f964c2ec8dcd8d3c6916ee9373e0befcd", size = 166622, upload-time = "2025-11-12T09:56:37.75Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/ab/84/02fc1827e8cdded4aa65baef11296a9bbe595c474f0d6d758af082d849fd/execnet-2.1.2-py3-none-any.whl", hash = "sha256:67fba928dd5a544b783f6056f449e5e3931a5c378b128bc18501f7ea79e296ec", size = 40708, upload-time = "2025-11-12T09:56:36.333Z" }, @@ -673,7 +673,7 @@ wheels = [ [[package]] name = "executing" version = "2.2.1" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4", size = 1129488, upload-time = "2025-09-01T09:48:10.866Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317, upload-time = "2025-09-01T09:48:08.5Z" }, @@ -682,7 +682,7 @@ wheels = [ [[package]] name = "google-auth" version = "2.49.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "cryptography" }, { name = "pyasn1-modules" }, @@ -696,7 +696,7 @@ wheels = [ [[package]] name = "googleapis-common-protos" version = "1.73.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "protobuf" }, ] @@ -708,7 +708,7 @@ wheels = [ [[package]] name = "grpcio" version = "1.78.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "typing-extensions" }, ] @@ -769,7 +769,7 @@ wheels = [ [[package]] name = "grpcio-status" version = "1.78.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "googleapis-common-protos" }, { name = "grpcio" }, @@ -783,7 +783,7 @@ wheels = [ [[package]] name = "h11" version = "0.16.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, @@ -792,7 +792,7 @@ wheels = [ [[package]] name = "httpcore" version = "1.0.9" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "certifi" }, { name = "h11" }, @@ -805,7 +805,7 @@ wheels = [ [[package]] name = "httpx" version = "0.28.1" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "anyio" }, { name = "certifi" }, @@ -820,7 +820,7 @@ wheels = [ [[package]] name = "idna" version = "3.11" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" }, @@ -829,7 +829,7 @@ wheels = [ [[package]] name = "importlib-metadata" version = "8.7.1" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "zipp", marker = "python_full_version < '3.11'" }, ] @@ -841,7 +841,7 @@ wheels = [ [[package]] name = "iniconfig" version = "2.3.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, @@ -850,7 +850,7 @@ wheels = [ [[package]] name = "ipython" version = "8.38.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } resolution-markers = [ "python_full_version < '3.11'", ] @@ -875,7 +875,7 @@ wheels = [ [[package]] name = "ipython" version = "9.10.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } resolution-markers = [ "python_full_version == '3.11.*'", ] @@ -900,7 +900,7 @@ wheels = [ [[package]] name = "ipython" version = "9.11.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } resolution-markers = [ "python_full_version >= '3.12'", ] @@ -924,7 +924,7 @@ wheels = [ [[package]] name = "ipython-pygments-lexers" version = "1.1.1" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "pygments", marker = "python_full_version >= '3.11'" }, ] @@ -936,12 +936,12 @@ wheels = [ [[package]] name = "ipywidgets" version = "8.1.8" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "comm" }, - { name = "ipython", version = "8.38.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, - { name = "ipython", version = "9.10.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" }, - { name = "ipython", version = "9.11.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, + { name = "ipython", version = "8.38.0", source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" }, marker = "python_full_version < '3.11'" }, + { name = "ipython", version = "9.10.0", source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" }, marker = "python_full_version == '3.11.*'" }, + { name = "ipython", version = "9.11.0", source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" }, marker = "python_full_version >= '3.12'" }, { name = "jupyterlab-widgets" }, { name = "traitlets" }, { name = "widgetsnbextension" }, @@ -954,7 +954,7 @@ wheels = [ [[package]] name = "isort" version = "5.13.2" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/87/f9/c1eb8635a24e87ade2efce21e3ce8cd6b8630bb685ddc9cdaca1349b2eb5/isort-5.13.2.tar.gz", hash = "sha256:48fdfcb9face5d58a4f6dde2e72a1fb8dcaf8ab26f95ab49fab84c2ddefb0109", size = 175303, upload-time = "2023-12-13T20:37:26.124Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/d1/b3/8def84f539e7d2289a02f0524b944b15d7c75dab7628bedf1c4f0992029c/isort-5.13.2-py3-none-any.whl", hash = "sha256:8ca5e72a8d85860d5a3fa69b8745237f2939afe12dbf656afbcb47fe72d947a6", size = 92310, upload-time = "2023-12-13T20:37:23.244Z" }, @@ -963,7 +963,7 @@ wheels = [ [[package]] name = "jedi" version = "0.19.2" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "parso" }, ] @@ -975,7 +975,7 @@ wheels = [ [[package]] name = "jiter" version = "0.13.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/0d/5e/4ec91646aee381d01cdb9974e30882c9cd3b8c5d1079d6b5ff4af522439a/jiter-0.13.0.tar.gz", hash = "sha256:f2839f9c2c7e2dffc1bc5929a510e14ce0a946be9365fd1219e7ef342dae14f4", size = 164847, upload-time = "2026-02-02T12:37:56.441Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/d0/5a/41da76c5ea07bec1b0472b6b2fdb1b651074d504b19374d7e130e0cdfb25/jiter-0.13.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2ffc63785fd6c7977defe49b9824ae6ce2b2e2b77ce539bdaf006c26da06342e", size = 311164, upload-time = "2026-02-02T12:35:17.688Z" }, @@ -1072,7 +1072,7 @@ wheels = [ [[package]] name = "jsonpatch" version = "1.33" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "jsonpointer" }, ] @@ -1084,7 +1084,7 @@ wheels = [ [[package]] name = "jsonpointer" version = "3.0.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/6a/0a/eebeb1fa92507ea94016a2a790b93c2ae41a7e18778f85471dc54475ed25/jsonpointer-3.0.0.tar.gz", hash = "sha256:2b2d729f2091522d61c3b31f82e11870f60b68f43fbc705cb76bf4b832af59ef", size = 9114, upload-time = "2024-06-10T19:24:42.462Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/71/92/5e77f98553e9e75130c78900d000368476aed74276eb8ae8796f65f00918/jsonpointer-3.0.0-py2.py3-none-any.whl", hash = "sha256:13e088adc14fca8b6aa8177c044e12701e6ad4b28ff10e65f2267a90109c9942", size = 7595, upload-time = "2024-06-10T19:24:40.698Z" }, @@ -1093,7 +1093,7 @@ wheels = [ [[package]] name = "jupyterlab-widgets" version = "3.0.16" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/26/2d/ef58fed122b268c69c0aa099da20bc67657cdfb2e222688d5731bd5b971d/jupyterlab_widgets-3.0.16.tar.gz", hash = "sha256:423da05071d55cf27a9e602216d35a3a65a3e41cdf9c5d3b643b814ce38c19e0", size = 897423, upload-time = "2025-11-01T21:11:29.724Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/ab/b5/36c712098e6191d1b4e349304ef73a8d06aed77e56ceaac8c0a306c7bda1/jupyterlab_widgets-3.0.16-py3-none-any.whl", hash = "sha256:45fa36d9c6422cf2559198e4db481aa243c7a32d9926b500781c830c80f7ecf8", size = 914926, upload-time = "2025-11-01T21:11:28.008Z" }, @@ -1102,7 +1102,7 @@ wheels = [ [[package]] name = "langchain-core" version = "1.2.20" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "jsonpatch" }, { name = "langsmith" }, @@ -1121,7 +1121,7 @@ wheels = [ [[package]] name = "langchain-openai" version = "1.1.11" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "langchain-core" }, { name = "openai" }, @@ -1135,7 +1135,7 @@ wheels = [ [[package]] name = "langsmith" version = "0.7.22" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "httpx" }, { name = "orjson", marker = "platform_python_implementation != 'PyPy'" }, @@ -1155,7 +1155,7 @@ wheels = [ [[package]] name = "matplotlib-inline" version = "0.2.1" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "traitlets" }, ] @@ -1167,7 +1167,7 @@ wheels = [ [[package]] name = "mypy-extensions" version = "1.1.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" }, @@ -1176,7 +1176,7 @@ wheels = [ [[package]] name = "numpy" version = "1.26.4" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } resolution-markers = [ "python_full_version == '3.11.*'", "python_full_version < '3.11'", @@ -1212,7 +1212,7 @@ wheels = [ [[package]] name = "numpy" version = "2.4.3" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } resolution-markers = [ "python_full_version >= '3.12'", ] @@ -1294,7 +1294,7 @@ wheels = [ [[package]] name = "openai" version = "2.26.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "anyio" }, { name = "distro" }, @@ -1313,7 +1313,7 @@ wheels = [ [[package]] name = "orjson" version = "3.11.7" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/53/45/b268004f745ede84e5798b48ee12b05129d19235d0e15267aa57dcdb400b/orjson-3.11.7.tar.gz", hash = "sha256:9b1a67243945819ce55d24a30b59d6a168e86220452d2c96f4d1f093e71c0c49", size = 6144992, upload-time = "2026-02-02T15:38:49.29Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/de/1a/a373746fa6d0e116dd9e54371a7b54622c44d12296d5d0f3ad5e3ff33490/orjson-3.11.7-cp310-cp310-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:a02c833f38f36546ba65a452127633afce4cf0dd7296b753d3bb54e55e5c0174", size = 229140, upload-time = "2026-02-02T15:37:06.082Z" }, @@ -1394,7 +1394,7 @@ wheels = [ [[package]] name = "packaging" version = "26.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" }, @@ -1403,10 +1403,10 @@ wheels = [ [[package]] name = "pandas" version = "2.3.3" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" }, - { name = "numpy", version = "2.4.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" }, marker = "python_full_version < '3.12'" }, + { name = "numpy", version = "2.4.3", source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" }, marker = "python_full_version >= '3.12'" }, { name = "python-dateutil" }, { name = "pytz" }, { name = "tzdata" }, @@ -1465,7 +1465,7 @@ wheels = [ [[package]] name = "parso" version = "0.8.6" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/81/76/a1e769043c0c0c9fe391b702539d594731a4362334cdf4dc25d0c09761e7/parso-0.8.6.tar.gz", hash = "sha256:2b9a0332696df97d454fa67b81618fd69c35a7b90327cbe6ba5c92d2c68a7bfd", size = 401621, upload-time = "2026-02-09T15:45:24.425Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/b6/61/fae042894f4296ec49e3f193aff5d7c18440da9e48102c3315e1bc4519a7/parso-0.8.6-py2.py3-none-any.whl", hash = "sha256:2c549f800b70a5c4952197248825584cb00f033b29c692671d3bf08bf380baff", size = 106894, upload-time = "2026-02-09T15:45:21.391Z" }, @@ -1474,7 +1474,7 @@ wheels = [ [[package]] name = "pathspec" version = "1.0.4" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/fa/36/e27608899f9b8d4dff0617b2d9ab17ca5608956ca44461ac14ac48b44015/pathspec-1.0.4.tar.gz", hash = "sha256:0210e2ae8a21a9137c0d470578cb0e595af87edaa6ebf12ff176f14a02e0e645", size = 131200, upload-time = "2026-01-27T03:59:46.938Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/ef/3c/2c197d226f9ea224a9ab8d197933f9da0ae0aac5b6e0f884e2b8d9c8e9f7/pathspec-1.0.4-py3-none-any.whl", hash = "sha256:fb6ae2fd4e7c921a165808a552060e722767cfa526f99ca5156ed2ce45a5c723", size = 55206, upload-time = "2026-01-27T03:59:45.137Z" }, @@ -1483,7 +1483,7 @@ wheels = [ [[package]] name = "pexpect" version = "4.9.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "ptyprocess" }, ] @@ -1495,7 +1495,7 @@ wheels = [ [[package]] name = "platformdirs" version = "4.9.4" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/19/56/8d4c30c8a1d07013911a8fdbd8f89440ef9f08d07a1b50ab8ca8be5a20f9/platformdirs-4.9.4.tar.gz", hash = "sha256:1ec356301b7dc906d83f371c8f487070e99d3ccf9e501686456394622a01a934", size = 28737, upload-time = "2026-03-05T18:34:13.271Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/63/d7/97f7e3a6abb67d8080dd406fd4df842c2be0efaf712d1c899c32a075027c/platformdirs-4.9.4-py3-none-any.whl", hash = "sha256:68a9a4619a666ea6439f2ff250c12a853cd1cbd5158d258bd824a7df6be2f868", size = 21216, upload-time = "2026-03-05T18:34:12.172Z" }, @@ -1504,7 +1504,7 @@ wheels = [ [[package]] name = "pluggy" version = "1.6.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, @@ -1513,7 +1513,7 @@ wheels = [ [[package]] name = "prompt-toolkit" version = "3.0.52" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "wcwidth" }, ] @@ -1525,7 +1525,7 @@ wheels = [ [[package]] name = "protobuf" version = "6.33.5" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/ba/25/7c72c307aafc96fa87062aa6291d9f7c94836e43214d43722e86037aac02/protobuf-6.33.5.tar.gz", hash = "sha256:6ddcac2a081f8b7b9642c09406bc6a4290128fce5f471cddd165960bb9119e5c", size = 444465, upload-time = "2026-01-29T21:51:33.494Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/b1/79/af92d0a8369732b027e6d6084251dd8e782c685c72da161bd4a2e00fbabb/protobuf-6.33.5-cp310-abi3-win32.whl", hash = "sha256:d71b040839446bac0f4d162e758bea99c8251161dae9d0983a3b88dee345153b", size = 425769, upload-time = "2026-01-29T21:51:21.751Z" }, @@ -1540,7 +1540,7 @@ wheels = [ [[package]] name = "ptyprocess" version = "0.7.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762, upload-time = "2020-12-28T15:15:30.155Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993, upload-time = "2020-12-28T15:15:28.35Z" }, @@ -1549,7 +1549,7 @@ wheels = [ [[package]] name = "pure-eval" version = "0.2.3" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752, upload-time = "2024-07-21T12:58:21.801Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842, upload-time = "2024-07-21T12:58:20.04Z" }, @@ -1558,7 +1558,7 @@ wheels = [ [[package]] name = "py4j" version = "0.10.9.7" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } resolution-markers = [ "python_full_version == '3.11.*'", "python_full_version < '3.11'", @@ -1571,7 +1571,7 @@ wheels = [ [[package]] name = "py4j" version = "0.10.9.9" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } resolution-markers = [ "python_full_version >= '3.12'", ] @@ -1583,7 +1583,7 @@ wheels = [ [[package]] name = "pyarrow" version = "23.0.1" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/88/22/134986a4cc224d593c1afde5494d18ff629393d74cc2eddb176669f234a4/pyarrow-23.0.1.tar.gz", hash = "sha256:b8c5873e33440b2bc2f4a79d2b47017a89c5a24116c055625e6f2ee50523f019", size = 1167336, upload-time = "2026-02-16T10:14:12.39Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/bc/a8/24e5dc6855f50a62936ceb004e6e9645e4219a8065f304145d7fb8a79d5d/pyarrow-23.0.1-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:3fab8f82571844eb3c460f90a75583801d14ca0cc32b1acc8c361650e006fd56", size = 34307390, upload-time = "2026-02-16T10:08:08.654Z" }, @@ -1640,7 +1640,7 @@ wheels = [ [[package]] name = "pyasn1" version = "0.6.3" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/5c/5f/6583902b6f79b399c9c40674ac384fd9cd77805f9e6205075f828ef11fb2/pyasn1-0.6.3.tar.gz", hash = "sha256:697a8ecd6d98891189184ca1fa05d1bb00e2f84b5977c481452050549c8a72cf", size = 148685, upload-time = "2026-03-17T01:06:53.382Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/5d/a0/7d793dce3fa811fe047d6ae2431c672364b462850c6235ae306c0efd025f/pyasn1-0.6.3-py3-none-any.whl", hash = "sha256:a80184d120f0864a52a073acc6fc642847d0be408e7c7252f31390c0f4eadcde", size = 83997, upload-time = "2026-03-17T01:06:52.036Z" }, @@ -1649,7 +1649,7 @@ wheels = [ [[package]] name = "pyasn1-modules" version = "0.4.2" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "pyasn1" }, ] @@ -1661,7 +1661,7 @@ wheels = [ [[package]] name = "pycodestyle" version = "2.14.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/11/e0/abfd2a0d2efe47670df87f3e3a0e2edda42f055053c85361f19c0e2c1ca8/pycodestyle-2.14.0.tar.gz", hash = "sha256:c4b5b517d278089ff9d0abdec919cd97262a3367449ea1c8b49b91529167b783", size = 39472, upload-time = "2025-06-20T18:49:48.75Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/d7/27/a58ddaf8c588a3ef080db9d0b7e0b97215cee3a45df74f3a94dbbf5c893a/pycodestyle-2.14.0-py2.py3-none-any.whl", hash = "sha256:dd6bf7cb4ee77f8e016f9c8e74a35ddd9f67e1d5fd4184d86c3b98e07099f42d", size = 31594, upload-time = "2025-06-20T18:49:47.491Z" }, @@ -1670,7 +1670,7 @@ wheels = [ [[package]] name = "pycparser" version = "3.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" }, @@ -1679,7 +1679,7 @@ wheels = [ [[package]] name = "pydantic" version = "2.12.5" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "annotated-types" }, { name = "pydantic-core" }, @@ -1694,7 +1694,7 @@ wheels = [ [[package]] name = "pydantic-core" version = "2.41.5" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "typing-extensions" }, ] @@ -1812,7 +1812,7 @@ wheels = [ [[package]] name = "pyfakefs" version = "6.1.4" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/76/11/efd26f319da2a170f42594efdd387df9abdbd3c213deb2251d602d9b8e2d/pyfakefs-6.1.4.tar.gz", hash = "sha256:58d5902282085e8ff03f95316ce133858904096f7adbe622efef899b90695698", size = 226757, upload-time = "2026-03-04T18:02:29.62Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/6b/0f/8fbdc47cfda8ab497b21ad66220407201ed2fc2de91640151b62bc6571af/pyfakefs-6.1.4-py3-none-any.whl", hash = "sha256:46bbc7520a1524af2461ddcaf4a5a800596c750bfdb75afa1afd985bf1e39536", size = 239887, upload-time = "2026-03-04T18:02:28.029Z" }, @@ -1821,7 +1821,7 @@ wheels = [ [[package]] name = "pyflakes" version = "3.4.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/45/dc/fd034dc20b4b264b3d015808458391acbf9df40b1e54750ef175d39180b1/pyflakes-3.4.0.tar.gz", hash = "sha256:b24f96fafb7d2ab0ec5075b7350b3d2d2218eab42003821c06344973d3ea2f58", size = 64669, upload-time = "2025-06-20T18:45:27.834Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/c2/2f/81d580a0fb83baeb066698975cb14a618bdbed7720678566f1b046a95fe8/pyflakes-3.4.0-py2.py3-none-any.whl", hash = "sha256:f742a7dbd0d9cb9ea41e9a24a918996e8170c799fa528688d40dd582c8265f4f", size = 63551, upload-time = "2025-06-20T18:45:26.937Z" }, @@ -1830,7 +1830,7 @@ wheels = [ [[package]] name = "pygments" version = "2.19.2" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" }, @@ -1839,7 +1839,7 @@ wheels = [ [[package]] name = "pyproject-hooks" version = "1.2.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/e7/82/28175b2414effca1cdac8dc99f76d660e7a4fb0ceefa4b4ab8f5f6742925/pyproject_hooks-1.2.0.tar.gz", hash = "sha256:1e859bd5c40fae9448642dd871adf459e5e2084186e8d2c2a79a824c970da1f8", size = 19228, upload-time = "2024-09-29T09:24:13.293Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/bd/24/12818598c362d7f300f18e74db45963dbcb85150324092410c8b49405e42/pyproject_hooks-1.2.0-py3-none-any.whl", hash = "sha256:9e5c6bfa8dcc30091c74b0cf803c81fdd29d94f01992a7707bc97babb1141913", size = 10216, upload-time = "2024-09-29T09:24:11.978Z" }, @@ -1848,7 +1848,7 @@ wheels = [ [[package]] name = "pytest" version = "9.0.2" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "colorama", marker = "sys_platform == 'win32'" }, { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, @@ -1866,7 +1866,7 @@ wheels = [ [[package]] name = "pytest-cov" version = "7.0.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "coverage", extra = ["toml"] }, { name = "pluggy" }, @@ -1880,7 +1880,7 @@ wheels = [ [[package]] name = "pytest-mock" version = "3.15.1" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "pytest" }, ] @@ -1892,7 +1892,7 @@ wheels = [ [[package]] name = "pytest-rerunfailures" version = "16.1" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "packaging" }, { name = "pytest" }, @@ -1905,7 +1905,7 @@ wheels = [ [[package]] name = "pytest-xdist" version = "3.8.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "execnet" }, { name = "pytest" }, @@ -1918,7 +1918,7 @@ wheels = [ [[package]] name = "python-dateutil" version = "2.9.0.post0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "six" }, ] @@ -1930,7 +1930,7 @@ wheels = [ [[package]] name = "pytz" version = "2026.1.post1" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/56/db/b8721d71d945e6a8ac63c0fc900b2067181dbb50805958d4d4661cf7d277/pytz-2026.1.post1.tar.gz", hash = "sha256:3378dde6a0c3d26719182142c56e60c7f9af7e968076f31aae569d72a0358ee1", size = 321088, upload-time = "2026-03-03T07:47:50.683Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/10/99/781fe0c827be2742bcc775efefccb3b048a3a9c6ce9aec0cbf4a101677e5/pytz-2026.1.post1-py2.py3-none-any.whl", hash = "sha256:f2fd16142fda348286a75e1a524be810bb05d444e5a081f37f7affc635035f7a", size = 510489, upload-time = "2026-03-03T07:47:49.167Z" }, @@ -1939,7 +1939,7 @@ wheels = [ [[package]] name = "pyyaml" version = "6.0.3" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" }, @@ -2003,7 +2003,7 @@ wheels = [ [[package]] name = "regex" version = "2026.2.28" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/8b/71/41455aa99a5a5ac1eaf311f5d8efd9ce6433c03ac1e0962de163350d0d97/regex-2026.2.28.tar.gz", hash = "sha256:a729e47d418ea11d03469f321aaf67cdee8954cde3ff2cf8403ab87951ad10f2", size = 415184, upload-time = "2026-02-28T02:19:42.792Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/70/b8/845a927e078f5e5cc55d29f57becbfde0003d52806544531ab3f2da4503c/regex-2026.2.28-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:fc48c500838be6882b32748f60a15229d2dea96e59ef341eaa96ec83538f498d", size = 488461, upload-time = "2026-02-28T02:15:48.405Z" }, @@ -2124,7 +2124,7 @@ wheels = [ [[package]] name = "requests" version = "2.32.5" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "certifi" }, { name = "charset-normalizer" }, @@ -2139,7 +2139,7 @@ wheels = [ [[package]] name = "requests-mock" version = "1.12.1" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "requests" }, ] @@ -2151,7 +2151,7 @@ wheels = [ [[package]] name = "requests-toolbelt" version = "1.0.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "requests" }, ] @@ -2163,7 +2163,7 @@ wheels = [ [[package]] name = "rsa" version = "4.9.1" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "pyasn1" }, ] @@ -2175,7 +2175,7 @@ wheels = [ [[package]] name = "setuptools" version = "82.0.1" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/4f/db/cfac1baf10650ab4d1c111714410d2fbb77ac5a616db26775db562c8fab2/setuptools-82.0.1.tar.gz", hash = "sha256:7d872682c5d01cfde07da7bccc7b65469d3dca203318515ada1de5eda35efbf9", size = 1152316, upload-time = "2026-03-09T12:47:17.221Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/9d/76/f789f7a86709c6b087c5a2f52f911838cad707cc613162401badc665acfe/setuptools-82.0.1-py3-none-any.whl", hash = "sha256:a59e362652f08dcd477c78bb6e7bd9d80a7995bc73ce773050228a348ce2e5bb", size = 1006223, upload-time = "2026-03-09T12:47:15.026Z" }, @@ -2184,7 +2184,7 @@ wheels = [ [[package]] name = "six" version = "1.17.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, @@ -2193,7 +2193,7 @@ wheels = [ [[package]] name = "sniffio" version = "1.3.1" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" }, @@ -2202,7 +2202,7 @@ wheels = [ [[package]] name = "stack-data" version = "0.6.3" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "asttokens" }, { name = "executing" }, @@ -2216,7 +2216,7 @@ wheels = [ [[package]] name = "tenacity" version = "9.1.4" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/47/c6/ee486fd809e357697ee8a44d3d69222b344920433d3b6666ccd9b374630c/tenacity-9.1.4.tar.gz", hash = "sha256:adb31d4c263f2bd041081ab33b498309a57c77f9acf2db65aadf0898179cf93a", size = 49413, upload-time = "2026-02-07T10:45:33.841Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/d7/c1/eb8f9debc45d3b7918a32ab756658a0904732f75e555402972246b0b8e71/tenacity-9.1.4-py3-none-any.whl", hash = "sha256:6095a360c919085f28c6527de529e76a06ad89b23659fa881ae0649b867a9d55", size = 28926, upload-time = "2026-02-07T10:45:32.24Z" }, @@ -2225,7 +2225,7 @@ wheels = [ [[package]] name = "tiktoken" version = "0.12.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "regex" }, { name = "requests" }, @@ -2286,7 +2286,7 @@ wheels = [ [[package]] name = "tomli" version = "2.4.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/82/30/31573e9457673ab10aa432461bee537ce6cef177667deca369efb79df071/tomli-2.4.0.tar.gz", hash = "sha256:aa89c3f6c277dd275d8e243ad24f3b5e701491a860d5121f2cdd399fbb31fc9c", size = 17477, upload-time = "2026-01-11T11:22:38.165Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/3c/d9/3dc2289e1f3b32eb19b9785b6a006b28ee99acb37d1d47f78d4c10e28bf8/tomli-2.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b5ef256a3fd497d4973c11bf142e9ed78b150d36f5773f1ca6088c230ffc5867", size = 153663, upload-time = "2026-01-11T11:21:45.27Z" }, @@ -2340,7 +2340,7 @@ wheels = [ [[package]] name = "tqdm" version = "4.67.3" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "colorama", marker = "sys_platform == 'win32'" }, ] @@ -2352,7 +2352,7 @@ wheels = [ [[package]] name = "traitlets" version = "5.14.3" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621, upload-time = "2024-04-19T11:11:49.746Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359, upload-time = "2024-04-19T11:11:46.763Z" }, @@ -2361,7 +2361,7 @@ wheels = [ [[package]] name = "typing-extensions" version = "4.15.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" }, @@ -2370,7 +2370,7 @@ wheels = [ [[package]] name = "typing-inspection" version = "0.4.2" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "typing-extensions" }, ] @@ -2382,7 +2382,7 @@ wheels = [ [[package]] name = "tzdata" version = "2025.3" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/5e/a7/c202b344c5ca7daf398f3b8a477eeb205cf3b6f32e7ec3a6bac0629ca975/tzdata-2025.3.tar.gz", hash = "sha256:de39c2ca5dc7b0344f2eba86f49d614019d29f060fc4ebc8a417896a620b56a7", size = 196772, upload-time = "2025-12-13T17:45:35.667Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/c7/b0/003792df09decd6849a5e39c28b513c06e84436a54440380862b5aeff25d/tzdata-2025.3-py2.py3-none-any.whl", hash = "sha256:06a47e5700f3081aab02b2e513160914ff0694bce9947d6b76ebd6bf57cfc5d1", size = 348521, upload-time = "2025-12-13T17:45:33.889Z" }, @@ -2391,7 +2391,7 @@ wheels = [ [[package]] name = "urllib3" version = "2.6.3" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" }, @@ -2400,7 +2400,7 @@ wheels = [ [[package]] name = "uuid-utils" version = "0.14.1" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/7b/d1/38a573f0c631c062cf42fa1f5d021d4dd3c31fb23e4376e4b56b0c9fbbed/uuid_utils-0.14.1.tar.gz", hash = "sha256:9bfc95f64af80ccf129c604fb6b8ca66c6f256451e32bc4570f760e4309c9b69", size = 22195, upload-time = "2026-02-20T22:50:38.833Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/43/b7/add4363039a34506a58457d96d4aa2126061df3a143eb4d042aedd6a2e76/uuid_utils-0.14.1-cp39-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:93a3b5dc798a54a1feb693f2d1cb4cf08258c32ff05ae4929b5f0a2ca624a4f0", size = 604679, upload-time = "2026-02-20T22:50:27.469Z" }, @@ -2429,7 +2429,7 @@ wheels = [ [[package]] name = "wcwidth" version = "0.6.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/35/a2/8e3becb46433538a38726c948d3399905a4c7cabd0df578ede5dc51f0ec2/wcwidth-0.6.0.tar.gz", hash = "sha256:cdc4e4262d6ef9a1a57e018384cbeb1208d8abbc64176027e2c2455c81313159", size = 159684, upload-time = "2026-02-06T19:19:40.919Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/68/5a/199c59e0a824a3db2b89c5d2dade7ab5f9624dbf6448dc291b46d5ec94d3/wcwidth-0.6.0-py3-none-any.whl", hash = "sha256:1a3a1e510b553315f8e146c54764f4fb6264ffad731b3d78088cdb1478ffbdad", size = 94189, upload-time = "2026-02-06T19:19:39.646Z" }, @@ -2438,7 +2438,7 @@ wheels = [ [[package]] name = "wheel" version = "0.46.3" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } dependencies = [ { name = "packaging" }, ] @@ -2450,7 +2450,7 @@ wheels = [ [[package]] name = "widgetsnbextension" version = "4.0.15" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/bd/f4/c67440c7fb409a71b7404b7aefcd7569a9c0d6bd071299bf4198ae7a5d95/widgetsnbextension-4.0.15.tar.gz", hash = "sha256:de8610639996f1567952d763a5a41af8af37f2575a41f9852a38f947eb82a3b9", size = 1097402, upload-time = "2025-11-01T21:15:55.178Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/3f/0e/fa3b193432cfc60c93b42f3be03365f5f909d2b3ea410295cf36df739e31/widgetsnbextension-4.0.15-py3-none-any.whl", hash = "sha256:8156704e4346a571d9ce73b84bee86a29906c9abfd7223b7228a28899ccf3366", size = 2196503, upload-time = "2025-11-01T21:15:53.565Z" }, @@ -2459,7 +2459,7 @@ wheels = [ [[package]] name = "xxhash" version = "3.6.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/02/84/30869e01909fb37a6cc7e18688ee8bf1e42d57e7e0777636bd47524c43c7/xxhash-3.6.0.tar.gz", hash = "sha256:f0162a78b13a0d7617b2845b90c763339d1f1d82bb04a4b07f4ab535cc5e05d6", size = 85160, upload-time = "2025-10-02T14:37:08.097Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/34/ee/f9f1d656ad168681bb0f6b092372c1e533c4416b8069b1896a175c46e484/xxhash-3.6.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:87ff03d7e35c61435976554477a7f4cd1704c3596a89a8300d5ce7fc83874a71", size = 32845, upload-time = "2025-10-02T14:33:51.573Z" }, @@ -2577,7 +2577,7 @@ wheels = [ [[package]] name = "zipp" version = "3.23.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" }, @@ -2586,7 +2586,7 @@ wheels = [ [[package]] name = "zstandard" version = "0.25.0" -source = { registry = "https://pypi.org/simple" } +source = { registry = "https://pypi-proxy.dev.databricks.com/simple/" } sdist = { url = "https://files.pythonhosted.org/packages/fd/aa/3e0508d5a5dd96529cdc5a97011299056e14c6505b678fd58938792794b1/zstandard-0.25.0.tar.gz", hash = "sha256:7713e1179d162cf5c7906da876ec2ccb9c3a9dcbdffef0cc7f70c3667a205f0b", size = 711513, upload-time = "2025-09-14T22:15:54.002Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/56/7a/28efd1d371f1acd037ac64ed1c5e2b41514a6cc937dd6ab6a13ab9f0702f/zstandard-0.25.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e59fdc271772f6686e01e1b3b74537259800f57e24280be3f29c8a0deb1904dd", size = 795256, upload-time = "2025-09-14T22:15:56.415Z" },