Exemplo n.º 1
0
    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 "kalliope_memory" to not override existing keys loaded form the order
        memory_dict = dict()
        memory_dict["kalliope_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 kalliope core
                if key in "say_template" or key in "file_template" or key in "kalliope_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
Exemplo n.º 2
0
    def _find_synapse_to_run(cls, brain, settings, order):
        """
        Find the list of the synapse matching the order.

        Note: we use named tuples:
        tuple_synapse_order = collections.namedtuple('tuple_synapse_matchingOrder',['synapse', 'order'])

        :param brain: the brain
        :param settings: the settings
        :param order: the provided order to match
        :return: the list of synapses launched (named tuples)
        """

        synapse_to_run = cls._get_matching_synapse_list(brain.synapses, order)
        if not synapse_to_run:
            Utils.print_info("No synapse match the captured order: %s" % order)

            if settings.default_synapse is not None:
                default_synapse = cls._get_default_synapse_from_sysnapses_list(
                    brain.synapses, settings.default_synapse)

                if default_synapse is not None:
                    logger.debug("Default synapse found %s" % default_synapse)
                    Utils.print_info("Default synapse found: %s, running it" %
                                     default_synapse.name)
                    tuple_synapse_order = collections.namedtuple(
                        'tuple_synapse_matchingOrder', ['synapse', 'order'])
                    synapse_to_run.append(
                        tuple_synapse_order(synapse=default_synapse, order=""))

        return synapse_to_run
Exemplo n.º 3
0
    def _get_matching_synapse_list(cls, all_synapses_list, order_to_match):
        """
        Class method to return all the matching synapses with the order from the complete of synapses.

        Note: we use named tuples:
        tuple_synapse_matchingOrder = collections.namedtuple('tuple_synapse_matchingOrder',['synapse', 'order'])

        :param all_synapses_list: the complete list of all synapses
        :param order_to_match: the order to match
        :type order_to_match: str
        :return: the list of matching synapses (named tuples)
        """
        tuple_synapse_order = collections.namedtuple(
            'tuple_synapse_matchingOrder', ['synapse', 'order'])
        matching_synapses_list = list()
        for synapse in all_synapses_list:
            for signal in synapse.signals:
                if type(signal) == Order:
                    if cls.spelt_order_match_brain_order_via_table(
                            signal.sentence, order_to_match):
                        matching_synapses_list.append(
                            tuple_synapse_order(synapse=synapse,
                                                order=signal.sentence))
                        logger.debug("Order found! Run neurons: %s" %
                                     synapse.neurons)
                        Utils.print_success(
                            "Order matched in the brain. Running synapse \"%s\""
                            % synapse.name)
        return matching_synapses_list
Exemplo n.º 4
0
    def test_remove_spaces_in_brackets(self):
        """
        Test the Utils remove_spaces_in_brackets
        """

        sentence = "This is the {{ bracket   }}"
        expected_result = "This is the {{bracket}}"
        self.assertEqual(Utils.remove_spaces_in_brackets(sentence=sentence),
                         expected_result,
                         "Fail to remove spaces in one bracket")

        sentence = "This is the {{ bracket   }} {{  second     }}"
        expected_result = "This is the {{bracket}} {{second}}"
        self.assertEqual(Utils.remove_spaces_in_brackets(sentence=sentence),
                         expected_result,
                         "Fail to remove spaces in two brackets")

        # test with json
        sentence = "{\"params\": {\"apikey\": \"ISNOTMYPASSWORD\", " \
                   "\"query\": \"met le chauffage a {{ valeur }} degres\"}}"
        expected_result = "{\"params\": {\"apikey\": \"ISNOTMYPASSWORD\", " \
                          "\"query\": \"met le chauffage a {{valeur}} degres\"}}"
        self.assertEqual(Utils.remove_spaces_in_brackets(sentence=sentence),
                         expected_result,
                         "Fail to remove spaces in two brackets")
Exemplo n.º 5
0
 def start_neuron(cls, neuron, parameters_dict=None):
     """
     Execute each neuron from the received neuron_list.
     Replace parameter if exist in the received dict of parameters_dict
     :param neuron: Neuron object to run
     :param parameters_dict: dict of parameter to load in each neuron if expecting a parameter
     :return: List of the instantiated neurons (no errors detected)
     """
     if neuron.parameters is not None:
         try:
             neuron.parameters = cls._replace_brackets_by_loaded_parameter(
                 neuron.parameters, parameters_dict)
         except NeuronParameterNotAvailable:
             Utils.print_danger(
                 "Missing parameter in neuron %s. Execution skipped" %
                 neuron.name)
             return None
     try:
         instantiated_neuron = NeuronLauncher.launch_neuron(neuron)
     except NeuronExceptions as e:
         Utils.print_danger("ERROR: Fail to execute neuron '%s'. "
                            '%s'
                            ". -> Execution skipped" %
                            (neuron.name, e.message))
         return None
     return instantiated_neuron
Exemplo n.º 6
0
    def test_remove_spaces_in_brackets(self):
        """
        Test the Utils remove_spaces_in_brackets
        """

        sentence = "This is the {{ bracket   }}"
        expected_result = "This is the {{bracket}}"
        self.assertEqual(Utils.remove_spaces_in_brackets(sentence=sentence),
                         expected_result,
                         "Fail to remove spaces in one bracket")

        sentence = "This is the {{ bracket   }} {{  second     }}"
        expected_result = "This is the {{bracket}} {{second}}"
        self.assertEqual(Utils.remove_spaces_in_brackets(sentence=sentence),
                         expected_result,
                         "Fail to remove spaces in two brackets")

        # test with json
        sentence = "{\"params\": {\"apikey\": \"ISNOTMYPASSWORD\", " \
                   "\"query\": \"met le chauffage a {{ valeur }} degres\"}}"
        expected_result = "{\"params\": {\"apikey\": \"ISNOTMYPASSWORD\", " \
                          "\"query\": \"met le chauffage a {{valeur}} degres\"}}"
        self.assertEqual(Utils.remove_spaces_in_brackets(sentence=sentence),
                         expected_result,
                         "Fail to remove spaces in two brackets")
    def get_list_match_synapse(cls, order, synapse_order_tuple):
        list_match_synapse = list()
        order = order.lower()  # Needed for STT Correction

        for synapse in cls.brain.synapses:
            if synapse.enabled:
                for signal in synapse.signals:
                    logger.debug("[OrderAnalyser] Testing Synapse name %s" %
                                 synapse.name)
                    # we are only concerned by synapse with a order type of signal
                    if signal.name == "order":
                        # Check if signal is matching the order and parameters.
                        if cls.is_order_matching_signal(user_order=order,
                                                        signal=signal):
                            order = cls.order_correction(order=order,
                                                         signal=signal)
                            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,
                                    matched_order=cls.get_signal_order(signal),
                                    user_order=order))
                            # we matched this synapse with an order, don't need to check another
                            break
        return list_match_synapse
