def run_ansible_playbook_module(self, install_file_path):
"""
Run the install.yml file through an Ansible playbook using the dedicated neuron !
:param sudo_password: local machine sudo password required to install libraries
:param install_file_path: the path of the Ansible playbook to run.
:return:
"""
logger.debug("[ResourcesManager] Run ansible playbook")
Utils.print_info("Starting neuron installation")
# ask the sudo password
if self.sudo_password is not None:
pswd = self.sudo_password
else:
pswd = getpass.getpass('Sudo password:')
if not pswd or pswd == "":
Utils.print_warning("You must enter a sudo password")
return False
else:
ansible_neuron_parameters = {
"task_file": install_file_path,
"sudo": True,
"sudo_user": "******",
"sudo_password": pswd
}
neuron = Neuron(name="ansible_playbook",
parameters=ansible_neuron_parameters)
NeuronLauncher.start_neuron(neuron)
return True
def test_parameters_are_available_in_loaded_parameters(self):
# the parameter in bracket is available in the dict
string_parameters = "this is a {{ parameter1 }}"
loaded_parameters = {"parameter1": "value"}
self.assertTrue(NeuronLauncher._neuron_parameters_are_available_in_loaded_parameters(string_parameters,
loaded_parameters))
# the parameter in bracket is NOT available in the dict
string_parameters = "this is a {{ parameter1 }}"
loaded_parameters = {"parameter2": "value"}
self.assertFalse(NeuronLauncher._neuron_parameters_are_available_in_loaded_parameters(string_parameters,
loaded_parameters))
# the string_parameters doesn't contains bracket in bracket is available in the dict
string_parameters = "this is a {{ parameter1 }}"
loaded_parameters = {"parameter1": "value"}
self.assertTrue(NeuronLauncher._neuron_parameters_are_available_in_loaded_parameters(string_parameters,
loaded_parameters))
# the string_parameters contains 2 parameters available in the dict
string_parameters = "this is a {{ parameter1 }} and this is {{ parameter2 }}"
loaded_parameters = {"parameter1": "value", "parameter2": "other value"}
self.assertTrue(NeuronLauncher._neuron_parameters_are_available_in_loaded_parameters(string_parameters,
loaded_parameters))
# the string_parameters contains 2 parameters and one of them is not available in the dict
string_parameters = "this is a {{ parameter1 }} and this is {{ parameter2 }}"
loaded_parameters = {"parameter1": "value", "parameter3": "other value"}
self.assertFalse(NeuronLauncher._neuron_parameters_are_available_in_loaded_parameters(string_parameters,
loaded_parameters))
def _run_synapse(cls, synapse):
"""
Start all neurons in the synapse
:param synapse: Synapse for which we run neurons
:return:
"""
for neuron in synapse.neurons:
NeuronLauncher.start_neuron(neuron)
return True
def test_launch_neuron(self):
"""
Test the Neuron Launcher trying to start a Neuron
"""
neuron = Neuron(name='neurone1', parameters={'var1': 'val1'})
sl = SettingLoader()
resources = Resources(neuron_folder='/var/tmp/test/resources')
sl.settings.resources = resources
with mock.patch("kalliope.core.Utils.get_dynamic_class_instantiation") as mock_get_class_instantiation:
NeuronLauncher.launch_neuron(neuron=neuron)
mock_get_class_instantiation.assert_called_once_with(package_name="neurons",
module_name=neuron.name,
parameters=neuron.parameters,
resources_dir=sl.settings.resources.neuron_folder)
mock_get_class_instantiation.reset_mock()
def test_start_neuron(self):
"""
Test the Neuron Launcher trying to start a Neuron
"""
neuron = Neuron(name='neurone1', parameters={'var1': 'val1'})
sl = SettingLoader()
resources = Resources(neuron_folder='/var/tmp/test/resources')
sl.settings.resources = resources
with mock.patch("kalliope.core.Utils.get_dynamic_class_instantiation"
) as mock_get_class_instantiation:
NeuronLauncher.start_neuron(neuron=neuron)
mock_get_class_instantiation.assert_called_once_with(
package_name="neurons",
module_name=neuron.name,
parameters=neuron.parameters,
resources_dir=sl.settings.resources.neuron_folder)
mock_get_class_instantiation.reset_mock()
def _process_neuron_list(self, matched_synapse):
"""
Process the neuron list of the matched_synapse
Execute the Neuron
Executing a Neuron creates a NeuronModule object. This one can have 3 status:
- waiting for an answer: The neuron wait for an answer from the caller. The api response object is returned.
The neuron is not removed from the matched synapse to be executed again
- want to execute a synapse: The neuron add a list of synapse to execute to the lifo.
The LIFO restart over to process it.The neuron is removed from the matched synapse
- complete: The neuron has been executed and its not waiting for an answer and doesn't want to start a synapse
The neuron is removed from the matched synapse
:param matched_synapse: MatchedSynapse object to process
"""
logger.debug("[LIFOBuffer] number of neuron to process: %s" % len(matched_synapse.neuron_fifo_list))
# while we have synapse to process in the list of synapse
while matched_synapse.neuron_fifo_list:
# get the first neuron in the FIFO neuron list
neuron = matched_synapse.neuron_fifo_list[0]
# from here, we are back into the last neuron we were processing.
if self.answer is not None: # we give the answer if exist to the first neuron
neuron.parameters["answer"] = self.answer
# the next neuron should not get this answer
self.answer = None
# todo fix this when we have a full client/server call. The client would be the voice or api call
neuron.parameters["is_api_call"] = self.is_api_call
logger.debug("[LIFOBuffer] process_neuron_list: is_api_call: %s" % (self.is_api_call))
# execute the neuron
instantiated_neuron = NeuronLauncher.start_neuron(neuron=neuron,
parameters_dict=matched_synapse.parameters)
# the status of an execution is "complete" if no neuron are waiting for an answer
self.api_response.status = "complete"
if instantiated_neuron is not None:
if instantiated_neuron.is_waiting_for_answer: # the neuron is waiting for an answer
logger.debug("[LIFOBuffer] Wait for answer mode")
self.api_response.status = "waiting_for_answer"
self.is_running = False
raise Serialize
else:
logger.debug("[LIFOBuffer] complete mode")
# we add the instantiated neuron to the neuron_module_list.
# This one contains info about generated text
matched_synapse.neuron_module_list.append(instantiated_neuron)
# the neuron is fully processed we can remove it from the list
matched_synapse.neuron_fifo_list.remove(neuron)
if self.reset_lifo: # the last executed neuron want to run a synapse
logger.debug("[LIFOBuffer] Last executed neuron want to run a synapse. Restart the LIFO")
# we have added a list of synapse to the LIFO ! this one must start over.
# break all while loop until the execution is back to the LIFO loop
self.reset_lifo = False
raise SynapseListAddedToLIFO
else:
# the neuron has not been processed but we still need to remove it from the list
matched_synapse.neuron_fifo_list.remove(neuron)
def run_ansible_playbook_module(install_file_path):
"""
Run the install.yml file through an Ansible playbook using the dedicated neuron !
:param install_file_path: the path of the Ansible playbook to run.
:return:
"""
logger.debug("[ResourcesManager] Run ansible playbook")
Utils.print_info("Starting neuron installation")
# ask the sudo password
pswd = getpass.getpass('Sudo password:')
ansible_neuron_parameters = {
"task_file": install_file_path,
"sudo": True,
"sudo_user": "******",
"sudo_password": pswd
}
neuron = Neuron(name="ansible_playbook", parameters=ansible_neuron_parameters)
NeuronLauncher.start_neuron(neuron)
def _start_neuron(neuron, params):
"""
Associate params and Starts a neuron.
:param neuron: the neuron to start
:param params: the params to check and associate to the neuron args.
"""
problem_in_neuron_found = False
if isinstance(neuron.parameters, dict):
# print neuron.parameters
if "args" in neuron.parameters:
logger.debug("The neuron waits for parameter")
# check that the user added parameters to his order
if params is None:
# we don't raise an error and break the program but we don't run the neuron
problem_in_neuron_found = True
Utils.print_danger(
"Error: The neuron %s is waiting for argument. "
"Argument found in bracket in the given order" %
neuron.name)
else:
# we add wanted arguments the existing neuron parameter dict
for arg in neuron.parameters["args"]:
if arg in params:
logger.debug(
"Parameter %s added to the current parameter "
"of the neuron: %s" % (arg, neuron.name))
neuron.parameters[arg] = params[arg]
else:
# we don't raise an error and break the program but
# we don't run the neuron
problem_in_neuron_found = True
Utils.print_danger(
"Error: Argument \"%s\" not found in the"
" order" % arg)
# if no error detected, we run the neuron
if not problem_in_neuron_found:
NeuronLauncher.start_neuron(neuron)
else:
Utils.print_danger("A problem has been found in the Synapse.")
def test_start_neuron(self):
"""
Testing params association and starting a Neuron
"""
with mock.patch("kalliope.core.NeuronLauncher.launch_neuron"
) as mock_launch_neuron_method:
# Assert to the neuron is launched with not parameter from order
neuron1 = Neuron(name='neurone1', parameters={'var1': 'val1'})
NeuronLauncher.start_neuron(neuron=neuron1)
mock_launch_neuron_method.assert_called_with(neuron1)
mock_launch_neuron_method.reset_mock()
# Assert the params are well passed to the neuron
neuron2 = Neuron(name='neurone2',
parameters={
'var2': 'val2',
'var3': "{{ var3 }}"
})
params = {'var3': 'value3'}
NeuronLauncher.start_neuron(neuron=neuron2, parameters_dict=params)
neuron2_params = Neuron(name='neurone2',
parameters={
'var2': 'val2',
'var3': 'value3'
})
mock_launch_neuron_method.assert_called_with(neuron2_params)
mock_launch_neuron_method.reset_mock()
# Assert the Neuron is not started when missing args
neuron3 = Neuron(name='neurone3',
parameters={
'var3': 'val3',
'var4': '{{val4}}'
})
params = {'not_exist': 'test'}
NeuronLauncher.start_neuron(neuron=neuron3, parameters_dict=params)
mock_launch_neuron_method.assert_not_called()
mock_launch_neuron_method.reset_mock()
# Assert no neuron is launched when waiting for args and none are given
neuron4 = Neuron(name='neurone4',
parameters={
'var5': 'val5',
'var6': '{{val6}}'
})
NeuronLauncher.start_neuron(neuron=neuron4)
mock_launch_neuron_method.assert_not_called()
mock_launch_neuron_method.reset_mock()
def test_start_neuron(self):
"""
Testing params association and starting a Neuron
"""
with mock.patch("kalliope.core.NeuronLauncher.launch_neuron") as mock_launch_neuron_method:
# Assert to the neuron is launched with not parameter from order
neuron1 = Neuron(name='neurone1', parameters={'var1': 'val1'})
NeuronLauncher.start_neuron(neuron=neuron1)
mock_launch_neuron_method.assert_called_with(neuron1)
mock_launch_neuron_method.reset_mock()
# Assert the params are well passed to the neuron
neuron2 = Neuron(name='neurone2', parameters={'var2': 'val2', 'var3': "{{ var3 }}"})
params = {
'var3': 'value3'
}
NeuronLauncher.start_neuron(neuron=neuron2,
parameters_dict=params)
neuron2_params = Neuron(name='neurone2', parameters={'var2': 'val2', 'var3': 'value3'})
mock_launch_neuron_method.assert_called_with(neuron2_params)
mock_launch_neuron_method.reset_mock()
# Assert the Neuron is not started when missing args
neuron3 = Neuron(name='neurone3', parameters={'var3': 'val3', 'var4': '{{val4}}'})
params = {
'not_exist': 'test'
}
NeuronLauncher.start_neuron(neuron=neuron3,
parameters_dict=params)
mock_launch_neuron_method.assert_not_called()
mock_launch_neuron_method.reset_mock()
# Assert no neuron is launched when waiting for args and none are given
neuron4 = Neuron(name='neurone4', parameters={'var5': 'val5', 'var6': '{{val6}}'})
NeuronLauncher.start_neuron(neuron=neuron4)
mock_launch_neuron_method.assert_not_called()
mock_launch_neuron_method.reset_mock()
def _process_neuron_list(self, matched_synapse):
"""
Process the neuron list of the matched_synapse
Execute the Neuron
Executing a Neuron creates a NeuronModule object. This one can have 3 status:
- waiting for an answer: The neuron wait for an answer from the caller. The api response object is returned.
The neuron is not removed from the matched synapse to be executed again
- want to execute a synapse: The neuron add a list of synapse to execute to the lifo.
The LIFO restart over to process it.The neuron is removed from the matched synapse
- complete: The neuron has been executed and its not waiting for an answer and doesn't want to start a synapse
The neuron is removed from the matched synapse
:param matched_synapse: MatchedSynapse object to process
"""
logger.debug("[LIFOBuffer] number of neuron to process: %s" %
len(matched_synapse.neuron_fifo_list))
# while we have synapse to process in the list of synapse
while matched_synapse.neuron_fifo_list:
# get the first neuron in the FIFO neuron list
neuron = matched_synapse.neuron_fifo_list[0]
# from here, we are back into the last neuron we were processing.
if self.answer is not None: # we give the answer if exist to the first neuron
neuron.parameters["answer"] = self.answer
# the next neuron should not get this answer
self.answer = None
# todo fix this when we have a full client/server call. The client would be the voice or api call
neuron.parameters["is_api_call"] = self.is_api_call
logger.debug("[LIFOBuffer] process_neuron_list: is_api_call: %s" %
self.is_api_call)
# execute the neuron
instantiated_neuron = NeuronLauncher.start_neuron(
neuron=neuron, parameters_dict=matched_synapse.parameters)
# the status of an execution is "complete" if no neuron are waiting for an answer
self.api_response.status = "complete"
if instantiated_neuron is not None:
if instantiated_neuron.is_waiting_for_answer: # the neuron is waiting for an answer
logger.debug("[LIFOBuffer] Wait for answer mode")
self.api_response.status = "waiting_for_answer"
self.is_running = False
raise Serialize
else:
logger.debug("[LIFOBuffer] complete mode")
# we add the instantiated neuron to the neuron_module_list.
# This one contains info about generated text
matched_synapse.neuron_module_list.append(
instantiated_neuron)
# the neuron is fully processed we can remove it from the list
matched_synapse.neuron_fifo_list.remove(neuron)
if self.reset_lifo: # the last executed neuron want to run a synapse
logger.debug(
"[LIFOBuffer] Last executed neuron want to run a synapse. Restart the LIFO"
)
# we have added a list of synapse to the LIFO ! this one must start over.
# break all while loop until the execution is back to the LIFO loop
self.reset_lifo = False
raise SynapseListAddedToLIFO
else:
# the neuron has not been processed but we still need to remove it from the list
matched_synapse.neuron_fifo_list.remove(neuron)
def test_replace_brackets_by_loaded_parameter(self):
# -------------------
# test with string
# -------------------
# the target value to replace is present in the loaded parameter dict
neuron_parameters = {"param1": "this is a value {{ replaced }}"}
loaded_parameters = {"replaced": "replaced successfully"}
expected_result = {"param1": "this is a value replaced successfully"}
self.assertEqual(
expected_result,
NeuronLauncher._replace_brackets_by_loaded_parameter(
neuron_parameters, loaded_parameters))
# the target value with unicode to replace is present in the loaded parameter dict
neuron_parameters = {"param1": "this is a value {{ replaced }}"}
loaded_parameters = {"replaced": u"rêmpläcée successfülly"}
expected_result = {"param1": "this is a value rêmpläcée successfülly"}
self.assertEqual(
expected_result,
NeuronLauncher._replace_brackets_by_loaded_parameter(
neuron_parameters, loaded_parameters))
# the target value to replace is NOT present in the loaded parameter dict
neuron_parameters = {"param1": "this is a value {{ replaced }}"}
loaded_parameters = {"not_exist": "replaced successfully"}
with self.assertRaises(NeuronParameterNotAvailable):
NeuronLauncher._replace_brackets_by_loaded_parameter(
neuron_parameters, loaded_parameters)
# one parameter doesn't contains bracket, the other one do
neuron_parameters = {
"param1": "this is a value {{ replaced }}",
"param2": "value"
}
loaded_parameters = {"replaced": "replaced successfully"}
expected_result = {
"param1": "this is a value replaced successfully",
"param2": "value"
}
self.assertEqual(
expected_result,
NeuronLauncher._replace_brackets_by_loaded_parameter(
neuron_parameters, loaded_parameters))
# parameters are integer or boolean
neuron_parameters = {"param1": 1, "param2": True}
loaded_parameters = {"replaced": "replaced successfully"}
expected_result = {"param1": 1, "param2": True}
self.assertEqual(
expected_result,
NeuronLauncher._replace_brackets_by_loaded_parameter(
neuron_parameters, loaded_parameters))
# parameters are say_template or file template. Should not be altered by the loader
neuron_parameters = {
"say_template": "{{output}}",
"file_template": "here is a file"
}
loaded_parameters = {"output": "should not be used"}
expected_result = {
"say_template": "{{output}}",
"file_template": "here is a file"
}
self.assertEqual(
expected_result,
NeuronLauncher._replace_brackets_by_loaded_parameter(
neuron_parameters, loaded_parameters))
# replacing with variable
sl = SettingLoader()
sl.settings.variables = {
"replaced": {
"name": u'replaced successfully'
}
}
neuron_parameters = {
"param1": "this is a value {{ replaced['name'] }}"
}
loaded_parameters = {"name": "replaced successfully"}
expected_result = {"param1": "this is a value replaced successfully"}
self.assertEqual(
expected_result,
NeuronLauncher._replace_brackets_by_loaded_parameter(
neuron_parameters, loaded_parameters))
# the parameter is a reserved key. for example from_answer_link from the neurotransmitter
list_reserved_keys = [
"say_template", "file_template", "kalliope_memory",
"from_answer_link"
]
for reserved_key in list_reserved_keys:
neuron_parameters = {
reserved_key: "this is a value with {{ 'brackets '}}"
}
loaded_parameters = dict()
expected_result = {
reserved_key: "this is a value with {{ 'brackets '}}"
}
self.assertEqual(
expected_result,
NeuronLauncher._replace_brackets_by_loaded_parameter(
neuron_parameters, loaded_parameters))
def test_replace_brackets_by_loaded_parameter(self):
# -------------------
# test with string
# -------------------
# the target value to replace is present in the loaded parameter dict
neuron_parameters = {
"param1": "this is a value {{ replaced }}"
}
loaded_parameters = {
"replaced": "replaced successfully"
}
expected_result = {
"param1": "this is a value replaced successfully"
}
self.assertEqual(expected_result, NeuronLauncher._replace_brackets_by_loaded_parameter(neuron_parameters,
loaded_parameters))
# the target value with unicode to replace is present in the loaded parameter dict
neuron_parameters = {
"param1": "this is a value {{ replaced }}"
}
loaded_parameters = {
"replaced": u"rêmpläcée successfülly"
}
expected_result = {
"param1": "this is a value rêmpläcée successfülly"
}
self.assertEqual(expected_result, NeuronLauncher._replace_brackets_by_loaded_parameter(neuron_parameters,
loaded_parameters))
# the target value to replace is NOT present in the loaded parameter dict
neuron_parameters = {
"param1": "this is a value {{ replaced }}"
}
loaded_parameters = {
"not_exist": "replaced successfully"
}
with self.assertRaises(NeuronParameterNotAvailable):
NeuronLauncher._replace_brackets_by_loaded_parameter(neuron_parameters, loaded_parameters)
# one parameter doesn't contains bracket, the other one do
neuron_parameters = {
"param1": "this is a value {{ replaced }}",
"param2": "value"
}
loaded_parameters = {
"replaced": "replaced successfully"
}
expected_result = {
"param1": "this is a value replaced successfully",
"param2": "value"
}
self.assertEqual(expected_result, NeuronLauncher._replace_brackets_by_loaded_parameter(neuron_parameters,
loaded_parameters))
# parameters are integer or boolean
neuron_parameters = {
"param1": 1,
"param2": True
}
loaded_parameters = {
"replaced": "replaced successfully"
}
expected_result = {
"param1": 1,
"param2": True
}
self.assertEqual(expected_result, NeuronLauncher._replace_brackets_by_loaded_parameter(neuron_parameters,
loaded_parameters))
# parameters are say_template or file template. Should not be altered by the loader
neuron_parameters = {
"say_template": "{{output}}",
"file_template": "here is a file"
}
loaded_parameters = {
"output": "should not be used"
}
expected_result = {
"say_template": "{{output}}",
"file_template": "here is a file"
}
self.assertEqual(expected_result, NeuronLauncher._replace_brackets_by_loaded_parameter(neuron_parameters,
loaded_parameters))
# replacing with variable
sl = SettingLoader()
sl.settings.variables = {
"replaced": {
"name": u'replaced successfully'
}
}
neuron_parameters = {
"param1": "this is a value {{ replaced['name'] }}"
}
loaded_parameters = {
"name": "replaced successfully"
}
expected_result = {
"param1": "this is a value replaced successfully"
}
self.assertEqual(expected_result, NeuronLauncher._replace_brackets_by_loaded_parameter(neuron_parameters,
loaded_parameters))
# the parameter is a reserved key. for example from_answer_link from the neurotransmitter
list_reserved_keys = ["say_template", "file_template", "kalliope_memory", "from_answer_link"]
for reserved_key in list_reserved_keys:
neuron_parameters = {
reserved_key: "this is a value with {{ 'brackets '}}"
}
loaded_parameters = dict()
expected_result = {
reserved_key: "this is a value with {{ 'brackets '}}"
}
self.assertEqual(expected_result, NeuronLauncher._replace_brackets_by_loaded_parameter(neuron_parameters,
loaded_parameters))
####
# tests with global variables
####
# 1/ only one global variable
sl = SettingLoader()
sl.settings.variables = {
"hello": "test",
"hello2": "test2",
}
parameters = {
'var1': '{{hello}}'
}
expected_parameters = {
'var1': 'test'
}
self.assertEqual(expected_parameters, NeuronLauncher._replace_brackets_by_loaded_parameter(parameters,
loaded_parameters))
# 2/ global variable with string after
sl.settings.variables = {
"hello": "test",
"hello2": "test2",
}
parameters = {
'var1': '{{hello}} Sispheor'
}
expected_parameters = {
'var1': 'test Sispheor'
}
self.assertEqual(expected_parameters, NeuronLauncher._replace_brackets_by_loaded_parameter(parameters,
loaded_parameters))
# 3/ global variable with int after
parameters = {
'var1': '{{hello}}0'
}
sl.settings.variables = {
"hello": 60,
"hello2": "test2",
}
expected_parameters = {
'var1': '600'
}
self.assertEqual(expected_parameters, NeuronLauncher._replace_brackets_by_loaded_parameter(parameters,
loaded_parameters))
# 4/ multiple global variables
parameters = {
'var1': '{{hello}} {{me}}'
}
sl.settings.variables = {
"hello": "hello",
"me": "LaMonf"
}
expected_parameters = {
'var1': 'hello LaMonf'
}
self.assertEqual(expected_parameters, NeuronLauncher._replace_brackets_by_loaded_parameter(parameters,
loaded_parameters))
# 5/ parameter value is a list
parameters = {
'var1': '[hello {{name}}, bonjour {{name}}]'
}
sl.settings.variables = {
"name": "LaMonf",
"hello2": "test2",
}
expected_parameters = {
'var1': '[hello LaMonf, bonjour LaMonf]'
}
self.assertEqual(expected_parameters, NeuronLauncher._replace_brackets_by_loaded_parameter(parameters,
loaded_parameters))
# 6/ parameter is a dict
parameters = {'random_dict': [{'synapse': 'synapse2', 'answers': ['absolument', '{{ name }}']},
{'synapse': 'synapse3', 'answers': ['{{ name }}']}], 'default': 'synapse4'}
sl.settings.variables = {
"name": "nico"
}
expected_parameters = {
'random_dict': [
{'synapse': 'synapse2', 'answers': ['absolument', 'nico']},
{'synapse': 'synapse3', 'answers': ['nico']}], 'default': 'synapse4'
}
self.assertEqual(expected_parameters, NeuronLauncher._replace_brackets_by_loaded_parameter(parameters,
loaded_parameters))
# 7/ parameter is a dict with a restricted word
parameters = {'from_answer_link': [{'synapse': 'synapse2', 'answers': ['absolument', '{{ name }}']},
{'synapse': 'synapse3', 'answers': ['{{ name }}']}], 'default': 'synapse4'}
sl.settings.variables = {
"name": "nico"
}
expected_parameters = {
'from_answer_link': [
{'synapse': 'synapse2', 'answers': ['absolument', '{{ name }}']},
{'synapse': 'synapse3', 'answers': ['{{ name }}']}], 'default': 'synapse4'
}
self.assertEqual(expected_parameters, NeuronLauncher._replace_brackets_by_loaded_parameter(parameters,
loaded_parameters))
def test_replace_brackets_by_loaded_parameter(self):
# -------------------
# test with string
# -------------------
# the target value to replace is present in the loaded parameter dict
neuron_parameters = {"param1": "this is a value {{ replaced }}"}
loaded_parameters = {"replaced": "replaced successfully"}
expected_result = {"param1": "this is a value replaced successfully"}
self.assertEqual(
expected_result,
NeuronLauncher._replace_brackets_by_loaded_parameter(
neuron_parameters, loaded_parameters))
# the target value with unicode to replace is present in the loaded parameter dict
neuron_parameters = {"param1": "this is a value {{ replaced }}"}
loaded_parameters = {"replaced": u"rêmpläcée successfülly"}
expected_result = {"param1": "this is a value rêmpläcée successfülly"}
self.assertEqual(
expected_result,
NeuronLauncher._replace_brackets_by_loaded_parameter(
neuron_parameters, loaded_parameters))
# the target value to replace is NOT present in the loaded parameter dict
neuron_parameters = {"param1": "this is a value {{ replaced }}"}
loaded_parameters = {"not_exist": "replaced successfully"}
with self.assertRaises(NeuronParameterNotAvailable):
NeuronLauncher._replace_brackets_by_loaded_parameter(
neuron_parameters, loaded_parameters)
# one parameter doesn't contains bracket, the other one do
neuron_parameters = {
"param1": "this is a value {{ replaced }}",
"param2": "value"
}
loaded_parameters = {"replaced": "replaced successfully"}
expected_result = {
"param1": "this is a value replaced successfully",
"param2": "value"
}
self.assertEqual(
expected_result,
NeuronLauncher._replace_brackets_by_loaded_parameter(
neuron_parameters, loaded_parameters))
# parameters are integer or boolean
neuron_parameters = {"param1": 1, "param2": True}
loaded_parameters = {"replaced": "replaced successfully"}
expected_result = {"param1": 1, "param2": True}
self.assertEqual(
expected_result,
NeuronLauncher._replace_brackets_by_loaded_parameter(
neuron_parameters, loaded_parameters))
# parameters are say_template or file template. Should not be altered by the loader
neuron_parameters = {
"say_template": "{{output}}",
"file_template": "here is a file"
}
loaded_parameters = {"output": "should not be used"}
expected_result = {
"say_template": "{{output}}",
"file_template": "here is a file"
}
self.assertEqual(
expected_result,
NeuronLauncher._replace_brackets_by_loaded_parameter(
neuron_parameters, loaded_parameters))
# replacing with variable
sl = SettingLoader()
sl.settings.variables = {
"replaced": {
"name": u'replaced successfully'
}
}
neuron_parameters = {
"param1": "this is a value {{ replaced['name'] }}"
}
loaded_parameters = {"name": "replaced successfully"}
expected_result = {"param1": "this is a value replaced successfully"}
self.assertEqual(
expected_result,
NeuronLauncher._replace_brackets_by_loaded_parameter(
neuron_parameters, loaded_parameters))
# the parameter is a reserved key. for example from_answer_link from the neurotransmitter
list_reserved_keys = [
"say_template", "file_template", "kalliope_memory",
"from_answer_link"
]
for reserved_key in list_reserved_keys:
neuron_parameters = {
reserved_key: "this is a value with {{ 'brackets '}}"
}
loaded_parameters = dict()
expected_result = {
reserved_key: "this is a value with {{ 'brackets '}}"
}
self.assertEqual(
expected_result,
NeuronLauncher._replace_brackets_by_loaded_parameter(
neuron_parameters, loaded_parameters))
####
# tests with global variables
####
# 1/ only one global variable
sl = SettingLoader()
sl.settings.variables = {
"hello": "test",
"hello2": "test2",
}
parameters = {'var1': '{{hello}}'}
expected_parameters = {'var1': 'test'}
self.assertEqual(
expected_parameters,
NeuronLauncher._replace_brackets_by_loaded_parameter(
parameters, loaded_parameters))
# 2/ global variable with string after
sl.settings.variables = {
"hello": "test",
"hello2": "test2",
}
parameters = {'var1': '{{hello}} Sispheor'}
expected_parameters = {'var1': 'test Sispheor'}
self.assertEqual(
expected_parameters,
NeuronLauncher._replace_brackets_by_loaded_parameter(
parameters, loaded_parameters))
# 3/ global variable with int after
parameters = {'var1': '{{hello}}0'}
sl.settings.variables = {
"hello": 60,
"hello2": "test2",
}
expected_parameters = {'var1': '600'}
self.assertEqual(
expected_parameters,
NeuronLauncher._replace_brackets_by_loaded_parameter(
parameters, loaded_parameters))
# 4/ multiple global variables
parameters = {'var1': '{{hello}} {{me}}'}
sl.settings.variables = {"hello": "hello", "me": "LaMonf"}
expected_parameters = {'var1': 'hello LaMonf'}
self.assertEqual(
expected_parameters,
NeuronLauncher._replace_brackets_by_loaded_parameter(
parameters, loaded_parameters))
# 5/ parameter value is a list
parameters = {'var1': '[hello {{name}}, bonjour {{name}}]'}
sl.settings.variables = {
"name": "LaMonf",
"hello2": "test2",
}
expected_parameters = {'var1': '[hello LaMonf, bonjour LaMonf]'}
self.assertEqual(
expected_parameters,
NeuronLauncher._replace_brackets_by_loaded_parameter(
parameters, loaded_parameters))
# 6/ parameter is a dict
parameters = {
'random_dict': [{
'synapse': 'synapse2',
'answers': ['absolument', '{{ name }}']
}, {
'synapse': 'synapse3',
'answers': ['{{ name }}']
}],
'default':
'synapse4'
}
sl.settings.variables = {"name": "nico"}
expected_parameters = {
'random_dict': [{
'synapse': 'synapse2',
'answers': ['absolument', 'nico']
}, {
'synapse': 'synapse3',
'answers': ['nico']
}],
'default':
'synapse4'
}
self.assertEqual(
expected_parameters,
NeuronLauncher._replace_brackets_by_loaded_parameter(
parameters, loaded_parameters))
# 7/ parameter is a dict with a restricted word
parameters = {
'from_answer_link': [{
'synapse': 'synapse2',
'answers': ['absolument', '{{ name }}']
}, {
'synapse': 'synapse3',
'answers': ['{{ name }}']
}],
'default':
'synapse4'
}
sl.settings.variables = {"name": "nico"}
expected_parameters = {
'from_answer_link': [{
'synapse': 'synapse2',
'answers': ['absolument', '{{ name }}']
}, {
'synapse': 'synapse3',
'answers': ['{{ name }}']
}],
'default':
'synapse4'
}
self.assertEqual(
expected_parameters,
NeuronLauncher._replace_brackets_by_loaded_parameter(
parameters, loaded_parameters))
def test_replace_brackets_by_loaded_parameter(self):
# -------------------
# test with string
# -------------------
# the target value to replace is present in the loaded parameter dict
neuron_parameters = {"param1": "this is a value {{ replaced }}"}
loaded_parameters = {"replaced": "replaced successfully"}
expected_result = {"param1": "this is a value replaced successfully"}
self.assertEqual(
expected_result,
NeuronLauncher._replace_brackets_by_loaded_parameter(
neuron_parameters, loaded_parameters))
# the target value with unicode to replace is present in the loaded parameter dict
neuron_parameters = {"param1": "this is a value {{ replaced }}"}
loaded_parameters = {"replaced": u"rêmpläcée successfülly"}
expected_result = {"param1": "this is a value rêmpläcée successfülly"}
self.assertEqual(
expected_result,
NeuronLauncher._replace_brackets_by_loaded_parameter(
neuron_parameters, loaded_parameters))
# the target value to replace is NOT present in the loaded parameter dict
neuron_parameters = {"param1": "this is a value {{ replaced }}"}
loaded_parameters = {"not_exist": "replaced successfully"}
with self.assertRaises(NeuronParameterNotAvailable):
NeuronLauncher._replace_brackets_by_loaded_parameter(
neuron_parameters, loaded_parameters)
# one parameter doesn't contains bracket, the other one do
neuron_parameters = {
"param1": "this is a value {{ replaced }}",
"param2": "value"
}
loaded_parameters = {"replaced": "replaced successfully"}
expected_result = {
"param1": "this is a value replaced successfully",
"param2": "value"
}
self.assertEqual(
expected_result,
NeuronLauncher._replace_brackets_by_loaded_parameter(
neuron_parameters, loaded_parameters))
# parameters are integer or boolean
neuron_parameters = {"param1": 1, "param2": True}
loaded_parameters = {"replaced": "replaced successfully"}
expected_result = {"param1": 1, "param2": True}
self.assertEqual(
expected_result,
NeuronLauncher._replace_brackets_by_loaded_parameter(
neuron_parameters, loaded_parameters))
# parameters are say_template or file template. Should not be altered by the loader
neuron_parameters = {
"say_template": "{{output}}",
"file_template": "here is a file"
}
loaded_parameters = {"output": "should not be used"}
expected_result = {
"say_template": "{{output}}",
"file_template": "here is a file"
}
self.assertEqual(
expected_result,
NeuronLauncher._replace_brackets_by_loaded_parameter(
neuron_parameters, loaded_parameters))