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

databricks/sdk/service/dashboards.py

@@ -102,76 +102,6 @@ class AuthorizationDetailsGrantRule:
         return cls(permission_set=d.get("permission_set", None))
 
 
-@dataclass
-class CancelQueryExecutionResponse:
-    status: Optional[List[CancelQueryExecutionResponseStatus]] = None
-
-    def as_dict(self) -> dict:
-        """Serializes the CancelQueryExecutionResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.status:
-            body["status"] = [v.as_dict() for v in self.status]
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CancelQueryExecutionResponse into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.status:
-            body["status"] = self.status
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CancelQueryExecutionResponse:
-        """Deserializes the CancelQueryExecutionResponse from a dictionary."""
-        return cls(status=_repeated_dict(d, "status", CancelQueryExecutionResponseStatus))
-
-
-@dataclass
-class CancelQueryExecutionResponseStatus:
-    data_token: str
-    """The token to poll for result asynchronously Example:
-    EC0A..ChAB7WCEn_4Qo4vkLqEbXsxxEgh3Y2pbWw45WhoQXgZSQo9aS5q2ZvFcbvbx9CgA-PAEAQ"""
-
-    pending: Optional[Empty] = None
-    """Represents an empty message, similar to google.protobuf.Empty, which is not available in the
-    firm right now."""
-
-    success: Optional[Empty] = None
-    """Represents an empty message, similar to google.protobuf.Empty, which is not available in the
-    firm right now."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CancelQueryExecutionResponseStatus into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.data_token is not None:
-            body["data_token"] = self.data_token
-        if self.pending:
-            body["pending"] = self.pending.as_dict()
-        if self.success:
-            body["success"] = self.success.as_dict()
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CancelQueryExecutionResponseStatus into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.data_token is not None:
-            body["data_token"] = self.data_token
-        if self.pending:
-            body["pending"] = self.pending
-        if self.success:
-            body["success"] = self.success
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CancelQueryExecutionResponseStatus:
-        """Deserializes the CancelQueryExecutionResponseStatus from a dictionary."""
-        return cls(
-            data_token=d.get("data_token", None),
-            pending=_from_dict(d, "pending", Empty),
-            success=_from_dict(d, "success", Empty),
-        )
-
-
 @dataclass
 class CronSchedule:
     quartz_cron_expression: str
@@ -359,94 +289,6 @@ class DeleteSubscriptionResponse:
         return cls()
 
 
-@dataclass
-class Empty:
-    """Represents an empty message, similar to google.protobuf.Empty, which is not available in the
-    firm right now."""
-
-    def as_dict(self) -> dict:
-        """Serializes the Empty into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the Empty into a shallow dictionary of its immediate attributes."""
-        body = {}
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> Empty:
-        """Deserializes the Empty from a dictionary."""
-        return cls()
-
-
-@dataclass
-class ExecutePublishedDashboardQueryRequest:
-    """Execute query request for published Dashboards. Since published dashboards have the option of
-    running as the publisher, the datasets, warehouse_id are excluded from the request and instead
-    read from the source (lakeview-config) via the additional parameters (dashboardName and
-    dashboardRevisionId)"""
-
-    dashboard_name: str
-    """Dashboard name and revision_id is required to retrieve PublishedDatasetDataModel which contains
-    the list of datasets, warehouse_id, and embedded_credentials"""
-
-    dashboard_revision_id: str
-
-    override_warehouse_id: Optional[str] = None
-    """A dashboard schedule can override the warehouse used as compute for processing the published
-    dashboard queries"""
-
-    def as_dict(self) -> dict:
-        """Serializes the ExecutePublishedDashboardQueryRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.dashboard_name is not None:
-            body["dashboard_name"] = self.dashboard_name
-        if self.dashboard_revision_id is not None:
-            body["dashboard_revision_id"] = self.dashboard_revision_id
-        if self.override_warehouse_id is not None:
-            body["override_warehouse_id"] = self.override_warehouse_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the ExecutePublishedDashboardQueryRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.dashboard_name is not None:
-            body["dashboard_name"] = self.dashboard_name
-        if self.dashboard_revision_id is not None:
-            body["dashboard_revision_id"] = self.dashboard_revision_id
-        if self.override_warehouse_id is not None:
-            body["override_warehouse_id"] = self.override_warehouse_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> ExecutePublishedDashboardQueryRequest:
-        """Deserializes the ExecutePublishedDashboardQueryRequest from a dictionary."""
-        return cls(
-            dashboard_name=d.get("dashboard_name", None),
-            dashboard_revision_id=d.get("dashboard_revision_id", None),
-            override_warehouse_id=d.get("override_warehouse_id", None),
-        )
-
-
-@dataclass
-class ExecuteQueryResponse:
-    def as_dict(self) -> dict:
-        """Serializes the ExecuteQueryResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the ExecuteQueryResponse into a shallow dictionary of its immediate attributes."""
-        body = {}
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> ExecuteQueryResponse:
-        """Deserializes the ExecuteQueryResponse from a dictionary."""
-        return cls()
-
-
 @dataclass
 class GenieAttachment:
     """Genie AI Response"""
@@ -687,6 +529,38 @@ class GenieGetMessageQueryResultResponse:
         return cls(statement_response=_from_dict(d, "statement_response", sql.StatementResponse))
 
 
+@dataclass
+class GenieListSpacesResponse:
+    next_page_token: Optional[str] = None
+    """Token to get the next page of results"""
+
+    spaces: Optional[List[GenieSpace]] = None
+    """List of Genie spaces"""
+
+    def as_dict(self) -> dict:
+        """Serializes the GenieListSpacesResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        if self.spaces:
+            body["spaces"] = [v.as_dict() for v in self.spaces]
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GenieListSpacesResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        if self.spaces:
+            body["spaces"] = self.spaces
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> GenieListSpacesResponse:
+        """Deserializes the GenieListSpacesResponse from a dictionary."""
+        return cls(next_page_token=d.get("next_page_token", None), spaces=_repeated_dict(d, "spaces", GenieSpace))
+
+
 @dataclass
 class GenieMessage:
     id: str
