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

dashscope/audio/qwen_tts_realtime/qwen_tts_realtime.py

@@ -0,0 +1,314 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
+import json
+import platform
+import threading
+import time
+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 QwenTtsRealtimeCallback:
+    """
+    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_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 QwenTtsRealtime:
+    def __init__(
+        self,
+        model,
+        headers=None,
+        callback: QwenTtsRealtimeCallback = None,
+        workspace=None,
+        url=None,
+        additional_params=None,
+    ):
+        """
+        Qwen Tts 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 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_first_text_time = 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('[qwen tts realtime] send string: {}'.format(data))
+        self.ws.send(data)
+
+    def update_session(self,
+                       voice: str,
+                       response_format: AudioFormat = AudioFormat.
+                       PCM_24000HZ_MONO_16BIT,
+                       mode: str = 'server_commit',
+                       **kwargs) -> None:
+        '''
+        update session configuration, should be used before create response
+
+        Parameters
+        ----------
+        voice: str
+            voice to be used in session
+        response_format: AudioFormat
+            output audio format
+        mode: str
+            response mode, server_commit or commit
+        '''
+        self.config = {
+            'voice': voice,
+            'mode': mode,
+            'response_format': response_format.format,
+            'sample_rate': response_format.sample_rate,
+        }
+        self.config.update(kwargs)
+        self.__send_str(
+            json.dumps({
+                'event_id': self._generate_event_id(),
+                'type': 'session.update',
+                'session': self.config
+            }))
+
+    def append_text(self, text: str) -> None:
+        '''
+        send text
+
+        Parameters
+        ----------
+        text: str
+            text to send
+        '''
+        self.__send_str(
+            json.dumps({
+                'event_id': self._generate_event_id(),
+                'type': 'input_text_buffer.append',
+                'text': text
+            }))
+        if self.last_first_text_time is None:
+            self.last_first_text_time = time.time() * 1000
+
+    def commit(self, ) -> None:
+        '''
+        commit the text sent before, create response and start synthesis audio.
+        '''
+        self.__send_str(
+            json.dumps({
+                'event_id': self._generate_event_id(),
+                'type': 'input_text_buffer.commit'
+            }))
+
+    def clear_appended_text(self, ) -> None:
+        '''
+        clear the text sent to server before.
+        '''
+        self.__send_str(
+            json.dumps({
+                'event_id': self._generate_event_id(),
+                'type': 'input_text_buffer.clear'
+            }))
+
+    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 finish(self, ) -> None:
+        '''
+        finish input text stream, server will synthesis all text in buffer and close the connection
+        '''
+        self.__send_str(
+            json.dumps({
+                'event_id': self._generate_event_id(),
+                'type': 'session.finish'
+            }))
+
+    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']
+                    elif 'response.audio.delta' == json_data['type']:
+                        if self.last_first_text_time and self.last_first_audio_delay is None:
+                            self.last_first_audio_delay = time.time(
+                            ) * 1000 - self.last_first_text_time
+                    elif 'response.done' == json_data['type']:
+                        logger.debug(
+                            '[Metric] response: {}, first audio delay: {}'
+                            .format(self.last_response_id,
+                                    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):
+        logger.debug(
+            '[omni realtime] connection closed with code {} and message {}'.format(
+                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):
+        return self.session_id
+
+    def get_last_message(self):
+        return self.last_message
+
+    def get_last_response_id(self):
+        return self.last_response_id
+
+    def get_first_audio_delay(self):
+        return self.last_first_audio_delay

dashscope/audio/tts_v2/speech_synthesizer.py

@@ -43,28 +43,39 @@ class ResultCallback:
 
 @unique
 class AudioFormat(Enum):
-    DEFAULT = ('Default', 0, '0', '0')
-    WAV_8000HZ_MONO_16BIT = ('wav', 8000, 'mono', '16bit')
-    WAV_16000HZ_MONO_16BIT = ('wav', 16000, 'mono', '16bit')
-    WAV_22050HZ_MONO_16BIT = ('wav', 22050, 'mono', '16bit')
-    WAV_24000HZ_MONO_16BIT = ('wav', 24000, 'mono', '16bit')
-    WAV_44100HZ_MONO_16BIT = ('wav', 44100, 'mono', '16bit')
-    WAV_48000HZ_MONO_16BIT = ('wav', 48000, 'mono', '16bit')
-
-    MP3_8000HZ_MONO_128KBPS = ('mp3', 8000, 'mono', '128kbps')
-    MP3_16000HZ_MONO_128KBPS = ('mp3', 16000, 'mono', '128kbps')
-    MP3_22050HZ_MONO_256KBPS = ('mp3', 22050, 'mono', '256kbps')
-    MP3_24000HZ_MONO_256KBPS = ('mp3', 24000, 'mono', '256kbps')
-    MP3_44100HZ_MONO_256KBPS = ('mp3', 44100, 'mono', '256kbps')
-    MP3_48000HZ_MONO_256KBPS = ('mp3', 48000, 'mono', '256kbps')
-
-    PCM_8000HZ_MONO_16BIT = ('pcm', 8000, 'mono', '16bit')
-    PCM_16000HZ_MONO_16BIT = ('pcm', 16000, 'mono', '16bit')
-    PCM_22050HZ_MONO_16BIT = ('pcm', 22050, 'mono', '16bit')
-    PCM_24000HZ_MONO_16BIT = ('pcm', 24000, 'mono', '16bit')
-    PCM_44100HZ_MONO_16BIT = ('pcm', 44100, 'mono', '16bit')
-    PCM_48000HZ_MONO_16BIT = ('pcm', 48000, 'mono', '16bit')
-
+    DEFAULT = ('Default', 0, '0', 0)
+    WAV_8000HZ_MONO_16BIT = ('wav', 8000, 'mono', 0)
+    WAV_16000HZ_MONO_16BIT = ('wav', 16000, 'mono', 16)
+    WAV_22050HZ_MONO_16BIT = ('wav', 22050, 'mono', 16)
+    WAV_24000HZ_MONO_16BIT = ('wav', 24000, 'mono', 16)
+    WAV_44100HZ_MONO_16BIT = ('wav', 44100, 'mono', 16)
+    WAV_48000HZ_MONO_16BIT = ('wav', 48000, 'mono', 16)
+
+    MP3_8000HZ_MONO_128KBPS = ('mp3', 8000, 'mono', 128)
+    MP3_16000HZ_MONO_128KBPS = ('mp3', 16000, 'mono', 128)
+    MP3_22050HZ_MONO_256KBPS = ('mp3', 22050, 'mono', 256)
+    MP3_24000HZ_MONO_256KBPS = ('mp3', 24000, 'mono', 256)
+    MP3_44100HZ_MONO_256KBPS = ('mp3', 44100, 'mono', 256)
+    MP3_48000HZ_MONO_256KBPS = ('mp3', 48000, 'mono', 256)
+
+    PCM_8000HZ_MONO_16BIT = ('pcm', 8000, 'mono', 16)
+    PCM_16000HZ_MONO_16BIT = ('pcm', 16000, 'mono', 16)
+    PCM_22050HZ_MONO_16BIT = ('pcm', 22050, 'mono', 16)
+    PCM_24000HZ_MONO_16BIT = ('pcm', 24000, 'mono', 16)
+    PCM_44100HZ_MONO_16BIT = ('pcm', 44100, 'mono', 16)
+    PCM_48000HZ_MONO_16BIT = ('pcm', 48000, 'mono', 16)
+
+    OGG_OPUS_8KHZ_MONO_32KBPS = ("opus", 8000, "mono", 32)
+    OGG_OPUS_8KHZ_MONO_16KBPS = ("opus", 8000, "mono", 16)
+    OGG_OPUS_16KHZ_MONO_16KBPS = ("opus", 16000, "mono", 16)
+    OGG_OPUS_16KHZ_MONO_32KBPS = ("opus", 16000, "mono", 32)
+    OGG_OPUS_16KHZ_MONO_64KBPS = ("opus", 16000, "mono", 64)
+    OGG_OPUS_24KHZ_MONO_16KBPS = ("opus", 24000, "mono", 16)
+    OGG_OPUS_24KHZ_MONO_32KBPS = ("opus", 24000, "mono", 32)
+    OGG_OPUS_24KHZ_MONO_64KBPS = ("opus", 24000, "mono", 64)
+    OGG_OPUS_48KHZ_MONO_16KBPS = ("opus", 48000, "mono", 16)
+    OGG_OPUS_48KHZ_MONO_32KBPS = ("opus", 48000, "mono", 32)
+    OGG_OPUS_48KHZ_MONO_64KBPS = ("opus", 48000, "mono", 64)
     def __init__(self, format, sample_rate, channels, bit_rate):
         self.format = format
         self.sample_rate = sample_rate
@@ -83,6 +94,7 @@ class Request:
         voice,
         format='wav',
         sample_rate=16000,
+        bit_rate=64000,
         volume=50,
         speech_rate=1.0,
         pitch_rate=1.0,
@@ -93,6 +105,7 @@ class Request:
         self.model = model
         self.format = format
         self.sample_rate = sample_rate
+        self.bit_rate = bit_rate
         self.volume = volume
         self.speech_rate = speech_rate
         self.pitch_rate = pitch_rate
@@ -146,6 +159,8 @@ class Request:
                 },
             },
         }
