# XML DOM tree manipulation

from HTMLParser import HTMLParser

    return strings.to_unicode(cgi.escape(str_, True)).encode('ascii',

        'xmlcharrefreplace')

def unescape(str_): return HTMLParser().unescape(str_)

def strip_namespace(name):

    namespace, sep, base = name.partition(':')

    if sep != '': return base

    else: return name

def is_node(value): return isinstance(value, Node)

def remove(node): node.parentNode.removeChild(node)

def replace(old, new):

    '''@param new Node|None'''

    else: old.parentNode.replaceChild(new, old) # note order reversed

def replace_with_text(node, new):

    @return The *new* node

    '''

    replace(node, new)

    return node.firstChild != None and node.firstChild.nextSibling == None

    '''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)))

    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

def is_empty(node):

    for child in NodeIter(node):

        if not is_comment(child): return False

    return True

    '''Sanitizes comment node contents. Strips invalid strings.'''

    return re.sub(r'-{2,}', r'-', str_) # comments can't contain '--'

def mk_comment(doc, str_): return doc.createComment(clean_comment(str_))

    def __init__(self, node): self.child = node.firstChild

    def __iter__(self): return self

    def curr(self):

        while self.child != None:

        raise StopIteration

    def next(self):

        child = self.curr()

        self.child = self.child.nextSibling

        return child

def first_elem(node): return NodeElemIter(node).next()

    try: first_elem(node); return True

    except StopIteration: return False

    def __init__(self, node): self.child = node.lastChild

    def __iter__(self): return self

    def curr(self):

        while self.child != None:

        raise StopIteration

    def next(self):

        child = self.curr()

        self.child = self.child.previousSibling

        return child

def last_elem(node): return NodeElemReverseIter(node).next()

    not a true element node'''

    if parent_ != None and is_elem(parent_): return parent_

    else: return None

class NodeParentIter:

    '''See parent() for special treatment of root node.

    Note that the first element returned is the current node, not its parent.'''

    def __iter__(self): return self

    def curr(self):

        else: raise StopIteration

    def next(self):

        node = self.curr()

        iter_ = NodeIter(node)

        util.skip(iter_, is_comment)

    return util.do_ignore_none(lambda n: n.nodeValue, value_node(node))

    if value != None:

        if value_node_ != None:

            value_node_.nodeValue = value

        else:

            assert is_elem(node)

            node.appendChild(node.ownerDocument.createTextNode(value))

        if is_elem(node): remove(value_node_)

        else: node.nodeValue = value

    def __init__(self, node): self.iter_ = NodeElemIter(node)

    def __iter__(self): return self

        util.skip(self.iter_, is_empty)

        entry = self.iter_.next()

        else:

            assert has_one_child(entry) # TODO: convert to an exception

            value_ = entry.firstChild

        return (entry.tagName, value_)

class TextEntryOnlyIter(util.CheckedIter):

    def __init__(self, iterable):

        util.CheckedIter.__init__(self, is_text_node_entry, iterable)

def get_id(node):

    '''If the node doesn't have an ID, assumes the node itself is the ID.

    @return None if the node doesn't have an ID or a value

    '''

    id_ = node.getAttribute('id')

    if id_ != '': return id_

    else: return value(node) # assume the node itself is the ID

def set_id(node, id_): node.setAttribute('id', id_)

    '''Note: does not remove any existing child of the same name'''

    child = node.ownerDocument.createElement(name)

    '''last_only optimization returns only the last matching node'''

    if ignore_namespace: filter_name = strip_namespace

    else: filter_name = lambda name: name

    name = filter_name(name)

    else: iter_ = NodeElemIter(node)

    for child in iter_:

            if last_only: break

    return children

    @post The into node is saved; the from_ node is deleted.

    '''

    if from_ == None or into == None: return # base case

    if from_.tagName != into.tagName: return # not mergeable

    from_first = from_.firstChild # save before merge

    remove(from_)

    merge(from_first, from_first.previousSibling) # = into.lastChild

    '''Merges siblings in root with the given name'''

    children = by_tag_name(root, name)

    child0 = children.pop(0)

    for child in children: merge(child, child0)

    merge_by_name(node.parentNode, node.tagName)

util.rename_key(toprettyxml_config, 'addindent', 'indent')

minidom.Node.__repr__ = __Node_str

minidom.Element.__repr__ = __Node_str

def __Node_clear(self):

    while not is_empty(self): self.pop()

minidom.Node.clear = __Node_clear

__Text_writexml_orig = minidom.Text.writexml

def __Text_writexml(self, *args, **kw_args):

    if is_whitespace(self): pass # we add our own whitespace

    else: __Text_writexml_orig(self, *args, **kw_args)

minidom.Text.writexml = __Text_writexml

#### Attr

def __Attr_str(self): return escape(self.name)+'="'+escape(self.value)+'"'

minidom.Attr.__str__ = __Attr_str

minidom.Attr.__repr__ = __Attr_str

#### Element

        writer.write(indent)

    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