/lib/xml_dom.py - Annotate - BIEN 3 - NCEAS Projects

root/lib/xml_dom.py @ 786

-            aaronmk
+# XML DOM tree manipulation
-            aaronmk
+import cgi
 from HTMLParser import HTMLParser
-            aaronmk
+from xml.dom import Node
-            aaronmk
+import xml.dom.minidom as minidom
             aaronmk
-            aaronmk
+import strings
-            aaronmk
+import util
             aaronmk
 def escape(str_):
     return strings.to_unicode(cgi.escape(str_, True)).encode('ascii',
         'xmlcharrefreplace')
 def unescape(str_): return HTMLParser().unescape(str_)
-            aaronmk
+#####
-            aaronmk
+def get_id(node): return node.getAttribute('id')
 def set_id(node, id_): node.setAttribute('id', id_)
-            aaronmk
+#####
-            aaronmk
+def is_completely_empty(node): return node.firstChild == None
             aaronmk
-            aaronmk
+def has_one_child(node):
     return node.firstChild != None and node.firstChild.nextSibling == None
-            aaronmk
+class NodeIter:
     def __init__(self, node): self.child = node.firstChild
     def __iter__(self): return self
     def curr(self):
         if self.child != None: return self.child
         raise StopIteration
     def next(self):
         child = self.curr()
         self.child = self.child.nextSibling
         return child
-            aaronmk
+#####
-            aaronmk
+def is_comment(node): return node.nodeType == Node.COMMENT_NODE
 def is_empty(node):
     for child in NodeIter(node):
         if not is_comment(child): return False
     return True
-            aaronmk
+#####
 def is_elem(node): return node.nodeType == Node.ELEMENT_NODE
-            aaronmk
+class NodeElemIter:
     def __init__(self, node): self.child = node.firstChild
     def __iter__(self): return self
     def curr(self):
         while self.child != None:
-            aaronmk
+            if is_elem(self.child): return self.child
-            aaronmk
+            self.child = self.child.nextSibling
         raise StopIteration
     def next(self):
         child = self.curr()
         self.child = self.child.nextSibling
         return child
 def first_elem(node): return NodeElemIter(node).next()
-            aaronmk
+def has_elems(node):
     try: first_elem(node); return True
     except StopIteration: return False
-            aaronmk
+class NodeElemReverseIter:
     def __init__(self, node): self.child = node.lastChild
     def __iter__(self): return self
     def curr(self):
         while self.child != None:
-            aaronmk
+            if is_elem(self.child): return self.child
-            aaronmk
+            self.child = self.child.previousSibling
         raise StopIteration
     def next(self):
         child = self.curr()
         self.child = self.child.previousSibling
         return child
 def last_elem(node): return NodeElemReverseIter(node).next()
 class NodeParentIter:
     def __init__(self, node): self.node = node
     def __iter__(self): return self
     def curr(self):
-            aaronmk
+        if self.node != None and is_elem(self.node): return self.node
-            aaronmk
+        raise StopIteration
     def next(self):
         node = self.curr()
         self.node = self.node.parentNode
         return node
-            aaronmk
+def is_simple(node):
     '''Whether every child recursively has no more than one child'''
     return (not is_elem(node) or is_completely_empty(node)
         or (has_one_child(node) and is_simple(node.firstChild)))
-            aaronmk
+#####
-            aaronmk
+def is_text_node(node): return node.nodeType == Node.TEXT_NODE
-            aaronmk
+def is_text(node): return has_one_child(node) and is_text_node(node.firstChild)
             aaronmk
 def value(node):
-            aaronmk
+    if node.firstChild != None: return node.firstChild.nodeValue
-            aaronmk
+    else: return node.nodeValue
-            aaronmk
+def set_value(node, value):
-            aaronmk
+    if is_elem(node): node.appendChild(node.ownerDocument.createTextNode(value))
-            aaronmk
+    else: node.nodeValue = value
-            aaronmk
+class NodeTextEntryIter:
     def __init__(self, node): self.iter_ = NodeElemIter(node)
     def __iter__(self): return self
     def curr(self):
-            aaronmk
+        child = self.iter_.curr()
         name = child.tagName
         if is_text(child): child = value(child)
         return (name, child)
             aaronmk
     def next(self):
         entry = self.curr()
         self.iter_.next()
         return entry
