databricks-sdk 0.39.0__py3-none-any.whl → 0.41.0__py3-none-any.whl

databricks/sdk/service/dashboards.py

@@ -381,8 +381,9 @@ class GenieMessage:
     status: Optional[MessageStatus] = None
     """MesssageStatus. The possible values are: * `FETCHING_METADATA`: Fetching metadata from the data
     sources. * `FILTERING_CONTEXT`: Running smart context step to determine relevant context. *
-    `ASKING_AI`: Waiting for the LLM to respond to the users question. * `EXECUTING_QUERY`:
-    Executing AI provided SQL query. Get the SQL query result by calling
+    `ASKING_AI`: Waiting for the LLM to respond to the users question. * `PENDING_WAREHOUSE`:
+    Waiting for warehouse before the SQL query can start executing. * `EXECUTING_QUERY`: Executing
+    AI provided SQL query. Get the SQL query result by calling
     [getMessageQueryResult](:method:genie/getMessageQueryResult) API. **Important: The message
     status will stay in the `EXECUTING_QUERY` until a client calls
     [getMessageQueryResult](:method:genie/getMessageQueryResult)**. * `FAILED`: Generating a
@@ -678,8 +679,9 @@ class MessageErrorType(Enum):
 class MessageStatus(Enum):
     """MesssageStatus. The possible values are: * `FETCHING_METADATA`: Fetching metadata from the data
     sources. * `FILTERING_CONTEXT`: Running smart context step to determine relevant context. *
-    `ASKING_AI`: Waiting for the LLM to respond to the users question. * `EXECUTING_QUERY`:
-    Executing AI provided SQL query. Get the SQL query result by calling
+    `ASKING_AI`: Waiting for the LLM to respond to the users question. * `PENDING_WAREHOUSE`:
+    Waiting for warehouse before the SQL query can start executing. * `EXECUTING_QUERY`: Executing
+    AI provided SQL query. Get the SQL query result by calling
     [getMessageQueryResult](:method:genie/getMessageQueryResult) API. **Important: The message
     status will stay in the `EXECUTING_QUERY` until a client calls
     [getMessageQueryResult](:method:genie/getMessageQueryResult)**. * `FAILED`: Generating a
@@ -696,6 +698,7 @@ class MessageStatus(Enum):
     FAILED = 'FAILED'
     FETCHING_METADATA = 'FETCHING_METADATA'
     FILTERING_CONTEXT = 'FILTERING_CONTEXT'
+    PENDING_WAREHOUSE = 'PENDING_WAREHOUSE'
     QUERY_RESULT_EXPIRED = 'QUERY_RESULT_EXPIRED'
     SUBMITTED = 'SUBMITTED'
 
@@ -711,12 +714,18 @@ class MigrateDashboardRequest:
     parent_path: Optional[str] = None
     """The workspace path of the folder to contain the migrated Lakeview dashboard."""
 
+    update_parameter_syntax: Optional[bool] = None
+    """Flag to indicate if mustache parameter syntax ({{ param }}) should be auto-updated to named
+    syntax (:param) when converting datasets in the dashboard."""
+
     def as_dict(self) -> dict:
         """Serializes the MigrateDashboardRequest into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.display_name is not None: body['display_name'] = self.display_name
         if self.parent_path is not None: body['parent_path'] = self.parent_path
         if self.source_dashboard_id is not None: body['source_dashboard_id'] = self.source_dashboard_id
+        if self.update_parameter_syntax is not None:
+            body['update_parameter_syntax'] = self.update_parameter_syntax
         return body
 
     def as_shallow_dict(self) -> dict:
@@ -725,6 +734,8 @@ class MigrateDashboardRequest:
         if self.display_name is not None: body['display_name'] = self.display_name
         if self.parent_path is not None: body['parent_path'] = self.parent_path
         if self.source_dashboard_id is not None: body['source_dashboard_id'] = self.source_dashboard_id
+        if self.update_parameter_syntax is not None:
+            body['update_parameter_syntax'] = self.update_parameter_syntax
         return body
 
     @classmethod
@@ -732,7 +743,8 @@ class MigrateDashboardRequest:
         """Deserializes the MigrateDashboardRequest from a dictionary."""
         return cls(display_name=d.get('display_name', None),
                    parent_path=d.get('parent_path', None),
-                   source_dashboard_id=d.get('source_dashboard_id', None))
+                   source_dashboard_id=d.get('source_dashboard_id', None),
+                   update_parameter_syntax=d.get('update_parameter_syntax', None))
 
 
 @dataclass
@@ -1759,7 +1771,8 @@ class LakeviewAPI:
                 source_dashboard_id: str,
                 *,
                 display_name: Optional[str] = None,
-                parent_path: Optional[str] = None) -> Dashboard:
+                parent_path: Optional[str] = None,
+                update_parameter_syntax: Optional[bool] = None) -> Dashboard:
         """Migrate dashboard.
         
         Migrates a classic SQL dashboard to Lakeview.
