41
41
SAMPLE_RATE = 16000
42
42
CHUNK_SIZE = int (SAMPLE_RATE / 10 ) # 100ms
43
43
44
- RED = " \033 [0;31m"
45
- GREEN = " \033 [0;32m"
46
- YELLOW = " \033 [0;33m"
44
+ RED = ' \033 [0;31m'
45
+ GREEN = ' \033 [0;32m'
46
+ YELLOW = ' \033 [0;33m'
47
47
48
48
49
49
def get_current_time ():
@@ -123,14 +123,12 @@ def generator(self):
123
123
if self .bridging_offset > self .final_request_end_time :
124
124
self .bridging_offset = self .final_request_end_time
125
125
126
- chunks_from_ms = round (
127
- (self .final_request_end_time - self .bridging_offset )
128
- / chunk_time
129
- )
126
+ chunks_from_ms = round ((self .final_request_end_time -
127
+ self .bridging_offset ) / chunk_time )
130
128
131
- self .bridging_offset = round (
132
- ( len (self .last_audio_input ) - chunks_from_ms ) * chunk_time
133
- )
129
+ self .bridging_offset = ( round ( (
130
+ len (self .last_audio_input ) - chunks_from_ms )
131
+ * chunk_time ) )
134
132
135
133
for i in range (chunks_from_ms , len (self .last_audio_input )):
136
134
data .append (self .last_audio_input [i ])
@@ -159,7 +157,7 @@ def generator(self):
159
157
except queue .Empty :
160
158
break
161
159
162
- yield b"" .join (data )
160
+ yield b'' .join (data )
163
161
164
162
165
163
def listen_print_loop (responses , stream ):
@@ -195,45 +193,42 @@ def listen_print_loop(responses, stream):
195
193
transcript = result .alternatives [0 ].transcript
196
194
197
195
result_seconds = 0
198
- result_nanos = 0
196
+ result_micros = 0
199
197
200
198
if result .result_end_time .seconds :
201
199
result_seconds = result .result_end_time .seconds
202
200
203
- if result .result_end_time .nanos :
204
- result_nanos = result .result_end_time .nanos
201
+ if result .result_end_time .microseconds :
202
+ result_micros = result .result_end_time .microseconds
205
203
206
- stream .result_end_time = int ((result_seconds * 1000 ) + (result_nanos / 1000000 ))
204
+ stream .result_end_time = int ((result_seconds * 1000 ) + (result_micros / 1000 ))
207
205
208
- corrected_time = (
209
- stream .result_end_time
210
- - stream .bridging_offset
211
- + (STREAMING_LIMIT * stream .restart_counter )
212
- )
206
+ corrected_time = (stream .result_end_time - stream .bridging_offset
207
+ + (STREAMING_LIMIT * stream .restart_counter ))
213
208
# Display interim results, but with a carriage return at the end of the
214
209
# line, so subsequent lines will overwrite them.
215
210
216
211
if result .is_final :
217
212
218
213
sys .stdout .write (GREEN )
219
- sys .stdout .write (" \033 [K" )
220
- sys .stdout .write (str (corrected_time ) + ": " + transcript + " \n " )
214
+ sys .stdout .write (' \033 [K' )
215
+ sys .stdout .write (str (corrected_time ) + ': ' + transcript + ' \n ' )
221
216
222
217
stream .is_final_end_time = stream .result_end_time
223
218
stream .last_transcript_was_final = True
224
219
225
220
# Exit recognition if any of the transcribed phrases could be
226
221
# one of our keywords.
227
- if re .search (r" \b(exit|quit)\b" , transcript , re .I ):
222
+ if re .search (r' \b(exit|quit)\b' , transcript , re .I ):
228
223
sys .stdout .write (YELLOW )
229
- sys .stdout .write (" Exiting...\n " )
224
+ sys .stdout .write (' Exiting...\n ' )
230
225
stream .closed = True
231
226
break
232
227
233
228
else :
234
229
sys .stdout .write (RED )
235
- sys .stdout .write (" \033 [K" )
236
- sys .stdout .write (str (corrected_time ) + ": " + transcript + " \r " )
230
+ sys .stdout .write (' \033 [K' )
231
+ sys .stdout .write (str (corrected_time ) + ': ' + transcript + ' \r ' )
237
232
238
233
stream .last_transcript_was_final = False
239
234
@@ -245,39 +240,34 @@ def main():
245
240
config = speech .RecognitionConfig (
246
241
encoding = speech .RecognitionConfig .AudioEncoding .LINEAR16 ,
247
242
sample_rate_hertz = SAMPLE_RATE ,
248
- language_code = "en-US" ,
249
- max_alternatives = 1 ,
250
- )
243
+ language_code = 'en-US' ,
244
+ max_alternatives = 1 )
251
245
streaming_config = speech .StreamingRecognitionConfig (
252
- config = config , interim_results = True
253
- )
246
+ config = config ,
247
+ interim_results = True )
254
248
255
249
mic_manager = ResumableMicrophoneStream (SAMPLE_RATE , CHUNK_SIZE )
256
250
print (mic_manager .chunk_size )
257
251
sys .stdout .write (YELLOW )
258
252
sys .stdout .write ('\n Listening, say "Quit" or "Exit" to stop.\n \n ' )
259
- sys .stdout .write (" End (ms) Transcript Results/Status\n " )
260
- sys .stdout .write (" =====================================================\n " )
253
+ sys .stdout .write (' End (ms) Transcript Results/Status\n ' )
254
+ sys .stdout .write (' =====================================================\n ' )
261
255
262
256
with mic_manager as stream :
263
257
264
258
while not stream .closed :
265
259
sys .stdout .write (YELLOW )
266
- sys .stdout .write (
267
- "\n " + str (STREAMING_LIMIT * stream .restart_counter ) + ": NEW REQUEST\n "
268
- )
260
+ sys .stdout .write ('\n ' + str (
261
+ STREAMING_LIMIT * stream .restart_counter ) + ': NEW REQUEST\n ' )
269
262
270
263
stream .audio_input = []
271
264
audio_generator = stream .generator ()
272
265
273
- requests = (
274
- speech .StreamingRecognizeRequest (audio_content = content )
275
- for content in audio_generator
276
- )
266
+ requests = (speech .StreamingRecognizeRequest (
267
+ audio_content = content )for content in audio_generator )
277
268
278
- responses = client .streaming_recognize (
279
- requests = requests , config = streaming_config
280
- )
269
+ responses = client .streaming_recognize (streaming_config ,
270
+ requests )
281
271
282
272
# Now, put the transcription responses to use.
283
273
listen_print_loop (responses , stream )
@@ -291,11 +281,11 @@ def main():
291
281
stream .restart_counter = stream .restart_counter + 1
292
282
293
283
if not stream .last_transcript_was_final :
294
- sys .stdout .write (" \n " )
284
+ sys .stdout .write (' \n ' )
295
285
stream .new_stream = True
296
286
297
287
298
- if __name__ == " __main__" :
288
+ if __name__ == ' __main__' :
299
289
300
290
main ()
301
291
0 commit comments