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

smartpi/servo.py

@@ -1,178 +0,0 @@
-# coding=utf-8
-import time
-from typing import List, Optional
-from smartpi import base_driver
-
-#С������� port:����P�˿ڣ�angle:�Ƕ�0~270��
-def steer_angle(port:bytes,angle:bytes) -> Optional[bytes]:
-    servo_str=[0xA0, 0x0E, 0x01, 0x71, 0x00, 0xBE]
-    servo_str[0]=0XA0+port
-    servo_str[4]=angle
-#    response = base_driver.single_operate_sensor(servo_str,0)
-    time.sleep(0.005)
-    base_driver.write_data(0X01, 0X02, servo_str)
-#    if response == None:
-#        return None
-#    else:
-    return 0
-        
-#С�����ʱ���� port:����P�˿ڣ�angle:�Ƕ�0~270��second:1~256
-def steer_angle_delay(port:bytes,angle:bytes,second:bytes) -> Optional[bytes]:
-    servo_str=[0xA0, 0x10, 0x01, 0x81, 0x00, 0x00, 0x81, 0x00, 0xBE]
-    servo_str[0]=0XA0+port
-    servo_str[4]=angle//256
-    servo_str[5]=angle%256
-    servo_str[7]=second
-#    response = base_driver.single_operate_sensor(servo_str,0)
-    time.sleep(0.005)
-    base_driver.write_data(0X01, 0X02, servo_str)
-#    if response == None:
-#        return None
-#    else:
-    return 0
-        
-#���ֶ������ת������(���ԽǶ�) port:����P�˿ڣ�dir:0:����Խ0��;1:��̾�����ת;2:˳ʱ����ת;3:��ʱ����ת
-def set_dir(port:bytes,dir:bytes) -> Optional[bytes]:
-    servo_str=[0xA0, 0x24, 0x01, 0x71, 0x00, 0xBE]
-    servo_str[0]=0XA0+port
-    servo_str[4]=dir
-#    response = base_driver.single_operate_sensor(servo_str,0)
-    time.sleep(0.005)
-    base_driver.write_data(0X01, 0X02, servo_str)
-#    if response == None:
-#        return None
-#    else:
-    return 0
-        
-#BE-9528���ֶ�����ٶ�ת���Ƕ� port:����P�˿ڣ�angle:�Ƕ�(0~360)��speed:�ٶ�(0~100)��
-def set_angle_speed(port:bytes,angle:bytes,speed:bytes) -> Optional[bytes]:
-    servo_str=[0xA0, 0x0D, 0x01, 0x81, 0x00, 0x00, 0x81, 0x00, 0xBE]
-    servo_str[0]=0XA0+port
-    servo_str[4]=angle//256
-    servo_str[5]=angle%256
-    servo_str[7]=speed
-    #response = base_driver.single_operate_sensor(servo_str,0)
-    time.sleep(0.005)   
-    base_driver.write_data(0X01, 0X02, servo_str)
-#    if response == None:
-#        return None
-#    else:
-    return 0
-        
-#���ֶ��ת�����Ƕ���ʱʱ�� port:����P�˿ڣ�angle:�Ƕ�(0~360)��ms:��ʱʱ��(0~65535)��
-def set_angle_ms(port:bytes,angle:bytes,ms:int) -> Optional[bytes]:
-    servo_str=[0xA0, 0x11, 0x01, 0x81, 0x00, 0x00, 0x81, 0x00, 0x00, 0xBE]
-    servo_str[0]=0XA0+port
-    servo_str[4]=angle//256
-    servo_str[5]=angle%256
-    servo_str[7]=ms//256
-    servo_str[8]=ms%256
-#    response = base_driver.single_operate_sensor(servo_str,0)
-    time.sleep(0.005)
-    base_driver.write_data(0X01, 0X02, servo_str)
-#    if response == None:
-#        return None
-#    else:
-    return 0
-
-#���ֶ����λ port:����P�˿ڣ�
-def set_init(port:bytes) -> Optional[bytes]:
-    servo_str=[0xA0, 0x12, 0x01, 0xBE]
-    servo_str[0]=0XA0+port
-#    response = base_driver.single_operate_sensor(servo_str,0)
-    time.sleep(0.005)
-    base_driver.write_data(0X01, 0X02, servo_str)
-#    if response == None:
-#        return None
-#    else:
-    return 0
-        
-#��ȡ���ֶ���Ƕ� port:����P�˿ڣ�
-def get_angle(port:bytes) -> Optional[bytes]:
-    servo_str=[0xA0, 0x13, 0x01, 0xBE]
-    servo_str[0]=0XA0+port
-    time.sleep(0.005)
-    response = base_driver.single_operate_sensor(servo_str,0)       
-    if response == None:
-        return None
-    else:
-        angle_data=response[4:-1]
-        angle_num=int.from_bytes(angle_data, byteorder='big', signed=True)
-        return angle_num
-        
-#���ֶ���ٶ�ת�� port:����P�˿ڣ�
-def set_speed(port:bytes,speed:int) -> Optional[bytes]:
-    servo_str=[0xA0, 0x14, 0x01, 0x71, 0x00, 0xBE]
-    servo_str[0]=0XA0+port
-    if speed>100:
-        m_par=100
-    elif speed>=0 and speed<=100:
-        m_par=speed        
-    elif speed<-100:
-        m_par=156
-    elif speed<=0 and speed>=-100:
-        m_par=256+speed
-        
-    servo_str[4]=m_par
-#    response = base_driver.single_operate_sensor(servo_str,0)
-    time.sleep(0.005)
-    base_driver.write_data(0X01, 0X02, servo_str)
-#    if response == None:
-#        return None
-#    else:
-    return 0      
-        
-#���ֶ������ת�� port:����P�˿ڣ�code:����(0~65535)��speed:�ٶ�(-100~100)��
-def set_code_speed(port:bytes,code:int,speed:int) -> Optional[bytes]:
-    servo_str=[0xA0, 0x15, 0x01, 0x81, 0x00, 0x00, 0x71, 0x00, 0xBE]
-    servo_str[0]=0XA0+port
-    
-    servo_str[4]=code//256
-    servo_str[5]=code%256
-    
-    if speed>100:
-        m_par=100
-    elif speed>=0 and speed<=100:
-        m_par=speed        
-    elif speed<-100:
-        m_par=156
-    elif speed<=0 and speed>=-100:
-        m_par=256+speed      
-    servo_str[7]=m_par
-
-#    response = base_driver.single_operate_sensor(servo_str,0)
-    time.sleep(0.005)
-    base_driver.write_data(0X01, 0X02, servo_str)
-#    if response == None:
-#        return None
-#    else:
-    return 0  
-
-#���ֶ������ֵ���� port:����P�˿ڣ�
-def reset_encode(port:bytes) -> Optional[bytes]:
-    servo_str=[0xA0, 0x16, 0x01, 0xBE]
-    servo_str[0]=0XA0+port
-#    response = base_driver.single_operate_sensor(servo_str,0)
-    time.sleep(0.005)
-    base_driver.write_data(0X01, 0X02, servo_str)
-#    if response == None:
-#        return None
-#    else:
-    return 0
-        
-#��ȡ���ֶ������ֵ port:����P�˿ڣ�
-def get_encoder(port:bytes) -> Optional[bytes]:
-    servo_str=[0xA0, 0x17, 0x01, 0xBE]
-    servo_str[0]=0XA0+port
-    time.sleep(0.005)
-    response = base_driver.single_operate_sensor(servo_str,0)        
-    if response == None:
-        return None
-    else:
-        code_data=response[4:-1]
-        code_num=int.from_bytes(code_data, byteorder='big', signed=True)
-        return code_num
-
-
-
-

smartpi/temperature.py

@@ -1,18 +0,0 @@
-# coding=utf-8
-import time
-from typing import List, Optional
-from smartpi import base_driver
-
-
-#�¶ȶ�ȡ port:����P�˿ڣ��������أ��¶�����; ��ȡ����-1
-def get_value(port:bytes) -> Optional[bytes]:
-    temp_str=[0XA0, 0X0C, 0X01, 0X71, 0X00, 0XBE]
-    temp_str[0]=0XA0+port
-    temp_str[4]=0 
-    time.sleep(0.005)
-    response = base_driver.single_operate_sensor(temp_str,0)
-    if response == None:
-        return None
-    else:
-        return response[4]
-        

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

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

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

@@ -1,178 +0,0 @@
-# -*- 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

@@ -1,311 +0,0 @@
-# -*- 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

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

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

@@ -1,6 +0,0 @@
-# -*- 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