Explorar el Código

[Review] Last Nazi code review for LIFO refacto

mostly typos, tests, PEP8 and refacto
monf hace 8 años
padre
commit
2aa95c148d

+ 4 - 4
Docs/rest_api.md

@@ -188,7 +188,7 @@ Output example if the order have matched and so launched synapses:
 }
 ```
 
-If the order haven't match any synapses it will try to run the default synapse if this lat exist in your settings:
+If the order haven't match any synapses it will try to run the default synapse if it exists in your settings:
 ```JSON
 {
   "matched_synapses": [
@@ -196,7 +196,7 @@ If the order haven't match any synapses it will try to run the default synapse i
       "matched_order": null,
       "neuron_module_list": [
         {
-          "generated_message": "Je n'ai pas compris vôtre ordre",
+          "generated_message": "Je n'ai pas compris votre ordre",
           "neuron_name": "Say"
         }
       ],
@@ -249,7 +249,7 @@ Output example if the order inside the audio have matched and so launched synaps
 }
 ```
 
-If the order haven't match any synapses it will try to run the default synapse if this lat exist in your settings:
+If the order haven't match any synapses it will try to run the default synapse if it exists in your settings:
 ```JSON
 {
   "matched_synapses": [
@@ -257,7 +257,7 @@ If the order haven't match any synapses it will try to run the default synapse i
       "matched_order": null,
       "neuron_module_list": [
         {
-          "generated_message": "Je n'ai pas compris vôtre ordre",
+          "generated_message": "Je n'ai pas compris votre ordre",
           "neuron_name": "Say"
         }
       ],

+ 159 - 43
Tests/test_lifo_buffer.py

@@ -30,11 +30,11 @@ class TestLIFOBuffer(unittest.TestCase):
     def test_execute(self):
         """
         In this test the brain contains a neurotransmitter
-        :return: 
         """
         # --------------------------------------
         # Test 1. The user answers correctly to all neurotransmitter
         # --------------------------------------
+
         # we suppose that the first synapse has matched the first synapse
         synapse = BrainLoader().brain.get_synapse_by_name("synapse1")
         order = "enter in synapse 1"
@@ -50,10 +50,23 @@ class TestLIFOBuffer(unittest.TestCase):
 
             response = self.lifo_buffer.execute(is_api_call=True)
 
-            expected_result = {'status': 'waiting_for_answer', 'matched_synapses': [
-                {'matched_order': 'enter in synapse 1', 'neuron_module_list':
-                    [{'neuron_name': 'Say', 'generated_message': 'question in synapse 1'}],
-                 'synapse_name': 'synapse1'}], 'user_order': 'enter in synapse 1'}
+            expected_result = {
+                'status': 'waiting_for_answer',
+                'matched_synapses': [
+                    {
+                        'matched_order': 'enter in synapse 1',
+                        'neuron_module_list':
+                            [
+                                {
+                                    'neuron_name': 'Say',
+                                    'generated_message': 'question in synapse 1'
+                                }
+                            ],
+                        'synapse_name': 'synapse1'
+                    }
+                ],
+                'user_order': 'enter in synapse 1'
+            }
 
             self.assertEqual(response, expected_result)
 
@@ -61,39 +74,97 @@ class TestLIFOBuffer(unittest.TestCase):
             answer = "answer synapse1"
             response = self.lifo_buffer.execute(answer=answer,
                                                 is_api_call=True)
-            expected_result = {'status': 'waiting_for_answer', 'matched_synapses': [
-                {'matched_order': 'enter in synapse 1',
-                 'neuron_module_list': [{'neuron_name': 'Say',
-                                         'generated_message': 'question in synapse 1'},
-                                        {'neuron_name': 'Neurotransmitter', 'generated_message': None}],
-                 'synapse_name': 'synapse1'},
-                {'matched_order': 'answer synapse1', 'neuron_module_list': [
-                    {'neuron_name': 'Say', 'generated_message': 'enter synapse 2'}],
-                 'synapse_name': 'synapse2'}], 'user_order': None}
+            expected_result = {
+                'status': 'waiting_for_answer',
+                'matched_synapses': [
+                    {
+                        'matched_order': 'enter in synapse 1',
+                        'neuron_module_list': [
+                            {
+                                'neuron_name': 'Say',
+                                 'generated_message': 'question in synapse 1'
+                            },
+                            {
+                                'neuron_name': 'Neurotransmitter',
+                                'generated_message': None
+                            }
+                        ],
+                        'synapse_name': 'synapse1'
+                    },
+                    {
+                        'matched_order': 'answer synapse1',
+                        'neuron_module_list': [
+                            {
+                                'neuron_name': 'Say',
+                                'generated_message': 'enter synapse 2'
+                            }
+                        ],
+                    'synapse_name': 'synapse2'
+                    }
+                ],
+                'user_order': None
+            }
             self.assertEqual(response, expected_result)
 
             # give the last answer
             answer = "synapse5"
             response = self.lifo_buffer.execute(answer=answer,
                                                 is_api_call=True)
-            expected_result = {'status': 'complete', 'matched_synapses': [
-                {'matched_order': 'answer synapse1', 'neuron_module_list': [
-                    {'neuron_name': 'Say', 'generated_message': 'enter synapse 2'},
-                    {'neuron_name': 'Neurotransmitter', 'generated_message': None}],
-                 'synapse_name': 'synapse2'}, {'matched_order': 'synapse5', 'neuron_module_list': [
-                    {'neuron_name': 'Say', 'generated_message': 'execution of synapse 5'}],
-                                               'synapse_name': 'synapse5'},
-                {'matched_order': 'enter in synapse 1', 'neuron_module_list':
-                    [{'neuron_name': 'Say', 'generated_message': 'question in synapse 1'},
-                     {'neuron_name': 'Neurotransmitter', 'generated_message': None},
-                     {'neuron_name': 'Say', 'generated_message': 'last neuron in synapse 1'}],
-                 'synapse_name': 'synapse1'}], 'user_order': None}
+            expected_result = {
+                'status': 'complete',
+                'matched_synapses': [
+                    {
+                        'matched_order': 'answer synapse1',
+                        'neuron_module_list': [
+                            {
+                                'neuron_name': 'Say',
+                                'generated_message': 'enter synapse 2'
+                            },
+                            {
+                                'neuron_name': 'Neurotransmitter',
+                                'generated_message': None
+                            }
+                        ],
+                        'synapse_name': 'synapse2'
+                    },
+                    {
+                        'matched_order': 'synapse5',
+                        'neuron_module_list': [
+                            {
+                                'neuron_name': 'Say',
+                                'generated_message': 'execution of synapse 5'
+                            }
+                        ],
+                        'synapse_name': 'synapse5'
+                    },
+                    {
+                        'matched_order': 'enter in synapse 1',
+                        'neuron_module_list':[
+                            {
+                                'neuron_name': 'Say',
+                                'generated_message': 'question in synapse 1'
+                            },
+                            {
+                                'neuron_name': 'Neurotransmitter',
+                                'generated_message': None
+                            },
+                            {
+                                'neuron_name': 'Say',
+                                'generated_message': 'last neuron in synapse 1'
+                            }
+                        ],
+                        'synapse_name': 'synapse1'
+                    }
+                ],
+                'user_order': None
+            }
 
             self.assertEqual(response, expected_result)
 
         # --------------------------------------
         # Test 2. The user doesn't answered correctly to the first neurotransmitter
         # --------------------------------------
+
         # we suppose that the first synapse has matched the first synapse
         synapse = BrainLoader().brain.get_synapse_by_name("synapse1")
         order = "enter in synapse 1"
@@ -112,18 +183,40 @@ class TestLIFOBuffer(unittest.TestCase):
             wrong_answer = "wrong answer"
             response = self.lifo_buffer.execute(answer=wrong_answer, is_api_call=True)
 
-            expected_result = {'status': 'complete',
-                               'matched_synapses': [
-                                   {'matched_order': 'enter in synapse 1',
-                                    'neuron_module_list': [
-                                        {'neuron_name': 'Say', 'generated_message': 'question in synapse 1'},
-                                        {'neuron_name': 'Neurotransmitter', 'generated_message': None},
-                                        {'neuron_name': 'Say', 'generated_message': 'last neuron in synapse 1'}],
-                                    'synapse_name': 'synapse1'},
-                                   {'matched_order': None, 'neuron_module_list': [
-                                       {'neuron_name': 'Say',
-                                        'generated_message': 'not understood'}],
-                                    'synapse_name': 'synapse4'}], 'user_order': None}
+            expected_result = {
+                'status': 'complete',
+                'matched_synapses': [
+                    {
+                        'matched_order': 'enter in synapse 1',
+                        'neuron_module_list': [
+                            {
+                                'neuron_name': 'Say',
+                                'generated_message': 'question in synapse 1'
+                            },
+                            {
+                                'neuron_name': 'Neurotransmitter',
+                                'generated_message': None
+                            },
+                            {
+                                'neuron_name': 'Say',
+                                'generated_message': 'last neuron in synapse 1'
+                            }
+                        ],
+                        'synapse_name': 'synapse1'
+                    },
+                    {
+                        'matched_order': None,
+                        'neuron_module_list': [
+                            {
+                                'neuron_name': 'Say',
+                                'generated_message': 'not understood'
+                            }
+                        ],
+                        'synapse_name': 'synapse4'
+                    }
+                ],
+                'user_order': None
+            }
 
             self.assertEqual(response, expected_result)
 
@@ -138,11 +231,18 @@ class TestLIFOBuffer(unittest.TestCase):
             # fist call to enter in the neurotransmitter
             response = self.lifo_buffer.execute(is_api_call=True)
 
-            expected_result = {'status': None, 'matched_synapses': [], 'user_order': 'this is an order'}
+            expected_result = {
+                'status': None,
+                'matched_synapses': [],
+                'user_order': 'this is an order'
+            }
 
             self.assertEqual(response, expected_result)
 
     def test_add_synapse_list_to_lifo(self):
+        """
+        Testing to add a synapse to the lifo
+        """
         synapse = BrainLoader().brain.get_synapse_by_name("synapse1")
         order = "enter in synapse 1"
         matched_synapse = MatchedSynapse(matched_synapse=synapse,
@@ -155,6 +255,9 @@ class TestLIFOBuffer(unittest.TestCase):
         self.assertEqual(self.lifo_buffer.lifo_list, [list_matched_synapse])
 
     def test_clean(self):
+        """
+        Test the Cleaning of the matched synapses list
+        """
         synapse = BrainLoader().brain.get_synapse_by_name("synapse1")
         order = "enter in synapse 1"
         matched_synapse = MatchedSynapse(matched_synapse=synapse,
@@ -168,6 +271,9 @@ class TestLIFOBuffer(unittest.TestCase):
         self.assertEqual(0, len(self.lifo_buffer.lifo_list))
 
     def test_return_serialized_api_response(self):
+        """
+        Test the serialization
+        """
         self.lifo_buffer.clean()
         self.lifo_buffer.execute(is_api_call=True)
         expected_result = {'status': None, 'matched_synapses': [], 'user_order': None}
@@ -175,6 +281,9 @@ class TestLIFOBuffer(unittest.TestCase):
         self.assertEqual(expected_result, response)
 
     def test_process_synapse_list(self):
+        """
+        Testing the neuron list from a synapse
+        """
         synapse = BrainLoader().brain.get_synapse_by_name("synapse1")
         order = "enter in synapse 1"
         matched_synapse = MatchedSynapse(matched_synapse=synapse,
@@ -185,10 +294,17 @@ class TestLIFOBuffer(unittest.TestCase):
 
         with mock.patch("kalliope.core.LIFOBuffer._process_neuron_list"):
             self.lifo_buffer._process_synapse_list(list_matched_synapse)
-            expected_response = {'status': None, 'matched_synapses': [
-                {'matched_order': 'enter in synapse 1',
-                 'neuron_module_list': [], 'synapse_name': 'synapse1'}],
-                                 'user_order': None}
+            expected_response = {
+                'status': None,
+                'matched_synapses': [
+                    {
+                        'matched_order': 'enter in synapse 1',
+                        'neuron_module_list': [],
+                        'synapse_name': 'synapse1'
+                    }
+                ],
+                'user_order': None
+            }
             self.assertEqual(expected_response, self.lifo_buffer.api_response.serialize())
             self.assertEqual(0, len(self.lifo_buffer.lifo_list))
 

+ 101 - 34
Tests/test_models.py

@@ -62,12 +62,18 @@ class TestModels(unittest.TestCase):
         api_response.user_order = user_order
         api_response.list_processed_matched_synapse = [self.matched_synapse]
 
-        expected_result_serialize = {'status': None,
-                                     'matched_synapses':
-                                         [{'matched_order': 'user order',
-                                           'neuron_module_list': [],
-                                           'synapse_name': 'Synapse1'}],
-                                     'user_order': 'user order'}
+        expected_result_serialize = {
+            'status': None,
+            'matched_synapses':
+                [
+                    {
+                        'matched_order': 'user order',
+                        'neuron_module_list': [],
+                        'synapse_name': 'Synapse1'
+                    }
+                ],
+                'user_order': 'user order'
+        }
 
         self.assertEqual(expected_result_serialize, api_response.serialize())
 
@@ -100,9 +106,13 @@ class TestModels(unittest.TestCase):
         dna3 = Dna(name="dna1", module_type="neuron", author="kalliope",
                    kalliope_supported_version="0.4.4", tags="test")
 
-
-        expected_result_serialize = {'kalliope_supported_version': '0.4.4', 'tags': 'test',
-                                     'type': 'neuron', 'name': 'dna1', 'author': 'kalliope'}
+        expected_result_serialize = {
+            'kalliope_supported_version': '0.4.4',
+            'tags': 'test',
+            'type': 'neuron',
+            'name': 'dna1',
+            'author': 'kalliope'
+        }
         expected_result_str = "{'kalliope_supported_version': '0.4.4', 'tags': 'test', 'type':" \
                               " 'neuron', 'name': 'dna1', 'author': 'kalliope'}"
 
@@ -123,8 +133,18 @@ class TestModels(unittest.TestCase):
         event3 = Event(year=2017, month=12, day=31, week=53, day_of_week=2,
                        hour=8, minute=30, second=0)
 
-        expected_result_serialize = {'event': {'week': 53, 'second': 0, 'minute': 30, 'hour': 8,
-                                               'year': 2017, 'day': 31, 'day_of_week': 2, 'month': 12}}
+        expected_result_serialize = {
+            'event': {
+                'week': 53,
+                'second': 0,
+                'minute': 30,
+                'hour': 8,
+                'year': 2017,
+                'day': 31,
+                'day_of_week': 2,
+                'month': 12
+            }
+        }
         expected_result_str = "{'event': {'week': 53, 'second': 0, 'minute': 30, 'hour': 8, " \
                               "'year': 2017, 'day': 31, 'day_of_week': 2, 'month': 12}}"
 
@@ -140,8 +160,11 @@ class TestModels(unittest.TestCase):
         matched_synapse2 = MatchedSynapse(matched_synapse=self.synapse2, matched_order=user_order)
         matched_synapse3 = MatchedSynapse(matched_synapse=self.synapse1, matched_order=user_order)
 
-        expected_result_serialize = {'matched_order': 'user order', 'neuron_module_list': [],
-                                     'synapse_name': 'Synapse1'}
+        expected_result_serialize = {
+            'matched_order': 'user order',
+            'neuron_module_list': [],
+            'synapse_name': 'Synapse1'
+        }
         expected_result_str = "{'matched_order': 'user order', 'neuron_module_list': [], 'synapse_name': 'Synapse1'}"
 
         self.assertEqual(expected_result_serialize, matched_synapse1.serialize())
@@ -226,8 +249,12 @@ class TestModels(unittest.TestCase):
         resource3 = Resources(neuron_folder="/path/neuron", stt_folder="/path/stt",
                               tts_folder="/path/tts", trigger_folder="/path/trigger")
 
-        expected_result_serialize = {'tts_folder': '/path/tts', 'neuron_folder': '/path/neuron',
-                                     'stt_folder': '/path/stt', 'trigger_folder': '/path/trigger'}
+        expected_result_serialize = {
+            'tts_folder': '/path/tts',
+            'neuron_folder': '/path/neuron',
+            'stt_folder': '/path/stt',
+            'trigger_folder': '/path/trigger'
+        }
         expected_result_str = "{'tts_folder': '/path/tts', 'neuron_folder': '/path/neuron', " \
                               "'stt_folder': '/path/stt', 'trigger_folder': '/path/trigger'}"
 
@@ -248,12 +275,14 @@ class TestModels(unittest.TestCase):
         rest_api3 = RestAPI(password_protected=True, login="admin", password="password", active=True,
                             port=5000, allowed_cors_origin="*")
 
-        expected_result_serialize = {'password_protected': True,
-                                     'port': 5000,
-                                     'active': True,
-                                     'allowed_cors_origin': '*',
-                                     'password': 'password',
-                                     'login': 'admin'}
+        expected_result_serialize = {
+            'password_protected': True,
+            'port': 5000,
+            'active': True,
+            'allowed_cors_origin': '*',
+            'password': 'password',
+            'login': 'admin'
+        }
         expected_result_str = "{'password_protected': True, 'port': 5000, 'active': True, 'allowed_cors_origin': '*', " \
                               "'password': 'password', 'login': 'admin'}"
 
@@ -319,13 +348,34 @@ class TestModels(unittest.TestCase):
                                 resources=None,
                                 variables={"key1": "val1"})
 
-            expected_result_serialize = {'default_synapse': 'default_synapse', 'default_tts_name': 'pico2wav',
-             'rest_api': {'password_protected': True, 'port': 5000, 'active': True, 'allowed_cors_origin': '*',
-                          'password': 'password', 'login': 'admin'}, 'play_on_ready_notification': False,
-             'default_stt_name': 'google', 'kalliope_version': '0.4.4b', 'random_wake_up_sounds': None,
-             'on_ready_answers': None, 'default_trigger_name': 'swoyboy', 'cache_path': '/tmp/kalliope',
-             'stts': ['stts'], 'machine': 'pumpkins', 'random_wake_up_answers': ['yes'], 'on_ready_sounds': None,
-             'ttss': ['ttts'], 'variables': {'key1': 'val1'}, 'resources': None, 'triggers': ['snowboy']}
+            expected_result_serialize = {
+                'default_synapse': 'default_synapse',
+                'default_tts_name': 'pico2wav',
+                'rest_api':
+                    {
+                        'password_protected': True,
+                        'port': 5000,
+                        'active': True,
+                        'allowed_cors_origin': '*',
+                        'password': 'password',
+                        'login': 'admin'
+                    },
+                'play_on_ready_notification': False,
+                'default_stt_name': 'google',
+                'kalliope_version': '0.4.4b',
+                'random_wake_up_sounds': None,
+                'on_ready_answers': None,
+                'default_trigger_name': 'swoyboy',
+                'cache_path': '/tmp/kalliope',
+                'stts': ['stts'],
+                'machine': 'pumpkins',
+                'random_wake_up_answers': ['yes'],
+                'on_ready_sounds': None,
+                'ttss': ['ttts'],
+                'variables': {'key1': 'val1'},
+                'resources': None,
+                'triggers': ['snowboy']
+            }
 
             expected_result_str = "{'default_synapse': 'default_synapse', 'default_tts_name': 'pico2wav', 'rest_api': " \
                                   "{'password_protected': True, 'port': 5000, 'active': True, 'allowed_cors_origin': " \
@@ -369,12 +419,29 @@ class TestModels(unittest.TestCase):
         synapse2 = Synapse(name="Synapse2", neurons=[neuron3, neuron4], signals=[signal2])
         synapse3 = Synapse(name="Synapse1", neurons=[neuron1, neuron2], signals=[signal1])
 
-        expected_result_serialize = {'signals': [{'order': 'this is the sentence'}],
-                                     'neurons': [{'name': 'neurone1',
-                                                  'parameters': {'var1': 'val1'}},
-                                                 {'name': 'neurone2', 'parameters':
-                                                     {'var2': 'val2'}}],
-                                     'name': 'Synapse1'}
+        expected_result_serialize = {
+            'signals': [
+                {
+                    'order': 'this is the sentence'
+                }
+            ],
+            'neurons': [
+                {
+                    'name': 'neurone1',
+                     'parameters': {
+                         'var1': 'val1'
+                     }
+                },
+                {
+                    'name': 'neurone2',
+                    'parameters':
+                        {
+                            'var2': 'val2'
+                        }
+                }
+            ],
+            'name': 'Synapse1'
+        }
 
         expected_result_str = "{'signals': [{'order': 'this is the sentence'}], 'neurons': [{'name': 'neurone1', " \
                               "'parameters': {'var1': 'val1'}}, {'name': 'neurone2', 'parameters': {'var2': " \

+ 12 - 6
Tests/test_rest_api.py

@@ -131,8 +131,6 @@ class TestRestAPI(LiveServerTestCase):
         # a lot of char ti process
         self.maxDiff = None
         self.assertEqual(response.status_code, 200)
-        # print response.get_data()
-        # print json.dumps(expected_content)
         self.assertEqual(json.dumps(expected_content), json.dumps(json.loads(response.get_data())))
 
     def test_get_one_synapse(self):
@@ -210,10 +208,18 @@ class TestRestAPI(LiveServerTestCase):
 
         expected_content = {'status': 'complete',
                             'matched_synapses':
-                                [{'matched_order': "test_order",
-                                  'neuron_module_list':
-                                      [{'generated_message': 'test message', 'neuron_name': 'Say'}],
-                                  'synapse_name': 'test'}],
+                                [
+                                    {
+                                        'matched_order': "test_order",
+                                        'neuron_module_list':
+                                            [
+                                                {
+                                                    'generated_message': 'test message', 'neuron_name': 'Say'
+                                                }
+                                            ],
+                                  'synapse_name': 'test'
+                                    }
+                                ],
                             'user_order': "test_order"
                             }
         self.assertEqual(json.dumps(expected_content), json.dumps(json.loads(result.get_data())))

+ 0 - 8
kalliope/core/ConfigurationManager/BrainLoader.py

@@ -87,7 +87,6 @@ class BrainLoader(object):
         for synapses_dict in dict_brain:
             if "includes" not in synapses_dict:     # we don't need to check includes as it's not a synapse
                 if ConfigurationChecker().check_synape_dict(synapses_dict):
-                    # print "synapses_dict ok"
                     name = synapses_dict["name"]
                     neurons = self._get_neurons(synapses_dict["neurons"], self.settings)
                     signals = self._get_signals(synapses_dict["signals"])
@@ -127,7 +126,6 @@ class BrainLoader(object):
         for neuron_dict in neurons_dict:
             if isinstance(neuron_dict, dict):
                 if ConfigurationChecker().check_neuron_dict(neuron_dict):
-                    # print "Neurons dict ok"
                     for neuron_name in neuron_dict:
 
                         name = neuron_name
@@ -164,11 +162,9 @@ class BrainLoader(object):
         .. seealso:: Event, Order
         .. warnings:: Class method and Private
         """
-        # print signals_dict
         signals = list()
         for signal_dict in signals_dict:
             if ConfigurationChecker().check_signal_dict(signal_dict):
-                # print "Signals dict ok"
                 event_or_order = cls._get_event_or_order_from_dict(signal_dict)
                 signals.append(event_or_order)
 
@@ -192,7 +188,6 @@ class BrainLoader(object):
         .. warnings:: Static method and Private
         """
         if 'event' in signal_or_event_dict:
-            # print "is event"
             event = signal_or_event_dict["event"]
             if ConfigurationChecker.check_event_dict(event):
                 return cls._get_event_object(event)
@@ -257,18 +252,15 @@ class BrainLoader(object):
         """
 
         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) or isinstance(parameter, int):
-            # print "parameter is string %s" % parameter
             if Utils.is_containing_bracket(parameter):
                 return cls._get_global_variable(sentence=parameter, settings=settings)
             return parameter

+ 0 - 4
kalliope/core/ConfigurationManager/SettingLoader.py

@@ -244,7 +244,6 @@ class SettingLoader(object):
         stts = list()
         for speechs_to_text_el in speechs_to_text_list:
             if isinstance(speechs_to_text_el, dict):
-                # print "Neurons dict ok"
                 for stt_name in speechs_to_text_el:
                     name = stt_name
                     parameters = speechs_to_text_el[name]
@@ -284,7 +283,6 @@ class SettingLoader(object):
         ttss = list()
         for text_to_speech_el in text_to_speech_list:
             if isinstance(text_to_speech_el, dict):
-                # print "Neurons dict ok"
                 for tts_name in text_to_speech_el:
                     name = tts_name
                     parameters = text_to_speech_el[name]
@@ -323,7 +321,6 @@ class SettingLoader(object):
         triggers = list()
         for trigger_el in triggers_list:
             if isinstance(trigger_el, dict):
-                # print "Neurons dict ok"
                 for trigger_name in trigger_el:
                     name = trigger_name
                     parameters = trigger_el[name]
@@ -458,7 +455,6 @@ class SettingLoader(object):
                      allowed_cors_origin = rest_api["allowed_cors_origin"]
 
             except KeyError, e:
-                # print e
                 raise SettingNotFound("%s settings not found" % e)
 
             # config ok, we can return the rest api object

+ 1 - 2
kalliope/core/LIFOBuffer.py

@@ -123,7 +123,6 @@ class LIFOBuffer(object):
         Add info in the API response object after each processed synapse
         Remove the synapse from the synapse_list when it has been fully executed
         :param synapse_list: List of MatchedSynapse
-        :return: 
         """
         # we keep processing til we have synapse in the FIFO to process
         while synapse_list:
@@ -152,8 +151,8 @@ class LIFOBuffer(object):
         - complete: The neuron has been executed and its not waiting for an answer and doesn't want to start a synapse
                     The neuron is removed from the matched synapse
         :param matched_synapse: MatchedSynapse object to process
-        :return: 
         """
+
         logger.debug("[LIFOBuffer] number of neuron to process: %s" % len(matched_synapse.neuron_fifo_list))
         # while we have synapse to process in the list of synapse
         while matched_synapse.neuron_fifo_list:

+ 4 - 2
kalliope/core/MainController.py

@@ -196,8 +196,10 @@ class MainController:
         Start the order analyser with the caught order to process
         """
         logger.debug("order in analysing_order_thread %s" % self.order_to_process)
-        SynapseLauncher.run_matching_synapse_from_order(self.order_to_process, self.brain,
-                                                        self.settings, is_api_call=False)
+        SynapseLauncher.run_matching_synapse_from_order(self.order_to_process,
+                                                        self.brain,
+                                                        self.settings,
+                                                        is_api_call=False)
 
         # return to the state "unpausing_trigger"
         self.unpause_trigger()

+ 0 - 2
kalliope/core/Models/APIResponse.py

@@ -8,7 +8,6 @@ class APIResponse(object):
         self.status = None
 
     def __str__(self):
-
         return str(self.serialize())
 
     def serialize(self):
@@ -17,7 +16,6 @@ class APIResponse(object):
         :return: A dict of name and parameters
         :rtype: Dict
         """
-
         return {
             'user_order': self.user_order,
             'matched_synapses': [e.serialize() for e in self.list_processed_matched_synapse],

+ 1 - 1
kalliope/core/Models/MatchedSynapse.py

@@ -10,11 +10,11 @@ class MatchedSynapse(object):
 
     def __init__(self, matched_synapse=None, matched_order=None, user_order=None):
         """
-        
         :param matched_synapse: The synapse that has matched in the brain.
         :param matched_order: The order from the synapse that have matched.
         :param user_order: The order said by the user.
         """
+
         # create a copy of the synapse. the received synapse come from the brain.
         self.synapse = matched_synapse
         # create a fifo list that contains all neurons to process.

+ 6 - 2
kalliope/core/Models/RestAPI.py

@@ -3,8 +3,12 @@ class RestAPI(object):
     This Class is representing the rest API with all its configuration.
     """
 
-    def __init__(self, password_protected=None, login=None, password=None, active=None,
-                 port=None, allowed_cors_origin=None):
+    def __init__(self,
+                 password_protected=None,
+                 login=None, password=None,
+                 active=None,
+                 port=None,
+                 allowed_cors_origin=None):
         """
         :param password_protected: If true, the rest api will ask for an authentication
         :param login: login used if auth is activated

+ 0 - 1
kalliope/core/Models/Stt.py

@@ -13,7 +13,6 @@ class Stt(object):
         return str(self.serialize())
 
     def serialize(self):
-
         return {
             'name': self.name,
             'parameters': self.parameters

+ 0 - 1
kalliope/core/Models/Trigger.py

@@ -13,7 +13,6 @@ class Trigger(object):
         return str(self.serialize())
 
     def serialize(self):
-
         return {
             'name': self.name,
             'parameters': self.parameters

+ 0 - 1
kalliope/core/Models/Tts.py

@@ -13,7 +13,6 @@ class Tts(object):
         return str(self.serialize())
 
     def serialize(self):
-
         return {
             'name': self.name,
             'parameters': self.parameters

+ 0 - 1
kalliope/core/NeuronLauncher.py

@@ -44,7 +44,6 @@ class NeuronLauncher:
         instantiated_neuron = None
         problem_in_neuron_found = False
         if isinstance(neuron.parameters, dict):
-            # print neuron.parameters
             if "args" in neuron.parameters:
                 logger.debug("The neuron waits for parameter")
                 # check that the user added parameters to his order