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)