databricks-sdk 0.57.0__py3-none-any.whl → 0.59.0__py3-none-any.whl

databricks/sdk/service/dashboards.py

@@ -253,42 +253,6 @@ class DashboardView(Enum):
     DASHBOARD_VIEW_BASIC = "DASHBOARD_VIEW_BASIC"
 
 
-@dataclass
-class DeleteScheduleResponse:
-    def as_dict(self) -> dict:
-        """Serializes the DeleteScheduleResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DeleteScheduleResponse into a shallow dictionary of its immediate attributes."""
-        body = {}
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DeleteScheduleResponse:
-        """Deserializes the DeleteScheduleResponse from a dictionary."""
-        return cls()
-
-
-@dataclass
-class DeleteSubscriptionResponse:
-    def as_dict(self) -> dict:
-        """Serializes the DeleteSubscriptionResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DeleteSubscriptionResponse into a shallow dictionary of its immediate attributes."""
-        body = {}
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DeleteSubscriptionResponse:
-        """Deserializes the DeleteSubscriptionResponse from a dictionary."""
-        return cls()
-
-
 @dataclass
 class GenieAttachment:
     """Genie AI Response"""
@@ -410,123 +374,104 @@ class GenieConversation:
 
 
 @dataclass
-class GenieCreateConversationMessageRequest:
-    content: str
-    """User message content."""
+class GenieConversationSummary:
+    conversation_id: str
 
-    conversation_id: Optional[str] = None
-    """The ID associated with the conversation."""
+    title: str
 
-    space_id: Optional[str] = None
-    """The ID associated with the Genie space where the conversation is started."""
+    created_timestamp: int
 
     def as_dict(self) -> dict:
-        """Serializes the GenieCreateConversationMessageRequest into a dictionary suitable for use as a JSON request body."""
+        """Serializes the GenieConversationSummary into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.content is not None:
-            body["content"] = self.content
         if self.conversation_id is not None:
             body["conversation_id"] = self.conversation_id
-        if self.space_id is not None:
-            body["space_id"] = self.space_id
+        if self.created_timestamp is not None:
+            body["created_timestamp"] = self.created_timestamp
+        if self.title is not None:
+            body["title"] = self.title
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the GenieCreateConversationMessageRequest into a shallow dictionary of its immediate attributes."""
+        """Serializes the GenieConversationSummary into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.content is not None:
-            body["content"] = self.content
         if self.conversation_id is not None:
             body["conversation_id"] = self.conversation_id
-        if self.space_id is not None:
-            body["space_id"] = self.space_id
+        if self.created_timestamp is not None:
+            body["created_timestamp"] = self.created_timestamp
+        if self.title is not None:
+            body["title"] = self.title
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> GenieCreateConversationMessageRequest:
-        """Deserializes the GenieCreateConversationMessageRequest from a dictionary."""
+    def from_dict(cls, d: Dict[str, Any]) -> GenieConversationSummary:
+        """Deserializes the GenieConversationSummary from a dictionary."""
         return cls(
-            content=d.get("content", None),
             conversation_id=d.get("conversation_id", None),
-            space_id=d.get("space_id", None),
+            created_timestamp=d.get("created_timestamp", None),
+            title=d.get("title", None),
         )
 
 
 @dataclass
-class GenieGenerateDownloadFullQueryResultResponse:
-    download_id: Optional[str] = None
-    """Download ID. Use this ID to track the download request in subsequent polling calls"""
-
-    def as_dict(self) -> dict:
-        """Serializes the GenieGenerateDownloadFullQueryResultResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.download_id is not None:
-            body["download_id"] = self.download_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the GenieGenerateDownloadFullQueryResultResponse into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.download_id is not None:
-            body["download_id"] = self.download_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> GenieGenerateDownloadFullQueryResultResponse:
-        """Deserializes the GenieGenerateDownloadFullQueryResultResponse from a dictionary."""
-        return cls(download_id=d.get("download_id", None))
-
-
-@dataclass
-class GenieGetDownloadFullQueryResultResponse:
+class GenieGetMessageQueryResultResponse:
     statement_response: Optional[sql.StatementResponse] = None
     """SQL Statement Execution response. See [Get status, manifest, and result first
     chunk](:method:statementexecution/getstatement) for more details."""
 
     def as_dict(self) -> dict:
