Add files using upload-large-folder tool

cbc00ce verified 6 months ago

25.5 kB

# -*- coding: utf-8 -*-
import json
import time
import threading
from abc import abstractmethod

import websocket

import dashscope
from dashscope.common.logging import logger
from dashscope.common.error import InputRequired
from dashscope.common.utils import get_user_agent
from dashscope.multimodal import dialog_state
from dashscope.multimodal.multimodal_constants import (
    RESPONSE_NAME_STARTED,
    RESPONSE_NAME_STOPPED,
    RESPONSE_NAME_STATE_CHANGED,
    RESPONSE_NAME_REQUEST_ACCEPTED,
    RESPONSE_NAME_SPEECH_STARTED,
    RESPONSE_NAME_SPEECH_ENDED,
    RESPONSE_NAME_RESPONDING_STARTED,
    RESPONSE_NAME_RESPONDING_ENDED,
    RESPONSE_NAME_SPEECH_CONTENT,
    RESPONSE_NAME_RESPONDING_CONTENT,
    RESPONSE_NAME_ERROR,
    RESPONSE_NAME_HEART_BEAT,
)
from dashscope.multimodal.multimodal_request_params import (
    RequestParameters,
    get_random_uuid,
    DashHeader,
    RequestBodyInput,
    DashPayload,
    RequestToRespondParameters,
    RequestToRespondBodyInput,
)
from dashscope.protocol.websocket import ActionType


class MultiModalCallback:
    """
    语音聊天回调类，用于处理语音聊天过程中的各种事件。
    """

    def on_started(self, dialog_id: str) -> None:
        """
        通知对话开始
        :param dialog_id: 回调对话ID
        """

    def on_stopped(self) -> None:
        """
        通知对话停止
        """

    def on_state_changed(self, state: "dialog_state.DialogState") -> None:
        """
        对话状态改变
        :param state: 新的对话状态
        """

    def on_speech_audio_data(self, data: bytes) -> None:
        """
        合成音频数据回调
        :param data: 音频数据
        """

    def on_error(self, error) -> None:
        """
        发生错误时调用此方法。
        :param error: 错误信息
        """

    def on_connected(self) -> None:
        """
        成功连接到服务器后调用此方法。
        """

    def on_responding_started(self):
        """
        回复开始回调
        """

    def on_responding_ended(self, payload):
        """
        回复结束
        """

    def on_speech_started(self):
        """
        检测到语音输入结束
        """

    def on_speech_ended(self):
        """
        检测到语音输入结束
        """

    def on_speech_content(self, payload):
        """
        语音识别文本
        :param payload: text
        """

    def on_responding_content(self, payload):
        """
        大模型回复文本。
        :param payload: text
        """

    def on_request_accepted(self):
        """
        打断请求被接受。
        """

    def on_close(self, close_status_code, close_msg):
        """
        连接关闭时调用此方法。
        :param close_status_code: 关闭状态码
        :param close_msg: 关闭消息
        """


