def run(self):
ppn = None
recorder = None
try:
ppn = pvporcupine.create(access_key=self._access_key,
keywords=KEYWORDS,
sensitivities=[0.75] * len(KEYWORDS))
recorder = PvRecorder(device_index=self._device_index,
frame_length=ppn.frame_length)
recorder.start()
self._is_ready = True
while not self._stop:
pcm = recorder.read()
keyword_index = ppn.process(pcm)
if keyword_index >= 0:
self._keyword_var.set(KEYWORDS[keyword_index])
print(self._keyword_var.get())
finally:
if recorder is not None:
recorder.delete()
if ppn is not None:
ppn.delete()
self._is_stopped = True
def run(self):
self._is_recording = True
o = None
recorder = None
try:
o = create(access_key=self._access_key,
library_path=self._library_path,
model_path=self._model_path,
endpoint_duration_sec=self._endpoint_duration_sec)
recorder = PvRecorder(device_index=-1, frame_length=o.frame_length)
recorder.start()
print(f'Cheetah version : {o.version}')
while True:
partial_transcript, is_endpoint = o.process(recorder.read())
print(partial_transcript, end='', flush=True)
if is_endpoint:
print(o.flush())
except KeyboardInterrupt:
pass
finally:
if recorder is not None:
recorder.stop()
if o is not None:
o.delete()
def run(self):
recorder = None
try:
recorder = PvRecorder(device_index=self._device_index,
frame_length=self._porcupine.frame_length)
recorder.start()
print('[Listening ...]')
while True:
pcm = recorder.read()
keyword_index = self._porcupine.process(pcm)
if keyword_index >= 0:
print("detected '%s'" % self._keywords[keyword_index])
self._set_color(COLORS_RGB[KEYWORDS_COLOR[
self._keywords[keyword_index]]])
except KeyboardInterrupt:
sys.stdout.write('\b' * 2)
print('Stopping ...')
finally:
if recorder is not None:
recorder.delete()
self._porcupine.delete()
def run(self):
"""
Creates an input audio stream, instantiates an instance of Rhino object, and infers the intent from spoken
commands.
"""
rhino = None
recorder = None
wav_file = None
try:
rhino = pvrhino.create(access_key=self._access_key,
library_path=self._library_path,
model_path=self._model_path,
context_path=self._context_path,
require_endpoint=self._require_endpoint)
recorder = PvRecorder(device_index=self._audio_device_index,
frame_length=rhino.frame_length)
recorder.start()
if self._output_path is not None:
wav_file = wave.open(self._output_path, "w")
wav_file.setparams((1, 2, 16000, 512, "NONE", "NONE"))
print(rhino.context_info)
print()
print(f"Using device: {recorder.selected_device}")
print("Listening...")
print()
while True:
pcm = recorder.read()
if wav_file is not None:
wav_file.writeframes(struct.pack("h" * len(pcm), *pcm))
is_finalized = rhino.process(pcm)
if is_finalized:
inference = rhino.get_inference()
if inference.is_understood:
print('{')
print(" intent : '%s'" % inference.intent)
print(' slots : {')
for slot, value in inference.slots.items():
print(" %s : '%s'" % (slot, value))
print(' }')
print('}\n')
else:
print("Didn't understand the command.\n")
except pvrhino.RhinoInvalidArgumentError as e:
print("One or more arguments provided to Rhino is invalid: {\n" +
f"\t{self._access_key=}\n" + f"\t{self._library_path=}\n" +
f"\t{self._model_path=}\n" + f"\t{self._context_path=}\n" +
f"\t{self._require_endpoint=}\n" + "}")
print(
f"If all other arguments seem valid, ensure that '{self._access_key}' is a valid AccessKey"
)
raise e
except pvrhino.RhinoActivationError as e:
print("AccessKey activation error")
raise e
except pvrhino.RhinoActivationLimitError as e:
print(
f"AccessKey '{self._access_key}' has reached it's temporary device limit"
)
raise e
except pvrhino.RhinoActivationRefusedError as e:
print(f"AccessKey '{self._access_key}' refused")
raise e
except pvrhino.RhinoActivationThrottledError as e:
print(f"AccessKey '{self._access_key}' has been throttled")
raise e
except pvrhino.RhinoError as e:
print(f"Failed to initialize Rhino")
raise e
except KeyboardInterrupt:
print('Stopping ...')
finally:
if recorder is not None:
recorder.delete()
if rhino is not None:
rhino.delete()
if wav_file is not None:
wav_file.close()
def show_audio_devices(cls):
devices = PvRecorder.get_audio_devices()
for i in range(len(devices)):
print(f'index: {i}, device name: {devices[i]}')
def run(self):
"""
Creates an input audio stream, instantiates an instance of Porcupine object, and monitors the audio stream for
occurrences of the wake word(s). It prints the time of detection for each occurrence and the wake word.
"""
keywords = list()
for x in self._keyword_paths:
keyword_phrase_part = os.path.basename(x).replace('.ppn',
'').split('_')
if len(keyword_phrase_part) > 6:
keywords.append(' '.join(keyword_phrase_part[0:-6]))
else:
keywords.append(keyword_phrase_part[0])
porcupine = None
recorder = None
try:
porcupine = pvporcupine.create(library_path=self._library_path,
model_path=self._model_path,
keyword_paths=self._keyword_paths,
sensitivities=self._sensitivities)
recorder = PvRecorder(device_index=self._input_device_index,
frame_length=porcupine.frame_length)
recorder.start()
print(f'Using device: {recorder.selected_device}')
print('Listening {')
for keyword, sensitivity in zip(keywords, self._sensitivities):
print(' %s (%.2f)' % (keyword, sensitivity))
print('}')
while True:
pcm = recorder.read()
if self._output_path is not None:
self._recorded_frames.append(pcm)
result = porcupine.process(pcm)
if result >= 0:
print('[%s] Detected %s' %
(str(datetime.now()), keywords[result]))
break
except KeyboardInterrupt:
print('Stopping ...')
finally:
if porcupine is not None:
porcupine.delete()
if recorder is not None:
recorder.delete()
if self._output_path is not None and len(
self._recorded_frames) > 0:
recorded_audio = np.concatenate(self._recorded_frames,
axis=0).astype(np.int16)
soundfile.write(self._output_path,
recorded_audio,
samplerate=porcupine.sample_rate,
subtype='PCM_16')
def run(self):
"""
Creates an input audio stream, instantiates an instance of Porcupine object, and monitors the audio stream for
occurrences of the wake word(s). It prints the time of detection for each occurrence and the wake word.
"""
keywords = list()
for x in self._keyword_paths:
keyword_phrase_part = os.path.basename(x).replace('.ppn',
'').split('_')
if len(keyword_phrase_part) > 6:
keywords.append(' '.join(keyword_phrase_part[0:-6]))
else:
keywords.append(keyword_phrase_part[0])
porcupine = None
recorder = None
wav_file = None
try:
porcupine = pvporcupine.create(access_key=self._access_key,
library_path=self._library_path,
model_path=self._model_path,
keyword_paths=self._keyword_paths,
sensitivities=self._sensitivities)
recorder = PvRecorder(device_index=self._input_device_index,
frame_length=porcupine.frame_length)
recorder.start()
if self._output_path is not None:
wav_file = wave.open(self._output_path, "w")
wav_file.setparams((1, 2, 16000, 512, "NONE", "NONE"))
print(f'Using device: {recorder.selected_device}')
print('Listening {')
for keyword, sensitivity in zip(keywords, self._sensitivities):
print(' %s (%.2f)' % (keyword, sensitivity))
print('}')
while True:
pcm = recorder.read()
if wav_file is not None:
wav_file.writeframes(struct.pack("h" * len(pcm), *pcm))
result = porcupine.process(pcm)
if result >= 0:
print('[%s] Detected %s' %
(str(datetime.now()), keywords[result]))
except pvporcupine.PorcupineInvalidArgumentError as e:
print(
"One or more arguments provided to Porcupine is invalid: {\n" +
f"\t{self._access_key=}\n" + f"\t{self._library_path=}\n" +
f"\t{self._model_path=}\n" + f"\t{self._keyword_paths=}\n" +
f"\t{self._sensitivities=}\n" + "}")
print(
f"If all other arguments seem valid, ensure that '{self._access_key}' is a valid AccessKey"
)
raise e
except pvporcupine.PorcupineActivationError as e:
print("AccessKey activation error")
raise e
except pvporcupine.PorcupineActivationLimitError as e:
print(
f"AccessKey '{self._access_key}' has reached it's temporary device limit"
)
raise e
except pvporcupine.PorcupineActivationRefusedError as e:
print(f"AccessKey '{self._access_key}' refused")
raise e
except pvporcupine.PorcupineActivationThrottledError as e:
print(f"AccessKey '{self._access_key}' has been throttled")
raise e
except pvporcupine.PorcupineError as e:
print(f"Failed to initialize Porcupine")
raise e
except KeyboardInterrupt:
print('Stopping ...')
finally:
if porcupine is not None:
porcupine.delete()
if recorder is not None:
recorder.delete()
if wav_file is not None:
wav_file.close()