dict can be used in global variables

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.

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

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"

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 = cls.load_settings()
-        settings = sl.settings
         neuron_folder = None
         if settings.resources:
             neuron_folder = settings.resources.neuron_folder
@@ -72,6 +71,8 @@ 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
+                    loaded_parameters = cls.merge_with_global_variable_from_settings(loaded_parameters)
                     neuron_parameters = jinja2.Template(neuron_parameters).render(loaded_parameters)
                     neuron_parameters = Utils.encode_text_utf8(neuron_parameters)
                     return str(neuron_parameters)
@@ -121,3 +122,23 @@ class NeuronLauncher:
                 Utils.print_danger("The parameter %s is not available in the order" % str(parameter))
                 return False
         return True
+
+    @classmethod
+    def merge_with_global_variable_from_settings(cls, loaded_parameters):
+        """
+        merge the received dict "loaded_parameters" with the dict of global variables from settings
+        """
+        settings = cls.load_settings()
+        z = loaded_parameters.copy()
+        z.update(settings.variables)
+        logger.debug("[NeuronLauncher] final dict of parameters: %s" % z)
+        return z
+
+    @classmethod
+    def load_settings(cls):
+        """
+        Return loaded kalliope settings
+        :return: setting object
+        """
+        sl = SettingLoader()
+        return sl.settings