def call_runner(limit_cnt=1): # See http://g.co/cloud/speech/docs/languages # for a list of supported languages. language_code = "ko-KR" # a BCP-47 language tag client = speech.SpeechClient() config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=RATE, language_code=language_code, ) streaming_config = speech.StreamingRecognitionConfig(config=config, interim_results=True) with MicrophoneStream(RATE, CHUNK) as stream: audio_generator = stream.generator() requests = (speech.StreamingRecognizeRequest(audio_content=content) for content in audio_generator) responses = client.streaming_recognize(streaming_config, requests) # Now, put the transcription responses to use. movie_dict_list = listen_print_loop(responses, stream, limit_cnt) print("====", movie_dict_list) # call_runner() return movie_dict_list
def main(): # See http://g.co/cloud/speech/docs/languages # for a list of supported languages. language_code = "en-US" # a BCP-47 language tag client = speech.SpeechClient.from_service_account_json( "../creds/speech_google_credentials.json") config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=RATE, language_code=language_code, ) streaming_config = speech.StreamingRecognitionConfig(config=config, interim_results=True) with MicrophoneStream(RATE, CHUNK) as stream: audio_generator = stream.generator() requests = (speech.StreamingRecognizeRequest(audio_content=content) for content in audio_generator) responses = client.streaming_recognize(streaming_config, requests) # Now, put the transcription responses to use. listen_print_loop(responses)
def main(): # See http://g.co/cloud/speech/docs/languages # for a list of supported languages. language_code = 'ja-JP' # a BCP-47 language tag import os os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = "speech-rec-827143ff9a4c.json" client = speech.SpeechClient() config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=RATE, language_code=language_code) streaming_config = speech.StreamingRecognitionConfig( config=config, interim_results=True) print("start rec") with MicrophoneStream(RATE, CHUNK) as stream: audio_generator = stream.generator() requests = (speech.StreamingRecognizeRequest(audio_content=content) for content in audio_generator) responses = client.streaming_recognize(streaming_config, requests) # Now, put the transcription responses to use. for s in listen_print_loop(responses): # voiceroid.say(s) print(s)
def transcribe(transcript, q): # See http://g.co/cloud/speech/docs/languages # for a list of supported languages. language_code = "en-US" client = speech.SpeechClient() config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=RATE, language_code=language_code) streaming_config = speech.StreamingRecognitionConfig(config=config, interim_results=True) with MicStream(RATE, CHUNK) as stream: generator = stream.generator() requests = (speech.StreamingRecognizeRequest(audio_content=content) for content in generator) responses = client.streaming_recognize(streaming_config, requests) # quit_transcript = [False] # while 1: # transcription(responses, quit_transcript) # if quit_transcript[0]: # print("Exit") # break # Now, put the transcription responses to use. listen_print_loop(responses, transcript, q)
def main(): language_code = 'ko-KR' print('AI 스피커가 동작하는데 시간이 걸립니다. 잠시만 기다려 주세요.') client = speech.SpeechClient() config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=RATE, language_code=language_code) streaming_config = speech.StreamingRecognitionConfig(config=config, interim_results=True) playsound('../../open_sound/open.wav') print('원하시는 것을 말씀 해주세요.') with MicrophoneStream(RATE, CHUNK) as stream: audio_generator = stream.generator() requests = (speech.StreamingRecognizeRequest(audio_content=content) for content in audio_generator) responses = client.streaming_recognize(streaming_config, requests) # Now, put the transcription responses to use. path = r'C:\Users\leewo\hci_test\err_sound' sounds = os.listdir(path) for sound in sounds: listen_print_loop(responses, sound)
def __init__( self, language: str, credentials: Union[None, str, dict] = None, sample_rate: int = 16000, **kwargs: Any, ) -> None: if credentials: if isinstance(credentials, str): credentials = service_account.Credentials.from_service_account_file( credentials) elif isinstance(credentials, dict): credentials = service_account.Credentials.from_service_account_info( credentials) else: raise ValueError( "Invalid Credentials: Only dict, str, or None accepted") self._client = speech.SpeechClient(credentials=credentials) self._config = speech.StreamingRecognitionConfig( config=speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=sample_rate, language_code=language, enable_automatic_punctuation=True, ), interim_results=True, ) self._queue: Queue = Queue() self._thread: Any = None
def main(): # See http://g.co/cloud/speech/docs/languages # for a list of supported languages. language_code = "en-US" # a BCP-47 language tag Labeling = speech.SpeakerDiarizationConfig( enable_speaker_diarization=True, min_speaker_count=1, max_speaker_count=5, ) client = speech.SpeechClient() config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=RATE, language_code=language_code, enable_automatic_punctuation=True, diarization_config=Labeling, ) streaming_config = speech.StreamingRecognitionConfig(config=config, interim_results=True) with MicrophoneStream(RATE, CHUNK) as stream: audio_generator = stream.generator() requests = (speech.StreamingRecognizeRequest(audio_content=content) for content in audio_generator) responses = client.streaming_recognize(streaming_config, requests) # Now, put the transcription responses to use. listen_print_loop(responses)
def create_speech_config(): phrases = [] if (len(confvars.G_PHRASES_PATH) != 0): with open(confvars.G_PHRASES_PATH, "r", encoding=confvars.G_PHRASES_ENCODING) as fp: for line in fp: if line: phrases.append(line.strip().encode( 'ascii', 'ignore').decode('ascii')) else: glbl.main_logger.info( f"Phrases file {confvars.G_PHRASES_PATH} is null.") glbl.main_logger.info(f"phrases as context, num={len(phrases)}") speech_context = speech.SpeechContext( phrases=phrases[:confvars.G_MAX_PHRASES]) config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=confvars.G_AUD_SAMPLING_RATE, enable_word_time_offsets=False, model='video', profanity_filter=True, enable_automatic_punctuation=True, speech_contexts=[speech_context], language_code=confvars.G_LANGUAGE_CODE) speech_config = speech.StreamingRecognitionConfig(config=config, interim_results=True) return speech_config
def __init__(self, audio_device): self.is_supported = is_supported if not self.is_supported: return self.audio_device = audio_device self.responseQueue = Queue(maxsize=100) self.credentials_json = speakreader.CONFIG.GOOGLE_CREDENTIALS_FILE self.client = speech.SpeechClient.from_service_account_json( self.credentials_json) self.recognition_config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=audio_device._outputSampleRate, language_code="en-US", max_alternatives=1, enable_word_time_offsets=False, enable_automatic_punctuation=True, profanity_filter=bool(speakreader.CONFIG.ENABLE_CENSORSHIP), ) self.streaming_config = speech.StreamingRecognitionConfig( config=self.recognition_config, interim_results=True, )
def download_audio_and_transcribe(self, recording_url: str) -> str: transcription: str = "" self.connect(destination="speech") response = requests.get(url=recording_url, stream=True) reqs = (speech.StreamingRecognizeRequest(audio_content=chunk) for chunk in response.iter_content()) config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=8000, language_code="en-US", ) streaming_config = speech.StreamingRecognitionConfig(config=config) responses = self.speech_client.streaming_recognize(config=streaming_config, requests=reqs,) for response in responses: # Once the transcription has settled, the first result will contain the # is_final result. The other results will be for subsequent portions of # the audio. for result in response.results: # print("Finished: {}".format(result.is_final)) # print("Stability: {}".format(result.stability)) alternatives = result.alternatives # The alternatives are ordered from most likely to least. for alternative in alternatives: # print("Confidence: {}".format(alternative.confidence)) transcription = u"{}".format(alternative.transcript) return transcription
def stt(): # See http://g.co/cloud/speech/docs/languages # for a list of supported languages. language_code = "en-US" # a BCP-47 language tag #language_code = 'ko-KR' # a BCP-47 language tag client = speech.SpeechClient() config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=RATE, language_code=language_code, ) streaming_config = speech.StreamingRecognitionConfig(config=config, interim_results=True, single_utterance=True) with MicrophoneStream(RATE, CHUNK) as stream: audio_generator = stream.generator() requests = (speech.StreamingRecognizeRequest(audio_content=content) for content in audio_generator) responses = client.streaming_recognize(streaming_config, requests) # Now, put the transcription responses to use. # print("here is final text:", end = "") return listen_print_loop(responses) # return final text
def main(): # See http://g.co/cloud/speech/docs/languages # for a list of supported languages. language_code = 'ko-KR' # a BCP-47 language tag client = speech.SpeechClient() config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=RATE, language_code=language_code) streaming_config = speech.StreamingRecognitionConfig( config=config, # single_utterance=True 파라미터 추가함 --> single spoken utterance만 인지해서 응답해줌 # 중간에 말을 멈추거나 하면 스트리밍인식을 종료함 --> 스피커소리 다시 인식 안하게됨 #single_utterance=True, # false로 바꿧어. 이렇게 바꾸면 is_final 이 true인것만 반환함 interim_results=True) with MicrophoneStream(RATE, CHUNK) as stream: audio_generator = stream.generator() requests = (speech.StreamingRecognizeRequest(audio_content=content) for content in audio_generator) responses = client.streaming_recognize(streaming_config, requests) # listen_print_loop가 리턴해도 다시 실핼될 수 있도 listen_print_loop(responses) print('main: finished listen_print_loop')
def main(): # See http://g.co/cloud/speech/docs/languages # for a list of supported languages. language_code = "ja-JP" # a BCP-47 language tag credential_path = "./aitraining-306004-2e354d0f5ba9.json" os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = credential_path client = speech.SpeechClient() config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=RATE, language_code=language_code, ) streaming_config = speech.StreamingRecognitionConfig( config=config, interim_results=True ) with MicrophoneStream(RATE, CHUNK) as stream: audio_generator = stream.generator() requests = ( speech.StreamingRecognizeRequest(audio_content=content) for content in audio_generator ) responses = client.streaming_recognize(streaming_config, requests) # Now, put the transcription responses to use. listen_print_loop(responses)
def main(lacalut): language_code = "uk-UA" client = speech.SpeechClient() interaction_type = speech.RecognitionMetadata.InteractionType.DICTATION metadata = speech.RecognitionMetadata(interaction_type=interaction_type) config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=RATE, language_code=language_code, metadata=metadata, ) streaming_config = speech.StreamingRecognitionConfig(config=config, interim_results=True) with MicrophoneStream(RATE, CHUNK) as stream: audio_generator = stream.generator() requests = (speech.StreamingRecognizeRequest(audio_content=content) for content in audio_generator) responses = client.streaming_recognize(streaming_config, requests) listen_print_loop(responses, lacalut)
def setup(self): self.client = gspeech.SpeechClient() config = gspeech.RecognitionConfig( encoding=gspeech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=self.rate, language_code=self.language, ) self.streaming_config = gspeech.StreamingRecognitionConfig( config=config, interim_results=True)
def main(): """start bidirectional streaming from microphone input to speech API""" client = speech.SpeechClient() config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=SAMPLE_RATE, language_code="ko-KR", #en-US max_alternatives=1, ) streaming_config = speech.StreamingRecognitionConfig( config=config, interim_results=True ) mic_manager = ResumableMicrophoneStream(SAMPLE_RATE, CHUNK_SIZE) print(mic_manager.chunk_size) sys.stdout.write(YELLOW) sys.stdout.write('\nListening, say "Quit" or "Exit" to stop.\n\n') sys.stdout.write("End (ms) Transcript Results/Status\n") sys.stdout.write("=====================================================\n") with mic_manager as stream: while not stream.closed: sys.stdout.write(YELLOW) sys.stdout.write( "\n" + str(STREAMING_LIMIT * stream.restart_counter) + ": NEW REQUEST\n" ) stream.audio_input = [] audio_generator = stream.generator() requests = ( speech.StreamingRecognizeRequest(audio_content=content) for content in audio_generator ) responses = client.streaming_recognize(streaming_config, requests) # Now, put the transcription responses to use. return_word = listen_print_loop(responses, stream) print(return_word) if stream.result_end_time > 0: stream.final_request_end_time = stream.is_final_end_time stream.result_end_time = 0 stream.last_audio_input = [] stream.last_audio_input = stream.audio_input stream.audio_input = [] stream.restart_counter = stream.restart_counter + 1 if not stream.last_transcript_was_final: sys.stdout.write("\n") stream.new_stream = True return return_word
def start(self, auto_turn=True, reset_result=False): # auto_turnがTrueの場合自動でターンテイキングを行う # 基本的にはTrueで良い self.print_debug("start Google ASR") if reset_result == True: self.recognition_result = "" self.is_listening = False self.utt_start_time = None self.turn_start_time = time.time() turn_thread_flag = False client = speech.SpeechClient() config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=SAMPLE_RATE, language_code="ja-JP", max_alternatives=1, ) # streaming_config = speech.StreamingRecognitionConfig( # config=config, interim_results=True) # single_utterance設定をオン # オンにしないと音声認識結果が確定するまで60秒かかる streaming_config = speech.StreamingRecognitionConfig( config=config, interim_results=True, single_utterance=True) mic_manager = ResumableMicrophoneStream(SAMPLE_RATE, CHUNK_SIZE) with mic_manager as self.stream: while not self.stream.closed: self.stream.audio_input = [] audio_generator = self.stream.generator() requests = (speech.StreamingRecognizeRequest( audio_content=content) for content in audio_generator) if (turn_thread_flag == False) and (auto_turn == True): turn_thread_flag = True self.m_turn.start_turn_thread() responses = client.streaming_recognize(streaming_config, requests) # 音声認識結果を取得するループ開始 self.listen_loop(responses) # streamリミットを超えた場合の音声認識再開処理 # 4分stream繋ぎ続けない限り実行されない if self.stream.result_end_time > 0: self.stream.final_request_end_time = self.stream.is_final_end_time self.stream.result_end_time = 0 self.stream.last_audio_input = [] self.stream.last_audio_input = self.stream.audio_input self.stream.audio_input = [] self.stream.restart_counter = self.stream.restart_counter + 1 if not self.stream.last_transcript_was_final: sys.stdout.write("\n") self.stream.new_stream = True self.file_num += 1
def set_speech(self): ''' Set the variables that needed for streaming_recognize ''' self.client = speech.SpeechClient() self.config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=self.RATE, language_code=self.language_code) self.streaming_config = speech.StreamingRecognitionConfig( config=self.config, interim_results=True)
def recognize_async_audio_stream(self, language_code="en-US"): """ Recognize in "real-time" from microphone stream. Returns when a final_result is found. May be created as a thread of its own or it'll block until a final result is found. Stores all results in the `final_result_queue` queue. Args: language_code -- language to use for recognition. See `languages` for supported languages. """ if language_code not in self.languages: print( '\"{}\" is not a supported language code. Make sure it\'s supported by Google and try adding adding it to the languages list.\n' .format(language_code)) return self.final_result_queue.queue.clear( ) # Clear all items in queue for new stream. config_stream = speech.StreamingRecognitionConfig( config=speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=self.microphone_handler.RATE, language_code=language_code, enable_automatic_punctuation=True, ), interim_results=True) self.microphone_handler.start_recording(streaming=True) while self.microphone_handler.streaming: data = self.microphone_handler.stream_generator() requests = (speech.StreamingRecognizeRequest(audio_content=content) for content in data) try: responses = self.client.streaming_recognize( config_stream, requests) for response in responses: self.final_result_queue.put(response.results[0]) if response.results[0].is_final: return # Stops more recordings than one. Doesn't halt after recording is done. (temp) if self.debug: print( response.results[0].alternatives[0].transcript + '\n' ) # Print all non final results in terminal(debug). except: print('Failed to get response.')
async def start_transcriptions_stream(self, call_sid: str): from_number = redisController.get(key=call_sid) await self.connect(destination="speech") config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.MULAW, sample_rate_hertz=8000, language_code="en-US", ) streaming_config = speech.StreamingRecognitionConfig(config=config, interim_results=True) self.stream_queue = queue.Queue() thread = threading.Thread(target=self.send_to_google, args=(streaming_config,from_number,)) thread.start()
def get_talk(): """start bidirectional streaming from microphone input to speech API""" client = speech.SpeechClient() config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=SAMPLE_RATE, language_code='ja-JP', max_alternatives=1) streaming_config = speech.StreamingRecognitionConfig(config=config, interim_results=True) mic_manager = ResumableMicrophoneStream(SAMPLE_RATE, CHUNK_SIZE) return mic_manager, client, streaming_config '''
def main(): """start bidirectional streaming from microphone input to speech API""" client = speech.SpeechClient() config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=SAMPLE_RATE, language_code="ja-JA", max_alternatives=1, ) streaming_config = speech.StreamingRecognitionConfig( config=config, interim_results=True ) '''
def get_stream_config(self): cfg = speechclient.RecognitionConfig( dict( sample_rate_hertz=DEFAULT_SAMPLE_RATE, encoding=speechclient.RecognitionConfig.AudioEncoding.LINEAR16, audio_channel_count=2, language_code='en-US', model='default', use_enhanced=False, )) return speechclient.StreamingRecognitionConfig( dict( config=cfg, single_utterance=False, interim_results=True, ))
def transcribe_streaming(stream_file): """Streams transcription of the given audio file.""" import io from google.cloud import speech client = speech.SpeechClient() # [START speech_python_migration_streaming_request] # In practice, stream should be a generator yielding chunks of audio data. stream = [stream_file] requests = (speech.StreamingRecognizeRequest(audio_content=chunk) for chunk in stream) config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=16000, language_code="en-US", ) streaming_config = speech.StreamingRecognitionConfig(config=config) # streaming_recognize returns a generator. # [START speech_python_migration_streaming_response] responses = client.streaming_recognize( config=streaming_config, requests=requests, ) # [END speech_python_migration_streaming_request] for response in responses: # Once the transcription has settled, the first result will contain the # is_final result. The other results will be for subsequent portions of # the audio. for result in response.results: print("Finished: {}".format(result.is_final)) print("Stability: {}".format(result.stability)) alternatives = result.alternatives # The alternatives are ordered from most likely to least. for alternative in alternatives: print("Confidence: {}".format(alternative.confidence)) print(u"Transcript: {}".format(alternative.transcript)) # [END speech_python_migration_streaming_response] return alternative.transcript
def socket_stream(c): with NetworkAudioStream(SAMPLE_RATE, CHUNK_SIZE, c) as stream: data = c.recv(1024) # Dummy Thread print('Headers', data, len(data), threading.currentThread().getName()) client = speech.SpeechClient() config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=SAMPLE_RATE, language_code='en-IN', max_alternatives=1) streaming_config = speech.StreamingRecognitionConfig( config=config, interim_results=True) #Start data receiving thread to fill the buffer start_new_thread(read_network_stream, ( c, stream, )) while not stream.closed: stream.audio_input = [] audio_generator = stream.generator() requests = (speech.StreamingRecognizeRequest(audio_content=content) for content in audio_generator) responses = client.streaming_recognize(streaming_config, requests) # Now, put the transcription responses to use. listen_print_loop(responses, stream) if stream.result_end_time > 0: stream.final_request_end_time = stream.is_final_end_time stream.result_end_time = 0 stream.last_audio_input = [] stream.last_audio_input = stream.audio_input stream.audio_input = [] stream.restart_counter = stream.restart_counter + 1 if not stream.last_transcript_was_final: sys.stdout.write('final-\n') stream.new_stream = True c.close()
def main(): client = speech.SpeechClient() config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=8000, language_code="en-IN") streaming_config = speech.StreamingRecognitionConfig(config=config, interim_results=True) with MicrophoneStream(8000, CHUNK) as stream: audio_generator = stream.generator() requests = (speech.StreamingRecognizeRequest(audio_content=content) for content in audio_generator) responses = client.streaming_recognize(streaming_config, requests) listen_print_loop(responses)
def main(): client = speech.SpeechClient() config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=RATE, language_code=in_language_code) streaming_config = speech.StreamingRecognitionConfig(config=config, interim_results=True) translate_client = translate.Client() speech_client = texttospeech.TextToSpeechClient() loop = asyncio.get_event_loop() with MicrophoneStream(RATE, CHUNK) as stream: audio_generator = stream.generator() requests = (speech.StreamingRecognizeRequest(audio_content=content) for content in audio_generator) responses = client.streaming_recognize(streaming_config, requests) interpret(responses, translate_client, speech_client, loop)
def __init__(self): self.order_server = actionlib.SimpleActionServer('sst_order_received', ReceiveTargetAction, self.handle_request_order, False) # self.sub_detect = rospy.Subscriber('detected_object', Result, self.handle_detector_result) # self.server = actionlib.SimpleActionServer('qrcode_detect', ReceiveTargetAction, self.handle_request_detect, False) language_code = 'ko-KR' # a BCP-47 language tag self.client = speech.SpeechClient() config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=RATE, language_code=language_code) self.streaming_config = speech.StreamingRecognitionConfig( config=config, interim_results=True) self.order_server.start() rospy.loginfo('[%s] initialized...'%rospy.get_name())
def _process(self): """Handles the setup of transcription request, and retreving audio chunks in queue.""" client = speech.SpeechClient() config = speech.RecognitionConfig(encoding=self.encoding, sample_rate_hertz=self.sample_rate, language_code=self.language_code) streaming_config = speech.StreamingRecognitionConfig( config=config, interim_results=True) # Give it a config and a generator which procduces audio chunks. in return # you get an iterator of results responses = client.streaming_recognize(streaming_config, self.generator()) # This will block until there's no more interim translation results left for response in responses: self.result_queue.put(self._response_to_dict(response))
def __init__(self): os.environ[ "GOOGLE_APPLICATION_CREDENTIALS"] = "/home/mj/PycharmProjects/speech-309618-0f83735de272.json" self.client = speech.SpeechClient() self.config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=SAMPLE_RATE, language_code="en-US", max_alternatives=1, ) self.streaming_config = speech.StreamingRecognitionConfig( config=self.config, interim_results=True) sys.stdout.write(YELLOW) sys.stdout.write('\nListening, say "Quit" or "Exit" to stop.\n\n') sys.stdout.write("End (ms) Transcript Results/Status\n") sys.stdout.write( "=====================================================\n")