def call_concerned_synapses(self, topic_name, message):
"""
Call synapse launcher class for each synapse concerned by the subscribed topic
convert the message to json if needed before.
The synapse is loaded with a parameter called "mqtt_subscriber_message" that can be used in neurons
:param topic_name: name of the topic that received a message from the broker
:param message: string message received from the broker
"""
# find concerned topic by name
target_topic = next(topic for topic in self.broker.topics
if topic.name == topic_name)
# convert payload to a dict if necessary
if target_topic.is_json:
message = json.loads(message)
logger.debug(
"[MqttClient] Payload message converted to JSON dict: %s" %
message)
else:
logger.debug("[MqttClient] Payload message is plain text: %s" %
message)
# run each synapse
for synapse in target_topic.synapses:
logger.debug("[MqttClient] start synapse name %s" % synapse.name)
overriding_parameter_dict = dict()
overriding_parameter_dict["mqtt_subscriber_message"] = message
SynapseLauncher.start_synapse_by_name(
synapse.name,
brain=self.brain,
overriding_parameter_dict=overriding_parameter_dict)
def run_synapse_by_name(synapse_name):
"""
This method will run the synapse
"""
Utils.print_info("[Event] triggered, running synapse: %s" %
synapse_name)
# get a brain
brain_loader = BrainLoader()
brain = brain_loader.brain
SynapseLauncher.start_synapse_by_name(synapse_name, brain=brain)
def show_synapses_test_menu(self):
"""
Show a list of available synapse in the brain to run it directly
"""
# create a tuple for the list menu
choices = list()
x = 0
for el in self.brain.synapses:
tup = (str(el.name), str(x))
choices.append(tup)
x += 1
code, tag = self.d.menu("Select a synapse to run", choices=choices)
if code == self.d.CANCEL:
self.show_main_menu()
if code == self.d.OK:
logger.debug("Run synapse from GUI: %s" % tag)
SynapseLauncher.start_synapse_by_name(tag, brain=self.brain)
self.show_synapses_test_menu()
def test_start_synapse_by_name(self):
# existing synapse in the brain
with mock.patch("intelora.core.Lifo.LIFOBuffer.execute"):
should_be_created_matched_synapse = MatchedSynapse(
matched_synapse=self.synapse1)
SynapseLauncher.start_synapse_by_name("Synapse1",
brain=self.brain_test)
# we expect that the lifo has been loaded with the synapse to run
expected_result = [[should_be_created_matched_synapse]]
lifo_buffer = LifoManager.get_singleton_lifo()
self.assertEqual(expected_result, lifo_buffer.lifo_list)
# we expect that the lifo has been loaded with the synapse to run and overwritten parameters
Singleton._instances = dict()
LifoManager.clean_saved_lifo()
lifo_buffer = LifoManager.get_singleton_lifo()
overriding_param = {"val1": "val"}
SynapseLauncher.start_synapse_by_name(
"Synapse1",
brain=self.brain_test,
overriding_parameter_dict=overriding_param)
should_be_created_matched_synapse = MatchedSynapse(
matched_synapse=self.synapse1,
overriding_parameter=overriding_param)
# we expect that the lifo has been loaded with the synapse to run
expected_result = [[should_be_created_matched_synapse]]
self.assertEqual(expected_result, lifo_buffer.lifo_list)
# non existing synapse in the brain
with self.assertRaises(SynapseNameNotFound):
SynapseLauncher.start_synapse_by_name("not_existing",
brain=self.brain_test)
def execute_synapses_in_hook_name(cls, hook_name):
# need to import SynapseLauncher from here to avoid cross import
from intelora.core.SynapseLauncher import SynapseLauncher
logger.debug("[HookManager] calling synapses in hook name: %s" %
hook_name)
settings = SettingLoader().settings
# list of synapse to execute
list_synapse = settings.hooks[hook_name]
logger.debug("[HookManager] hook: %s , type: %s" %
(hook_name, type(list_synapse)))
if isinstance(list_synapse, list):
return SynapseLauncher.start_synapse_by_list_name(list_synapse,
new_lifo=True)
if isinstance(list_synapse, str):
return SynapseLauncher.start_synapse_by_name(list_synapse,
new_lifo=True)
return None
def main():
"""Entry point of Intelora program."""
# parse argument. the script name is removed
try:
parser = parse_args(sys.argv[1:])
except SystemExit:
sys.exit(1)
# check if we want debug
configure_logging(debug=parser.debug)
logger.debug("intelora args: %s" % parser)
# 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 parser.brain_file:
brain_file = parser.brain_file
# check the user provide a valid action
if parser.action not in ACTION_LIST:
Utils.print_warning("%s is not a recognised action\n" % parser.action)
sys.exit(1)
# install modules
if parser.action == "install":
if not parser.git_url:
Utils.print_danger("You must specify the git url")
sys.exit(1)
else:
parameters = {"git_url": parser.git_url}
res_manager = ResourcesManager(**parameters)
res_manager.install()
return
# uninstall modules
if parser.action == "uninstall":
if not parser.neuron_name \
and not parser.stt_name \
and not parser.tts_name \
and not parser.trigger_name\
and not parser.signal_name:
Utils.print_danger("You must specify a module name with "
"--neuron-name "
"or --stt-name "
"or --tts-name "
"or --trigger-name "
"or --signal-name")
sys.exit(1)
else:
res_manager = ResourcesManager()
res_manager.uninstall(neuron_name=parser.neuron_name,
stt_name=parser.stt_name,
tts_name=parser.tts_name,
trigger_name=parser.trigger_name,
signal_name=parser.signal_name)
return
# load the brain once
brain_loader = BrainLoader(file_path=brain_file)
brain = brain_loader.brain
# load settings
# get global configuration once
settings_loader = SettingLoader()
settings = settings_loader.settings
if parser.action == "start":
# user set a synapse to start
if parser.run_synapse is not None:
SynapseLauncher.start_synapse_by_name(parser.run_synapse,
brain=brain)
if parser.run_order is not None:
SynapseLauncher.run_matching_synapse_from_order(parser.run_order,
brain=brain,
settings=settings,
is_api_call=False)
if (parser.run_synapse is None) and (parser.run_order is None):
# if --muted
if parser.muted:
settings.start_options['muted'] = True
# start rest api
start_rest_api(settings, brain)
start_intelora(settings, brain)
if parser.action == "gui":
try:
ShellGui(brain=brain)
except (KeyboardInterrupt, SystemExit):
Utils.print_info("Intelora stopped")
sys.exit(0)