databricks-sdk 0.29.0__py3-none-any.whl → 0.30.0__py3-none-any.whl

databricks/sdk/service/dashboards.py

@@ -3,14 +3,20 @@
 from __future__ import annotations
 
 import logging
+import random
+import time
 from dataclasses import dataclass
+from datetime import timedelta
 from enum import Enum
-from typing import Dict, Iterator, List, Optional
+from typing import Callable, Dict, Iterator, List, Optional
 
-from ._internal import _enum, _from_dict, _repeated_dict
+from ..errors import OperationFailed
+from ._internal import Wait, _enum, _from_dict, _repeated_dict
 
 _LOG = logging.getLogger('databricks.sdk')
 
+from databricks.sdk.service import sql
+
 # all definitions in this file are in alphabetical order
 
 
@@ -202,7 +208,6 @@ class Dashboard:
 class DashboardView(Enum):
 
     DASHBOARD_VIEW_BASIC = 'DASHBOARD_VIEW_BASIC'
-    DASHBOARD_VIEW_FULL = 'DASHBOARD_VIEW_FULL'
 
 
 @dataclass
@@ -233,6 +238,244 @@ class DeleteSubscriptionResponse:
         return cls()
 
 
+@dataclass
+class GenieAttachment:
+    """Genie AI Response"""
+
+    query: Optional[QueryAttachment] = None
+
+    text: Optional[TextAttachment] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the GenieAttachment into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.query: body['query'] = self.query.as_dict()
+        if self.text: body['text'] = self.text.as_dict()
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> GenieAttachment:
+        """Deserializes the GenieAttachment from a dictionary."""
+        return cls(query=_from_dict(d, 'query', QueryAttachment), text=_from_dict(d, 'text', TextAttachment))
+
+
+@dataclass
+class GenieConversation:
+    id: str
+    """Conversation ID"""
+
+    space_id: str
+    """Genie space ID"""
+
+    user_id: int
+    """ID of the user who created the conversation"""
+
+    title: str
+    """Conversation title"""
+
+    created_timestamp: Optional[int] = None
+    """Timestamp when the message was created"""
+
+    last_updated_timestamp: Optional[int] = None
+    """Timestamp when the message was last updated"""
+
+    def as_dict(self) -> dict:
+        """Serializes the GenieConversation into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.created_timestamp is not None: body['created_timestamp'] = self.created_timestamp
+        if self.id is not None: body['id'] = self.id
+        if self.last_updated_timestamp is not None:
+            body['last_updated_timestamp'] = self.last_updated_timestamp
+        if self.space_id is not None: body['space_id'] = self.space_id
+        if self.title is not None: body['title'] = self.title
+        if self.user_id is not None: body['user_id'] = self.user_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> GenieConversation:
+        """Deserializes the GenieConversation from a dictionary."""
+        return cls(created_timestamp=d.get('created_timestamp', None),
+                   id=d.get('id', None),
+                   last_updated_timestamp=d.get('last_updated_timestamp', None),
+                   space_id=d.get('space_id', None),
+                   title=d.get('title', None),
+                   user_id=d.get('user_id', None))
+
+
+@dataclass
+class GenieCreateConversationMessageRequest:
+    content: str
+    """User message content."""
+
+    conversation_id: Optional[str] = None
+    """The ID associated with the conversation."""
+
+    space_id: Optional[str] = None
+    """The ID associated with the Genie space where the conversation is started."""
+
+    def as_dict(self) -> dict:
+        """Serializes the GenieCreateConversationMessageRequest 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
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> GenieCreateConversationMessageRequest:
+        """Deserializes the GenieCreateConversationMessageRequest from a dictionary."""
+        return cls(content=d.get('content', None),
+                   conversation_id=d.get('conversation_id', None),
+                   space_id=d.get('space_id', None))
+
+
+@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."""
+
+    def as_dict(self) -> dict:
+        """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
+
+    @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))
+
+
+@dataclass
+class GenieMessage:
+    id: str
+    """Message ID"""
+
+    space_id: str
+    """Genie space ID"""
+
+    conversation_id: str
+    """Conversation ID"""
+
+    content: str
+    """User message content"""
+
+    attachments: Optional[List[GenieAttachment]] = None
+    """AI produced response to the message"""
+
+    created_timestamp: Optional[int] = None
+    """Timestamp when the message was created"""
+
+    error: Optional[MessageError] = None
+    """Error message if AI failed to respond to the message"""
+
+    last_updated_timestamp: Optional[int] = None
+    """Timestamp when the message was last updated"""
+
+    query_result: Optional[Result] = None
+    """The result of SQL query if the message has a query attachment"""
+
+    status: Optional[MessageStatus] = None
+    """MesssageStatus. The possible values are: * `FETCHING_METADATA`: Fetching metadata from the data
+    sources. * `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
+    [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
+    response or the executing the query failed. Please see `error` field. * `COMPLETED`: Message
+    processing is completed. Results are in the `attachments` field. Get the SQL query result by
+    calling [getMessageQueryResult](:method:genie/getMessageQueryResult) API. * `SUBMITTED`: Message
+    has been submitted. * `QUERY_RESULT_EXPIRED`: SQL result is not available anymore. The user
+    needs to execute the query again. * `CANCELLED`: Message has been cancelled."""
+
+    user_id: Optional[int] = None
+    """ID of the user who created the message"""
+
+    def as_dict(self) -> dict:
+        """Serializes the GenieMessage into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.attachments: body['attachments'] = [v.as_dict() for v in self.attachments]
+        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.created_timestamp is not None: body['created_timestamp'] = self.created_timestamp
+        if self.error: body['error'] = self.error.as_dict()
+        if self.id is not None: body['id'] = self.id
+        if self.last_updated_timestamp is not None:
+            body['last_updated_timestamp'] = self.last_updated_timestamp
+        if self.query_result: body['query_result'] = self.query_result.as_dict()
+        if self.space_id is not None: body['space_id'] = self.space_id
+        if self.status is not None: body['status'] = self.status.value
+        if self.user_id is not None: body['user_id'] = self.user_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> GenieMessage:
+        """Deserializes the GenieMessage from a dictionary."""
+        return cls(attachments=_repeated_dict(d, 'attachments', GenieAttachment),
+                   content=d.get('content', None),
+                   conversation_id=d.get('conversation_id', None),
+                   created_timestamp=d.get('created_timestamp', None),
+                   error=_from_dict(d, 'error', MessageError),
+                   id=d.get('id', None),
+                   last_updated_timestamp=d.get('last_updated_timestamp', None),
+                   query_result=_from_dict(d, 'query_result', Result),
+                   space_id=d.get('space_id', None),
+                   status=_enum(d, 'status', MessageStatus),
+                   user_id=d.get('user_id', 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
+
+    @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
+    """Message ID"""
+
+    conversation_id: str
+    """Conversation ID"""
+
+    conversation: Optional[GenieConversation] = None
+
+    message: Optional[GenieMessage] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the GenieStartConversationResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.conversation: body['conversation'] = self.conversation.as_dict()
+        if self.conversation_id is not None: body['conversation_id'] = self.conversation_id
+        if self.message: body['message'] = self.message.as_dict()
+        if self.message_id is not None: body['message_id'] = self.message_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> GenieStartConversationResponse:
+        """Deserializes the GenieStartConversationResponse from a dictionary."""
+        return cls(conversation=_from_dict(d, 'conversation', GenieConversation),
+                   conversation_id=d.get('conversation_id', None),
+                   message=_from_dict(d, 'message', GenieMessage),
+                   message_id=d.get('message_id', None))
+
+
 class LifecycleState(Enum):
 
     ACTIVE = 'ACTIVE'
@@ -305,6 +548,90 @@ class ListSubscriptionsResponse:
                    subscriptions=_repeated_dict(d, 'subscriptions', Subscription))
 
 
+@dataclass
+class MessageError:
+    error: Optional[str] = None
+
+    type: Optional[MessageErrorType] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the MessageError into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.error is not None: body['error'] = self.error
+        if self.type is not None: body['type'] = self.type.value
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> MessageError:
+        """Deserializes the MessageError from a dictionary."""
+        return cls(error=d.get('error', None), type=_enum(d, 'type', MessageErrorType))
+
+
+class MessageErrorType(Enum):
+
+    BLOCK_MULTIPLE_EXECUTIONS_EXCEPTION = 'BLOCK_MULTIPLE_EXECUTIONS_EXCEPTION'
+    CHAT_COMPLETION_CLIENT_EXCEPTION = 'CHAT_COMPLETION_CLIENT_EXCEPTION'
+    CHAT_COMPLETION_CLIENT_TIMEOUT_EXCEPTION = 'CHAT_COMPLETION_CLIENT_TIMEOUT_EXCEPTION'
+    CHAT_COMPLETION_NETWORK_EXCEPTION = 'CHAT_COMPLETION_NETWORK_EXCEPTION'
+    CONTENT_FILTER_EXCEPTION = 'CONTENT_FILTER_EXCEPTION'
+    CONTEXT_EXCEEDED_EXCEPTION = 'CONTEXT_EXCEEDED_EXCEPTION'
+    COULD_NOT_GET_UC_SCHEMA_EXCEPTION = 'COULD_NOT_GET_UC_SCHEMA_EXCEPTION'
+    DEPLOYMENT_NOT_FOUND_EXCEPTION = 'DEPLOYMENT_NOT_FOUND_EXCEPTION'
+    FUNCTIONS_NOT_AVAILABLE_EXCEPTION = 'FUNCTIONS_NOT_AVAILABLE_EXCEPTION'
+    FUNCTION_ARGUMENTS_INVALID_EXCEPTION = 'FUNCTION_ARGUMENTS_INVALID_EXCEPTION'
+    FUNCTION_ARGUMENTS_INVALID_JSON_EXCEPTION = 'FUNCTION_ARGUMENTS_INVALID_JSON_EXCEPTION'
+    FUNCTION_CALL_MISSING_PARAMETER_EXCEPTION = 'FUNCTION_CALL_MISSING_PARAMETER_EXCEPTION'
+    GENERIC_CHAT_COMPLETION_EXCEPTION = 'GENERIC_CHAT_COMPLETION_EXCEPTION'
+    GENERIC_CHAT_COMPLETION_SERVICE_EXCEPTION = 'GENERIC_CHAT_COMPLETION_SERVICE_EXCEPTION'
+    GENERIC_SQL_EXEC_API_CALL_EXCEPTION = 'GENERIC_SQL_EXEC_API_CALL_EXCEPTION'
+    ILLEGAL_PARAMETER_DEFINITION_EXCEPTION = 'ILLEGAL_PARAMETER_DEFINITION_EXCEPTION'
+    INVALID_CERTIFIED_ANSWER_FUNCTION_EXCEPTION = 'INVALID_CERTIFIED_ANSWER_FUNCTION_EXCEPTION'
+    INVALID_CERTIFIED_ANSWER_IDENTIFIER_EXCEPTION = 'INVALID_CERTIFIED_ANSWER_IDENTIFIER_EXCEPTION'
+    INVALID_CHAT_COMPLETION_JSON_EXCEPTION = 'INVALID_CHAT_COMPLETION_JSON_EXCEPTION'
+    INVALID_COMPLETION_REQUEST_EXCEPTION = 'INVALID_COMPLETION_REQUEST_EXCEPTION'
+    INVALID_FUNCTION_CALL_EXCEPTION = 'INVALID_FUNCTION_CALL_EXCEPTION'
+    INVALID_TABLE_IDENTIFIER_EXCEPTION = 'INVALID_TABLE_IDENTIFIER_EXCEPTION'
+    LOCAL_CONTEXT_EXCEEDED_EXCEPTION = 'LOCAL_CONTEXT_EXCEEDED_EXCEPTION'
+    MESSAGE_DELETED_WHILE_EXECUTING_EXCEPTION = 'MESSAGE_DELETED_WHILE_EXECUTING_EXCEPTION'
+    MESSAGE_UPDATED_WHILE_EXECUTING_EXCEPTION = 'MESSAGE_UPDATED_WHILE_EXECUTING_EXCEPTION'
+    NO_TABLES_TO_QUERY_EXCEPTION = 'NO_TABLES_TO_QUERY_EXCEPTION'
+    RATE_LIMIT_EXCEEDED_GENERIC_EXCEPTION = 'RATE_LIMIT_EXCEEDED_GENERIC_EXCEPTION'
+    RATE_LIMIT_EXCEEDED_SPECIFIED_WAIT_EXCEPTION = 'RATE_LIMIT_EXCEEDED_SPECIFIED_WAIT_EXCEPTION'
+    REPLY_PROCESS_TIMEOUT_EXCEPTION = 'REPLY_PROCESS_TIMEOUT_EXCEPTION'
+    RETRYABLE_PROCESSING_EXCEPTION = 'RETRYABLE_PROCESSING_EXCEPTION'
+    SQL_EXECUTION_EXCEPTION = 'SQL_EXECUTION_EXCEPTION'
+    TABLES_MISSING_EXCEPTION = 'TABLES_MISSING_EXCEPTION'
+    TOO_MANY_CERTIFIED_ANSWERS_EXCEPTION = 'TOO_MANY_CERTIFIED_ANSWERS_EXCEPTION'
+    TOO_MANY_TABLES_EXCEPTION = 'TOO_MANY_TABLES_EXCEPTION'
+    UNEXPECTED_REPLY_PROCESS_EXCEPTION = 'UNEXPECTED_REPLY_PROCESS_EXCEPTION'
+    UNKNOWN_AI_MODEL = 'UNKNOWN_AI_MODEL'
+    WAREHOUSE_ACCESS_MISSING_EXCEPTION = 'WAREHOUSE_ACCESS_MISSING_EXCEPTION'
+    WAREHOUSE_NOT_FOUND_EXCEPTION = 'WAREHOUSE_NOT_FOUND_EXCEPTION'
+
+
+class MessageStatus(Enum):
+    """MesssageStatus. The possible values are: * `FETCHING_METADATA`: Fetching metadata from the data
+    sources. * `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
+    [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
+    response or the executing the query failed. Please see `error` field. * `COMPLETED`: Message
+    processing is completed. Results are in the `attachments` field. Get the SQL query result by
+    calling [getMessageQueryResult](:method:genie/getMessageQueryResult) API. * `SUBMITTED`: Message
+    has been submitted. * `QUERY_RESULT_EXPIRED`: SQL result is not available anymore. The user
+    needs to execute the query again. * `CANCELLED`: Message has been cancelled."""
+
+    ASKING_AI = 'ASKING_AI'
+    CANCELLED = 'CANCELLED'
+    COMPLETED = 'COMPLETED'
+    EXECUTING_QUERY = 'EXECUTING_QUERY'
+    FAILED = 'FAILED'
+    FETCHING_METADATA = 'FETCHING_METADATA'
+    QUERY_RESULT_EXPIRED = 'QUERY_RESULT_EXPIRED'
+    SUBMITTED = 'SUBMITTED'
+
+
 @dataclass
 class MigrateDashboardRequest:
     source_dashboard_id: str
@@ -392,6 +719,76 @@ class PublishedDashboard:
                    warehouse_id=d.get('warehouse_id', None))
 
 
+@dataclass
+class QueryAttachment:
+    description: Optional[str] = None
+    """Description of the query"""
+
+    id: Optional[str] = None
+
+    instruction_id: Optional[str] = None
+    """If the query was created on an instruction (trusted asset) we link to the id"""
+
+    instruction_title: Optional[str] = None
+    """Always store the title next to the id in case the original instruction title changes or the
+    instruction is deleted."""
+
+    last_updated_timestamp: Optional[int] = None
+    """Time when the user updated the query last"""
+
+    query: Optional[str] = None
+    """AI generated SQL query"""
+
+    title: Optional[str] = None
+    """Name of the query"""
+
+    def as_dict(self) -> dict:
+        """Serializes the QueryAttachment into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.description is not None: body['description'] = self.description
+        if self.id is not None: body['id'] = self.id
+        if self.instruction_id is not None: body['instruction_id'] = self.instruction_id
+        if self.instruction_title is not None: body['instruction_title'] = self.instruction_title
+        if self.last_updated_timestamp is not None:
+            body['last_updated_timestamp'] = self.last_updated_timestamp
+        if self.query is not None: body['query'] = self.query
+        if self.title is not None: body['title'] = self.title
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> QueryAttachment:
+        """Deserializes the QueryAttachment from a dictionary."""
+        return cls(description=d.get('description', None),
+                   id=d.get('id', None),
+                   instruction_id=d.get('instruction_id', None),
+                   instruction_title=d.get('instruction_title', None),
+                   last_updated_timestamp=d.get('last_updated_timestamp', None),
+                   query=d.get('query', None),
+                   title=d.get('title', None))
+
+
+@dataclass
+class Result:
+    row_count: Optional[int] = None
+    """Row count of the result"""
+
+    statement_id: Optional[str] = None
+    """Statement Execution API statement id. Use [Get status, manifest, and result first
+    chunk](:method:statementexecution/getstatement) to get the full result data."""
+
+    def as_dict(self) -> dict:
+        """Serializes the Result into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.row_count is not None: body['row_count'] = self.row_count
+        if self.statement_id is not None: body['statement_id'] = self.statement_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> Result:
+        """Deserializes the Result from a dictionary."""
+        return cls(row_count=d.get('row_count', None), statement_id=d.get('statement_id', None))
+
+
 @dataclass
 class Schedule:
     cron_schedule: CronSchedule
@@ -565,6 +962,26 @@ class SubscriptionSubscriberUser:
         return cls(user_id=d.get('user_id', None))
 
 
+@dataclass
+class TextAttachment:
+    content: Optional[str] = None
+    """AI generated message"""
+
+    id: Optional[str] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the TextAttachment into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.content is not None: body['content'] = self.content
+        if self.id is not None: body['id'] = self.id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> TextAttachment:
+        """Deserializes the TextAttachment from a dictionary."""
+        return cls(content=d.get('content', None), id=d.get('id', None))
+
+
 @dataclass
 class TrashDashboardResponse:
 
@@ -675,6 +1092,193 @@ class UpdateScheduleRequest:
                    schedule_id=d.get('schedule_id', None))
 
 
+class GenieAPI:
+    """Genie provides a no-code experience for business users, powered by AI/BI. Analysts set up spaces that
+    business users can use to ask questions using natural language. Genie uses data registered to Unity
+    Catalog and requires at least CAN USE permission on a Pro or Serverless SQL warehouse. Also, Databricks
+    Assistant must be enabled."""
+
+    def __init__(self, api_client):
+        self._api = api_client
+
+    def wait_get_message_genie_completed(
+            self,
+            conversation_id: str,
+            message_id: str,
+            space_id: str,
+            timeout=timedelta(minutes=20),
+            callback: Optional[Callable[[GenieMessage], None]] = None) -> GenieMessage:
+        deadline = time.time() + timeout.total_seconds()
+        target_states = (MessageStatus.COMPLETED, )
+        failure_states = (MessageStatus.FAILED, )
+        status_message = 'polling...'
+        attempt = 1
+        while time.time() < deadline:
+            poll = self.get_message(conversation_id=conversation_id, message_id=message_id, space_id=space_id)
+            status = poll.status
+            status_message = f'current status: {status}'
+            if status in target_states:
+                return poll
+            if callback:
+                callback(poll)
+            if status in failure_states:
+                msg = f'failed to reach COMPLETED, got {status}: {status_message}'
+                raise OperationFailed(msg)
+            prefix = f"conversation_id={conversation_id}, message_id={message_id}, space_id={space_id}"
+            sleep = attempt
+            if sleep > 10:
+                # sleep 10s max per attempt
+                sleep = 10
+            _LOG.debug(f'{prefix}: ({status}) {status_message} (sleeping ~{sleep}s)')
+            time.sleep(sleep + random.random())
+            attempt += 1
+        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 [conversation](:method:genie/startconversation). The AI response uses all
+        previously created messages in the conversation to respond.
+        
+        :param space_id: str
+          The ID associated with the Genie space where the conversation is started.
+        :param conversation_id: str
+          The ID associated with the conversation.
+        :param content: str
+          User message content.
+        
+        :returns:
+          Long-running operation waiter for :class:`GenieMessage`.
+          See :method:wait_get_message_genie_completed for more details.
+        """
+        body = {}
+        if content is not None: body['content'] = content
+        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
+
+        op_response = self._api.do(
+            'POST',
+            f'/api/2.0/genie/spaces/{space_id}/conversations/{conversation_id}/messages',
+            body=body,
+            headers=headers)
+        return Wait(self.wait_get_message_genie_completed,
+                    response=GenieMessage.from_dict(op_response),
+                    conversation_id=conversation_id,
+                    message_id=op_response['id'],
+                    space_id=space_id)
+
+    def create_message_and_wait(self,
+                                space_id: str,
+                                conversation_id: str,
+                                content: str,
+                                timeout=timedelta(minutes=20)) -> GenieMessage:
+        return self.create_message(content=content, conversation_id=conversation_id,
+                                   space_id=space_id).result(timeout=timeout)
+
+    def execute_message_query(self, space_id: str, conversation_id: str,
+                              message_id: str) -> GenieGetMessageQueryResultResponse:
+        """Execute SQL query in a conversation message.
+        
+        Execute the SQL query in the message.
+        
+        :param space_id: str
+          Genie space ID
+        :param conversation_id: str
+          Conversation ID
+        :param message_id: str
+          Message ID
+        
+        :returns: :class:`GenieGetMessageQueryResultResponse`
+        """
+
+        headers = {'Accept': 'application/json', }
+
+        res = self._api.do(
+            'POST',
+            f'/api/2.0/genie/spaces/{space_id}/conversations/{conversation_id}/messages/{message_id}/execute-query',
+            headers=headers)
+        return GenieGetMessageQueryResultResponse.from_dict(res)
+
+    def get_message(self, space_id: str, conversation_id: str, message_id: str) -> GenieMessage:
+        """Get conversation message.
+        
+        Get message from conversation.
+        
+        :param space_id: str
+          The ID associated with the Genie space where the target conversation is located.
+        :param conversation_id: str
+          The ID associated with the target conversation.
+        :param message_id: str
+          The ID associated with the target message from the identified conversation.
+        
+        :returns: :class:`GenieMessage`
+        """
+
+        headers = {'Accept': 'application/json', }
+
+        res = self._api.do(
+            'GET',
+            f'/api/2.0/genie/spaces/{space_id}/conversations/{conversation_id}/messages/{message_id}',
+            headers=headers)
+        return GenieMessage.from_dict(res)
+
+    def get_message_query_result(self, space_id: str, conversation_id: str,
+                                 message_id: str) -> GenieGetMessageQueryResultResponse:
+        """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
+        has a query attachment and the message status is `EXECUTING_QUERY`.
+        
+        :param space_id: str
+          Genie space ID
+        :param conversation_id: str
+          Conversation ID
+        :param message_id: str
+          Message ID
+        
+        :returns: :class:`GenieGetMessageQueryResultResponse`
+        """
+
+        headers = {'Accept': 'application/json', }
+
+        res = self._api.do(
+            'GET',
+            f'/api/2.0/genie/spaces/{space_id}/conversations/{conversation_id}/messages/{message_id}/query-result',
+            headers=headers)
+        return GenieGetMessageQueryResultResponse.from_dict(res)
+
+    def start_conversation(self, space_id: str, content: str) -> Wait[GenieMessage]:
+        """Start conversation.
+        
+        Start a new conversation.
+        
+        :param space_id: str
+          The ID associated with the Genie space where you want to start a conversation.
+        :param content: str
+          The text of the message that starts the conversation.
+        
+        :returns:
+          Long-running operation waiter for :class:`GenieMessage`.
+          See :method:wait_get_message_genie_completed for more details.
+        """
+        body = {}
+        if content is not None: body['content'] = content
+        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
+
+        op_response = self._api.do('POST',
+                                   f'/api/2.0/genie/spaces/{space_id}/start-conversation',
+                                   body=body,
+                                   headers=headers)
+        return Wait(self.wait_get_message_genie_completed,
+                    response=GenieStartConversationResponse.from_dict(op_response),
+                    conversation_id=op_response['conversation_id'],
+                    message_id=op_response['message_id'],
+                    space_id=space_id)
+
+    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)
+
+
 class LakeviewAPI:
     """These APIs provide specific management operations for Lakeview dashboards. Generic resource management can
     be done with Workspace API (import, export, get-status, list, delete)."""
@@ -911,8 +1515,7 @@ class LakeviewAPI:
           The flag to include dashboards located in the trash. If unspecified, only active dashboards will be
           returned.
         :param view: :class:`DashboardView` (optional)
-          Indicates whether to include all metadata from the dashboard in the response. If unset, the response
-          defaults to `DASHBOARD_VIEW_BASIC` which only includes summary metadata from the dashboard.
+          `DASHBOARD_VIEW_BASIC`only includes summary metadata from the dashboard.
         
         :returns: Iterator over :class:`Dashboard`
         """