Просмотр исходного кода

Merge pull request #315 from kalliope-project/dict_in_global_var

Dict in global var
Monf 7 лет назад
Родитель
Сommit
dbadceb124

+ 21 - 2
Docs/settings.md

@@ -354,7 +354,7 @@ var_files:
   - variables.yml
   - variables2.yml
 ```
-/!\ If a variable is defined in different files, the last file defines the value.
+> **Note:** If a variable is defined in different files, the last file defines the value.
 
 In the files the variables are defined by key/value:
 ```yml
@@ -364,7 +364,6 @@ password: "secret"
 ```
 
 And use variables in your neurons:
-/!\ Because YAML format does no allow double braces not surrounded by quotes: you must use the variable between double quotes. 
 ```yml
   - name: "run-simple-sleep"
     signals:
@@ -376,6 +375,26 @@ And use variables in your neurons:
           password: "{{password}}"
 ```
 
+> **Note:** Because YAML format does no allow double braces not surrounded by quotes: you must use the variable between double quotes. 
+
+A global variable can be a dictionary. Example:
+```yml
+contacts:
+  nico: "1234"
+  tibo: "5678"
+```
+
+And a synapse that use this dict:
+```yml
+- name: "test-var"
+  signals:
+    - order: "give me the number of {{ contact_to_search }}"
+  neurons:
+    - say:
+        message:
+        - "the number is {{ contacts[contact_to_search] }}"
+```
+
 ## Raspberry LED and mute button
 LEDs connected to GPIO port of your Raspberry can be used to know current status of Kalliope.
 A button can also be added in order to pause the trigger process. Kalliope does not listen for the hotword anymore when pressed.

+ 29 - 1
Tests/test_neuron_launcher.py

@@ -2,6 +2,7 @@
 
 import unittest
 import mock
+from kalliope.core.Models import Singleton
 
 from kalliope.core.Models.Resources import Resources
 from kalliope.core.NeuronLauncher import NeuronLauncher, NeuronParameterNotAvailable
@@ -16,7 +17,11 @@ class TestNeuronLauncher(unittest.TestCase):
     """
 
     def setUp(self):
-        pass
+        # clean settings
+        Singleton._instances = dict()
+
+    def tearDown(self):
+        Singleton._instances = dict()
 
     ####
     # Neurons Launcher
@@ -181,6 +186,29 @@ class TestNeuronLauncher(unittest.TestCase):
         self.assertEqual(expected_result, NeuronLauncher._replace_brackets_by_loaded_parameter(neuron_parameters,
                                                                                                loaded_parameters))
 
+        # replacing with variable
+        sl = SettingLoader()
+        sl.settings.variables = {
+            "replaced": {
+                "name": u'replaced successfully'
+            }
+        }
+
+        neuron_parameters = {
+            "param1": "this is a value {{ replaced['name'] }}"
+        }
+
+        loaded_parameters = {
+            "name": "replaced successfully"
+        }
+
+        expected_result = {
+            "param1": "this is a value replaced successfully"
+        }
+
+        self.assertEqual(expected_result, NeuronLauncher._replace_brackets_by_loaded_parameter(neuron_parameters,
+                                                                                               loaded_parameters))
+
     def test_parameters_are_available_in_loaded_parameters(self):
         # the parameter in bracket is available in the dict
         string_parameters = "this is a {{ parameter1 }}"

+ 14 - 0
Tests/test_synapse_launcher.py

@@ -52,6 +52,20 @@ class TestSynapseLauncher(unittest.TestCase):
             expected_result = [[should_be_created_matched_synapse]]
             self.assertEqual(expected_result, LIFOBuffer.lifo_list)
 
+            # we expect that the lifo has been loaded with the synapse to run and overwritten parameters
+            # clean the LiFO
+            LIFOBuffer.lifo_list = list()
+            overriding_param = {
+                "val1": "val"
+            }
+            SynapseLauncher.start_synapse_by_name("Synapse1", brain=self.brain_test,
+                                                  overriding_parameter_dict=overriding_param)
+            should_be_created_matched_synapse = MatchedSynapse(matched_synapse=self.synapse1,
+                                                               overriding_parameter=overriding_param)
+            # we expect that the lifo has been loaded with the synapse to run
+            expected_result = [[should_be_created_matched_synapse]]
+            self.assertEqual(expected_result, LIFOBuffer.lifo_list)
+
         # non existing synapse in the brain
         with self.assertRaises(SynapseNameNotFound):
             SynapseLauncher.start_synapse_by_name("not_existing", brain=self.brain_test)

+ 55 - 0
brain_examples/neurotimer.yml

@@ -0,0 +1,55 @@
+  - name: "timer"
+    signals:
+      - order: "je lance un thé"
+      - order: "je lance un T"
+    neurons:
+      - neurotimer:
+          seconds: 10
+          synapse: "time-over"
+      - say:
+          message:
+            - "je vous préviens dans 5 secondes"
+
+  - name: "time-over"
+    signals:
+      - order: "time-is-over"
+    neurons:
+      - say:
+          message:
+            - "c'est terminé"
+
+  - name: "timer2"
+    signals:
+      - order: "préviens moi dans {{ time }} secondes"
+      - order: "préviens-moi dans {{ time }} secondes"
+    neurons:
+      - neurotimer:
+          seconds: "{{ time }}"
+          synapse: "time-over"
+      - say:
+          message:
+            - "je vous préviens dans {{ time }} secondes"
+
+  - name: "remember-synapse"
+    signals:
+      - order: "rappel-moi de {{ remember }} dans {{ time }} secondes"
+      - order: "rappel moi de {{ remember }} dans {{ time }} secondes"
+      - order: "rappelle-moi de {{ remember }} dans {{ time }} secondes"
+    neurons:
+      - neurotimer:
+          seconds: "{{ time }}"
+          synapse: "remember-todo"
+          forwarded_parameters:
+            remember: "{{ remember }}"
+            time: "{{ time }}"
+      - say:
+          message:
+            - "je vous le rappel dans {{ time }} secondes"
+
+  - name: "remember-todo"
+    signals:
+      - order: "no-order-for-this-synapse"
+    neurons:
+      - say:
+          message:
+            - "Vous m'avez demandé de vous rappler de {{ remember }} il y a {{ time }} secondes"

+ 16 - 5
kalliope/core/NeuronLauncher.py

@@ -1,10 +1,10 @@
 import logging
-import six
+
 import jinja2
-import sys
+import six
 
-from kalliope.core.Utils.Utils import Utils
 from kalliope.core.ConfigurationManager.SettingLoader import SettingLoader
+from kalliope.core.Utils.Utils import Utils
 
 logging.basicConfig()
 logger = logging.getLogger("kalliope")
@@ -28,8 +28,7 @@ class NeuronLauncher:
         :return:
         """
         logger.debug("Run neuron: \"%s\"" % (neuron.__str__()))
-        sl = SettingLoader()
-        settings = sl.settings
+        settings = cls.load_settings()
         neuron_folder = None
         if settings.resources:
             neuron_folder = settings.resources.neuron_folder
@@ -72,6 +71,9 @@ class NeuronLauncher:
             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)
@@ -121,3 +123,12 @@ class NeuronLauncher:
                 Utils.print_danger("The parameter %s is not available in the order" % str(parameter))
                 return False
         return True
+
+    @staticmethod
+    def load_settings():
+        """
+        Return loaded kalliope settings
+        :return: setting object
+        """
+        sl = SettingLoader()
+        return sl.settings