Преглед на файлове

review synapse launcher

nico преди 8 години
родител
ревизия
624670a4c1

+ 2 - 2
Tests/test_launchers.py

@@ -70,7 +70,7 @@ class TestLaunchers(unittest.TestCase):
         sl.settings.resources = r
         with mock.patch("kalliope.core.Utils.get_dynamic_class_instantiation") as mock_get_class_instantiation:
             # Success
-            SynapseLauncher.start_synapse("Synapse1", brain=br)
+            SynapseLauncher.start_synapse_by_name("Synapse1", brain=br)
 
             calls = [mock.call(package_name="neurons",
                                module_name=neuron1.name,
@@ -85,7 +85,7 @@ class TestLaunchers(unittest.TestCase):
 
             # Fail
             with self.assertRaises(SynapseNameNotFound):
-                SynapseLauncher.start_synapse("Synapse4", brain=br)
+                SynapseLauncher.start_synapse_by_name("Synapse4", brain=br)
 
     def test_run_synapse(self):
         """

+ 63 - 32
Tests/test_synapse_launcher.py

@@ -2,7 +2,9 @@ import unittest
 
 import mock
 
+from kalliope.core import LIFOBuffer
 from kalliope.core.Models import Brain
+from kalliope.core.Models.MatchedSynapse import MatchedSynapse
 from kalliope.core.Models.Settings import Settings
 from kalliope.core.SynapseLauncher import SynapseLauncher, SynapseNameNotFound
 
@@ -38,43 +40,72 @@ class TestSynapseLauncher(unittest.TestCase):
         self.brain_test = Brain(synapses=all_synapse_list)
         self.settings_test = Settings(default_synapse="Synapse3")
 
-    def test_run_matching_synapse_or_default(self):
+        # clean the LiFO
+        LIFOBuffer.lifo_list = list()
 
+    def test_start_synapse_by_name(self):
+        # existing synapse in the brain
+        with mock.patch("kalliope.core.LIFOBuffer.execute"):
+            should_be_created_matched_synapse = MatchedSynapse(matched_synapse=self.synapse1)
+            SynapseLauncher.start_synapse_by_name("Synapse1", brain=self.brain_test)
+            # 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)
+
+    def test_run_matching_synapse_from_order(self):
+        # ------------------
         # test_match_synapse1
-        with mock.patch("kalliope.core.NeuronLauncher.start_neuron_list"):
+        # ------------------
+        with mock.patch("kalliope.core.LIFOBuffer.execute"):
             order_to_match = "this is the sentence"
-            expected_result = [self.synapse1]
 
-            self.assertEqual(expected_result,
-                             SynapseLauncher.run_matching_synapse_or_default(order_to_match,
-                                                                             brain=self.brain_test,
-                                                                             settings=self.settings_test))
+            should_be_created_matched_synapse = MatchedSynapse(matched_synapse=self.synapse1,
+                                                               user_order=order_to_match,
+                                                               matched_order="this is the sentence")
+            expected_result = [[should_be_created_matched_synapse]]
+            SynapseLauncher.run_matching_synapse_from_order(order_to_match,
+                                                            brain=self.brain_test,
+                                                            settings=self.settings_test)
 
+            self.assertEqual(expected_result, LIFOBuffer.lifo_list)
+
+        # -------------------------
         # test_match_synapse1_and_2
-        with mock.patch("kalliope.core.NeuronLauncher.start_neuron_list"):
+        # -------------------------
+        # clean LIFO
+        LIFOBuffer.lifo_list = list()
+        with mock.patch("kalliope.core.LIFOBuffer.execute"):
             order_to_match = "this is the second sentence"
-            expected_result = [self.synapse1, self.synapse2]
-
-            self.assertEqual(expected_result,
-                             SynapseLauncher.run_matching_synapse_or_default(order_to_match,
-                                                                             brain=self.brain_test,
-                                                                             settings=self.settings_test))
-
+            should_be_created_matched_synapse1 = MatchedSynapse(matched_synapse=self.synapse1,
+                                                                user_order=order_to_match,
+                                                                matched_order="this is the sentence")
+            should_be_created_matched_synapse2 = MatchedSynapse(matched_synapse=self.synapse2,
+                                                                user_order=order_to_match,
+                                                                matched_order="this is the second sentence")
+
+            expected_result = [[should_be_created_matched_synapse1, should_be_created_matched_synapse2]]
+            SynapseLauncher.run_matching_synapse_from_order(order_to_match,
+                                                            brain=self.brain_test,
+                                                            settings=self.settings_test)
+            self.assertEqual(expected_result, LIFOBuffer.lifo_list)
+
+        # -------------------------
         # test_match_default_synapse
-        with mock.patch("kalliope.core.NeuronLauncher.start_neuron"):
-            order_to_match = "this is an invalid order"
-            expected_result = [self.synapse3]
-
-            self.assertEqual(expected_result,
-                             SynapseLauncher.run_matching_synapse_or_default(order_to_match,
-                                                                             brain=self.brain_test,
-                                                                             settings=self.settings_test))
-
-    def test_start_synapse(self):
-        with mock.patch("kalliope.core.NeuronLauncher.start_neuron"):
-            expected_result = self.synapse1
-            self.assertEqual(expected_result,
-                             SynapseLauncher.start_synapse("Synapse1", brain=self.brain_test))
-
-        with self.assertRaises(SynapseNameNotFound):
-            SynapseLauncher.start_synapse(name="no_do_exist", brain=self.brain_test)
+        # -------------------------
+        # clean LIFO
+        # LIFOBuffer.lifo_list = list()
+        # with mock.patch("kalliope.core.LIFOBuffer.execute"):
+        #     order_to_match = "not existing sentence"
+        #     should_be_created_matched_synapse = MatchedSynapse(matched_synapse=self.synapse3,
+        #                                                        user_order=order_to_match,
+        #                                                        matched_order=None)
+        #
+        #     expected_result = [[should_be_created_matched_synapse]]
+        #     SynapseLauncher.run_matching_synapse_from_order(order_to_match,
+        #                                                     brain=self.brain_test,
+        #                                                     settings=self.settings_test)
+        #     self.assertEqual(expected_result, LIFOBuffer.lifo_list)

+ 2 - 2
kalliope/__init__.py

@@ -120,8 +120,8 @@ def main():
 
         # user set a synapse to start
         if args.run_synapse is not None:
-            SynapseLauncher.start_synapse(args.run_synapse,
-                                          brain=brain)
+            SynapseLauncher.start_synapse_by_name(args.run_synapse,
+                                                  brain=brain)
 
         if args.run_order is not None:
             SynapseLauncher.run_matching_synapse_from_order(args.run_order,

+ 1 - 1
kalliope/core/EventManager.py

@@ -46,4 +46,4 @@ class EventManager(object):
         # get a brain
         brain_loader = BrainLoader()
         brain = brain_loader.brain
-        SynapseLauncher.start_synapse(synapse_name, brain=brain)
+        SynapseLauncher.start_synapse_by_name(synapse_name, brain=brain)

+ 7 - 0
kalliope/core/Models/MatchedSynapse.py

@@ -51,3 +51,10 @@ class MatchedSynapse(object):
             'neuron_module_list': [e.serialize() for e in self.neuron_module_list]
         }
 
+    def __eq__(self, other):
+        """
+        This is used to compare 2 objects
+        :param other:
+        :return:
+        """
+        return self.__dict__ == other.__dict__

+ 1 - 1
kalliope/core/ShellGui.py

@@ -193,5 +193,5 @@ class ShellGui:
             self.show_main_menu()
         if code == self.d.OK:
             logger.debug("Run synapse from GUI: %s" % tag)
-            SynapseLauncher.start_synapse(tag, brain=self.brain)
+            SynapseLauncher.start_synapse_by_name(tag, brain=self.brain)
             self.show_synapses_test_menu()

+ 11 - 19
kalliope/core/SynapseLauncher.py

@@ -22,37 +22,29 @@ class SynapseNameNotFound(Exception):
 
 class SynapseLauncher(object):
 
-    def __init__(self):
-        pass
-
     @classmethod
-    def start_synapse(cls, name, brain=None):
+    def start_synapse_by_name(cls, name, brain=None):
         """
         Start a synapse by it's name
         :param name: Name (Unique ID) of the synapse to launch
         :param brain: Brain instance
         """
-
+        logger.debug("[SynapseLauncher] start_synapse_by_name called with synapse name: %s " % name)
         # check if we have found and launched the synapse
         synapse = brain.get_synapse_by_name(synapse_name=name)
 
         if not synapse:
             raise SynapseNameNotFound("The synapse name \"%s\" does not exist in the brain file" % name)
         else:
-            return cls._run_synapse(synapse=synapse)
-
-    @classmethod
-    def _run_synapse(cls, synapse):
-        """
-        Start all neurons in the synapse
-        :param synapse: Synapse for which we run neurons
-        :return:
-        """
-        for neuron in synapse.neurons:
-            instantiated_neuron = NeuronLauncher.start_neuron(neuron)
-            # add the generated message to the synapse
-            synapse.answers.append(instantiated_neuron.tts_message)
-        return synapse
+            # get our singleton LIFO
+            lifo_buffer = LIFOBuffer()
+            list_synapse_to_process = list()
+            new_matching_synapse = MatchedSynapse(matched_synapse=synapse,
+                                                  matched_order=None,
+                                                  user_order=None)
+            list_synapse_to_process.append(new_matching_synapse)
+            lifo_buffer.add_synapse_list_to_lifo(list_synapse_to_process)
+            return lifo_buffer.execute(is_api_call=True)
 
     @classmethod
     def run_matching_synapse_from_order(cls, order_to_process, brain, settings, is_api_call=False):

+ 1 - 3
kalliope/core/__init__.py

@@ -6,6 +6,4 @@ from kalliope.core.Utils import FileManager
 from kalliope.core.ResourcesManager import ResourcesManager
 from kalliope.core.NeuronLauncher import NeuronLauncher
 from kalliope.core.SynapseLauncher import SynapseLauncher
-
-
-
+from kalliope.core.LIFOBuffer import LIFOBuffer