def _add_event(self, period_string, event_id):
"""
Add a single event in the crontab.
Will add a line like:
<period_string> python /path/to/kalliope.py start --brain-file /path/to/brain.yml --run-synapse "<event_id>"
E.g:
30 7 * * * python /home/me/kalliope/kalliope.py start --brain-file /home/me/brain.yml --run-synapse "Say-hello"
:param period_string: crontab period
:type period_string: str
:param event_id:
:type event_id: str
:return:
"""
my_user_cron = CronTab(user=True)
job = my_user_cron.new(command=self.base_command + " " +
str("\"" + event_id + "\""),
comment=CRONTAB_COMMENT)
if CronSlices.is_valid(period_string):
job.setall(period_string)
job.enable()
else:
raise InvalidCrontabPeriod("The crontab period %s is not valid" %
period_string)
# write the file
my_user_cron.write()
Utils.print_info("Synapse \"%s\" added to the crontab" % event_id)
def main():
"""
Entry point of Kalliope program
"""
# create arguments
parser = argparse.ArgumentParser(description='Kalliope')
parser.add_argument("action", help="[start|gui]")
parser.add_argument("--run-synapse",
help="Name of a synapse to load surrounded by quote")
parser.add_argument("--brain-file", help="Full path of a brain file")
parser.add_argument("--debug",
action='store_true',
help="Show debug output")
# parse arguments from script parameters
args = parser.parse_args()
# require at least one parameter, the action
if len(sys.argv[1:]) == 0:
parser.print_usage()
sys.exit(1)
# check if we want debug
configure_logging(debug=args.debug)
logger.debug("kalliope args: %s" % args)
# by default, no brain file is set. Use the default one: brain.yml in the root path
brain_file = None
# check if user set a brain.yml file
if args.brain_file:
brain_file = args.brain_file
# load the brain once
brain = BrainLoader.get_brain(file_path=brain_file)
# check the user provide a valid action
if args.action not in ACTION_LIST:
Utils.print_warning("%s is not a recognised action\n" % args.action)
parser.print_help()
if args.action == "start":
# user set a synapse to start
if args.run_synapse is not None:
SynapseLauncher.start_synapse(args.run_synapse, brain=brain)
if args.run_synapse is None:
# first, load events in crontab
crontab_manager = CrontabManager(brain=brain)
crontab_manager.load_events_in_crontab()
Utils.print_success("Events loaded in crontab")
# then start kalliope
Utils.print_success("Starting Kalliope")
Utils.print_info("Press Ctrl+C for stopping")
# catch signal for killing on Ctrl+C pressed
signal.signal(signal.SIGINT, signal_handler)
# start the main controller
MainController(brain=brain)
if args.action == "gui":
ShellGui(brain=brain)
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 signal_handler(signal, frame):
"""
Used to catch a keyboard signal like Ctrl+C in order to kill the kalliope program
:param signal: signal handler
:param frame: execution frame
"""
print "\n"
Utils.print_info("Ctrl+C pressed. Killing Kalliope")
sys.exit(0)
def _add_event(self, period_string, event_id):
my_user_cron = CronTab(user=True)
job = my_user_cron.new(command=self.base_command+" "+str("\"" + event_id + "\""), comment=CRONTAB_COMMENT)
if CronSlices.is_valid(period_string):
job.setall(period_string)
job.enable()
else:
raise InvalidCrontabPeriod("The crontab period %s is not valid" % period_string)
# write the file
my_user_cron.write()
Utils.print_info("Synapse \"%s\" added to the crontab" % event_id)
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")
def signal_handler(signal, frame):
print "\n"
Utils.print_info("Ctrl+C pressed. Killing Kalliope")
sys.exit(0)