-            aaronmk
+#####
-            aaronmk
+def set_child(node, name, value):
     '''Note: does not remove any existing child of the same name'''
     child = node.ownerDocument.createElement(name)
-            aaronmk
+    set_value(child, value)
-            aaronmk
+    node.appendChild(child)
-            aaronmk
+def remove(node): node.parentNode.removeChild(node)
-            aaronmk
+def replace(old_node, new_node):
     old_node.parentNode.replaceChild(new_node, old_node) # note order reversed
-            aaronmk
+def replace_with_text(node, new):
     if isinstance(new, basestring): new = node.ownerDocument.createTextNode(new)
     replace(node, new)
             aaronmk
-            aaronmk
+#####
-            aaronmk
+def by_tag_name(node, name, last_only=False):
-            aaronmk
+    '''last_only optimization returns last matching node'''
-            aaronmk
+    children = []
-            aaronmk
+    for child in NodeElemReverseIter(node):
-            aaronmk
+        if child.tagName == name:
             children.append(child)
             if last_only: break
     return children
             aaronmk
-            aaronmk
+#####
-            aaronmk
+def create_doc(root='_'):
-            aaronmk
+    return minidom.getDOMImplementation().createDocument(None, root, None)
             aaronmk
-            aaronmk
+#####
-            aaronmk
+prettyxml_config = dict(addindent='    ', newl='\n')
-            aaronmk
+toprettyxml_config = prettyxml_config.copy()
 util.rename_key(toprettyxml_config, 'addindent', 'indent')
             aaronmk
-            aaronmk
+#####
-            aaronmk
+# minidom modifications
             aaronmk
-            aaronmk
+minidom._write_data = lambda writer, data: writer.write(escape(data))
             aaronmk
-            aaronmk
+minidom.Node.__iter__ = lambda self: NodeIter(self)
-            aaronmk
+minidom.Node.__str__ = lambda self: self.toprettyxml(**toprettyxml_config)
             aaronmk
-            aaronmk
+minidom.Node.pop = lambda self: self.removeChild(self.lastChild)
 def __Node_clear(self):
     while not is_empty(self): self.pop()
 minidom.Node.clear = __Node_clear
-            aaronmk
+def __Element_write_opening(self, writer, indent='', addindent='', newl=''):
-            aaronmk
+    writer.write(indent+'<'+self.tagName)
     for attr_idx in xrange(self.attributes.length):
         attr = self.attributes.item(attr_idx)
         writer.write(' '+attr.name+'='+escape(attr.value))
     writer.write('>'+newl)
-            aaronmk
+minidom.Element.write_opening = __Element_write_opening
             aaronmk
-            aaronmk
+def __Element_write_closing(self, writer, indent='', addindent='', newl=''):
-            aaronmk
+    writer.write('</'+self.tagName+'>'+newl)
-            aaronmk
+minidom.Element.write_closing = __Element_write_closing
             aaronmk
-            aaronmk
+_writexml_orig = minidom.Element.writexml
-            aaronmk
+def __Element_writexml(self, writer, indent='', addindent='', newl=''):
-            aaronmk
+    if isinstance(indent, int): indent = addindent*indent
-            aaronmk
+    if is_simple(self):
         writer.write(indent)
         _writexml_orig(self, writer)
         writer.write(newl)
-            aaronmk
+    else: _writexml_orig(self, writer, indent, addindent, newl)
-            aaronmk
+minidom.Element.writexml = __Element_writexml
             aaronmk
-            aaronmk
+def __Document_write_opening(self, writer, indent='', addindent='', newl='',
     encoding=None):
     xmlDecl = '<?xml version="1.0" '
     if encoding != None: xmlDecl += 'encoding="'+escape(encoding)+'"'
     xmlDecl += '?>'+newl
     writer.write(xmlDecl)
     assert has_one_child(self)
     assert is_elem(self.firstChild)
     self.firstChild.write_opening(writer, indent, addindent, newl)
 minidom.Document.write_opening = __Document_write_opening
 def __Document_write_closing(self, writer, indent='', addindent='', newl=''):
     self.firstChild.write_closing(writer, indent, addindent, newl)
 minidom.Document.write_closing = __Document_write_closing

Project

General

Profile