dashscope 1.8.0__py3-none-any.whl → 1.25.6__py3-none-any.whl

dashscope/audio/asr/asr_phrase_manager.py

@@ -0,0 +1,203 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
+from http import HTTPStatus
+from typing import Any, Dict
+
+from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
+from dashscope.client.base_api import BaseAsyncApi
+from dashscope.common.error import InvalidParameter
+from dashscope.common.logging import logger
+from dashscope.customize.finetunes import FineTunes
+
+
+class AsrPhraseManager(BaseAsyncApi):
+    """Hot word management for speech recognition.
+    """
+    @classmethod
+    def create_phrases(cls,
+                       model: str,
+                       phrases: Dict[str, Any],
+                       training_type: str = 'compile_asr_phrase',
+                       workspace: str = None,
+                       **kwargs) -> DashScopeAPIResponse:
+        """Create hot words.
+
+        Args:
+            model (str): The requested model.
+            phrases (Dict[str, Any]): A dictionary that contains phrases,
+                such as {'下一首':90,'上一首':90}.
+            training_type (str, `optional`): The training type,
+                'compile_asr_phrase' is default.
+            workspace (str): The dashscope workspace id.
+
+        Raises:
+            InvalidParameter: Parameter input is None or empty!
+
+        Returns:
+            DashScopeAPIResponse: The results of creating hot words.
+        """
+        if phrases is None or len(phrases) == 0:
+            raise InvalidParameter('phrases is empty!')
+        if training_type is None or len(training_type) == 0:
+            raise InvalidParameter('training_type is empty!')
+
+        original_ft_sub_path = FineTunes.SUB_PATH
+        FineTunes.SUB_PATH = 'fine-tunes'
+        response = FineTunes.call(model=model,
+                                  training_file_ids=[],
+                                  validation_file_ids=[],
+                                  mode=training_type,
+                                  hyper_parameters={'phrase_list': phrases},
+                                  workspace=workspace,
+                                  **kwargs)
+        FineTunes.SUB_PATH = original_ft_sub_path
+
+        if response.status_code != HTTPStatus.OK:
+            logger.error('Create phrase failed, ' + str(response))
+
+        return response
+
+    @classmethod
+    def update_phrases(cls,
+                       model: str,
+                       phrase_id: str,
+                       phrases: Dict[str, Any],
+                       training_type: str = 'compile_asr_phrase',
+                       workspace: str = None,
+                       **kwargs) -> DashScopeAPIResponse:
+        """Update the hot words marked phrase_id.
+
+        Args:
+            model (str): The requested model.
+            phrase_id (str): The ID of phrases,
+                which created by create_phrases().
+            phrases (Dict[str, Any]): A dictionary that contains phrases,
+                such as {'暂停':90}.
+            training_type (str, `optional`):
+                The training type, 'compile_asr_phrase' is default.
+            workspace (str): The dashscope workspace id.
+
+        Raises:
+            InvalidParameter: Parameter input is None or empty!
+
+        Returns:
+            DashScopeAPIResponse: The results of updating hot words.
+        """
+        if phrase_id is None or len(phrase_id) == 0:
+            raise InvalidParameter('phrase_id is empty!')
+        if phrases is None or len(phrases) == 0:
+            raise InvalidParameter('phrases is empty!')
+        if training_type is None or len(training_type) == 0:
+            raise InvalidParameter('training_type is empty!')
+
+        original_ft_sub_path = FineTunes.SUB_PATH
+        FineTunes.SUB_PATH = 'fine-tunes'
+        response = FineTunes.call(model=model,
+                                  training_file_ids=[],
+                                  validation_file_ids=[],
+                                  mode=training_type,
+                                  hyper_parameters={'phrase_list': phrases},
+                                  finetuned_output=phrase_id,
+                                  workspace=workspace,
+                                  **kwargs)
+        FineTunes.SUB_PATH = original_ft_sub_path
+
+        if response.status_code != HTTPStatus.OK:
+            logger.error('Update phrase failed, ' + str(response))
+
+        return response
+
+    @classmethod
+    def query_phrases(cls,
+                      phrase_id: str,
+                      workspace: str = None,
+                      **kwargs) -> DashScopeAPIResponse:
+        """Query the hot words by phrase_id.
+
+        Args:
+            phrase_id (str): The ID of phrases,
+                which created by create_phrases().
+            workspace (str): The dashscope workspace id.
+
+        Raises:
+            InvalidParameter: phrase_id input is None or empty!
+
+        Returns:
+            AsrPhraseManagerResult: The results of querying hot words.
+        """
+        if phrase_id is None or len(phrase_id) == 0:
+            raise InvalidParameter('phrase_id is empty!')
+
+        original_ft_sub_path = FineTunes.SUB_PATH
+        FineTunes.SUB_PATH = 'fine-tunes/outputs'
+        response = FineTunes.get(job_id=phrase_id,
+                                 workspace=workspace,
+                                 **kwargs)
+        FineTunes.SUB_PATH = original_ft_sub_path
+
+        if response.status_code != HTTPStatus.OK:
+            logger.error('Query phrase failed, ' + str(response))
+
+        return response
+
+    @classmethod
+    def list_phrases(cls,
+                     page: int = 1,
+                     page_size: int = 10,
+                     workspace: str = None,
+                     **kwargs) -> DashScopeAPIResponse:
+        """List all information of phrases.
+
+        Args:
+            page (int): Page number, greater than 0, default value 1.
+            page_size (int): The paging size, greater than 0
+                and less than or equal to 100, default value 10.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            DashScopeAPIResponse: The results of listing hot words.
+        """
+        original_ft_sub_path = FineTunes.SUB_PATH
+        FineTunes.SUB_PATH = 'fine-tunes/outputs'
+        response = FineTunes.list(page=page,
+                                  page_size=page_size,
+                                  workspace=workspace,
+                                  **kwargs)
+        FineTunes.SUB_PATH = original_ft_sub_path
+
+        if response.status_code != HTTPStatus.OK:
+            logger.error('List phrase failed, ' + str(response))
+
+        return response
+
+    @classmethod
+    def delete_phrases(cls,
+                       phrase_id: str,
+                       workspace: str = None,
+                       **kwargs) -> DashScopeAPIResponse:
+        """Delete the hot words by phrase_id.
+
+        Args:
+            phrase_id (str): The ID of phrases,
+                which created by create_phrases().
+
+        Raises:
+            InvalidParameter: phrase_id input is None or empty!
+
+        Returns:
+            DashScopeAPIResponse: The results of deleting hot words.
+        """
+        if phrase_id is None or len(phrase_id) == 0:
+            raise InvalidParameter('phrase_id is empty!')
+
+        original_ft_sub_path = FineTunes.SUB_PATH
+        FineTunes.SUB_PATH = 'fine-tunes/outputs'
+        response = FineTunes.delete(job_id=phrase_id,
+                                    workspace=workspace,
+                                    **kwargs)
+        FineTunes.SUB_PATH = original_ft_sub_path
+
+        if response.status_code != HTTPStatus.OK:
+            logger.error('Delete phrase failed, ' + str(response))
+
+        return response

