smartpi 1.1.4__py3-none-any.whl → 1.1.6__py3-none-any.whl

smartpi/tencentcloud-speech-sdk-python/common/utils.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+import sys
+
+def is_python3():
+    if sys.version > '3':
+        return True
+    return False

smartpi/tencentcloud-speech-sdk-python/soe/speaking_assessment.py

@@ -0,0 +1,276 @@
+# -*- coding: utf-8 -*-
+import sys
+import hmac
+import hashlib
+import base64
+import time
+import json
+import threading
+import urllib
+
+import websocket
+import uuid
+from urllib.parse import quote
+from common.log import logger
+
+
+def is_python3():
+    if sys.version > '3':
+        return True
+    return False
+
+
+# 实时识别语音使用
+class SpeakingAssessmentListener():
+    '''
+    reponse:  
+    on_recognition_start的返回只有voice_id字段。
+    on_fail 只有voice_id、code、message字段。
+    on_recognition_complete没有result字段。
+    其余消息包含所有字段。
+    字段名	类型	
+    code	Integer	
+    message	String	
+    voice_id	String
+    message_id	String
+    result
+    final	Integer	
+
+    # Result的结构体格式为:
+    # slice_type	Integer
+    # index	Integer
+    # start_time	Integer
+    # end_time	Integer
+    # voice_text_str	String
+    # word_size	Integer
+    # word_list	Word Array
+    #
+    # Word的类型为:
+    # word    String
+    # start_time Integer
+    # end_time Integer
+    # stable_flag：Integer
+    '''
+
+    def on_recognition_start(self, response):
+        pass
+
+    def on_intermediate_result(self, response):
+        pass
+
+    def on_recognition_complete(self, response):
+        pass
+
+    def on_fail(self, response):
+        pass
+
+
+NOTOPEN = 0
+STARTED = 1
+OPENED = 2
+FINAL = 3
+ERROR = 4
+CLOSED = 5
+
+
+def quote_autho(autho):
+    if sys.version_info >= (3, 0):
+        import urllib.parse as urlparse
+        return urlparse.quote(autho)
+    else:
+        return urllib.quote(autho)
+
+
+# 实时识别使用
+class SpeakingAssessment:
+
+    def __init__(self, appid, credential, engine_model_type, listener):
+        self.result = ""
+        self.credential = credential
+        self.appid = appid
+        self.server_engine_type = engine_model_type
+        self.status = NOTOPEN
+        self.ws = None
+        self.wst = None
+        self.voice_id = ""
+        self.new_start = 0
+        self.listener = listener
+        self.text_mode = 0
+        self.ref_text = ""
+        self.keyword = ""
+        self.eval_mode = 0
+        self.score_coeff = 1.0
+        self.sentence_info_enabled = 0
+        self.voice_format = 0
+        self.nonce = ""
+        self.rec_mode = 0
+
+    def set_text_mode(self, text_mode):
+        self.text_mode = text_mode
+    
+    def set_rec_mode(self, rec_mode):
+        self.rec_mode = rec_mode
+
+    def set_ref_text(self, ref_text):
+        self.ref_text = ref_text
+
+    def set_keyword(self, keyword):
+        self.keyword = keyword
+
+    def set_eval_mode(self, eval_mode):
+        self.eval_mode = eval_mode
+
+    def set_sentence_info_enabled(self, sentence_info_enabled):
+        self.sentence_info_enabled = sentence_info_enabled
+
+    def set_voice_format(self, voice_format):
+        self.voice_format = voice_format
+
+    def set_nonce(self, nonce):
+        self.nonce = nonce
+
+    def format_sign_string(self, param):
+        signstr = "soe.cloud.tencent.com/soe/api/"
+        for t in param:
+            if 'appid' in t:
+                signstr += str(t[1])
+                break
+        signstr += "?"
+        for x in param:
+            tmp = x
+            if 'appid' in x:
+                continue
+            for t in tmp:
+                signstr += str(t)
+                signstr += "="
+            signstr = signstr[:-1]
+            signstr += "&"
+        signstr = signstr[:-1]
+        return signstr
+
+    def create_query_string(self, param):
+        signstr = ""
+        for key, value in param.items():
+            if key == 'appid':
+                signstr += str(value)
+                break
+        signstr += "?"
+        for key, value in param.items():
+            if key == 'appid':
+                continue
+            value = quote_autho(str(value))
+            signstr += str(key) + "=" + str(value) + "&"
+        signstr = signstr[:-1]
+        return "wss://soe.cloud.tencent.com/soe/api/" + signstr
+
+    def sign(self, signstr, secret_key):
+        hmacstr = hmac.new(secret_key.encode('utf-8'),
+                           signstr.encode('utf-8'), hashlib.sha1).digest()
+        s = base64.b64encode(hmacstr)
+        s = s.decode('utf-8')
+        return s
+
+    def create_query_arr(self):
+        query_arr = dict()
+
+        query_arr['appid'] = self.appid
+        query_arr['server_engine_type'] = self.server_engine_type
+        query_arr['text_mode'] = self.text_mode
+        query_arr['rec_mode'] = self.rec_mode
+        query_arr['ref_text'] = self.ref_text
+        query_arr['keyword'] = self.keyword
+        query_arr['eval_mode'] = self.eval_mode
+        query_arr['score_coeff'] = self.score_coeff
+        query_arr['sentence_info_enabled'] = self.sentence_info_enabled
+        query_arr['secretid'] = self.credential.secret_id
+        if self.credential.token != "":
+            query_arr['token'] = self.credential.token
+        query_arr['voice_format'] = self.voice_format
+        query_arr['voice_id'] = self.voice_id
+        query_arr['timestamp'] = str(int(time.time()))
+        if self.nonce != "":
+            query_arr['nonce'] = self.nonce
+        else:
+            query_arr['nonce'] = query_arr['timestamp']
+        query_arr['expired'] = int(time.time()) + 24 * 60 * 60
+        return query_arr
+
+    def stop(self):
+        if self.status == OPENED:
+            msg = {'type': "end"}
+            text_str = json.dumps(msg)
+            self.ws.sock.send(text_str)
+        if self.ws:
+            if self.wst and self.wst.is_alive():
+                self.wst.join()
+        self.ws.close()
+
+    def write(self, data):
+        while self.status == STARTED:
+            time.sleep(0.1)
+        if self.status == OPENED:
+            self.ws.sock.send_binary(data)
+
+    def start(self):
+        def on_message(ws, message):
+            # print(message)
+            response = json.loads(message)
+            response['voice_id'] = self.voice_id
+            if response['code'] != 0:
+                logger.error("%s server recognition fail %s" %
+                             (response['voice_id'], response['message']))
+                self.listener.on_fail(response)
+                return
+            if "final" in response and response["final"] == 1:
+                self.status = FINAL
+                self.result = message
+                self.listener.on_recognition_complete(response)
+                logger.info("%s recognition complete" % response['voice_id'])
+                self.ws.close()
+                return
+            else:
+                if response["result"] is not None:
+                    self.listener.on_intermediate_result(response)
+                    logger.info("%s recognition doing" % response['voice_id'])
+                    return
+
+        def on_error(ws, error):
+            if self.status == FINAL:
+                return
+            logger.error("websocket error %s  voice id %s" %
+                         (format(error), self.voice_id))
+            self.status = ERROR
+
+        def on_close(ws):
+            self.status = CLOSED
+            logger.info("websocket closed  voice id %s" %
+                        self.voice_id)
+
+        def on_open(ws):
+            self.status = OPENED
+
+        query_arr = self.create_query_arr()
+        if self.voice_id == "":
+            query_arr['voice_id'] = str(uuid.uuid1())
+            self.voice_id = query_arr['voice_id']
+        query = sorted(query_arr.items(), key=lambda d: d[0])
+        signstr = self.format_sign_string(query)
+        autho = self.sign(signstr, self.credential.secret_key)
+        requrl = self.create_query_string(query_arr)
+        print(requrl)
+        if is_python3():
+            autho = urllib.parse.quote(autho)
+        else:
+            autho = urllib.quote(autho)
+        requrl += "&signature=%s" % autho
+        print(requrl)
+        self.ws = websocket.WebSocketApp(requrl, None,
+                                         on_error=on_error, on_close=on_close, on_message=on_message)
+        self.ws.on_open = on_open
+        self.wst = threading.Thread(target=self.ws.run_forever)
+        self.wst.daemon = True
+        self.wst.start()
+        self.status = STARTED
+        response = {'voice_id': self.voice_id}
+        self.listener.on_recognition_start(response)
+        logger.info("%s recognition start" % response['voice_id'])