Exemplo n.º 8
0
 def _neuron_parameters_are_available_in_loaded_parameters(
         string_parameters, loaded_parameters):
     """
     Check that all parameters in brackets are available in the loaded_parameters dict
     
     E.g:
     string_parameters = "this is a {{ parameter1 }}"
     
     Will return true if the loaded_parameters looks like the following
     loaded_parameters { "parameter1": "a value"}        
     
     :param string_parameters: The string that contains one or more parameters in brace brackets
     :param loaded_parameters: Dict of parameter
     :return: True if all parameters in brackets have an existing key in loaded_parameters dict
     """
     list_parameters_with_brackets = Utils.find_all_matching_brackets(
         string_parameters)
     # remove brackets to keep only the parameter name
     for parameter_with_brackets in list_parameters_with_brackets:
         parameter = Utils.remove_spaces_in_brackets(
             parameter_with_brackets)
         parameter = parameter.replace("{{", "").replace("}}", "")
         if loaded_parameters is None or parameter not in loaded_parameters:
             Utils.print_danger(
                 "The parameter %s is not available in the order" %
                 str(parameter))
             return False
     return True
Exemplo n.º 9
0
    def get_list_match_synapse(cls, order, synapse_order_tuple):
        list_match_synapse = list()
        for synapse in cls.brain.synapses:
            if synapse.enabled:
                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

                            expected_matching_type = cls.get_matching_type(signal)

                            order = cls.order_correction(order, signal)

                        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))
        return list_match_synapse
Exemplo n.º 10
0
    def test_get_dynamic_class_instantiation(self):
        """
        Test that an instance as been instantiate properly.
        """
        sl = SettingLoader()
        sl.settings.resource_dir = '/var/tmp/test/resources'

        neuron = Neuron(
            name='Say',
            parameters={'message': 'test dynamic class instantiate'})
        say1 = Utils.get_dynamic_class_instantiation(
            package_name="neurons",
            module_name=neuron.name.capitalize(),
            parameters=neuron.parameters,
            resources_dir='/var/tmp/test/resources')
        self.assertTrue(isinstance(say1, Say),
                        "Failed to dynamically instantiate neuron 'Say'")
        say2 = Utils.get_dynamic_class_instantiation(
            package_name="neurons",
            module_name=neuron.name.capitalize(),
            parameters=neuron.parameters,
            resources_dir='/var/tmp/test/resources')
        self.assertTrue(isinstance(say2, Say),
                        "Failed to dynamically instantiate neuron 'Say'")
        self.assertNotEqual(
            id(say1), id(say2),
            "Dynamic class instantiations must return unique instances")
Exemplo n.º 11
0
 def start_neuron(cls, neuron, parameters_dict=dict()):
     """
     Execute each neuron from the received neuron_list.
     Replace parameter if exist in the received dict of parameters_dict
     :param neuron: Neuron object to run
     :param parameters_dict: dict of parameter to load in each neuron if expecting a parameter
     :return: List of the instantiated neurons (no errors detected)
     """
     if neuron.parameters is not None:
         try:
             neuron.parameters = cls._replace_brackets_by_loaded_parameter(
                 neuron.parameters, parameters_dict)
         except NeuronParameterNotAvailable:
             Utils.print_danger(
                 "Missing parameter in neuron %s. Execution skipped" %
                 neuron.name)
             return None
     try:
         instantiated_neuron = NeuronLauncher.launch_neuron(neuron)
     except Exception as e:
         Utils.print_danger(
             f"ERROR: Fail to execute neuron '{neuron.name}'. "
             'e.message'
             ". -> Execution skipped, run with debug flag for more information"
         )
         logger.debug(traceback.format_exc())
         return None
     return instantiated_neuron
