def conversation(self, deadline=DEFAULT_GRPC_DEADLINE): """ Starts a conversation with the Google Assistant. The device begins listening for your query or command and will wait indefinitely. Once it completes a query/command, it returns to listening for another. Args: deadline: The amount of time (in milliseconds) to wait for each gRPC request to complete before terminating. """ keep_talking = True while keep_talking: playing = False with Recorder() as recorder: #removed bytes player #play = player.play(AUDIO_FORMAT) def wrapped_play(data): nonlocal playing if not playing: self._playing_started() #playing = True #play(data) try: keep_talking = self._assist(recorder, wrapped_play, deadline) finally: #play(None) # Signal end of sound stream. recorder.done() # Signal stop recording. if playing: self._playing_stopped() return self._user_text
def conversation(self, deadline=DEFAULT_GRPC_DEADLINE): listen_flag = False keep_talking = True while keep_talking: playing = False with Recorder() as recorder, BytesPlayer() as player: play = player.play(AUDIO_FORMAT) def wrapped_play(data): nonlocal playing if not playing: self._playing_started() playing = True play(data) try: keep_talking, listen_flag = self._assist( recorder, wrapped_play, deadline) finally: play(None) # Signal end of sound stream. recorder.done() # Signal stop recording. if listen_flag: return True if playing: self._playing_stopped() return False
def recognize(self, language_code='en-US', alternative_language_codes=None, hint_phrases=None): """ Performs speech-to-text for a single utterance using the default ALSA soundcard driver. Once it detects the user is done speaking, it stops listening and delivers the top result as text. By default, this method calls :meth:`start_listening` and :meth:`stop_listening` as the recording begins and ends, respectively. Args: language_code: Language expected from the user, in IETF BCP 47 syntax (default is "en-US"). See the `list of Cloud's supported languages`_. hint_phrase: A list of strings containing words and phrases that may be expected from the user. These hints help the speech recognizer identify them in the dialog and improve the accuracy of your results. Returns: The text transcription of the user's dialog. """ streaming_config = speech_v1p1beta1.types.StreamingRecognitionConfig( config=self._make_config(language_code, alternative_language_codes, hint_phrases), single_utterance=True) with Recorder() as recorder: chunks = recorder.record(AUDIO_FORMAT, chunk_duration_sec=0.1, on_start=self.start_listening, on_stop=self.stop_listening) requests = (speech_v1p1beta1.types.StreamingRecognizeRequest( audio_content=data) for data in chunks) responses = self._client.streaming_recognize( config=streaming_config, requests=requests) for response in responses: if response.speech_event_type == END_OF_SINGLE_UTTERANCE: recorder.done() for result in response.results: if result.is_final: return result.alternatives[0].transcript return None
def conversation2(self, deadline=DEFAULT_GRPC_DEADLINE): """ Starts a conversation with the Google Assistant. The device begins listening for your query or command and will wait indefinitely. Once it completes a query/command, it returns to listening for another. Args: deadline: The amount of time (in milliseconds) to wait for each gRPC request to complete before terminating. """ keep_talking = True while keep_talking: playing = False with Recorder() as recorder, BytesPlayer() as player: play = player.play(AUDIO_FORMAT) def wrapped_play(data): nonlocal playing if not playing: self._playing_started() playing = True play(data) try: logger.info( "FINALLYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY YO SHIT" ) keep_talking = self._assist_2(recorder, wrapped_play, deadline) finally: #play(None) # Signal end of sound stream. recorder.done() # Signal stop recording. if playing: self._playing_stopped() logger.info("WE can start recording now yo f**k") self.record_candy()
def recognize(self, language_code='en-US', hint_phrases=None): streaming_config=speech.types.StreamingRecognitionConfig( config=self._make_config(language_code, hint_phrases), single_utterance=True) with Recorder() as recorder: chunks = recorder.record(AUDIO_FORMAT, chunk_duration_sec=0.1, on_start=self.start_listening, on_stop=self.stop_listening) requests = (speech.types.StreamingRecognizeRequest(audio_content=data) for data in chunks) responses = self._client.streaming_recognize(config=streaming_config, requests=requests) for response in responses: if response.speech_event_type == END_OF_SINGLE_UTTERANCE: recorder.done() for result in response.results: if result.is_final: return result.alternatives[0].transcript return None
def start(self, detected_callback=callbacks, interrupt_check=interrupt_callback, sleep_time=0.02): """ Start the voice detector. For every `sleep_time` second it checks the audio buffer for triggering keywords. If detected, then call corresponding function in `detected_callback`, which can be a single function (single model) or a list of callback functions (multiple models). Every loop it also calls `interrupt_check` -- if it returns True, then breaks from the loop and return. :param detected_callback: a function or list of functions. The number of items must match the number of models in `decoder_model`. :param interrupt_check: a function that returns True if the main loop needs to stop. :param float sleep_time: how much time in second every loop waits. :return: None """ self._running = True global interrupted interrupted = False if interrupt_check(): logger.debug("detect voice return") return tc = type(detected_callback) if tc is not list: detected_callback = [detected_callback] if len(detected_callback) == 1 and self.num_hotwords > 1: detected_callback *= self.num_hotwords assert self.num_hotwords == len(detected_callback), \ "Error: hotwords in your models (%d) do not match the number of " \ "callbacks (%d)" % (self.num_hotwords, len(detected_callback)) logger.debug("detecting...") while self._running is True: with Recorder() as recorder: for data in recorder.record(AUDIO_FORMAT, chunk_duration_sec=0.02, on_start=self.start_detect, on_stop=self.stop_detect): ans = self.detector.RunDetection(data) if ans == -1: logger.warning( "Error initializing streams or reading audio data") recorder.done() elif ans > 0: recorder.done() message = "Keyword " + str(ans) + " detected at time: " message += time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time())) logger.info(message) callback = detected_callback[ans - 1] if callback is not None: callback() if interrupt_check(): logger.debug("detect voice break") recorder.done() break logger.debug("finished.")