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

smartpi/__init__.py

@@ -0,0 +1,8 @@
+from ._gui import gui
+from .base_driver import P1, P2, P3, P4, P5, P6, M1, M2, M3, M4, M5, M6
+
+__all__ = ["base_driver","gui","audio","ultrasonic","touch_sensor","temperature","humidity","light_sensor","color_sensor","motor","servo","led","flash",
+           "trace","move","local_model","P1", "P2", "P3", "P4", "P5", "P6", "M1", "M2", "M3", "M4", "M5", "M6"]
+
+__version__ = "1.1.6"
+

smartpi/models/snakers4_silero-vad/hubconf.py

@@ -0,0 +1,56 @@
+dependencies = ['torch', 'torchaudio']
+import torch
+import os
+import sys
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
+from silero_vad.utils_vad import (init_jit_model,
+                                  get_speech_timestamps,
+                                  save_audio,
+                                  read_audio,
+                                  VADIterator,
+                                  collect_chunks,
+                                  OnnxWrapper)
+
+
+def versiontuple(v):
+    splitted = v.split('+')[0].split(".")
+    version_list = []
+    for i in splitted:
+        try:
+            version_list.append(int(i))
+        except:
+            version_list.append(0)
+    return tuple(version_list)
+
+
+def silero_vad(onnx=False, force_onnx_cpu=False, opset_version=16):
+    """Silero Voice Activity Detector
+    Returns a model with a set of utils
+    Please see https://github.com/snakers4/silero-vad for usage examples
+    """
+    available_ops = [15, 16]
+    if onnx and opset_version not in available_ops:
+        raise Exception(f'Available ONNX opset_version: {available_ops}')
+
+    if not onnx:
+        installed_version = torch.__version__
+        supported_version = '1.12.0'
+        if versiontuple(installed_version) < versiontuple(supported_version):
+            raise Exception(f'Please install torch {supported_version} or greater ({installed_version} installed)')
+
+    model_dir = os.path.join(os.path.dirname(__file__), 'src', 'silero_vad', 'data')
+    if onnx:
+        if opset_version == 16:
+            model_name = 'silero_vad.onnx'
+        else:
+            model_name = f'silero_vad_16k_op{opset_version}.onnx'
+        model = OnnxWrapper(os.path.join(model_dir, model_name), force_onnx_cpu)
+    else:
+        model = init_jit_model(os.path.join(model_dir, 'silero_vad.jit'))
+    utils = (get_speech_timestamps,
+             save_audio,
+             read_audio,
+             VADIterator,
+             collect_chunks)
+
+    return model, utils

smartpi/tencentcloud-speech-sdk-python/__init__.py

@@ -0,0 +1 @@
+# -*- coding:utf-8 -*-

smartpi/tencentcloud-speech-sdk-python/asr/flash_recognizer.py

