timeside/analyzer/core.py: add serialize routines

diff --git a/tests/test_AnalyzerResult.py b/tests/test_AnalyzerResult.py
new file mode 100755 (executable)
index 0000000..b9e4be2
--- /dev/null
+++ b/tests/test_AnalyzerResult.py
@@ -0,0 +1,105 @@
+#! /usr/bin/env python
+
+from unit_timeside import *
+from timeside.decoder import *
+from timeside.analyzer.core import *
+
+verbose = 0
+
+class TestAnalyzerResult(TestCase):
+    """ test AnalyzerResult """
+
+    def setUp(self):
+        self.result = AnalyzerResult(id = "foo_bar", name = "Foo bar", unit = "foo")
+
+    def testOnFloat(self):
+        "float result"
+        self.result.value = 1.2
+
+    def testOnInt(self):
+        "integer result"
+        self.result.value = 1
+
+    def testOnList(self):
+        "list result"
+        self.result.value = [1., 2.]
+
+    def testOnString(self):
+        "string result"
+        self.result.value = "hello"
+
+    def testOnListOfString(self):
+        "list of strings result"
+        self.result.value = ["hello", "hola"]
+
+    def testOnListOfList(self):
+        "list of lists result"
+        self.result.value = [[0,1], [0,1,2]]
+
+    def tearDown(self):
+        pass
+
+class TestAnalyzerResultNumpy(TestAnalyzerResult):
+    """ test AnalyzerResult numpy serialize """
+
+    def tearDown(self):
+        results = [self.result]
+        r_numpy = data_to_numpy(results, '/tmp/t.npy')
+        d_numpy = data_from_numpy('/tmp/t.npy')
+        if verbose:
+            print '%15s' % 'from numpy:',
+            print d_numpy
+        for i in range(len(d_numpy)):
+            self.assertEquals(d_numpy[i], results[i])
+
+class TestAnalyzerResultYaml(TestAnalyzerResult):
+    """ test AnalyzerResult yaml serialize """
+    def tearDown(self):
+        results = [self.result]
+        r_yaml = data_to_yaml(results)
+        if verbose:
+            print 'to yaml:'
+            print r_yaml
+        d_yaml = data_from_yaml(r_yaml)
+        if verbose:
+            print '%15s' % 'from yaml:',
+            print d_yaml
+        for i in range(len(d_yaml)):
+            self.assertEquals(results[i], d_yaml[i])
+
+class TestAnalyzerResultXml(TestAnalyzerResult):
+    """ test AnalyzerResult xml serialize """
+    def tearDown(self):
+        results = [self.result]
+        r_xml = data_to_xml(results)
+        if verbose:
+            print 'to xml:'
+            print r_xml
+
+        d_xml = data_from_xml(r_xml)
+        if verbose:
+            print '%15s' % 'from xml:',
+            print d_xml
+
+        for i in range(len(d_xml)):
+            self.assertEquals(d_xml[i], results[i])
+
+class TestAnalyzerResultJson(TestAnalyzerResult):
+    """ test AnalyzerResult json serialize """
+    def tearDown(self):
+        results = [self.result]
+        r_json = data_to_json(results)
+        if verbose:
+            print 'to json:'
+            print r_json
+
+        d_json = data_from_json(r_json)
+        if verbose:
+            print d_json
+            print '%15s' % 'from yaml:',
+
+        for i in range(len(d_json)):
+            self.assertEquals(d_json[i], results[i])
+
+if __name__ == '__main__':
+    unittest.main(testRunner=TestRunner())

diff --git a/timeside/analyzer/core.py b/timeside/analyzer/core.py
index ec60570bcfcb644109a985a7e89d571dff178802..e0c1c45cbd09032ac67b6fbcca025cd418a85088 100644 (file)
--- a/timeside/analyzer/core.py
+++ b/timeside/analyzer/core.py
@@ -33,3 +33,82 @@ class AnalyzerResult(object):
         for attr in ['id', 'name', 'unit', 'value']:
             o[attr] = getattr(self, attr)
         return repr(o)
+
+    def __getitem__(self, attr):
+        return getattr(self, attr)
+
+    def __eq__(self, that):
+        for attr in ['id', 'name', 'unit', 'value']:
+            if getattr(self, attr) != that[attr]:
+                return False
+        return True
+
+def data_to_xml(data_list):
+    import xml.dom.minidom
+    doc = xml.dom.minidom.Document()
+    root = doc.createElement('telemeta')
+    doc.appendChild(root)
+    for data in data_list:
+        node = doc.createElement('data')
+        node.setAttribute('name', data.name)
+        node.setAttribute('id', data.id)
+        node.setAttribute('unit', data.unit)
+        node.setAttribute('value', str(data.value))
+        if type(data.value) != type(str()) and type(data.value) != type(unicode()):
+            node.setAttribute('str', '0')
+        root.appendChild(node)
+    return xml.dom.minidom.Document.toprettyxml(doc)
+
+def data_from_xml(xml_string):
+    import xml.dom.minidom
+    doc = xml.dom.minidom.parseString(xml_string)
+    root = doc.getElementsByTagName('telemeta')[0]
+    results = []
+    for child in root.childNodes:
+        if child.nodeType != child.ELEMENT_NODE: continue
+        child_dict = {}
+        for a in ['name', 'id', 'unit', 'value']:
+            child_dict[a] = str(child.getAttribute(a))
+        if child.getAttribute('str') == '0':
+            try:
+                child_dict['value'] = eval(child_dict['value'])
+            except Exception, e:
+                print e
+        results.append(child_dict)
+    return results
+
+def data_to_json(data_list):
+    import simplejson as json
+    data_strings = []
+    for data in data_list:
+        data_dict = {}
+        for a in ['name', 'id', 'unit', 'value']:
+            data_dict[a] = getattr(data,a)
+        data_strings.append(data_dict)
+    return json.dumps(data_strings)
+
+def data_from_json(json_str):
+    import simplejson as json
+    return json.loads(json_str)
+
+def data_to_yaml(data_list):
+    import yaml
+    data_strings = []
+    for f in data_list:
+        f_dict = {}
+        for a in ['name', 'id', 'unit', 'value']:
+            f_dict[a] = getattr(f,a)
+        data_strings.append(f_dict)
+    return yaml.dump(data_strings, default_flow_style=False)
+
+def data_from_yaml(yaml_str):
+    import yaml
+    return yaml.load(yaml_str)
+
+def data_to_numpy(data_list, output_file = None):
+    import numpy
+    numpy.save(output_file, data_list)
+
+def data_from_numpy(input_file):
+    import numpy
+    return numpy.load(input_file)