ソースを参照

add tests for models serialization

nico 8 年 前
コミット
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
 
     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):
         """
         This method allows to serialize in a proper way this object
-
         :return: A dict of name and parameters
         :rtype: Dict
         """

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

@@ -25,11 +25,7 @@ class Dna(object):
         }
 
     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):
         """

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

@@ -17,9 +17,7 @@ class Event(object):
         self.second = second
 
     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):
         """

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

@@ -31,13 +31,7 @@ class MatchedSynapse(object):
         self.neuron_module_list = list()
 
     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):
         """

+ 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
         :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()
         for key, value in self.parameters.iteritems():
             if "password" in key:
                 cleaned_parameters[key] = "*****"
             else:
                 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):
         """

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

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

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

@@ -11,11 +11,7 @@ class Resources(object):
         self.trigger_folder = trigger_folder
 
     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):
         """

+ 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.
     """
 
-    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
@@ -19,14 +20,24 @@ class RestAPI(object):
         self.allowed_cors_origin = allowed_cors_origin
 
     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):
         """

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

@@ -24,9 +24,7 @@ class Settings(object):
                  cache_path=None,
                  default_synapse=None,
                  resources=None,
-                 variables= None, # dict()
-                 machine=None,
-                 kalliope_version=None):
+                 variables=None):
 
         self.default_tts_name = default_tts_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.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):
         """
         This is used to compare 2 objects

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

@@ -10,7 +10,14 @@ class Stt(object):
         self.parameters = parameters
 
     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):
         """

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

@@ -25,14 +25,7 @@ class Synapse(object):
         }
 
     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):
         """

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

@@ -10,7 +10,14 @@ class Trigger(object):
         self.parameters = parameters
 
     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):
         """

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

@@ -10,7 +10,14 @@ class Tts(object):
         self.parameters = parameters
 
     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):
         """

+ 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.SynapseLauncher import SynapseLauncher
 from kalliope.core.LIFOBuffer import LIFOBuffer
+from kalliope.core.NeuronParameterLoader import NeuronParameterLoader