databricks-sdk 0.68.0__py3-none-any.whl → 0.70.0__py3-none-any.whl

databricks/sdk/service/ml.py

@@ -1299,11 +1299,16 @@ class Feature:
     description: Optional[str] = None
     """The description of the feature."""
 
+    filter_condition: Optional[str] = None
+    """The filter condition applied to the source data before aggregation."""
+
     def as_dict(self) -> dict:
         """Serializes the Feature into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.description is not None:
             body["description"] = self.description
+        if self.filter_condition is not None:
+            body["filter_condition"] = self.filter_condition
         if self.full_name is not None:
             body["full_name"] = self.full_name
         if self.function:
@@ -1321,6 +1326,8 @@ class Feature:
         body = {}
         if self.description is not None:
             body["description"] = self.description
+        if self.filter_condition is not None:
+            body["filter_condition"] = self.filter_condition
         if self.full_name is not None:
             body["full_name"] = self.full_name
         if self.function:
@@ -1338,6 +1345,7 @@ class Feature:
         """Deserializes the Feature from a dictionary."""
         return cls(
             description=d.get("description", None),
+            filter_condition=d.get("filter_condition", None),
             full_name=d.get("full_name", None),
             function=_from_dict(d, "function", Function),
             inputs=d.get("inputs", None),
@@ -2419,6 +2427,41 @@ class ListFeaturesResponse:
         return cls(features=_repeated_dict(d, "features", Feature), next_page_token=d.get("next_page_token", None))
 
 
+@dataclass
+class ListMaterializedFeaturesResponse:
+    materialized_features: Optional[List[MaterializedFeature]] = None
+    """List of materialized features."""
+
+    next_page_token: Optional[str] = None
+    """Pagination token to request the next page of results for this query."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ListMaterializedFeaturesResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.materialized_features:
+            body["materialized_features"] = [v.as_dict() for v in self.materialized_features]
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListMaterializedFeaturesResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.materialized_features:
+            body["materialized_features"] = self.materialized_features
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ListMaterializedFeaturesResponse:
+        """Deserializes the ListMaterializedFeaturesResponse from a dictionary."""
+        return cls(
+            materialized_features=_repeated_dict(d, "materialized_features", MaterializedFeature),
+            next_page_token=d.get("next_page_token", None),
+        )
+
+
 @dataclass
 class ListModelsResponse:
     next_page_token: Optional[str] = None
@@ -2937,6 +2980,90 @@ class LoggedModelTag:
         return cls(key=d.get("key", None), value=d.get("value", None))
 
 