class MultiModalDialog:
    """
    用于管理WebSocket连接以进行语音聊天的服务类。
    """

    def __init__(
        self,
        app_id: str,
        request_params: RequestParameters,
        multimodal_callback: MultiModalCallback,
        workspace_id: str = None,
        url: str = None,
        api_key: str = None,
        dialog_id: str = None,
        model: str = None,
    ):
        """
        创建一个语音对话会话。
        此方法用于初始化一个新的voice_chat会话，设置必要的参数以准备开始与模型的交互。
        ：param workspace_id: 客户的workspace_id 主工作空间id,非必填字段
        :param app_id: 客户在管控台创建的应用id，可以根据值规律确定使用哪个对话系统
        :param request_params: 请求参数集合
        :param url: (str) API的URL地址。
        :param multimodal_callback: (MultimodalCallback) 回调对象，用于处理来自服务器的消息。
        :param api_key: (str) 应用程序接入的唯一key
        :param dialog_id:对话id，如果传入表示承接上下文继续聊
        :param model: 模型
        """
        if request_params is None:
            raise InputRequired("request_params is required!")
        if url is None:
            url = dashscope.base_websocket_api_url
        if api_key is None:
            api_key = dashscope.api_key

        self.request_params = request_params
        self.model = model
        self._voice_detection = None
        self.thread = None
        self.ws = None
        self.request = _Request()
        self._callback = multimodal_callback
        self.url = url
        self.api_key = api_key
        self.workspace_id = workspace_id
        self.app_id = app_id
        self.dialog_id = dialog_id
        self.dialog_state = dialog_state.StateMachine()
        self.response = _Response(
            self.dialog_state,
            self._callback,
            self.close,
        )  # 传递 self.close 作为回调

    def _on_message(  # pylint: disable=unused-argument
        self,
        ws,
        message,
    ):
        logger.debug(f"<<<<<<< Received message: {message}")
        if isinstance(message, str):
            self.response.handle_text_response(message)
        elif isinstance(message, (bytes, bytearray)):
            self.response.handle_binary_response(message)

    def _on_error(self, ws, error):  # pylint: disable=unused-argument
        logger.error(f"Error: {error}")
        if self._callback:
            self._callback.on_error(error)

    def _on_close(  # pylint: disable=unused-argument
        self,
        ws,
        close_status_code,
        close_msg,
    ):
        try:
            logger.debug(
                "WebSocket connection closed with status %s and message %s",  # noqa: E501
                close_status_code,
                close_msg,
            )
            if close_status_code is None:
                close_status_code = 1000
            if close_msg is None:
                close_msg = "websocket is closed"
            self._callback.on_close(close_status_code, close_msg)
        except Exception as e:
            logger.error(f"Error: {e}")

    def _on_open(self, ws):  # pylint: disable=unused-argument
        self._callback.on_connected()

    # def _on_pong(self, _):
    #     _log.debug("on pong")

    def start(self, dialog_id, enable_voice_detection=False, task_id=None):
        """
        初始化WebSocket连接并发送启动请求
        :param dialog_id: 上下位继承标志位。新对话无需设置。
               如果继承之前的对话历史，则需要记录之前的dialog_id并传入
        :param enable_voice_detection: 是否开启语音检测,可选参数 默认False
        :param task_id: 百炼请求任务 Id，默认会自动生成。您可以指定此 ID 来跟踪请求。
        """
        self._voice_detection = enable_voice_detection
        self._connect(self.api_key)
        logger.debug("connected with server.")
        self._send_start_request(
            dialog_id,
            self.request_params,
            task_id=task_id,
        )

    def start_speech(self):
        """开始上传语音数据"""
        _send_speech_json = self.request.generate_common_direction_request(
            "SendSpeech",
            self.dialog_id,
        )
        self._send_text_frame(_send_speech_json)

    def send_audio_data(self, speech_data: bytes):
        """发送语音数据"""
        self.__send_binary_frame(speech_data)

    def stop_speech(self):
        """停止上传语音数据"""
        _send_speech_json = self.request.generate_common_direction_request(
            "StopSpeech",
            self.dialog_id,
        )
        self._send_text_frame(_send_speech_json)

    def interrupt(self):
        """请求服务端开始说话"""
        _send_speech_json = self.request.generate_common_direction_request(
            "RequestToSpeak",
            self.dialog_id,
        )
        self._send_text_frame(_send_speech_json)

    def request_to_respond(
        self,
        request_type: str,
        text: str,
        parameters: RequestToRespondParameters = None,
    ):
        """请求服务端直接文本合成语音"""
        _send_speech_json = self.request.generate_request_to_response_json(
            direction_name="RequestToRespond",
            dialog_id=self.dialog_id,
            request_type=request_type,
            text=text,
            parameters=parameters,
        )
        self._send_text_frame(_send_speech_json)

    @abstractmethod
    def request_to_respond_prompt(self, text):
        """请求服务端通过文本请求回复文本答复"""
        return

    def local_responding_started(self):
        """本地tts播放开始"""
        _send_speech_json = self.request.generate_common_direction_request(
            "LocalRespondingStarted",
            self.dialog_id,
        )
        self._send_text_frame(_send_speech_json)

    def local_responding_ended(self):
        """本地tts播放结束"""
        _send_speech_json = self.request.generate_common_direction_request(
            "LocalRespondingEnded",
            self.dialog_id,
        )
        self._send_text_frame(_send_speech_json)

    def send_heart_beat(self):
        """发送心跳"""
        _send_speech_json = self.request.generate_common_direction_request(
            "HeartBeat",
            self.dialog_id,
        )
        self._send_text_frame(_send_speech_json)

    def update_info(self, parameters: RequestToRespondParameters = None):
        """更新信息"""
        _send_speech_json = self.request.generate_update_info_json(
            direction_name="UpdateInfo",
            dialog_id=self.dialog_id,
            parameters=parameters,
        )
        self._send_text_frame(_send_speech_json)

    def stop(self):
        if self.ws is None or not self.ws.sock or not self.ws.sock.connected:
            self._callback.on_close(1001, "websocket is not connected")
            return
        _send_speech_json = self.request.generate_stop_request(
            "Stop",
            self.dialog_id,
        )
        self._send_text_frame(_send_speech_json)

    def get_dialog_state(self) -> dialog_state.DialogState:
        return self.dialog_state.get_current_state()

    def get_conversation_mode(self) -> str:
        """get mode of conversation: support tap2talk/push2talk/duplex"""
        return self.request_params.upstream.mode

    """内部方法"""  # pylint: disable=pointless-string-statement

    def _send_start_request(
        self,
        dialog_id: str,
        request_params: RequestParameters,
        task_id: str = None,
    ):
        """发送'Start'请求"""
        _start_json = self.request.generate_start_request(
            workspace_id=self.workspace_id,
            direction_name="Start",
            dialog_id=dialog_id,
            app_id=self.app_id,
            request_params=request_params,
            model=self.model,
            task_id=task_id,
        )
        # send start request
        self._send_text_frame(_start_json)

    def _run_forever(self):
        self.ws.run_forever(ping_interval=None, ping_timeout=None)

    def _connect(self, api_key: str):
        """初始化WebSocket连接并发送启动请求。"""
        self.ws = websocket.WebSocketApp(
            self.url,
            header=self.request.get_websocket_header(api_key),
            on_open=self._on_open,
            on_message=self._on_message,
            on_error=self._on_error,
            on_close=self._on_close,
        )
        self.thread = threading.Thread(target=self._run_forever)
        self.thread.daemon = True
        self.thread.start()

        self._wait_for_connection()

    def close(self):
        if self.ws is None or not self.ws.sock or not self.ws.sock.connected:
            return
        self.ws.close()

    def _wait_for_connection(self):
        """等待WebSocket连接建立"""
        timeout = 5
        start_time = time.time()
        while (
            not (self.ws.sock and self.ws.sock.connected)
            and (time.time() - start_time) < timeout
        ):
            time.sleep(0.1)  # 短暂休眠，避免密集轮询

    def _send_text_frame(self, text: str):
        logger.info(">>>>>> send text frame : %s", text)
        self.ws.send(text, websocket.ABNF.OPCODE_TEXT)

    def __send_binary_frame(self, binary: bytes):
        # _log.info('send binary frame length: %d' % len(binary))
        self.ws.send(binary, websocket.ABNF.OPCODE_BINARY)

    def __del__(self):
        self.cleanup()

    def cleanup(self):
        """清理所有资源"""
        try:
            if self.ws:
                self.ws.close()
            if self.thread and self.thread.is_alive():
                # 设置标志位通知线程退出
                self.thread.join(timeout=2)
            # 清除引用
            self.ws = None
            self.thread = None
            self._callback = None
            self.response = None
        except Exception as e:
            logger.error(f"Error in cleanup: {e}")


