Browse Source

[Fix] #146 Review the code to manage multiple orders matching in orders

monf 8 years ago
parent
commit
1edc0d39ed
3 changed files with 79 additions and 37 deletions
  1. 33 15
      Tests/test_order_analyser.py
  2. 4 1
      kalliope/core/NeuronLauncher.py
  3. 42 21
      kalliope/core/OrderAnalyser.py

+ 33 - 15
Tests/test_order_analyser.py

@@ -1,3 +1,4 @@
+import collections
 import unittest
 import unittest
 import mock
 import mock
 
 
@@ -364,11 +365,13 @@ class TestOrderAnalyser(unittest.TestCase):
                             synapse2,
                             synapse2,
                             synapse3]
                             synapse3]
 
 
-        expected_result = [synapse1]
+
 
 
         # Success
         # Success
-        self.assertEquals(OrderAnalyser._get_matching_synapse_list(all_synapses_list=all_synapse_list,
-                                                                   order_to_match=order_to_match),
+        expected_result = synapse1
+        oa_tuple_list = OrderAnalyser._get_matching_synapse_list(all_synapses_list=all_synapse_list,
+                                                                   order_to_match=order_to_match)
+        self.assertEquals(oa_tuple_list[0].synapse,
                           expected_result,
                           expected_result,
                           "Fail matching 'the expected synapse' from the complete synapse list and the order")
                           "Fail matching 'the expected synapse' from the complete synapse list and the order")
 
 
@@ -384,10 +387,14 @@ class TestOrderAnalyser(unittest.TestCase):
 
 
         expected_result = [synapse1,
         expected_result = [synapse1,
                            synapse2]
                            synapse2]
-        self.assertEquals(OrderAnalyser._get_matching_synapse_list(all_synapses_list=all_synapse_list,
-                                                                   order_to_match=order_to_match),
-                          expected_result,
-                          "Fail 'Multiple Matching synapses' from the complete synapse list and the order")
+        oa_tuple_list = OrderAnalyser._get_matching_synapse_list(all_synapses_list=all_synapse_list,
+                                                                 order_to_match=order_to_match)
+        self.assertEquals(oa_tuple_list[0].synapse,
+                          expected_result[0],
+                          "Fail 'Multiple Matching synapses' from the complete synapse list and the order (first element)")
+        self.assertEquals(oa_tuple_list[1].synapse,
+                          expected_result[1],
+                          "Fail 'Multiple Matching synapses' from the complete synapse list and the order (second element)")
 
 
         # matching no synapses
         # matching no synapses
         order_to_match = "this is not the correct word"
         order_to_match = "this is not the correct word"
@@ -413,10 +420,15 @@ class TestOrderAnalyser(unittest.TestCase):
         expected_result = [synapse1,
         expected_result = [synapse1,
                            synapse2]
                            synapse2]
 
 
-        self.assertEquals(OrderAnalyser._get_matching_synapse_list(all_synapses_list=all_synapse_list,
-                                                                   order_to_match=order_to_match),
-                          expected_result,
-                          "Fail matching 'synapse with all key worlds' from the complete synapse list and the order")
+        oa_tuple_list = OrderAnalyser._get_matching_synapse_list(all_synapses_list=all_synapse_list,
+                                                                 order_to_match=order_to_match)
+
+        self.assertEquals(oa_tuple_list[0].synapse,
+                          expected_result[0],
+                          "Fail matching 'synapse with all key worlds' from the complete synapse list and the order (first element)")
+        self.assertEquals(oa_tuple_list[1].synapse,
+                          expected_result[1],
+                          "Fail matching 'synapse with all key worlds' from the complete synapse list and the order (second element)")
 
 
     def test_get_params_from_order(self):
     def test_get_params_from_order(self):
 
 
@@ -537,11 +549,16 @@ class TestOrderAnalyser(unittest.TestCase):
         st = Settings()
         st = Settings()
         # Find synapse
         # Find synapse
         order = "this is the sentence"
         order = "this is the sentence"
-        expected_result = [synapse1]
-        self.assertEquals(OrderAnalyser._find_synapse_to_run(brain=br,settings=st, order=order),
+        expected_result = synapse1
+        oa_tuple_list = OrderAnalyser._find_synapse_to_run(brain=br,settings=st, order=order)
+        self.assertEquals(oa_tuple_list[0].synapse,
                           expected_result,
                           expected_result,
                           "Fail to run the proper synapse matching the order")
                           "Fail to run the proper synapse matching the order")
 
 
