Browse Source

add tests for models serialization

nico 8 years ago
parent
commit
cd207cb687

+ 417 - 0
Tests/test_models.py

@@ -0,0 +1,417 @@
+import unittest
+
+import mock
+from kalliope.core.Models.Tts import Tts
+
+from kalliope.core.Models.Trigger import Trigger
+
+from kalliope.core.Models.Stt import Stt
+
+from kalliope.core.Models.RestAPI import RestAPI
+
+from kalliope.core.Models.Dna import Dna
+
+from kalliope.core import LIFOBuffer
+from kalliope.core.Models.Settings import Settings
+
+from kalliope.core.Models import Neuron, Order, Synapse, Brain, Event, Resources
+
+from kalliope.core.Models.APIResponse import APIResponse
+from kalliope.core.Models.MatchedSynapse import MatchedSynapse
+
+
+class TestModels(unittest.TestCase):
+
+    def setUp(self):
+        # Init
+        neuron1 = Neuron(name='neurone1', parameters={'var1': 'val1'})
+        neuron2 = Neuron(name='neurone2', parameters={'var2': 'val2'})
+        neuron3 = Neuron(name='neurone3', parameters={'var3': 'val3'})
+        neuron4 = Neuron(name='neurone4', parameters={'var4': 'val4'})
+
+        signal1 = Order(sentence="this is the sentence")
+        signal2 = Order(sentence="this is the second sentence")
+        signal3 = Order(sentence="that is part of the third sentence")
+
+        self.synapse1 = Synapse(name="Synapse1", neurons=[neuron1, neuron2], signals=[signal1])
+        self.synapse2 = Synapse(name="Synapse2", neurons=[neuron3, neuron4], signals=[signal2])
+        self.synapse3 = Synapse(name="Synapse3", neurons=[neuron2, neuron4], signals=[signal3])
+
+        self.all_synapse_list1 = [self.synapse1,
+                                  self.synapse2,
+                                  self.synapse3]
+
+        self.all_synapse_list2 = [self.synapse2,
+                                  self.synapse3]
+
+        self.brain_test1 = Brain(synapses=self.all_synapse_list1)
+        self.brain_test2 = Brain(synapses=self.all_synapse_list2)
+        # this brain is the same as the first one
+        self.brain_test3 = Brain(synapses=self.all_synapse_list1)
+
+        self.settings_test = Settings(default_synapse="Synapse3")
+
+        # clean the LiFO
+        LIFOBuffer.lifo_list = list()
+
+    def test_APIResponse(self):
+        user_order = "user order"
+        self.matched_synapse = MatchedSynapse(matched_synapse=self.synapse1, matched_order=user_order)
+
+        api_response = APIResponse()
+        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'}
+
+        self.assertEqual(expected_result_serialize, api_response.serialize())
+
+        expected_result_str = "{'status': None, 'matched_synapses': [{'matched_order': 'user order', " \
+                              "'neuron_module_list': [], 'synapse_name': 'Synapse1'}], 'user_order': 'user order'}"
+
+        self.assertEqual(expected_result_str, api_response.__str__())
+
+    def test_Brain(self):
+        # test get synapse by name
+        expect_result = self.synapse1
+        synapse_name = "Synapse1"
+        self.assertEqual(self.brain_test1.get_synapse_by_name(synapse_name), expect_result)
+
+        # test equals
+        self.assertTrue(self.brain_test1.__eq__(self.brain_test3))
+
+        # test not equals
+        self.assertFalse(self.brain_test1.__eq__(self.brain_test2))
+
+    def test_Dna(self):
+        # create DNA object
+        dna1 = Dna(name="dna1", module_type="neuron", author="kalliope",
+                   kalliope_supported_version="0.4.4", tags="test")
+
+        dna2 = Dna(name="dna2", module_type="neuron", author="community",
+                   kalliope_supported_version="0.4.2", tags="other")
+
+        # this dna is exactly the same as the first one
+        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_str = "{'kalliope_supported_version': '0.4.4', 'tags': 'test', 'type':" \
+                              " 'neuron', 'name': 'dna1', 'author': 'kalliope'}"
+
+        self.assertEqual(expected_result_serialize, dna1.serialize())
+        self.assertEqual(expected_result_str, dna1.__str__())
+
+        self.assertTrue(dna1.__eq__(dna3))
+        self.assertFalse(dna1.__eq__(dna2))
+
+    def test_Event(self):
+        event1 = Event(year=2017, month=12, day=31, week=53, day_of_week=2,
+                       hour=8, minute=30, second=0)
+
+        event2 = Event(year=2018, month=11, day=30, week=25, day_of_week=4,
+                       hour=9, minute=40, second=0)
+
+        # same as the event1
+        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_str = "{'event': {'week': 53, 'second': 0, 'minute': 30, 'hour': 8, " \
+                              "'year': 2017, 'day': 31, 'day_of_week': 2, 'month': 12}}"
+
+        self.assertEqual(expected_result_serialize, event1.serialize())
+        self.assertEqual(expected_result_str, event1.__str__())
+
+        self.assertTrue(event1.__eq__(event3))
+        self.assertFalse(event1.__eq__(event2))
+
+    def test_MatchedSynapse(self):
+        user_order = "user order"
+        matched_synapse1 = MatchedSynapse(matched_synapse=self.synapse1, matched_order=user_order)
+        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_str = "{'matched_order': 'user order', 'neuron_module_list': [], 'synapse_name': 'Synapse1'}"
+
+        self.assertEqual(expected_result_serialize, matched_synapse1.serialize())
+        self.assertEqual(expected_result_str, matched_synapse1.__str__())
+
+        self.assertTrue(matched_synapse1.__eq__(matched_synapse3))
+        self.assertFalse(matched_synapse1.__eq__(matched_synapse2))
+
+        # test neuron parameter loader is called
+        with mock.patch("kalliope.core.NeuronParameterLoader.get_parameters") as mock_get_parameters:
+
+            MatchedSynapse(matched_synapse=self.synapse1, matched_order=user_order, user_order=user_order)
+            mock_get_parameters.assert_called_once_with(synapse_order=user_order,
+                                                        user_order=user_order)
+            mock_get_parameters.reset_mock()
+
+    def test_Neuron(self):
+
+        neuron1 = Neuron(name="test", parameters={"key1": "val1", "key2": "val2"})
+        neuron2 = Neuron(name="test", parameters={"key3": "val3", "key4": "val4"})
+        neuron3 = Neuron(name="test", parameters={"key1": "val1", "key2": "val2"})
+
+        expected_result_serialize = {'name': 'test', 'parameters': {'key2': 'val2', 'key1': 'val1'}}
+        expected_result_str = "{'name': 'test', 'parameters': {'key2': 'val2', 'key1': 'val1'}}"
+
+        self.assertEqual(expected_result_serialize, neuron1.serialize())
+        self.assertEqual(expected_result_str, neuron1.__str__())
+
+        self.assertTrue(neuron1.__eq__(neuron3))
+        self.assertFalse(neuron1.__eq__(neuron2))
+
+        # test password
+        neuron_name = "test"
+        neuron_parameters = {
+            "password": "my secret",
+            "parameter": "test"
+        }
+
+        neuron = Neuron()
+        neuron.name = neuron_name
+        neuron.parameters = neuron_parameters
+
+        expected_result = "{'name': 'test', 'parameters': {'password': '*****', 'parameter': 'test'}}"
+
+        self.assertEqual(neuron.__str__(), expected_result)
+
+        neuron_name = "test"
+        neuron_parameters = {
+            "password_parameter": "my secret",
+            "parameter": "test"
+        }
+
+        neuron = Neuron()
+        neuron.name = neuron_name
+        neuron.parameters = neuron_parameters
+
+        expected_result = "{'name': 'test', 'parameters': {'parameter': 'test', 'password_parameter': '*****'}}"
+
+        self.assertEqual(neuron.__str__(), expected_result)
+
+    def test_Order(self):
+        order1 = Order(sentence="this is an order")
+        order2 = Order(sentence="this is an other order")
+        order3 = Order(sentence="this is an order")
+
+        expected_result_serialize = {'order': 'this is an order'}
+        expected_result_str = "{'order': 'this is an order'}"
+
+        self.assertEqual(expected_result_serialize, order1.serialize())
+        self.assertEqual(expected_result_str, order1.__str__())
+
+        self.assertTrue(order1.__eq__(order3))
+        self.assertFalse(order1.__eq__(order2))
+
+    def test_Resources(self):
+        resource1 = Resources(neuron_folder="/path/neuron", stt_folder="/path/stt",
+                              tts_folder="/path/tts", trigger_folder="/path/trigger")
+
+        resource2 = Resources(neuron_folder="/other_path/neuron", stt_folder="/other_path/stt",
+                              tts_folder="/other_path/tts", trigger_folder="/other_path/trigger")
+
+        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_str = "{'tts_folder': '/path/tts', 'neuron_folder': '/path/neuron', " \
+                              "'stt_folder': '/path/stt', 'trigger_folder': '/path/trigger'}"
+
+        self.assertEqual(expected_result_serialize, resource1.serialize())
+        self.assertEqual(expected_result_str, resource1.__str__())
+
+        self.assertTrue(resource1.__eq__(resource3))
+        self.assertFalse(resource1.__eq__(resource2))
+
+    def test_RestAPI(self):
+
+        rest_api1 = RestAPI(password_protected=True, login="admin", password="password", active=True,
+                            port=5000, allowed_cors_origin="*")
+
+        rest_api2 = RestAPI(password_protected=False, active=False,
+                            port=5000, allowed_cors_origin=None)
+
+        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_str = "{'password_protected': True, 'port': 5000, 'active': True, 'allowed_cors_origin': '*', " \
+                              "'password': 'password', 'login': 'admin'}"
+
+        self.assertEqual(expected_result_serialize, rest_api1.serialize())
+        self.assertEqual(expected_result_str, rest_api1.__str__())
+
+        self.assertTrue(rest_api1.__eq__(rest_api3))
+        self.assertFalse(rest_api1.__eq__(rest_api2))
+
+    def test_Settings(self):
+        with mock.patch('platform.machine', return_value='pumpkins'):
+            rest_api1 = RestAPI(password_protected=True, login="admin", password="password", active=True,
+                                port=5000, allowed_cors_origin="*")
+
+            setting1 = Settings(default_tts_name="pico2wav",
+                                default_stt_name="google",
+                                default_trigger_name="swoyboy",
+                                ttss=["ttts"],
+                                stts=["stts"],
+                                random_wake_up_answers=["yes"],
+                                random_wake_up_sounds=None,
+                                play_on_ready_notification=False,
+                                on_ready_answers=None,
+                                on_ready_sounds=None,
+                                triggers=["snowboy"],
+                                rest_api=rest_api1,
+                                cache_path="/tmp/kalliope",
+                                default_synapse="default_synapse",
+                                resources=None,
+                                variables={"key1": "val1"})
+
+            setting2 = Settings(default_tts_name="accapela",
+                                default_stt_name="bing",
+                                default_trigger_name="swoyboy",
+                                ttss=["ttts"],
+                                stts=["stts"],
+                                random_wake_up_answers=["no"],
+                                random_wake_up_sounds=None,
+                                play_on_ready_notification=False,
+                                on_ready_answers=None,
+                                on_ready_sounds=None,
+                                triggers=["snowboy"],
+                                rest_api=rest_api1,
+                                cache_path="/tmp/kalliope_tmp",
+                                default_synapse="my_default_synapse",
+                                resources=None,
+                                variables={"key1": "val1"})
+
+            setting3 = Settings(default_tts_name="pico2wav",
+                                default_stt_name="google",
+                                default_trigger_name="swoyboy",
+                                ttss=["ttts"],
+                                stts=["stts"],
+                                random_wake_up_answers=["yes"],
+                                random_wake_up_sounds=None,
+                                play_on_ready_notification=False,
+                                on_ready_answers=None,
+                                on_ready_sounds=None,
+                                triggers=["snowboy"],
+                                rest_api=rest_api1,
+                                cache_path="/tmp/kalliope",
+                                default_synapse="default_synapse",
+                                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_str = "{'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']}"
+
+            self.assertEqual(expected_result_serialize, setting1.serialize())
+            self.assertEqual(expected_result_str, setting1.__str__())
+
+            self.assertTrue(setting1.__eq__(setting3))
+            self.assertFalse(setting1.__eq__(setting2))
+
+    def test_Stt(self):
+        stt1 = Stt(name="stt1", parameters={"key1": "val1"})
+        stt2 = Stt(name="stt2", parameters={"key2": "val2"})
+        stt3 = Stt(name="stt1", parameters={"key1": "val1"})
+
+        expected_result_serialize = {'name': 'stt1', 'parameters': {'key1': 'val1'}}
+        expected_result_str = "{'name': 'stt1', 'parameters': {'key1': 'val1'}}"
+
+        self.assertEqual(expected_result_serialize, stt1.serialize())
+        self.assertEqual(expected_result_str, stt1.__str__())
+
+        self.assertTrue(stt1.__eq__(stt3))
+        self.assertFalse(stt1.__eq__(stt2))
+
+    def test_Synapse(self):
+        neuron1 = Neuron(name='neurone1', parameters={'var1': 'val1'})
+        neuron2 = Neuron(name='neurone2', parameters={'var2': 'val2'})
+        neuron3 = Neuron(name='neurone3', parameters={'var3': 'val3'})
+        neuron4 = Neuron(name='neurone4', parameters={'var4': 'val4'})
+
+        signal1 = Order(sentence="this is the sentence")
+        signal2 = Order(sentence="this is the second sentence")
+
+        synapse1 = Synapse(name="Synapse1", neurons=[neuron1, neuron2], signals=[signal1])
+        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_str = "{'signals': [{'order': 'this is the sentence'}], 'neurons': [{'name': 'neurone1', " \
+                              "'parameters': {'var1': 'val1'}}, {'name': 'neurone2', 'parameters': {'var2': " \
+                              "'val2'}}], 'name': 'Synapse1'}"
+
+        self.assertEqual(expected_result_serialize, synapse1.serialize())
+        self.assertEqual(expected_result_str, synapse1.__str__())
+
+        self.assertTrue(synapse1.__eq__(synapse3))
+        self.assertFalse(synapse1.__eq__(synapse2))
+
+    def test_Trigger(self):
+        trigger1 = Trigger(name="trigger1", parameters={"key1": "val1"})
+        trigger2 = Trigger(name="trigger2", parameters={"key2": "val2"})
+        trigger3 = Trigger(name="trigger1", parameters={"key1": "val1"})
+
+        expected_result_serialize = {'name': 'trigger1', 'parameters': {'key1': 'val1'}}
+        expected_result_str = "{'name': 'trigger1', 'parameters': {'key1': 'val1'}}"
+
+        self.assertEqual(expected_result_serialize, trigger1.serialize())
+        self.assertEqual(expected_result_str, trigger1.__str__())
+
+        self.assertTrue(trigger1.__eq__(trigger3))
+        self.assertFalse(trigger1.__eq__(trigger2))
+
+    def test_Tts(self):
+        tts1 = Tts(name="tts1", parameters={"key1": "val1"})
+        tts2 = Tts(name="tts2", parameters={"key2": "val2"})
+        tts3 = Tts(name="tts1", parameters={"key1": "val1"})
+
+        expected_result_serialize = {'name': 'tts1', 'parameters': {'key1': 'val1'}}
+        expected_result_str = "{'name': 'tts1', 'parameters': {'key1': 'val1'}}"
+
+        self.assertEqual(expected_result_serialize, tts1.serialize())
+        self.assertEqual(expected_result_str, tts1.__str__())
+
+        self.assertTrue(tts1.__eq__(tts3))
+        self.assertFalse(tts1.__eq__(tts2))
+
+

+ 0 - 40
Tests/test_neuron_model.py

@@ -1,40 +0,0 @@
-import os
-import unittest
-
-from kalliope.core.Models import Neuron
-
-
-class TestNeuronModule(unittest.TestCase):
-
-    def test_password_parameter(self):
-        neuron_name = "test"
-        neuron_parameters = {
-            "password": "my secret",
-            "parameter": "test"
-        }
-
-        neuron = Neuron()
-        neuron.name = neuron_name
-        neuron.parameters = neuron_parameters
-
-        expected_result = "Neuron: name: test, parameters: {'password': '*****', 'parameter': 'test'}"
-
-        self.assertEqual(neuron.__str__(), expected_result)
-
-    def test_password_in_parameter(self):
-        neuron_name = "test"
-        neuron_parameters = {
-            "password_parameter": "my secret",
-            "parameter": "test"
-        }
-
-        neuron = Neuron()
-        neuron.name = neuron_name
-        neuron.parameters = neuron_parameters
-
-        expected_result = "Neuron: name: test, parameters: {'parameter': 'test', 'password_parameter': '*****'}"
-
-        self.assertEqual(neuron.__str__(), expected_result)
-
-if __name__ == '__main__':
-    unittest.main()

+ 1 - 5
kalliope/core/Models/APIResponse.py

@@ -8,16 +8,12 @@ class APIResponse(object):
         self.status = None
         self.status = None
 
 
     def __str__(self):
     def __str__(self):
-        returned_string = ""
-        for el in self.list_processed_matched_synapse:
-            returned_string += str(el)
 
 
-        return returned_string
+        return str(self.serialize())
 
 
     def serialize(self):
     def serialize(self):
         """
         """
         This method allows to serialize in a proper way this object
         This method allows to serialize in a proper way this object
-
         :return: A dict of name and parameters
         :return: A dict of name and parameters
         :rtype: Dict
         :rtype: Dict
         """
         """

+ 1 - 5
kalliope/core/Models/Dna.py

@@ -25,11 +25,7 @@ class Dna(object):
         }
         }
 
 
     def __str__(self):
     def __str__(self):
