Merge lp:~milo/linaro-ci-dashboard/xml-to-dict into lp:linaro-ci-dashboard

[Milo Casagrande]

Here there is all the logic for XML to dictionary and dictionary to XML conversions. Some tests and their values are provided.

[Stevan Radaković (stevanr)]

Hey Milo great work !!1
Before discussing the dict necessity with danilo, I'll do a review here and lets land this, with tendency to refactor things later.

=== modified file 'dashboard/frontend/android_textfield_loop/tests/test_android_textfield_loop_model.py'
--- dashboard/frontend/android_textfield_loop/tests/test_android_textfield_loop_model.py 2012-09-05 13:59:57 +0000
+++ dashboard/frontend/android_textfield_loop/tests/test_android_textfield_loop_model.py 2012-09-06 11:09:25 +0000
@@ -24,9 +24,9 @@

     A_NAME = 'a-build'
     B_NAME = 'b-build'
- VALID_VALUES = 'a=2\nb=3'
+ VALID_VALUES = u'a=2\nb=3'
     VALID_LINES = ['a=2', 'b=3']
- NON_VALID_VALUES = 'a:2\nb=3'
+ NON_VALID_VALUES = u'a:2\nb=3'
     NON_VALID_LINES = ['a:2', 'b=3']
     VALID_DICT = {'a': '2', 'b': '3'}

@@ -52,6 +52,7 @@
     def test_valid_values_wrong(self):
         self.assertEqual((False, self.NON_VALID_LINES),
                          AndroidTextFieldLoop.valid_values(
+<<<<<<< TREE
                              self.NON_VALID_VALUES))

     def test_schedule_build(self):
@@ -62,3 +63,27 @@
     def test_schedule_build_invalid(self):
         build = self.non_valid_android_loop.schedule_build()
         self.assertEqual(build.result_xml, {})
+=======
+ self.NON_VALID_VALUES))
+
+ def test_schedule_build(self):
+ build = self.android_loop.schedule_build()
+ expected_out = '<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE ' \
+ 'loop [\n <!ELEMENT loop (description?,fields)>\n' \
+ ' <!ELEMENT description (#PCDATA)>\n ' \
+ '<!ELEMENT fields (field+)>\n <!ELEMENT field ' \
+ '(#PCDATA)>\n <!ATTLIST field name CDATA ' \
+ '#REQUIRED>\n <!ATTLIST field type (text|int|bool) ' \
+ '"text">\n]><loop><fields><field name="a">2</field>' \
+ '<field name="b">3</field><field name="name">a-build' \
+ '</field><field name="is_restricted">False</field>' \
+ '<field name="is_official">False</field>' \
+ '<field name="type">AndroidTextFieldLoop</field>' \
+ '</fields></loop>'
+ self.assertEqual(expected_out, build.result_xml)
+ self.assertEqual(build.status, "success")
+
+ def test_schedule_build_invalid(self):
+ build = self.non_valid_android_loop.schedule_build()
+ self.assertEqual("", build.result_xml)
+>>>>>>> MERGE-SOURCE

What's with all the white spaces in the expected out? Can't we do strip() somewhere in the code and output xml without new lines and white spaces?

=== modified file 'dashboard/frontend/models/loop_build.py'
--- dashboard/frontend/models/loop_build.py 2012-09-05 13:23:05 +0000
+++ dashboard/frontend/models/loop_build.py 2012-09-06 11:09:25 +0000
@@ -18,6 +18,7 @@

 from django.db import models
 from frontend.models.loop import Loop
+from dashboard.lib.xml_to_dict import XmlToDict

 class LoopBuild(models.Model):
@@ -47,3 +48,15 @@
             else:
                 self.build_number = 1
         ...

review: Needs Fixing

[Milo Casagrande (milo)]

Hello Stevan,

thanks for the review!

On Thu, Sep 6, 2012 at 3:55 PM, Stevan Radaković
<email address hidden> wrote:
> Review: Needs Fixing
>
> Hey Milo great work !!1
> Before discussing the dict necessity with danilo, I'll do a review here and lets land this, with tendency to refactor things later.
>
>
>
> === modified file 'dashboard/frontend/android_textfield_loop/tests/test_android_textfield_loop_model.py'
> --- dashboard/frontend/android_textfield_loop/tests/test_android_textfield_loop_model.py 2012-09-05 13:59:57 +0000
> +++ dashboard/frontend/android_textfield_loop/tests/test_android_textfield_loop_model.py 2012-09-06 11:09:25 +0000
> @@ -24,9 +24,9 @@
>
> A_NAME = 'a-build'
> B_NAME = 'b-build'
> - VALID_VALUES = 'a=2\nb=3'
> + VALID_VALUES = u'a=2\nb=3'
> VALID_LINES = ['a=2', 'b=3']
> - NON_VALID_VALUES = 'a:2\nb=3'
> + NON_VALID_VALUES = u'a:2\nb=3'
> NON_VALID_LINES = ['a:2', 'b=3']
> VALID_DICT = {'a': '2', 'b': '3'}
>
> @@ -52,6 +52,7 @@
> def test_valid_values_wrong(self):
> self.assertEqual((False, self.NON_VALID_LINES),
> AndroidTextFieldLoop.valid_values(
> +<<<<<<< TREE
> self.NON_VALID_VALUES))
>
> def test_schedule_build(self):
> @@ -62,3 +63,27 @@
> def test_schedule_build_invalid(self):
> build = self.non_valid_android_loop.schedule_build()
> self.assertEqual(build.result_xml, {})
> +=======
> + self.NON_VALID_VALUES))
> +
> + def test_schedule_build(self):
> + build = self.android_loop.schedule_build()
> + expected_out = '<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE ' \
> + 'loop [\n <!ELEMENT loop (description?,fields)>\n' \
> + ' <!ELEMENT description (#PCDATA)>\n ' \
> + '<!ELEMENT fields (field+)>\n <!ELEMENT field ' \
> + '(#PCDATA)>\n <!ATTLIST field name CDATA ' \
> + '#REQUIRED>\n <!ATTLIST field type (text|int|bool) ' \
> + '"text">\n]><loop><fields><field name="a">2</field>' \
> + '<field name="b">3</field><field name="name">a-build' \
> + '</field><field name="is_restricted">False</field>' \
> + '<field name="is_official">False</field>' \
> + '<field name="type">AndroidTextFieldLoop</field>' \
> + '</fields></loop>'
> + self.assertEqual(expected_out, build.result_xml)
> + self.assertEqual(build.status, "success")
> +
> + def test_schedule_build_invalid(self):
> + build = self.non_valid_android_loop.schedule_build()
> + self.assertEqual("", build.result_xml)
> +>>>>>>> MERGE-SOURCE
>
>
> What's with all the white spaces in the expected out? Can't we do strip() somewhere in the code and output xml without new lines and white spaces?