@@ -1770,6 +1783,9 @@ class LakeviewAPI:
           Display name for the new Lakeview dashboard.
         :param parent_path: str (optional)
           The workspace path of the folder to contain the migrated Lakeview dashboard.
+        :param update_parameter_syntax: bool (optional)
+          Flag to indicate if mustache parameter syntax ({{ param }}) should be auto-updated to named syntax
+          (:param) when converting datasets in the dashboard.
         
         :returns: :class:`Dashboard`
         """
@@ -1777,6 +1793,7 @@ class LakeviewAPI:
         if display_name is not None: body['display_name'] = display_name
         if parent_path is not None: body['parent_path'] = parent_path
         if source_dashboard_id is not None: body['source_dashboard_id'] = source_dashboard_id
+        if update_parameter_syntax is not None: body['update_parameter_syntax'] = update_parameter_syntax
         headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
 
         res = self._api.do('POST', '/api/2.0/lakeview/dashboards/migrate', body=body, headers=headers)

databricks/sdk/service/files.py

@@ -925,9 +925,12 @@ class FilesAPI:
     /Volumes/<catalog_name>/<schema_name>/<volume_name>/<path_to_file>.
     
     The Files API has two distinct endpoints, one for working with files (`/fs/files`) and another one for
-    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.
+    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`.
     
     [Unity Catalog volumes]: https://docs.databricks.com/en/connect/unity-catalog/volumes.html"""
 

databricks/sdk/service/iam.py

@@ -106,6 +106,58 @@ class AccessControlResponse:
                    user_name=d.get('user_name', None))
 
 
+@dataclass
+class Actor:
+    """represents an identity trying to access a resource - user or a service principal group can be a
+    principal of a permission set assignment but an actor is always a user or a service principal"""
+
+    actor_id: Optional[int] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the Actor into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.actor_id is not None: body['actor_id'] = self.actor_id
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the Actor into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.actor_id is not None: body['actor_id'] = self.actor_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> Actor:
+        """Deserializes the Actor from a dictionary."""
+        return cls(actor_id=d.get('actor_id', None))
+
+
+@dataclass
+class CheckPolicyResponse:
+    consistency_token: ConsistencyToken
+
+    is_permitted: Optional[bool] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the CheckPolicyResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.consistency_token: body['consistency_token'] = self.consistency_token.as_dict()
+        if self.is_permitted is not None: body['is_permitted'] = self.is_permitted
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CheckPolicyResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.consistency_token: body['consistency_token'] = self.consistency_token
+        if self.is_permitted is not None: body['is_permitted'] = self.is_permitted
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> CheckPolicyResponse:
+        """Deserializes the CheckPolicyResponse from a dictionary."""
+        return cls(consistency_token=_from_dict(d, 'consistency_token', ConsistencyToken),
+                   is_permitted=d.get('is_permitted', None))
+
+
 @dataclass
 class ComplexValue:
     display: Optional[str] = None
@@ -148,6 +200,28 @@ class ComplexValue:
                    value=d.get('value', None))
 
 