smartpi/tencentcloud-speech-sdk-python/tts/flowing_speech_synthesizer.py

@@ -0,0 +1,294 @@
+# -*- coding: utf-8 -*-
+import sys
+import hmac
+import hashlib
+import base64
+import time
+import json
+import threading
+import websocket
+import uuid
+import urllib
+from common.log import logger
+from common.utils import is_python3
+
+
+_PROTOCOL = "wss://"
+_HOST = "tts.cloud.tencent.com"
+_PATH = "/stream_wsv2"
+_ACTION = "TextToStreamAudioWSv2"
+
+
+class FlowingSpeechSynthesisListener(object):
+    '''
+    '''
+    def on_synthesis_start(self, session_id):
+        logger.info("on_synthesis_start: session_id={}".format(session_id))
+
+    def on_synthesis_end(self):
+        logger.info("on_synthesis_end: -")
+
+    def on_audio_result(self, audio_bytes):
+        logger.info("on_audio_result: recv audio bytes, len={}".format(len(audio_bytes)))
+
+    def on_text_result(self, response):
+        session_id = response["session_id"]
+        request_id = response["request_id"]
+        message_id = response["message_id"]
+        result = response['result']
+        subtitles = []
+        if "subtitles" in result and len(result["subtitles"]) > 0:
+            subtitles = result["subtitles"]
+        logger.info("on_text_result: session_id={} request_id={} message_id={}\nsubtitles={}".format(
+            session_id, request_id, message_id, subtitles))
+
+    def on_synthesis_fail(self, response):
+        logger.error("on_synthesis_fail: code={} msg={}".format(
+            response['code'], response['message']
+        ))
+
+
+NOTOPEN = 0
+STARTED = 1
+OPENED = 2
+FINAL = 3
+ERROR = 4
+CLOSED = 5
+
+FlowingSpeechSynthesizer_ACTION_SYNTHESIS = "ACTION_SYNTHESIS"
+FlowingSpeechSynthesizer_ACTION_COMPLETE = "ACTION_COMPLETE"
+FlowingSpeechSynthesizer_ACTION_RESET = "ACTION_RESET"
+
+
+class FlowingSpeechSynthesizer:
+
+    def __init__(self, appid, credential, listener):
+        self.appid = appid
+        self.credential = credential
+        self.status = NOTOPEN
+        self.ws = None
+        self.wst = None
+        self.listener = listener
+
+        self.ready = False
+
+        self.voice_type = 0
+        self.codec = "pcm"
+        self.sample_rate = 16000
+        self.volume = 10
+        self.speed = 0
+        self.session_id = ""
+        self.enable_subtitle = 0
+        self.emotion_category = ""
+        self.emotion_intensity = 100
+
+    def set_voice_type(self, voice_type):
+        self.voice_type = voice_type
+
+    def set_emotion_category(self, emotion_category):
+        self.emotion_category = emotion_category
+
+    def set_emotion_intensity(self, emotion_intensity):
+        self.emotion_intensity = emotion_intensity
+
+    def set_codec(self, codec):
+        self.codec = codec
+
+    def set_sample_rate(self, sample_rate):
+        self.sample_rate = sample_rate
+
+    def set_speed(self, speed):
+        self.speed = speed
+
+    def set_volume(self, volume):
+        self.volume = volume
+
+    def set_enable_subtitle(self, enable_subtitle):
+        self.enable_subtitle = enable_subtitle
+
+    def __gen_signature(self, params):
+        sort_dict = sorted(params.keys())
+        sign_str = "GET" + _HOST + _PATH + "?"
+        for key in sort_dict:
+            sign_str = sign_str + key + "=" + str(params[key]) + '&'
+        sign_str = sign_str[:-1]
+        print(sign_str)
+        if is_python3():
+            secret_key = self.credential.secret_key.encode('utf-8')
+            sign_str = sign_str.encode('utf-8')
+        else:
+            secret_key = self.credential.secret_key
+        hmacstr = hmac.new(secret_key, sign_str, hashlib.sha1).digest()
+        s = base64.b64encode(hmacstr)
+        s = s.decode('utf-8')
+        return s
+
+    def __gen_params(self, session_id):
+        self.session_id = session_id
+
+        params = dict()
+        params['Action'] = _ACTION
+        params['AppId'] = int(self.appid)
+        params['SecretId'] = self.credential.secret_id
+        params['ModelType'] = 1
+        params['VoiceType'] = self.voice_type
+        params['Codec'] = self.codec
+        params['SampleRate'] = self.sample_rate
+        params['Speed'] = self.speed
+        params['Volume'] = self.volume
+        params['SessionId'] = self.session_id
+        params['EnableSubtitle'] = self.enable_subtitle
+        if self.emotion_category != "":
+            params['EmotionCategory']= self.emotion_category
+            params['EmotionIntensity']= self.emotion_intensity
+
+        timestamp = int(time.time())
+        params['Timestamp'] = timestamp
+        params['Expired'] = timestamp + 24 * 60 * 60
+        return params
+
+    def __create_query_string(self, param):
+        param = sorted(param.items(), key=lambda d: d[0])
+
+        url = _PROTOCOL + _HOST + _PATH
+
+        signstr = url + "?"
+        for x in param:
+            tmp = x
+            for t in tmp:
+                signstr += str(t)
+                signstr += "="
+            signstr = signstr[:-1]
+            signstr += "&"
+        signstr = signstr[:-1]
+        return signstr
+
+    def __new_ws_request_message(self, action, data):
+        return {
+            "session_id": self.session_id,
+            "message_id": str(uuid.uuid1()),
+
+            "action": action,
+            "data": data,
+        }
+    
+    def __do_send(self, action, text):
+        WSRequestMessage = self.__new_ws_request_message(action, text)
+        data = json.dumps(WSRequestMessage)
+        opcode = websocket.ABNF.OPCODE_TEXT
+        logger.info("ws send opcode={} data={}".format(opcode, data))
+        self.ws.send(data, opcode)
+
+    def process(self, text, action=FlowingSpeechSynthesizer_ACTION_SYNTHESIS):
+        logger.info("process: action={} data={}".format(action, text))
+        self.__do_send(action, text)
+
+    def complete(self, action = FlowingSpeechSynthesizer_ACTION_COMPLETE):
+        logger.info("complete: action={}".format(action))
+        self.__do_send(action, "")
+    
+    def reset(self, action = FlowingSpeechSynthesizer_ACTION_RESET):
+        logger.info("reset: action={}".format(action))
+        self.__do_send(action, "")
+
+    def wait_ready(self, timeout_ms):
+        timeout_start = int(time.time() * 1000)
+        while True:
+            if self.ready:
+                return True
+            if int(time.time() * 1000) - timeout_start > timeout_ms:
+                break
+            time.sleep(0.01)
+        return False
+
+    def start(self):
+        logger.info("synthesizer start: begin")
+
+        def _close_conn(reason):
+            ta = time.time()
+            self.ws.close()
+            tb = time.time()
+            logger.info("client has closed connection ({}), cost {} ms".format(reason, int((tb-ta)*1000)))
+
+        def _on_data(ws, data, opcode, flag):
+            logger.debug("data={} opcode={} flag={}".format(data, opcode, flag))
+            if opcode == websocket.ABNF.OPCODE_BINARY:
+                self.listener.on_audio_result(data) # <class 'bytes'>
+                pass
+            elif opcode == websocket.ABNF.OPCODE_TEXT:
+                resp = json.loads(data) # WSResponseMessage
+                if resp['code'] != 0:
+                    logger.error("server synthesis fail request_id={} code={} msg={}".format(
+                        resp['request_id'], resp['code'], resp['message']
+                    ))
+                    self.listener.on_synthesis_fail(resp)
+                    return
+                if "final" in resp and resp['final'] == 1:
+                    logger.info("recv FINAL frame")
+                    self.status = FINAL
+                    _close_conn("after recv final")
+                    self.listener.on_synthesis_end()
+                    return
+                if "ready" in resp and resp['ready'] == 1:
+                    logger.info("recv READY frame")
+                    self.ready = True
+                    return
+                if "reset" in resp and resp['reset'] == 1:
+                    logger.info("recv RESET frame")
+                    return
+                if "heartbeat" in resp and resp['heartbeat'] == 1:
+                    logger.info("recv HEARTBEAT frame")
+                    return
+                if "result" in resp:
+                    if "subtitles" in resp["result"] and resp["result"]["subtitles"] is not None:
+                        self.listener.on_text_result(resp)
+                    return
+            else:
+                logger.error("invalid on_data code, opcode=".format(opcode))
+
+        def _on_error(ws, error):
+            if self.status == FINAL or self.status == CLOSED:
+                return
+            self.status = ERROR
+            logger.error("error={}, session_id={}".format(error, self.session_id))
+            _close_conn("after recv error")
+
+        def _on_close(ws, close_status_code, close_msg):
+            logger.info("conn closed, close_status_code={} close_msg={}".format(close_status_code, close_msg))
+            self.status = CLOSED
+
+        def _on_open(ws):
+            logger.info("conn opened")
+            self.status = OPENED
+            
+        session_id = str(uuid.uuid1())
+        params = self.__gen_params(session_id)
+        signature = self.__gen_signature(params)
+        requrl = self.__create_query_string(params)
+
+        if is_python3():
+            autho = urllib.parse.quote(signature)
+        else:
+            autho = urllib.quote(signature)
+        requrl += "&Signature=%s" % autho
+        print(requrl)
+
+        self.ws = websocket.WebSocketApp(requrl, None,# header=headers,
+            on_error=_on_error, on_close=_on_close,
+            on_data=_on_data)
+        self.ws.on_open = _on_open
+
+        self.status = STARTED
+        self.wst = threading.Thread(target=self.ws.run_forever)
+        self.wst.daemon = True
+        self.wst.start()
+        self.listener.on_synthesis_start(session_id)
+        
+        logger.info("synthesizer start: end")
+
+    def wait(self):
+        logger.info("synthesizer wait: begin")
+        if self.ws:
+            if self.wst and self.wst.is_alive():
+                self.wst.join()
+        logger.info("synthesizer wait: end")