def __init__(self): self.CHUNK = 1024 self.BUF_MAX_SIZE = self.CHUNK * 10 self.q = Queue(maxsize=int(round(self.BUF_MAX_SIZE / self.CHUNK))) self.audio_source = AudioSource(self.q, True, True) self.FORMAT = pyaudio.paInt16 self.CHANNELS = 1 self.RATE = 44100 self.__apikey_stt = Config().Get("SpeechToText", "WatsonSTTAPIKey") self.__url_stt = Config().Get("SpeechToText", "WatsonSTTUrl") self.__apikey_tts = Config().Get("TextToSpeech", "WatsonTTSAPIKey") self.__url_tts = Config().Get("TextToSpeech", "WatsonTTSUrl") self.__voiceName = Config().Get("TextToSpeech", "WatsonVoiceName") self.__language_2letter_cc = Config().Get("SpeechToText", "CountryCode2Letter") self.__language_4letter_cc = Config().Get("SpeechToText", "CountryCode4Letter") self.__audioPlayer = Config().Get("TextToSpeech", "AudioPlayer") + " '{0}'" self.text_to_speech = TextToSpeechV1(url=self.__url_tts, iam_apikey=self.__apikey_tts) self.text_to_speech.set_default_headers( {'x-watson-learning-opt-out': "true"}) self.speech_to_text = SpeechToTextV1(url=self.__url_stt, iam_apikey=self.__apikey_stt) self.speech_to_text.set_default_headers( {'x-watson-learning-opt-out': "true"}) self.audio = pyaudio.PyAudio() # open stream using callback self.stream = self.audio.open(format=self.FORMAT, channels=self.CHANNELS, rate=self.RATE, input=True, frames_per_buffer=self.CHUNK, stream_callback=self.pyaudio_callback, start=False) try: rospy.init_node('STT_watson_node', anonymous=True) except: FileLogger().Info('already initialized')
def addToDatabase(file, youtube_id): with open(join(dirname(__file__), './.', file), 'rb') as audio_file: audio_source = AudioSource(audio_file) speech_to_text.recognize_using_websocket( audio=audio_source, content_type='audio/flac', recognize_callback=myRecognizeCallback, smart_formatting=True, timestamps=True, model='en-US_BroadbandModel', max_alternatives=0) try: print('This is the data object:') final_data = [] for result in myRecognizeCallback.my_data['results']: for element in result['alternatives'][0]['timestamps']: final_data.append({'keyword': element[0], 'secs': element[1], 'youtube_id': youtube_id}) print(final_data) collection_timestamps.insert_many(final_data) except: print("Can't connect to timestamp database") try: formattedText = requests.post('http://bark.phon.ioc.ee/punctuator', data={'text': myRecognizeCallback.my_transcript, 'youtube_id': youtube_id}) print('This is the formatted transcript:') my_transcript = {'transcript': formattedText.text} print(formattedText.text) collection_transcripts.insert_one(my_transcript) except: print("Can't connect to transcript database")
def stt(speech_file): sst_api_key = 'e_jevakkc6QsQcCmA41mMtKE2sJl1Ug0OEoKEi8oLIb1' sst_url = 'https://stream.watsonplatform.net/speech-to-text/api' speech_to_text = SpeechToTextV1(iam_apikey=sst_api_key, url=sst_url) class MyRecognizeCallback(RecognizeCallback): def __init__(self): RecognizeCallback.__init__(self) def on_data(self, data): print(json.dumps(data, indent=2)) def on_error(self, error): print('Error received: {}'.format(error)) def on_inactivity_timeout(self, error): print('Inactivity timeout: {}'.format(error)) myRecognizeCallback = MyRecognizeCallback() with open(join(dirname(__file__), './.', speech_file), 'rb') as audio_file: audio_source = AudioSource(audio_file) speech_to_text.recognize_using_websocket( audio=audio_source, interim_results=True, content_type='audio/wav', recognize_callback=myRecognizeCallback, keywords=[ 'ticket', 'speeding', 'limit', 'cell phone', 'cellphone', 'seatbelt', 'tailgating' ], keywords_threshold=0.8)
def test_recognize_using_websocket(self): class MyRecognizeCallback(RecognizeCallback): def __init__(self): RecognizeCallback.__init__(self) self.error = None self.transcript = None def on_error(self, error): self.error = error def on_transcription(self, transcript): self.transcript = transcript test_callback = MyRecognizeCallback() with open( os.path.join(os.path.dirname(__file__), '../../resources/speech.wav'), 'rb') as audio_file: audio_source = AudioSource(audio_file, False) t = threading.Thread( target=self.speech_to_text.recognize_using_websocket, args=(audio_source, "audio/l16; rate=44100", test_callback)) t.start() t.join() assert test_callback.error is None assert test_callback.transcript is not None assert test_callback.transcript[0][ 'transcript'] == 'thunderstorms could produce large hail isolated tornadoes and heavy rain '
def open_recognizer(audio_config): q = Queue(maxsize=int(round(audio_config['buf_max_size'],audio_config['chunk']))) audio_source = AudioSource(q,True,True) audio_thread = Thread(target=audio_callback, args=(audio_config['address'],q)) audio_thread.start() try: rec_thread = Thread(target=recognize_using_weboscket, args=(audio_source,)) rec_thread.start() while True: pass except KeyboardInterrupt: audio_source.completed_recording() return
def load_audio_forWatson(kwargs): ''' loads audio for use with Watson ''' with open(kwargs.i, 'rb') as audio_file: audio_source = AudioSource(audio_file) kwargs.audio = audio_source return kwargs
def __init__(self): logger.info('__init__:Enter') self._token = None self.transcript = None self._queue = queue.Queue() self._stt = SpeechToTextV1( iam_apikey=model.key.WATSON_APIKEY, url=model.key.WATSON_URL) self._audio_source = AudioSource(self._queue, True, True) # 2019/04/14現在、WebSocketのエンドポイントの証明書が不正扱いになっているので以下を設定する self._stt.disable_SSL_verification()
def translateSpeech(self, audio_file): audio_type = 'audio/mp3' audio_source = AudioSource(audio_file) dataCallback = DataCallback() self.speech_to_text.recognize_using_websocket( audio=audio_source, content_type=audio_type, recognize_callback=dataCallback, model='en-US_BroadbandModel')
def stt(): with open(join(dirname(__file__), './.', 'audio-file2.flac'), 'rb') as audio_file: audio_source = AudioSource(audio_file) service.recognize_using_websocket( audio=audio_source, content_type='audio/flac', recognize_callback=myRecognizeCallback, model='en-US_BroadbandModel', #keywords=['colorado', 'tornado', 'tornadoes'], #keywords_threshold=0.5, #max_alternatives=3) )
def stt_file(name): print("Opening file...") with open(name, "rb") as audio_file: watson_audio_stack = AudioSource(audio_file) print("Sending file to Watson...") stt_auth.recognize_using_websocket( audio=watson_audio_stack, content_type="audio/flac", # rate = audioin.py's RATE*CHANNELS recognize_callback=mycallback, interim_results=True, # Print all attempts, including not final responses. )
def act(self): """Realization of implemented act() method of ProcessService Create the sdk audio source buffer base on input_buffer then pass it as argument to stt service handler that listen data appearing in buffer and than after recognition process finished call callback on_transcription method and pass the recognized text there. Returns: None """ audio_source = AudioSource(self.input_buffer, True, True) self.interface.recognize_using_websocket( audio=audio_source, content_type=f'{self.REQUEST_ENCODING}; rate={self.SAMPLE_RATE}', recognize_callback=self, interim_results=True)
def stt_ws_listener(): """ Opens a socket to Watson services with the microphone's queue stack, running the callback functions defined on MyRecognizeCallback as Watson returns network data, while listening forever. """ # import pyaudio # import queue # print("Preparing Watson websocket...") # stack = queue.Queue(maxsize=16) # def listener(new_data, frame_count, time_info, status): # stack.put(new_data) # return (None, pyaudio.paContinue) # print("using audioin ", audioin.stack) # a_int = pyaudio.PyAudio() # sound_stream = a_int.open(format=pyaudio.paInt16, # channels=1, # rate=44100, # input=True, # frames_per_buffer=1024, # start=True, # stream_callback=listener) watson_audio_stack = AudioSource(audioin.stack, is_recording=True, is_buffer=True) print("Watson Audio stack created.") try: socket_output = stt_auth.recognize_using_websocket( audio=watson_audio_stack, content_type="audio/l16; rate=44100", # rate = audioin.py's RATE*CHANNELS recognize_callback=mycallback, interim_results=True, # Print all attempts, including not final responses. ) print("Socket quit with message: {}".format(socket_output)) except: print("Error at websocket!!") return
class Watson(): __metaclass__ = Singleton def __init__(self): self.CHUNK = 1024 self.BUF_MAX_SIZE = self.CHUNK * 10 self.q = Queue(maxsize=int(round(self.BUF_MAX_SIZE / self.CHUNK))) self.audio_source = AudioSource(self.q, True, True) self.FORMAT = pyaudio.paInt16 self.CHANNELS = 1 self.RATE = 44100 self.__apikey_stt = Config().Get("SpeechToText", "WatsonSTTAPIKey") self.__url_stt = Config().Get("SpeechToText", "WatsonSTTUrl") self.__apikey_tts = Config().Get("TextToSpeech", "WatsonTTSAPIKey") self.__url_tts = Config().Get("TextToSpeech", "WatsonTTSUrl") self.__voiceName = Config().Get("TextToSpeech", "WatsonVoiceName") self.__language_2letter_cc = Config().Get("SpeechToText", "CountryCode2Letter") self.__language_4letter_cc = Config().Get("SpeechToText", "CountryCode4Letter") self.__audioPlayer = Config().Get("TextToSpeech", "AudioPlayer") + " '{0}'" self.text_to_speech = TextToSpeechV1(url=self.__url_tts, iam_apikey=self.__apikey_tts) self.text_to_speech.set_default_headers( {'x-watson-learning-opt-out': "true"}) self.speech_to_text = SpeechToTextV1(url=self.__url_stt, iam_apikey=self.__apikey_stt) self.speech_to_text.set_default_headers( {'x-watson-learning-opt-out': "true"}) self.audio = pyaudio.PyAudio() # open stream using callback self.stream = self.audio.open(format=self.FORMAT, channels=self.CHANNELS, rate=self.RATE, input=True, frames_per_buffer=self.CHUNK, stream_callback=self.pyaudio_callback, start=False) try: rospy.init_node('STT_watson_node', anonymous=True) except: FileLogger().Info('already initialized') def Speak(self, audioString, playAudio=False): if (len(audioString) == 0): return tmpAudioFile = os.path.join(Global.EmeraldPath, "Data", "TTS", ("Watson_" + \ self.__language_2letter_cc + "_" + \ self.CleanString(audioString) + ".mp3")) if not os.path.isfile(tmpAudioFile): with open(join(dirname(__file__), tmpAudioFile), 'wb') as audio_file: response = self.text_to_speech.synthesize( audioString, accept='audio/mp3', voice=self.__voiceName).get_result() audio_file.write(response.content) if (playAudio): os.system(self.__audioPlayer.format(tmpAudioFile)) return tmpAudioFile def Listen(self): self.stream.start_stream() try: while True: recognize_thread = Thread( target=self.recognize_using_weboscket, args=()) recognize_thread.start() recognize_thread.join() except KeyboardInterrupt: # stop recording self.audio_source.completed_recording() self.stream.stop_stream() self.stream.close() self.audio.terminate() def CleanString(self, string): data = re.sub(r'\W+', '', string) return (data[:75] + '_TRIMMED') if len(data) > 75 else data def recognize_using_weboscket(self, *args): mycallback = MyRecognizeCallback() self.speech_to_text.recognize_using_websocket( audio=self.audio_source, content_type='audio/l16; rate=44100', recognize_callback=mycallback, interim_results=True, model='{0}_BroadbandModel'.format(self.__language_4letter_cc), smart_formatting=True) def pyaudio_callback(self, in_data, frame_count, time_info, status): try: self.q.put(in_data) except Full: pass return (None, pyaudio.paContinue)
weighted_confidence += result['alternatives'][0][ 'confidence'] * text_len / word_count print(weighted_confidence, file=open("output.txt", "a")) def on_error(self, error): print('Error received: {}'.format(error), file=open("output.txt", "a")) def on_inactivity_timeout(self, error): print('Inactivity timeout: {}'.format(error), file=open("output.txt", "a")) myRecognizeCallback = MyRecognizeCallback() original_text = ("please call stella ask her to bring these things with her " "from the store six spoons of fresh snow peas five thick " "slabs of blue cheese and maybe a snack for her brother bob " "we also need a small plastic snake and a big toy frog for " "the kids she can scoop these things into three red bags and " "we will go meet her wednesday at the train station ") for file in os.listdir(join(dirname(__file__), './resources')): with open(join(dirname(__file__), './resources', file), 'rb') as audio_file: print(file, file=open("output.txt", "a")) audio_source = AudioSource(audio_file) speech_to_text.recognize_using_websocket( audio=audio_source, content_type='audio/mp3', recognize_callback=myRecognizeCallback, model='en-US_BroadbandModel')
from Queue import Queue, Full except ImportError: from queue import Queue, Full ############################################### #### Initalize queue to store the recordings ## ############################################### CHUNK = 1024 # Note: It will discard if the websocket client can't consumme fast enough # So, increase the max size as per your choice BUF_MAX_SIZE = CHUNK * 10 # Buffer to store audio q = Queue(maxsize=int(round(BUF_MAX_SIZE / CHUNK))) # Create an instance of AudioSource audio_source = AudioSource(q, True, True) ############################################### #### Prepare Speech to Text Service ######## ############################################### # initialize speech to text service speech_to_text = SpeechToTextV1(iam_apikey='{YOUR_IAM_API_KEY}', url='{YOUR_GATEWAY_URL}') # define callback for the speech to text service class MyRecognizeCallback(RecognizeCallback): def __init__(self): RecognizeCallback.__init__(self)
class WatsonSTTCallback(RecognizeCallback): def on_data(self, data): print('on_data callback:') print(json.dumps(data, indent=2)) def on_error(self, error): print('on_error callback: {}'.format(error)) def on_inactivity_timeout(self, inactivity_timeout): print('on_inactivity_timeout callback: {}'.format(inactivity_timeout)) try: with open(audio_fn, 'rb') as audio_file: audio_fll = io.BytesIO(audio_file.read()) audio_src = AudioSource(audio_fll) stt_callback = WatsonSTTCallback() response = stt.recognize_using_websocket(audio=audio_src, content_type=audio_fn_type, recognize_callback=stt_callback, model=audio_fn_model) # Experimentally, response is None and the above call blocks until it's complete. # The on_data callback is called once with the result. if response: try: print('Status Code: ' + str(response.get_status_code())) print('Result: ' + json.dumps(response.get_result(), indent=2)) print('Headers: ', response.get_headers()) except Exception as ex: print('Exception: ' + str(ex))
def live_translate(): print('hey im here') try: from Queue import Queue, Full except ImportError: from queue import Queue, Full ############################################### #### Initalize queue to store the recordings ## ############################################### CHUNK = 1024 # Note: It will discard if the websocket client can't consumme fast enough # So, increase the max size as per your choice BUF_MAX_SIZE = CHUNK * 10 # Buffer to store audio q = Queue(maxsize=int(round(BUF_MAX_SIZE / CHUNK))) # Create an instance of AudioSource audio_source = AudioSource(q, True, True) audioTrans = {} with open("server\\routes\\spchToTxtLive.json", 'w') as f: json.dump(audioTrans, f) ############################################### #### Prepare Speech to Text Service ######## ############################################### # initialize speech to text service #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!Give Keys here!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1 # speech_to_text = SpeechToTextV1( # url="URL HERE", # iam_apikey="APIKEY HERE") # define callback for the speech to text service class MyRecognizeCallback(RecognizeCallback): def __init__(self): RecognizeCallback.__init__(self) self.transcript = None def on_transcription(self, transcript): print('transcript: {}'.format(transcript)) print(transcript) audioTrans = transcript def on_connected(self): print('Connection was successful') def on_error(self, error): print('Error received: {}'.format(error)) def on_inactivity_timeout(self, error): print('Inactivity timeout: {}'.format(error)) def on_listening(self): print('Service is listening') def on_hypothesis(self, hypothesis): print(hypothesis) def on_data(self, data): self.transcript = data['results'][0]['alternatives'][0][ 'transcript'] print('{0}final: {1}'.format( '' if data['results'][0]['final'] else 'not ', self.transcript)) audioTrans = '{0}final: {1}'.format( '' if data['results'][0]['final'] else 'not ', self.transcript) json.dump(audioTrans, f) # print(data) def on_close(self): print("Connection closed") # this function will initiate the recognize service and pass in the AudioSource def recognize_using_weboscket(*args): mycallback = MyRecognizeCallback() speech_to_text.recognize_using_websocket( audio=audio_source, content_type='audio/l16; rate=44100', recognize_callback=mycallback, interim_results=True) print(mycallback.transcript) ############################################### #### Prepare the for recording using Pyaudio ## ############################################### # Variables for recording the speech FORMAT = pyaudio.paInt16 CHANNELS = 1 RATE = 44100 # define callback for pyaudio to store the recording in queue def pyaudio_callback(in_data, frame_count, time_info, status): try: q.put(in_data) except Full: pass # discard return (None, pyaudio.paContinue) # instantiate pyaudio audio = pyaudio.PyAudio() # open stream using callback stream = audio.open(format=FORMAT, channels=CHANNELS, rate=RATE, input=True, frames_per_buffer=CHUNK, stream_callback=pyaudio_callback, start=False) ######################################################################### #### Start the recording and start service to recognize the stream ###### ######################################################################### print("Enter CTRL+C to end recording...") stream.start_stream() try: recognize_thread = Thread(target=recognize_using_weboscket, args=()) recognize_thread.start() while True: pass except KeyboardInterrupt: # stop recording audio_source.completed_recording() stream.stop_stream() stream.close() audio.terminate()
def __init__(self): """initialize the Microphone to Text service""" self.switch = True try: from Queue import Queue, Full except ImportError: from queue import Queue, Full ############################################### #### Initalize queue to store the recordings ## ############################################### self.CHUNK = 1024 # Note: It will discard if the websocket client can't consumme fast enough # So, increase the max size as per your choice self.BUF_MAX_SIZE = self.CHUNK * 100 # Buffer to store audio self.q = Queue(maxsize=int(round(self.BUF_MAX_SIZE / self.CHUNK))) # Create an instance of AudioSource self.audio_source = AudioSource(self.q, True, True) #with open('result.txt', 'w') as f: #pass # Create a results txt file self.result = open('result.txt', 'a+', encoding='utf-8') # Create a results dictionary self.keywords = dict({ 'street': [], 'location': [], 'capital': [], 'income': [], 'price': [] }) self.keywordsshort = dict() self.resultkeywords = dict({ 'street': [], 'location': [], 'capital': [], 'income': [], 'price': [] }) self.convs = ConvSent.ConvertSent() self.conv = ConvNumb.ConvertNumber() ############################################### #### Prepare Speech to Text Service ######## ############################################### # initialize speech to text service self.speech_to_text = SpeechToTextV1( #nicis key #iam_apikey='aBOJ7l-LsQuJDc9vdMcyomvfv9PeqKTToplptgmjPRlA', #url='https://gateway-lon.watsonplatform.net/speech-to-text/api') iam_apikey='SWm4Cbisst2AihTyz42f6RXVZjaLLX6UTcal_PQxtADf', url='https://stream-fra.watsonplatform.net/speech-to-text/api') ############################################### #### Prepare the for recording using Pyaudio ## ############################################### # Variables for recording the speech self.FORMAT = pyaudio.paInt16 self.CHANNELS = 1 self.RATE = 44100 # instantiate pyaudio self.audio = pyaudio.PyAudio() # open stream using callback self.stream = self.audio.open(format=self.FORMAT, channels=self.CHANNELS, rate=self.RATE, input=True, frames_per_buffer=self.CHUNK, stream_callback=self.pyaudio_callback, start=False)
class MicrophoneToText: def __init__(self): """initialize the Microphone to Text service""" self.switch = True try: from Queue import Queue, Full except ImportError: from queue import Queue, Full ############################################### #### Initalize queue to store the recordings ## ############################################### self.CHUNK = 1024 # Note: It will discard if the websocket client can't consumme fast enough # So, increase the max size as per your choice self.BUF_MAX_SIZE = self.CHUNK * 100 # Buffer to store audio self.q = Queue(maxsize=int(round(self.BUF_MAX_SIZE / self.CHUNK))) # Create an instance of AudioSource self.audio_source = AudioSource(self.q, True, True) #with open('result.txt', 'w') as f: #pass # Create a results txt file self.result = open('result.txt', 'a+', encoding='utf-8') # Create a results dictionary self.keywords = dict({ 'street': [], 'location': [], 'capital': [], 'income': [], 'price': [] }) self.keywordsshort = dict() self.resultkeywords = dict({ 'street': [], 'location': [], 'capital': [], 'income': [], 'price': [] }) self.convs = ConvSent.ConvertSent() self.conv = ConvNumb.ConvertNumber() ############################################### #### Prepare Speech to Text Service ######## ############################################### # initialize speech to text service self.speech_to_text = SpeechToTextV1( #nicis key #iam_apikey='aBOJ7l-LsQuJDc9vdMcyomvfv9PeqKTToplptgmjPRlA', #url='https://gateway-lon.watsonplatform.net/speech-to-text/api') iam_apikey='SWm4Cbisst2AihTyz42f6RXVZjaLLX6UTcal_PQxtADf', url='https://stream-fra.watsonplatform.net/speech-to-text/api') ############################################### #### Prepare the for recording using Pyaudio ## ############################################### # Variables for recording the speech self.FORMAT = pyaudio.paInt16 self.CHANNELS = 1 self.RATE = 44100 # instantiate pyaudio self.audio = pyaudio.PyAudio() # open stream using callback self.stream = self.audio.open(format=self.FORMAT, channels=self.CHANNELS, rate=self.RATE, input=True, frames_per_buffer=self.CHUNK, stream_callback=self.pyaudio_callback, start=False) def switchoff(self): """Method to end the Microphone to Text service which closes all open connections and recordings :return: None """ self.switch = False self.audio_source.completed_recording() self.stream.stop_stream() self.stream.close() self.audio.terminate() self.result.close() def recognize_using_weboscket(self, *args): """Initiate the recognize service and pass the audio source :return: None """ self.mycallback = MyRecognizeCallback() self.speech_to_text.recognize_using_websocket( audio=self.audio_source, content_type='audio/l16; rate=44100', model='de-DE_BroadbandModel', recognize_callback=self.mycallback, interim_results=True) def analyze_txt(self): """analyzes the working txt file to find specific keywords and stores the results in a dict structure note: this method runs as long as the Microphone to Text service is active and gets executed all 5 seconds :return: None """ while self.switch: with open('result.txt', 'r') as f: for text in f: # text = text.lower() if 'straße' in text or 'adreße' in text or 'adresse' in text or 'strasse' in text or 'weg' in text: self.keywords['street'].append(self.find_word(text)) if 'ort' in text or 'postleitzahl' in text or 'in' in text: self.keywords['location'].append(self.find_word(text)) if 'eigenmittel' in text or 'eigenkapital' in text: self.keywords['capital'].append(self.find_word(text)) if 'einkommen' in text or 'verdiene' in text or 'verdienen' in text: self.keywords['income'].append(self.find_word(text)) if 'kaufpreis' in text or 'koste' in text: self.keywords['price'].append(self.find_word(text)) self.keywordsshort = { k: list(set(v)) for k, v in self.keywords.items() } sleep(5) def find_correct_keyword(self): """finds in the sentences with keywords in them the essential information :return: None """ for k, v in self.keywordsshort.items(): #bindwords = ['lautet', 'ist', 'sind', 'beträgt'] uselesswords = [ 'ähm', 'äh', 'ä', 'hh', ' ', 'oh', 'uh', 'und', '[geräusch]' ] for x in v: #for y in bindwords: #if y in x: #vals = x.split(y) #val = vals[1] val = x if val in uselesswords: continue if k == 'street': print("val:" + val) to_append = self.convs.find_street(val) print(to_append) if to_append != None and to_append != 'straße': self.resultkeywords[k].append(to_append) elif k == 'location': to_append1 = self.convs.find_city(val) if to_append1 != None: self.resultkeywords[k].append(to_append1) else: self.conv.setnum(val) to_append2 = self.conv.getnum() if to_append2 != 0: self.resultkeywords[k].append(to_append2) self.resultkeywords = { k: list(set(v)) for k, v in self.resultkeywords.items() } def print_results(self): """returns the final dict structure of results :return: dict with resultkeywords """ print(self.keywordsshort) self.find_correct_keyword() print(self.resultkeywords) return self.resultkeywords def find_word(self, text): """finds the transcript in a json formatted text input :param text: json formatted string :return: the actual transcribed sentence """ words = text.split('transcript":') words = words[1].split('}') word = words[0] return word def pyaudio_callback(self, in_data, frame_count, time_info, status): """puts a recording in the queue :param in_data: the recording to put in the queue :param frame_count: frame count if its specific otherwise not used :param time_info: timestamp if its specific otherwise not used :param status: status if its specific otherwise not used :return: None, the queue continues """ try: self.q.put(in_data) except Full: pass # discard return (None, pyaudio.paContinue) def threader(self): """Starts a thread to start the Microphone to Text service :return: None """ main_thread = Thread(target=self.main) main_thread.start() def main(self): """Start the recording, start the Microphone to Text service in a separate thread and start analyzing in a separate thread :return: None """ print("Enter CTRL+C or CTRL+F2 if in pycharm to end recording...") self.stream.start_stream() try: recognize_thread = Thread(target=self.recognize_using_weboscket, args=()) recognize_thread.start() analyze_thread = Thread(target=self.analyze_txt(), ) analyze_thread.start() while self.switch: pass except KeyboardInterrupt: # stop recording for developing purposes with keyboardinterrupt self.audio_source.completed_recording() self.stream.stop_stream() self.stream.close() self.audio.terminate() self.result.close()