dashscope 1.21.0__py3-none-any.whl → 1.22.0__py3-none-any.whl

dashscope/api_entities/aiohttp_request.py

@@ -2,7 +2,6 @@ import json
 from http import HTTPStatus
 
 import aiohttp
-
 from dashscope.api_entities.base_request import AioBaseRequest
 from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
 from dashscope.common.constants import (DEFAULT_REQUEST_TIMEOUT_SECONDS,

dashscope/api_entities/api_request_data.py

@@ -2,7 +2,6 @@ import json
 from urllib.parse import urlencode
 
 import aiohttp
-
 from dashscope.common.constants import ApiProtocol
 from dashscope.io.input_output import InputResolver
 

dashscope/api_entities/api_request_factory.py

@@ -81,13 +81,15 @@ def _build_api_request(model: str,
             websocket_url = base_address
         else:
             websocket_url = dashscope.base_websocket_api_url
+        pre_task_id = kwargs.pop('pre_task_id', None)
         request = WebSocketRequest(url=websocket_url,
                                    api_key=api_key,
                                    stream=stream,
                                    ws_stream_mode=ws_stream_mode,
                                    is_binary_input=is_binary_input,
                                    timeout=request_timeout,
-                                   flattened_output=flattened_output)
+                                   flattened_output=flattened_output,
+                                   pre_task_id=pre_task_id)
     else:
         raise UnsupportedApiProtocol(
             'Unsupported protocol: %s, support [http, https, websocket]' %

dashscope/api_entities/http_request.py

@@ -3,7 +3,6 @@ from http import HTTPStatus
 
 import aiohttp
 import requests
-
 from dashscope.api_entities.base_request import AioBaseRequest
 from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
 from dashscope.common.constants import (DEFAULT_REQUEST_TIMEOUT_SECONDS,

dashscope/api_entities/websocket_request.py

@@ -5,7 +5,6 @@ from http import HTTPStatus
 from typing import Tuple, Union
 
 import aiohttp
-
 from dashscope.api_entities.base_request import AioBaseRequest
 from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
 from dashscope.common.constants import (DEFAULT_REQUEST_TIMEOUT_SECONDS,
@@ -31,6 +30,7 @@ class WebSocketRequest(AioBaseRequest):
         is_binary_input: bool = False,
         timeout: int = DEFAULT_REQUEST_TIMEOUT_SECONDS,
         flattened_output: bool = False,
+        pre_task_id=None,
     ) -> None:
         super().__init__()
         """HttpRequest.
@@ -61,6 +61,7 @@ class WebSocketRequest(AioBaseRequest):
         self.task_headers = {
             'streaming': self.ws_stream_mode,
         }
+        self.pre_task_id = pre_task_id
 
     def add_headers(self, headers):
         self.headers = {**self.headers, **headers}
@@ -77,6 +78,10 @@ class WebSocketRequest(AioBaseRequest):
                 pass
             return output
 
+    async def close(self):
+        if self.ws is not None and not self.ws.closed:
+            await self.ws.close()
+
     async def aio_call(self):
         response = self.connection_handler()
         if self.stream:
@@ -140,7 +145,11 @@ class WebSocketRequest(AioBaseRequest):
                                        code=e.name,
                                        message=e.message)
         except aiohttp.ClientConnectorError as e:
-            raise e
+            logger.exception(e)
+            yield DashScopeAPIResponse(request_id='',
+                                       status_code=-1,
+                                       code='ClientConnectorError',
+                                       message=str(e))
         except aiohttp.WSServerHandshakeError as e:
             code = e.status
             msg = e.message
@@ -227,17 +236,22 @@ class WebSocketRequest(AioBaseRequest):
         raise error
 
     async def _start_task(self, ws):
-        self.task_headers['task_id'] = uuid.uuid4().hex  # create task id.
+        if self.pre_task_id is not None:
+            self.task_headers['task_id'] = self.pre_task_id
+        else:
+            self.task_headers['task_id'] = uuid.uuid4().hex  # create task id.
         task_header = {**self.task_headers, ACTION_KEY: ActionType.START}
         # for binary data, the start action has no input, only parameters.
         start_data = self.data.get_websocket_start_data()
         message = self._build_up_message(task_header, start_data)
+        logger.debug('Send start task: {}'.format(message))
         await ws.send_str(message)
 
     async def _send_finished_task(self, ws):
         task_header = {**self.task_headers, ACTION_KEY: ActionType.FINISHED}
         payload = {'input': {}}
         message = self._build_up_message(task_header, payload)
+        logger.debug('Send finish task: {}'.format(message))
         await ws.send_str(message)
 
     async def _send_continue_task_data(self, ws):
@@ -250,12 +264,19 @@ class WebSocketRequest(AioBaseRequest):
                 if len(input) > 0:
                     if isinstance(input, bytes):
                         await ws.send_bytes(input)
+                        logger.debug(
+                            'Send continue task with bytes: {}'.format(
+                                len(input)))
                     else:
                         await ws.send_bytes(list(input.values())[0])
+                        logger.debug(
+                            'Send continue task with list[byte]: {}'.format(
+                                len(input)))
             else:
                 if len(input) > 0:
                     message = self._build_up_message(headers=headers,
                                                      payload=input)
+                    logger.debug('Send continue task: {}'.format(message))
                     await ws.send_str(message)
             await asyncio.sleep(0.000001)
 

dashscope/audio/asr/__init__.py

@@ -1,9 +1,18 @@
 from .asr_phrase_manager import AsrPhraseManager
 from .recognition import Recognition, RecognitionCallback, RecognitionResult
 from .transcription import Transcription
+from .translation_recognizer import (TranscriptionResult, Translation,
+                                     TranslationRecognizerCallback,
+                                     TranslationRecognizerChat,
+                                     TranslationRecognizerRealtime,
+                                     TranslationRecognizerResultPack,
+                                     TranslationResult)
 from .vocabulary import VocabularyService, VocabularyServiceException
 
 __all__ = [
     'Transcription', 'Recognition', 'RecognitionCallback', 'RecognitionResult',
-    'AsrPhraseManager', 'VocabularyServiceException', 'VocabularyService'
+    'AsrPhraseManager', 'VocabularyServiceException', 'VocabularyService',
+    'TranslationRecognizerRealtime', 'TranslationRecognizerChat',
+    'TranslationRecognizerCallback', 'Translation', 'TranslationResult',
+    'TranscriptionResult', 'TranslationRecognizerResultPack'
 ]

dashscope/audio/asr/recognition.py

@@ -2,7 +2,9 @@ import json
 import os
 import threading
 import time
+import uuid
 from http import HTTPStatus
+from queue import Queue
 from threading import Timer
 from typing import Any, Dict, List, Union
 
@@ -153,18 +155,22 @@ class Recognition(BaseApi):
         self._recognition_once = False
         self._callback = callback
         self._running = False
-        self._stream_data = []
+        self._stream_data = Queue()
         self._worker = None
         self._silence_timer = None
         self._kwargs = kwargs
         self._workspace = workspace
         self._start_stream_timestamp = -1
         self._first_package_timestamp = -1
+        self._stop_stream_timestamp = -1
+        self._on_complete_timestamp = -1
+        self.request_id_confirmed = False
+        self.last_request_id = uuid.uuid4().hex
 
     def __del__(self):
         if self._running:
             self._running = False
-            self._stream_data.clear()
+            self._stream_data = Queue()
             if self._worker is not None and self._worker.is_alive():
                 self._worker.join()
             if self._silence_timer is not None and self._silence_timer.is_alive(  # noqa E501
@@ -182,6 +188,9 @@ class Recognition(BaseApi):
         for part in responses:
             if part.status_code == HTTPStatus.OK:
                 if len(part.output) == 0:
+                    self._on_complete_timestamp = time.time() * 1000
+                    logger.debug('last package delay {}'.format(
+                        self.get_last_package_delay()))
                     self._callback.on_complete()
                 else:
                     usage: Dict[str, Any] = None
@@ -190,12 +199,12 @@ class Recognition(BaseApi):
                         if (self._first_package_timestamp < 0):
                             self._first_package_timestamp = time.time() * 1000
                             logger.debug('first package delay {}'.format(
-                                self._first_package_timestamp -
-                                self._start_stream_timestamp))
+                                self.get_first_package_delay()))
                         sentence = part.output['sentence']
-                        logger.debug('Recv Result :{}, isEnd: {}'.format(
-                            sentence,
-                            RecognitionResult.is_sentence_end(sentence)))
+                        logger.debug(
+                            'Recv Result [rid:{}]:{}, isEnd: {}'.format(
+                                part.request_id, sentence,
+                                RecognitionResult.is_sentence_end(sentence)))
                         if part.usage is not None:
                             usage = {
                                 'end_time':
@@ -203,6 +212,9 @@ class Recognition(BaseApi):
                                 'usage': part.usage
                             }
                             usages = [usage]
+                        if self.request_id_confirmed is False and part.request_id is not None:
+                            self.last_request_id = part.request_id
+                            self.request_id_confirmed = True
 
                     self._callback.on_event(
                         RecognitionResult(
@@ -210,7 +222,7 @@ class Recognition(BaseApi):
                             usages=usages))
             else:
                 self._running = False
-                self._stream_data.clear()
+                self._stream_data = Queue()
                 self._callback.on_error(
                     RecognitionResult(
                         RecognitionResponse.from_api_response(part)))
@@ -242,6 +254,7 @@ class Recognition(BaseApi):
                                  format=self.format,
                                  stream=True,
                                  workspace=self._workspace,
+                                 pre_task_id=self.last_request_id,
                                  **self._kwargs)
         return responses
 
@@ -276,6 +289,8 @@ class Recognition(BaseApi):
 
         self._start_stream_timestamp = -1
         self._first_package_timestamp = -1
+        self._stop_stream_timestamp = -1
+        self._on_complete_timestamp = -1
         self._phrase = phrase_id
         self._kwargs.update(**kwargs)
         self._recognition_once = False
@@ -334,7 +349,7 @@ class Recognition(BaseApi):
             raise FileNotFoundError('No such file or directory: ' + file)
 
         self._recognition_once = True
-        self._stream_data.clear()
+        self._stream_data = Queue()
         self._phrase = phrase_id
         self._kwargs.update(**kwargs)
         error_flag: bool = False
@@ -352,16 +367,17 @@ class Recognition(BaseApi):
                     if not audio_data:
                         break
                     else:
-                        self._stream_data = self._stream_data + [audio_data]
+                        self._stream_data.put(audio_data)
             else:
                 raise InputDataRequired(
                     'The supplied file was empty (zero bytes long)')
             f.close()
+            self._stop_stream_timestamp = time.time() * 1000
         except Exception as e:
             logger.error(e)
             raise e
 
-        if self._stream_data is not None and len(self._stream_data) > 0:
+        if not self._stream_data.empty():
             self._running = True
             responses = self.__launch_request()
             for part in responses:
@@ -373,9 +389,10 @@ class Recognition(BaseApi):
                                 self._first_package_timestamp -
                                 self._start_stream_timestamp))
                         sentence = part.output['sentence']
-                        logger.debug('Recv Result :{}, isEnd: {}'.format(
-                            sentence,
-                            RecognitionResult.is_sentence_end(sentence)))
+                        logger.debug(
+                            'Recv Result [rid:{}]:{}, isEnd: {}'.format(
+                                part.request_id, sentence,
+                                RecognitionResult.is_sentence_end(sentence)))
                         if RecognitionResult.is_sentence_end(sentence):
                             sentences.append(sentence)
 
@@ -394,12 +411,16 @@ class Recognition(BaseApi):
                     error_flag = True
                     break
 
+        self._on_complete_timestamp = time.time() * 1000
+        logger.debug('last package delay {}'.format(
+            self.get_last_package_delay()))
+
         if error_flag:
             result = RecognitionResult(response)
         else:
             result = RecognitionResult(response, sentences, usages)
 
-        self._stream_data.clear()
+        self._stream_data = Queue()
         self._recognition_once = False
         self._running = False
 
@@ -414,10 +435,12 @@ class Recognition(BaseApi):
         if self._running is False:
             raise InvalidParameter('Speech recognition has stopped.')
 
+        self._stop_stream_timestamp = time.time() * 1000
+
         self._running = False
         if self._worker is not None and self._worker.is_alive():
             self._worker.join()
-        self._stream_data.clear()
+        self._stream_data = Queue()
         if self._silence_timer is not None and self._silence_timer.is_alive():
             self._silence_timer.cancel()
             self._silence_timer = None
@@ -436,7 +459,7 @@ class Recognition(BaseApi):
         if (self._start_stream_timestamp < 0):
             self._start_stream_timestamp = time.time() * 1000
         logger.debug('send_audio_frame: {}'.format(len(buffer)))
-        self._stream_data = self._stream_data + [buffer]
+        self._stream_data.put(buffer)
 
     def _tidy_kwargs(self):
         for k in self._kwargs.copy():
@@ -445,8 +468,9 @@ class Recognition(BaseApi):
 
     def _input_stream_cycle(self):
         while self._running:
-            while len(self._stream_data) == 0:
+            while self._stream_data.empty():
                 if self._running:
+                    time.sleep(0.01)
                     continue
                 else:
                     break
@@ -459,16 +483,17 @@ class Recognition(BaseApi):
                                             self._silence_stop_timer)
                 self._silence_timer.start()
 
-            for frame in self._stream_data:
+            while not self._stream_data.empty():
+                frame = self._stream_data.get()
                 yield bytes(frame)
-            self._stream_data.clear()
 
             if self._recognition_once:
                 self._running = False
 
         # drain all audio data when invoking stop().
         if self._recognition_once is False:
-            for frame in self._stream_data:
+            while not self._stream_data.empty():
+                frame = self._stream_data.get()
                 yield bytes(frame)
 
     def _silence_stop_timer(self):
@@ -480,4 +505,18 @@ class Recognition(BaseApi):
         self._silence_timer = None
         if self._worker is not None and self._worker.is_alive():
             self._worker.join()
-        self._stream_data.clear()
+        self._stream_data = Queue()
+
+    def get_first_package_delay(self):
+        """First Package Delay is the time between start sending audio and receive first words package
+        """
+        return self._first_package_timestamp - self._start_stream_timestamp
+
+    def get_last_package_delay(self):
+        """Last Package Delay is the time between stop sending audio and receive last words package
+        """
+        return self._on_complete_timestamp - self._stop_stream_timestamp
+
+    # 获取上一个任务的taskId
+    def get_last_request_id(self):
+        return self.last_request_id