The spaces are just in the DTD, that is a copy paste of the DTD as
defined in the HACKING file. That's the only part with spaces and
newlines. The XML output from the "parser" is just a one-...

[Milo Casagrande (milo)]

On Fri, Sep 7, 2012 at 10:34 AM, Milo Casagrande
<email address hidden> wrote:
>
> The spaces are just in the DTD, that is a copy paste of the DTD as
> defined in the HACKING file. That's the only part with spaces and
> newlines. The XML output from the "parser" is just a one-liner.

Forgot to say that I will remove the spaces and newlines from the DTD
and make a one single line.

--
Milo Casagrande
Infrastructure Engineer
Linaro.org <www.linaro.org> │ Open source software for ARM SoCs

[Stevan Radaković (stevanr)]

On 09/07/2012 10:43 AM, Milo Casagrande wrote:
> On Fri, Sep 7, 2012 at 10:34 AM, Milo Casagrande
> <email address hidden> wrote:
>> The spaces are just in the DTD, that is a copy paste of the DTD as
>> defined in the HACKING file. That's the only part with spaces and
>> newlines. The XML output from the "parser" is just a one-liner.
> Forgot to say that I will remove the spaces and newlines from the DTD
> and make a one single line.
>
hmm, you can use textwrap.dedent("""...""") as an alternative...

[Stevan Radaković (stevanr)]

On 09/07/2012 10:37 AM, Milo Casagrande wrote:
> Hello Stevan,
>
> thanks for the review!
>
> On Thu, Sep 6, 2012 at 3:55 PM, Stevan Radaković
> <email address hidden> wrote:
>> Review: Needs Fixing
>>
>> Hey Milo great work !!1
>> Before discussing the dict necessity with danilo, I'll do a review here and lets land this, with tendency to refactor things later.
>>
>>
>>
>> === modified file 'dashboard/frontend/android_textfield_loop/tests/test_android_textfield_loop_model.py'
>> --- dashboard/frontend/android_textfield_loop/tests/test_android_textfield_loop_model.py 2012-09-05 13:59:57 +0000
>> +++ dashboard/frontend/android_textfield_loop/tests/test_android_textfield_loop_model.py 2012-09-06 11:09:25 +0000
>> @@ -24,9 +24,9 @@
>>
>> A_NAME = 'a-build'
>> B_NAME = 'b-build'
>> - VALID_VALUES = 'a=2\nb=3'
>> + VALID_VALUES = u'a=2\nb=3'
>> VALID_LINES = ['a=2', 'b=3']
>> - NON_VALID_VALUES = 'a:2\nb=3'
>> + NON_VALID_VALUES = u'a:2\nb=3'
>> NON_VALID_LINES = ['a:2', 'b=3']
>> VALID_DICT = {'a': '2', 'b': '3'}
>>
>> @@ -52,6 +52,7 @@
>> def test_valid_values_wrong(self):
>> self.assertEqual((False, self.NON_VALID_LINES),
>> AndroidTextFieldLoop.valid_values(
>> +<<<<<<< TREE
>> self.NON_VALID_VALUES))
>>
>> def test_schedule_build(self):
>> @@ -62,3 +63,27 @@
>> def test_schedule_build_invalid(self):
>> build = self.non_valid_android_loop.schedule_build()
>> self.assertEqual(build.result_xml, {})
>> +=======
>> + self.NON_VALID_VALUES))
>> +
>> + def test_schedule_build(self):
>> + build = self.android_loop.schedule_build()
>> + expected_out = '<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE ' \
>> + 'loop [\n <!ELEMENT loop (description?,fields)>\n' \
>> + ' <!ELEMENT description (#PCDATA)>\n ' \
>> + '<!ELEMENT fields (field+)>\n <!ELEMENT field ' \
>> + '(#PCDATA)>\n <!ATTLIST field name CDATA ' \
>> + '#REQUIRED>\n <!ATTLIST field type (text|int|bool) ' \
>> + '"text">\n]><loop><fields><field name="a">2</field>' \
>> + '<field name="b">3</field><field name="name">a-build' \
>> + '</field><field name="is_restricted">False</field>' \
>> + '<field name="is_official">False</field>' \
>> + '<field name="type">AndroidTextFieldLoop</field>' \
>> + '</fields></loop>'
>> + self.assertEqual(expected_out, build.result_xml)
>> + self.assertEqual(build.status, "success")
>> +
>> + def test_schedule_build_invalid(self):
>> + build = self.non_valid_android_loop.schedule_build()
>> + self.assertEqual("", build.result_xml)
>> +>>>>>>> MERGE-SOURCE
>>
>>
>> What's with all the white spaces in the expected out? Can't we do strip() somewhere in the code and output xml without new lines and white spaces?
> The spaces are just in the DTD, that is a copy paste of the DTD as
> de...

[lp:~milo/linaro-ci-dashboard/xml-to-dict]

45. By Milo Casagrande on 2012-09-06

Merged from trunk.

46. By Milo Casagrande on 2012-09-07

Fixes for review.

47. By Milo Casagrande on 2012-09-07

Fixed assertion.

48. By Milo Casagrande on 2012-09-07

PEP8 fixes.

49. By Milo Casagrande on 2012-09-07

Added some tests.

50. By Milo Casagrande on 2012-09-07

Added note, fixed some tests.

51. By Milo Casagrande on 2012-09-07

Fixed reference.

52. By Milo Casagrande on 2012-09-07

Removed comment.

[Milo Casagrande (milo)]

On Fri, Sep 7, 2012 at 12:28 PM, Stevan Radaković
<email address hidden> wrote:
>
> Good idea... We could also check if we can somehow make use of the
> 'exclude' option in the Meta subclass for filtering out the fields; or
> create our own option if it's not good match for us.