@@ -1043,24 +917,6 @@ class GenieStartConversationResponse:
         )
 
 
-@dataclass
-class GetPublishedDashboardEmbeddedResponse:
-    def as_dict(self) -> dict:
-        """Serializes the GetPublishedDashboardEmbeddedResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the GetPublishedDashboardEmbeddedResponse into a shallow dictionary of its immediate attributes."""
-        body = {}
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> GetPublishedDashboardEmbeddedResponse:
-        """Deserializes the GetPublishedDashboardEmbeddedResponse from a dictionary."""
-        return cls()
-
-
 @dataclass
 class GetPublishedDashboardTokenInfoResponse:
     authorization_details: Optional[List[AuthorizationDetails]] = None
@@ -1381,80 +1237,6 @@ class MigrateDashboardRequest:
         )
 
 
-@dataclass
-class PendingStatus:
-    data_token: str
-    """The token to poll for result asynchronously Example:
-    EC0A..ChAB7WCEn_4Qo4vkLqEbXsxxEgh3Y2pbWw45WhoQXgZSQo9aS5q2ZvFcbvbx9CgA-PAEAQ"""
-
-    def as_dict(self) -> dict:
-        """Serializes the PendingStatus into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.data_token is not None:
-            body["data_token"] = self.data_token
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the PendingStatus into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.data_token is not None:
-            body["data_token"] = self.data_token
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> PendingStatus:
-        """Deserializes the PendingStatus from a dictionary."""
-        return cls(data_token=d.get("data_token", None))
-
-
-@dataclass
-class PollQueryStatusResponse:
-    data: Optional[List[PollQueryStatusResponseData]] = None
-
-    def as_dict(self) -> dict:
-        """Serializes the PollQueryStatusResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.data:
-            body["data"] = [v.as_dict() for v in self.data]
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the PollQueryStatusResponse into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.data:
-            body["data"] = self.data
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> PollQueryStatusResponse:
-        """Deserializes the PollQueryStatusResponse from a dictionary."""
-        return cls(data=_repeated_dict(d, "data", PollQueryStatusResponseData))
-
-
-@dataclass
-class PollQueryStatusResponseData:
-    status: QueryResponseStatus
-
-    def as_dict(self) -> dict:
-        """Serializes the PollQueryStatusResponseData into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.status:
-            body["status"] = self.status.as_dict()
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the PollQueryStatusResponseData into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.status:
-            body["status"] = self.status
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> PollQueryStatusResponseData:
-        """Deserializes the PollQueryStatusResponseData from a dictionary."""
-        return cls(status=_from_dict(d, "status", QueryResponseStatus))
-
-
 @dataclass
 class PublishRequest:
     dashboard_id: Optional[str] = None
@@ -1550,67 +1332,6 @@ class PublishedDashboard:
         )
 
 
-@dataclass
-class QueryResponseStatus:
-    canceled: Optional[Empty] = None
-    """Represents an empty message, similar to google.protobuf.Empty, which is not available in the
-    firm right now."""
-
-    closed: Optional[Empty] = None
-    """Represents an empty message, similar to google.protobuf.Empty, which is not available in the
-    firm right now."""
-
-    pending: Optional[PendingStatus] = None
-
-    statement_id: Optional[str] = None
-    """The statement id in format(01eef5da-c56e-1f36-bafa-21906587d6ba) The statement_id should be
-    identical to data_token in SuccessStatus and PendingStatus. This field is created for audit
-    logging purpose to record the statement_id of all QueryResponseStatus."""
-
-    success: Optional[SuccessStatus] = None
-
-    def as_dict(self) -> dict:
-        """Serializes the QueryResponseStatus into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.canceled:
-            body["canceled"] = self.canceled.as_dict()
-        if self.closed:
-            body["closed"] = self.closed.as_dict()
-        if self.pending:
-            body["pending"] = self.pending.as_dict()
-        if self.statement_id is not None:
-            body["statement_id"] = self.statement_id
-        if self.success:
-            body["success"] = self.success.as_dict()
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the QueryResponseStatus into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.canceled:
-            body["canceled"] = self.canceled
-        if self.closed:
-            body["closed"] = self.closed
-        if self.pending:
-            body["pending"] = self.pending
-        if self.statement_id is not None:
-            body["statement_id"] = self.statement_id
-        if self.success:
-            body["success"] = self.success
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> QueryResponseStatus:
-        """Deserializes the QueryResponseStatus from a dictionary."""
-        return cls(
-            canceled=_from_dict(d, "canceled", Empty),
-            closed=_from_dict(d, "closed", Empty),
-            pending=_from_dict(d, "pending", PendingStatus),
-            statement_id=d.get("statement_id", None),
-            success=_from_dict(d, "success", SuccessStatus),
-        )
-
-
 @dataclass
 class Result:
     is_truncated: Optional[bool] = None