dashscope/audio/asr/recognition.py

@@ -1,7 +1,12 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
 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
 
@@ -110,10 +115,20 @@ class Recognition(BaseApi):
             speech recognition results.
         format (str): The input audio format for speech recognition.
         sample_rate (int): The input audio sample rate for speech recognition.
+        workspace (str): The dashscope workspace id.
 
         **kwargs:
+            phrase_id (list, `optional`): The ID of phrase.
             disfluency_removal_enabled(bool, `optional`): Filter mood words,
                 turned off by default.
+            diarization_enabled (bool, `optional`): Speech auto diarization,
+                turned off by default.
+            speaker_count (int, `optional`): The number of speakers.
+            timestamp_alignment_enabled (bool, `optional`): Timestamp-alignment
+                calibration, turned off by default.
+            special_word_filter(str, `optional`): Sensitive word filter.
+            audio_event_detection_enabled(bool, `optional`):
+                Audio event detection, turned off by default.
 
     Raises:
         InputRequired: Input is required.
@@ -121,8 +136,13 @@ class Recognition(BaseApi):
 
     SILENCE_TIMEOUT_S = 23
 
-    def __init__(self, model: str, callback: RecognitionCallback, format: str,
-                 sample_rate: int, **kwargs):
+    def __init__(self,
+                 model: str,
+                 callback: RecognitionCallback,
+                 format: str,
+                 sample_rate: int,
+                 workspace: str = None,
+                 **kwargs):
         if model is None:
             raise ModelRequired('Model is required!')
         if format is None:
@@ -137,15 +157,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
@@ -162,25 +189,46 @@ class Recognition(BaseApi):
         responses = self.__launch_request()
         for part in responses:
             if part.status_code == HTTPStatus.OK:
-                if len(part.output) == 0:
+                if len(part.output) == 0 or ('finished' in part.output and part.output['finished'] == True):
+                    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
-                    useags: List[Any] = None
-                    if 'sentence' in part.output and part.usage is not None:
-                        usage = {
-                            'end_time': part.output['sentence']['end_time'],
-                            'usage': part.usage
-                        }
-                        useags = [usage]
+                    usages: List[Any] = None
+                    if 'sentence' in part.output:
+                        if 'text' in part.output['sentence'] and part.output['sentence']['text'] != '':
+                            if (self._first_package_timestamp < 0):
+                                self._first_package_timestamp = time.time() * 1000
+                                logger.debug('first package delay {}'.format(
+                                    self.get_first_package_delay()))
+                        sentence = part.output['sentence']
+                        if 'heartbeat' in sentence and sentence['heartbeat'] == True:
+                            logger.debug('recv heartbeat')
+                            continue
+                        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':
+                                part.output['sentence']['end_time'],
+                                '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(
                             RecognitionResponse.from_api_response(part),
-                            usages=useags))
+                            usages=usages))
             else:
                 self._running = False
-                self._stream_data.clear()
+                self._stream_data = Queue()
                 self._callback.on_error(
                     RecognitionResult(
                         RecognitionResponse.from_api_response(part)))