Unfortunately, we can't. The exclude option in the Meta class is only
available for the class that inhertis from Form, not for the models.
I pushed the last changes into the branch associated with this MP.

There is a "problem" also with using "model_to_dict": not all the
fields will be serialized to a dictionary. I wrote a note in the code.
The problem is with fields set as "editable=False". That parameter is
used with Form display, but since the "model_to_dict" is a function
taken from the "forms" part of Django, that parameter applies here as
well, so we do not get back everything, even if we include it in the
list of fields we want back.

I tried also with the serializers, but we would need to craft the
correct query, since the filter and exlude functions on serializers
need to have actual values to operate (we would end up doing
pk=self.pk, etc...).
The other options I see are or using getattr, or through
obj.__dict__['field_string']. With both approaches we would still need
to pass a list of fields we want or we want to exclude.
Ciao.

--
Milo Casagrande
Infrastructure Engineer
Linaro.org <www.linaro.org> │ Open source software for ARM SoCs

[Stevan Radaković (stevanr)]

Looks much better Milo.
Thanks for addressing all the comments and cleaning up things.
Approve +1.

review: Approve

=== modified file 'HACKING'
--- HACKING	2012-09-05 16:50:12 +0000
+++ HACKING	2012-09-07 12:52:19 +0000
@@ -67,7 +67,7 @@
     <!ELEMENT fields (field+)>
     <!ELEMENT field (#PCDATA)>
     <!ATTLIST field name CDATA #REQUIRED>
-    <!ATTLIST field type (text|int|bool) "text">
+    <!ATTLIST field type (str|int|bool) "str">
 ]>
 <loop>
     <fields>

=== modified file 'dashboard/frontend/android_textfield_loop/models/android_textfield_loop.py'
--- dashboard/frontend/android_textfield_loop/models/android_textfield_loop.py	2012-09-05 13:07:59 +0000
+++ dashboard/frontend/android_textfield_loop/models/android_textfield_loop.py	2012-09-07 12:52:19 +0000
@@ -23,6 +23,9 @@
     class Meta:
         app_label = 'android_textfield_loop'
 
+    # Fields we want in the XML for chaining.
+    XML_INCLUDE_LIST = ['name', 'is_official', 'is_restricted']
+
     def save(self, *args, **kwargs):
         self.type = self.__class__.__name__
         super(self.__class__, self).save(*args, **kwargs)

=== modified file 'dashboard/frontend/android_textfield_loop/templates/android_textfield_loop_create.html'
--- dashboard/frontend/android_textfield_loop/templates/android_textfield_loop_create.html	2012-08-31 15:21:11 +0000
+++ dashboard/frontend/android_textfield_loop/templates/android_textfield_loop_create.html	2012-09-07 12:52:19 +0000
@@ -6,14 +6,6 @@
     <form name="{{ form_name }}" action="{% url AndroidTextFieldLoopCreate %}" method="post">
     {% csrf_token %}
 {% endblock create_form %}
-
-{% if form.non_field_errors %}
-    <div class="form_error">
-        {% for err in form.non_field_errors %}
-            <div class="error_message">{{ err }}</div>
-        {% endfor %}
-    </div>
-{% endif %}
 {{ form.as_p }}
         <div><input type="submit" value="Submit" /></div>
     </form>

=== modified file 'dashboard/frontend/android_textfield_loop/tests/test_android_textfield_loop_model.py'
--- dashboard/frontend/android_textfield_loop/tests/test_android_textfield_loop_model.py	2012-09-05 13:59:57 +0000
+++ dashboard/frontend/android_textfield_loop/tests/test_android_textfield_loop_model.py	2012-09-07 12:52:19 +0000
@@ -18,15 +18,16 @@
 from django.test import TestCase
 from frontend.android_textfield_loop.models.android_textfield_loop \
     import AndroidTextFieldLoop
+from dashboard.lib.xml_fields import XML_START
 
 
 class AndroidTextFieldLoopModelTest(TestCase):
 
     A_NAME = 'a-build'
     B_NAME = 'b-build'
-    VALID_VALUES = 'a=2\nb=3'
+    VALID_VALUES = u'a=2\nb=3'
     VALID_LINES = ['a=2', 'b=3']
-    NON_VALID_VALUES = 'a:2\nb=3'
+    NON_VALID_VALUES = u'a:2\nb=3'
     NON_VALID_LINES = ['a:2', 'b=3']
     VALID_DICT = {'a': '2', 'b': '3'}
 
@@ -56,9 +57,17 @@
 
     def test_schedule_build(self):
         build = self.android_loop.schedule_build()
-        self.assertEqual(build.result_xml, self.VALID_DICT)
+        expected_out = (XML_START +
+                        '<loop><fields>'
+                        '<field name="a" type="str">2</field>'
+                        '<field name="is_restricted" type="bool">False</field>'
+                        '<field name="b" type="str">3</field>'
+                        '<field name="is_official" type="bool">False</field>'
+                        '<field name="name" type="str">a-build</field>'
+                        '</fields></loop>')
+        self.assertEqual(expected_out, build.result_xml)
         self.assertEqual(build.status, "success")
 
     def test_schedule_build_invalid(self):
         build = self.non_valid_android_loop.schedule_build()
-        self.assertEqual(build.result_xml, {})
+        self.assertEqual("", build.result_xml)

=== modified file 'dashboard/frontend/models/loop.py'
--- dashboard/frontend/models/loop.py	2012-09-04 14:51:52 +0000
+++ dashboard/frontend/models/loop.py	2012-09-07 12:52:19 +0000
@@ -44,7 +44,7 @@
     # List of fields to be excluded by default from the base64 encoded config.
     # If a subclass needs different fields, it is necessary to override this
     # variable.
-    EXCLUDE_LIST = ['id', 'name', 'server', 'loop_ptr']
+    EXCLUDE_LIST = ['id', 'server', 'loop_ptr', 'next_loop', 'name', 'type']
 
     def __init__(self, *args, **kwargs):
         self.log = Logger.getClassLogger(self)
@@ -79,13 +79,37 @@
             pass
         return build
 