+@dataclass
+class MaterializedFeature:
+    """A materialized feature represents a feature that is continuously computed and stored."""
+
+    feature_name: str
+    """The full name of the feature in Unity Catalog."""
+
+    offline_store_config: OfflineStoreConfig
+
+    online_store_config: OnlineStore
+
+    last_materialization_time: Optional[str] = None
+    """The timestamp when the pipeline last ran and updated the materialized feature values. If the
+    pipeline has not run yet, this field will be null."""
+
+    materialized_feature_id: Optional[str] = None
+    """Unique identifier for the materialized feature."""
+
+    pipeline_schedule_state: Optional[MaterializedFeaturePipelineScheduleState] = None
+    """The schedule state of the materialization pipeline."""
+
+    table_name: Optional[str] = None
+    """The fully qualified Unity Catalog path to the table containing the materialized feature (Delta
+    table or Lakebase table). Output only."""
+
+    def as_dict(self) -> dict:
+        """Serializes the MaterializedFeature into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.feature_name is not None:
+            body["feature_name"] = self.feature_name
+        if self.last_materialization_time is not None:
+            body["last_materialization_time"] = self.last_materialization_time
+        if self.materialized_feature_id is not None:
+            body["materialized_feature_id"] = self.materialized_feature_id
+        if self.offline_store_config:
+            body["offline_store_config"] = self.offline_store_config.as_dict()
+        if self.online_store_config:
+            body["online_store_config"] = self.online_store_config.as_dict()
+        if self.pipeline_schedule_state is not None:
+            body["pipeline_schedule_state"] = self.pipeline_schedule_state.value
+        if self.table_name is not None:
+            body["table_name"] = self.table_name
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the MaterializedFeature into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.feature_name is not None:
+            body["feature_name"] = self.feature_name
+        if self.last_materialization_time is not None:
+            body["last_materialization_time"] = self.last_materialization_time
+        if self.materialized_feature_id is not None:
+            body["materialized_feature_id"] = self.materialized_feature_id
+        if self.offline_store_config:
+            body["offline_store_config"] = self.offline_store_config
+        if self.online_store_config:
+            body["online_store_config"] = self.online_store_config
+        if self.pipeline_schedule_state is not None:
+            body["pipeline_schedule_state"] = self.pipeline_schedule_state
+        if self.table_name is not None:
+            body["table_name"] = self.table_name
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> MaterializedFeature:
+        """Deserializes the MaterializedFeature from a dictionary."""
+        return cls(
+            feature_name=d.get("feature_name", None),
+            last_materialization_time=d.get("last_materialization_time", None),
+            materialized_feature_id=d.get("materialized_feature_id", None),
+            offline_store_config=_from_dict(d, "offline_store_config", OfflineStoreConfig),
+            online_store_config=_from_dict(d, "online_store_config", OnlineStore),
+            pipeline_schedule_state=_enum(d, "pipeline_schedule_state", MaterializedFeaturePipelineScheduleState),
+            table_name=d.get("table_name", None),
+        )
+
+
+class MaterializedFeaturePipelineScheduleState(Enum):
+
+    ACTIVE = "ACTIVE"
+    PAUSED = "PAUSED"
+    SNAPSHOT = "SNAPSHOT"
+
+
 @dataclass
 class Metric:
     """Metric associated with a run, represented as a key-value pair."""
@@ -3613,6 +3740,52 @@ class ModelVersionTag:
         return cls(key=d.get("key", None), value=d.get("value", None))
 
 
+@dataclass
+class OfflineStoreConfig:
+    """Configuration for offline store destination."""
+
+    catalog_name: str
+    """The Unity Catalog catalog name."""
+
+    schema_name: str
+    """The Unity Catalog schema name."""
+
+    table_name_prefix: str
+    """Prefix for Unity Catalog table name. The materialized feature will be stored in a table with
+    this prefix and a generated postfix."""
+
+    def as_dict(self) -> dict:
+        """Serializes the OfflineStoreConfig into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.catalog_name is not None:
+            body["catalog_name"] = self.catalog_name
+        if self.schema_name is not None:
+            body["schema_name"] = self.schema_name
+        if self.table_name_prefix is not None:
+            body["table_name_prefix"] = self.table_name_prefix
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the OfflineStoreConfig into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.catalog_name is not None:
+            body["catalog_name"] = self.catalog_name
+        if self.schema_name is not None:
+            body["schema_name"] = self.schema_name
+        if self.table_name_prefix is not None:
+            body["table_name_prefix"] = self.table_name_prefix
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> OfflineStoreConfig:
+        """Deserializes the OfflineStoreConfig from a dictionary."""
+        return cls(
+            catalog_name=d.get("catalog_name", None),
+            schema_name=d.get("schema_name", None),
+            table_name_prefix=d.get("table_name_prefix", None),
+        )
+
+
 @dataclass
 class OnlineStore:
     """An OnlineStore is a logical database instance that stores and serves features online."""
@@ -6563,6 +6736,23 @@ class FeatureEngineeringAPI:
         res = self._api.do("POST", "/api/2.0/feature-engineering/features", body=body, headers=headers)
         return Feature.from_dict(res)
 
+    def create_materialized_feature(self, materialized_feature: MaterializedFeature) -> MaterializedFeature:
+        """Create a materialized feature.
+
+        :param materialized_feature: :class:`MaterializedFeature`
+          The materialized feature to create.
+
+        :returns: :class:`MaterializedFeature`
+        """
+        body = materialized_feature.as_dict()
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        res = self._api.do("POST", "/api/2.0/feature-engineering/materialized-features", body=body, headers=headers)
+        return MaterializedFeature.from_dict(res)
+
     def delete_feature(self, full_name: str):
         """Delete a Feature.
 
@@ -6578,6 +6768,23 @@ class FeatureEngineeringAPI:
 
         self._api.do("DELETE", f"/api/2.0/feature-engineering/features/{full_name}", headers=headers)
 
+    def delete_materialized_feature(self, materialized_feature_id: str):
+        """Delete a materialized feature.
+
+        :param materialized_feature_id: str
+          The ID of the materialized feature to delete.
+
+
+        """
+
+        headers = {
+            "Accept": "application/json",
+        }
+
+        self._api.do(
+            "DELETE", f"/api/2.0/feature-engineering/materialized-features/{materialized_feature_id}", headers=headers
+        )
+
     def get_feature(self, full_name: str) -> Feature:
         """Get a Feature.
 