+@dataclass
+class ConsistencyToken:
+    value: str
+
+    def as_dict(self) -> dict:
+        """Serializes the ConsistencyToken into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.value is not None: body['value'] = self.value
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ConsistencyToken into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.value is not None: body['value'] = self.value
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> ConsistencyToken:
+        """Deserializes the ConsistencyToken from a dictionary."""
+        return cls(value=d.get('value', None))
+
+
 @dataclass
 class DeleteResponse:
 
@@ -1219,6 +1293,49 @@ class PrincipalOutput:
                    user_name=d.get('user_name', None))
 
 
+class RequestAuthzIdentity(Enum):
+    """Defines the identity to be used for authZ of the request on the server side. See one pager for
+    for more information: http://go/acl/service-identity"""
+
+    REQUEST_AUTHZ_IDENTITY_SERVICE_IDENTITY = 'REQUEST_AUTHZ_IDENTITY_SERVICE_IDENTITY'
+    REQUEST_AUTHZ_IDENTITY_USER_CONTEXT = 'REQUEST_AUTHZ_IDENTITY_USER_CONTEXT'
+
+
+@dataclass
+class ResourceInfo:
+    id: str
+    """Id of the current resource."""
+
+    legacy_acl_path: Optional[str] = None
+    """The legacy acl path of the current resource."""
+
+    parent_resource_info: Optional[ResourceInfo] = None
+    """Parent resource info for the current resource. The parent may have another parent."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ResourceInfo into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.id is not None: body['id'] = self.id
+        if self.legacy_acl_path is not None: body['legacy_acl_path'] = self.legacy_acl_path
+        if self.parent_resource_info: body['parent_resource_info'] = self.parent_resource_info.as_dict()
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ResourceInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.id is not None: body['id'] = self.id
+        if self.legacy_acl_path is not None: body['legacy_acl_path'] = self.legacy_acl_path
+        if self.parent_resource_info: body['parent_resource_info'] = self.parent_resource_info
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> ResourceInfo:
+        """Deserializes the ResourceInfo from a dictionary."""
+        return cls(id=d.get('id', None),
+                   legacy_acl_path=d.get('legacy_acl_path', None),
+                   parent_resource_info=_from_dict(d, 'parent_resource_info', ResourceInfo))
+
+
 @dataclass
 class ResourceMeta:
     resource_type: Optional[str] = None
@@ -1622,6 +1739,47 @@ class WorkspacePermissions:
         return cls(permissions=_repeated_dict(d, 'permissions', PermissionOutput))
 
 
+class AccessControlAPI:
+    """Rule based Access Control for Databricks Resources."""
+
+    def __init__(self, api_client):
+        self._api = api_client
+
+    def check_policy(self,
+                     actor: Actor,
+                     permission: str,
+                     resource: str,
+                     consistency_token: ConsistencyToken,
+                     authz_identity: RequestAuthzIdentity,
+                     *,
+                     resource_info: Optional[ResourceInfo] = None) -> CheckPolicyResponse:
+        """Check access policy to a resource.
+        
+        :param actor: :class:`Actor`
+        :param permission: str
+        :param resource: str
+          Ex: (servicePrincipal/use, accounts/<account-id>/servicePrincipals/<sp-id>) Ex:
+          (servicePrincipal.ruleSet/update, accounts/<account-id>/servicePrincipals/<sp-id>/ruleSets/default)
+        :param consistency_token: :class:`ConsistencyToken`
+        :param authz_identity: :class:`RequestAuthzIdentity`
+        :param resource_info: :class:`ResourceInfo` (optional)
+        
+        :returns: :class:`CheckPolicyResponse`
+        """
+
+        query = {}
+        if actor is not None: query['actor'] = actor.as_dict()
+        if authz_identity is not None: query['authz_identity'] = authz_identity.value
+        if consistency_token is not None: query['consistency_token'] = consistency_token.as_dict()
+        if permission is not None: query['permission'] = permission
+        if resource is not None: query['resource'] = resource
+        if resource_info is not None: query['resource_info'] = resource_info.as_dict()
+        headers = {'Accept': 'application/json', }
+
+        res = self._api.do('GET', '/api/2.0/access-control/check-policy-v2', query=query, headers=headers)
+        return CheckPolicyResponse.from_dict(res)
+
+
 class AccountAccessControlAPI:
     """These APIs manage access rules on resources in an account. Currently, only grant rules are supported. A
     grant rule specifies a role assigned to a set of principals. A list of rules attached to a resource is