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