-        return "Dna: name: %s, " \
-               "type: %s, " \
-               "author: %s, " \
-               "kalliope_supported_version: %s, " \
-               "tags: %s" % (self.name, self.module_type, self.author, self.kalliope_supported_version, self.tags)
+        return str(self.serialize())
 
 
     def __eq__(self, other):
     def __eq__(self, other):
         """
         """

+ 1 - 3
kalliope/core/Models/Event.py

@@ -17,9 +17,7 @@ class Event(object):
         self.second = second
         self.second = second
 
 
     def __str__(self):
     def __str__(self):
-        return "%s:  year: %s, month: %s, day: %s, week: %s, day_of_week: %s, hour: %s, minute: %s, second: %s" \
-               % (self.__class__.__name__, self.year, self.month, self.day, self.week,
-                  self.day_of_week, self.hour, self.minute, self.second)
+        return str(self.serialize())
 
 
     def serialize(self):
     def serialize(self):
         """
         """

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

@@ -31,13 +31,7 @@ class MatchedSynapse(object):
         self.neuron_module_list = list()
         self.neuron_module_list = list()
 
 
     def __str__(self):
     def __str__(self):
-        returned_string = str()
-        returned_string += str(self.synapse)
-        returned_string += "answers: "
-        for neuron_module in self.neuron_module_list:
-            returned_string += str(neuron_module)
-
-        return returned_string
+        return str(self.serialize())
 
 
     def serialize(self):
     def serialize(self):
         """
         """