-        """Serializes the GenieGetDownloadFullQueryResultResponse into a dictionary suitable for use as a JSON request body."""
+        """Serializes the GenieGetMessageQueryResultResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.statement_response:
             body["statement_response"] = self.statement_response.as_dict()
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the GenieGetDownloadFullQueryResultResponse into a shallow dictionary of its immediate attributes."""
+        """Serializes the GenieGetMessageQueryResultResponse into a shallow dictionary of its immediate attributes."""
         body = {}
         if self.statement_response:
             body["statement_response"] = self.statement_response
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> GenieGetDownloadFullQueryResultResponse:
-        """Deserializes the GenieGetDownloadFullQueryResultResponse from a dictionary."""
+    def from_dict(cls, d: Dict[str, Any]) -> GenieGetMessageQueryResultResponse:
+        """Deserializes the GenieGetMessageQueryResultResponse from a dictionary."""
         return cls(statement_response=_from_dict(d, "statement_response", sql.StatementResponse))
 
 
 @dataclass
-class GenieGetMessageQueryResultResponse:
-    statement_response: Optional[sql.StatementResponse] = None
-    """SQL Statement Execution response. See [Get status, manifest, and result first
-    chunk](:method:statementexecution/getstatement) for more details."""
+class GenieListConversationsResponse:
+    conversations: Optional[List[GenieConversationSummary]] = None
+    """List of conversations in the Genie space"""
+
+    next_page_token: Optional[str] = None
+    """Token to get the next page of results"""
 
     def as_dict(self) -> dict:
-        """Serializes the GenieGetMessageQueryResultResponse into a dictionary suitable for use as a JSON request body."""
+        """Serializes the GenieListConversationsResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.statement_response:
-            body["statement_response"] = self.statement_response.as_dict()
+        if self.conversations:
+            body["conversations"] = [v.as_dict() for v in self.conversations]
+        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 GenieGetMessageQueryResultResponse into a shallow dictionary of its immediate attributes."""
+        """Serializes the GenieListConversationsResponse into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.statement_response:
-            body["statement_response"] = self.statement_response
+        if self.conversations:
+            body["conversations"] = self.conversations
+        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]) -> GenieGetMessageQueryResultResponse:
-        """Deserializes the GenieGetMessageQueryResultResponse from a dictionary."""
-        return cls(statement_response=_from_dict(d, "statement_response", sql.StatementResponse))
+    def from_dict(cls, d: Dict[str, Any]) -> GenieListConversationsResponse:
+        """Deserializes the GenieListConversationsResponse from a dictionary."""
+        return cls(
+            conversations=_repeated_dict(d, "conversations", GenieConversationSummary),
+            next_page_token=d.get("next_page_token", None),
+        )
 
 
 @dataclass
@@ -595,20 +540,6 @@ class GenieMessage:
     `query_result_metadata` in `GenieQueryAttachment` instead."""
 
     status: Optional[MessageStatus] = None
-    """MessageStatus. 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 user's question. * `PENDING_WAREHOUSE`:
-    Waiting for warehouse before the SQL query can start executing. * `EXECUTING_QUERY`: Executing a
-    generated SQL query. Get the SQL query result by calling
-    [getMessageAttachmentQueryResult](:method:genie/getMessageAttachmentQueryResult) API. *
-    `FAILED`: The response generation or query execution failed. See `error` field. * `COMPLETED`:
-    Message processing is completed. Results are in the `attachments` field. Get the SQL query
-    result by calling
-    [getMessageAttachmentQueryResult](:method:genie/getMessageAttachmentQueryResult) API. *
-    `SUBMITTED`: Message has been submitted. * `QUERY_RESULT_EXPIRED`: SQL result is not available
-    anymore. The user needs to rerun the query. Rerun the SQL query result by calling
-    [executeMessageAttachmentQuery](:method:genie/executeMessageAttachmentQuery) API. * `CANCELLED`:
-    Message has been cancelled."""
 
     user_id: Optional[int] = None
     """ID of the user who created the message"""
@@ -836,38 +767,6 @@ class GenieSpace:
         return cls(description=d.get("description", None), space_id=d.get("space_id", None), title=d.get("title", None))
 
 
