ElementTree Wrapper (Python recipe) by David Pokorny

ActiveState Code (http://code.activestate.com/recipes/576445/)

from xml.etree import cElementTree
import re

#Compatibility with 3.0
try:
  #3.x
  import io
  def is_file(ob):
    return isinstance(ob, io.IOBase)
  def is_text(ob):
    return type(ob) == str
except:
  #2.x
  def is_file(ob):
    return isinstance(ob, file)
  def is_text(ob):
    return isinstance(ob, basestring)


def attr_str(obj):
  return ' '.join('%s = "%s"' % (key,value) for key,value in obj.items())

def text(obj):
  if type(obj) in (int,float):
    return str(obj)
  elif is_text(obj):
    return obj
  return str(obj)

PREFIX_PAT = re.compile('(\{.*\})')

class xml(object):
  """
  Usage:
    xml(tag, child, ..., attr = value, ...)
      returns new element with specified child elements and attributes
    xml(tag, text, child, ..., attr = value, ...)
      returns new element with specified text, child elements, and attributes
    xml(literal)
      returns new element for literal xml string
    xml(xmlable)
      returns xmlable.__xml__()

  Example:
    from xmlwrapper import xml
    table_elt = xml('table', xml('tr',xml('td',"header",colspan = "2")),
                             xml('tr',xml('td',xml('b',"bold text")),
                                      xml('td',"plain text")))
    table_elt['border'] = "1"
    open("test.html","w").write(str(xml('html',xml('body',table_elt))))
    print table_elt.navlist('tr')

  Example of __xml__ interface:
    class xmldict(dict):
      def __xml__(self):
        xml_elt = xml('dict')
        for key in self:
          xml_elt.append(xml('dictent',xml('key',str(key)),
                                       xml('value',str(self[key]))))
        return xml_elt

    e = xmldict()
    e['foo'] = 'bar'
    print xml(e)
  """
  def __new__(cls,tag,thing = None,*args,**kwargs):
    if hasattr(tag,'__xml__'):
      return tag.__xml__()
    self = object.__new__(xml)
    if cElementTree.iselement(tag):
      self.__content = tag
    elif isinstance(tag,cElementTree.ElementTree):
      self.__content = tag.getroot()
    elif is_file(tag):
      self.__content = cElementTree.parse(tag).getroot()
    elif isinstance(tag,str) and len(tag) > 0 and tag[0] == '<':
      self.__content = cElementTree.fromstring(tag)
    else:
      if type(tag) != str:
        raise TypeError("Cannot convert %s object to xml" % str(type(tag)))
      self.__content = cElementTree.fromstring('<%s/>' % tag)
      if is_text(thing) or type(thing) == int:
        self.__content.text = text(thing)
      elif thing != None:
        self.append(xml(thing))
      for subthing in args:
        self.append(xml(subthing))
      for key,value in kwargs.items():
        if key == '__class' or key == 'klass':
          self['class'] = value
        else:
          self[key] = value
    if '{' in self.__content.tag:
      self.__prefix = PREFIX_PAT.search(self.__content.tag).groups()[0]
    else:
      self.__prefix = ''
    return self
  def clear(self):
    self.__content.clear()
  def append(self,xml_obj):
    assert type(xml_obj) == xml
    self.__content.append(xml_obj.__content)
  def setprefix(self, prefix):
    self.__prefix = prefix
  def getprefix(self):
    return self.__prefix
  def remove(self,xml_obj):
    assert type(xml_obj) == xml
    self.__content.remove(xml_obj.__content)
  def __xml__(self):
    return self
  def __str__(self):
    return cElementTree.tostring(self.__content)
  def __repr__(self):
    return str(self)
  def __getitem__(self,attr):
    qattr = self.__prefix + attr
    if qattr in self.__content.keys():
      return self.__content.get(qattr)
    raise AttributeError("<%s> element does not have attribute %s" % (self.tag, attr))
  def get(self,attr, default):
    return self.__content.get(self.__prefix + attr, default)
  def __setitem__(self,attr,value):
    assert type(attr) == str and type(value) == str
    self.__content.set(attr,value)
  def getxml(self):
    return self.__content
  def __get_text(self):
    if self.__content.text:
      return self.__content.text
    return ''
  def __set_text(self, value):
    if not is_text(value):
      raise ValueError("xmlwrapper: cannot set text of element to object of type %s" % str(type(value)))
    self.__content.text = value
  text = property(__get_text,__set_text)
  def __get_tag(self):
    return self.__strip_key(self.__content.tag)
  def __set_tag(self,tag_value):
    assert type(tag_value) == str
    self.__content.tag = self.__prefix + tag_value
  tag = property(__get_tag,__set_tag)
  def pretty_list(self):
    str_list = []
    for child_elt in self.__content.getchildren():
      for pretty_str in xml(child_elt).pretty_list():
        str_list.append(pretty_str)
    str_list = ["  " + pretty_str for pretty_str in str_list]
    head_str = ' '.join(str_item for str_item in [self.tag, attr_str(self.__content.attrib)] if str_item.strip())
    if str_list:
      str_list = ["<%s>" % head_str, self.text] + str_list + ["</%s>" % self.tag]
    elif self.text:
      str_list = ["<%s>%s</%s>" % (head_str, self.text, self.tag)]
    else:
      str_list = ["<%s/>" % head_str]
    return str_list
  def pretty(self):
    return '\n'.join(pretty_str for pretty_str in self.pretty_list() if pretty_str.strip())
  def __strip_key(self,key):
    return key[len(self.__prefix):]
  def keys(self):
    return [self.__strip_key(key) for key in self.__content.keys()]
  def attrs(self):
    return self.keys()
  def items(self):
    return [(self.__strip_key(k),v) for k,v in self.__content.items()]
  def iterattrs(self):
    return self.__content.attrib.iterkeys()
  def iterelts(self):
    return iter(xml(child_elt) for child_elt in self.__content.getchildren())
  def __iter__(self):
    return self.iterelts()
  def __len__(self):
    return len(self.__content.getchildren())
  def __path_from_list(self,tag_list):
    return './/' + '//'.join(self.__prefix + tag for tag in tag_list)
  def nav(self,*tag_list):
    path = self.__path_from_list(tag_list)
    return self.find(path)
  def navlist(self,*tag_list):
    return self.findall(self.__path_from_list(tag_list))
  def find(self,path):
    elt = self.__content.find(path)
    return xml(elt) if elt != None else None
  def findall(self,path):
    return [xml(elt) for elt in self.__content.findall(path)]
  def join(self,iterable):
    """
    Usage:
      elt.join(iterable)
        returns list of elements from iterable separated by elt

    Example:
      xml('html', xml('body', *xml('br').join(xml('span',text) for text in ['foo','bar','baz'])))
    """
    join_list = []
    for elt in iterable:
      assert type(elt) == xml
      join_list.append(elt)
      join_list.append(self)
    if len(join_list) > 0:
      join_list.pop()
    return join_list
  def extend(self,iterable):
    for elt in iterable:
      assert type(elt) == xml
      self.append(elt)

def test1():
  class xmldict(dict):
    def __xml__(self):
      xml_elt = xml('dict')
      for key in self:
        xml_elt.append(xml('dictent',xml('key',str(key)),
                                     xml('value',str(self[key]))))
      return xml_elt

  e = xmldict()
  e['foo'] = 'bar'
  assert repr(xml(e)) == "<dict><dictent><key>foo</key><value>bar</value></dictent></dict>"

def test2():
  xml_test_data = [[xml('html', xml('body', *xml('br').join(xml('span',text) for text in ['foo','bar','baz']))),
                   "<html><body><span>foo</span><br /><span>bar</span><br /><span>baz</span></body></html>"],
                   [xml("<br/>"),"<br />"],
                  ]
  for v1,v2 in xml_test_data:
    assert repr(v1) == v2

def runtests():
  test1()
  test2()
  print("xmlwrapper: tests OK")

if __name__ == '__main__':
  runtests()