+ 8 - 4
kalliope/core/Models/Neuron.py

@@ -27,16 +27,20 @@ class Neuron(object):
         the output of this parameter will be masked in order to not appears in clean in the console
         the output of this parameter will be masked in order to not appears in clean in the console
         :return: string description of the neuron
         :return: string description of the neuron
         """
         """
-        returned_string = str()
-        returned_string += "Neuron: name: %s" % self.name
+        returned_dict = {
+            'name': self.name,
+            'parameters': self.parameters
+        }
+
         cleaned_parameters = dict()
         cleaned_parameters = dict()
         for key, value in self.parameters.iteritems():
         for key, value in self.parameters.iteritems():
             if "password" in key:
             if "password" in key:
                 cleaned_parameters[key] = "*****"
                 cleaned_parameters[key] = "*****"
             else:
             else:
                 cleaned_parameters[key] = value
                 cleaned_parameters[key] = value
-        returned_string += ", parameters: %s" % cleaned_parameters
-        return returned_string
+        returned_dict["parameters"] = cleaned_parameters
+
+        return str(returned_dict)
 
 
     def __eq__(self, other):
     def __eq__(self, other):
         """
         """

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

@@ -9,7 +9,7 @@ class Order(object):
         self.sentence = sentence
         self.sentence = sentence
 
 
     def __str__(self):
     def __str__(self):
