dashscope 1.23.8__py3-none-any.whl → 1.24.0__py3-none-any.whl

dashscope/app/application_response.py

@@ -6,7 +6,7 @@
 """
 from dataclasses import dataclass
 from http import HTTPStatus
-from typing import Dict, List
+from typing import Dict, List, Optional
 
 from dashscope.api_entities.dashscope_response import (DashScopeAPIResponse,
                                                        DictMixin)
@@ -105,6 +105,50 @@ class ApplicationDocReference(DictMixin):
                          page_number=page_number,
                          **kwargs)
 
+@dataclass(init=False)
+class WorkflowMessage(DictMixin):
+    node_id: str
+    node_name: str
+    node_type: str
+    node_status: str
+    node_is_completed: str
+    node_msg_seq_id: int
+    message: str
+
+    class Message(DictMixin):
+        role: str
+        content: str
+
+    def __init__(self,
+                 node_id: str = None,
+                 node_name: str = None,
+                 node_type: str = None,
+                 node_status: str = None,
+                 node_is_completed: str = None,
+                 node_msg_seq_id: int = None,
+                 message: Message = None,
+                 **kwargs):
+        """ Workflow message.
+
+        Args:
+            node_id (str, optional): .
+            node_name (str, optional): .
+            node_type (str, optional): .
+            node_status (str, optional): .
+            node_is_completed (str, optional): .
+            node_msg_seq_id (int, optional): .
+            message (Message, optional): .
+        """
+
+        super().__init__(node_id=node_id,
+                         node_name=node_name,
+                         node_type=node_type,
+                         node_status=node_status,
+                         node_is_completed=node_is_completed,
+                         node_msg_seq_id=node_msg_seq_id,
+                         message=message,
+                         **kwargs)
+
 
 @dataclass(init=False)
 class ApplicationOutput(DictMixin):
@@ -113,6 +157,7 @@ class ApplicationOutput(DictMixin):
     session_id: str
     thoughts: List[ApplicationThought]
     doc_references: List[ApplicationDocReference]
+    workflow_message: WorkflowMessage
 
     def __init__(self,
                  text: str = None,
@@ -120,6 +165,7 @@ class ApplicationOutput(DictMixin):
                  session_id: str = None,
                  thoughts: List[ApplicationThought] = None,
                  doc_references: List[ApplicationDocReference] = None,
+                 workflow_message: WorkflowMessage = None,
                  **kwargs):
 
         ths = None
@@ -139,6 +185,7 @@ class ApplicationOutput(DictMixin):
                          session_id=session_id,
                          thoughts=ths,
                          doc_references=refs,
+                         workflow_message=workflow_message,
                          **kwargs)
 
 

dashscope/assistants/assistant_types.py

@@ -118,6 +118,15 @@ class Assistant(BaseObjectMixin):
     metadata: Optional[object] = None
     tools: List[Tool]
 
+    object: Optional[str] = None
+
+    top_p: Optional[float] = None
+    top_k: Optional[int] = None
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+
+    request_id: Optional[str] = None
+
     def __init__(self, **kwargs):
         self.tools = convert_tools_dict_to_objects(kwargs.pop('tools', []))
         super().__init__(**kwargs)

dashscope/assistants/assistants.py

@@ -26,6 +26,10 @@ class Assistants(CreateMixin, CancelMixin, DeleteMixin, ListObjectMixin,
         tools: Optional[List[Dict]] = None,
         file_ids: Optional[List[str]] = [],
         metadata: Dict = {},
+        top_p: Optional[float] = None,
+        top_k: Optional[int] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
     ):
         obj = {}
         if model:
@@ -41,6 +45,15 @@ class Assistants(CreateMixin, CancelMixin, DeleteMixin, ListObjectMixin,
         obj['file_ids'] = file_ids
         obj['metadata'] = metadata
 
+        if top_p is not None:
+            obj['top_p'] = top_p
+        if top_k is not None:
+            obj['top_k'] = top_k
+        if temperature is not None:
+            obj['temperature'] = temperature
+        if max_tokens is not None:
+            obj['max_tokens'] = max_tokens
+
         return obj
 
     @classmethod
@@ -98,6 +111,10 @@ class Assistants(CreateMixin, CancelMixin, DeleteMixin, ListObjectMixin,
                metadata: Dict = None,
                workspace: str = None,
                api_key: str = None,
+               top_p: Optional[float] = None,
+               top_k: Optional[int] = None,
+               temperature: Optional[float] = None,
+               max_tokens: Optional[int] = None,
                **kwargs) -> Assistant:
         """Create Assistant.
 