@@ -0,0 +1,178 @@
+# -*- coding: utf-8 -*-
+import requests
+import hmac
+import hashlib
+import base64
+import time
+import random
+import os
+import json
+from common import credential
+
+#录音识别极速版使用
+class FlashRecognitionRequest:
+    def __init__(self, engine_type):
+        self.engine_type = engine_type
+        self.speaker_diarization = 0
+        self.hotword_id = ""
+        self.hotword_list = ""
+        self.input_sample_rate = 0
+        self.customization_id = ""
+        self.filter_dirty = 0
+        self.filter_modal = 0
+        self.filter_punc = 0
+        self.convert_num_mode = 1
+        self.word_info = 0
+        self.voice_format = ""
+        self.first_channel_only = 1
+        self.reinforce_hotword = 0
+        self.sentence_max_length = 0
+
+    def set_first_channel_only(self, first_channel_only):
+        self.first_channel_only = first_channel_only
+
+    def set_speaker_diarization(self, speaker_diarization):
+        self.speaker_diarization = speaker_diarization
+
+    def set_filter_dirty(self, filter_dirty):
+        self.filter_dirty = filter_dirty
+
+    def set_filter_modal(self, filter_modal):
+        self.filter_modal = filter_modal
+
+    def set_filter_punc(self, filter_punc):
+        self.filter_punc = filter_punc
+
+    def set_convert_num_mode(self, convert_num_mode):
+        self.convert_num_mode = convert_num_mode
+
+    def set_word_info(self, word_info):
+        self.word_info = word_info
+
+    def set_hotword_id(self, hotword_id):
+        self.hotword_id = hotword_id
+
+    def set_hotword_list(self, hotword_list):
+        self.hotword_list = hotword_list
+
+    def set_input_sample_rate(self, input_sample_rate):
+        self.input_sample_rate = input_sample_rate
+
+    def set_customization_id(self, customization_id):
+        self.customization_id = customization_id
+
+    def set_voice_format(self, voice_format):
+        self.voice_format = voice_format
+
+    def set_sentence_max_length(self, sentence_max_length):
+        self.sentence_max_length = sentence_max_length
+
+    def set_reinforce_hotword(self, reinforce_hotword):
+        self.reinforce_hotword = reinforce_hotword
+
+
+
+class FlashRecognizer:
+    '''
+    reponse:  
+    字段名            类型
+    request_id        string
+    status            Integer    
+    message           String    
+    audio_duration    Integer
+    flash_result      Result Array
+
+    Result的结构体格式为:
+    text              String
+    channel_id        Integer
+    sentence_list     Sentence Array
+
+    Sentence的结构体格式为:
+    text              String
+    start_time        Integer    
+    end_time          Integer    
+    speaker_id        Integer    
+    word_list         Word Array
+
+    Word的类型为:
+    word              String 
+    start_time        Integer 
+    end_time          Integer 
+    stable_flag：     Integer 
+    '''
+
+    def __init__(self, appid, credential):
+        self.credential = credential
+        self.appid = appid
+
+    def _format_sign_string(self, param):
+        signstr = "POSTasr.cloud.tencent.com/asr/flash/v1/"
+        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 _build_header(self):
+        header = dict()
+        header["Host"] = "asr.cloud.tencent.com"
+        return header
+
+    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 _build_req_with_signature(self, secret_key, params, header):
+        query = sorted(params.items(), key=lambda d: d[0])
+        signstr = self._format_sign_string(query)
+        signature = self._sign(signstr, secret_key)
+        header["Authorization"] = signature
+        requrl = "https://"
+        requrl += signstr[4::]
+        return requrl
+
+    def _create_query_arr(self, req):
+        query_arr = dict()
+        query_arr['appid'] = self.appid
+        query_arr['secretid'] = self.credential.secret_id
+        query_arr['timestamp'] = str(int(time.time()))
+        query_arr['engine_type'] = req.engine_type
+        query_arr['voice_format'] = req.voice_format
+        query_arr['speaker_diarization'] = req.speaker_diarization
+        if req.hotword_id != "":
+            query_arr['hotword_id'] = req.hotword_id
+        if req.hotword_list != "":
+            query_arr['hotword_list'] = req.hotword_list
+        if req.input_sample_rate != 0:
+            query_arr['input_sample_rate'] = req.input_sample_rate
+        query_arr['customization_id'] = req.customization_id
+        query_arr['filter_dirty'] = req.filter_dirty
+        query_arr['filter_modal'] = req.filter_modal
+        query_arr['filter_punc'] = req.filter_punc
+        query_arr['convert_num_mode'] = req.convert_num_mode
+        query_arr['word_info'] = req.word_info
+        query_arr['first_channel_only'] = req.first_channel_only
+        query_arr['reinforce_hotword'] = req.reinforce_hotword
+        query_arr['sentence_max_length'] = req.sentence_max_length
+        return query_arr
+
+    def recognize(self, req, data):
+        header = self._build_header()
+        query_arr = self._create_query_arr(req)
+        req_url = self._build_req_with_signature(self.credential.secret_key, query_arr, header)
+        r = requests.post(req_url, headers=header, data=data)
+        return r.text

smartpi/tencentcloud-speech-sdk-python/asr/speech_recognizer.py