-        return "%s: Sentence: %s" % (self.__class__.__name__, self.sentence)
+        return str(self.serialize())
 
 
     def serialize(self):
     def serialize(self):
         """
         """

+ 1 - 5
kalliope/core/Models/Resources.py

@@ -11,11 +11,7 @@ class Resources(object):
         self.trigger_folder = trigger_folder
         self.trigger_folder = trigger_folder
 
 
     def __str__(self):
     def __str__(self):
-        return "%s: neuron_folder: %s, stt_folder: %s, tts_folder: %s, trigger_folder: %s" % (self.__class__.__name__,
-                                                                                              self.neuron_folder,
-                                                                                              self.stt_folder,
-                                                                                              self.tts_folder,
-                                                                                              self.trigger_folder)
+        return str(self.serialize())
 
 
     def serialize(self):
     def serialize(self):
         """
         """

+ 20 - 9
kalliope/core/Models/RestAPI.py

@@ -3,7 +3,8 @@ class RestAPI(object):
     This Class is representing the rest API with all its configuration.
     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 password_protected: If true, the rest api will ask for an authentication
         :param login: login used if auth is activated
         :param login: login used if auth is activated
@@ -19,14 +20,24 @@ class RestAPI(object):
         self.allowed_cors_origin = allowed_cors_origin
         self.allowed_cors_origin = allowed_cors_origin
 
 
     def __str__(self):
     def __str__(self):