class _Request:
    def __init__(self):
        # websocket header
        self.ws_headers = None
        # request body for voice chat
        self.header = None
        self.payload = None
        # params
        self.task_id = None
        self.app_id = None
        self.workspace_id = None

    def get_websocket_header(self, api_key):
        ua = get_user_agent()
        self.ws_headers = {
            "User-Agent": ua,
            "Authorization": f"Bearer {api_key}",
            "Accept": "application/json",
        }
        log_headers = self.ws_headers.copy()
        log_headers["Authorization"] = "REDACTED"
        logger.info("websocket header: %s", log_headers)
        return self.ws_headers

    def generate_start_request(
        self,
        direction_name: str,
        dialog_id: str,
        app_id: str,
        request_params: RequestParameters,
        model: str = None,
        workspace_id: str = None,
        task_id: str = None,
    ) -> str:
        """
        构建语音聊天服务的启动请求数据.
        :param app_id: 管控台应用id
        :param request_params: start请求body中的parameters
        :param direction_name:
        :param dialog_id: 对话ID.
        :param workspace_id: 管控台工作空间id, 非必填字段。
        :param model: 模型
        :param task_id: 百炼请求任务 Id，默认会自动生成。您可以指定此 ID 来跟踪请求。
        :return: 启动请求字典.
        """
        self.task_id = task_id
        self._get_dash_request_header(ActionType.START)
        self._get_dash_request_payload(
            direction_name,
            dialog_id,
            app_id,
            workspace_id=workspace_id,
            request_params=request_params,
            model=model,
        )

        cmd = {
            "header": self.header,
            "payload": self.payload,
        }
        return json.dumps(cmd)

    def generate_common_direction_request(
        self,
        direction_name: str,
        dialog_id: str,
    ) -> str:
        """
        构建语音聊天服务的命令请求数据.
        :param direction_name: 命令.
        :param dialog_id: 对话ID.
        :return: 命令请求json.
        """
        self._get_dash_request_header(ActionType.CONTINUE)
        self._get_dash_request_payload(direction_name, dialog_id, self.app_id)
        cmd = {
            "header": self.header,
            "payload": self.payload,
        }
        return json.dumps(cmd)

    def generate_stop_request(
        self,
        direction_name: str,
        dialog_id: str,
    ) -> str:
        """
        构建语音聊天服务的启动请求数据.
        :param direction_name:指令名称
        :param dialog_id: 对话ID.
        :return: 启动请求json.
        """
        self._get_dash_request_header(ActionType.FINISHED)
        self._get_dash_request_payload(direction_name, dialog_id, self.app_id)

        cmd = {
            "header": self.header,
            "payload": self.payload,
        }
        return json.dumps(cmd)

    def generate_request_to_response_json(
        self,
        direction_name: str,
        dialog_id: str,
        request_type: str,
        text: str,
        parameters: RequestToRespondParameters = None,
    ) -> str:
        """
        构建语音聊天服务的命令请求数据.
        :param direction_name: 命令.
        :param dialog_id: 对话ID.
        :param request_type: 服务应该采取的交互类型，transcript 表示直接把文本转语音，prompt 表示把文本送大模型回答  # noqa: E501
        :param text: 文本.
        :param parameters: 命令请求body中的parameters
        :return: 命令请求字典.
        """
        self._get_dash_request_header(ActionType.CONTINUE)

        custom_input = RequestToRespondBodyInput(
            app_id=self.app_id,
            directive=direction_name,
            dialog_id=dialog_id,
            type_=request_type,
            text=text,
        )

        self._get_dash_request_payload(
            direction_name,
            dialog_id,
            self.app_id,
            request_params=parameters,  # type: ignore[arg-type]
            custom_input=custom_input,
        )
        cmd = {
            "header": self.header,
            "payload": self.payload,
        }
        return json.dumps(cmd)

    def generate_update_info_json(
        self,
        direction_name: str,
        dialog_id: str,
        parameters: RequestToRespondParameters = None,
    ) -> str:
        """
        构建语音聊天服务的命令请求数据.
        :param direction_name: 命令.
        :param parameters: 命令请求body中的parameters
        :return: 命令请求字典.
        """
        self._get_dash_request_header(ActionType.CONTINUE)

        custom_input = RequestToRespondBodyInput(
            app_id=self.app_id,
            directive=direction_name,
            dialog_id=dialog_id,
        )

        self._get_dash_request_payload(
            direction_name,
            dialog_id,
            self.app_id,
            request_params=parameters,  # type: ignore[arg-type]
            custom_input=custom_input,
        )
        cmd = {
            "header": self.header,
            "payload": self.payload,
        }
        return json.dumps(cmd)

    def _get_dash_request_header(self, action: str):
        """
        构建多模对话请求的请求协议Header
        :param action: ActionType 百炼协议action 支持：run-task, continue-task, finish-task  # noqa: E501
        """
        if self.task_id is None:
            self.task_id = get_random_uuid()
        self.header = DashHeader(action=action, task_id=self.task_id).to_dict()

    def _get_dash_request_payload(
        self,
        direction_name: str,
        dialog_id: str,
        app_id: str,
        workspace_id: str = None,
        request_params: RequestParameters = None,
        custom_input=None,
        model: str = None,
    ):
        """
        构建多模对话请求的请求协议payload
        :param direction_name: 对话协议内部的指令名称
        :param dialog_id: 对话ID.
        :param app_id: 管控台应用id
        :param request_params: start请求body中的parameters
        :param custom_input: 自定义输入
        :param model: 模型
        """
        if custom_input is not None:
            input = custom_input  # pylint: disable=redefined-builtin
        else:
            input = RequestBodyInput(
                workspace_id=workspace_id,
                app_id=app_id,
                directive=direction_name,
                dialog_id=dialog_id,
            )

        self.payload = DashPayload(
            model=model,
            input=input,
            parameters=request_params,
        ).to_dict()