-@dataclass
-class GenieStartConversationMessageRequest:
-    content: str
-    """The text of the message that starts the conversation."""
-
-    space_id: Optional[str] = None
-    """The ID associated with the Genie space where you want to start a conversation."""
-
-    def as_dict(self) -> dict:
-        """Serializes the GenieStartConversationMessageRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.content is not None:
-            body["content"] = self.content
-        if self.space_id is not None:
-            body["space_id"] = self.space_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the GenieStartConversationMessageRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.content is not None:
-            body["content"] = self.content
-        if self.space_id is not None:
-            body["space_id"] = self.space_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> GenieStartConversationMessageRequest:
-        """Deserializes the GenieStartConversationMessageRequest from a dictionary."""
-        return cls(content=d.get("content", None), space_id=d.get("space_id", None))
-
-
 @dataclass
 class GenieStartConversationResponse:
     message_id: str
@@ -1185,102 +1084,6 @@ class MessageStatus(Enum):
     SUBMITTED = "SUBMITTED"
 
 
-@dataclass
-class MigrateDashboardRequest:
-    source_dashboard_id: str
-    """UUID of the dashboard to be migrated."""
-
-    display_name: Optional[str] = None
-    """Display name for the new Lakeview dashboard."""
-
-    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:
-        """Serializes the MigrateDashboardRequest into a shallow dictionary of its immediate attributes."""
-        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
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> 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),
-            update_parameter_syntax=d.get("update_parameter_syntax", None),
-        )
-
-
-@dataclass
-class PublishRequest:
-    dashboard_id: Optional[str] = None
-    """UUID identifying the dashboard to be published."""
-
-    embed_credentials: Optional[bool] = None
-    """Flag to indicate if the publisher's credentials should be embedded in the published dashboard.
-    These embedded credentials will be used to execute the published dashboard's queries."""
-
-    warehouse_id: Optional[str] = None
-    """The ID of the warehouse that can be used to override the warehouse which was set in the draft."""
-
-    def as_dict(self) -> dict:
-        """Serializes the PublishRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.dashboard_id is not None:
-            body["dashboard_id"] = self.dashboard_id
-        if self.embed_credentials is not None:
-            body["embed_credentials"] = self.embed_credentials
-        if self.warehouse_id is not None:
-            body["warehouse_id"] = self.warehouse_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the PublishRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.dashboard_id is not None:
-            body["dashboard_id"] = self.dashboard_id
-        if self.embed_credentials is not None:
-            body["embed_credentials"] = self.embed_credentials
-        if self.warehouse_id is not None:
-            body["warehouse_id"] = self.warehouse_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> PublishRequest:
-        """Deserializes the PublishRequest from a dictionary."""
-        return cls(
-            dashboard_id=d.get("dashboard_id", None),
-            embed_credentials=d.get("embed_credentials", None),
-            warehouse_id=d.get("warehouse_id", None),
-        )
-
-
 @dataclass
 class PublishedDashboard:
     display_name: Optional[str] = None
@@ -1801,6 +1604,23 @@ class GenieAPI:
             timeout=timeout
         )
 
+    def delete_conversation(self, space_id: str, conversation_id: str):
+        """Delete a conversation.
+
+        :param space_id: str
+          The ID associated with the Genie space where the conversation is located.
+        :param conversation_id: str
+          The ID of the conversation to delete.
+
+
+        """
+
+        headers = {
+            "Accept": "application/json",
+        }
+
+        self._api.do("DELETE", f"/api/2.0/genie/spaces/{space_id}/conversations/{conversation_id}", headers=headers)
+
     def execute_message_attachment_query(
         self, space_id: str, conversation_id: str, message_id: str, attachment_id: str
     ) -> GenieGetMessageQueryResultResponse:
@@ -1856,75 +1676,6 @@ class GenieAPI:
         )
         return GenieGetMessageQueryResultResponse.from_dict(res)
 
-    def generate_download_full_query_result(
-        self, space_id: str, conversation_id: str, message_id: str, attachment_id: str
-    ) -> GenieGenerateDownloadFullQueryResultResponse:
-        """Initiates a new SQL execution and returns a `download_id` that you can use to track the progress of
-        the download. The query result is stored in an external link and can be retrieved using the [Get
-        Download Full Query Result](:method:genie/getdownloadfullqueryresult) API. Warning: Databricks
-        strongly recommends that you protect the URLs that are returned by the `EXTERNAL_LINKS` disposition.
-        See [Execute Statement](:method:statementexecution/executestatement) for more details.
-
-        :param space_id: str
-          Genie space ID
-        :param conversation_id: str
-          Conversation ID
-        :param message_id: str
-          Message ID
-        :param attachment_id: str
-          Attachment ID
-
-        :returns: :class:`GenieGenerateDownloadFullQueryResultResponse`
-        """
-
-        headers = {
-            "Accept": "application/json",
-        }
-
-        res = self._api.do(
-            "POST",
-            f"/api/2.0/genie/spaces/{space_id}/conversations/{conversation_id}/messages/{message_id}/attachments/{attachment_id}/downloads",
-            headers=headers,
-        )
-        return GenieGenerateDownloadFullQueryResultResponse.from_dict(res)
-
-    def get_download_full_query_result(
-        self, space_id: str, conversation_id: str, message_id: str, attachment_id: str, download_id: str
-    ) -> GenieGetDownloadFullQueryResultResponse:
-        """After [Generating a Full Query Result Download](:method:genie/getdownloadfullqueryresult) and
-        successfully receiving a `download_id`, use this API to poll the download progress. When the download
-        is complete, the API returns one or more external links to the query result files. Warning: Databricks
-        strongly recommends that you protect the URLs that are returned by the `EXTERNAL_LINKS` disposition.
-        You must not set an Authorization header in download requests. When using the `EXTERNAL_LINKS`
-        disposition, Databricks returns presigned URLs that grant temporary access to data. See [Execute
-        Statement](:method:statementexecution/executestatement) for more details.
-
-        :param space_id: str
-          Genie space ID
-        :param conversation_id: str
-          Conversation ID
-        :param message_id: str
-          Message ID
-        :param attachment_id: str
-          Attachment ID
-        :param download_id: str
-          Download ID. This ID is provided by the [Generate Download
-          endpoint](:method:genie/generateDownloadFullQueryResult)
-
-        :returns: :class:`GenieGetDownloadFullQueryResultResponse`
-        """
-
-        headers = {
-            "Accept": "application/json",
-        }
-
-        res = self._api.do(
-            "GET",
-            f"/api/2.0/genie/spaces/{space_id}/conversations/{conversation_id}/messages/{message_id}/attachments/{attachment_id}/downloads/{download_id}",
-            headers=headers,
-        )
-        return GenieGetDownloadFullQueryResultResponse.from_dict(res)
-
     def get_message(self, space_id: str, conversation_id: str, message_id: str) -> GenieMessage:
         """Get message from conversation.
 
