fix neurotransmitter

Tests/test_brain_loader.py

@@ -15,7 +15,11 @@ from kalliope.core.Models.Settings import Settings
 class TestBrainLoader(unittest.TestCase):
 
     def setUp(self):
-        self.brain_to_test = os.getcwd() + os.sep + "Tests/brains/brain_test.yml"
+        if "/Tests" in os.getcwd():
+            self.brain_to_test = os.getcwd() + os.sep + "brains/brain_test.yml"
+        else:
+            self.brain_to_test = os.getcwd() + os.sep + "Tests/brains/brain_test.yml"
+
         self.expected_result = [
             {'signals': [{'order': 'test_order'}],
              'neurons': [{'say': {'message': ['test message']}}],
@@ -138,11 +142,12 @@ class TestBrainLoader(unittest.TestCase):
             - 3/ global variable with int after
             - 4/ multiple global variables
             - 5/ parameter value is a list
+            - 6/ parameter is a dict
 
         """
 
         # 1/ only one global variable
-        parameters={
+        parameters = {
             'var1': '{{hello}}'
         }
 
@@ -152,17 +157,17 @@ class TestBrainLoader(unittest.TestCase):
         }
         st = Settings(variables=variables)
 
-        expected_parameters={
+        expected_parameters = {
             'var1': 'test'
         }
 
-        self.assertEquals(BrainLoader._replace_global_variables(parameters=parameters,
+        self.assertEquals(BrainLoader._replace_global_variables(parameter=parameters,
                                                                 settings=st),
                           expected_parameters,
                           "Fail to assign a single global variable to parameters")
 
         # 2/ global variable with string after
-        parameters={
+        parameters = {
             'var1': '{{hello}} Sispheor'
         }
         variables = {
@@ -175,13 +180,13 @@ class TestBrainLoader(unittest.TestCase):
             'var1': 'test Sispheor'
         }
 
-        self.assertEquals(BrainLoader._replace_global_variables(parameters=parameters,
+        self.assertEquals(BrainLoader._replace_global_variables(parameter=parameters,
                                                                 settings=st),
                           expected_parameters,
                           "Fail to assign a global variable with string after to parameters")
 
         # 3/ global variable with int after
-        parameters={
+        parameters = {
             'var1': '{{hello}}0'
         }
         variables = {
@@ -190,17 +195,17 @@ class TestBrainLoader(unittest.TestCase):
         }
         st = Settings(variables=variables)
 
-        expected_parameters={
+        expected_parameters = {
             'var1': '600'
         }
 
-        self.assertEquals(BrainLoader._replace_global_variables(parameters=parameters,
+        self.assertEquals(BrainLoader._replace_global_variables(parameter=parameters,
                                                                 settings=st),
                           expected_parameters,
                           "Fail to assign global variable with int after to parameters")
 
         # 4/ multiple global variables
-        parameters={
+        parameters = {
             'var1': '{{hello}} {{me}}'
         }
         variables = {
@@ -209,17 +214,17 @@ class TestBrainLoader(unittest.TestCase):
         }
         st = Settings(variables=variables)
 
-        expected_parameters={
+        expected_parameters = {
             'var1': 'hello LaMonf'
         }
 
-        self.assertEquals(BrainLoader._replace_global_variables(parameters=parameters,
+        self.assertEquals(BrainLoader._replace_global_variables(parameter=parameters,
                                                                 settings=st),
                           expected_parameters,
                           "Fail to assign multiple global variables to parameters")
 
         # 5/ parameter value is a list
-        parameters={
+        parameters = {
             'var1': '[hello {{name}}, bonjour {{name}}]'
         }
         variables = {
@@ -228,11 +233,31 @@ class TestBrainLoader(unittest.TestCase):
         }
         st = Settings(variables=variables)
 
-        expected_parameters={
+        expected_parameters = {
             'var1': '[hello LaMonf, bonjour LaMonf]'
         }
 
-        self.assertEquals(BrainLoader._replace_global_variables(parameters=parameters,
+        self.assertEquals(BrainLoader._replace_global_variables(parameter=parameters,
+                                                                settings=st),
+                          expected_parameters,
+                          "Fail to assign a single global when parameter value is a list to neuron")
+
+        # 6/ parameter is a dict
+        parameters = {'from_answer_link': [{'synapse': 'synapse2', 'answers': ['absolument', '{{ name }}']},
+                                           {'synapse': 'synapse3', 'answers': ['{{ name }}']}], 'default': 'synapse4'}
+
+        variables = {
+            "name": "nico"
+        }
+        st = Settings(variables=variables)
+
+        expected_parameters = {
+            'from_answer_link': [
+                {'synapse': 'synapse2', 'answers': ['absolument', 'nico']},
+                {'synapse': 'synapse3', 'answers': ['nico']}], 'default': 'synapse4'
+        }
+
+        self.assertEquals(BrainLoader._replace_global_variables(parameter=parameters,
                                                                 settings=st),
                           expected_parameters,
                           "Fail to assign a single global when parameter value is a list to neuron")

Tests/test_neuron_module.py

@@ -36,7 +36,8 @@ class TestNeuronModule(unittest.TestCase):
             with mock.patch("kalliope.core.OrderListener.join") as mock_orderListener_join:
                 def callback():
                     pass
-                NeuronModule.get_audio_from_stt(callback=callback())
+
+                self.neuron_module_test.get_audio_from_stt(callback=callback())
                 mock_orderListener_start.assert_called_once_with()
                 mock_orderListener_start.reset_mock()
 

kalliope/core/ConfigurationManager/BrainLoader.py

@@ -133,8 +133,8 @@ class BrainLoader(object):
                         name = neuron_name
                         parameters = neuron_dict[name]
 
-                        # Update brackets
-                        parameters = cls._replace_global_variables(parameters=parameters,
+                        # Update brackets with the global parameter if exist
+                        parameters = cls._replace_global_variables(parameter=parameters,
                                                                    settings=settings)
 
                         new_neuron = Neuron(name=name, parameters=parameters)
@@ -246,28 +246,32 @@ class BrainLoader(object):
                      day_of_week=day_of_week, hour=hour, minute=minute, second=second)
 
     @classmethod
-    def _replace_global_variables(cls, parameters, settings):
+    def _replace_global_variables(cls, parameter, settings):
         """
-        Replace all the parameters with variables with the variable value.
-        :param parameters: the parameters dict with brackets
+        replace a parameter that contains bracket by the instantiated parameter from the var file
+        This function will call itself multiple time to handle different level of parameter in a neuron
+
+        :param parameter: the parameter to update. can be a dict, a list or a string
         :param settings: the settings
         :return: the parameter dict
         """
-        for param in parameters:
-            if isinstance(parameters[param], list):
-                list_param_value = list()
-                for sentence in parameters[param]:
-                    sentence_with_global_variables = cls._get_global_variable(sentence=sentence,
-                                                                              settings=settings)
-                    list_param_value.append(sentence_with_global_variables)
-                parameters[param] = list_param_value
 
-            else:
-                if Utils.is_containing_bracket(parameters[param]):
-                    sentence_with_global_variables = cls._get_global_variable(sentence=parameters[param],
-                                                                              settings=settings)
-                    parameters[param] = sentence_with_global_variables
-        return parameters
+        if isinstance(parameter, dict):
+            # print "parameter is dict %s" % str(parameter)
+            for key, value in parameter.iteritems():
+                parameter[key] = cls._replace_global_variables(value, settings=settings)
+            return parameter
+        if isinstance(parameter, list):
+            # print "parameter is list %s" % str(parameter)
+            new_parameter_list = list()
+            for el in parameter:
+                new_parameter_list.append(cls._replace_global_variables(el, settings=settings))
+            return new_parameter_list
+        if isinstance(parameter, str) or isinstance(parameter, unicode):
+            # print "parameter is string %s" % parameter
+            if Utils.is_containing_bracket(parameter):
+                return cls._get_global_variable(sentence=parameter, settings=settings)
+            return parameter
 
     @staticmethod
     def _get_global_variable(sentence, settings):
@@ -285,4 +289,4 @@ class BrainLoader(object):
                                                                  settings.variables[param_no_brackets]))
                 sentence_no_spaces = sentence_no_spaces.replace(param_with_bracket,
                                                                 str(settings.variables[param_no_brackets]))
-        return sentence_no_spaces
+        return sentence_no_spaces

kalliope/core/NeuronModule.py

@@ -209,7 +209,8 @@ class NeuronModule(object):
             oa = OrderAnalyser(order=order, brain=self.brain)
             oa.start(synapses_to_run=list_to_run, external_order=order_template)
         else:
-            logger.debug("[NeuronModule]-> run_synapse_by_name_with_order, the synapse has not been found : %s" % synapse_name)
+            logger.debug("[NeuronModule]-> run_synapse_by_name_with_order, the synapse has not been found : %s"
+                         % synapse_name)
         return synapse_to_run is not None
 
     @staticmethod
@@ -245,6 +246,9 @@ class NeuronModule(object):
         ol = OrderListener(callback=callback)
         ol.start()
         ol.join()
+        # wait that the STT engine has finish his job (or the neurotransmitter neuron will be killed)
+        if ol.stt_instance is not None:
+            ol.stt_instance.join()
 
     def get_neuron_name(self):
         """