+        expected_result = signal1.sentence
+        self.assertEquals(oa_tuple_list[0].order,
+                        expected_result,
+                        "Fail to run the proper synapse matching the order")
         # No Default synapse
         # No Default synapse
         order = "No default synapse"
         order = "No default synapse"
         expected_result = []
         expected_result = []
@@ -552,8 +569,9 @@ class TestOrderAnalyser(unittest.TestCase):
         # Default synapse
         # Default synapse
         st = Settings(default_synapse="Synapse2")
         st = Settings(default_synapse="Synapse2")
         order = "default synapse"
         order = "default synapse"
-        expected_result = [synapse2]
-        self.assertEquals(OrderAnalyser._find_synapse_to_run(brain=br, settings=st, order=order),
+        expected_result = synapse2
+        oa_tuple_list = OrderAnalyser._find_synapse_to_run(brain=br, settings=st, order=order)
+        self.assertEquals(oa_tuple_list[0].synapse,
                           expected_result,
                           expected_result,
                           "Fail to run the default synapse")
                           "Fail to run the default synapse")
 
 

+ 4 - 1
kalliope/core/NeuronLauncher.py

@@ -23,7 +23,10 @@ class NeuronLauncher:
         logger.debug("Run plugin \"%s\" with parameters %s" % (neuron.name, neuron.parameters))
         logger.debug("Run plugin \"%s\" with parameters %s" % (neuron.name, neuron.parameters))
         sl = SettingLoader()
         sl = SettingLoader()
         settings = sl.settings
         settings = sl.settings
+        neuron_folder = None
+        if settings.resources:
+            neuron_folder = settings.resources.neuron_folder
         return Utils.get_dynamic_class_instantiation(package_name="neurons",
         return Utils.get_dynamic_class_instantiation(package_name="neurons",
                                                      module_name=neuron.name,
                                                      module_name=neuron.name,
                                                      parameters=neuron.parameters,
                                                      parameters=neuron.parameters,
-                                                     resources_dir=settings.resources.neuron_folder)
+                                                     resources_dir=neuron_folder)

+ 42 - 21
kalliope/core/OrderAnalyser.py

@@ -1,5 +1,6 @@
 # coding: utf8
 # coding: utf8
 import re
 import re
+import collections
 from collections import Counter
 from collections import Counter
 
 
 from kalliope.core.Utils.Utils import Utils
 from kalliope.core.Utils.Utils import Utils
@@ -17,6 +18,7 @@ class OrderAnalyser:
     """
     """
     This Class is used to compare the incoming message to the Signal/Order sentences.
     This Class is used to compare the incoming message to the Signal/Order sentences.
     """
     """
+
     def __init__(self, order, brain=None):
     def __init__(self, order, brain=None):
         """
         """
         Class used to load brain and run neuron attached to the received order
         Class used to load brain and run neuron attached to the received order
@@ -33,43 +35,54 @@ class OrderAnalyser:
 
 
     def start(self, synapses_to_run=None, external_order=None):
     def start(self, synapses_to_run=None, external_order=None):
         """
         """
-        This method matches the incoming messages to the signals/order sentences provided in the Brain
+        This method matches the incoming messages to the signals/order sentences provided in the Brain.
+
+        Note: we use named tuples:
+        tuple_synapse_order = collections.namedtuple('tuple_synapse_matchingOrder',['synapse', 'order'])
         """
         """
 
 
+        synapse_order_tuple = collections.namedtuple('tuple_synapse_matchingOrder', ['synapse', 'order'])
+        synapses_order_tuple_list = list()
+
+        if synapses_to_run is not None and external_order is not None:
+            for synapse in synapses_to_run:
+                synapses_order_tuple_list.append(synapse_order_tuple(synapse=synapse,
+                                                                     order=external_order))
+
         # if list of synapse is not provided, let's find one
         # if list of synapse is not provided, let's find one
-        if synapses_to_run is None and external_order is None:
+        else:  # synapses_to_run is None or external_order is None:
             # create a dict of synapses that have been launched
             # create a dict of synapses that have been launched
             logger.debug("[orderAnalyser.start]-> No Synapse provided, let's find one")
             logger.debug("[orderAnalyser.start]-> No Synapse provided, let's find one")