@@ -2050,6 +1801,33 @@ class GenieAPI:
         res = self._api.do("GET", f"/api/2.0/genie/spaces/{space_id}", headers=headers)
         return GenieSpace.from_dict(res)
 
+    def list_conversations(
+        self, space_id: str, *, page_size: Optional[int] = None, page_token: Optional[str] = None
+    ) -> GenieListConversationsResponse:
+        """Get a list of conversations in a Genie Space.
+
+        :param space_id: str
+          The ID of the Genie space to retrieve conversations from.
+        :param page_size: int (optional)
+          Maximum number of conversations to return per page
+        :param page_token: str (optional)
+          Token to get the next page of results
+
+        :returns: :class:`GenieListConversationsResponse`
+        """
+
+        query = {}
+        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",
+        }
+
+        res = self._api.do("GET", f"/api/2.0/genie/spaces/{space_id}/conversations", query=query, headers=headers)
+        return GenieListConversationsResponse.from_dict(res)
+
     def list_spaces(
         self, *, page_size: Optional[int] = None, page_token: Optional[str] = None
     ) -> GenieListSpacesResponse:
@@ -2109,6 +1887,21 @@ class GenieAPI:
     def start_conversation_and_wait(self, space_id: str, content: str, timeout=timedelta(minutes=20)) -> GenieMessage:
         return self.start_conversation(content=content, space_id=space_id).result(timeout=timeout)
 
+    def trash_space(self, space_id: str):
+        """Move a Genie Space to the trash.
+
+        :param space_id: str
+          The ID associated with the Genie space to be sent to the trash.
+
+
+        """
+
+        headers = {
+            "Accept": "application/json",
+        }
+
+        self._api.do("DELETE", f"/api/2.0/genie/spaces/{space_id}", headers=headers)
+
 
 class LakeviewAPI:
     """These APIs provide specific management operations for Lakeview dashboards. Generic resource management can
@@ -2139,6 +1932,7 @@ class LakeviewAPI:
         :param dashboard_id: str
           UUID identifying the dashboard to which the schedule belongs.
         :param schedule: :class:`Schedule`
+          The schedule to create. A dashboard is limited to 10 schedules.
 
         :returns: :class:`Schedule`
         """
@@ -2159,6 +1953,7 @@ class LakeviewAPI:
         :param schedule_id: str
           UUID identifying the schedule to which the subscription belongs.
         :param subscription: :class:`Subscription`
+          The subscription to create. A schedule is limited to 100 subscriptions.
 
         :returns: :class:`Subscription`
         """
@@ -2558,6 +2353,7 @@ class LakeviewAPI:
         :param schedule_id: str
           UUID identifying the schedule.
         :param schedule: :class:`Schedule`
+          The schedule to update.
 
         :returns: :class:`Schedule`
         """
@@ -2582,12 +2378,7 @@ class LakeviewEmbeddedAPI:
     def get_published_dashboard_token_info(
         self, dashboard_id: str, *, external_value: Optional[str] = None, external_viewer_id: Optional[str] = None
     ) -> GetPublishedDashboardTokenInfoResponse:
-        """Get a required authorization details and scopes of a published dashboard to mint an OAuth token. The
-        `authorization_details` can be enriched to apply additional restriction.
-
-        Example: Adding the following `authorization_details` object to downscope the viewer permission to
-        specific table ``` { type: "unity_catalog_privileges", privileges: ["SELECT"], object_type: "TABLE",
-        object_full_path: "main.default.testdata" } ```
+        """Get a required authorization details and scopes of a published dashboard to mint an OAuth token.
 
         :param dashboard_id: str
           UUID identifying the published dashboard.