Exemplo n.º 12
0
    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.kalliope_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)
            # save in kalliope memory the last tts message
            Cortex.save("kalliope_last_tts_message", tts_message)

            # process the audio only if the mute flag is false
            if self.settings.options.mute:
                logger.debug("[NeuronModule] mute is True, Kalliope is muted")
            else:
                logger.debug(
                    "[NeuronModule] mute is False, make Kalliope 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()
Exemplo n.º 13
0
def signal_handler(signal, frame):
    """
    Used to catch a keyboard signal like Ctrl+C in order to kill the kalliope program
    :param signal: signal handler
    :param frame: execution frame
    """
    print "\n"
    Utils.print_info("Ctrl+C pressed. Killing Kalliope")
    sys.exit(0)
Exemplo n.º 14
0
    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.kalliope_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)
            # save in kalliope memory the last tts message
            Cortex.save("kalliope_last_tts_message", tts_message)

            # process the audio only if the mute flag is false
            if self.settings.options.mute:
                logger.debug("[NeuronModule] mute is True, Kalliope is muted")
            else:
                logger.debug("[NeuronModule] mute is False, make Kalliope 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()
Exemplo n.º 15
0
    def load_stt_plugin(self):
        if self.stt is None:
            self.stt_module_name = self.settings.default_stt_name

        for stt_object in self.settings.stts:
            if stt_object.name == self.stt_module_name:
                stt_object.parameters["callback"] = self.callback
                Utils.get_dynamic_class_instantiation(
                    package_name='stt',
                    module_name=stt_object.name.capitalize(),
                    parameters=stt_object.parameters)
Exemplo n.º 16
0
 def __init__(self, file_path=None):
     self.file_path = file_path
     if self.file_path is None:
         self.file_path = Utils.get_real_file_path(FILE_NAME)
     else:
         self.file_path = Utils.get_real_file_path(file_path)
     # if the returned file path is none, the file doesn't exist
     if self.file_path is None:
         raise SettingNotFound("Settings.yml file not found")
     self.yaml_config = self._get_yaml_config()
     self.settings = self._get_settings()
Exemplo n.º 17
0
    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

        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, Kalliope is muted")
            else:
                logger.debug("[NeuronModule] no_voice is False, make Kalliope 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)
                # Kalliope will talk, turn on the LED
                self.switch_on_led_talking(rpi_settings=self.settings.rpi_settings, on=True)

                # generate the audio file and play it
                tts_module_instance.say(tts_message)

                # Kalliope has finished to talk, turn off the LED
                self.switch_on_led_talking(rpi_settings=self.settings.rpi_settings, on=False)
Exemplo n.º 18
0
    def test_find_all_matching_brackets(self):
        """
        Test the Utils find all matching brackets
        """
        sentence = "This is the {{bracket}}"
        expected_result = ["{{bracket}}"]
        self.assertEqual(Utils.find_all_matching_brackets(sentence=sentence),
                         expected_result, "Fail to match one bracket")

        sentence = "This is the {{bracket}} {{second}}"
        expected_result = ["{{bracket}}", "{{second}}"]
        self.assertEqual(Utils.find_all_matching_brackets(sentence=sentence),
                         expected_result, "Fail to match two brackets")
Exemplo n.º 19
0
    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
Exemplo n.º 20
0
    def _replace_brackets_by_loaded_parameter(cls, neuron_parameters, loaded_parameters=dict()):
        """
        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))

        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):
                settings = cls.load_settings()
                # Priority to memory over the variables
                loaded_parameters.update(settings.variables)
                memory_dict = dict()
                # 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 "kalliope_memory" to not override existing keys loaded form the order
                memory_dict["kalliope_memory"] = Cortex.get_memory()
                loaded_parameters.update(memory_dict)
                # 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
                    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 kalliope core
                if key in "say_template" or key in "file_template" or key in "kalliope_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
Exemplo n.º 21
0
    def test_get_next_value_list(self):
        # Success
        list_to_test = {1, 2, 3}
        self.assertEqual(Utils.get_next_value_list(list_to_test), 2,
                         "Fail to match the expected next value from the list")

        # Failure
        list_to_test = {1}
        self.assertEqual(Utils.get_next_value_list(list_to_test), None,
                         "Fail to ensure there is no next value from the list")

        # Behaviour
        list_to_test = {}
        self.assertEqual(Utils.get_next_value_list(list_to_test), None,
                         "Fail to ensure the empty list return None value")
Exemplo n.º 22
0
    def test_find_all_matching_brackets(self):
        """
        Test the Utils find all matching brackets
        """
        sentence = "This is the {{bracket}}"
        expected_result = ["{{bracket}}"]
        self.assertEqual(Utils.find_all_matching_brackets(sentence=sentence),
                         expected_result,
                         "Fail to match one bracket")

        sentence = "This is the {{bracket}} {{second}}"
        expected_result = ["{{bracket}}", "{{second}}"]
        self.assertEqual(Utils.find_all_matching_brackets(sentence=sentence),
                         expected_result,
                         "Fail to match two brackets")
Exemplo n.º 23
0
    def save_neuron_parameter_in_memory(cls, kalliope_memory_dict,
                                        neuron_parameters):
        """
        receive a dict of value send by the child neuron
        save in kalliope memory all value

        E.g
        dict_parameter_to_save = {"my_key_to_save_in_memory": "{{ output_val_from_neuron }}"}
        neuron_parameter = {"output_val_from_neuron": "this_is_a_value" }

        then the cortex will save in memory the key "my_key_to_save_in_memory" and attach the value "this_is_a_value"

        :param neuron_parameters: dict of parameter the neuron has processed and send to the neurone module to
                be processed by the TTS engine
        :param kalliope_memory_dict: a dict of key value the user want to save from the dict_neuron_parameter
        """

        if kalliope_memory_dict is not None:
            logger.debug("[Cortex] save_memory - User want to save: %s" %
                         kalliope_memory_dict)
            logger.debug(
                "[Cortex] save_memory - Available parameters in the neuron: %s"
                % neuron_parameters)

            for key, value in kalliope_memory_dict.items():
                # ask the cortex to save in memory the target "key" if it was in parameters of the neuron
                if isinstance(neuron_parameters, dict):
                    if Utils.is_containing_bracket(value):
                        value = jinja2.Template(value).render(
                            neuron_parameters)
                    Cortex.save(key, value)
Exemplo n.º 24
0
    def save_neuron_parameter_in_memory(cls, kalliope_memory_dict, neuron_parameters):
        """
        receive a dict of value send by the child neuron
        save in kalliope memory all value

        E.g
        dict_parameter_to_save = {"my_key_to_save_in_memory": "{{ output_val_from_neuron }}"}
        neuron_parameter = {"output_val_from_neuron": "this_is_a_value" }

        then the cortex will save in memory the key "my_key_to_save_in_memory" and attach the value "this_is_a_value"

        :param neuron_parameters: dict of parameter the neuron has processed and send to the neurone module to
                be processed by the TTS engine
        :param kalliope_memory_dict: a dict of key value the user want to save from the dict_neuron_parameter
        """

        if kalliope_memory_dict is not None:
            logger.debug("[Cortex] save_memory - User want to save: %s" % kalliope_memory_dict)
            logger.debug("[Cortex] save_memory - Available parameters in the neuron: %s" % neuron_parameters)

            for key, value in kalliope_memory_dict.items():
                # ask the cortex to save in memory the target "key" if it was in parameters of the neuron
                if isinstance(neuron_parameters, dict):
                    if Utils.is_containing_bracket(value):
                        value = jinja2.Template(value).render(neuron_parameters)
                    Cortex.save(key, value)
Exemplo n.º 25
0
    def is_ordered_strict_matching(cls, user_order, signal_order):
        """
       True if :
            - all word in the user_order are present in the signal_order
            - no additional word
            - same order as word present in signal_order
        :param user_order: order from the user
        :param signal_order: order in the signal
        :return: Boolean
        """
        logger.debug(
            "[OrderAnalyser] ordered_strict_matching called with user_order: %s, signal_order: %s"
            % (user_order, signal_order))
        if cls.is_normal_matching(user_order=user_order, signal_order=signal_order) and \
                cls.is_strict_matching(user_order=user_order, signal_order=signal_order):
            # if the signal order contains bracket, we need to instantiate it with loaded parameters from the user order
            if Utils.is_containing_bracket(signal_order):
                signal_order = cls._get_instantiated_order_signal_from_user_order(
                    signal_order, user_order)

            split_user_order = user_order.split()
            split_signal_order = signal_order.split()
            return split_user_order == split_signal_order

        return False
Exemplo n.º 26
0
    def load_stt_correction_file(cls, stt_correction_file):
        stt_correction_file_path = Utils.get_real_file_path(
            stt_correction_file)
        stt_correction_file = open(stt_correction_file_path, "r")
        stt_correction = yaml.full_load(stt_correction_file)

        return stt_correction
Exemplo n.º 27
0
    def _get_random_wake_up_sounds(settings):
        """
        Return a list of the wake up sounds set up on the settings.yml file

        :param settings: The YAML settings file
        :type settings: dict
        :return: list of wake up sounds
        :rtype: list of str

        :Example:

            wakeup_sounds = cls._get_random_wake_up_sounds(settings)

        .. seealso::
        .. raises:: NullSettingException
        .. warnings:: Class Method and Private
        """

        try:
            random_wake_up_sounds_list = settings["random_wake_up_sounds"]
            # In case files are declared in settings.yml, make sure kalliope can access them.
            for sound in random_wake_up_sounds_list:
                if Utils.get_real_file_path(sound) is None:
                    raise SettingInvalidException("sound file %s not found" %
                                                  sound)
        except KeyError:
            # User does not provide this settings
            return None

        # The the setting is present, the list cannot be empty
        if random_wake_up_sounds_list is None:
            raise NullSettingException(
                "random_wake_up_sounds settings is empty")

        return random_wake_up_sounds_list
Exemplo n.º 28
0
    def test_remove_spaces_in_brackets(self):
        """
        Test the Utils remove_spaces_in_brackets
        """

        sentence = "This is the {{ bracket   }}"
        expected_result = "This is the {{bracket}}"
        self.assertEqual(Utils.remove_spaces_in_brackets(sentence=sentence),
                         expected_result,
                         "Fail to remove spaces in one bracket")

        sentence = "This is the {{ bracket   }} {{  second     }}"
        expected_result = "This is the {{bracket}} {{second}}"
        self.assertEqual(Utils.remove_spaces_in_brackets(sentence=sentence),
                         expected_result,
                         "Fail to remove spaces in two brackets")
Exemplo n.º 29
0
    def save_parameter_from_order_in_memory(cls, order_parameters):
        """
        Save key from the temp dict (where parameters loaded from the voice order where placed temporary)
        into the memory dict
        :param order_parameters: dict of key to save.  {'key_name_in_memory': 'key_name_in_temp_dict'}
        :return True if a value has been saved in the kalliope memory
        """
        order_saved = False
        if order_parameters is not None:
            logger.debug(
                "[Cortex] save_parameter_from_order_in_memory - User want to save: %s"
                % order_parameters)
            logger.debug(
                "[Cortex] save_parameter_from_order_in_memory - Available parameters in orders: %s"
                % cls.temp)

            for key, value in order_parameters.items():
                # ask the cortex to save in memory the target "key" if it was in the order
                if Utils.is_containing_bracket(value):
                    # if the key exist in the temp dict we can load it with jinja
                    value = jinja2.Template(value).render(Cortex.temp)
                    if value:
                        Cortex.save(key, value)
                        order_saved = True

        return order_saved
Exemplo n.º 30
0
    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))
        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):
                    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():
                if key in "say_template" or key in "file_template":  # those keys are reserved for the TTS.
                    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
Exemplo n.º 31
0
    def test_get_next_value_list(self):
        # Success
        list_to_test = {1, 2, 3}
        self.assertEqual(
            Utils.get_next_value_list(list_to_test), 2,
            "Fail to match the expected next value from the list")

        # Failure
        list_to_test = {1}
        self.assertEqual(
            Utils.get_next_value_list(list_to_test), None,
            "Fail to ensure there is no next value from the list")

        # Behaviour
        list_to_test = {}
        self.assertEqual(Utils.get_next_value_list(list_to_test), None,
                         "Fail to ensure the empty list return None value")
Exemplo n.º 32
0
    def _associate_order_params_to_values(order, order_to_check):
        """
        Associate the variables from the order to the incoming user order
        :param order_to_check: the order to check incoming from the brain
        :type order_to_check: str
        :param order: the order from user
        :type order: str
        :return: the dict corresponding to the key / value of the params
        """
        logger.debug(
            "[OrderAnalyser._associate_order_params_to_values] user order: %s, "
            "order to check: %s" % (order, order_to_check))

        list_word_in_order = Utils.remove_spaces_in_brackets(
            order_to_check).split()

        # get the order, defined by the first words before {{
        # /!\ Could be empty if order starts with double brace
        the_order = order_to_check[:order_to_check.find('{{')]

        # remove sentence before order which are sentences not matching anyway
        truncate_user_sentence = order[order.find(the_order):]
        truncate_list_word_said = truncate_user_sentence.split()

        # make dict var:value
        dict_var = dict()
        for idx, ow in enumerate(list_word_in_order):
            if Utils.is_containing_bracket(ow):
                # remove bracket and grab the next value / stop value
                var_name = ow.replace("{{", "").replace("}}", "")
                stop_value = Utils.get_next_value_list(
                    list_word_in_order[idx:])
                if stop_value is None:
                    dict_var[var_name] = " ".join(truncate_list_word_said)
                    break
                for word_said in truncate_list_word_said:
                    if word_said == stop_value:
                        break
                    if var_name in dict_var:
                        dict_var[var_name] += " " + word_said
                        truncate_list_word_said = truncate_list_word_said[1:]
                    else:
                        dict_var[var_name] = word_said
            truncate_list_word_said = truncate_list_word_said[1:]
        return dict_var
Exemplo n.º 33
0
    def _get_default_synapse_from_sysnapses_list(all_synapses_list, default_synapse_name):
        """
        Static method to get the default synapse if it exists.

        :param all_synapses_list: the complete list of all synapses
        :param default_synapse_name: the synapse to find
        :return: the Synapse
        """
        default_synapse = None
        for synapse in all_synapses_list:
            if synapse.name == default_synapse_name:
                logger.debug("Default synapse found: %s" % synapse.name)
                default_synapse = synapse
                break
        if default_synapse is None:
            logger.debug("Default synapse not found")
            Utils.print_warning("Default synapse not found")
        return default_synapse
Exemplo n.º 34
0
 def start_neuron(cls, neuron, parameters_dict=None):
     """
     Execute each neuron from the received neuron_list.
     Replace parameter if exist in the received dict of parameters_dict
     :param neuron: Neuron object to run
     :param parameters_dict: dict of parameter to load in each neuron if expecting a parameter
     :return: List of the instantiated neurons (no errors detected)
     """
     if neuron.parameters is not None:
         try:
             neuron.parameters = cls._replace_brackets_by_loaded_parameter(
                 neuron.parameters, parameters_dict)
         except NeuronParameterNotAvailable:
             Utils.print_danger("The neuron %s cannot be launched" %
                                neuron.name)
             return None
     instantiated_neuron = NeuronLauncher.launch_neuron(neuron)
     return instantiated_neuron
Exemplo n.º 35
0
    def test_get_current_file_parent_path(self):
        """
        Expect to get back the parent path file
        """
        path_to_test = "../kalliope/core/Utils"
        expected_result = os.path.normpath("../kalliope/core")

        self.assertEqual(
            Utils.get_current_file_parent_path(path_to_test), expected_result,
            "fail getting the parent parent path from the given path")
Exemplo n.º 36
0
    def test_get_current_file_parent_parent_path(self):
        """
        Expect to get back the parent parent path file
        """
        path_to_test = "../kalliope/core/Utils"
        expected_result = os.path.normpath("../kalliope")

        self.assertEqual(Utils.get_current_file_parent_parent_path(path_to_test),
                         expected_result,
                         "fail getting the parent parent path from the given path")
Exemplo n.º 37
0
    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

        if isinstance(message, str) or isinstance(message, unicode):
            logger.debug("message is string")
            tts_message = message

        if isinstance(message, list):
            logger.debug("message is list")
            tts_message = random.choice(message)

        if isinstance(message, dict):
            logger.debug("message is dict")
            tts_message = self._get_message_from_dict(message)

        if tts_message is not None:
            logger.debug("tts_message to say: %s" % tts_message)

            # create a tts object from the tts the user want to use
            tts_object = next(
                (x for x in self.settings.ttss if x.name == self.tts), None)
            if tts_object is None:
                raise TTSModuleNotFound(
                    "The tts module name %s does not exist in settings file" %
                    self.tts)
            # change the cache settings with the one precised for the current neuron
            if self.override_cache is not None:
                tts_object.parameters = self._update_cache_var(
                    self.override_cache, tts_object.parameters)

            logger.debug("NeuroneModule: TTS args: %s" % tts_object)

            # 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=tts_object.name,
                parameters=tts_object.parameters,
                resources_dir=tts_folder)
            # generate the audio file and play it
            tts_module_instance.say(tts_message)
Exemplo n.º 38
0
    def get_list_match_synapse(cls, order, synapse_order_tuple):
        list_match_synapse = list()
        for synapse in cls.brain.synapses:
            if synapse.enabled:
                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

                            expected_matching_type = cls.get_matching_type(
                                signal)

                            order = cls.order_correction(order, signal)

                        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))
        return list_match_synapse
Exemplo n.º 39
0
    def _get_file_template(cls, file_template, message_dict):
        real_file_template_path = Utils.get_real_file_path(file_template)
        if real_file_template_path is None:
            raise TemplateFileNotFoundException("Template file %s not found in templates folder"
                                                % real_file_template_path)

        # load the content of the file as template
        t = Template(cls._get_content_of_file(real_file_template_path))
        returned_message = t.render(**message_dict)

        return returned_message
Exemplo n.º 40
0
    def test_encode_text_utf8(self):
        """
        Test encoding the text in utf8
        """
        sentence = "kâllìöpé"
        if sys.version_info[0] < 3:
            sentence = sentence.decode('utf8')
        expected_sentence = "kâllìöpé"

        self.assertEqual(Utils.encode_text_utf8(text=sentence),
                         expected_sentence)
Exemplo n.º 41
0
    def serialize(self):
        """
        This method allows to serialize in a proper way this object

        :return: A dict of name and parameters
        :rtype: Dict
        """
        self.tts_message = Utils.encode_text_utf8(self.tts_message)
        return {
            'neuron_name': self.neuron_name,
            'generated_message': self.tts_message
        }
Exemplo n.º 42
0
 def start_neuron(cls, neuron, parameters_dict=dict()):
     """
     Execute each neuron from the received neuron_list.
     Replace parameter if exist in the received dict of parameters_dict
     :param neuron: Neuron object to run
     :param parameters_dict: dict of parameter to load in each neuron if expecting a parameter
     :return: List of the instantiated neurons (no errors detected)
     """
     if neuron.parameters is not None:
         try:
             neuron.parameters = cls._replace_brackets_by_loaded_parameter(neuron.parameters, parameters_dict)
         except NeuronParameterNotAvailable:
             Utils.print_danger("Missing parameter in neuron %s. Execution skipped" % neuron.name)
             return None
     try:
         instantiated_neuron = NeuronLauncher.launch_neuron(neuron)
     except NeuronExceptions as e:
         Utils.print_danger("ERROR: Fail to execute neuron '%s'. "
                            '%s' ". -> Execution skipped" % (neuron.name, e.message))
         return None
     return instantiated_neuron
Exemplo n.º 43
0
 def _neuron_parameters_are_available_in_loaded_parameters(string_parameters, loaded_parameters):
     """
     Check that all parameters in brackets are available in the loaded_parameters dict
     
     E.g:
     string_parameters = "this is a {{ parameter1 }}"
     
     Will return true if the loaded_parameters looks like the following
     loaded_parameters { "parameter1": "a value"}        
     
     :param string_parameters: The string that contains one or more parameters in brace brackets
     :param loaded_parameters: Dict of parameter
     :return: True if all parameters in brackets have an existing key in loaded_parameters dict
     """
     list_parameters_with_brackets = Utils.find_all_matching_brackets(string_parameters)
     # remove brackets to keep only the parameter name
     for parameter_with_brackets in list_parameters_with_brackets:
         parameter = Utils.remove_spaces_in_brackets(parameter_with_brackets)
         parameter = parameter.replace("{{", "").replace("}}", "")
         if loaded_parameters is None or parameter not in loaded_parameters:
             Utils.print_danger("The parameter %s is not available in the order" % str(parameter))
             return False
     return True
Exemplo n.º 44
0
    def _get_split_order_without_bracket(order):
        """
        Get an order with bracket inside like: "hello my name is {{ name }}.
        return a list of string without bracket like ["hello", "my", "name", "is"]
        :param order: sentence to split
        :return: list of string without bracket
        """

        matches = Utils.find_all_matching_brackets(order)
        for match in matches:
            order = order.replace(match, "")
        # then split
        split_order = order.split()
        return split_order
Exemplo n.º 45
0
    def test_get_dynamic_class_instantiation(self):
        """
        Test that an instance as been instantiate properly.
        """
        sl = SettingLoader()
        sl.settings.resource_dir = '/var/tmp/test/resources'

        neuron = Neuron(name='Say', parameters={'message': 'test dynamic class instantiate'})
        self.assertTrue(isinstance(Utils.get_dynamic_class_instantiation(package_name="neurons",
                                                                         module_name=neuron.name.capitalize(),
                                                                         parameters=neuron.parameters,
                                                                         resources_dir='/var/tmp/test/resources'),
                                   Say),
                        "Fail instantiate a class")
Exemplo n.º 46
0
    def launch_neuron(cls, neuron):
        """
        Start a neuron plugin
        :param neuron: neuron object
        :type neuron: Neuron
        :return:
        """
        logger.debug("Run neuron: \"%s\"" % (neuron.__str__()))
        settings = cls.load_settings()
        neuron_folder = None
        if settings.resources:
            neuron_folder = settings.resources.neuron_folder

        return Utils.get_dynamic_class_instantiation(package_name="neurons",
                                                     module_name=neuron.name,
                                                     parameters=neuron.parameters,
                                                     resources_dir=neuron_folder)
Exemplo n.º 47
0
    def load_stt_plugin(self):
        if self.stt is None:
            self.stt_module_name = self.settings.default_stt_name

        logger.debug("[OrderListener] stt module name : %s" % self.stt_module_name)
        for stt_object in self.settings.stts:
            if stt_object.name == self.stt_module_name:
                stt_object.parameters["callback"] = self.callback
                # add the audio file path to the list of parameter if set
                if self.audio_file_path is not None:
                    stt_object.parameters["audio_file_path"] = self.audio_file_path

                stt_folder = None
                if self.settings.resources:
                    stt_folder = self.settings.resources.stt_folder
                return Utils.get_dynamic_class_instantiation(package_name='stt',
                                                             module_name=stt_object.name.capitalize(),
                                                             parameters=stt_object.parameters,
                                                             resources_dir=stt_folder)
Exemplo n.º 48
0
    def _get_variables(settings):
        """
        Return the dict of variables from the settings.
        :param settings: The YAML settings file
        :return: dict
        """

        variables = dict()
        try:
            variables_files_name = settings["var_files"]
            # In case files are declared in settings.yml, make sure kalliope can access them.
            for files in variables_files_name:
                var = Utils.get_real_file_path(files)
                if var is None:
                    raise SettingInvalidException("Variables file %s not found" % files)
                else:
                    variables.update(YAMLLoader.get_config(var))
            return variables
        except KeyError:
            # User does not provide this settings
            return dict()
Exemplo n.º 49
0
    def test_is_containing_bracket(self):
        #  Success
        order_to_test = "This test contains {{ bracket }}"
        self.assertTrue(Utils.is_containing_bracket(order_to_test),
                        "Fail returning True when order contains spaced brackets")

        order_to_test = "This test contains {{bracket }}"
        self.assertTrue(Utils.is_containing_bracket(order_to_test),
                        "Fail returning True when order contains right spaced bracket")

        order_to_test = "This test contains {{ bracket}}"
        self.assertTrue(Utils.is_containing_bracket(order_to_test),
                        "Fail returning True when order contains left spaced bracket")

        order_to_test = "This test contains {{bracket}}"
        self.assertTrue(Utils.is_containing_bracket(order_to_test),
                        "Fail returning True when order contains no spaced bracket")

        # Failure
        order_to_test = "This test does not contain bracket"
        self.assertFalse(Utils.is_containing_bracket(order_to_test),
                         "Fail returning False when order has no brackets")

        # Behaviour
        order_to_test = ""
        self.assertFalse(Utils.is_containing_bracket(order_to_test),
                         "Fail returning False when no order")

        # Behaviour int
        order_to_test = 6
        self.assertFalse(Utils.is_containing_bracket(order_to_test),
                         "Fail returning False when an int")

        # Behaviour unicode
        order_to_test = "j'aime les goûters l'été"
        self.assertFalse(Utils.is_containing_bracket(order_to_test),
                         "Fail returning False when an int")
Exemplo n.º 50
0
    def save_parameter_from_order_in_memory(cls, order_parameters):
        """
        Save key from the temp dict (where parameters loaded from the voice order where placed temporary)
        into the memory dict
        :param order_parameters: dict of key to save.  {'key_name_in_memory': 'key_name_in_temp_dict'}
        :return True if a value has been saved in the kalliope memory
        """
        order_saved = False
        if order_parameters is not None:
            logger.debug("[Cortex] save_parameter_from_order_in_memory - User want to save: %s" % order_parameters)
            logger.debug("[Cortex] save_parameter_from_order_in_memory - Available parameters in orders: %s"
                         % cls.temp)

            for key, value in order_parameters.items():
                # ask the cortex to save in memory the target "key" if it was in the order
                if Utils.is_containing_bracket(value):
                    # if the key exist in the temp dict we can load it with jinja
                    value = jinja2.Template(value).render(Cortex.temp)
                    if value:
                        Cortex.save(key, value)
                        order_saved = True

        return order_saved
Exemplo n.º 51
0
    def is_ordered_strict_matching(cls, user_order, signal_order):
        """
       True if :
            - all word in the user_order are present in the signal_order
            - no additional word
            - same order as word present in signal_order
        :param user_order: order from the user
        :param signal_order: order in the signal
        :return: Boolean
        """
        logger.debug(
            "[OrderAnalyser] ordered_strict_matching called with user_order: %s, signal_order: %s" % (user_order,
                                                                                                      signal_order))
        if cls.is_normal_matching(user_order=user_order, signal_order=signal_order) and \
                cls.is_strict_matching(user_order=user_order, signal_order=signal_order):
            # if the signal order contains bracket, we need to instantiate it with loaded parameters from the user order
            if Utils.is_containing_bracket(signal_order):
                signal_order = cls._get_instantiated_order_signal_from_user_order(signal_order, user_order)

            split_user_order = user_order.split()
            split_signal_order = signal_order.split()
            return split_user_order == split_signal_order

        return False
Exemplo n.º 52
0
    def test_get_real_file_path(self):
        """
        Expect to load the proper file following the order :
            - Provided absolute path
            - Current user path + file_name
            - /etc/kalliope + file_name
            - /path/to/kalliope/ +file_name
        """
        ###
        # Test the absolute path
        dir_path = "/tmp/kalliope/tests/"
        file_name = "test_real_file_path"
        absolute_path_to_test = os.path.join(dir_path, file_name)
        expected_result = absolute_path_to_test
        if not os.path.exists(dir_path):
            os.makedirs(dir_path)

        # touch the file
        open(absolute_path_to_test, 'a').close()

        self.assertEqual(Utils.get_real_file_path(absolute_path_to_test),
                         expected_result,
                         "Fail to match the given absolute path ")
        # Clean up
        if os.path.exists(absolute_path_to_test):
            os.remove(absolute_path_to_test)

        ###
        # test the Current path
        file_name = "test_real_file_path"
        expected_result = os.getcwd() + os.sep + file_name

        # touch the file
        open(file_name, 'a').close()

        self.assertEqual(Utils.get_real_file_path(file_name),
                         expected_result,
                         "Fail to match the Current path ")
        # Clean up
        if os.path.exists(file_name):
            os.remove(file_name)

        ###
        # test /etc/kalliope
        # /!\ need permissions
        # dir_path = "/etc/kalliope/"
        # file_name = "test_real_file_path"
        # path_to_test = os.path.join(dir_path,file_name)
        # expected_result = "/etc/kalliope" + os.sep + file_name
        # if not os.path.exists(dir_path):
        #     os.makedirs(dir_path)
        #
        # # touch the file
        # open(path_to_test, 'a').close()
        #
        # self.assertEquals(Utils.get_real_file_path(file_name),
        #                   expected_result,
        #                   "Fail to match the /etc/kalliope path")
        # # Clean up
        # if os.path.exists(file_name):
        #     os.remove(file_name)

        ###
        # /an/unknown/path/kalliope/
        dir_path = "../kalliope/"
        file_name = "test_real_file_path"
        path_to_test = os.path.join(dir_path, file_name)
        expected_result = os.path.normpath(os.getcwd() + os.sep + os.pardir + os.sep + "kalliope" + os.sep + file_name)
        if not os.path.exists(dir_path):
            os.makedirs(dir_path)

        # touch the file
        open(path_to_test, 'a').close()

        self.assertEqual(Utils.get_real_file_path(file_name),
                         expected_result,
                         "Fail to match the /an/unknown/path/kalliope path")
        # Clean up
        if os.path.exists(expected_result):
            os.remove(expected_result)
Exemplo n.º 53
0
    def load_stt_correction_file(cls, stt_correction_file):
        stt_correction_file_path = Utils.get_real_file_path(stt_correction_file)
        stt_correction_file = open(stt_correction_file_path, "r")
        stt_correction = yaml.load(stt_correction_file)

        return stt_correction