-            synapses_to_run = self._find_synapse_to_run(brain=self.brain,
-                                                        settings=self.settings,
-                                                        order=self.order)
+            synapses_order_tuple_list = self._find_synapse_to_run(brain=self.brain,
+                                                                  settings=self.settings,
+                                                                  order=self.order)
 
 
         # retrieve params
         # retrieve params
-        for synapse in synapses_to_run:
-            # If no external orders has been provided then run signals sentences
-            if external_order is None:
-                logger.debug("[orderAnalyser.start]-> No external order provided, run the signals from the synapse")
-                for signal in synapse.signals:
-                    params = self._get_params_from_order(signal.sentence, self.order)
-            else:
-                logger.debug("[orderAnalyser.start]-> provided external order")
-                params = self._get_params_from_order(external_order, self.order)
+        synapses_launched = list()
+        for tuple in synapses_order_tuple_list:
+            logger.debug("[orderAnalyser.start]-> Grab the params")
+            params = self._get_params_from_order(tuple.order, self.order)
 
 
             # Start a neuron list with params
             # Start a neuron list with params
-            self._start_list_neurons(list_neurons=synapse.neurons,
+            self._start_list_neurons(list_neurons=tuple.synapse.neurons,
                                      params=params)
                                      params=params)
+            synapses_launched.append(tuple.synapse)
 
 
         # return the list of launched synapse
         # return the list of launched synapse
-        return synapses_to_run
+        return synapses_launched
 
 
     @classmethod
     @classmethod
     def _find_synapse_to_run(cls, brain, settings, order):
     def _find_synapse_to_run(cls, brain, settings, order):
         """
         """
-        Find the list of the synapse matching the 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 brain: the brain
         :param settings: the settings
         :param settings: the settings
         :param order: the provided order to match
         :param order: the provided order to match
-        :return: the list of synapses launched
+        :return: the list of synapses launched (named tuples)
         """
         """
 
 
         synapse_to_run = cls._get_matching_synapse_list(brain.synapses, order)
         synapse_to_run = cls._get_matching_synapse_list(brain.synapses, order)
@@ -83,7 +96,10 @@ class OrderAnalyser:
                 if default_synapse is not None:
                 if default_synapse is not None:
                     logger.debug("Default synapse found %s" % default_synapse)
                     logger.debug("Default synapse found %s" % default_synapse)
                     Utils.print_info("Default synapse found: %s, running it" % default_synapse.name)
                     Utils.print_info("Default synapse found: %s, running it" % default_synapse.name)
-                    synapse_to_run.append(default_synapse)
+                    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
         return synapse_to_run
 
 
@@ -92,17 +108,22 @@ class OrderAnalyser:
         """
         """
         Class method to return all the matching synapses with the order from the complete of synapses.
         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 all_synapses_list: the complete list of all synapses
         :param order_to_match: the order to match
         :param order_to_match: the order to match
         :type order_to_match: str
         :type order_to_match: str
-        :return: the list of matching synapses
+        :return: the list of matching synapses (named tuples)
         """
         """
+        tuple_synapse_order = collections.namedtuple('tuple_synapse_matchingOrder', ['synapse', 'order'])
         matching_synapses_list = list()
         matching_synapses_list = list()
         for synapse in all_synapses_list:
         for synapse in all_synapses_list:
             for signal in synapse.signals:
             for signal in synapse.signals:
                 if type(signal) == Order:
                 if type(signal) == Order:
                     if cls.spelt_order_match_brain_order_via_table(signal.sentence, order_to_match):
                     if cls.spelt_order_match_brain_order_via_table(signal.sentence, order_to_match):
-                        matching_synapses_list.append(synapse)
+                        matching_synapses_list.append(tuple_synapse_order(synapse=synapse,
+                                                                                  order=signal.sentence))
                         logger.debug("Order found! Run neurons: %s" % synapse.neurons)
                         logger.debug("Order found! Run neurons: %s" % synapse.neurons)
                         Utils.print_success("Order matched in the brain. Running synapse \"%s\"" % synapse.name)
                         Utils.print_success("Order matched in the brain. Running synapse \"%s\"" % synapse.name)
         return matching_synapses_list
         return matching_synapses_list