-    def json(self):
+    def json(self, include=None, exclude=None):
         """Return Loop in a format suitable for serialization as JSON. The
-        method is called without underscores to be callabel from Django
+        method is called without underscores to be callable from Django
         templates.
+
+        :param include: the list of fields to be included
+        :type include list
+        :param exclude: the list of fields to be excluded
+        :return A dictionary of the model fields
         """
         from django.forms.models import model_to_dict
-        return model_to_dict(self)
+        # XXX
+        # This method will not return all the fields, even if they are in the
+        # include list. This is true for fields like 'type', that are set as
+        # 'editable=False'. Since that is a parameter for the form, and we are
+        # using a function from there, it applies here too.
+        return model_to_dict(self, include, exclude)
+
+    def dict_for_xml(self, include=None, exclude=None):
+        """
+        Get a dictionary representation of this loop to be serialized into an
+        XML form for chaining loop.
+
+        :param include: the list of fields to be included
+        :type include list
+        :param exclude: the list of fields to be excluded
+        :return A dictionary with the fields to be serialized.
+        """
+        # Done in this way, calling self.json, since we have it, but if we
+        # change the json representation, this needs to be changed as well.
+        return self.json(include, exclude)
 
     @staticmethod
     def can_chain_into():

=== modified file 'dashboard/frontend/models/loop_build.py'
--- dashboard/frontend/models/loop_build.py	2012-09-05 13:23:05 +0000
+++ dashboard/frontend/models/loop_build.py	2012-09-07 12:52:19 +0000
@@ -18,6 +18,7 @@
 
 from django.db import models
 from frontend.models.loop import Loop
+from dashboard.lib.xml_to_dict import XmlToDict
 
 
 class LoopBuild(models.Model):
@@ -47,3 +48,15 @@
             else:
                 self.build_number = 1
         super(LoopBuild, self).save(*args, **kwargs)
+
+    def get_build_result(self):
+        """
+        Returns a Python dictionary representation of the build XML stored.
+
+        :return A dictionary of the XML result.
+        """
+        dict_result = {}
+        if self.result_xml:
+            xml_to_dict = XmlToDict(self.result_xml)
+            dict_result = xml_to_dict.tree_to_dict()
+        return dict_result

=== modified file 'dashboard/frontend/models/textfield_loop.py'
--- dashboard/frontend/models/textfield_loop.py	2012-09-05 13:59:57 +0000
+++ dashboard/frontend/models/textfield_loop.py	2012-09-07 12:52:19 +0000
@@ -17,6 +17,7 @@
 
 from django.db import models
 from frontend.models.loop import Loop
+from dashboard.lib.xml_to_dict import DictToXml
 
 
 # Default delimiter to separate values from keys in the text field.
@@ -39,6 +40,11 @@
 
     values = models.TextField()
 
+    # List of fields to be included and excluded from serialization.
+    # Each subclass should override these two variables.
+    XML_INCLUDE_LIST = None
+    XML_EXCLUDE_LIST = None
+
     def schedule_build(self, parameters=None):
         from frontend.models.loop_build import LoopBuild
         build = LoopBuild()
@@ -46,7 +52,7 @@
         build.duration = 0.00
 
         try:
-            build.result_xml = self.values_to_dict()
+            build.result_xml = self.values_to_xml()
             build.status = 'success'
         except:
             build.status = 'failure'
@@ -54,15 +60,24 @@
         build.save()
         return build
 
-    def values_to_dict(self):
+    def values_to_dict(self, valid=None, lines=None):
         """
         Returns a dictionary representation of the values inserted. The
         key<>value pairs are split on DEFAULT_DELIMITER.
 
-        :return A dictionary of the values inserted.
+        The default parameters are used for a second iteration of this function
+        if we do not want to parse again the lines, but we only want to get the
+        dictionary.
+
+        :param valid: If the lines are valid or not.
+        :type valid bool
+        :param lines: The list of lines in the text field.
+        :type lines list
+        :return A dictionary of the values inserted in the text field.
         """
         text_to_dict = {}
-        valid, lines = self.valid_values(self.values)
+        if valid is None and lines is None:
+            valid, lines = self.valid_values(self.values)
 
         if valid:
             for line in lines:
@@ -79,7 +94,7 @@
 
         :param values: the string with all the key<>value pairs, separated with
         a newline character.
