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

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