def test_start_synapse_by_name(self):
# existing synapse in the brain
with mock.patch("kalliope.core.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 = LIFOBuffer()
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()
lifo_buffer = LIFOBuffer()
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 test_start_synapse_by_list_name_single_synapse(self):
# existing synapse in the brain
with mock.patch("kalliope.core.Lifo.LIFOBuffer.execute"):
should_be_created_matched_synapse = MatchedSynapse(
matched_synapse=self.synapse1)
SynapseLauncher.start_synapse_by_list_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_list_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_list_name(["not_existing"],
brain=self.brain_test)
# check that the cortex is well loaded with temp parameter from a signal
with mock.patch("kalliope.core.Lifo.LIFOBuffer.execute"):
overriding_parameter_dict = {"parameter1": "value1"}
with mock.patch(
"kalliope.core.Cortex.Cortex.add_parameters_from_order"
) as cortex_mock:
SynapseLauncher.start_synapse_by_list_name(
["Synapse1"],
brain=self.brain_test,
overriding_parameter_dict=overriding_parameter_dict)
cortex_mock.assert_called_with(overriding_parameter_dict)
# check disable synapse is not run
self.synapse4.enabled = False
LifoManager.clean_saved_lifo()
with mock.patch("kalliope.core.Lifo.LIFOBuffer.execute"):
SynapseLauncher.start_synapse_by_list_name(["Synapse4"],
brain=self.brain_test)
# we expect that the lifo has NOT been loaded with the disabled synapse
expected_result = [[]]
lifo_buffer = LifoManager.get_singleton_lifo()
self.assertEqual(expected_result, lifo_buffer.lifo_list)
def test_MatchedSynapse(self):
user_order = "user order"
matched_synapse1 = MatchedSynapse(matched_synapse=self.synapse1,
matched_order=user_order)
matched_synapse2 = MatchedSynapse(matched_synapse=self.synapse2,
matched_order=user_order)
matched_synapse3 = MatchedSynapse(matched_synapse=self.synapse1,
matched_order=user_order)
expected_result_serialize = {
'matched_order': 'user order',
'neuron_module_list': [],
'synapse_name': 'Synapse1'
}
self.assertDictEqual(expected_result_serialize,
matched_synapse1.serialize())
self.assertTrue(matched_synapse1.__eq__(matched_synapse3))
self.assertFalse(matched_synapse1.__eq__(matched_synapse2))
# test neuron parameter loader is called
with mock.patch("kalliope.core.NeuronParameterLoader.get_parameters"
) as mock_get_parameters:
MatchedSynapse(matched_synapse=self.synapse1,
matched_order=user_order,
user_order=user_order)
mock_get_parameters.assert_called_once_with(
synapse_order=user_order, user_order=user_order)
mock_get_parameters.reset_mock()
def run_synapse_by_name(synapse_name,
user_order=None,
synapse_order=None,
high_priority=False,
is_api_call=False,
overriding_parameter_dict=None):
"""
call the lifo for adding a synapse to execute in the list of synapse list to process
:param synapse_name: The name of the synapse to run
:param user_order: The user order
:param synapse_order: The synapse order
:param high_priority: If True, the synapse is executed before the end of the current synapse list
:param is_api_call: If true, the current call comes from the api
:param overriding_parameter_dict: dict of value to add to neuron parameters
"""
synapse = BrainLoader().brain.get_synapse_by_name(synapse_name)
matched_synapse = MatchedSynapse(
matched_synapse=synapse,
matched_order=synapse_order,
user_order=user_order,
overriding_parameter=overriding_parameter_dict)
list_synapse_to_process = list()
list_synapse_to_process.append(matched_synapse)
# get the singleton
lifo_buffer = LifoManager.get_singleton_lifo()
lifo_buffer.add_synapse_list_to_lifo(list_synapse_to_process,
high_priority=high_priority)
lifo_buffer.execute(is_api_call=is_api_call)
def start_synapse_by_name(cls, name, brain=None):
"""
Start a synapse by it's name
:param name: Name (Unique ID) of the synapse to launch
:param brain: Brain instance
"""
logger.debug(
"[SynapseLauncher] start_synapse_by_name called with synapse name: %s "
% name)
# check if we have found and launched the synapse
synapse = brain.get_synapse_by_name(synapse_name=name)
if not synapse:
raise SynapseNameNotFound(
"The synapse name \"%s\" does not exist in the brain file" %
name)
else:
# get our singleton LIFO
lifo_buffer = LIFOBuffer()
list_synapse_to_process = list()
new_matching_synapse = MatchedSynapse(matched_synapse=synapse,
matched_order=None,
user_order=None)
list_synapse_to_process.append(new_matching_synapse)
lifo_buffer.add_synapse_list_to_lifo(list_synapse_to_process)
return lifo_buffer.execute(is_api_call=True)
def run_synapse_by_name(self, synapse_name):
"""
Run a synapse by its name
test with curl:
curl -i --user admin:secret -X POST http://127.0.0.1:5000/synapses/start/id/say-hello-fr
:param synapse_name:
:return:
"""
# get a synapse object from the name
synapse_target = BrainLoader().get_brain().get_synapse_by_name(
synapse_name=synapse_name)
if synapse_target is None:
data = {"synapse name not found": "%s" % synapse_name}
return jsonify(error=data), 404
else:
# generate a MatchedSynapse from the synapse
matched_synapse = MatchedSynapse(matched_synapse=synapse_target)
# get the current LIFO buffer
lifo_buffer = LIFOBuffer()
# this is a new call we clean up the LIFO
lifo_buffer.clean()
lifo_buffer.add_synapse_list_to_lifo([matched_synapse])
response = lifo_buffer.execute(is_api_call=True)
data = jsonify(response)
return data, 201
def test_process_synapse_list(self):
"""
Testing the neuron list from a synapse
"""
synapse = BrainLoader().brain.get_synapse_by_name("synapse1")
order = "enter in synapse 1"
matched_synapse = MatchedSynapse(matched_synapse=synapse,
user_order=order,
matched_order=order)
list_matched_synapse = list()
list_matched_synapse.append(matched_synapse)
with mock.patch("kalliope.core.Lifo.LIFOBuffer._process_neuron_list"):
self.lifo_buffer._process_synapse_list(list_matched_synapse)
expected_response = {
'status':
None,
'matched_synapses': [{
'matched_order': 'enter in synapse 1',
'neuron_module_list': [],
'synapse_name': 'synapse1'
}],
'user_order':
None
}
self.assertEqual(expected_response,
self.lifo_buffer.api_response.serialize())
self.assertEqual(0, len(self.lifo_buffer.lifo_list))
def get_list_synapses_to_process(cls, list_match_synapse):
list_synapse_to_process = list()
for tuple_el in list_match_synapse:
new_matching_synapse = MatchedSynapse(matched_synapse=tuple_el.synapse,
matched_order=tuple_el.matched_order,
user_order=tuple_el.user_order)
list_synapse_to_process.append(new_matching_synapse)
return list_synapse_to_process
def start_synapse_by_list_name(cls,
list_name,
brain=None,
overriding_parameter_dict=None,
new_lifo=False):
"""
Start synapses by their name
:param list_name: List of name of the synapse to launch
:param brain: Brain instance
:param overriding_parameter_dict: parameter to pass to neurons
:param new_lifo: If True, ask the LifoManager to return a new lifo and not the singleton
"""
logger.debug(
"[SynapseLauncher] start_synapse_by_list_name called with synapse list: %s "
% list_name)
if list_name:
if brain is None:
brain = BrainLoader().brain
if overriding_parameter_dict:
# this dict is used by signals to pass parameter to neuron,
# save in temp memory in case the user want to save in kalliope memory
Cortex.add_parameters_from_order(overriding_parameter_dict)
# get all synapse object
list_synapse_object_to_start = list()
for name in list_name:
synapse_to_start = brain.get_synapse_by_name(synapse_name=name)
if not synapse_to_start:
raise SynapseNameNotFound(
"[SynapseLauncher] The synapse name \"%s\" does not exist "
"in the brain file" % name)
if synapse_to_start.enabled:
list_synapse_object_to_start.append(synapse_to_start)
else:
logger.debug(
"[SynapseLauncher] Synapse not activated: %s " %
synapse_to_start)
# run the LIFO with all synapse
if new_lifo:
lifo_buffer = LifoManager.get_new_lifo()
else:
lifo_buffer = LifoManager.get_singleton_lifo()
list_synapse_to_process = list()
for synapse in list_synapse_object_to_start:
if synapse is not None:
new_matching_synapse = MatchedSynapse(
matched_synapse=synapse,
matched_order=None,
user_order=None,
overriding_parameter=overriding_parameter_dict)
list_synapse_to_process.append(new_matching_synapse)
lifo_buffer.add_synapse_list_to_lifo(list_synapse_to_process)
return lifo_buffer.execute(is_api_call=True)
return None
def test_process_neuron_list(self):
# Test with a neuron that doesn't wait for an answer
synapse = BrainLoader().brain.get_synapse_by_name("synapse5")
order = "synapse5"
matched_synapse = MatchedSynapse(matched_synapse=synapse,
user_order=order,
matched_order=order)
with mock.patch("kalliope.core.TTS.TTSModule.generate_and_play"):
self.lifo_buffer.set_api_call(True)
self.lifo_buffer._process_neuron_list(
matched_synapse=matched_synapse)
self.assertEqual("complete", self.lifo_buffer.api_response.status)
# test with neuron that wait for an answer
LifoManager.clean_saved_lifo()
synapse = BrainLoader().brain.get_synapse_by_name("synapse6")
order = "synapse6"
matched_synapse = MatchedSynapse(matched_synapse=synapse,
user_order=order,
matched_order=order)
self.lifo_buffer.set_api_call(True)
with mock.patch("kalliope.core.TTS.TTSModule.generate_and_play"):
with self.assertRaises(Serialize):
self.lifo_buffer._process_neuron_list(
matched_synapse=matched_synapse)
# test with a neuron that want to add a synapse list to the LIFO
LifoManager.clean_saved_lifo()
synapse = BrainLoader().brain.get_synapse_by_name("synapse6")
order = "synapse6"
matched_synapse = MatchedSynapse(matched_synapse=synapse,
user_order=order,
matched_order=order)
self.lifo_buffer.set_api_call(True)
self.lifo_buffer.set_answer("synapse 6 answer")
with mock.patch("kalliope.core.TTS.TTSModule.generate_and_play"):
self.assertRaises(
SynapseListAddedToLIFO,
self.lifo_buffer._process_neuron_list(
matched_synapse=matched_synapse))
def run_matching_synapse_from_order(cls,
order_to_process,
brain,
settings,
is_api_call=False,
no_voice=False):
"""
:param order_to_process: the spoken order sent by the user
:param brain: Brain object
:param settings: Settings object
:param is_api_call: if True, the current call come from the API. This info must be known by launched Neuron
:param no_voice: If true, the generated text will not be processed by the TTS engine
:return: list of matched synapse
"""
# get our singleton LIFO
lifo_buffer = LIFOBuffer()
# if the LIFO is not empty, so, the current order is passed to the current processing synapse as an answer
if len(lifo_buffer.lifo_list) > 0:
# the LIFO is not empty, this is an answer to a previous call
return lifo_buffer.execute(answer=order_to_process,
is_api_call=is_api_call,
no_voice=no_voice)
else: # the LIFO is empty, this is a new call
# get a list of matched synapse from the order
list_synapse_to_process = OrderAnalyser.get_matching_synapse(
order=order_to_process, brain=brain)
if not list_synapse_to_process: # the order analyser returned us an empty list
# add the default synapse if exist into the lifo
if settings.default_synapse:
logger.debug(
"[SynapseLauncher] No matching Synapse-> running default synapse "
)
# get the default synapse
default_synapse = brain.get_synapse_by_name(
settings.default_synapse)
new_matching_synapse = MatchedSynapse(
matched_synapse=default_synapse,
matched_order=None,
user_order=order_to_process)
list_synapse_to_process.append(new_matching_synapse)
else:
logger.debug(
"[SynapseLauncher] No matching Synapse and no default synapse "
)
lifo_buffer.add_synapse_list_to_lifo(list_synapse_to_process)
lifo_buffer.api_response.user_order = order_to_process
return lifo_buffer.execute(is_api_call=is_api_call,
no_voice=no_voice)
def run_synapse_by_name(self, synapse_name, user_order=None, synapse_order=None):
"""
call the lifo for adding a synapse to execute in the list of synapse list to process
:param synapse_name: The name of the synapse to run
:param user_order: The user order
:param synapse_order: The synapse order
"""
synapse = BrainLoader().get_brain().get_synapse_by_name(synapse_name)
matched_synapse = MatchedSynapse(matched_synapse=synapse,
matched_order=synapse_order,
user_order=user_order)
self.pending_synapse = matched_synapse
def run_synapse_by_name(self, synapse_name):
"""
Run a synapse by its name
test with curl:
curl -i --user admin:secret -X POST http://127.0.0.1:5000/synapses/start/id/say-hello-fr
run a synapse without making kalliope speaking
curl -i -H "Content-Type: application/json" --user admin:secret -X POST \
-d '{"mute":"true"}' http://127.0.0.1:5000/synapses/start/id/say-hello-fr
Run a synapse by its name and pass order's parameters
curl -i -H "Content-Type: application/json" --user admin:secret -X POST \
-d '{"mute":"true", "parameters": {"parameter1": "value1" }}' \
http://127.0.0.1:5000/synapses/start/id/say-hello-fr
:param synapse_name: name(id) of the synapse to execute
:return:
"""
# get a synapse object from the name
logger.debug("[FlaskAPI] run_synapse_by_name: synapse name -> %s" %
synapse_name)
synapse_target = BrainLoader().brain.get_synapse_by_name(
synapse_name=synapse_name)
# Store the mute value, then apply depending of the request parameters
old_mute_value = self.settings.options.mute
mute = self.get_value_flag_from_request(http_request=request,
flag_to_find="mute",
is_boolean=True)
if mute is not None:
SettingEditor.set_mute_status(mute=mute)
# get parameters
parameters = self.get_parameters_from_request(request)
if synapse_target is None:
data = {"synapse name not found": "%s" % synapse_name}
if mute is not None:
SettingEditor.set_mute_status(mute=old_mute_value)
return jsonify(error=data), 404
else:
# generate a MatchedSynapse from the synapse
matched_synapse = MatchedSynapse(matched_synapse=synapse_target,
overriding_parameter=parameters)
# get the current LIFO buffer from the singleton
lifo_buffer = LifoManager.get_singleton_lifo()
lifo_buffer.add_synapse_list_to_lifo([matched_synapse])
response = lifo_buffer.execute(is_api_call=True)
data = jsonify(response)
if mute is not None:
SettingEditor.set_mute_status(mute=old_mute_value)
return data, 201
def test_get_matching_synapse(self):
# Init
neuron1 = Neuron(name='neurone1', parameters={'var1': 'val1'})
neuron2 = Neuron(name='neurone2', parameters={'var2': 'val2'})
neuron3 = Neuron(name='neurone3', parameters={'var3': 'val3'})
neuron4 = Neuron(name='neurone4', parameters={'var4': 'val4'})
signal1 = Signal(name="order", parameters="this is the sentence")
signal2 = Signal(name="order",
parameters="this is the second sentence")
signal3 = Signal(name="order",
parameters="that is part of the third sentence")
synapse1 = Synapse(name="Synapse1",
neurons=[neuron1, neuron2],
signals=[signal1])
synapse2 = Synapse(name="Synapse2",
neurons=[neuron3, neuron4],
signals=[signal2])
synapse3 = Synapse(name="Synapse3",
neurons=[neuron2, neuron4],
signals=[signal3])
all_synapse_list = [synapse1, synapse2, synapse3]
br = Brain(synapses=all_synapse_list)
# TEST1: should return synapse1
spoken_order = "this is the sentence"
# Create the matched synapse
matched_synapse_1 = MatchedSynapse(matched_synapse=synapse1,
matched_order=spoken_order,
user_order=spoken_order)
matched_synapses = OrderAnalyser.get_matching_synapse(
order=spoken_order, brain=br)
self.assertEqual(len(matched_synapses), 1)
self.assertTrue(matched_synapse_1 in matched_synapses)
# TEST2: should return synapse1 and 2
spoken_order = "this is the second sentence"
matched_synapses = OrderAnalyser.get_matching_synapse(
order=spoken_order, brain=br)
self.assertEqual(len(matched_synapses), 2)
self.assertTrue(synapse1, synapse2 in matched_synapses)
# TEST3: should empty
spoken_order = "not a valid order"
matched_synapses = OrderAnalyser.get_matching_synapse(
order=spoken_order, brain=br)
self.assertFalse(matched_synapses)
def get_matching_synapse(cls, order, brain=None):
"""
Return the list of matching synapses from the given order
:param order: The user order
:param brain: The loaded brain
:return: The List of synapses matching the given order
"""
cls.brain = brain
logger.debug("[OrderAnalyser] Received order: %s" % order)
if isinstance(order, six.binary_type):
order = order.decode('utf-8')
# We use a namedtuple to associate the synapse and the signal of the synapse
synapse_order_tuple = collections.namedtuple(
'tuple_synapse_matchingOrder', ['synapse', 'order'])
list_match_synapse = list()
# if the received order is None we can stop the process immediately
if order is None:
return list_match_synapse
# test each synapse from the brain
for synapse in cls.brain.synapses:
# we are only concerned by synapse with a order type of signal
for signal in synapse.signals:
if signal.name == "order":
if cls.spelt_order_match_brain_order_via_table(
signal.parameters, order):
# the order match the synapse, we add it to the returned list
logger.debug("Order found! Run synapse name: %s" %
synapse.name)
Utils.print_success(
"Order matched in the brain. Running synapse \"%s\""
% synapse.name)
list_match_synapse.append(
synapse_order_tuple(synapse=synapse,
order=signal.parameters))
# create a list of MatchedSynapse from the tuple list
list_synapse_to_process = list()
for tuple_el in list_match_synapse:
new_matching_synapse = MatchedSynapse(
matched_synapse=tuple_el.synapse,
matched_order=tuple_el.order,
user_order=order)
list_synapse_to_process.append(new_matching_synapse)
return list_synapse_to_process
def test_add_synapse_list_to_lifo(self):
"""
Testing to add a synapse to the lifo
"""
synapse = BrainLoader().brain.get_synapse_by_name("synapse1")
order = "enter in synapse 1"
matched_synapse = MatchedSynapse(matched_synapse=synapse,
user_order=order,
matched_order=order)
list_matched_synapse = list()
list_matched_synapse.append(matched_synapse)
self.lifo_buffer.add_synapse_list_to_lifo(list_matched_synapse)
self.assertEqual(self.lifo_buffer.lifo_list, [list_matched_synapse])
def test_MatchedSynapse(self):
user_order = "user order"
matched_synapse1 = MatchedSynapse(matched_synapse=self.synapse1, matched_order=user_order)
matched_synapse2 = MatchedSynapse(matched_synapse=self.synapse2, matched_order=user_order)
matched_synapse3 = MatchedSynapse(matched_synapse=self.synapse1, matched_order=user_order)
expected_result_serialize = {
'matched_order': 'user order',
'neuron_module_list': [],
'synapse_name': 'Synapse1'
}
self.assertDictEqual(expected_result_serialize, matched_synapse1.serialize())
self.assertTrue(matched_synapse1.__eq__(matched_synapse3))
self.assertFalse(matched_synapse1.__eq__(matched_synapse2))
# test neuron parameter loader is called
with mock.patch("kalliope.core.NeuronParameterLoader.get_parameters") as mock_get_parameters:
MatchedSynapse(matched_synapse=self.synapse1, matched_order=user_order, user_order=user_order)
mock_get_parameters.assert_called_once_with(synapse_order=user_order,
user_order=user_order)
mock_get_parameters.reset_mock()
def test_start_synapse_by_name(self):
# existing synapse in the brain
with mock.patch("kalliope.core.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]]
self.assertEqual(expected_result, LIFOBuffer.lifo_list)
# non existing synapse in the brain
with self.assertRaises(SynapseNameNotFound):
SynapseLauncher.start_synapse_by_name("not_existing",
brain=self.brain_test)
def test_clean(self):
"""
Test the Cleaning of the matched synapses list
"""
synapse = BrainLoader().brain.get_synapse_by_name("synapse1")
order = "enter in synapse 1"
matched_synapse = MatchedSynapse(matched_synapse=synapse,
user_order=order,
matched_order=order)
list_matched_synapse = list()
list_matched_synapse.append(matched_synapse)
self.lifo_buffer.add_synapse_list_to_lifo(list_matched_synapse)
self.lifo_buffer.clean()
self.assertEqual(0, len(self.lifo_buffer.lifo_list))
def run_synapse_by_name(self, synapse_name):
"""
Run a synapse by its name
test with curl:
curl -i --user admin:secret -X POST http://127.0.0.1:5000/synapses/start/id/say-hello-fr
run a synapse without making kalliope speaking
curl -i -H "Content-Type: application/json" --user admin:secret -X POST \
-d '{"no_voice":"true"}' http://127.0.0.1:5000/synapses/start/id/say-hello-fr
Run a synapse by its name and pass order's parameters
curl -i -H "Content-Type: application/json" --user admin:secret -X POST \
-d '{"no_voice":"true", "parameters": {"parameter1": "value1" }}' \
http://127.0.0.1:5000/synapses/start/id/say-hello-fr
:param synapse_name: name(id) of the synapse to execute
:return:
"""
# get a synapse object from the name
logger.debug("[FlaskAPI] run_synapse_by_name: synapse name -> %s" %
synapse_name)
synapse_target = BrainLoader().get_brain().get_synapse_by_name(
synapse_name=synapse_name)
# get no_voice_flag if present
no_voice = self.get_boolean_flag_from_request(
request, boolean_flag_to_find="no_voice")
# get parameters
parameters = self.get_parameters_from_request(request)
if synapse_target is None:
data = {"synapse name not found": "%s" % synapse_name}
return jsonify(error=data), 404
else:
# generate a MatchedSynapse from the synapse
matched_synapse = MatchedSynapse(matched_synapse=synapse_target,
overriding_parameter=parameters)
# get the current LIFO buffer
lifo_buffer = LIFOBuffer()
# this is a new call we clean up the LIFO
lifo_buffer.clean()
lifo_buffer.add_synapse_list_to_lifo([matched_synapse])
response = lifo_buffer.execute(is_api_call=True, no_voice=no_voice)
data = jsonify(response)
return data, 201
def start_synapse_by_list_name(cls,
list_name,
brain=None,
overriding_parameter_dict=None,
new_lifo=False):
"""
Start synapses by their name
:param list_name: List of name of the synapse to launch
:param brain: Brain instance
:param overriding_parameter_dict: parameter to pass to neurons
:param new_lifo: If True, ask the LifoManager to return a new lifo and not the singleton
"""
logger.debug(
"[SynapseLauncher] start_synapse_by_list_name called with synapse list: %s "
% list_name)
if list_name:
if brain is None:
brain = BrainLoader().brain
# get all synapse object
list_synapse_object_to_start = list()
for name in list_name:
synapse_to_start = brain.get_synapse_by_name(synapse_name=name)
list_synapse_object_to_start.append(synapse_to_start)
# run the LIFO with all synapse
if new_lifo:
lifo_buffer = LifoManager.get_new_lifo()
else:
lifo_buffer = LifoManager.get_singleton_lifo()
list_synapse_to_process = list()
for synapse in list_synapse_object_to_start:
if synapse is not None:
new_matching_synapse = MatchedSynapse(
matched_synapse=synapse,
matched_order=None,
user_order=None,
overriding_parameter=overriding_parameter_dict)
list_synapse_to_process.append(new_matching_synapse)
lifo_buffer.add_synapse_list_to_lifo(list_synapse_to_process)
return lifo_buffer.execute(is_api_call=True)
return None
def start_synapse_by_name(cls,
name,
brain=None,
overriding_parameter_dict=None,
new_lifo=False):
"""
Start a synapse by it's name
:param name: Name (Unique ID) of the synapse to launch
:param brain: Brain instance
:param overriding_parameter_dict: parameter to pass to neurons
:param new_lifo: If True, ask the HookManager to return a new lifo and not the singleton
"""
logger.debug(
"[SynapseLauncher] start_synapse_by_name called with synapse name: %s "
% name)
if brain is None:
brain = BrainLoader().brain
# check if we have found and launched the synapse
synapse = brain.get_synapse_by_name(synapse_name=name)
if not synapse:
raise SynapseNameNotFound(
"The synapse name \"%s\" does not exist in the brain file" %
name)
else:
if new_lifo:
lifo_buffer = LifoManager.get_new_lifo()
else:
lifo_buffer = LifoManager.get_singleton_lifo()
list_synapse_to_process = list()
new_matching_synapse = MatchedSynapse(
matched_synapse=synapse,
matched_order=None,
user_order=None,
overriding_parameter=overriding_parameter_dict)
list_synapse_to_process.append(new_matching_synapse)
lifo_buffer.add_synapse_list_to_lifo(list_synapse_to_process)
return lifo_buffer.execute(is_api_call=True)
def test_APIResponse(self):
user_order = "user order"
self.matched_synapse = MatchedSynapse(matched_synapse=self.synapse1, matched_order=user_order)
api_response = APIResponse()
api_response.user_order = user_order
api_response.list_processed_matched_synapse = [self.matched_synapse]
expected_result_serialize = {
'status': None,
'matched_synapses':
[
{
'matched_order': 'user order',
'neuron_module_list': [],
'synapse_name': 'Synapse1'
}
],
'user_order': 'user order'
}
self.assertDictEqual(expected_result_serialize, api_response.serialize())
def test_get_matching_synapse(self):
# Init
neuron1 = Neuron(name='neurone1', parameters={'var1': 'val1'})
neuron2 = Neuron(name='neurone2', parameters={'var2': 'val2'})
neuron3 = Neuron(name='neurone3', parameters={'var3': 'val3'})
neuron4 = Neuron(name='neurone4', parameters={'var4': 'val4'})
signal1 = Signal(name="order", parameters="this is the sentence")
signal2 = Signal(name="order",
parameters="this is the second sentence")
signal3 = Signal(name="order",
parameters="that is part of the third sentence")
signal4 = Signal(name="order",
parameters={
"matching-type": "strict",
"text": "that is part of the fourth sentence"
})
signal5 = Signal(name="order",
parameters={
"matching-type": "ordered-strict",
"text": "sentence 5 with specific order"
})
signal6 = Signal(name="order",
parameters={
"matching-type": "normal",
"text": "matching type normal"
})
signal7 = Signal(name="order",
parameters={
"matching-type": "non-existing",
"text": "matching type non existing"
})
signal8 = Signal(name="order",
parameters={
"matching-type": "non-existing",
"non-existing-parameter": "will not match order"
})
signal9 = Signal(
name="order",
parameters=
"order that should be triggered because synapse is disabled")
signal10 = Signal(name="order", parameters="i say this")
signal11 = Signal(name="order", parameters="and then that")
signal12 = Signal(name="order",
parameters={
"matching-type": "strict",
"text": "just 1 test",
"stt-correction": [{
"input": "one",
"output": "1"
}]
})
synapse1 = Synapse(name="Synapse1",
neurons=[neuron1, neuron2],
signals=[signal1])
synapse2 = Synapse(name="Synapse2",
neurons=[neuron3, neuron4],
signals=[signal2])
synapse3 = Synapse(name="Synapse3",
neurons=[neuron2, neuron4],
signals=[signal3])
synapse4 = Synapse(name="Synapse4",
neurons=[neuron2, neuron4],
signals=[signal4])
synapse5 = Synapse(name="Synapse5",
neurons=[neuron1, neuron2],
signals=[signal5])
synapse6 = Synapse(name="Synapse6",
neurons=[neuron1, neuron2],
signals=[signal6])
synapse7 = Synapse(name="Synapse7",
neurons=[neuron1, neuron2],
signals=[signal7])
synapse8 = Synapse(name="Synapse8",
neurons=[neuron1, neuron2],
signals=[signal8])
synapse9 = Synapse(name="Synapse9",
enabled=False,
neurons=[neuron1, neuron2],
signals=[signal9])
synapse10 = Synapse(name="Synapse10",
neurons=[neuron1],
signals=[signal10, signal11])
synapse11 = Synapse(name="Synapse11",
neurons=[neuron1],
signals=[signal12])
all_synapse_list = [
synapse1, synapse2, synapse3, synapse4, synapse5, synapse6,
synapse7, synapse8, synapse9, synapse10, synapse11
]
br = Brain(synapses=all_synapse_list)
# TEST1: should return synapse1
spoken_order = "this is the sentence"
# Create the matched synapse
expected_matched_synapse_1 = MatchedSynapse(matched_synapse=synapse1,
matched_order=spoken_order,
user_order=spoken_order)
matched_synapses = OrderAnalyser.get_matching_synapse(
order=spoken_order, brain=br)
self.assertEqual(len(matched_synapses), 1)
self.assertTrue(expected_matched_synapse_1 in matched_synapses)
# with defined normal matching type
spoken_order = "matching type normal"
expected_matched_synapse_5 = MatchedSynapse(matched_synapse=synapse6,
matched_order=spoken_order,
user_order=spoken_order)
matched_synapses = OrderAnalyser.get_matching_synapse(
order=spoken_order, brain=br)
self.assertEqual(len(matched_synapses), 1)
self.assertTrue(expected_matched_synapse_5 in matched_synapses)
# TEST2: should return synapse1 and 2
spoken_order = "this is the second sentence"
expected_matched_synapse_2 = MatchedSynapse(matched_synapse=synapse1,
matched_order=spoken_order,
user_order=spoken_order)
matched_synapses = OrderAnalyser.get_matching_synapse(
order=spoken_order, brain=br)
self.assertEqual(len(matched_synapses), 2)
self.assertTrue(expected_matched_synapse_1, expected_matched_synapse_2
in matched_synapses)
# TEST3: should empty
spoken_order = "not a valid order"
matched_synapses = OrderAnalyser.get_matching_synapse(
order=spoken_order, brain=br)
self.assertFalse(matched_synapses)
# TEST4: with matching type strict
spoken_order = "that is part of the fourth sentence"
expected_matched_synapse_3 = MatchedSynapse(matched_synapse=synapse4,
matched_order=spoken_order,
user_order=spoken_order)
matched_synapses = OrderAnalyser.get_matching_synapse(
order=spoken_order, brain=br)
self.assertTrue(expected_matched_synapse_3 in matched_synapses)
spoken_order = "that is part of the fourth sentence with more word"
matched_synapses = OrderAnalyser.get_matching_synapse(
order=spoken_order, brain=br)
self.assertFalse(matched_synapses)
# TEST5: with matching type ordered strict
spoken_order = "sentence 5 with specific order"
expected_matched_synapse_4 = MatchedSynapse(matched_synapse=synapse5,
matched_order=spoken_order,
user_order=spoken_order)
matched_synapses = OrderAnalyser.get_matching_synapse(
order=spoken_order, brain=br)
self.assertEqual(len(matched_synapses), 1)
self.assertTrue(expected_matched_synapse_4 in matched_synapses)
spoken_order = "order specific with 5 sentence"
matched_synapses = OrderAnalyser.get_matching_synapse(
order=spoken_order, brain=br)
self.assertFalse(matched_synapses)
# TEST6: non supported type of matching. should fallback to normal
spoken_order = "matching type non existing"
expected_matched_synapse_5 = MatchedSynapse(matched_synapse=synapse7,
matched_order=spoken_order,
user_order=spoken_order)
matched_synapses = OrderAnalyser.get_matching_synapse(
order=spoken_order, brain=br)
self.assertTrue(expected_matched_synapse_5 in matched_synapses)
# TEST7: should not match the disabled synapse
spoken_order = "order that should be triggered because synapse is disabled"
# we expect an empty list
matched_synapses = OrderAnalyser.get_matching_synapse(
order=spoken_order, brain=br)
self.assertTrue(len(matched_synapses) == 0)
# TEST8: a spoken order that match multiple time the same synapse should return the synapse only once
spoken_order = "i say this and then that"
matched_synapses = OrderAnalyser.get_matching_synapse(
order=spoken_order, brain=br)
self.assertTrue("Synapse10" in matched_synapse.synapse.name
for matched_synapse in matched_synapses)
self.assertTrue(len(matched_synapses) == 1)
# TEST9: with STT correction
spoken_order = "just one test"
matched_synapses = OrderAnalyser.get_matching_synapse(
order=spoken_order, brain=br)
self.assertTrue("Synapse11" in matched_synapse.synapse.name
for matched_synapse in matched_synapses)
self.assertTrue(spoken_order in matched_synapse.user_order
for matched_synapse in matched_synapses)
self.assertTrue(len(matched_synapses) == 1)
def test_get_matching_synapse(self):
# Init
neuron1 = Neuron(name='neurone1', parameters={'var1': 'val1'})
neuron2 = Neuron(name='neurone2', parameters={'var2': 'val2'})
neuron3 = Neuron(name='neurone3', parameters={'var3': 'val3'})
neuron4 = Neuron(name='neurone4', parameters={'var4': 'val4'})
signal1 = Signal(name="order", parameters="this is the sentence")
signal2 = Signal(name="order",
parameters="this is the second sentence")
signal3 = Signal(name="order",
parameters="that is part of the third sentence")
signal4 = Signal(name="order",
parameters={
"matching-type": "strict",
"text": "that is part of the fourth sentence"
})
signal5 = Signal(name="order",
parameters={
"matching-type": "ordered-strict",
"text": "sentence 5 with specific order"
})
signal6 = Signal(name="order",
parameters={
"matching-type": "normal",
"text": "matching type normal"
})
signal7 = Signal(name="order",
parameters={
"matching-type": "non-existing",
"text": "matching type non existing"
})
signal8 = Signal(name="order",
parameters={
"matching-type": "non-existing",
"non-existing-parameter": "will not match order"
})
synapse1 = Synapse(name="Synapse1",
neurons=[neuron1, neuron2],
signals=[signal1])
synapse2 = Synapse(name="Synapse2",
neurons=[neuron3, neuron4],
signals=[signal2])
synapse3 = Synapse(name="Synapse3",
neurons=[neuron2, neuron4],
signals=[signal3])
synapse4 = Synapse(name="Synapse4",
neurons=[neuron2, neuron4],
signals=[signal4])
synapse5 = Synapse(name="Synapse5",
neurons=[neuron1, neuron2],
signals=[signal5])
synapse6 = Synapse(name="Synapse6",
neurons=[neuron1, neuron2],
signals=[signal6])
synapse7 = Synapse(name="Synapse6",
neurons=[neuron1, neuron2],
signals=[signal7])
synapse8 = Synapse(name="Synapse6",
neurons=[neuron1, neuron2],
signals=[signal8])
all_synapse_list = [
synapse1, synapse2, synapse3, synapse4, synapse5, synapse6,
synapse7, synapse8
]
br = Brain(synapses=all_synapse_list)
# TEST1: should return synapse1
spoken_order = "this is the sentence"
# Create the matched synapse
expected_matched_synapse_1 = MatchedSynapse(matched_synapse=synapse1,
matched_order=spoken_order,
user_order=spoken_order)
matched_synapses = OrderAnalyser.get_matching_synapse(
order=spoken_order, brain=br)
self.assertEqual(len(matched_synapses), 1)
self.assertTrue(expected_matched_synapse_1 in matched_synapses)
# with defined normal matching type
spoken_order = "matching type normal"
expected_matched_synapse_5 = MatchedSynapse(matched_synapse=synapse6,
matched_order=spoken_order,
user_order=spoken_order)
matched_synapses = OrderAnalyser.get_matching_synapse(
order=spoken_order, brain=br)
self.assertEqual(len(matched_synapses), 1)
self.assertTrue(expected_matched_synapse_5 in matched_synapses)
# TEST2: should return synapse1 and 2
spoken_order = "this is the second sentence"
expected_matched_synapse_2 = MatchedSynapse(matched_synapse=synapse1,
matched_order=spoken_order,
user_order=spoken_order)
matched_synapses = OrderAnalyser.get_matching_synapse(
order=spoken_order, brain=br)
self.assertEqual(len(matched_synapses), 2)
self.assertTrue(expected_matched_synapse_1, expected_matched_synapse_2
in matched_synapses)
# TEST3: should empty
spoken_order = "not a valid order"
matched_synapses = OrderAnalyser.get_matching_synapse(
order=spoken_order, brain=br)
self.assertFalse(matched_synapses)
# TEST4: with matching type strict
spoken_order = "that is part of the fourth sentence"
expected_matched_synapse_3 = MatchedSynapse(matched_synapse=synapse4,
matched_order=spoken_order,
user_order=spoken_order)
matched_synapses = OrderAnalyser.get_matching_synapse(
order=spoken_order, brain=br)
self.assertTrue(expected_matched_synapse_3 in matched_synapses)
spoken_order = "that is part of the fourth sentence with more word"
matched_synapses = OrderAnalyser.get_matching_synapse(
order=spoken_order, brain=br)
self.assertFalse(matched_synapses)
# TEST5: with matching type ordered strict
spoken_order = "sentence 5 with specific order"
expected_matched_synapse_4 = MatchedSynapse(matched_synapse=synapse5,
matched_order=spoken_order,
user_order=spoken_order)
matched_synapses = OrderAnalyser.get_matching_synapse(
order=spoken_order, brain=br)
self.assertEqual(len(matched_synapses), 1)
self.assertTrue(expected_matched_synapse_4 in matched_synapses)
spoken_order = "order specific with 5 sentence"
matched_synapses = OrderAnalyser.get_matching_synapse(
order=spoken_order, brain=br)
self.assertFalse(matched_synapses)
# TEST6: non supported type of matching. should fallback to normal
spoken_order = "matching type non existing"
expected_matched_synapse_5 = MatchedSynapse(matched_synapse=synapse7,
matched_order=spoken_order,
user_order=spoken_order)
matched_synapses = OrderAnalyser.get_matching_synapse(
order=spoken_order, brain=br)
self.assertTrue(expected_matched_synapse_5 in matched_synapses)
def test_execute(self):
"""
In this test the brain contains a neurotransmitter
"""
# --------------------------------------
# Test 1. The user answers correctly to all neurotransmitter
# --------------------------------------
# we suppose that the first synapse has matched the first synapse
synapse = BrainLoader().brain.get_synapse_by_name("synapse1")
order = "enter in synapse 1"
matched_synapse = MatchedSynapse(matched_synapse=synapse,
user_order=order,
matched_order=order)
list_matched_synapse = list()
list_matched_synapse.append(matched_synapse)
self.lifo_buffer.add_synapse_list_to_lifo(list_matched_synapse)
self.lifo_buffer.api_response.user_order = order
with mock.patch("kalliope.core.TTS.TTSModule.generate_and_play"):
response = self.lifo_buffer.execute(is_api_call=True)
expected_result = {
'status':
'waiting_for_answer',
'matched_synapses': [{
'matched_order':
'enter in synapse 1',
'neuron_module_list': [{
'neuron_name':
'Say',
'generated_message':
'question in synapse 1'
}],
'synapse_name':
'synapse1'
}],
'user_order':
'enter in synapse 1'
}
self.assertEqual(response, expected_result)
# give an answer
answer = "answer synapse1"
response = self.lifo_buffer.execute(answer=answer,
is_api_call=True)
expected_result = {
'status':
'waiting_for_answer',
'matched_synapses': [{
'matched_order':
'enter in synapse 1',
'neuron_module_list': [{
'neuron_name':
'Say',
'generated_message':
'question in synapse 1'
}, {
'neuron_name': 'Neurotransmitter',
'generated_message': None
}],
'synapse_name':
'synapse1'
}, {
'matched_order':
'answer synapse1',
'neuron_module_list': [{
'neuron_name':
'Say',
'generated_message':
'enter synapse 2'
}],
'synapse_name':
'synapse2'
}],
'user_order':
None
}
self.assertEqual(response, expected_result)
# give the last answer
answer = "synapse5"
response = self.lifo_buffer.execute(answer=answer,
is_api_call=True)
expected_result = {
'status':
'complete',
'matched_synapses': [{
'matched_order':
'answer synapse1',
'neuron_module_list': [{
'neuron_name':
'Say',
'generated_message':
'enter synapse 2'
}, {
'neuron_name': 'Neurotransmitter',
'generated_message': None
}],
'synapse_name':
'synapse2'
}, {
'matched_order':
'synapse5',
'neuron_module_list': [{
'neuron_name':
'Say',
'generated_message':
'execution of synapse 5'
}],
'synapse_name':
'synapse5'
}, {
'matched_order':
'enter in synapse 1',
'neuron_module_list': [{
'neuron_name':
'Say',
'generated_message':
'question in synapse 1'
}, {
'neuron_name': 'Neurotransmitter',
'generated_message': None
}, {
'neuron_name':
'Say',
'generated_message':
'last neuron in synapse 1'
}],
'synapse_name':
'synapse1'
}],
'user_order':
None
}
self.assertEqual(response, expected_result)
# --------------------------------------
# Test 2. The user doesn't answered correctly to the first neurotransmitter
# --------------------------------------
# we suppose that the first synapse has matched the first synapse
synapse = BrainLoader().brain.get_synapse_by_name("synapse1")
order = "enter in synapse 1"
matched_synapse = MatchedSynapse(matched_synapse=synapse,
user_order=order,
matched_order=order)
list_matched_synapse = list()
list_matched_synapse.append(matched_synapse)
self.lifo_buffer.add_synapse_list_to_lifo(list_matched_synapse)
self.lifo_buffer.api_response.user_order = order
with mock.patch("kalliope.core.TTS.TTSModule.generate_and_play"):
# fist call to enter in the neurotransmitter
self.lifo_buffer.execute(is_api_call=True)
wrong_answer = "wrong answer"
response = self.lifo_buffer.execute(answer=wrong_answer,
is_api_call=True)
expected_result = {
'status':
'complete',
'matched_synapses': [{
'matched_order':
'enter in synapse 1',
'neuron_module_list': [{
'neuron_name':
'Say',
'generated_message':
'question in synapse 1'
}, {
'neuron_name': 'Neurotransmitter',
'generated_message': None
}, {
'neuron_name':
'Say',
'generated_message':
'last neuron in synapse 1'
}],
'synapse_name':
'synapse1'
}, {
'matched_order':
None,
'neuron_module_list': [{
'neuron_name':
'Say',
'generated_message':
'not understood'
}],
'synapse_name':
'synapse4'
}],
'user_order':
None
}
self.assertEqual(response, expected_result)
# --------------------------------------
# Test 3. No synapse matched, we still execute the list
# --------------------------------------
list_matched_synapse = list()
self.lifo_buffer.add_synapse_list_to_lifo(list_matched_synapse)
self.lifo_buffer.api_response.user_order = "this is an order"
with mock.patch("kalliope.core.TTS.TTSModule.generate_and_play"):
# fist call to enter in the neurotransmitter
response = self.lifo_buffer.execute(is_api_call=True)
expected_result = {
'status': None,
'matched_synapses': [],
'user_order': 'this is an order'
}
self.assertEqual(response, expected_result)
def test_start_synapse_by_list_name(self):
# test to start a list of synapse
with mock.patch("kalliope.core.Lifo.LIFOBuffer.execute"):
created_matched_synapse1 = MatchedSynapse(
matched_synapse=self.synapse1)
created_matched_synapse2 = MatchedSynapse(
matched_synapse=self.synapse2)
expected_list_matched_synapse = [
created_matched_synapse1, created_matched_synapse2
]
SynapseLauncher.start_synapse_by_list_name(
["Synapse1", "Synapse2"], brain=self.brain_test)
# we expect that the lifo has been loaded with the synapse to run
expected_result = [expected_list_matched_synapse]
lifo_buffer = LifoManager.get_singleton_lifo()
self.maxDiff = None
self.assertEqual(expected_result, lifo_buffer.lifo_list)
# empty list should return none
empty_list = list()
self.assertIsNone(
SynapseLauncher.start_synapse_by_list_name(empty_list))
# test to start a synapse list with a new lifo
# we create a Lifo that is the current singleton
Singleton._instances = dict()
LifoManager.clean_saved_lifo()
lifo_buffer = LifoManager.get_singleton_lifo()
created_matched_synapse1 = MatchedSynapse(
matched_synapse=self.synapse1)
lifo_buffer.lifo_list = [created_matched_synapse1]
# the current status of the singleton lifo should not move even after the call of SynapseLauncher
expected_result = [created_matched_synapse1]
# create a new call
with mock.patch("kalliope.core.Lifo.LIFOBuffer.execute"):
SynapseLauncher.start_synapse_by_list_name(
["Synapse2", "Synapse3"], brain=self.brain_test, new_lifo=True)
# the current singleton should be the same
self.assertEqual(expected_result, lifo_buffer.lifo_list)
# test to start a synapse list with the singleton lifo
Singleton._instances = dict()
LifoManager.clean_saved_lifo()
lifo_buffer = LifoManager.get_singleton_lifo()
created_matched_synapse1 = MatchedSynapse(
matched_synapse=self.synapse1)
# place a synapse in the singleton
lifo_buffer.lifo_list = [created_matched_synapse1]
# the current status of the singleton lifo should contain synapse launched in the next call
created_matched_synapse2 = MatchedSynapse(
matched_synapse=self.synapse2)
created_matched_synapse3 = MatchedSynapse(
matched_synapse=self.synapse3)
expected_result = [
created_matched_synapse1,
[created_matched_synapse2, created_matched_synapse3]
]
with mock.patch("kalliope.core.Lifo.LIFOBuffer.execute"):
SynapseLauncher.start_synapse_by_list_name(
["Synapse2", "Synapse3"], brain=self.brain_test)
# the singleton should now contains the synapse that was already there and the 2 other synapses
self.assertEqual(expected_result, lifo_buffer.lifo_list)
def test_run_matching_synapse_from_order(self):
# ------------------
# test_match_synapse1
# ------------------
with mock.patch("kalliope.core.Lifo.LIFOBuffer.execute"):
order_to_match = "this is the sentence"
should_be_created_matched_synapse = MatchedSynapse(
matched_synapse=self.synapse1,
user_order=order_to_match,
matched_order="this is the sentence")
expected_result = [[should_be_created_matched_synapse]]
SynapseLauncher.run_matching_synapse_from_order(
order_to_match,
brain=self.brain_test,
settings=self.settings_test)
lifo_buffer = LifoManager.get_singleton_lifo()
self.assertEqual(expected_result, lifo_buffer.lifo_list)
# -------------------------
# test_match_synapse1_and_2
# -------------------------
# clean LIFO
Singleton._instances = dict()
LifoManager.clean_saved_lifo()
with mock.patch("kalliope.core.Lifo.LIFOBuffer.execute"):
order_to_match = "this is the second sentence"
should_be_created_matched_synapse1 = MatchedSynapse(
matched_synapse=self.synapse1,
user_order=order_to_match,
matched_order="this is the sentence")
should_be_created_matched_synapse2 = MatchedSynapse(
matched_synapse=self.synapse2,
user_order=order_to_match,
matched_order="this is the second sentence")
expected_result = [[
should_be_created_matched_synapse1,
should_be_created_matched_synapse2
]]
SynapseLauncher.run_matching_synapse_from_order(
order_to_match,
brain=self.brain_test,
settings=self.settings_test)
lifo_buffer = LifoManager.get_singleton_lifo()
self.assertEqual(expected_result, lifo_buffer.lifo_list)
# -------------------------
# test_call_hook_order_not_found
# -------------------------
# clean LIFO
Singleton._instances = dict()
LifoManager.clean_saved_lifo()
with mock.patch(
"kalliope.core.HookManager.on_order_not_found") as mock_hook:
order_to_match = "not existing sentence"
SynapseLauncher.run_matching_synapse_from_order(
order_to_match,
brain=self.brain_test,
settings=self.settings_test)
mock_hook.assert_called_with()
mock_hook.reset_mock()
# -------------------------
# test_call_hook_order_found
# -------------------------
# clean LIFO
Singleton._instances = dict()
with mock.patch("kalliope.core.Lifo.LIFOBuffer.execute"):
with mock.patch(
"kalliope.core.HookManager.on_order_found") as mock_hook:
order_to_match = "this is the second sentence"
new_settings = Settings()
SynapseLauncher.run_matching_synapse_from_order(
order_to_match,
brain=self.brain_test,
settings=new_settings)
mock_hook.assert_called_with()
mock_hook.reset_mock()
def test_run_matching_synapse_from_order(self):
# ------------------
# test_match_synapse1
# ------------------
with mock.patch("kalliope.core.LIFOBuffer.execute"):
order_to_match = "this is the sentence"
should_be_created_matched_synapse = MatchedSynapse(
matched_synapse=self.synapse1,
user_order=order_to_match,
matched_order="this is the sentence")
expected_result = [[should_be_created_matched_synapse]]
SynapseLauncher.run_matching_synapse_from_order(
order_to_match,
brain=self.brain_test,
settings=self.settings_test)
lifo_buffer = LIFOBuffer()
self.assertEqual(expected_result, lifo_buffer.lifo_list)
# -------------------------
# test_match_synapse1_and_2
# -------------------------
# clean LIFO
Singleton._instances = dict()
with mock.patch("kalliope.core.LIFOBuffer.execute"):
order_to_match = "this is the second sentence"
should_be_created_matched_synapse1 = MatchedSynapse(
matched_synapse=self.synapse1,
user_order=order_to_match,
matched_order="this is the sentence")
should_be_created_matched_synapse2 = MatchedSynapse(
matched_synapse=self.synapse2,
user_order=order_to_match,
matched_order="this is the second sentence")
expected_result = [[
should_be_created_matched_synapse1,
should_be_created_matched_synapse2
]]
SynapseLauncher.run_matching_synapse_from_order(
order_to_match,
brain=self.brain_test,
settings=self.settings_test)
lifo_buffer = LIFOBuffer()
self.assertEqual(expected_result, lifo_buffer.lifo_list)
# -------------------------
# test_match_default_synapse
# -------------------------
# clean LIFO
Singleton._instances = dict()
with mock.patch("kalliope.core.LIFOBuffer.execute"):
order_to_match = "not existing sentence"
should_be_created_matched_synapse = MatchedSynapse(
matched_synapse=self.synapse3,
user_order=order_to_match,
matched_order=None)
expected_result = [[should_be_created_matched_synapse]]
SynapseLauncher.run_matching_synapse_from_order(
order_to_match,
brain=self.brain_test,
settings=self.settings_test)
lifo_buffer = LIFOBuffer()
self.assertEqual(expected_result, lifo_buffer.lifo_list)
# -------------------------
# test_no_match_and_no_default_synapse
# -------------------------
# clean LIFO
Singleton._instances = dict()
with mock.patch("kalliope.core.LIFOBuffer.execute"):
order_to_match = "not existing sentence"
new_settings = Settings()
expected_result = [[]]
SynapseLauncher.run_matching_synapse_from_order(
order_to_match, brain=self.brain_test, settings=new_settings)
lifo_buffer = LIFOBuffer()
self.assertEqual(expected_result, lifo_buffer.lifo_list)
def get_matching_synapse(cls, order, brain=None):
"""
Return the list of matching synapses from the given order
:param order: The user order
:param brain: The loaded brain
:return: The List of synapses matching the given order
"""
cls.brain = brain
logger.debug("[OrderAnalyser] Received order: %s" % order)
if isinstance(order, six.binary_type):
order = order.decode('utf-8')
# We use a namedtuple to associate the synapse and the signal of the synapse
synapse_order_tuple = collections.namedtuple(
'tuple_synapse_matchingOrder', ['synapse', 'order'])
list_match_synapse = list()
# if the received order is None we can stop the process immediately
if order is None:
return list_match_synapse
# test each synapse from the brain
for synapse in cls.brain.synapses:
for signal in synapse.signals:
# we are only concerned by synapse with a order type of signal
if signal.name == "order":
# get the type of matching expected, by default "normal"
expected_matching_type = "normal"
signal_order = None
if isinstance(signal.parameters, str) or isinstance(
signal.parameters, six.text_type):
signal_order = signal.parameters
if isinstance(signal.parameters, dict):
try:
signal_order = signal.parameters["text"]
except KeyError:
logger.debug(
"[OrderAnalyser] Warning, missing parameter 'text' in order. "
"Order will be skipped")
continue
try:
expected_matching_type = signal.parameters[
"matching-type"]
except KeyError:
logger.debug(
"[OrderAnalyser] Warning, missing parameter 'matching-type' in order. "
"Fallback to 'normal'")
if cls.is_order_matching(
user_order=order,
signal_order=signal_order,
expected_order_type=expected_matching_type):
# the order match the synapse, we add it to the returned list
logger.debug("Order found! Run synapse name: %s" %
synapse.name)
Utils.print_success(
"Order matched in the brain. Running synapse \"%s\""
% synapse.name)
list_match_synapse.append(
synapse_order_tuple(synapse=synapse,
order=signal_order))
# create a list of MatchedSynapse from the tuple list
list_synapse_to_process = list()
for tuple_el in list_match_synapse:
new_matching_synapse = MatchedSynapse(
matched_synapse=tuple_el.synapse,
matched_order=tuple_el.order,
user_order=order)
list_synapse_to_process.append(new_matching_synapse)
return list_synapse_to_process