-        :type str
+        :type values unicode
         :return a boolean for the validity, and the list of lines.
         """
         valid = True
@@ -91,3 +106,21 @@
                 valid = False
                 break
         return valid, lines
+
+    def values_to_xml(self):
+        """
+        Converts the necessary values into an XML tree.
+
+        :return The XML tree as a string, or an empty string if the inserted
+        values are not valid.
+        """
+        xml_string = ""
+        valid, lines = self.valid_values(self.values)
+        if valid:
+            values = self.values_to_dict(valid, lines)
+            other_values = self.dict_for_xml(include=self.XML_INCLUDE_LIST,
+                                             exclude=self.XML_EXCLUDE_LIST)
+            if other_values:
+                values.update(other_values)
+            xml_string = DictToXml(values).dict_to_tree()
+        return xml_string

=== modified file 'dashboard/frontend/tests/__init__.py'
--- dashboard/frontend/tests/__init__.py	2012-09-03 08:18:10 +0000
+++ dashboard/frontend/tests/__init__.py	2012-09-07 12:52:19 +0000
@@ -2,6 +2,7 @@
 from dashboard.frontend.tests.test_models import *
 from dashboard.frontend.tests.test_clientresponse import *
 from dashboard.frontend.tests.test_custom_commands import *
+from dashboard.frontend.tests.test_xml_to_dict import *
 
 
 #starts the test suite
@@ -14,4 +15,6 @@
            'LoopTests': LoopTest,
            'ClientResponseTests': ClientResponseTests,
            'JenkinsCommandTest': JenkinsCommandTest,
+           'XmlToDictTest': XmlToDictTest,
+           'DictToXmlTest': DictToXmlTest,
            }

=== modified file 'dashboard/frontend/tests/test_models.py'
--- dashboard/frontend/tests/test_models.py	2012-09-04 11:56:22 +0000
+++ dashboard/frontend/tests/test_models.py	2012-09-07 12:52:19 +0000
@@ -26,6 +26,7 @@
   import AndroidTextFieldLoop
 from lib.model_getter import ModelGetter
 
+
 class LoopTest(TestCase):
 
     def setUp(self):
@@ -42,6 +43,11 @@
         self.android_loop.build_type = "build-android"
         self.android_loop.save()
 
+        self.loop = Loop()
+        self.loop.name = 'a-loop'
+        self.loop.type = Loop.__class__.__name__
+        self.loop.save()
+
     def test_get_child_object(self):
         loop = Loop.objects.get(id=1)
         self.assertEqual("testjob_integration", loop.get_child_object().name)
@@ -49,7 +55,6 @@
         self.assertEqual("IntegrationLoop",
                          loop.get_child_object().__class__.__name__)
 
-
     def test_get_all_chainable_integration_empty(self):
         chainable_loops = IntegrationLoop.get_all_chainable()
         # Integration loop does not have any chainable loops
@@ -64,3 +69,26 @@
     def test_model_getter_unique_model(self):
         all_models = [model.__name__ for model in get_models()]
         self.assertTrue(len(all_models) == len(set(all_models)))
+
+    def test_model_json(self):
+        expected_out = {'next_loop': None, 'name': 'a-loop', 'server': None,
+                        'is_restricted': False, 'is_official': False, 'id': 3}
+        self.assertEqual(expected_out, self.loop.json())
+
+    def test_model_dict_for_xml(self):
+        expected_out = {'next_loop': None, 'name': 'a-loop', 'server': None,
+                        'is_restricted': False, 'is_official': False, 'id': 3}
+        self.assertEqual(expected_out, self.loop.dict_for_xml())
+
+    def test_model_dict_for_xml_with_include(self):
+        include_list = ['name', 'is_restricted']
+        expected_out = {'name': 'a-loop', 'is_restricted': False}
+        self.assertEqual(expected_out,
+                         self.loop.dict_for_xml(include=include_list))
+
+    def test_model_dict_for_xml_with_exclude(self):
+        exclude_list = ['is_restricted', 'name']
+        expected_out = {'next_loop': None, 'server': None,
+                        'is_official': False, 'id': 3}
+        self.assertEqual(expected_out,
+                         self.loop.dict_for_xml(exclude=exclude_list))

=== added file 'dashboard/frontend/tests/test_xml_to_dict.py'
--- dashboard/frontend/tests/test_xml_to_dict.py	1970-01-01 00:00:00 +0000
+++ dashboard/frontend/tests/test_xml_to_dict.py	2012-09-07 12:52:19 +0000
@@ -0,0 +1,293 @@
+# Copyright (C) 2012 Linaro
+#
+# This file is part of linaro-ci-dashboard.
+#
+# linaro-ci-dashboard is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# linaro-ci-dashboard is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with linaro-ci-dashboard.  If not, see <http://www.gnu.org/licenses/>.
+
+from django.test import TestCase
+import os
+from dashboard.lib.xml_to_dict import (
+    XmlToDict,
+    DictToXml
+)
+from dashboard.lib.xml_fields import (
+    LOOP_ELEMENT,
+    FIELDS_ELEMENT,
+    TYPE_ATTR,
+    NAME_ATTR,
+    XML_START,
+    INT_TYPE,
+    BOOL_TYPE,
+    STR_TYPE,
+)
+
+
+# XML tags
+ROOT_TAG_OPEN = '<loop>'
+ROOT_TAG_CLOSE = '</loop>'
+FIELDS_TAG_OPEN = '<fields>'
+FIELDS_TAG_CLOSE = '</fields>'
+VALID_FIELD = '<field name="%(field_name)s">%(field_value)s</field>'
+VALID_FIELD_WITH_TYPE = ('<field name="%(field_name)s" '
+                         'type="%(field_type)s">%(field_value)s</field>')
+
+# Field names, types and values used as defaults for the tests.
+LOOP_TYPE_VAL = 'text-build'
+LOOP_NAME_VAL = 'build-test'
+BUILD_TYPE = 'build_type'
+BUILD_TYPE_VAL = 'build-android'
+REPO_QUIET = 'repo_quiet'
+REPO_QUIET_VAL = True
+BUILD_FS_IMAGE = 'build_fs_image'
+BUILD_FS_IMAGE_VAL = False
+MAKE_JOBS = 'make_jobs'
+MAKE_JOBS_VAL = 2
+
+NEWLINE = os.linesep
+# Used to create the needed dictionary for fields creation.
+# The dictionary has to be:
+# {FIELD_NAME: value, FIELD_VALUE: value [, FIELD_TYPE: value]}
+# FIELD_TYPE is optional.
+FIELD_NAME = 'field_name'
+FIELD_VALUE = 'field_value'
+FIELD_TYPE = 'field_type'
+
+FIELDS = [
+        {FIELD_NAME: BUILD_TYPE, FIELD_VALUE: BUILD_TYPE_VAL},
+        {FIELD_NAME: REPO_QUIET, FIELD_TYPE: BOOL_TYPE,
+         FIELD_VALUE: REPO_QUIET_VAL},
+        {FIELD_NAME: BUILD_FS_IMAGE, FIELD_TYPE: BOOL_TYPE,
+         FIELD_VALUE: BUILD_FS_IMAGE_VAL},
+        {FIELD_NAME: MAKE_JOBS, FIELD_TYPE: INT_TYPE,
+         FIELD_VALUE: MAKE_JOBS_VAL},
+        {FIELD_NAME: NAME_ATTR, FIELD_VALUE: LOOP_NAME_VAL},
+        {FIELD_NAME: TYPE_ATTR, FIELD_VALUE: LOOP_TYPE_VAL}
+]
+
+VALID_START = XML_START + ROOT_TAG_OPEN
+VALID_CLOSE = ROOT_TAG_CLOSE
+
+
+def create_xml_fields(fields_list):
+    """
+    Support functions to create the <fields><field>... hierarchy.
+
+    :param fields_list: the list of fields to create. Each field has to be
+    a dictionary with FIELD_NAME, FIELD_VALUE and optional FIELD_TYPE keys.
+    :type fields_list list
+    """
+    assert isinstance(fields_list, list)
+    fields_xml = FIELDS_TAG_OPEN
+
+    for field in fields_list:
+        if field.get(FIELD_TYPE, None) is not None:
+            fields_xml += VALID_FIELD_WITH_TYPE % field
+        else:
+            fields_xml += VALID_FIELD % field
+    fields_xml += FIELDS_TAG_CLOSE
+    return fields_xml
+
+
+class XmlToDictTest(TestCase):
+    """
+    Test class for the conversion from XML to Python dictionary.
+    The XML specification is taken from the HACKING file.
+    """
+
+    def setUp(self):
+        super(XmlToDictTest, self).setUp()
+        self.xml_string = VALID_START
+        self.xml_string += create_xml_fields(FIELDS)
+        self.xml_string += VALID_CLOSE
+        self.xml_to_dict = XmlToDict(self.xml_string)
+
+    def test_get_element_from_root(self):
+        """
+        Tests retrieval of the elements in the XML tree, but the root.
+        """
+        self.assertEqual(self.xml_to_dict.get_elements_from_root()[0].tag,
+                         FIELDS_ELEMENT)
+
+    def test_get_element_by_name_correct(self):
+        """Tests retrieving of an element with a correct name."""
+        self.assertEqual(FIELDS_ELEMENT,
+                         self.xml_to_dict.get_element_by_name(
+                             FIELDS_ELEMENT).tag)
+
+    def test_get_element_by_name_wrong(self):
+        """ Tests retrieving of an element with a wrong name."""
+        self.assertEqual(None,
+                         self.xml_to_dict.get_element_by_name('wrong'))
+
+    def test_elements_to_dict(self):
+        """
+        Tests creation of a dictionary with multiple elements.
+        """
+        expected_output = {MAKE_JOBS: MAKE_JOBS_VAL,
+                           BUILD_TYPE: BUILD_TYPE_VAL,
+                           BUILD_FS_IMAGE: BUILD_FS_IMAGE_VAL,
+                           REPO_QUIET: REPO_QUIET_VAL,
+                           NAME_ATTR: LOOP_NAME_VAL,
+                           TYPE_ATTR: LOOP_TYPE_VAL}
+        element = self.xml_to_dict.get_element_by_name(FIELDS_ELEMENT)
+        self.assertEqual(expected_output,
+                         self.xml_to_dict.element_to_dict(element))
+
+    def test_bool_true_conversion(self):
+        """
+        Tests the True bool conversion.
+        """
+        expected_out = {'a-field': True}
+        for value in ['1', 1, 'y', 'Yes', True, 'True']:
+            local_xml = VALID_START
+            fields_list = [{FIELD_NAME: 'a-field',
+                            FIELD_TYPE: BOOL_TYPE,
+                            FIELD_VALUE: value}]
+            local_xml += create_xml_fields(fields_list)
+            local_xml += VALID_CLOSE
+            local_xml_to_dict = XmlToDict(local_xml)
+            element = local_xml_to_dict.get_element_by_name(FIELDS_ELEMENT)
+            self.assertEqual(expected_out,
+                             local_xml_to_dict.element_to_dict(element))
+
+    def test_bool_false_conversion(self):
+        """
+        Tests the False bool conversion.
+        """
+        expected_out = {'a-field': False}
+        for value in ['n', 0, 42, 'Yep', 'No', False, 'False', '?']:
+            local_xml = VALID_START
+            fields_list = [{FIELD_NAME: 'a-field',
+                            FIELD_TYPE: BOOL_TYPE,
+                            FIELD_VALUE: value}]
+            local_xml += create_xml_fields(fields_list)
+            local_xml += VALID_CLOSE
+            local_xml_to_dict = XmlToDict(local_xml)
+            element = local_xml_to_dict.get_element_by_name(FIELDS_ELEMENT)
+            self.assertEqual(expected_out,
+                             local_xml_to_dict.element_to_dict(element))
+
+    def test_int_conversion(self):
+        """
+        Tests the int conversion.
+        """
+        expected_out = {'a-field': 42}
+        for value in [42, '42', '42           ', '   42']:
+            local_xml = VALID_START
+            fields_list = [{FIELD_NAME: 'a-field',
+                            FIELD_TYPE: INT_TYPE,
+                            FIELD_VALUE: value}]
+            local_xml += create_xml_fields(fields_list)
+            local_xml += VALID_CLOSE
+            local_xml_to_dict = XmlToDict(local_xml)
+            element = local_xml_to_dict.get_element_by_name(FIELDS_ELEMENT)
+            self.assertEqual(expected_out,
+                             local_xml_to_dict.element_to_dict(element))
+
+    def test_str_conversion(self):
+        """
+        Tests the str conversion.
+        """
+        expected_out = {'a-field': '42'}
+        for value in [42, '42', '42           ', '   42']:
+            local_xml = VALID_START
+            fields_list = [{FIELD_NAME: 'a-field',
+                            FIELD_VALUE: value}]
+            local_xml += create_xml_fields(fields_list)
+            local_xml += VALID_CLOSE
+            local_xml_to_dict = XmlToDict(local_xml)
+            element = local_xml_to_dict.get_element_by_name(FIELDS_ELEMENT)
+            self.assertEqual(expected_out,
+                             local_xml_to_dict.element_to_dict(element))
+
+    def test_tree_to_dict(self):
+        """
+        Tests the conversion of a dictionary into a full XML tree.
+        """
+        expected_output = {
+            REPO_QUIET: REPO_QUIET_VAL,
+            NAME_ATTR: LOOP_NAME_VAL,
+            MAKE_JOBS: MAKE_JOBS_VAL,
+            TYPE_ATTR: LOOP_TYPE_VAL,
+            BUILD_TYPE: BUILD_TYPE_VAL,
+            BUILD_FS_IMAGE: BUILD_FS_IMAGE_VAL
+        }
+        self.assertEqual(expected_output, self.xml_to_dict.tree_to_dict())
+
+    def test_get_root_name(self):
+        """
+        Tests retrieving of the root element.
+        """
+        self.assertEqual(self.xml_to_dict.get_root(), LOOP_ELEMENT)
+
+    def test_get_root_attributes(self):
+        """
+        Tests retrieving of the root attributes.
+        """
+        self.assertEqual({}, self.xml_to_dict.get_root_attributes())
+
+
+class DictToXmlTest(TestCase):
+    """
+    Test class for the conversion from Python dictionary into XML.
+    The XML specification is taken from the HACKING file.
+    """
+
+    FIELDS_LIST = [
+            {FIELD_NAME: MAKE_JOBS, FIELD_VALUE: MAKE_JOBS_VAL,
+             FIELD_TYPE: INT_TYPE},
+            {FIELD_NAME: TYPE_ATTR, FIELD_VALUE: LOOP_TYPE_VAL,
+             FIELD_TYPE: STR_TYPE},
+            {FIELD_NAME: NAME_ATTR, FIELD_VALUE: LOOP_NAME_VAL,
+             FIELD_TYPE: STR_TYPE},
+    ]
+
+    VALID_DICT = {
+        NAME_ATTR: LOOP_NAME_VAL, TYPE_ATTR: LOOP_TYPE_VAL,
+        MAKE_JOBS: MAKE_JOBS_VAL
+    }
+
+    def setUp(self):
+        super(DictToXmlTest, self).setUp()
+        self.valid_xml = VALID_START
+        self.valid_xml += create_xml_fields(self.FIELDS_LIST)
+        self.valid_xml += VALID_CLOSE
+        self.dict_to_xml = DictToXml(self.VALID_DICT)
+
+    def test_dict_to_tree(self):
+        """
+        Tests dictionary to XML conversion.
+        """
+        self.assertEqual(self.valid_xml, self.dict_to_xml.dict_to_tree())
+
+    def test_dict_to_tree_with_bool(self):
+        """
+        Tests dictionary to XML conversion, with a bool inside, ElementTree
+        does not cope very well with bool type.
+        """
+        fields = [
+                {FIELD_NAME: REPO_QUIET, FIELD_VALUE: REPO_QUIET_VAL,
+                 FIELD_TYPE: BOOL_TYPE},
+                {FIELD_NAME: TYPE_ATTR, FIELD_VALUE: LOOP_TYPE_VAL,
+                 FIELD_TYPE: STR_TYPE},
+                {FIELD_NAME: NAME_ATTR, FIELD_VALUE: LOOP_NAME_VAL,
+                 FIELD_TYPE: STR_TYPE},
+        ]
+        dictionary = {TYPE_ATTR: LOOP_TYPE_VAL, NAME_ATTR: LOOP_NAME_VAL,
+                      REPO_QUIET: REPO_QUIET_VAL}
+        dict_2_xml = DictToXml(dictionary)
+        xml_string = VALID_START
+        xml_string += create_xml_fields(fields)
+        xml_string += VALID_CLOSE
+        self.assertEqual(xml_string, dict_2_xml.dict_to_tree())

=== modified file 'dashboard/lib/template.py'
--- dashboard/lib/template.py	2012-08-22 14:44:49 +0000
+++ dashboard/lib/template.py	2012-09-07 12:52:19 +0000
@@ -16,6 +16,7 @@
 # along with linaro-ci-dashboard.  If not, see <http://www.gnu.org/licenses/>.
 # Django settings for dashboard project.
 
+
 class AbstractTemplate(object):
     "Template class interface."
 

=== added file 'dashboard/lib/xml_fields.py'
--- dashboard/lib/xml_fields.py	1970-01-01 00:00:00 +0000
+++ dashboard/lib/xml_fields.py	2012-09-07 12:52:19 +0000
@@ -0,0 +1,47 @@
+# Copyright (C) 2012 Linaro
+#
+# This file is part of linaro-ci-dashboard.
+#
+# linaro-ci-dashboard is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# linaro-ci-dashboard is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with linaro-ci-dashboard.  If not, see <http://www.gnu.org/licenses/>.
+# Django settings for dashboard project.
+
+# The file contains all the necessary elements, tags and everything else
+# related to the XML representation of a chain-build.
+
+# All the XML valid elements.
+FIELD_ELEMENT = 'field'
+FIELDS_ELEMENT = 'fields'
+LOOP_ELEMENT = 'loop'
+DESCRIPTION_ELEMENT = 'description'
+
+# All the XML attributes.
+NAME_ATTR = 'name'
+TYPE_ATTR = 'type'
+
+# The valid types for element values.
+BOOL_TYPE = 'bool'
+INT_TYPE = 'int'
+STR_TYPE = 'str'
+VALID_TYPES = [BOOL_TYPE, INT_TYPE, STR_TYPE]
+
+# List of valid values considered as boolean True.
+VALID_TRUES = ['1', 'y', 'yes', 'Yes', 'True', 'true']
+
+# This is the start of the XML file. The DTD, if updated, needs to be updated
+# also in the HACKING file. This one is taken from the HACKING file.
+XML_START = ('<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE loop '
+             '[<!ELEMENT loop (description?,fields)><!ELEMENT description '
+             '(#PCDATA)><!ELEMENT fields (field+)><!ELEMENT field '
+             '(#PCDATA)><!ATTLIST field name CDATA #REQUIRED>'
+             '<!ATTLIST field type (str|int|bool) "str">]>')

=== added file 'dashboard/lib/xml_to_dict.py'
--- dashboard/lib/xml_to_dict.py	1970-01-01 00:00:00 +0000
+++ dashboard/lib/xml_to_dict.py	2012-09-07 12:52:19 +0000
@@ -0,0 +1,253 @@
+# Copyright (C) 2012 Linaro
+#
+# This file is part of linaro-ci-dashboard.
+#
+# linaro-ci-dashboard is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# linaro-ci-dashboard is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with linaro-ci-dashboard.  If not, see <http://www.gnu.org/licenses/>.
+# Django settings for dashboard project.
+
+import xml.etree.ElementTree as ET
+from dashboard.lib.xml_fields import *
+
+
+class XmlToDictException(Exception):
+    """
+    Exception for the XmlToDict class.
+    """
+
+
+class DictToXmlException(Exception):
+    """
+    Exception fro the DictToXml class.
+    """
+
+
+class XmlToDict(object):
+    """
+    Class to convert an XML string into a Python dictionary.
+    This applies to the XML as defined for the loop chaining.
+
+    Simple usage:
+        xml_2_dict = XmlToDict(xml_string).tree_to_dict()
+    """
+
+    def __init__(self, xml):
+        """
+        Initialize the XmlToDict class.
+
+        :param xml: The XML tree as a string.
+        :type xml str
+        """
+        if not isinstance(xml, str):
+            raise XmlToDictException("Type of parameter is not 'str', "
+                                     "got '%s' instead." % type(xml).__name__)
+        super(XmlToDict, self).__init__()
+        self.tree = ET.fromstring(xml)
+
+    def get_root(self):
+        """
+        Returns the name of the root of the XML tree.
+        :return The name of the root element.
+        """
+        return self.tree.tag
+
+    def get_root_attributes(self):
+        """
+        Returns a dictionary containing the attributes of the root element.
+
+        :return A dictionary with the attributes of the root element.
+        """
+        root_attr = {}
+        for item in self.tree.items():
+            root_attr[item[0]] = item[1]
+        return root_attr
+
+    def get_elements_from_root(self):
+        """
+        Returns the list of elements of the XML tree starting from the root.
+        :return A list with Element instances.
+        """
+        return list(self.tree)
+
+    def get_element_by_name(self, name):
+        """
+        Returns an element from the XML tree by its name.
+        :param name: the name of the element to get.
+        :type name str
+        :return An Element instance, None if not found.
+        """
+        return self.tree.find(name)
+
+    def element_to_dict(self, element):
+        """
+        Returns a dictionary representation of the provided XML element.
+
+        :param element: The Element to convert.
+        :type element Element
+        :return The dictionary representation of element.
+        """
+        if not isinstance(element, ET.Element):
+            raise XmlToDictException("Type of parameter is not 'Element', "
+                                     "got '%s' instead" %
+                                     type(element).__name__)
+        element_dict = {}
+        element_tag = element.tag
+        element_text = element.text
+
+        if element_text:
+            element_text = self._check_element_text(element_text)
+
+        attributes = element.items()
+        children = list(element)
+
+        # Special case for XML 'field' tag.
+        # 'field' tag must have a value and at least 'name' attribute set.
+        if element_tag == FIELD_ELEMENT:
+            if attributes:
+                element_name = element.get(NAME_ATTR)
+                element_type = element.get(TYPE_ATTR)
+                # Convert the value into the specified type.
+                value = self.convert_to_type(element_type, element.text)
+                element_dict[element_name] = value
+        else:
+            if attributes:
+                # Other case, we store all attributes as key<>value, plus also
+                # the tag name and its value if OK.
+                # There might be name collisions if XML is not well done.
+                for attribute in attributes:
+                    element_dict[attribute[0]] = attribute[1]
+                if element_text:
+                    element_dict[element_tag] = element_text
+            elif element_text:
+                element_dict[element_tag] = element_text
+        if children:
+            for child in children:
+                element_dict.update(self.element_to_dict(child))
+        return element_dict
+
+    def _check_element_text(self, text):
+        """
+        Check that the value contained in an XML element is valid, meaning it
+        is not an empty space, a newline. In these cases, we return None since
+        we do not want to have that element in the final dictionary.
+
+        :param text: The value contained between opening and closing XML tag.
+        :type text str
+        :return None if text is empty spaces or newlines, text otherwise.
+        """
+        # We do this since when we get nested elements, there might be 'valid'
+        # characters, like newlines or empty spaces, between the opening and
+        # closing tags, but we do not want to have such fields in the resulting
+        # dictionary.
+        import os
+        text = str(text).strip()
+        if text == os.linesep or len(text) == 0:
+            text = None
+        return text
+
+    def convert_to_type(self, value_type, value):
+        """
+        Converts a value of an XML element into the provided type. If type is
+        None, tha value is converted into a string.
+
+        :param value_type: The type of the resulting value.
+        :type value_type str
+        :param value: The value associated with the XML element.
+        :return The value converted into the specified type.
+        """
+        converted = str(value).strip()
+        if value_type == BOOL_TYPE:
+            if converted in VALID_TRUES:
+                converted = True
+            else:
+                converted = False
+        elif value_type == INT_TYPE:
+            converted = int(converted)
+
+        return converted
+
+    def tree_to_dict(self):
+        """
+        Create a dictionary out of the XML tree.
+
+        :return A python dictionary of the XML tree.
+        """
+        tree_dict = {}
+
+        root_dict = self.get_root_attributes()
+        elements_dict = {}
+        for element in self.get_elements_from_root():
+            elements_dict.update(self.element_to_dict(element))
+
+        if root_dict:
+            tree_dict.update(root_dict)
+
+        if elements_dict:
+            if tree_dict:
+                tree_dict.update(elements_dict)
+            else:
+                tree_dict = elements_dict
+
+        return tree_dict
+
+
+class DictToXml(object):
+    """
+    Class to convert a Python dictionary into an XML string .
+
+    Simple usage:
+        dict_2_xml = DictToXml(dictionary).dict_to_tree()
+    """
+
+    def __init__(self, dictionary):
+        """
+        Initialize the DictToXml class.
+
+        :param dictionary: The dictionary to convert.
+        :type dictionary dict
+        """
+        if not isinstance(dictionary, dict):
+            raise DictToXmlException("Type of parameter is not 'dict, "
+                                     "got '%s' instead." %
+                                     type(dictionary).__name__)
+        super(DictToXml, self).__init__()
+        self.dictionary = dictionary
+
+    def dict_to_tree(self):
+        """
+        Create an XML tree out of the provided dictionary. The XML structure
+        is defined in the HACKING file.
+
+        :return A string with the XML representation of the dictionary.
+        """
+        dict_to_xml = XML_START
+
+        loop = ET.Element(LOOP_ELEMENT)
+        fields = ET.SubElement(loop, FIELDS_ELEMENT)
+        for key, value in self.dictionary.iteritems():
+            # Get the type of the value. If it comes from Django, everything
+            # will be unicode type, we default to 'str'.
+            # TODO maybe have a mappings of fields<>type?
+            value_type = type(value).__name__
+            if not value_type in VALID_TYPES:
+                value_type = STR_TYPE
+            attrib = {NAME_ATTR: key, TYPE_ATTR: value_type}
+            field = ET.SubElement(fields, FIELD_ELEMENT, attrib)
+            # ElementTree cannot serialize boolean types.
+            field.text = str(value)
+
+        # Dump the XML and add it to the valid start with its DTD.
+        xml_dump = ET.tostring(loop)
+        dict_to_xml += xml_dump
+
+        return dict_to_xml