def __init__(self, callback=None, **kwargs): """ Start recording the microphone and analyse audio with Bing api :param callback: The callback function to call to send the text :param kwargs: """ OrderListener.__init__(self) # callback function to call after the translation speech/tex self.callback = callback # obtain audio from the microphone r = sr.Recognizer() with sr.Microphone() as source: # listen for 1 second to calibrate the energy threshold for ambient noise levels r.adjust_for_ambient_noise(source) Utils.print_info("Say something!") audio = r.listen(source) # recognize speech using Bing Speech Recognition try: key = kwargs.get('key', None) language = kwargs.get('language', "en-US") show_all = kwargs.get('show_all', False) captured_audio = r.recognize_bing(audio, key=key, language=language, show_all=show_all) Utils.print_success("Bing Speech Recognition thinks you said %s" % captured_audio) self._analyse_audio(captured_audio) except sr.UnknownValueError: Utils.print_warning("Bing Speech Recognition could not understand audio") except sr.RequestError as e: Utils.print_danger("Could not request results from Bing Speech Recognition service; {0}".format(e))
def analyse_order(self, order): """ Receive an order, try to retreive it in the brain.yml to launch to attached plugins :return: """ order_analyser = OrderAnalyser(order, main_controller=self, brain_file=self.brain_file) order_analyser.start() # restart the trigger when the order analyser has finish his job Utils.print_info("Waiting for trigger detection") self.trigger_instance.unpause() # create a new order listener that will wait for start self.order_listener = OrderListener(self.analyse_order) # restart the trigger to catch the hotword self.trigger_instance.start()
def __init__(self, callback=None, **kwargs): """ Start recording the microphone and analyse audio with google api :param callback: The callback function to call to send the text :param kwargs: """ OrderListener.__init__(self) """ Start recording the microphone :return: """ # callback function to call after the translation speech/tex self.callback = callback # obtain audio from the microphone r = sr.Recognizer() with sr.Microphone() as source: # listen for 1 second to calibrate the energy threshold for ambient noise levels r.adjust_for_ambient_noise(source) Utils.print_info("Say something!") audio = r.listen(source) # recognize speech using Google Speech Recognition try: # for testing purposes, we're just using the default API key # to use another API key, use `r.recognize_google(audio, key="GOOGLE_SPEECH_RECOGNITION_API_KEY")` # instead of `r.recognize_google(audio)` key = kwargs.get('key', None) language = kwargs.get('language', "en-US") show_all = kwargs.get('show_all', False) captured_audio = r.recognize_google(audio, key=key, language=language, show_all=show_all) Utils.print_success( "Google Speech Recognition thinks you said %s" % captured_audio) self._analyse_audio(captured_audio) except sr.UnknownValueError: Utils.print_warning( "Google Speech Recognition could not understand audio") except sr.RequestError as e: Utils.print_danger( "Could not request results from Google Speech Recognition service; {0}" .format(e))
def analyse_order(self, order): """ Receive an order, try to retrieve it in the brain.yml to launch to attached plugins :param order: the sentence received :type order: str """ if order is not None: # maybe we have received a null audio from STT engine order_analyser = OrderAnalyser(order, main_controller=self, brain=self.brain) order_analyser.start() # restart the trigger when the order analyser has finish his job Utils.print_info("Waiting for trigger detection") self.trigger_instance.unpause() # create a new order listener that will wait for start self.order_listener = OrderListener(self.analyse_order) # restart the trigger to catch the hotword self.trigger_instance.start()
def __init__(self, brain_file=None): self.brain_file = brain_file # get global configuration self.settings = SettingLoader.get_settings() # run the api if the user want it if self.settings.rest_api.active: Utils.print_info("Starting REST API Listening port: %s" % self.settings.rest_api.port) app = Flask(__name__) flask_api = FlaskAPI(app, port=self.settings.rest_api.port, brain_file=brain_file) flask_api.start() # create an order listener object. This last will the trigger callback before starting self.order_listener = OrderListener(self.analyse_order) # Wait that the kalliope trigger is pronounced by the user self.trigger_instance = self._get_default_trigger() self.trigger_instance.start() Utils.print_info("Waiting for trigger detection")
class MainController: def __init__(self, brain_file=None): self.brain_file = brain_file # get global configuration self.settings = SettingLoader.get_settings() # run the api if the user want it if self.settings.rest_api.active: Utils.print_info("Starting REST API Listening port: %s" % self.settings.rest_api.port) app = Flask(__name__) flask_api = FlaskAPI(app, port=self.settings.rest_api.port, brain_file=brain_file) flask_api.start() # create an order listener object. This last will the trigger callback before starting self.order_listener = OrderListener(self.analyse_order) # Wait that the kalliope trigger is pronounced by the user self.trigger_instance = self._get_default_trigger() self.trigger_instance.start() Utils.print_info("Waiting for trigger detection") def callback(self): """ # we have detected the hotword, we can now pause the kalliope Trigger for a while # The user can speak out loud his order during this time. :return: """ # pause the snowboy process self.trigger_instance.pause() # start listening for an order self.order_listener.start() # if random wake answer sentence are present, we play this if self.settings.random_wake_up_answers is not None: Say(message=self.settings.random_wake_up_answers) else: ap = AudioPlayer() ap.init_play() random_sound_to_play = self._get_random_sound(self.settings.random_wake_up_sounds) ap.play_audio(random_sound_to_play) def analyse_order(self, order): """ Receive an order, try to retreive it in the brain.yml to launch to attached plugins :return: """ order_analyser = OrderAnalyser(order, main_controller=self, brain_file=self.brain_file) order_analyser.start() # restart the trigger when the order analyser has finish his job Utils.print_info("Waiting for trigger detection") self.trigger_instance.unpause() # create a new order listener that will wait for start self.order_listener = OrderListener(self.analyse_order) # restart the trigger to catch the hotword self.trigger_instance.start() def _get_default_trigger(self): """ Return an instance of the default trigger :return: """ for trigger in self.settings.triggers: if trigger.name == self.settings.default_trigger_name: return TriggerLauncher.get_trigger(trigger, callback=self.callback) @staticmethod def _get_random_sound(random_wake_up_sounds): """ Return a path of a sound to play If the path is absolute, test if file exist If the path is relative, we check if the file exist in the sound folder :param random_wake_up_sounds: :return: """ # take first randomly a path random_path = random.choice(random_wake_up_sounds) logger.debug("Selected sound: %s" % random_path) if os.path.isabs(random_path): logger.debug("Path of file %s is absolute" % random_path) return random_path else: logger.debug("Path of file %s is relative" % random_path) return "sounds" + os.sep + random_path