+        if self.format == 'opus':
+            cmd['payload']['parameters']['bit_rate'] = self.bit_rate
         if additional_params:
             cmd['payload']['parameters'].update(additional_params)
         return json.dumps(cmd)
@@ -252,6 +267,7 @@ class SpeechSynthesizer:
             voice=voice,
             format=format.format,
             sample_rate=format.sample_rate,
+            bit_rate = format.bit_rate,
             volume=volume,
             speech_rate=speech_rate,
             pitch_rate=pitch_rate,

dashscope/cli.py

@@ -2,12 +2,14 @@
 import argparse
 import sys
 import time
+import os
 from http import HTTPStatus
 
 import dashscope
 from dashscope.aigc import Generation
 from dashscope.common.constants import (DeploymentStatus, FilePurpose,
                                         TaskStatus)
+from dashscope.utils.oss_utils import OssUtils
 
 
 def print_failed_message(rsp):
@@ -193,6 +195,34 @@ class FineTunes:
         else:
             print_failed_message(rsp)
 
+class Oss:
+    @classmethod
+    def upload(cls, args):
+        print('Start oss.upload: model=%s, file=%s, api_key=%s' % (args.model, args.file, args.api_key))
+        if not args.file or not args.model:
+            print('Please specify the model and file path')
+            return
+
+        file_path = os.path.expanduser(args.file)
+        if not os.path.exists(file_path):
+            print('File %s does not exist' % file_path)
+            return
+
+        api_key = os.environ.get('DASHSCOPE_API_KEY', args.api_key)
+        if not api_key:
+            print('Please set your DashScope API key as environment variable '
+                  'DASHSCOPE_API_KEY or pass it as argument by -k/--api_key')
+            return
+
+        oss_url = OssUtils.upload(model=args.model,
+                                  file_path=file_path,
+                                  api_key=api_key)
+
+        if not oss_url:
+            print('Failed to upload file: %s' % file_path)
+            return
+
+        print('Uploaded oss url: %s' % oss_url)
 
 class Files:
     @classmethod