@@ -111,6 +128,10 @@ class Assistants(CreateMixin, CancelMixin, DeleteMixin, ListObjectMixin,
             metadata (Dict, optional): Custom key-value pairs associate with assistant. Defaults to None.
             workspace (str, optional): The DashScope workspace id. Defaults to None.
             api_key (str, optional): The DashScope api key. Defaults to None.
+            top_p (float, optional): top_p parameter for model. Defaults to None.
+            top_k (int, optional): top_p parameter for model. Defaults to None.
+            temperature (float, optional): temperature parameter for model. Defaults to None.
+            max_tokens (int, optional): max_tokens parameter for model. Defaults to None.
 
         Raises:
             ModelRequired: The model is required.
@@ -122,7 +143,7 @@ class Assistants(CreateMixin, CancelMixin, DeleteMixin, ListObjectMixin,
             raise ModelRequired('Model is required!')
         data = cls._create_assistant_object(model, name, description,
                                             instructions, tools, file_ids,
-                                            metadata)
+                                            metadata, top_p, top_k, temperature, max_tokens)
         response = super().call(data=data,
                                 api_key=api_key,
                                 flattened_output=True,
@@ -224,6 +245,10 @@ class Assistants(CreateMixin, CancelMixin, DeleteMixin, ListObjectMixin,
                metadata: Dict = None,
                workspace: str = None,
                api_key: str = None,
+               top_p: Optional[float] = None,
+               top_k: Optional[int] = None,
+               temperature: Optional[float] = None,
+               max_tokens: Optional[int] = None,
                **kwargs) -> Assistant:
         """Update an exist assistants
 
@@ -238,6 +263,10 @@ class Assistants(CreateMixin, CancelMixin, DeleteMixin, ListObjectMixin,
             metadata (Dict, optional): Custom key-value pairs associate with assistant. Defaults to None.
             workspace (str): The DashScope workspace id.
             api_key (str, optional): The DashScope workspace id. Defaults to None.
+            top_p (float, optional): top_p parameter for model. Defaults to None.
+            top_k (int, optional): top_p parameter for model. Defaults to None.
+            temperature (float, optional): temperature parameter for model. Defaults to None.
+            max_tokens (int, optional): max_tokens parameter for model. Defaults to None.
 
         Returns:
             Assistant: The updated assistant.
@@ -247,7 +276,7 @@ class Assistants(CreateMixin, CancelMixin, DeleteMixin, ListObjectMixin,
         response = super().update(assistant_id,
                                   cls._create_assistant_object(
                                       model, name, description, instructions,
-                                      tools, file_ids, metadata),
+                                      tools, file_ids, metadata, top_p, top_k, temperature, max_tokens),
                                   api_key=api_key,
                                   workspace=workspace,
                                   flattened_output=True,

dashscope/assistants/files.py

@@ -1,4 +1,5 @@
 # Copyright (c) Alibaba, Inc. and its affiliates.
+from typing import Optional
 
 from dashscope.assistants.assistant_types import (AssistantFile,
                                                   AssistantFileList,
@@ -148,7 +149,7 @@ class Files(CreateMixin, DeleteMixin, ListObjectMixin, GetStatusMixin):
             assistant_id: str,
             workspace: str = None,
             api_key: str = None,
-            **kwargs) -> AssistantFile:
+            **kwargs) -> Optional[AssistantFile]:
         """Retrieve file information.
 
         Args:
@@ -160,6 +161,11 @@ class Files(CreateMixin, DeleteMixin, ListObjectMixin, GetStatusMixin):
         Returns:
             AssistantFile: The `AssistantFile` object.
         """
+        response = super().get(target=assistant_id + '/files/' + file_id, api_key=api_key, workspace=workspace, **kwargs)
+        if response.status_code == 200 and response.output:
+            return AssistantFile(**response.output)
+        else:
+            return None
 
     @classmethod
     def delete(cls,

dashscope/audio/__init__.py

@@ -1,5 +1,5 @@
 # Copyright (c) Alibaba, Inc. and its affiliates.
 
-from . import asr, tts, tts_v2, qwen_tts
+from . import asr, tts, tts_v2, qwen_tts, qwen_tts_realtime, qwen_omni
 
-__all__ = [asr, tts, tts_v2, qwen_tts]
+__all__ = [asr, tts, tts_v2, qwen_tts, qwen_tts_realtime, qwen_omni]

dashscope/audio/qwen_omni/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
+from .omni_realtime import (AudioFormat, MultiModality, OmniRealtimeCallback,
+                            OmniRealtimeConversation)
+
+__all__ = [
+    'OmniRealtimeCallback',
+    'AudioFormat',
+    'MultiModality',
+    'OmniRealtimeConversation',
+]

dashscope/audio/qwen_omni/omni_realtime.py

@@ -0,0 +1,415 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
+import json
+import platform
+import threading
+import time
+from typing import List
+import uuid
+from enum import Enum, unique
+
+import dashscope
+import websocket
+from dashscope.common.error import InputRequired, ModelRequired
+from dashscope.common.logging import logger
+
+
+class OmniRealtimeCallback:
+    """
+    An interface that defines callback methods for getting omni-realtime results. # noqa E501
+    Derive from this class and implement its function to provide your own data.
+    """
+    def on_open(self) -> None:
+        pass
+
+    def on_close(self, close_status_code, close_msg) -> None:
+        pass
+
+    def on_event(self, message: str) -> None:
+        pass
+
+
+@unique
+class AudioFormat(Enum):
+    # format, sample_rate, channels, bit_rate, name
+    PCM_16000HZ_MONO_16BIT = ('pcm', 16000, 'mono', '16bit', 'pcm16')
+    PCM_24000HZ_MONO_16BIT = ('pcm', 24000, 'mono', '16bit', 'pcm16')
+
+    def __init__(self, format, sample_rate, channels, bit_rate, format_str):
+        self.format = format
+        self.sample_rate = sample_rate
+        self.channels = channels
+        self.bit_rate = bit_rate
+        self.format_str = format_str
+
+    def __repr__(self):
+        return self.format_str
+
+    def __str__(self):
+        return f'{self.format.upper()} with {self.sample_rate}Hz sample rate, {self.channels} channel, {self.bit_rate} bit rate:  {self.format_str}'
+
+
+class MultiModality(Enum):
+    """
+    MultiModality
+    """
+    TEXT = 'text'
+    AUDIO = 'audio'
+
+    def __str__(self):
+        return self.name
+
+
+class OmniRealtimeConversation:
+    def __init__(
+        self,
+        model,
+        callback: OmniRealtimeCallback,
+        headers=None,
+        workspace=None,
+        url=None,
+        additional_params=None,
+    ):
+        """
+        Qwen Omni Realtime SDK
+        Parameters:
+        -----------
+        model: str
+            Model name.
+        headers: Dict
+            User-defined headers.
+        callback: OmniRealtimeCallback
+            Callback to receive real-time omni results.
+        workspace: str
+            Dashscope workspace ID.
+        url: str
+            Dashscope WebSocket URL.
+        additional_params: Dict
+            Additional parameters for the Dashscope API.
+        """
+
+        if model is None:
+            raise ModelRequired('Model is required!')
+        if callback is None:
+            raise ModelRequired('Callback is required!')
+        if url is None:
+            url = f'wss://dashscope.aliyuncs.com/api-ws/v1/realtime?model={model}'
+        else:
+            url = f'{url}?model={model}'
+        self.url = url
+        self.apikey = dashscope.api_key
+        self.user_headers = headers
+        self.user_workspace = workspace
+        self.model = model
+        self.config = {}
+        self.callback = callback
+        self.ws = None
+        self.session_id = None
+        self.last_message = None
+        self.last_response_id = None
+        self.last_response_create_time = None
+        self.last_first_text_delay = None
+        self.last_first_audio_delay = None
+        self.metrics = []
+
+    def _generate_event_id(self):
+        '''
+        generate random event id: event_xxxx
+        '''
+        return 'event_' + uuid.uuid4().hex
+
+    def _get_websocket_header(self, ):
+        ua = 'dashscope/%s; python/%s; platform/%s; processor/%s' % (
+            '1.18.0',  # dashscope version
+            platform.python_version(),
+            platform.platform(),
+            platform.processor(),
+        )
+        headers = {
+            'user-agent': ua,
+            'Authorization': 'bearer ' + self.apikey,
+        }
+        if self.user_headers:
+            headers = {**self.user_headers, **headers}
+        if self.user_workspace:
+            headers = {
+                **headers,
+                'X-DashScope-WorkSpace': self.user_workspace,
+            }
+        return headers
+
+    def connect(self) -> None:
+        '''
+        connect to server, create session and return default session configuration
+        '''
+        self.ws = websocket.WebSocketApp(
+            self.url,
+            header=self._get_websocket_header(),
+            on_message=self.on_message,
+            on_error=self.on_error,
+            on_close=self.on_close,
+        )
+        self.thread = threading.Thread(target=self.ws.run_forever)
+        self.thread.daemon = True
+        self.thread.start()
+        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)  # 短暂休眠，避免密集轮询
+        if not (self.ws.sock and self.ws.sock.connected):
+            raise TimeoutError(
+                'websocket connection could not established within 5s. '
+                'Please check your network connection, firewall settings, or server status.'
+            )
+        self.callback.on_open()
+
+    def __send_str(self, data: str, enable_log: bool = True):
+        if enable_log:
+            logger.debug('[omni realtime] send string: {}'.format(data))
+        self.ws.send(data)
+
+    def update_session(self,
+                       output_modalities: List[MultiModality],
+                       voice: str,
+                       input_audio_format: AudioFormat = AudioFormat.
+                       PCM_16000HZ_MONO_16BIT,
+                       output_audio_format: AudioFormat = AudioFormat.
+                       PCM_24000HZ_MONO_16BIT,
+                       enable_input_audio_transcription: bool = True,
+                       input_audio_transcription_model: str = None,
+                       enable_turn_detection: bool = True,
+                       turn_detection_type: str = 'server_vad',
+                       prefix_padding_ms: int = 300,
+                       turn_detection_threshold: float = 0.2,
+                       turn_detection_silence_duration_ms: int = 800,
+                       turn_detection_param: dict = None,
+                       **kwargs) -> None:
+        '''
+        update session configuration, should be used before create response
+
+        Parameters
+        ----------
+        output_modalities: list[MultiModality]
+            omni output modalities to be used in session
+        voice: str
+            voice to be used in session
+        input_audio_format: AudioFormat
+            input audio format
+        output_audio_format: AudioFormat
+            output audio format
+        enable_turn_detection: bool
+            enable turn detection
+        turn_detection_threshold: float
+            turn detection threshold, range [-1, 1]
+            In a noisy environment, it may be necessary to increase the threshold to reduce false detections
+            In a quiet environment, it may be necessary to decrease the threshold to improve sensitivity
+        turn_detection_silence_duration_ms: int
+            duration of silence in milliseconds to detect turn, range [200, 6000]
+        '''
+        self.config = {
+            'modalities': [m.value for m in output_modalities],
+            'voice': voice,
+            'input_audio_format': input_audio_format.format_str,
+            'output_audio_format': output_audio_format.format_str,
+        }
+        if enable_input_audio_transcription:
+            self.config['input_audio_transcription'] = {
+                'model': input_audio_transcription_model,
+            }
+        else:
+            self.config['input_audio_transcription'] = None
+        if enable_turn_detection:
+            self.config['turn_detection'] = {
+                'type': turn_detection_type,
+                'threshold': turn_detection_threshold,
+                'prefix_padding_ms': prefix_padding_ms,
+                'silence_duration_ms': turn_detection_silence_duration_ms,
+            }
+            if turn_detection_param is not None:
+                self.config['turn_detection'].update(turn_detection_param)
+        else:
+            self.config['turn_detection'] = None
+        self.config.update(kwargs)
+        self.__send_str(
+            json.dumps({
+                'event_id': self._generate_event_id(),
+                'type': 'session.update',
+                'session': self.config
+            }))
+
+    def append_audio(self, audio_b64: str) -> None:
+        '''
+        send audio in base64 format
+
+        Parameters
+        ----------
+        audio_b64: str
+            base64 audio string
+        '''
+        logger.debug('[omni realtime] append audio: {}'.format(len(audio_b64)))
+        self.__send_str(
+            json.dumps({
+                'event_id': self._generate_event_id(),
+                'type': 'input_audio_buffer.append',
+                'audio': audio_b64
+            }), False)
+
+    def append_video(self, video_b64: str) -> None:
+        '''
+        send one image frame in video in base64 format
+
+        Parameters
+        ----------
+        video_b64: str
+            base64 image string
+        '''
+        logger.debug('[omni realtime] append video: {}'.format(len(video_b64)))
+        self.__send_str(
+            json.dumps({
+                'event_id': self._generate_event_id(),
+                'type': 'input_image_buffer.append',
+                'image': video_b64
+            }), False)
+
+    def commit(self, ) -> None:
+        '''
+        Commit the audio and video sent before.
+        When in Server VAD mode, the client does not need to use this method,
+        the server will commit the audio automatically after detecting vad end.
+        '''
+        self.__send_str(
+            json.dumps({
+                'event_id': self._generate_event_id(),
+                'type': 'input_audio_buffer.commit'
+            }))
+
+    def clear_appended_audio(self, ) -> None:
+        '''
+        clear the audio sent to server before.
+        '''
+        self.__send_str(
+            json.dumps({
+                'event_id': self._generate_event_id(),
+                'type': 'input_audio_buffer.clear'
+            }))
+
+    def create_response(self,
+                        instructions: str = None,
+                        output_modalities: List[MultiModality] = None) -> None:
+        '''
+        create response, use audio and video commited before to request llm.
+        When in Server VAD mode, the client does not need to use this method,
+        the server will create response automatically after detecting vad
+        and sending commit.
+
+        Parameters
+        ----------
+        instructions: str
+            instructions to llm
+        output_modalities: list[MultiModality]
+            omni output modalities to be used in session
+        '''
+        request = {
+            'event_id': self._generate_event_id(),
+            'type': 'response.create',
+            'response': {}
+        }
+        request['response']['instructions'] = instructions
+        if output_modalities:
+            request['response']['modalities'] = [
+                m.value for m in output_modalities
+            ]
+        self.__send_str(json.dumps(request))
+
+    def cancel_response(self, ) -> None:
+        '''
+        cancel the current response
+        '''
+        self.__send_str(
+            json.dumps({
+                'event_id': self._generate_event_id(),
+                'type': 'response.cancel'
+            }))
+
+    def send_raw(self, raw_data: str) -> None:
+        '''
+        send raw data to server
+        '''
+        self.__send_str(raw_data)
+
+    def close(self, ) -> None:
+        '''
+        close the connection to server
+        '''
+        self.ws.close()
+
+    # 监听消息的回调函数
+    def on_message(self, ws, message):
+        if isinstance(message, str):
+            logger.debug('[omni realtime] receive string {}'.format(
+                message[:1024]))
+            try:
+                # 尝试将消息解析为JSON
+                json_data = json.loads(message)
+                self.last_message = json_data
+                self.callback.on_event(json_data)
+                if 'type' in message:
+                    if 'session.created' == json_data['type']:
+                        self.session_id = json_data['session']['id']
+                    if 'response.created' == json_data['type']:
+                        self.last_response_id = json_data['response']['id']
+                        self.last_response_create_time = time.time() * 1000
+                        self.last_first_audio_delay = None
+                        self.last_first_text_delay = None
+                    elif 'response.audio_transcript.delta' == json_data[
+                            'type']:
+                        if self.last_response_create_time and self.last_first_text_delay is None:
+                            self.last_first_text_delay = time.time(
+                            ) * 1000 - self.last_response_create_time
+                    elif 'response.audio.delta' == json_data['type']:
+                        if self.last_response_create_time and self.last_first_audio_delay is None:
+                            self.last_first_audio_delay = time.time(
+                            ) * 1000 - self.last_response_create_time
+                    elif 'response.done' == json_data['type']:
+                        logger.info(
+                            '[Metric] response: {}, first text delay: {}, first audio delay: {}'
+                            .format(self.last_response_id,
+                                    self.last_first_text_delay,
+                                    self.last_first_audio_delay))
+            except json.JSONDecodeError:
+                logger.error('Failed to parse message as JSON.')
+                raise Exception('Failed to parse message as JSON.')
+        elif isinstance(message, (bytes, bytearray)):
+            # 如果失败，认为是二进制消息
+            logger.error(
+                'should not receive binary message in omni realtime api')
+            logger.debug('[omni realtime] receive binary {} bytes'.format(
+                len(message)))
+
+    def on_close(self, ws, close_status_code, close_msg):
+        self.callback.on_close(close_status_code, close_msg)
+
+    # WebSocket发生错误的回调函数
+    def on_error(self, ws, error):
+        print(f'websocket closed due to {error}')
+        raise Exception(f'websocket closed due to {error}')
+
+    # 获取上一个任务的taskId
+    def get_session_id(self) -> str:
+        return self.session_id
+
+    def get_last_message(self) -> str:
+        return self.last_message
+
+    def get_last_message(self) -> str:
+        return self.last_message
+
+    def get_last_response_id(self) -> str:
+        return self.last_response_id
+
+    def get_last_first_text_delay(self):
+        return self.last_first_text_delay
+
+    def get_last_first_audio_delay(self):
+        return self.last_first_audio_delay

dashscope/audio/qwen_tts_realtime/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
+from .qwen_tts_realtime import (AudioFormat, QwenTtsRealtimeCallback,
+                            QwenTtsRealtime)
+
+__all__ = [
+    'AudioFormat',
+    'QwenTtsRealtimeCallback',
+    'QwenTtsRealtime',
+]