def test_save_parameter_from_order_in_memory(self):
# Test with a value that exist in the temp memory
order_parameters = {
"key1": "value1",
"key2": "value2"
}
Cortex.temp = order_parameters
dict_val_to_save = {"my_key_in_memory": "{{key1}}"}
expected_dict = {"my_key_in_memory": "value1"}
Cortex.save_parameter_from_order_in_memory(dict_val_to_save)
self.assertDictEqual(expected_dict, Cortex.memory)
# test with a value that does not exsit
order_parameters = {
"key1": "value1",
"key2": "value2"
}
Cortex.temp = order_parameters
dict_val_to_save = {"my_key_in_memory": "{{key3}}"}
self.assertFalse(Cortex.save_parameter_from_order_in_memory(dict_val_to_save))
def test_clean_parameter_from_order(self):
Cortex.temp = {
"key1": "value1",
"key2": "value2"
}
Cortex.clean_parameter_from_order()
expected_temp_dict = dict()
self.assertDictEqual(expected_temp_dict, Cortex.memory)
def say(self, message):
"""
USe TTS to speak out loud the Message.
A message can be a string, a list or a dict
If it's a string, simply use the TTS with the message
If it's a list, we select randomly a string in the list and give it to the TTS
If it's a dict, we use the template given in parameter to create a string that we give to the TTS
:param message: Can be a String or a dict or a list
.. raises:: TTSModuleNotFound
"""
logger.debug("[NeuronModule] Say() called with message: %s" % message)
tts_message = None
# we can save parameters from the neuron in memory
Cortex.save_neuron_parameter_in_memory(self.intelora_memory, message)
if isinstance(message, str) or isinstance(message, six.text_type):
logger.debug("[NeuronModule] message is string")
tts_message = message
if isinstance(message, list):
logger.debug("[NeuronModule] message is list")
tts_message = random.choice(message)
if isinstance(message, dict):
logger.debug("[NeuronModule] message is dict")
tts_message = self._get_message_from_dict(message)
if tts_message is not None:
logger.debug("[NeuronModule] tts_message to say: %s" % tts_message)
self.tts_message = tts_message
Utils.print_success(tts_message)
# process the audio only if the no_voice flag is false
if self.no_voice:
logger.debug(
"[NeuronModule] no_voice is True, Intelora is muted")
else:
logger.debug(
"[NeuronModule] no_voice is False, make Intelora speaking")
HookManager.on_start_speaking()
# get the instance of the TTS module
tts_folder = None
if self.settings.resources:
tts_folder = self.settings.resources.tts_folder
tts_module_instance = Utils.get_dynamic_class_instantiation(
package_name="tts",
module_name=self.tts.name,
parameters=self.tts.parameters,
resources_dir=tts_folder)
# generate the audio file and play it
tts_module_instance.say(tts_message)
HookManager.on_stop_speaking()
def test_save(self):
key_to_save = "key1"
value_to_save = "value1"
expected_memory = {
"key1": "value1"
}
Cortex.save(key=key_to_save, value=value_to_save)
self.assertDictEqual(expected_memory, Cortex.memory)
def get_parameters(cls, synapse_order, user_order):
"""
Class method to get all params coming from a string order. Returns a dict of key/value.
"""
params = dict()
if Utils.is_containing_bracket(synapse_order):
params = cls._associate_order_params_to_values(user_order, synapse_order)
logger.debug("[NeuronParameterLoader.get_parameters]Parameters for order: %s" % params)
# we place the dict of parameters load from order into a cache in Cortex so the user can save it later
Cortex.add_parameters_from_order(params)
return params
def __init__(self, **kwargs):
"""
Class used by neuron for talking
:param kwargs: Same parameter as the Child. Can contain info about the tts to use instead of the
default one
"""
# get the child who called the class
child_name = self.__class__.__name__
self.neuron_name = child_name
sl = SettingLoader()
self.settings = sl.settings
brain_loader = BrainLoader()
self.brain = brain_loader.brain
# a dict of overridden TTS parameters if provided by the user
self.override_tts_parameters = kwargs.get('tts', None)
# create the TTS instance
self.tts = None
if self.override_tts_parameters is None or not isinstance(
self.override_tts_parameters, dict):
# we get the default TTS
self.tts = self._get_tts_object(settings=self.settings)
else:
for key, value in self.override_tts_parameters.items():
tts_name = key
tts_parameters = value
self.tts = self._get_tts_object(
tts_name=tts_name,
override_parameter=tts_parameters,
settings=self.settings)
# get templates if provided
# Check if there is a template associate to the output message
self.say_template = kwargs.get('say_template', None)
# check if there is a template file associate to the output message
self.file_template = kwargs.get('file_template', None)
# keep the generated message
self.tts_message = None
# if the current call is api one
self.is_api_call = kwargs.get('is_api_call', False)
# if the current call want to mute intelora
self.no_voice = kwargs.get('no_voice', False)
# boolean to know id the synapse is waiting for an answer
self.is_waiting_for_answer = False
# the synapse name to add the the buffer
self.pending_synapse = None
# a dict of parameters the user ask to save in short term memory
self.intelora_memory = kwargs.get('intelora_memory', None)
# parameters loaded from the order can be save now
Cortex.save_parameter_from_order_in_memory(self.intelora_memory)
def test_add_parameters_from_order(self):
order_parameters = {
"key1": "value1",
"key2": "value2"
}
expected_temp_dict = {
"key1": "value1",
"key2": "value2"
}
Cortex.add_parameters_from_order(order_parameters)
self.assertDictEqual(Cortex.temp, expected_temp_dict)
def _replace_brackets_by_loaded_parameter(cls, neuron_parameters,
loaded_parameters):
"""
Receive a value (which can be a str or dict or list) and instantiate value in double brace bracket
by the value specified in the loaded_parameters dict.
This method will call itself until all values has been instantiated
:param neuron_parameters: value to instantiate. Str or dict or list
:param loaded_parameters: dict of parameters
"""
logger.debug("[NeuronLauncher] replacing brackets from %s, using %s" %
(neuron_parameters, loaded_parameters))
# add variables from the short term memory to the list of loaded parameters that can be used in a template
# the final dict is added into a key "intelora_memory" to not override existing keys loaded form the order
memory_dict = dict()
memory_dict["intelora_memory"] = Cortex.get_memory()
if loaded_parameters is None:
loaded_parameters = dict(
) # instantiate an empty dict in order to be able to add memory in it
loaded_parameters.update(memory_dict)
if isinstance(neuron_parameters, str) or isinstance(
neuron_parameters, six.text_type):
# replace bracket parameter only if the str contains brackets
if Utils.is_containing_bracket(neuron_parameters):
# check that the parameter to replace is available in the loaded_parameters dict
if cls._neuron_parameters_are_available_in_loaded_parameters(
neuron_parameters, loaded_parameters):
# add parameters from global variable into the final loaded parameter dict
settings = cls.load_settings()
loaded_parameters.update(settings.variables)
neuron_parameters = jinja2.Template(
neuron_parameters).render(loaded_parameters)
neuron_parameters = Utils.encode_text_utf8(
neuron_parameters)
return str(neuron_parameters)
else:
raise NeuronParameterNotAvailable
return neuron_parameters
if isinstance(neuron_parameters, dict):
returned_dict = dict()
for key, value in neuron_parameters.items():
# following keys are reserved by intelora core
if key in "say_template" or key in "file_template" or key in "intelora_memory" \
or key in "from_answer_link":
returned_dict[key] = value
else:
returned_dict[
key] = cls._replace_brackets_by_loaded_parameter(
value, loaded_parameters)
return returned_dict
if isinstance(neuron_parameters, list):
returned_list = list()
for el in neuron_parameters:
templated_value = cls._replace_brackets_by_loaded_parameter(
el, loaded_parameters)
returned_list.append(templated_value)
return returned_list
# in all other case (boolean or int for example) we return the value as it
return neuron_parameters
def test_get_memory(self):
test_memory = {
"key1": "value1",
"key2": "value2"
}
Cortex.memory = test_memory
self.assertDictEqual(test_memory, Cortex.get_memory())
def test_get_from_key(self):
test_memory = {
"key1": "value1",
"key2": "value2"
}
Cortex.memory = test_memory
expected_value = "value2"
self.assertEqual(expected_value, Cortex.get_from_key("key2"))
def execute(self, answer=None, is_api_call=False, no_voice=False):
"""
Process the LIFO list.
The LIFO list contains multiple list of matched synapses.
For each list of matched synapse we process synapses inside
For each synapses we process neurons.
If a neuron add a Synapse list to the lifo, this synapse list is processed before executing the first list
in which we were in.
:param answer: String answer to give the the last neuron which was waiting for an answer
:param is_api_call: Boolean passed to all neuron in order to let them know if the current call comes from API
:param no_voice: If true, the generated text will not be processed by the TTS engine
:return: serialized APIResponse object
"""
# store the answer if present
self.answer = answer
self.is_api_call = is_api_call
self.no_voice = no_voice
if not self.is_running:
self.is_running = True
try:
# we keep looping over the LIFO til we have synapse list to process in it
while self.lifo_list:
logger.debug(
"[LIFOBuffer] number of synapse list to process: %s" %
len(self.lifo_list))
try:
# get the last list of matched synapse in the LIFO
last_synapse_fifo_list = self.lifo_list[-1]
self._process_synapse_list(last_synapse_fifo_list)
except SynapseListAddedToLIFO:
continue
# remove the synapse list from the LIFO
self.lifo_list.remove(last_synapse_fifo_list)
# clean the cortex from value loaded from order as all synapses have been processed
Cortex.clean_parameter_from_order()
self.is_running = False
raise Serialize
except Serialize:
return self._return_serialized_api_response()
def test_save_neuron_parameter_in_memory(self):
# test with a list of parameter with bracket
neuron1_parameters = {
"key1": "value1",
"key2": "value2"
}
dict_val_to_save = {"my_key_in_memory": "{{key1}}"}
expected_dict = {"my_key_in_memory": "value1"}
Cortex.save_neuron_parameter_in_memory(intelora_memory_dict=dict_val_to_save,
neuron_parameters=neuron1_parameters)
self.assertDictEqual(expected_dict, Cortex.memory)
# test with a list of parameter with brackets and string
self.setUp() # clean
neuron1_parameters = {
"key1": "value1",
"key2": "value2"
}
dict_val_to_save = {"my_key_in_memory": "string {{key1}}"}
expected_dict = {"my_key_in_memory": "string value1"}
Cortex.save_neuron_parameter_in_memory(intelora_memory_dict=dict_val_to_save,
neuron_parameters=neuron1_parameters)
self.assertDictEqual(expected_dict, Cortex.memory)
# test with a list of parameter with only a string. Neuron parameters are not used
self.setUp() # clean
neuron1_parameters = {
"key1": "value1",
"key2": "value2"
}
dict_val_to_save = {"my_key_in_memory": "string"}
expected_dict = {"my_key_in_memory": "string"}
Cortex.save_neuron_parameter_in_memory(intelora_memory_dict=dict_val_to_save,
neuron_parameters=neuron1_parameters)
self.assertDictEqual(expected_dict, Cortex.memory)
# test with an empty list of parameter to save (no intelora_memory set)
self.setUp() # clean
neuron1_parameters = {
"key1": "value1",
"key2": "value2"
}
dict_val_to_save = None
Cortex.save_neuron_parameter_in_memory(intelora_memory_dict=dict_val_to_save,
neuron_parameters=neuron1_parameters)
self.assertDictEqual(dict(), Cortex.memory)