@@ -190,6 +238,15 @@ class Recognition(BaseApi):
     def __launch_request(self):
         """Initiate real-time speech recognition requests.
         """
+        resources_list: list = []
+        if self._phrase is not None and len(self._phrase) > 0:
+            item = {'resource_id': self._phrase, 'resource_type': 'asr_phrase'}
+            resources_list.append(item)
+
+            if len(resources_list) > 0:
+                self._kwargs['resources'] = resources_list
+
+        self._tidy_kwargs()
         task_name, _ = _get_task_group_and_task(__name__)
         responses = super().call(model=self.model,
                                  task_group='audio',
@@ -202,13 +259,30 @@ class Recognition(BaseApi):
                                  sample_rate=self.sample_rate,
                                  format=self.format,
                                  stream=True,
+                                 workspace=self._workspace,
+                                 pre_task_id=self.last_request_id,
                                  **self._kwargs)
         return responses
 
-    def start(self):
+    def start(self, phrase_id: str = None, **kwargs):
         """Real-time speech recognition in asynchronous mode.
            Please call 'stop()' after you have completed recognition.
 
+        Args:
+            phrase_id (str, `optional`): The ID of phrase.
+
+            **kwargs:
+                disfluency_removal_enabled(bool, `optional`):
+                    Filter mood words, turned off by default.
+                diarization_enabled (bool, `optional`):
+                    Speech auto diarization, turned off by default.
+                speaker_count (int, `optional`): The number of speakers.
+                timestamp_alignment_enabled (bool, `optional`):
+                    Timestamp-alignment calibration, turned off by default.
+                special_word_filter(str, `optional`): Sensitive word filter.
+                audio_event_detection_enabled(bool, `optional`):
+                    Audio event detection, turned off by default.
+
         Raises:
             InvalidParameter: This interface cannot be called again
                 if it has already been started.
@@ -219,6 +293,12 @@ class Recognition(BaseApi):
         if self._running:
             raise InvalidParameter('Speech recognition has started.')
 
+        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
         self._worker = threading.Thread(target=self.__receive_worker)
         self._worker.start()
@@ -234,11 +314,27 @@ class Recognition(BaseApi):
             self._running = False
             raise InvalidTask('Invalid task, task create failed.')
 
-    def call(self, file: str) -> RecognitionResult:
+    def call(self,
+             file: str,
+             phrase_id: str = None,
+             **kwargs) -> RecognitionResult:
         """Real-time speech recognition in synchronous mode.
 
         Args:
             file (str): The path to the local audio file.
+            phrase_id (str, `optional`): The ID of phrase.
+
+            **kwargs:
+                disfluency_removal_enabled(bool, `optional`):
+                    Filter mood words, turned off by default.
+                diarization_enabled (bool, `optional`):
+                    Speech auto diarization, turned off by default.
+                speaker_count (int, `optional`): The number of speakers.
+                timestamp_alignment_enabled (bool, `optional`):
+                    Timestamp-alignment calibration, turned off by default.
+                special_word_filter(str, `optional`): Sensitive word filter.
+                audio_event_detection_enabled(bool, `optional`):
+                    Audio event detection, turned off by default.
 
         Raises:
             InvalidParameter: This interface cannot be called again
@@ -248,6 +344,7 @@ class Recognition(BaseApi):
         Returns:
             RecognitionResult: The result of speech recognition.
         """
+        self._start_stream_timestamp = time.time() * 1000
         if self._running:
             raise InvalidParameter('Speech recognition has been called.')
 
@@ -258,12 +355,14 @@ class Recognition(BaseApi):
             raise FileNotFoundError('No such file or directory: ' + file)
 
         self._recognition_once = True
+        self._stream_data = Queue()
+        self._phrase = phrase_id
+        self._kwargs.update(**kwargs)
         error_flag: bool = False
         sentences: List[Any] = []
         usages: List[Any] = []
         response: RecognitionResponse = None
         result: RecognitionResult = None
-        self._stream_data.clear()
 
         try:
             audio_data: bytes = None
@@ -274,22 +373,33 @@ 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:
                 if part.status_code == HTTPStatus.OK:
                     if 'sentence' in part.output:
+                        if 'text' in part.output['sentence'] and part.output['sentence']['text'] != '':
+                            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))
                         sentence = part.output['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)
 
@@ -308,12 +418,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
 
@@ -328,10 +442,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
@@ -347,12 +463,21 @@ class Recognition(BaseApi):
         if self._running is False:
             raise InvalidParameter('Speech recognition has stopped.')
 
-        self._stream_data = self._stream_data + [buffer]
+        if (self._start_stream_timestamp < 0):
+            self._start_stream_timestamp = time.time() * 1000
+        logger.debug('send_audio_frame: {}'.format(len(buffer)))
+        self._stream_data.put(buffer)
+
+    def _tidy_kwargs(self):
+        for k in self._kwargs.copy():
+            if self._kwargs[k] is None:
+                self._kwargs.pop(k, None)
 
     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
@@ -365,16 +490,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):
@@ -386,4 +512,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