@@ -6594,6 +6801,24 @@ class FeatureEngineeringAPI:
         res = self._api.do("GET", f"/api/2.0/feature-engineering/features/{full_name}", headers=headers)
         return Feature.from_dict(res)
 
+    def get_materialized_feature(self, materialized_feature_id: str) -> MaterializedFeature:
+        """Get a materialized feature.
+
+        :param materialized_feature_id: str
+          The ID of the materialized feature.
+
+        :returns: :class:`MaterializedFeature`
+        """
+
+        headers = {
+            "Accept": "application/json",
+        }
+
+        res = self._api.do(
+            "GET", f"/api/2.0/feature-engineering/materialized-features/{materialized_feature_id}", headers=headers
+        )
+        return MaterializedFeature.from_dict(res)
+
     def list_features(self, *, page_size: Optional[int] = None, page_token: Optional[str] = None) -> Iterator[Feature]:
         """List Features.
 
@@ -6623,6 +6848,45 @@ class FeatureEngineeringAPI:
                 return
             query["page_token"] = json["next_page_token"]
 
+    def list_materialized_features(
+        self, *, feature_name: Optional[str] = None, page_size: Optional[int] = None, page_token: Optional[str] = None
+    ) -> Iterator[MaterializedFeature]:
+        """List materialized features.
+
+        :param feature_name: str (optional)
+          Filter by feature name. If specified, only materialized features materialized from this feature will
+          be returned.
+        :param page_size: int (optional)
+          The maximum number of results to return. Defaults to 100 if not specified. Cannot be greater than
+          1000.
+        :param page_token: str (optional)
+          Pagination token to go to the next page based on a previous query.
+
+        :returns: Iterator over :class:`MaterializedFeature`
+        """
+
+        query = {}
+        if feature_name is not None:
+            query["feature_name"] = feature_name
+        if page_size is not None:
+            query["page_size"] = page_size
+        if page_token is not None:
+            query["page_token"] = page_token
+        headers = {
+            "Accept": "application/json",
+        }
+
+        while True:
+            json = self._api.do(
+                "GET", "/api/2.0/feature-engineering/materialized-features", query=query, headers=headers
+            )
+            if "materialized_features" in json:
+                for v in json["materialized_features"]:
+                    yield MaterializedFeature.from_dict(v)
+            if "next_page_token" not in json or not json["next_page_token"]:
+                return
+            query["page_token"] = json["next_page_token"]
+
     def update_feature(self, full_name: str, feature: Feature, update_mask: str) -> Feature:
         """Update a Feature.
 
@@ -6649,6 +6913,39 @@ class FeatureEngineeringAPI:
         )
         return Feature.from_dict(res)
 