@@ -1926,39 +1647,6 @@ class SubscriptionSubscriberUser:
         return cls(user_id=d.get("user_id", None))
 
 
-@dataclass
-class SuccessStatus:
-    data_token: str
-    """The token to poll for result asynchronously Example:
-    EC0A..ChAB7WCEn_4Qo4vkLqEbXsxxEgh3Y2pbWw45WhoQXgZSQo9aS5q2ZvFcbvbx9CgA-PAEAQ"""
-
-    truncated: Optional[bool] = None
-    """Whether the query result is truncated (either by byte limit or row limit)"""
-
-    def as_dict(self) -> dict:
-        """Serializes the SuccessStatus into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.data_token is not None:
-            body["data_token"] = self.data_token
-        if self.truncated is not None:
-            body["truncated"] = self.truncated
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the SuccessStatus into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.data_token is not None:
-            body["data_token"] = self.data_token
-        if self.truncated is not None:
-            body["truncated"] = self.truncated
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> SuccessStatus:
-        """Deserializes the SuccessStatus from a dictionary."""
-        return cls(data_token=d.get("data_token", None), truncated=d.get("truncated", None))
-
-
 @dataclass
 class TextAttachment:
     content: Optional[str] = None
@@ -2070,9 +1758,7 @@ class GenieAPI:
         raise TimeoutError(f"timed out after {timeout}: {status_message}")
 
     def create_message(self, space_id: str, conversation_id: str, content: str) -> Wait[GenieMessage]:
-        """Create conversation message.
-
-        Create new message in a [conversation](:method:genie/startconversation). The AI response uses all
+        """Create new message in a [conversation](:method:genie/startconversation). The AI response uses all
         previously created messages in the conversation to respond.
 
         :param space_id: str
@@ -2118,9 +1804,7 @@ class GenieAPI:
     def execute_message_attachment_query(
         self, space_id: str, conversation_id: str, message_id: str, attachment_id: str
     ) -> GenieGetMessageQueryResultResponse:
-        """Execute message attachment SQL query.
-
-        Execute the SQL for a message query attachment. Use this API when the query attachment has expired and
+        """Execute the SQL for a message query attachment. Use this API when the query attachment has expired and
         needs to be re-executed.
 
         :param space_id: str
@@ -2149,9 +1833,7 @@ class GenieAPI:
     def execute_message_query(
         self, space_id: str, conversation_id: str, message_id: str
     ) -> GenieGetMessageQueryResultResponse:
-        """[Deprecated] Execute SQL query in a conversation message.
-
-        Execute the SQL query in the message.
+        """Execute the SQL query in the message.
 
         :param space_id: str
           Genie space ID
@@ -2177,9 +1859,7 @@ class GenieAPI:
     def generate_download_full_query_result(
         self, space_id: str, conversation_id: str, message_id: str, attachment_id: str
     ) -> GenieGenerateDownloadFullQueryResultResponse:
-        """Generate full query result download.
-
-        Initiates a new SQL execution and returns a `download_id` that you can use to track the progress of
+        """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.
@@ -2211,9 +1891,7 @@ class GenieAPI:
     def get_download_full_query_result(
         self, space_id: str, conversation_id: str, message_id: str, attachment_id: str, download_id: str
     ) -> GenieGetDownloadFullQueryResultResponse:
-        """Get download full query result.
-
-        After [Generating a Full Query Result Download](:method:genie/getdownloadfullqueryresult) and
+        """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.
@@ -2248,9 +1926,7 @@ class GenieAPI:
         return GenieGetDownloadFullQueryResultResponse.from_dict(res)
 
     def get_message(self, space_id: str, conversation_id: str, message_id: str) -> GenieMessage:
-        """Get conversation message.
-
-        Get message from conversation.
+        """Get message from conversation.
 
         :param space_id: str
           The ID associated with the Genie space where the target conversation is located.
@@ -2276,9 +1952,7 @@ class GenieAPI:
     def get_message_attachment_query_result(
         self, space_id: str, conversation_id: str, message_id: str, attachment_id: str
     ) -> GenieGetMessageQueryResultResponse:
-        """Get message attachment SQL query result.
-
-        Get the result of SQL query if the message has a query attachment. This is only available if a message
+        """Get the result of SQL query if the message has a query attachment. This is only available if a message
         has a query attachment and the message status is `EXECUTING_QUERY` OR `COMPLETED`.
 
         :param space_id: str
@@ -2307,9 +1981,7 @@ class GenieAPI:
     def get_message_query_result(
         self, space_id: str, conversation_id: str, message_id: str
     ) -> GenieGetMessageQueryResultResponse:
-        """[Deprecated] Get conversation message SQL query result.
-
-        Get the result of SQL query if the message has a query attachment. This is only available if a message
+        """Get the result of SQL query if the message has a query attachment. This is only available if a message
         has a query attachment and the message status is `EXECUTING_QUERY`.
 
         :param space_id: str
@@ -2336,9 +2008,7 @@ class GenieAPI:
     def get_message_query_result_by_attachment(
         self, space_id: str, conversation_id: str, message_id: str, attachment_id: str
     ) -> GenieGetMessageQueryResultResponse:
-        """[Deprecated] Get conversation message SQL query result.
-
-        Get the result of SQL query if the message has a query attachment. This is only available if a message
+        """Get the result of SQL query if the message has a query attachment. This is only available if a message
         has a query attachment and the message status is `EXECUTING_QUERY` OR `COMPLETED`.
 
         :param space_id: str
@@ -2365,9 +2035,7 @@ class GenieAPI:
         return GenieGetMessageQueryResultResponse.from_dict(res)
 
     def get_space(self, space_id: str) -> GenieSpace:
-        """Get Genie Space.
-
-        Get details of a Genie Space.
+        """Get details of a Genie Space.
 
         :param space_id: str
           The ID associated with the Genie space
@@ -2382,10 +2050,33 @@ class GenieAPI:
         res = self._api.do("GET", f"/api/2.0/genie/spaces/{space_id}", headers=headers)
         return GenieSpace.from_dict(res)
 
-    def start_conversation(self, space_id: str, content: str) -> Wait[GenieMessage]:
-        """Start conversation.
+    def list_spaces(
+        self, *, page_size: Optional[int] = None, page_token: Optional[str] = None
+    ) -> GenieListSpacesResponse:
+        """Get list of Genie Spaces.
 
-        Start a new conversation.
+        :param page_size: int (optional)
+          Maximum number of spaces to return per page
+        :param page_token: str (optional)
+          Pagination token for getting the next page of results
+
+        :returns: :class:`GenieListSpacesResponse`
+        """
+
+        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", "/api/2.0/genie/spaces", query=query, headers=headers)
+        return GenieListSpacesResponse.from_dict(res)
+
+    def start_conversation(self, space_id: str, content: str) -> Wait[GenieMessage]:
+        """Start a new conversation.
 
         :param space_id: str
           The ID associated with the Genie space where you want to start a conversation.
@@ -2427,9 +2118,7 @@ class LakeviewAPI:
         self._api = api_client
 
     def create(self, dashboard: Dashboard) -> Dashboard:
-        """Create dashboard.
-
-        Create a draft dashboard.
+        """Create a draft dashboard.
 
         :param dashboard: :class:`Dashboard`
 
@@ -2548,9 +2237,7 @@ class LakeviewAPI:
         )
 
     def get(self, dashboard_id: str) -> Dashboard:
-        """Get dashboard.
-
-        Get a draft dashboard.
+        """Get a draft dashboard.
 
         :param dashboard_id: str
           UUID identifying the dashboard.
@@ -2566,9 +2253,7 @@ class LakeviewAPI:
         return Dashboard.from_dict(res)
 
     def get_published(self, dashboard_id: str) -> PublishedDashboard:
-        """Get published dashboard.
-
-        Get the current published dashboard.
+        """Get the current published dashboard.
 
         :param dashboard_id: str
           UUID identifying the published dashboard.
@@ -2758,9 +2443,7 @@ class LakeviewAPI:
         parent_path: Optional[str] = None,
         update_parameter_syntax: Optional[bool] = None,
     ) -> Dashboard:
-        """Migrate dashboard.
-
-        Migrates a classic SQL dashboard to Lakeview.
+        """Migrates a classic SQL dashboard to Lakeview.
 
         :param source_dashboard_id: str
           UUID of the dashboard to be migrated.
@@ -2794,9 +2477,7 @@ class LakeviewAPI:
     def publish(
         self, dashboard_id: str, *, embed_credentials: Optional[bool] = None, warehouse_id: Optional[str] = None
     ) -> PublishedDashboard:
-        """Publish dashboard.
-
-        Publish the current draft dashboard.
+        """Publish the current draft dashboard.
 
         :param dashboard_id: str
           UUID identifying the dashboard to be published.
@@ -2822,9 +2503,7 @@ class LakeviewAPI:
         return PublishedDashboard.from_dict(res)
 
     def trash(self, dashboard_id: str):
-        """Trash dashboard.
-
-        Trash a dashboard.
+        """Trash a dashboard.
 
         :param dashboard_id: str
           UUID identifying the dashboard.
@@ -2839,9 +2518,7 @@ class LakeviewAPI:
         self._api.do("DELETE", f"/api/2.0/lakeview/dashboards/{dashboard_id}", headers=headers)
 
     def unpublish(self, dashboard_id: str):
-        """Unpublish dashboard.
-
-        Unpublish the dashboard.
+        """Unpublish the dashboard.
 
         :param dashboard_id: str
           UUID identifying the published dashboard.
@@ -2856,9 +2533,7 @@ class LakeviewAPI:
         self._api.do("DELETE", f"/api/2.0/lakeview/dashboards/{dashboard_id}/published", headers=headers)
 
     def update(self, dashboard_id: str, dashboard: Dashboard) -> Dashboard:
-        """Update dashboard.
-
-        Update a draft dashboard.
+        """Update a draft dashboard.
 
         :param dashboard_id: str
           UUID identifying the dashboard.
@@ -2904,29 +2579,10 @@ class LakeviewEmbeddedAPI:
     def __init__(self, api_client):
         self._api = api_client
 
-    def get_published_dashboard_embedded(self, dashboard_id: str):
-        """Read a published dashboard in an embedded ui.
-
-        Get the current published dashboard within an embedded context.
-
-        :param dashboard_id: str
-          UUID identifying the published dashboard.
-
-
-        """
-
-        headers = {
-            "Accept": "application/json",
-        }
-
-        self._api.do("GET", f"/api/2.0/lakeview/dashboards/{dashboard_id}/published/embedded", headers=headers)
-
     def get_published_dashboard_token_info(
         self, dashboard_id: str, *, external_value: Optional[str] = None, external_viewer_id: Optional[str] = None
     ) -> GetPublishedDashboardTokenInfoResponse:
-        """Read an information of a published dashboard to mint an OAuth token.
-
-        Get a required authorization details and scopes of a published dashboard to mint an OAuth token. The
+        """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
@@ -2956,93 +2612,3 @@ class LakeviewEmbeddedAPI:
             "GET", f"/api/2.0/lakeview/dashboards/{dashboard_id}/published/tokeninfo", query=query, headers=headers
         )
         return GetPublishedDashboardTokenInfoResponse.from_dict(res)
-
-
-class QueryExecutionAPI:
-    """Query execution APIs for AI / BI Dashboards"""
-
-    def __init__(self, api_client):
-        self._api = api_client
-
-    def cancel_published_query_execution(
-        self, dashboard_name: str, dashboard_revision_id: str, *, tokens: Optional[List[str]] = None
-    ) -> CancelQueryExecutionResponse:
-        """Cancel the results for the a query for a published, embedded dashboard.
-
-        :param dashboard_name: str
-        :param dashboard_revision_id: str
-        :param tokens: List[str] (optional)
-          Example: EC0A..ChAB7WCEn_4Qo4vkLqEbXsxxEgh3Y2pbWw45WhoQXgZSQo9aS5q2ZvFcbvbx9CgA-PAEAQ
-
-        :returns: :class:`CancelQueryExecutionResponse`
-        """
-
-        query = {}
-        if dashboard_name is not None:
-            query["dashboard_name"] = dashboard_name
-        if dashboard_revision_id is not None:
-            query["dashboard_revision_id"] = dashboard_revision_id
-        if tokens is not None:
-            query["tokens"] = [v for v in tokens]
-        headers = {
-            "Accept": "application/json",
-        }
-
-        res = self._api.do("DELETE", "/api/2.0/lakeview-query/query/published", query=query, headers=headers)
-        return CancelQueryExecutionResponse.from_dict(res)
-
-    def execute_published_dashboard_query(
-        self, dashboard_name: str, dashboard_revision_id: str, *, override_warehouse_id: Optional[str] = None
-    ):
-        """Execute a query for a published dashboard.
-
-        :param dashboard_name: str
-          Dashboard name and revision_id is required to retrieve PublishedDatasetDataModel which contains the
-          list of datasets, warehouse_id, and embedded_credentials
-        :param dashboard_revision_id: str
-        :param override_warehouse_id: str (optional)
-          A dashboard schedule can override the warehouse used as compute for processing the published
-          dashboard queries
-
-
-        """
-        body = {}
-        if dashboard_name is not None:
-            body["dashboard_name"] = dashboard_name
-        if dashboard_revision_id is not None:
-            body["dashboard_revision_id"] = dashboard_revision_id
-        if override_warehouse_id is not None:
-            body["override_warehouse_id"] = override_warehouse_id
-        headers = {
-            "Accept": "application/json",
-            "Content-Type": "application/json",
-        }
-
-        self._api.do("POST", "/api/2.0/lakeview-query/query/published", body=body, headers=headers)
-
-    def poll_published_query_status(
-        self, dashboard_name: str, dashboard_revision_id: str, *, tokens: Optional[List[str]] = None
-    ) -> PollQueryStatusResponse:
-        """Poll the results for the a query for a published, embedded dashboard.
-
-        :param dashboard_name: str
-        :param dashboard_revision_id: str
-        :param tokens: List[str] (optional)
-          Example: EC0A..ChAB7WCEn_4Qo4vkLqEbXsxxEgh3Y2pbWw45WhoQXgZSQo9aS5q2ZvFcbvbx9CgA-PAEAQ
-
-        :returns: :class:`PollQueryStatusResponse`
-        """
-
-        query = {}
-        if dashboard_name is not None:
-            query["dashboard_name"] = dashboard_name
-        if dashboard_revision_id is not None:
-            query["dashboard_revision_id"] = dashboard_revision_id
-        if tokens is not None:
-            query["tokens"] = [v for v in tokens]
-        headers = {
-            "Accept": "application/json",
-        }
-
-        res = self._api.do("GET", "/api/2.0/lakeview-query/query/published", query=query, headers=headers)
-        return PollQueryStatusResponse.from_dict(res)