-        return "%s: RestAPI: password_protected: %s, login: %s, " \
-              "password: %s, active: %s, port: %s, allow_cors_request: %s" % (self.__class__.__name__,
-                                                       self.password_protected,
-                                                       self.login,
-                                                       self.password,
-                                                       self.active,
-                                                       self.port,
-                                                       self.allowed_cors_origin)
+        return str(self.serialize())
+
+    def serialize(self):
+        """
+        This method allows to serialize in a proper way this object
+
+        :return: A dict of order
+        :rtype: Dict
+        """
+
+        return {
+            'password_protected': self.password_protected,
+            'login': self.login,
+            'password': self.password,
+            'active': self.active,
+            'port': self.port,
+            'allowed_cors_origin': self.allowed_cors_origin
+        }
 
 
     def __eq__(self, other):
     def __eq__(self, other):
         """
         """

+ 33 - 3
kalliope/core/Models/Settings.py

@@ -24,9 +24,7 @@ class Settings(object):
                  cache_path=None,
                  cache_path=None,
                  default_synapse=None,
                  default_synapse=None,
                  resources=None,
                  resources=None,
-                 variables= None, # dict()
-                 machine=None,
-                 kalliope_version=None):
+                 variables=None):
 
 
         self.default_tts_name = default_tts_name
         self.default_tts_name = default_tts_name
         self.default_stt_name = default_stt_name
         self.default_stt_name = default_stt_name
