Working With Elements

There is virtually no escaping XML markup in one form or another when building modern applications. Whether HTML, SOAP, or some other dialect, XML has become an important standard to support in applications. Even if the application isn't a web application.

Thankfully, most programming languages have built-in library support for reading and manipulating XML. Some are better than others. For instance, the ElementTree Python package is probably the easiest library for developers to work with. It doesn't add unnecessary complexity on top of a simplistic standard.

The ElementTree package is now part of the growing set of standard Python modules included in the distribution. Since the module can be used to both read and write XML data, it cuts down on dependencies. Most XML libraries support both reading and writing of XML data, but like any other library type, it may do one well but not the other.

The following is an example of how easy it is to not only use the ElementTree package to build an XML document, but also to add abstractions around the elements that are created.

#Example; Abstracting elements.

#Do element tree imports.
from xml.etree.ElementTree import Element, tostring

#The base DOM element.
class Dom(object):
   def __init__(self, name, **kw):
      
       #Create the element and set the attributes.
       self._element=Element(name)
       for i in kw.keys():
           self._element.attrib[i]=kw[i]

   #Set an element attribute.
   def __setitem__(self, name, value):
       self._element.attrib[name]=value
      
   #Get an attribute.
   def __getitem__(self, name):
       return self._element.attrib(name)
  
   #Append a sub-element.
   def append(self, value):
       self._element.append(value._element)

#A specialized Dom class for accepting raw text content.        
class DomContent(Dom):
  
   #Constructor.
   def __init__(self, name, content=None, **kw):
       Dom.__init__(self, name, **kw)
       self._element.text=content

#Common HTML elements.
class Head(Dom):
   def __init__(self):
       Dom.__init__(self, "head")
      
class Title(DomContent):
   def __init__(self, content, **kw):
       DomContent.__init__(self, "title", content, **kw)
      
class Body(Dom):
   def __init__(self):
       Dom.__init__(self, "body")
      
class Div(DomContent):
   def __init__(self, content, **kw):
       DomContent.__init__(self, "div", content, **kw)

#The root document.
class Document(Dom):
   def __init__(self, title):
       Dom.__init__(self, "html")

       #Initialize the head, title, and body elements.
       self.head=Head()
       self.title=Title(title)
       self.body=Body()
      
       #Add the title element to the head element.
       self.head.append(self.title)
      
       #Add the head and body elements to the document.
       self.append(self.head)       
       self.append(self.body)
      
   #Actual output.
   def __str__(self):
       return tostring(self._element)
      
#Main.
if __name__=="__main__":
  
   #Initialize the document with a title.
   my_doc=Document("My Document")
  
   #Create a div with content and an attribute.
   my_div=Div("My Div", style="float: left;")
  
   #Add the div to the body.
   my_doc.body.append(my_div)
  
   #Display.
   print my_doc

In this example, we construct a simple HTML page. The Dom class is the topmost level abstraction that we create around ElementTree. The Dom class is meant to represent any HTML tags that are placed in the HTML page. The Dom._element attribute represents the actual ElementTree element. The Dom constructor will give the element attribute values based on what keyword parameters were passed to the constructor. The Dom.__getitem__() and Dom.__setitem__() methods allow element attributes to be get and set respectively. The Dom.append() method allows other Dom instances to be attached to the current instance as a sub-element.

The DomContent class is a simple specialization of the Dom class. The DomContent class accepts an additional content parameter, otherwise, the class isn't really any different than its' base class.

The Head, Title, Body, and Div classes are all standard HTML specializations of the Dom class. The main difference being that Title and Div inherit from DomContent instead of Dom because they support raw text content.

The Document class is a helper type of abstraction. It assembles Dom elements common in all HTML pages we might want to build. It is the Document class that makes the main program trivial to read and understand.