+    def update_materialized_feature(
+        self, materialized_feature_id: str, materialized_feature: MaterializedFeature, update_mask: str
+    ) -> MaterializedFeature:
+        """Update a materialized feature (pause/resume).
+
+        :param materialized_feature_id: str
+          Unique identifier for the materialized feature.
+        :param materialized_feature: :class:`MaterializedFeature`
+          The materialized feature to update.
+        :param update_mask: str
+          Provide the materialization feature fields which should be updated. Currently, only the
+          pipeline_state field can be updated.
+
+        :returns: :class:`MaterializedFeature`
+        """
+        body = materialized_feature.as_dict()
+        query = {}
+        if update_mask is not None:
+            query["update_mask"] = update_mask
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        res = self._api.do(
+            "PATCH",
+            f"/api/2.0/feature-engineering/materialized-features/{materialized_feature_id}",
+            query=query,
+            body=body,
+            headers=headers,
+        )
+        return MaterializedFeature.from_dict(res)
+
 
 class FeatureStoreAPI:
     """A feature store is a centralized repository that enables data scientists to find and share features. Using

databricks/sdk/service/oauth2.py

@@ -863,17 +863,37 @@ class SecretInfo:
 
 @dataclass
 class TokenAccessPolicy:
+    absolute_session_lifetime_in_minutes: Optional[int] = None
+    """Absolute OAuth session TTL in minutes. Effective only when the single-use refresh token feature
+    is enabled. This is the absolute TTL of all refresh tokens issued in one OAuth session. When a
+    new refresh token is issued during refresh token rotation, it will inherit the same absolute TTL
+    as the old refresh token. In other words, this represents the maximum amount of time a user can
+    stay logged in without re-authenticating."""
+
     access_token_ttl_in_minutes: Optional[int] = None
     """access token time to live in minutes"""
 
+    enable_single_use_refresh_tokens: Optional[bool] = None
+    """Whether to enable single-use refresh tokens (refresh token rotation). If this feature is
+    enabled, upon successfully getting a new access token using a refresh token, Databricks will
+    issue a new refresh token along with the access token in the response and invalidate the old
+    refresh token. The client should use the new refresh token to get access tokens in future
+    requests."""
+
     refresh_token_ttl_in_minutes: Optional[int] = None
-    """refresh token time to live in minutes"""
+    """Refresh token time to live in minutes. When single-use refresh tokens are enabled, this
+    represents the TTL of an individual refresh token. If the refresh token is used before it
+    expires, a new one is issued with a renewed individual TTL."""
 
     def as_dict(self) -> dict:
         """Serializes the TokenAccessPolicy into a dictionary suitable for use as a JSON request body."""
         body = {}
+        if self.absolute_session_lifetime_in_minutes is not None:
+            body["absolute_session_lifetime_in_minutes"] = self.absolute_session_lifetime_in_minutes
         if self.access_token_ttl_in_minutes is not None:
             body["access_token_ttl_in_minutes"] = self.access_token_ttl_in_minutes
+        if self.enable_single_use_refresh_tokens is not None:
+            body["enable_single_use_refresh_tokens"] = self.enable_single_use_refresh_tokens
         if self.refresh_token_ttl_in_minutes is not None:
             body["refresh_token_ttl_in_minutes"] = self.refresh_token_ttl_in_minutes
         return body
@@ -881,8 +901,12 @@ class TokenAccessPolicy:
     def as_shallow_dict(self) -> dict:
         """Serializes the TokenAccessPolicy into a shallow dictionary of its immediate attributes."""
         body = {}
+        if self.absolute_session_lifetime_in_minutes is not None:
+            body["absolute_session_lifetime_in_minutes"] = self.absolute_session_lifetime_in_minutes
         if self.access_token_ttl_in_minutes is not None:
             body["access_token_ttl_in_minutes"] = self.access_token_ttl_in_minutes
+        if self.enable_single_use_refresh_tokens is not None:
+            body["enable_single_use_refresh_tokens"] = self.enable_single_use_refresh_tokens
         if self.refresh_token_ttl_in_minutes is not None:
             body["refresh_token_ttl_in_minutes"] = self.refresh_token_ttl_in_minutes
         return body
@@ -891,7 +915,9 @@ class TokenAccessPolicy:
     def from_dict(cls, d: Dict[str, Any]) -> TokenAccessPolicy:
         """Deserializes the TokenAccessPolicy from a dictionary."""
         return cls(
+            absolute_session_lifetime_in_minutes=d.get("absolute_session_lifetime_in_minutes", None),
             access_token_ttl_in_minutes=d.get("access_token_ttl_in_minutes", None),
+            enable_single_use_refresh_tokens=d.get("enable_single_use_refresh_tokens", None),
             refresh_token_ttl_in_minutes=d.get("refresh_token_ttl_in_minutes", None),
         )
 

databricks/sdk/service/pipelines.py

@@ -119,8 +119,8 @@ class DataPlaneId:
 
 
 class DayOfWeek(Enum):
-    """Days of week in which the restart is allowed to happen (within a five-hour window starting at
-    start_hour). If not specified all days of the week will be used."""
+    """Days of week in which the window is allowed to happen. If not specified all days of the week
+    will be used."""
 
     FRIDAY = "FRIDAY"
     MONDAY = "MONDAY"

databricks/sdk/service/provisioning.py

@@ -1436,7 +1436,7 @@ class Workspace:
     azure_workspace_info: Optional[AzureWorkspaceInfo] = None
 
     cloud: Optional[str] = None
-    """The cloud name. This field always has the value `gcp`."""
+    """The cloud name. This field can have values like `azure`, `gcp`."""
 
     cloud_resource_container: Optional[CloudResourceContainer] = None
 
@@ -2487,6 +2487,7 @@ class WorkspacesAPI:
         gke_config: Optional[GkeConfig] = None,
         location: Optional[str] = None,
         managed_services_customer_managed_key_id: Optional[str] = None,
+        network_connectivity_config_id: Optional[str] = None,
         network_id: Optional[str] = None,
         pricing_tier: Optional[PricingTier] = None,
         private_access_settings_id: Optional[str] = None,
@@ -2565,6 +2566,10 @@ class WorkspacesAPI:
           The ID of the workspace's managed services encryption key configuration object. This is used to help
           protect and control access to the workspace's notebooks, secrets, Databricks SQL queries, and query
           history. The provided key configuration object property use_cases must contain MANAGED_SERVICES.
+        :param network_connectivity_config_id: str (optional)
+          The object ID of network connectivity config. Once assigned, the workspace serverless compute
+          resources use the same set of stable IP CIDR blocks and optional private link to access your
+          resources.
         :param network_id: str (optional)
           The ID of the workspace's network configuration object. To use AWS PrivateLink, this field is
           required.
@@ -2613,6 +2618,8 @@ class WorkspacesAPI:
             body["location"] = location
         if managed_services_customer_managed_key_id is not None:
             body["managed_services_customer_managed_key_id"] = managed_services_customer_managed_key_id
+        if network_connectivity_config_id is not None:
+            body["network_connectivity_config_id"] = network_connectivity_config_id
         if network_id is not None:
             body["network_id"] = network_id
         if pricing_tier is not None:
@@ -2653,6 +2660,7 @@ class WorkspacesAPI:
         gke_config: Optional[GkeConfig] = None,
         location: Optional[str] = None,
         managed_services_customer_managed_key_id: Optional[str] = None,
+        network_connectivity_config_id: Optional[str] = None,
         network_id: Optional[str] = None,
         pricing_tier: Optional[PricingTier] = None,
         private_access_settings_id: Optional[str] = None,
@@ -2673,6 +2681,7 @@ class WorkspacesAPI:
             gke_config=gke_config,
             location=location,
             managed_services_customer_managed_key_id=managed_services_customer_managed_key_id,
+            network_connectivity_config_id=network_connectivity_config_id,
             network_id=network_id,
             pricing_tier=pricing_tier,
             private_access_settings_id=private_access_settings_id,

databricks/sdk/service/settings.py

@@ -4183,6 +4183,8 @@ class NccPrivateEndpointRule:
 
 class NccPrivateEndpointRulePrivateLinkConnectionState(Enum):
 
+    CREATE_FAILED = "CREATE_FAILED"
+    CREATING = "CREATING"
     DISCONNECTED = "DISCONNECTED"
     ESTABLISHED = "ESTABLISHED"
     EXPIRED = "EXPIRED"

databricks/sdk/service/sharing.py

@@ -2987,44 +2987,6 @@ class RecipientFederationPoliciesAPI:
                 return
             query["page_token"] = json["next_page_token"]
 
-    def update(
-        self, recipient_name: str, name: str, policy: FederationPolicy, *, update_mask: Optional[str] = None
-    ) -> FederationPolicy:
-        """Updates an existing federation policy for an OIDC_RECIPIENT. The caller must be the owner of the
-        recipient.
-
-        :param recipient_name: str
-          Name of the recipient. This is the name of the recipient for which the policy is being updated.
-        :param name: str
-          Name of the policy. This is the name of the current name of the policy.
-        :param policy: :class:`FederationPolicy`
-        :param update_mask: str (optional)
-          The field mask specifies which fields of the policy to update. To specify multiple fields in the
-          field mask, use comma as the separator (no space). The special value '*' indicates that all fields
-          should be updated (full replacement). If unspecified, all fields that are set in the policy provided
-          in the update request will overwrite the corresponding fields in the existing policy. Example value:
-          'comment,oidc_policy.audiences'.
-
-        :returns: :class:`FederationPolicy`
-        """
-        body = policy.as_dict()
-        query = {}
-        if update_mask is not None:
-            query["update_mask"] = update_mask
-        headers = {
-            "Accept": "application/json",
-            "Content-Type": "application/json",
-        }
-
-        res = self._api.do(
-            "PATCH",
-            f"/api/2.0/data-sharing/recipients/{recipient_name}/federation-policies/{name}",
-            query=query,
-            body=body,
-            headers=headers,
-        )
-        return FederationPolicy.from_dict(res)
-
 
 class RecipientsAPI:
     """A recipient is an object you create using :method:recipients/create to represent an organization which you