@@ -47,6 +45,38 @@ class Settings(object):
         self.machine = platform.machine()   # can be x86_64 or armv7l
         self.machine = platform.machine()   # can be x86_64 or armv7l
         self.kalliope_version = current_kalliope_version
         self.kalliope_version = current_kalliope_version
 
 
+    def serialize(self):
+        """
+        This method allows to serialize in a proper way this object
+
+        :return: A dict of order
+        :rtype: Dict
+        """
+
+        return {
+            'default_tts_name': self.default_tts_name,
+            'default_stt_name': self.default_stt_name,
+            'default_trigger_name': self.default_trigger_name,
+            'ttss': self.ttss,
+            'stts': self.stts,
+            'random_wake_up_answers': self.random_wake_up_answers,
+            'random_wake_up_sounds': self.random_wake_up_sounds,
+            'play_on_ready_notification': self.play_on_ready_notification,
+            'on_ready_answers': self.on_ready_answers,
+            'on_ready_sounds': self.on_ready_sounds,
+            'triggers': self.triggers,
+            'rest_api': self.rest_api.serialize(),
+            'cache_path': self.cache_path,
+            'default_synapse': self.default_synapse,
+            'resources': self.resources,
+            'variables': self.variables,
+            'machine': self.machine,
+            'kalliope_version': self.kalliope_version
+        }
+
+    def __str__(self):
+        return str(self.serialize())
+
     def __eq__(self, other):
     def __eq__(self, other):
         """
         """
         This is used to compare 2 objects
         This is used to compare 2 objects

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

