From 1fa8738368ae960ac2593e834ab910cc36ac33ef Mon Sep 17 00:00:00 2001 From: "databricks-ci-ghec-2[bot]" <184307802+databricks-ci-ghec-2[bot]@users.noreply.github.com> Date: Wed, 9 Sep 2026 03:16:35 +0000 Subject: [PATCH] Release databricks-sdk-py --- .codegen/_last_sha | 2 +- CHANGELOG.md | 9 + databricks/sdk/service/catalog.py | 37 ++ databricks/sdk/service/cleanrooms.py | 5 +- databricks/sdk/service/domains.py | 3 +- databricks/sdk/service/ml.py | 350 ++++++++++++++++++ databricks/sdk/service/pipelines.py | 10 +- databricks/sdk/service/postgres.py | 18 +- databricks/sdk/version.py | 2 +- docs/dbdataclasses/catalog.rst | 7 + docs/dbdataclasses/ml.rst | 44 +++ .../cleanrooms/clean_room_assets.rst | 2 +- docs/workspace/domains/domains.rst | 3 +- docs/workspace/ml/feature_engineering.rst | 18 + docs/workspace/pipelines/pipelines.rst | 6 +- 15 files changed, 488 insertions(+), 28 deletions(-) mode change 100755 => 100644 docs/workspace/cleanrooms/clean_room_assets.rst diff --git a/.codegen/_last_sha b/.codegen/_last_sha index 6edd38c1a..e44f2b9eb 100644 --- a/.codegen/_last_sha +++ b/.codegen/_last_sha @@ -1 +1 @@ -e3de5c8d1fe0388abbe5f874c4bd7ff9756d3756 \ No newline at end of file +d4a68ff2811115e3aeb9d7e148ff9b4efb6e2a15 \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md index 2da1fba60..d703535e0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,14 @@ # Version changelog +## Release v0.137.0 (2026-09-09) + +### API Changes +* Add `purge_feature_entities()` method for [w.feature_engineering](https://databricks-sdk-py.readthedocs.io/en/latest/workspace/ml/feature_engineering.html) workspace-level service. +* Add `deny` field for `databricks.sdk.service.catalog.PolicyInfo`. +* Add `budget_policy_id` and `tags` fields for `databricks.sdk.service.ml.IngestionConfig`. +* Add `budget_policy_id` and `tags` fields for `databricks.sdk.service.ml.MaterializedFeature`. +* Add `policy_type_deny` enum value for `databricks.sdk.service.catalog.PolicyType`. + ## Release v0.136.0 (2026-09-07) ### API Changes diff --git a/databricks/sdk/service/catalog.py b/databricks/sdk/service/catalog.py index 5b9f95438..e9982a128 100644 --- a/databricks/sdk/service/catalog.py +++ b/databricks/sdk/service/catalog.py @@ -3058,6 +3058,32 @@ class DeltaSharingScopeEnum(Enum): INTERNAL_AND_EXTERNAL = "INTERNAL_AND_EXTERNAL" +@dataclass +class DenyOptions: + privileges: List[str] + """List of privileges to deny. When any of these privileges are requested, the policy will deny + access if the principal and condition match. Required on create and update.""" + + def as_dict(self) -> dict: + """Serializes the DenyOptions into a dictionary suitable for use as a JSON request body.""" + body = {} + if self.privileges: + body["privileges"] = [v for v in self.privileges] + return body + + def as_shallow_dict(self) -> dict: + """Serializes the DenyOptions into a shallow dictionary of its immediate attributes.""" + body = {} + if self.privileges: + body["privileges"] = self.privileges + return body + + @classmethod + def from_dict(cls, d: Dict[str, Any]) -> DenyOptions: + """Deserializes the DenyOptions from a dictionary.""" + return cls(privileges=d.get("privileges", None)) + + @dataclass class Dependency: """A dependency of a SQL object. One of the following fields must be defined: **table**, @@ -10208,6 +10234,11 @@ class PolicyInfo: created_by: Optional[str] = None """Username of the user who created the policy. Output only.""" + deny: Optional[DenyOptions] = None + """Options for deny policies. Valid only if ``policy_type`` is ``POLICY_TYPE_DENY``. Required on + create and optional on update. When specified on update, the new options will replace the + existing options as a whole.""" + except_principals: Optional[List[str]] = None """Optional list of user or group names that should be excluded from the policy.""" @@ -10260,6 +10291,8 @@ def as_dict(self) -> dict: body["created_at"] = self.created_at if self.created_by is not None: body["created_by"] = self.created_by + if self.deny: + body["deny"] = self.deny.as_dict() if self.except_principals: body["except_principals"] = [v for v in self.except_principals] if self.for_securable_type is not None: @@ -10301,6 +10334,8 @@ def as_shallow_dict(self) -> dict: body["created_at"] = self.created_at if self.created_by is not None: body["created_by"] = self.created_by + if self.deny: + body["deny"] = self.deny if self.except_principals: body["except_principals"] = self.except_principals if self.for_securable_type is not None: @@ -10339,6 +10374,7 @@ def from_dict(cls, d: Dict[str, Any]) -> PolicyInfo: comment=d.get("comment", None), created_at=_int64(d, "created_at"), created_by=d.get("created_by", None), + deny=_from_dict(d, "deny", DenyOptions), except_principals=d.get("except_principals", None), for_securable_type=_enum(d, "for_securable_type", SecurableType), grant=_from_dict(d, "grant", GrantOptions), @@ -10358,6 +10394,7 @@ def from_dict(cls, d: Dict[str, Any]) -> PolicyInfo: class PolicyType(Enum): POLICY_TYPE_COLUMN_MASK = "POLICY_TYPE_COLUMN_MASK" + POLICY_TYPE_DENY = "POLICY_TYPE_DENY" POLICY_TYPE_GRANT = "POLICY_TYPE_GRANT" POLICY_TYPE_ROW_FILTER = "POLICY_TYPE_ROW_FILTER" diff --git a/databricks/sdk/service/cleanrooms.py b/databricks/sdk/service/cleanrooms.py index 1dcbbf8c0..edfc0ca7d 100644 --- a/databricks/sdk/service/cleanrooms.py +++ b/databricks/sdk/service/cleanrooms.py @@ -166,7 +166,8 @@ class CleanRoomAsset: *shared_catalog*.*shared_schema*.*asset_name* For notebooks, the name is the notebook file name. For jar analyses, the name is the jar - analysis name.""" + analysis name. For Genie spaces, the name is derived from the clean room; the caller does not + choose it.""" asset_type: CleanRoomAssetAssetType """The type of the asset.""" @@ -2161,7 +2162,7 @@ def update( *shared_catalog*.*shared_schema*.*asset_name* For notebooks, the name is the notebook file name. For jar analyses, the name is the jar analysis - name. + name. For Genie spaces, the name is derived from the clean room; the caller does not choose it. :param asset: :class:`CleanRoomAsset` The asset to update. The asset's ``name`` and ``asset_type`` fields are used to identify the asset to update. diff --git a/databricks/sdk/service/domains.py b/databricks/sdk/service/domains.py index 50784b9d2..3606563cb 100644 --- a/databricks/sdk/service/domains.py +++ b/databricks/sdk/service/domains.py @@ -335,8 +335,7 @@ def delete_domain(self, name: str, *, force: Optional[bool] = None): Full resource name of the domain to delete. Format: ``domains/{domain_id}`` :param force: bool (optional) When false (default), DeleteDomain is rejected with FAILED_PRECONDITION if the domain still has - Glossary pages. When true, those pages are deleted first and then the domain is removed. Forwarded - to the central service. + Glossary pages. When true, those pages are deleted first and then the domain is removed. """ diff --git a/databricks/sdk/service/ml.py b/databricks/sdk/service/ml.py index a77f7bda1..64c87379b 100644 --- a/databricks/sdk/service/ml.py +++ b/databricks/sdk/service/ml.py @@ -3430,6 +3430,10 @@ class IngestionConfig: source must match exactly that of the key and payload schemas specified for this Stream, except that it may omit any columns listed in excluded_columns.""" + budget_policy_id: Optional[str] = None + """The ID of the budget policy used to attribute the serverless compute cost of this stream's + managed ingestion. If not specified, a default budget policy may be applied.""" + deduplication_columns: Optional[List[str]] = None """Column paths used to identify duplicate rows during ingestion; only one row per distinct combination of these values is kept. Use dot notation for nested fields (e.g. @@ -3442,6 +3446,14 @@ class IngestionConfig: """The ID of the SDP pipeline that continuously copies new events from the streaming source into the ingestion Delta table.""" + tags: Optional[Dict[str, str]] = None + """Custom tags to associate with this stream's managed ingestion. They are applied to the ingestion + pipeline and its forward-fill and backfill jobs, and forwarded to the underlying compute as + cluster tags, so ingestion cost can be attributed in the billing system tables. These tags apply + only to the managed ingestion compute; they are not applied to the Stream entity itself, and are + distinct from any Unity Catalog tags on the Stream. A maximum of 25 tags is supported; keys and + values are subject to the same limitations as cluster tags.""" + def as_dict(self) -> dict: """Serializes the IngestionConfig into a dictionary suitable for use as a JSON request body.""" body = {} @@ -3449,6 +3461,8 @@ def as_dict(self) -> dict: body["backfill_job_id"] = self.backfill_job_id if self.backfill_source: body["backfill_source"] = self.backfill_source.as_dict() + if self.budget_policy_id is not None: + body["budget_policy_id"] = self.budget_policy_id if self.deduplication_columns: body["deduplication_columns"] = [v for v in self.deduplication_columns] if self.ingestion_destination: @@ -3457,6 +3471,8 @@ def as_dict(self) -> dict: body["ingestion_job_id"] = self.ingestion_job_id if self.ingestion_pipeline_id is not None: body["ingestion_pipeline_id"] = self.ingestion_pipeline_id + if self.tags: + body["tags"] = self.tags return body def as_shallow_dict(self) -> dict: @@ -3466,6 +3482,8 @@ def as_shallow_dict(self) -> dict: body["backfill_job_id"] = self.backfill_job_id if self.backfill_source: body["backfill_source"] = self.backfill_source + if self.budget_policy_id is not None: + body["budget_policy_id"] = self.budget_policy_id if self.deduplication_columns: body["deduplication_columns"] = self.deduplication_columns if self.ingestion_destination: @@ -3474,6 +3492,8 @@ def as_shallow_dict(self) -> dict: body["ingestion_job_id"] = self.ingestion_job_id if self.ingestion_pipeline_id is not None: body["ingestion_pipeline_id"] = self.ingestion_pipeline_id + if self.tags: + body["tags"] = self.tags return body @classmethod @@ -3482,10 +3502,12 @@ def from_dict(cls, d: Dict[str, Any]) -> IngestionConfig: return cls( backfill_job_id=_int64(d, "backfill_job_id"), backfill_source=_from_dict(d, "backfill_source", BackfillSource), + budget_policy_id=d.get("budget_policy_id", None), deduplication_columns=d.get("deduplication_columns", None), ingestion_destination=_from_dict(d, "ingestion_destination", IngestionDestination), ingestion_job_id=_int64(d, "ingestion_job_id"), ingestion_pipeline_id=d.get("ingestion_pipeline_id", None), + tags=d.get("tags", None), ) @@ -4959,6 +4981,10 @@ class MaterializedFeature: feature_name: str """The full name of the feature in Unity Catalog.""" + budget_policy_id: Optional[str] = None + """The ID of the budget policy used to attribute the serverless compute cost of this + materialization. If not specified, a default budget policy may be applied.""" + cron_schedule: Optional[str] = None cron_schedule_trigger: Optional[CronSchedule] = None @@ -5000,9 +5026,20 @@ class MaterializedFeature: table_trigger: Optional[TableTrigger] = None """A trigger that fires when the upstream source table changes.""" + tags: Optional[Dict[str, str]] = None + """Custom tags to associate with this materialization. They are applied to the materialization job + (for batch features) or pipeline (for streaming features) and forwarded to the underlying + compute as cluster tags, so materialization cost can be attributed in the billing system tables. + These tags apply only to the materialization compute; they are not applied to the Unity Catalog + Feature resource itself, whose tags are managed separately through the Unity Catalog tagging + API. A maximum of 25 tags is supported; keys and values are subject to the same limitations as + cluster tags.""" + def as_dict(self) -> dict: """Serializes the MaterializedFeature into a dictionary suitable for use as a JSON request body.""" body = {} + if self.budget_policy_id is not None: + body["budget_policy_id"] = self.budget_policy_id if self.cron_schedule is not None: body["cron_schedule"] = self.cron_schedule if self.cron_schedule_trigger: @@ -5029,11 +5066,15 @@ def as_dict(self) -> dict: body["table_name"] = self.table_name if self.table_trigger: body["table_trigger"] = self.table_trigger.as_dict() + if self.tags: + body["tags"] = self.tags return body def as_shallow_dict(self) -> dict: """Serializes the MaterializedFeature into a shallow dictionary of its immediate attributes.""" body = {} + if self.budget_policy_id is not None: + body["budget_policy_id"] = self.budget_policy_id if self.cron_schedule is not None: body["cron_schedule"] = self.cron_schedule if self.cron_schedule_trigger: @@ -5060,12 +5101,15 @@ def as_shallow_dict(self) -> dict: body["table_name"] = self.table_name if self.table_trigger: body["table_trigger"] = self.table_trigger + if self.tags: + body["tags"] = self.tags return body @classmethod def from_dict(cls, d: Dict[str, Any]) -> MaterializedFeature: """Deserializes the MaterializedFeature from a dictionary.""" return cls( + budget_policy_id=d.get("budget_policy_id", None), cron_schedule=d.get("cron_schedule", None), cron_schedule_trigger=_from_dict(d, "cron_schedule_trigger", CronSchedule), feature_name=d.get("feature_name", None), @@ -5079,6 +5123,7 @@ def from_dict(cls, d: Dict[str, Any]) -> MaterializedFeature: streaming_mode=_from_dict(d, "streaming_mode", StreamingMode), table_name=d.get("table_name", None), table_trigger=_from_dict(d, "table_trigger", TableTrigger), + tags=d.get("tags", None), ) @@ -6341,6 +6386,191 @@ def from_dict(cls, d: Dict[str, Any]) -> PublishTableResponse: return cls(online_table_name=d.get("online_table_name", None), pipeline_id=d.get("pipeline_id", None)) +@dataclass +class PurgeFeatureEntitiesMetadata: + """Progress and configuration for a feature entity purge.""" + + create_time: Optional[Timestamp] = None + """Time at which the purge operation was created.""" + + entities_table: Optional[str] = None + """Fully qualified name of the Unity Catalog Delta table containing the entity keys to purge.""" + + entities_table_version: Optional[str] = None + """Version of the entities table used by the purge.""" + + features: Optional[List[str]] = None + """Fully qualified names of the features targeted by the purge.""" + + job_id: Optional[int] = None + """ID of the job that executes this purge.""" + + state: Optional[PurgeFeatureEntitiesMetadataState] = None + """Current state of the purge operation.""" + + def as_dict(self) -> dict: + """Serializes the PurgeFeatureEntitiesMetadata into a dictionary suitable for use as a JSON request body.""" + body = {} + if self.create_time is not None: + body["create_time"] = self.create_time.ToJsonString() + if self.entities_table is not None: + body["entities_table"] = self.entities_table + if self.entities_table_version is not None: + body["entities_table_version"] = self.entities_table_version + if self.features: + body["features"] = [v for v in self.features] + if self.job_id is not None: + body["job_id"] = self.job_id + if self.state is not None: + body["state"] = self.state.value + return body + + def as_shallow_dict(self) -> dict: + """Serializes the PurgeFeatureEntitiesMetadata into a shallow dictionary of its immediate attributes.""" + body = {} + if self.create_time is not None: + body["create_time"] = self.create_time + if self.entities_table is not None: + body["entities_table"] = self.entities_table + if self.entities_table_version is not None: + body["entities_table_version"] = self.entities_table_version + if self.features: + body["features"] = self.features + if self.job_id is not None: + body["job_id"] = self.job_id + if self.state is not None: + body["state"] = self.state + return body + + @classmethod + def from_dict(cls, d: Dict[str, Any]) -> PurgeFeatureEntitiesMetadata: + """Deserializes the PurgeFeatureEntitiesMetadata from a dictionary.""" + return cls( + create_time=_timestamp(d, "create_time"), + entities_table=d.get("entities_table", None), + entities_table_version=d.get("entities_table_version", None), + features=d.get("features", None), + job_id=_int64(d, "job_id"), + state=_enum(d, "state", PurgeFeatureEntitiesMetadataState), + ) + + +class PurgeFeatureEntitiesMetadataState(Enum): + """Lifecycle state of a feature entity purge.""" + + CANCELLED = "CANCELLED" + FAILED = "FAILED" + PENDING = "PENDING" + RUNNING = "RUNNING" + SUCCEEDED = "SUCCEEDED" + + +@dataclass +class PurgeFeatureEntitiesResponse: + """Result of a completed feature entity purge.""" + + metadata: Optional[PurgeFeatureEntitiesMetadata] = None + """Metadata about the purge operation.""" + + results: Optional[List[PurgeFeatureEntitiesResult]] = None + """Per-feature purge results.""" + + state: Optional[PurgeFeatureEntitiesMetadataState] = None + """State of the purge operation.""" + + def as_dict(self) -> dict: + """Serializes the PurgeFeatureEntitiesResponse into a dictionary suitable for use as a JSON request body.""" + body = {} + if self.metadata: + body["metadata"] = self.metadata.as_dict() + if self.results: + body["results"] = [v.as_dict() for v in self.results] + if self.state is not None: + body["state"] = self.state.value + return body + + def as_shallow_dict(self) -> dict: + """Serializes the PurgeFeatureEntitiesResponse into a shallow dictionary of its immediate attributes.""" + body = {} + if self.metadata: + body["metadata"] = self.metadata + if self.results: + body["results"] = self.results + if self.state is not None: + body["state"] = self.state + return body + + @classmethod + def from_dict(cls, d: Dict[str, Any]) -> PurgeFeatureEntitiesResponse: + """Deserializes the PurgeFeatureEntitiesResponse from a dictionary.""" + return cls( + metadata=_from_dict(d, "metadata", PurgeFeatureEntitiesMetadata), + results=_repeated_dict(d, "results", PurgeFeatureEntitiesResult), + state=_enum(d, "state", PurgeFeatureEntitiesMetadataState), + ) + + +@dataclass +class PurgeFeatureEntitiesResult: + """Result of purging one feature.""" + + error: Optional[DatabricksServiceExceptionWithDetailsProto] = None + """Error encountered while purging this feature, if any.""" + + feature: Optional[str] = None + """Fully qualified name of the feature that was purged.""" + + offline_state: Optional[PurgeFeatureEntitiesResultState] = None + """State of the offline purge for this feature.""" + + online_state: Optional[PurgeFeatureEntitiesResultState] = None + """State of the online purge for this feature.""" + + def as_dict(self) -> dict: + """Serializes the PurgeFeatureEntitiesResult into a dictionary suitable for use as a JSON request body.""" + body = {} + if self.error: + body["error"] = self.error.as_dict() + if self.feature is not None: + body["feature"] = self.feature + if self.offline_state is not None: + body["offline_state"] = self.offline_state.value + if self.online_state is not None: + body["online_state"] = self.online_state.value + return body + + def as_shallow_dict(self) -> dict: + """Serializes the PurgeFeatureEntitiesResult into a shallow dictionary of its immediate attributes.""" + body = {} + if self.error: + body["error"] = self.error + if self.feature is not None: + body["feature"] = self.feature + if self.offline_state is not None: + body["offline_state"] = self.offline_state + if self.online_state is not None: + body["online_state"] = self.online_state + return body + + @classmethod + def from_dict(cls, d: Dict[str, Any]) -> PurgeFeatureEntitiesResult: + """Deserializes the PurgeFeatureEntitiesResult from a dictionary.""" + return cls( + error=_from_dict(d, "error", DatabricksServiceExceptionWithDetailsProto), + feature=d.get("feature", None), + offline_state=_enum(d, "offline_state", PurgeFeatureEntitiesResultState), + online_state=_enum(d, "online_state", PurgeFeatureEntitiesResultState), + ) + + +class PurgeFeatureEntitiesResultState(Enum): + """Terminal state of a purge for one store type.""" + + FAILED = "FAILED" + NOT_APPLICABLE = "NOT_APPLICABLE" + SUCCEEDED = "SUCCEEDED" + + @dataclass class RegisteredModelAccessControlRequest: group_name: Optional[str] = None @@ -10978,6 +11208,49 @@ def list_streams( return query["page_token"] = json["next_page_token"] + def purge_feature_entities( + self, features: List[str], entities_table: str, *, request_id: Optional[str] = None + ) -> PurgeFeatureEntitiesOperation: + """Purge materialized feature values for specified entities. + + :param features: List[str] + Fully qualified names of the features to purge. At least one nonempty feature name is required. A + request may contain at most 10000 features; submit additional features in separate requests. + Duplicate features are rejected. + :param entities_table: str + Fully qualified name of the Unity Catalog Delta table containing the entity keys to purge. The table + may contain a subset of each feature's entity-key columns. A partial key match deletes all feature + rows matching the provided key values. Non-key columns are rejected; null key values are allowed. + :param request_id: str (optional) + Optional UUID4 idempotency token for the request. + + :returns: :class:`Operation` + """ + + if request_id is None or request_id == "": + request_id = str(uuid.uuid4()) + body = {} + if entities_table is not None: + body["entities_table"] = entities_table + if features is not None: + body["features"] = [v for v in features] + if request_id is not None: + body["request_id"] = request_id + headers = { + "Accept": "application/json", + "Content-Type": "application/json", + } + + cfg = self._api._cfg + if cfg.workspace_id: + headers["X-Databricks-Workspace-Id"] = cfg.workspace_id + + res = self._api.do( + "POST", "/api/2.0/feature-engineering/features:purgeFeatureEntities", body=body, headers=headers + ) + operation = Operation.from_dict(res) + return PurgeFeatureEntitiesOperation(self, operation) + def update_feature(self, full_name: str, feature: Feature, update_mask: str) -> Feature: """Update a Feature. @@ -11202,6 +11475,83 @@ def done(self) -> bool: return operation.done +class PurgeFeatureEntitiesOperation: + """Long-running operation for purge_feature_entities""" + + def __init__(self, impl: FeatureEngineeringAPI, operation: Operation): + self._impl = impl + self._operation = operation + + def wait(self, opts: Optional[lro.LroOptions] = None) -> PurgeFeatureEntitiesResponse: + """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:`PurgeFeatureEntitiesResponse` + """ + + 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")) + + purge_feature_entities_response = PurgeFeatureEntitiesResponse.from_dict(operation.response) + + return purge_feature_entities_response, None + + return 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) -> PurgeFeatureEntitiesMetadata: + """Metadata returns metadata associated with the long-running operation. + If the metadata is not available, the returned metadata is None. + + :returns: :class:`PurgeFeatureEntitiesMetadata` or None + """ + if self._operation.metadata is None: + return None + + return PurgeFeatureEntitiesMetadata.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 FeatureStoreAPI: """A feature store is a centralized repository that enables data scientists to find and share features. Using a feature store also ensures that the code used to compute feature values is the same during model diff --git a/databricks/sdk/service/pipelines.py b/databricks/sdk/service/pipelines.py index b688e4dc3..128eba095 100644 --- a/databricks/sdk/service/pipelines.py +++ b/databricks/sdk/service/pipelines.py @@ -2097,10 +2097,10 @@ def from_dict(cls, d: Dict[str, Any]) -> ListPipelineEventsResponse: @dataclass class ListPipelinesResponse: next_page_token: Optional[str] = None - """If present, a token to fetch the next page of events.""" + """If present, a token to fetch the next page of pipelines.""" statuses: Optional[List[PipelineStateInfo]] = None - """The list of events matching the request criteria.""" + """The list of pipelines matching the request criteria.""" def as_dict(self) -> dict: """Serializes the ListPipelinesResponse into a dictionary suitable for use as a JSON request body.""" @@ -6380,9 +6380,9 @@ def list_pipelines( Composite filters are not supported. This field is optional. :param max_results: int (optional) The maximum number of entries to return in a single page. The system may return fewer than - max_results events in a response, even if there are more events available. This field is optional. - The default value is 25. The maximum value is 100. An error is returned if the value of max_results - is greater than 100. + max_results pipelines in a response, even if there are more pipelines available. This field is + optional. The default value is 25. The maximum value is 100. An error is returned if the value of + max_results is greater than 100. :param order_by: List[str] (optional) A list of strings specifying the order of results. Supported order_by fields are id and name. The default is id asc. This field is optional. diff --git a/databricks/sdk/service/postgres.py b/databricks/sdk/service/postgres.py index 9f35c1f39..235e4409d 100644 --- a/databricks/sdk/service/postgres.py +++ b/databricks/sdk/service/postgres.py @@ -142,7 +142,7 @@ def from_dict(cls, d: Dict[str, Any]) -> BranchOperationMetadata: class BranchSpec: expire_time: Optional[Timestamp] = None """Absolute expiration timestamp. When set, the branch will expire at this time. Mutually exclusive - with ``ttl`` and ``no_expiry``. When updating, use ``spec.expiration`` in the update_mask.""" + with ``ttl`` and ``no_expiry``.""" is_protected: Optional[bool] = None """When set to true, protects the branch from deletion and reset. Associated compute endpoints and @@ -151,7 +151,7 @@ class BranchSpec: no_expiry: Optional[bool] = None """Explicitly disable expiration. When set to true, the branch will not expire. If set to false, the request is invalid; provide either ttl or expire_time instead. Mutually exclusive with - ``expire_time`` and ``ttl``. When updating, use ``spec.expiration`` in the update_mask.""" + ``expire_time`` and ``ttl``.""" source_branch: Optional[str] = None """The name of the source branch from which this branch was created (data lineage for point-in-time @@ -172,8 +172,7 @@ class BranchSpec: ttl: Optional[Duration] = None """Relative time-to-live duration. When set, the branch will expire at creation_time + ttl. - Mutually exclusive with ``expire_time`` and ``no_expiry``. When updating, use - ``spec.expiration`` in the update_mask.""" + Mutually exclusive with ``expire_time`` and ``no_expiry``.""" def as_dict(self) -> dict: """Serializes the BranchSpec into a dictionary suitable for use as a JSON request body.""" @@ -1722,15 +1721,14 @@ class EndpointSpec: no_suspension: Optional[bool] = None """When set to true, explicitly disables automatic suspension (never suspend). Should be set to - true when provided. Mutually exclusive with ``suspend_timeout_duration``. When updating, use - ``spec.suspension`` in the update_mask.""" + true when provided. Mutually exclusive with ``suspend_timeout_duration``.""" settings: Optional[EndpointSettings] = None suspend_timeout_duration: Optional[Duration] = None """Duration of inactivity after which the compute endpoint is automatically suspended. If specified should be between 60s and 604800s (1 minute to 1 week). Mutually exclusive with - ``no_suspension``. When updating, use ``spec.suspension`` in the update_mask.""" + ``no_suspension``.""" def as_dict(self) -> dict: """Serializes the EndpointSpec into a dictionary suitable for use as a JSON request body.""" @@ -2697,8 +2695,7 @@ class ProjectDefaultEndpointSettings: no_suspension: Optional[bool] = None """When set to true, explicitly disables automatic suspension (never suspend). Should be set to - true when provided. Mutually exclusive with ``suspend_timeout_duration``. When updating, use - ``spec.project_default_settings.suspension`` in the update_mask.""" + true when provided. Mutually exclusive with ``suspend_timeout_duration``.""" pg_settings: Optional[Dict[str, str]] = None """A raw representation of Postgres settings.""" @@ -2706,8 +2703,7 @@ class ProjectDefaultEndpointSettings: suspend_timeout_duration: Optional[Duration] = None """Duration of inactivity after which the compute endpoint is automatically suspended. If specified should be between 60s and 604800s (1 minute to 1 week). Mutually exclusive with - ``no_suspension``. When updating, use ``spec.project_default_settings.suspension`` in the - update_mask.""" + ``no_suspension``.""" def as_dict(self) -> dict: """Serializes the ProjectDefaultEndpointSettings into a dictionary suitable for use as a JSON request body.""" diff --git a/databricks/sdk/version.py b/databricks/sdk/version.py index dd2dfb407..da56c9c74 100644 --- a/databricks/sdk/version.py +++ b/databricks/sdk/version.py @@ -1 +1 @@ -__version__ = "0.136.0" +__version__ = "0.137.0" diff --git a/docs/dbdataclasses/catalog.rst b/docs/dbdataclasses/catalog.rst index b818fdc99..dca2c2481 100644 --- a/docs/dbdataclasses/catalog.rst +++ b/docs/dbdataclasses/catalog.rst @@ -656,6 +656,10 @@ These dataclasses are used in the SDK to represent API requests and responses fo .. py:attribute:: INTERNAL_AND_EXTERNAL :value: "INTERNAL_AND_EXTERNAL" +.. autoclass:: DenyOptions + :members: + :undoc-members: + .. autoclass:: Dependency :members: :undoc-members: @@ -1556,6 +1560,9 @@ These dataclasses are used in the SDK to represent API requests and responses fo .. py:attribute:: POLICY_TYPE_COLUMN_MASK :value: "POLICY_TYPE_COLUMN_MASK" + .. py:attribute:: POLICY_TYPE_DENY + :value: "POLICY_TYPE_DENY" + .. py:attribute:: POLICY_TYPE_GRANT :value: "POLICY_TYPE_GRANT" diff --git a/docs/dbdataclasses/ml.rst b/docs/dbdataclasses/ml.rst index c19db4462..892de6900 100644 --- a/docs/dbdataclasses/ml.rst +++ b/docs/dbdataclasses/ml.rst @@ -1113,6 +1113,50 @@ These dataclasses are used in the SDK to represent API requests and responses fo :members: :undoc-members: +.. autoclass:: PurgeFeatureEntitiesMetadata + :members: + :undoc-members: + +.. py:class:: PurgeFeatureEntitiesMetadataState + + Lifecycle state of a feature entity purge. + + .. py:attribute:: CANCELLED + :value: "CANCELLED" + + .. py:attribute:: FAILED + :value: "FAILED" + + .. py:attribute:: PENDING + :value: "PENDING" + + .. py:attribute:: RUNNING + :value: "RUNNING" + + .. py:attribute:: SUCCEEDED + :value: "SUCCEEDED" + +.. autoclass:: PurgeFeatureEntitiesResponse + :members: + :undoc-members: + +.. autoclass:: PurgeFeatureEntitiesResult + :members: + :undoc-members: + +.. py:class:: PurgeFeatureEntitiesResultState + + Terminal state of a purge for one store type. + + .. py:attribute:: FAILED + :value: "FAILED" + + .. py:attribute:: NOT_APPLICABLE + :value: "NOT_APPLICABLE" + + .. py:attribute:: SUCCEEDED + :value: "SUCCEEDED" + .. autoclass:: RegisteredModelAccessControlRequest :members: :undoc-members: diff --git a/docs/workspace/cleanrooms/clean_room_assets.rst b/docs/workspace/cleanrooms/clean_room_assets.rst old mode 100755 new mode 100644 index ccceb2ea7..2e9928442 --- a/docs/workspace/cleanrooms/clean_room_assets.rst +++ b/docs/workspace/cleanrooms/clean_room_assets.rst @@ -95,7 +95,7 @@ *shared_catalog*.*shared_schema*.*asset_name* For notebooks, the name is the notebook file name. For jar analyses, the name is the jar analysis - name. + name. For Genie spaces, the name is derived from the clean room; the caller does not choose it. :param asset: :class:`CleanRoomAsset` The asset to update. The asset's ``name`` and ``asset_type`` fields are used to identify the asset to update. diff --git a/docs/workspace/domains/domains.rst b/docs/workspace/domains/domains.rst index 6c127e85c..ced23313f 100644 --- a/docs/workspace/domains/domains.rst +++ b/docs/workspace/domains/domains.rst @@ -26,8 +26,7 @@ Full resource name of the domain to delete. Format: ``domains/{domain_id}`` :param force: bool (optional) When false (default), DeleteDomain is rejected with FAILED_PRECONDITION if the domain still has - Glossary pages. When true, those pages are deleted first and then the domain is removed. Forwarded - to the central service. + Glossary pages. When true, those pages are deleted first and then the domain is removed. diff --git a/docs/workspace/ml/feature_engineering.rst b/docs/workspace/ml/feature_engineering.rst index e1fe5f6fb..c9de1210a 100644 --- a/docs/workspace/ml/feature_engineering.rst +++ b/docs/workspace/ml/feature_engineering.rst @@ -231,6 +231,24 @@ :returns: Iterator over :class:`Stream` + .. py:method:: purge_feature_entities(features: List[str], entities_table: str [, request_id: Optional[str]]) -> PurgeFeatureEntitiesOperation + + Purge materialized feature values for specified entities. + + :param features: List[str] + Fully qualified names of the features to purge. At least one nonempty feature name is required. A + request may contain at most 10000 features; submit additional features in separate requests. + Duplicate features are rejected. + :param entities_table: str + Fully qualified name of the Unity Catalog Delta table containing the entity keys to purge. The table + may contain a subset of each feature's entity-key columns. A partial key match deletes all feature + rows matching the provided key values. Non-key columns are rejected; null key values are allowed. + :param request_id: str (optional) + Optional UUID4 idempotency token for the request. + + :returns: :class:`Operation` + + .. py:method:: update_feature(full_name: str, feature: Feature, update_mask: str) -> Feature Update a Feature. diff --git a/docs/workspace/pipelines/pipelines.rst b/docs/workspace/pipelines/pipelines.rst index bf54ebc7c..161beed7d 100644 --- a/docs/workspace/pipelines/pipelines.rst +++ b/docs/workspace/pipelines/pipelines.rst @@ -424,9 +424,9 @@ Composite filters are not supported. This field is optional. :param max_results: int (optional) The maximum number of entries to return in a single page. The system may return fewer than - max_results events in a response, even if there are more events available. This field is optional. - The default value is 25. The maximum value is 100. An error is returned if the value of max_results - is greater than 100. + max_results pipelines in a response, even if there are more pipelines available. This field is + optional. The default value is 25. The maximum value is 100. An error is returned if the value of + max_results is greater than 100. :param order_by: List[str] (optional) A list of strings specifying the order of results. Supported order_by fields are id and name. The default is id asc. This field is optional.