class _Response:
    def __init__(
        self,
        state: dialog_state.StateMachine,
        callback: MultiModalCallback,
        close_callback=None,
    ):
        super().__init__()
        self.dialog_id = None  # 对话ID.
        self.dialog_state = state
        self._callback = callback
        self._close_callback = close_callback  # 保存关闭回调函数

    # pylint: disable=inconsistent-return-statements
    def handle_text_response(self, response_json: str):
        """
        处理语音聊天服务的响应数据.
        :param response_json: 从服务接收到的原始JSON字符串响应。
        """
        logger.info("<<<<<< server response: %s", response_json)
        try:
            # 尝试将消息解析为JSON
            json_data = json.loads(response_json)
            if (
                "status_code" in json_data["header"]
                and json_data["header"]["status_code"] != 200
            ):
                logger.error(
                    "Server returned invalid message: %s",
                    response_json,
                )
                if self._callback:
                    self._callback.on_error(response_json)
                return
            if (
                "event" in json_data["header"]
                and json_data["header"]["event"] == "task-failed"
            ):
                logger.error(
                    "Server returned invalid message: %s",
                    response_json,
                )
                if self._callback:
                    self._callback.on_error(response_json)
                return None

            payload = json_data["payload"]
            if "output" in payload and payload["output"] is not None:
                response_event = payload["output"]["event"]
                logger.info("Server response event: %s", response_event)
                self._handle_text_response_in_conversation(
                    response_event=response_event,
                    response_json=json_data,
                )
            del json_data

        except json.JSONDecodeError:
            logger.error("Failed to parse message as JSON.")

    def _handle_text_response_in_conversation(
        self,
        response_event: str,
        response_json: dict,
    ):  # pylint: disable=too-many-branches
        payload = response_json["payload"]
        try:
            if response_event == RESPONSE_NAME_STARTED:
                self._handle_started(payload["output"])
            elif response_event == RESPONSE_NAME_STOPPED:
                self._handle_stopped()
            elif response_event == RESPONSE_NAME_STATE_CHANGED:
                self._handle_state_changed(payload["output"]["state"])
                logger.debug(
                    "service response change state: %s",
                    payload["output"]["state"],
                )
            elif response_event == RESPONSE_NAME_REQUEST_ACCEPTED:
                self._handle_request_accepted()
            elif response_event == RESPONSE_NAME_SPEECH_STARTED:
                self._handle_speech_started()
            elif response_event == RESPONSE_NAME_SPEECH_ENDED:
                self._handle_speech_ended()
            elif response_event == RESPONSE_NAME_RESPONDING_STARTED:
                self._handle_responding_started()
            elif response_event == RESPONSE_NAME_RESPONDING_ENDED:
                self._handle_responding_ended(payload)
            elif response_event == RESPONSE_NAME_SPEECH_CONTENT:
                self._handle_speech_content(payload)
            elif response_event == RESPONSE_NAME_RESPONDING_CONTENT:
                self._handle_responding_content(payload)
            elif response_event == RESPONSE_NAME_ERROR:
                self._callback.on_error(json.dumps(response_json))
            elif response_event == RESPONSE_NAME_HEART_BEAT:
                logger.debug("Server response heart beat")
            else:
                logger.error("Unknown response name: %s", response_event)
        except json.JSONDecodeError:
            logger.error("Failed to parse message as JSON.")

    def handle_binary_response(self, message: bytes):
        # logger.debug('<<<recv binary {}'.format(len(message)))
        self._callback.on_speech_audio_data(message)

    def _handle_request_accepted(self):
        self._callback.on_request_accepted()

    def _handle_started(self, payload: dict):
        self.dialog_id = payload["dialog_id"]
        self._callback.on_started(self.dialog_id)  # type: ignore[arg-type]

    def _handle_stopped(self):
        self._callback.on_stopped()
        if self._close_callback is not None:
            self._close_callback()

    def _handle_state_changed(self, state: str):
        """
        处理语音聊天状态流转.
        :param state: 状态.
        """
        self.dialog_state.change_state(state)
        self._callback.on_state_changed(self.dialog_state.get_current_state())

    def _handle_speech_started(self):
        self._callback.on_speech_started()

    def _handle_speech_ended(self):
        self._callback.on_speech_ended()

    def _handle_responding_started(self):
        self._callback.on_responding_started()

    def _handle_responding_ended(self, payload: dict):
        self._callback.on_responding_ended(payload)

    def _handle_speech_content(self, payload: dict):
        self._callback.on_speech_content(payload)

    def _handle_responding_content(self, payload: dict):
        self._callback.on_responding_content(payload)

	# -- coding: utf-8 --
	import json
	import time
	import threading
	from abc import abstractmethod

	import websocket

	import dashscope
	from dashscope.common.logging import logger
	from dashscope.common.error import InputRequired
	from dashscope.common.utils import get_user_agent
	from dashscope.multimodal import dialog_state
	from dashscope.multimodal.multimodal_constants import (
	RESPONSE_NAME_STARTED,
	RESPONSE_NAME_STOPPED,
	RESPONSE_NAME_STATE_CHANGED,
	RESPONSE_NAME_REQUEST_ACCEPTED,
	RESPONSE_NAME_SPEECH_STARTED,
	RESPONSE_NAME_SPEECH_ENDED,
	RESPONSE_NAME_RESPONDING_STARTED,
	RESPONSE_NAME_RESPONDING_ENDED,
	RESPONSE_NAME_SPEECH_CONTENT,
	RESPONSE_NAME_RESPONDING_CONTENT,
	RESPONSE_NAME_ERROR,
	RESPONSE_NAME_HEART_BEAT,
	)
	from dashscope.multimodal.multimodal_request_params import (
	RequestParameters,
	get_random_uuid,
	DashHeader,
	RequestBodyInput,
	DashPayload,
	RequestToRespondParameters,
	RequestToRespondBodyInput,
	)
	from dashscope.protocol.websocket import ActionType


	class MultiModalCallback:
	"""
	语音聊天回调类，用于处理语音聊天过程中的各种事件。
	"""

	def on_started(self, dialog_id: str) -> None:
	"""
	通知对话开始

	:param dialog_id: 回调对话ID
	"""

	def on_stopped(self) -> None:
	"""
	通知对话停止
	"""

	def on_state_changed(self, state: "dialog_state.DialogState") -> None:
	"""
	对话状态改变

	:param state: 新的对话状态
	"""

	def on_speech_audio_data(self, data: bytes) -> None:
	"""
	合成音频数据回调

	:param data: 音频数据
	"""

	def on_error(self, error) -> None:
	"""
	发生错误时调用此方法。

	:param error: 错误信息
	"""

	def on_connected(self) -> None:
	"""
	成功连接到服务器后调用此方法。
	"""

	def on_responding_started(self):
	"""
	回复开始回调
	"""

	def on_responding_ended(self, payload):
	"""
	回复结束
	"""

	def on_speech_started(self):
	"""
	检测到语音输入结束
	"""

	def on_speech_ended(self):
	"""
	检测到语音输入结束
	"""

	def on_speech_content(self, payload):
	"""
	语音识别文本

	:param payload: text
	"""

	def on_responding_content(self, payload):
	"""
	大模型回复文本。

	:param payload: text
	"""

	def on_request_accepted(self):
	"""
	打断请求被接受。
	"""

	def on_close(self, close_status_code, close_msg):
	"""
	连接关闭时调用此方法。

	:param close_status_code: 关闭状态码
	:param close_msg: 关闭消息
	"""


	class MultiModalDialog:
	"""
	用于管理WebSocket连接以进行语音聊天的服务类。
	"""

	def __init__(
	self,
	app_id: str,
	request_params: RequestParameters,
	multimodal_callback: MultiModalCallback,
	workspace_id: str = None,
	url: str = None,
	api_key: str = None,
	dialog_id: str = None,
	model: str = None,
	):
	"""
	创建一个语音对话会话。

	此方法用于初始化一个新的voice_chat会话，设置必要的参数以准备开始与模型的交互。
	：param workspace_id: 客户的workspace_id 主工作空间id,非必填字段
	:param app_id: 客户在管控台创建的应用id，可以根据值规律确定使用哪个对话系统
	:param request_params: 请求参数集合
	:param url: (str) API的URL地址。
	:param multimodal_callback: (MultimodalCallback) 回调对象，用于处理来自服务器的消息。
	:param api_key: (str) 应用程序接入的唯一key
	:param dialog_id:对话id，如果传入表示承接上下文继续聊
	:param model: 模型
	"""
	if request_params is None:
	raise InputRequired("request_params is required!")
	if url is None:
	url = dashscope.base_websocket_api_url
	if api_key is None:
	api_key = dashscope.api_key

	self.request_params = request_params
	self.model = model
	self._voice_detection = None
	self.thread = None
	self.ws = None
	self.request = _Request()
	self._callback = multimodal_callback
	self.url = url
	self.api_key = api_key
	self.workspace_id = workspace_id
	self.app_id = app_id
	self.dialog_id = dialog_id
	self.dialog_state = dialog_state.StateMachine()
	self.response = _Response(
	self.dialog_state,
	self._callback,
	self.close,
	) # 传递 self.close 作为回调

	def _on_message( # pylint: disable=unused-argument
	self,
	ws,
	message,
	):
	logger.debug(f"<<<<<<< Received message: {message}")
	if isinstance(message, str):
	self.response.handle_text_response(message)
	elif isinstance(message, (bytes, bytearray)):
	self.response.handle_binary_response(message)

	def _on_error(self, ws, error): # pylint: disable=unused-argument
	logger.error(f"Error: {error}")
	if self._callback:
	self._callback.on_error(error)

	def _on_close( # pylint: disable=unused-argument
	self,
	ws,
	close_status_code,
	close_msg,
	):
	try:
	logger.debug(
	"WebSocket connection closed with status %s and message %s", # noqa: E501
	close_status_code,
	close_msg,
	)
	if close_status_code is None:
	close_status_code = 1000
	if close_msg is None:
	close_msg = "websocket is closed"
	self._callback.on_close(close_status_code, close_msg)
	except Exception as e:
	logger.error(f"Error: {e}")

	def _on_open(self, ws): # pylint: disable=unused-argument
	self._callback.on_connected()

	# def _on_pong(self, _):
	# _log.debug("on pong")

	def start(self, dialog_id, enable_voice_detection=False, task_id=None):
	"""
	初始化WebSocket连接并发送启动请求
	:param dialog_id: 上下位继承标志位。新对话无需设置。
	如果继承之前的对话历史，则需要记录之前的dialog_id并传入
	:param enable_voice_detection: 是否开启语音检测,可选参数默认False
	:param task_id: 百炼请求任务 Id，默认会自动生成。您可以指定此 ID 来跟踪请求。
	"""
	self._voice_detection = enable_voice_detection
	self._connect(self.api_key)
	logger.debug("connected with server.")
	self._send_start_request(
	dialog_id,
	self.request_params,
	task_id=task_id,
	)

	def start_speech(self):
	"""开始上传语音数据"""
	_send_speech_json = self.request.generate_common_direction_request(
	"SendSpeech",
	self.dialog_id,
	)
	self._send_text_frame(_send_speech_json)

	def send_audio_data(self, speech_data: bytes):
	"""发送语音数据"""
	self.__send_binary_frame(speech_data)

	def stop_speech(self):
	"""停止上传语音数据"""
	_send_speech_json = self.request.generate_common_direction_request(
	"StopSpeech",
	self.dialog_id,
	)
	self._send_text_frame(_send_speech_json)

	def interrupt(self):
	"""请求服务端开始说话"""
	_send_speech_json = self.request.generate_common_direction_request(
	"RequestToSpeak",
	self.dialog_id,
	)
	self._send_text_frame(_send_speech_json)

	def request_to_respond(
	self,
	request_type: str,
	text: str,
	parameters: RequestToRespondParameters = None,
	):
	"""请求服务端直接文本合成语音"""
	_send_speech_json = self.request.generate_request_to_response_json(
	direction_name="RequestToRespond",
	dialog_id=self.dialog_id,
	request_type=request_type,
	text=text,
	parameters=parameters,
	)
	self._send_text_frame(_send_speech_json)

	@abstractmethod
	def request_to_respond_prompt(self, text):
	"""请求服务端通过文本请求回复文本答复"""
	return

	def local_responding_started(self):
	"""本地tts播放开始"""
	_send_speech_json = self.request.generate_common_direction_request(
	"LocalRespondingStarted",
	self.dialog_id,
	)
	self._send_text_frame(_send_speech_json)

	def local_responding_ended(self):
	"""本地tts播放结束"""
	_send_speech_json = self.request.generate_common_direction_request(
	"LocalRespondingEnded",
	self.dialog_id,
	)
	self._send_text_frame(_send_speech_json)

	def send_heart_beat(self):
	"""发送心跳"""
	_send_speech_json = self.request.generate_common_direction_request(
	"HeartBeat",
	self.dialog_id,
	)
	self._send_text_frame(_send_speech_json)

	def update_info(self, parameters: RequestToRespondParameters = None):
	"""更新信息"""
	_send_speech_json = self.request.generate_update_info_json(
	direction_name="UpdateInfo",
	dialog_id=self.dialog_id,
	parameters=parameters,
	)
	self._send_text_frame(_send_speech_json)

	def stop(self):
	if self.ws is None or not self.ws.sock or not self.ws.sock.connected:
	self._callback.on_close(1001, "websocket is not connected")
	return
	_send_speech_json = self.request.generate_stop_request(
	"Stop",
	self.dialog_id,
	)
	self._send_text_frame(_send_speech_json)

	def get_dialog_state(self) -> dialog_state.DialogState:
	return self.dialog_state.get_current_state()

	def get_conversation_mode(self) -> str:
	"""get mode of conversation: support tap2talk/push2talk/duplex"""
	return self.request_params.upstream.mode

	"""内部方法""" # pylint: disable=pointless-string-statement

	def _send_start_request(
	self,
	dialog_id: str,
	request_params: RequestParameters,
	task_id: str = None,
	):
	"""发送'Start'请求"""
	_start_json = self.request.generate_start_request(
	workspace_id=self.workspace_id,
	direction_name="Start",
	dialog_id=dialog_id,
	app_id=self.app_id,
	request_params=request_params,
	model=self.model,
	task_id=task_id,
	)
	# send start request
	self._send_text_frame(_start_json)

	def _run_forever(self):
	self.ws.run_forever(ping_interval=None, ping_timeout=None)

	def _connect(self, api_key: str):
	"""初始化WebSocket连接并发送启动请求。"""
	self.ws = websocket.WebSocketApp(
	self.url,
	header=self.request.get_websocket_header(api_key),
	on_open=self._on_open,
	on_message=self._on_message,
	on_error=self._on_error,
	on_close=self._on_close,
	)
	self.thread = threading.Thread(target=self._run_forever)
	self.thread.daemon = True
	self.thread.start()

	self._wait_for_connection()

	def close(self):
	if self.ws is None or not self.ws.sock or not self.ws.sock.connected:
	return
	self.ws.close()

	def _wait_for_connection(self):
	"""等待WebSocket连接建立"""
	timeout = 5
	start_time = time.time()
	while (
	not (self.ws.sock and self.ws.sock.connected)
	and (time.time() - start_time) < timeout
	):
	time.sleep(0.1) # 短暂休眠，避免密集轮询

	def _send_text_frame(self, text: str):
	logger.info(">>>>>> send text frame : %s", text)
	self.ws.send(text, websocket.ABNF.OPCODE_TEXT)

	def __send_binary_frame(self, binary: bytes):
	# _log.info('send binary frame length: %d' % len(binary))
	self.ws.send(binary, websocket.ABNF.OPCODE_BINARY)

	def __del__(self):
	self.cleanup()

	def cleanup(self):
	"""清理所有资源"""
	try:
	if self.ws:
	self.ws.close()
	if self.thread and self.thread.is_alive():
	# 设置标志位通知线程退出
	self.thread.join(timeout=2)
	# 清除引用
	self.ws = None
	self.thread = None
	self._callback = None
	self.response = None
	except Exception as e:
	logger.error(f"Error in cleanup: {e}")


	class _Request:
	def __init__(self):
	# websocket header
	self.ws_headers = None
	# request body for voice chat
	self.header = None
	self.payload = None
	# params
	self.task_id = None
	self.app_id = None
	self.workspace_id = None

	def get_websocket_header(self, api_key):
	ua = get_user_agent()
	self.ws_headers = {
	"User-Agent": ua,
	"Authorization": f"Bearer {api_key}",
	"Accept": "application/json",
	}
	log_headers = self.ws_headers.copy()
	log_headers["Authorization"] = "REDACTED"
	logger.info("websocket header: %s", log_headers)
	return self.ws_headers

	def generate_start_request(
	self,
	direction_name: str,
	dialog_id: str,
	app_id: str,
	request_params: RequestParameters,
	model: str = None,
	workspace_id: str = None,
	task_id: str = None,
	) -> str:
	"""
	构建语音聊天服务的启动请求数据.
	:param app_id: 管控台应用id
	:param request_params: start请求body中的parameters
	:param direction_name:
	:param dialog_id: 对话ID.
	:param workspace_id: 管控台工作空间id, 非必填字段。
	:param model: 模型
	:param task_id: 百炼请求任务 Id，默认会自动生成。您可以指定此 ID 来跟踪请求。
	:return: 启动请求字典.
	"""
	self.task_id = task_id
	self._get_dash_request_header(ActionType.START)
	self._get_dash_request_payload(
	direction_name,
	dialog_id,
	app_id,
	workspace_id=workspace_id,
	request_params=request_params,
	model=model,
	)

	cmd = {
	"header": self.header,
	"payload": self.payload,
	}
	return json.dumps(cmd)

	def generate_common_direction_request(
	self,
	direction_name: str,
	dialog_id: str,
	) -> str:
	"""
	构建语音聊天服务的命令请求数据.
	:param direction_name: 命令.
	:param dialog_id: 对话ID.
	:return: 命令请求json.
	"""
	self._get_dash_request_header(ActionType.CONTINUE)
	self._get_dash_request_payload(direction_name, dialog_id, self.app_id)
	cmd = {
	"header": self.header,
	"payload": self.payload,
	}
	return json.dumps(cmd)

	def generate_stop_request(
	self,
	direction_name: str,
	dialog_id: str,
	) -> str:
	"""
	构建语音聊天服务的启动请求数据.
	:param direction_name:指令名称
	:param dialog_id: 对话ID.
	:return: 启动请求json.
	"""
	self._get_dash_request_header(ActionType.FINISHED)
	self._get_dash_request_payload(direction_name, dialog_id, self.app_id)

	cmd = {
	"header": self.header,
	"payload": self.payload,
	}
	return json.dumps(cmd)

	def generate_request_to_response_json(
	self,
	direction_name: str,
	dialog_id: str,
	request_type: str,
	text: str,
	parameters: RequestToRespondParameters = None,
	) -> str:
	"""
	构建语音聊天服务的命令请求数据.
	:param direction_name: 命令.
	:param dialog_id: 对话ID.
	:param request_type: 服务应该采取的交互类型，transcript 表示直接把文本转语音，prompt 表示把文本送大模型回答 # noqa: E501
	:param text: 文本.
	:param parameters: 命令请求body中的parameters
	:return: 命令请求字典.
	"""
	self._get_dash_request_header(ActionType.CONTINUE)

	custom_input = RequestToRespondBodyInput(
	app_id=self.app_id,
	directive=direction_name,
	dialog_id=dialog_id,
	type_=request_type,
	text=text,
	)

	self._get_dash_request_payload(
	direction_name,
	dialog_id,
	self.app_id,
	request_params=parameters, # type: ignore[arg-type]
	custom_input=custom_input,
	)
	cmd = {
	"header": self.header,
	"payload": self.payload,
	}
	return json.dumps(cmd)

	def generate_update_info_json(
	self,
	direction_name: str,
	dialog_id: str,
	parameters: RequestToRespondParameters = None,
	) -> str:
	"""
	构建语音聊天服务的命令请求数据.
	:param direction_name: 命令.
	:param parameters: 命令请求body中的parameters
	:return: 命令请求字典.
	"""
	self._get_dash_request_header(ActionType.CONTINUE)

	custom_input = RequestToRespondBodyInput(
	app_id=self.app_id,
	directive=direction_name,
	dialog_id=dialog_id,
	)

	self._get_dash_request_payload(
	direction_name,
	dialog_id,
	self.app_id,
	request_params=parameters, # type: ignore[arg-type]
	custom_input=custom_input,
	)
	cmd = {
	"header": self.header,
	"payload": self.payload,
	}
	return json.dumps(cmd)

	def _get_dash_request_header(self, action: str):
	"""
	构建多模对话请求的请求协议Header
	:param action: ActionType 百炼协议action 支持：run-task, continue-task, finish-task # noqa: E501
	"""
	if self.task_id is None:
	self.task_id = get_random_uuid()
	self.header = DashHeader(action=action, task_id=self.task_id).to_dict()

	def _get_dash_request_payload(
	self,
	direction_name: str,
	dialog_id: str,
	app_id: str,
	workspace_id: str = None,
	request_params: RequestParameters = None,
	custom_input=None,
	model: str = None,
	):
	"""
	构建多模对话请求的请求协议payload
	:param direction_name: 对话协议内部的指令名称
	:param dialog_id: 对话ID.
	:param app_id: 管控台应用id
	:param request_params: start请求body中的parameters
	:param custom_input: 自定义输入
	:param model: 模型
	"""
	if custom_input is not None:
	input = custom_input # pylint: disable=redefined-builtin
	else:
	input = RequestBodyInput(
	workspace_id=workspace_id,
	app_id=app_id,
	directive=direction_name,
	dialog_id=dialog_id,
	)

	self.payload = DashPayload(
	model=model,
	input=input,
	parameters=request_params,
	).to_dict()


	class _Response:
	def __init__(
	self,
	state: dialog_state.StateMachine,
	callback: MultiModalCallback,
	close_callback=None,
	):
	super().__init__()
	self.dialog_id = None # 对话ID.
	self.dialog_state = state
	self._callback = callback
	self._close_callback = close_callback # 保存关闭回调函数

	# pylint: disable=inconsistent-return-statements
	def handle_text_response(self, response_json: str):
	"""
	处理语音聊天服务的响应数据.
	:param response_json: 从服务接收到的原始JSON字符串响应。
	"""
	logger.info("<<<<<< server response: %s", response_json)
	try:
	# 尝试将消息解析为JSON
	json_data = json.loads(response_json)
	if (
	"status_code" in json_data["header"]
	and json_data["header"]["status_code"] != 200
	):
	logger.error(
	"Server returned invalid message: %s",
	response_json,
	)
	if self._callback:
	self._callback.on_error(response_json)
	return
	if (
	"event" in json_data["header"]
	and json_data["header"]["event"] == "task-failed"
	):
	logger.error(
	"Server returned invalid message: %s",
	response_json,
	)
	if self._callback:
	self._callback.on_error(response_json)
	return None

	payload = json_data["payload"]
	if "output" in payload and payload["output"] is not None:
	response_event = payload["output"]["event"]
	logger.info("Server response event: %s", response_event)
	self._handle_text_response_in_conversation(
	response_event=response_event,
	response_json=json_data,
	)
	del json_data

	except json.JSONDecodeError:
	logger.error("Failed to parse message as JSON.")

	def _handle_text_response_in_conversation(
	self,
	response_event: str,
	response_json: dict,
	): # pylint: disable=too-many-branches
	payload = response_json["payload"]
	try:
	if response_event == RESPONSE_NAME_STARTED:
	self._handle_started(payload["output"])
	elif response_event == RESPONSE_NAME_STOPPED:
	self._handle_stopped()
	elif response_event == RESPONSE_NAME_STATE_CHANGED:
	self._handle_state_changed(payload["output"]["state"])
	logger.debug(
	"service response change state: %s",
	payload["output"]["state"],
	)
	elif response_event == RESPONSE_NAME_REQUEST_ACCEPTED:
	self._handle_request_accepted()
	elif response_event == RESPONSE_NAME_SPEECH_STARTED:
	self._handle_speech_started()
	elif response_event == RESPONSE_NAME_SPEECH_ENDED:
	self._handle_speech_ended()
	elif response_event == RESPONSE_NAME_RESPONDING_STARTED:
	self._handle_responding_started()
	elif response_event == RESPONSE_NAME_RESPONDING_ENDED:
	self._handle_responding_ended(payload)
	elif response_event == RESPONSE_NAME_SPEECH_CONTENT:
	self._handle_speech_content(payload)
	elif response_event == RESPONSE_NAME_RESPONDING_CONTENT:
	self._handle_responding_content(payload)
	elif response_event == RESPONSE_NAME_ERROR:
	self._callback.on_error(json.dumps(response_json))
	elif response_event == RESPONSE_NAME_HEART_BEAT:
	logger.debug("Server response heart beat")
	else:
	logger.error("Unknown response name: %s", response_event)
	except json.JSONDecodeError:
	logger.error("Failed to parse message as JSON.")

	def handle_binary_response(self, message: bytes):
	# logger.debug('<<<recv binary {}'.format(len(message)))
	self._callback.on_speech_audio_data(message)

	def _handle_request_accepted(self):
	self._callback.on_request_accepted()

	def _handle_started(self, payload: dict):
	self.dialog_id = payload["dialog_id"]
	self._callback.on_started(self.dialog_id) # type: ignore[arg-type]

	def _handle_stopped(self):
	self._callback.on_stopped()
	if self._close_callback is not None:
	self._close_callback()

	def _handle_state_changed(self, state: str):
	"""
	处理语音聊天状态流转.
	:param state: 状态.
	"""
	self.dialog_state.change_state(state)
	self._callback.on_state_changed(self.dialog_state.get_current_state())

	def _handle_speech_started(self):
	self._callback.on_speech_started()

	def _handle_speech_ended(self):
	self._callback.on_speech_ended()

	def _handle_responding_started(self):
	self._callback.on_responding_started()

	def _handle_responding_ended(self, payload: dict):
	self._callback.on_responding_ended(payload)

	def _handle_speech_content(self, payload: dict):
	self._callback.on_speech_content(payload)

	def _handle_responding_content(self, payload: dict):
	self._callback.on_responding_content(payload)