@@ -477,6 +507,30 @@ def main():
                                   help='The fine-tune job id.')
     fine_tune_cancel.set_defaults(func=FineTunes.cancel)
 
+    oss_upload = sub_parsers.add_parser('oss.upload')
+    oss_upload.add_argument(
+        '-f',
+        '--file',
+        type=str,
+        required=True,
+        help='The file path to upload',
+    )
+    oss_upload.add_argument(
+        '-m',
+        '--model',
+        type=str,
+        required=True,
+        help='The model name',
+    )
+    oss_upload.add_argument(
+        '-k',
+        '--api_key',
+        type=str,
+        required=False,
+        help='The dashscope api key',
+    )
+    oss_upload.set_defaults(func=Oss.upload)
+
     file_upload = sub_parsers.add_parser('files.upload')
     file_upload.add_argument(
         '-f',

dashscope/embeddings/text_embedding.py

@@ -15,6 +15,7 @@ class TextEmbedding(BaseApi):
         text_embedding_v1 = 'text-embedding-v1'
         text_embedding_v2 = 'text-embedding-v2'
         text_embedding_v3 = 'text-embedding-v3'
+        text_embedding_v4 = 'text-embedding-v4'
 
     @classmethod
     def call(cls,

dashscope/multimodal/multimodal_request_params.py

@@ -83,12 +83,15 @@ class Upstream:
     # sample_rate: int  # 合成音频采样率
 
     def to_dict(self):
-        return {
+        upstream: dict = {
             "type": self.type,
             "mode": self.mode,
             "audio_format": self.audio_format,
             # "sample_rate": self.sample_rate
         }
+        if self.pass_through_params is not None:
+            upstream.update(self.pass_through_params)
+        return upstream
 
 
 @dataclass
@@ -105,6 +108,7 @@ class Downstream:
     volume: int = field(default=50)  # 语音音量 0-100
     pitch_rate: int = field(default=100)  # 语音语调 50-200
     speech_rate: int = field(default=100)  # 语音语速 50-200
+    pass_through_params: dict = field(default=None)
 
     def to_dict(self):
         stream: dict = {
@@ -120,6 +124,8 @@ class Downstream:
             stream["voice"] = self.voice
         if self.sample_rate != 0:
             stream["sample_rate"] = self.sample_rate
+        if self.pass_through_params is not None:
+            stream.update(self.pass_through_params)
         return stream
 
 
@@ -199,6 +205,7 @@ class BizParams:
     user_prompt_params: dict = field(default=None)
     user_query_params: dict = field(default=None)
     videos: list = field(default=None)
+    pass_through_params: dict = field(default=None)
 
     def to_dict(self):
         params = {}
@@ -214,6 +221,8 @@ class BizParams:
             params["user_query_params"] = self.user_query_params
         if self.videos is not None:
             params["videos"] = self.videos
+        if self.pass_through_params is not None:
+            params.update(self.pass_through_params)
         return params
 
 

dashscope/threads/runs/runs.py

@@ -82,6 +82,10 @@ class Runs(CreateMixin, CancelMixin, ListObjectMixin, GetStatusMixin,
                workspace: str = None,
                extra_body: Optional[Dict] = 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) -> Run:
         """Create a run.
 
@@ -122,6 +126,15 @@ class Runs(CreateMixin, CancelMixin, ListObjectMixin, GetStatusMixin,
         if extra_body is not None and extra_body:
             data = {**data, **extra_body}
 
+        if top_p is not None:
+            data['top_p'] = top_p
+        if top_k is not None:
+            data['top_k'] = top_k
+        if temperature is not None:
+            data['temperature'] = temperature
+        if max_tokens is not None:
+            data['max_tokens'] = max_tokens
+
         response = super().call(data=data,
                                 path=f'threads/{thread_id}/runs',
                                 api_key=api_key,
@@ -180,6 +193,10 @@ class Runs(CreateMixin, CancelMixin, ListObjectMixin, GetStatusMixin,
              workspace: str = None,
              extra_body: Optional[Dict] = 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) -> Run:
         """Create a run.
 
@@ -214,6 +231,10 @@ class Runs(CreateMixin, CancelMixin, ListObjectMixin, GetStatusMixin,
                           workspace=workspace,
                           extra_body=extra_body,
                           api_key=api_key,
+                          top_p=top_p,
+                          top_k=top_k,
+                          temperature=temperature,
+                          max_tokens=max_tokens,
                           **kwargs)
 
     @classmethod

dashscope/threads/thread_types.py

@@ -51,6 +51,13 @@ class Usage(BaseObjectMixin):
 
     total_tokens: int
     """Total number of tokens used (prompt + completion)."""
+
+    input_tokens: int
+    """Input tokens used (prompt)."""
+
+    output_tokens: int
+    """Output tokens used (completion)."""
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
 
@@ -302,6 +309,11 @@ class Run(BaseObjectMixin):
 
     tools: List[Tool]
 
+    top_p: Optional[float] = None
+    top_k: Optional[int] = None
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+
     usage: Optional[Usage] = None
 
     def __init__(self, **kwargs):

dashscope/utils/oss_utils.py

@@ -154,7 +154,10 @@ def check_and_upload_local(model: str, content: str, api_key: str):
             return True, file_url
         else:
             raise InvalidInput('The file: %s is not exists!' % file_path)
+    elif content.startswith('oss://'):
+        return True, content
     elif not content.startswith('http'):
+        content = os.path.expanduser(content)
         if os.path.isfile(content):
             file_url = OssUtils.upload(model=model,
                                        file_path=content,

dashscope/version.py

@@ -1,3 +1,3 @@
 # Copyright (c) Alibaba, Inc. and its affiliates.
 
-__version__ = '1.23.8'
+__version__ = '1.24.0'

{dashscope-1.23.8.dist-info → dashscope-1.24.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dashscope
-Version: 1.23.8
+Version: 1.24.0
 Summary: dashscope client sdk library
 Home-page: https://dashscope.aliyun.com/
 Author: Alibaba Cloud