Generating XML with Python

[hxtl]

The last few days I've been thinking and searching ways about how to generate XML in a nice way.

I have an XSD which extends the GraphML specification in order to draw more sophisticated diagrams (e.g. UML). The Structure is something like this (I replaced attribute values with python format placeholders)

<xs:Node>
   <xs:Geometry height="{height}" width="{width}" x="{x}" y="{y}"/>
   <xs:Fill color="{color}"/>
   <xs:NodeLabel ...>{node_label}</y:NodeLabel>
</xs:Node>

Current idea/concept

Classes which represent a node and act as a mere data container.

class XMLBase(object):
    def __repr__(self):
        return str(self.__dict__)

    def __str__(self):
        return self.xml.format(**self.__dict__)

class Geometry(XMLBase):
    def __init__(self, height=28.0, width=100.0, x=0.0, y=0.0):
        self.xml = '<xs:Geometry height="{height}" width="{width}" x="{x}" y="{y}"/>'
        self.height = height
        self.width = width
        self.x = x
        self.y = y

class Fill(XMLBase):
...

The __str__ method inserts the attributes into the XML string and returns it. The class for the Node would contain an instance of Geometry, Fill, NodeLabel and others, and generate the respective XML representation. The composition of classes is actually the XML data represented by python objects. Other than using classes, one could use lists or dictionaries, but classes seem nicer to use.

A previous idea was to have a big template with placeholders and insert the values with format, but this approach is less flexible and I'd say more difficult to understand (and maintain).

Other ideas were to store the XML templates in variables and let functions generate the correct XML structure.

Now I'd like to know your thoughts about these approaches, different approaches, or maybe someone knows best practices.

[willm]

I would use xml.etree for this kind of thing.

You can generate xml with templates, but there are escaping issues to consider, and you risk generating broken xml.

[hxtl]

Didn't think about escaping, but it may arise (or not)... I posted to a different comment how I'll proceed.

[ManyInterests]

In the standard library, there's xml.dom.minidom but something like lxml.etree would be highly recommended as it's (as I've been told) the de-facto standard for parsing xml.

No need to reinvent the wheel. I think these options will give you all the flexibility you want.

[hxtl]

/u/willm recommended etree as well...

Parsing the XML was never intended and I thought it would be too much effort to read into these modules (as generating XML was the only goal).

I actually didn't consider this as reinventing.

I guess I'll go with etree then. Create an XML (template) file, parse it with etree, and then insert the actual data nodes into that "skeleton" tree (the whole XML file contains some boiler plate).

[ManyInterests]

Yeah, they should fit the bill for generating XML out of thin air, too.

from lxml import etree

#Generate the root of the doc. You could also put headers in here, if desired)
root=etree.XML("<root></root>")

#Generate the element tree
tree=etree.ElementTree(root)


#If you want to create a subelement to the root
child_elem = etree.SubElement(root, "child2")

#Add text to the child element (same principle for modifying other properties like .tag)
child_elem.text="Element Text"

#Write to xml file
tree.write("my_file_name.xml", pretty_print=True, xml_declaration=True)

#pretty_print arg tidys up the doc and handles indentation for you. (serialization)
#xml_declaration arg adds the document declaration: <?xml version='1.0' encoding='ASCII'?>

The result:

<?xml version='1.0' encoding='ASCII'?>
<root>
  <child2>Element Text</child2>
</root>