@@ -10,7 +10,14 @@ class Stt(object):
         self.parameters = parameters
         self.parameters = parameters
 
 
     def __str__(self):
     def __str__(self):
-        return "Stt name: %s, parameters: %s" % (str(self.name), str(self.parameters))
+        return str(self.serialize())
+
+    def serialize(self):
+
+        return {
+            'name': self.name,
+            'parameters': self.parameters
+        }
 
 
     def __eq__(self, other):
     def __eq__(self, other):
         """
         """

+ 1 - 8
kalliope/core/Models/Synapse.py

@@ -25,14 +25,7 @@ class Synapse(object):
         }
         }
 
 
     def __str__(self):
     def __str__(self):
-        return_val = "Synapse name: %s" % self.name
-        return_val += "\nneurons:"
-        for el in self.neurons:
-            return_val += str(el)
-        return_val += "\nsignals:"
-        for el in self.signals:
-            return_val += str(el)
-        return return_val
+        return str(self.serialize())
 
 
     def __eq__(self, other):
     def __eq__(self, other):
         """
         """

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

@@ -10,7 +10,14 @@ class Trigger(object):
         self.parameters = parameters
         self.parameters = parameters
 
 
     def __str__(self):
     def __str__(self):
-        return "Trigger name: %s, parameters: %s" % (str(self.name), str(self.parameters))
+        return str(self.serialize())
+
+    def serialize(self):
+
+        return {
+            'name': self.name,
+            'parameters': self.parameters
+        }
 
 
     def __eq__(self, other):
     def __eq__(self, other):
         """
         """

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

@@ -10,7 +10,14 @@ class Tts(object):
         self.parameters = parameters
         self.parameters = parameters
 
 
     def __str__(self):
     def __str__(self):
-        return "Tts name: %s, parameters: %s" % (str(self.name), str(self.parameters))
+        return str(self.serialize())
+
+    def serialize(self):
+
+        return {
+            'name': self.name,
+            'parameters': self.parameters
+        }
 
 
     def __eq__(self, other):
     def __eq__(self, other):
         """
         """

+ 1 - 0
kalliope/core/__init__.py

@@ -7,3 +7,4 @@ from kalliope.core.ResourcesManager import ResourcesManager
 from kalliope.core.NeuronLauncher import NeuronLauncher
 from kalliope.core.NeuronLauncher import NeuronLauncher
 from kalliope.core.SynapseLauncher import SynapseLauncher
 from kalliope.core.SynapseLauncher import SynapseLauncher
 from kalliope.core.LIFOBuffer import LIFOBuffer
 from kalliope.core.LIFOBuffer import LIFOBuffer
+from kalliope.core.NeuronParameterLoader import NeuronParameterLoader