def test_get_global_variable(self):
"""
Test the get_global_variable of the OrderAnalyser Class
"""
sentence = "i am {{name2}}"
variables = {
"name": "LaMonf",
"name2": "kalliope",
"name3": u"kalliopé",
"name4": 1
}
st = Settings(variables=variables)
expected_result = "i am kalliope"
self.assertEqual(BrainLoader._get_global_variable(sentence=sentence,
settings=st),
expected_result)
# test with accent
sentence = "i am {{name3}}"
expected_result = u"i am kalliopé"
self.assertEqual(BrainLoader._get_global_variable(sentence=sentence,
settings=st),
expected_result)
# test with int
sentence = "i am {{name4}}"
expected_result = "i am 1"
self.assertEqual(BrainLoader._get_global_variable(sentence=sentence,
settings=st),
expected_result)
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_get_signals(self):
signals = [{'order': 'test_order'}]
signal = Signal(name="order", parameters="test_order")
bl = BrainLoader(file_path=self.brain_to_test)
signals_from_brain_loader = bl._get_signals(signals)
self.assertEqual([signal], signals_from_brain_loader)
def test_get_neurons(self):
neuron_list = [{'say': {'message': ['test message']}}]
neuron = Neuron(name='say', parameters={'message': ['test message']})
bl = BrainLoader(file_path=self.brain_to_test)
neurons_from_brain_loader = bl._get_neurons(neuron_list)
self.assertEqual([neuron], neurons_from_brain_loader)
def create_synapses(self):
"""
curl -i -H "Content-Type: application/json" \
--user admin:secret \
-X POST \
-d '{
"name": "Say-hello",
"signals": [
{
"order": "je suis nicolas"
}
],
"neurons": [
{
"say": {
"message": "je sais"
}
}
]
}' \
http://127.0.0.1:5000/synapses
:return:
"""
if not request.get_json() or 'name' not in request.get_json():
data = {
"Error": "Wrong parameters, 'name' not set"
}
return jsonify(error=data), 400
new_synapse = request.get_json()
try:
ConfigurationChecker().check_synape_dict(new_synapse)
except (InvalidSynapeName, NoSynapeNeurons, NoSynapeSignals) as e:
data = {
"error": "%s" % e
}
return jsonify(data), 400
try:
name = new_synapse["name"]
neurons = BrainLoader.get_neurons(new_synapse["neurons"], self.settings)
signals = BrainLoader.get_signals(new_synapse["signals"])
new_synapse_instance = Synapse(name=name, neurons=neurons, signals=signals)
self.brain.synapses.append(new_synapse_instance)
# TODO save the brain in yaml
return jsonify(new_synapse_instance.serialize()), 201
except KalliopeModuleNotFoundError as e:
data = {
"error": "%s" % e
}
return jsonify(data), 400
def __init__(self, **kwargs):
super(SignalModule, self).__init__(**kwargs)
# get the child who called the class
self.signal_name = self.__class__.__name__
Utils.print_info('Init Signal :' + self.signal_name)
self.brain = BrainLoader().brain
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 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)
if not synapse_to_start:
raise SynapseNameNotFound("[SynapseLauncher] The synapse name \"%s\" does not exist in the brain file" % 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 test_get_neurons(self):
"""
Test to get neurons from the brainLoader
scenarii:
- 1/ get a simple neuron from the brainloader
- 2/ get a neuron with brackets
- 3/ get a neuron with int as parameters
"""
# 1/ get a simple neuron from the brainloader
st = Settings()
neuron_list = [{'say': {'message': ['test message']}}]
neuron = Neuron(name='say', parameters={'message': ['test message']})
bl = BrainLoader(file_path=self.brain_to_test)
neurons_from_brain_loader = bl._get_neurons(neuron_list,
settings=st)
self.assertEqual([neuron], neurons_from_brain_loader)
# 2/ get a neuron with global variables as parameters
neuron_list = [{'say': {'message': ['bonjour {{name}}']}}]
st = Settings()
bl = BrainLoader(file_path=self.brain_to_test)
neurons_from_brain_loader = bl._get_neurons(neuron_list,
settings=st)
neuron = Neuron(name='say', parameters={'message': ['bonjour {{name}}']})
self.assertEqual([neuron], neurons_from_brain_loader)
# 3/ get a neuron with int as parameters
st = Settings()
neuron_list = [{'sleep': {'seconds': 60}}]
neuron = Neuron(name='sleep', parameters={'seconds': 60})
bl = BrainLoader(file_path=self.brain_to_test)
neurons_from_brain_loader = bl._get_neurons(neuron_list,
settings=st)
self.assertEqual([neuron], neurons_from_brain_loader)