@@ -0,0 +1,311 @@
+# -*- 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
+
+
+def is_python3():
+    if sys.version > '3':
+        return True
+    return False
+
+
+#实时识别语音使用
+class SpeechRecognitionListener():
+    '''
+    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	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_sentence_begin(self, response):
+        pass
+
+    def on_recognition_result_change(self, response):
+        pass
+
+    def on_sentence_end(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
+
+#实时识别语音使用
+class SpeechRecognizer:
+
+    def __init__(self, appid, credential, engine_model_type, listener):
+        self.result = ""
+        self.credential = credential
+        self.appid = appid
+        self.engine_model_type = engine_model_type
+        self.status = NOTOPEN
+        self.ws = None
+        self.wst = None
+        self.voice_id = ""
+        self.new_start = 0
+        self.listener = listener
+        self.filter_dirty = 0
+        self.filter_modal = 0
+        self.filter_punc = 0
+        self.convert_num_mode = 0
+        self.word_info = 0
+        self.need_vad = 0
+        self.vad_silence_time = 0
+        self.hotword_id = ""
+        self.hotword_list = ""
+        self.reinforce_hotword = 0
+        self.noise_threshold = 0
+        self.voice_format = 4
+        self.nonce = ""
+        self.replace_text_id = ""
+
+    def set_filter_dirty(self, filter_dirty):
+        self.filter_dirty = filter_dirty
+
+    def set_filter_modal(self, filter_modal):
+        self.filter_modal = filter_modal
+
+    def set_filter_punc(self, filter_punc):
+        self.filter_punc = filter_punc
+
+    def set_convert_num_mode(self, convert_num_mode):
+        self.convert_num_mode = convert_num_mode
+
+    def set_word_info(self, word_info):
+        self.word_info = word_info
+
+    def set_need_vad(self, need_vad):
+        self.need_vad = need_vad
+
+    def set_vad_silence_time(self, vad_silence_time):
+        self.vad_silence_time = vad_silence_time
+
+    def set_hotword_id(self, hotword_id):
+        self.hotword_id = hotword_id
+
+    def set_hotword_list(self, hotword_list):
+        self.hotword_list = hotword_list
+
+    def set_voice_format(self, voice_format):
+        self.voice_format = voice_format
+
+    def set_nonce(self, nonce):
+        self.nonce = nonce
+
+    def set_reinforce_hotword(self, reinforce_hotword):
+        self.reinforce_hotword = reinforce_hotword
+
+    def set_noise_threshold(self, noise_threshold):
+        self.noise_threshold = noise_threshold
+
+    def set_replace_text_id(self, replace_text_id):
+        self.replace_text_id = replace_text_id
+
+    def format_sign_string(self, param):
+        signstr = "asr.cloud.tencent.com/asr/v2/"
+        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 = "wss://asr.cloud.tencent.com/asr/v2/"
+        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 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['sub_service_type'] = 1
+        query_arr['engine_model_type'] = self.engine_model_type
+        query_arr['filter_dirty'] = self.filter_dirty
+        query_arr['filter_modal'] = self.filter_modal
+        query_arr['filter_punc'] = self.filter_punc
+        query_arr['needvad'] = self.need_vad
+        query_arr['convert_num_mode'] = self.convert_num_mode
+        query_arr['word_info'] = self.word_info
+        if self.vad_silence_time != 0:
+            query_arr['vad_silence_time'] = self.vad_silence_time
+        if self.hotword_id != "":
+            query_arr['hotword_id'] = self.hotword_id
+        if self.hotword_list != "":
+            query_arr['hotword_list'] = self.hotword_list
+        if self.replace_text_id != "":
+            query_arr['replace_text_id'] = self.replace_text_id
+        query_arr['secretid'] = self.credential.secret_id
+        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
+        query_arr['reinforce_hotword'] = self.reinforce_hotword
+        query_arr['noise_threshold'] = self.noise_threshold
+        return query_arr
+
+    def stop(self):
+        if self.status == OPENED: 
+            msg = {}
+            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):
+            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'])
+                return
+            if "result" in response.keys():
+                if response["result"]['slice_type'] == 0:
+                    self.listener.on_sentence_begin(response)
+                    return
+                elif response["result"]["slice_type"] == 2:
+                    self.listener.on_sentence_end(response)
+                    return
+                elif response["result"]["slice_type"] == 1:
+                    self.listener.on_recognition_result_change(response)
+                    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)
+        if is_python3():
+            autho = urllib.parse.quote(autho)
+        else:
+            autho = urllib.quote(autho)
+        requrl += "&signature=%s" % autho
+        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 = {}
+        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/common/__init__.py

@@ -0,0 +1 @@
+#!#-*-coding:utf-8 -*-

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

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+class Credential:
+    def __init__(self, secret_id, secret_key, token=""):
+        self.secret_id = secret_id
+        self.secret_key = secret_key
+        self.token = token

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

@@ -0,0 +1,16 @@
+import logging
+import logging.handlers
+
+
+
+FORMAT = '%(asctime)15s %(name)s-%(levelname)s  %(funcName)s:%(lineno)s %(message)s'
+logging.basicConfig(level=logging.DEBUG, format=FORMAT)
+logger = logging.getLogger('tencent_speech.log')
+
+handler = logging.handlers.RotatingFileHandler('tencent_speech.log', maxBytes=1024 * 1024,
+                                               backupCount=5, encoding='utf-8')
+handler.setLevel(logging.DEBUG)
+handler.setFormatter(logging.Formatter(FORMAT))
+logger.addHandler(handler)
+logger.setLevel('INFO')
+