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

    if not new: olds_parent.removeChild(old)

    else: # at least one node

        last = new.pop(-1)

        olds_parent.replaceChild(last, old) # note arg order reversed

        for node in reversed(new):

            olds_parent.insertBefore(node, last) # there is no insertAfter()

    '''For use with replace_with_text()'''

    if val: return '1'

    else: return None # remove node

    @return The *new* node

    '''

        if isinstance(new, bool): new = bool2str(new)

        else: new = strings.ustr(new)

        if new != None: new = node.ownerDocument.createTextNode(new)

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

    if not has_one_child(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)))

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

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

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

    def __iter__(self): return self

    def next(self):

        entry = self.iter_.next()

        if not values: values = None

        elif len(values) == 1: values = values[0]

        return (entry.tagName, values)

    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 is_text_node(node) and (node.nodeValue == ''

        or node.nodeValue.isspace())

    if value != None:

        if value_node_ != None:

            value_node_.nodeValue = value

        else:

            assert is_elem(node)

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

        else:

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

    def __iter__(self): return self

        entry = self.iter_.next()

        elif is_text(entry): value_ = value(entry)

    return itertools.ifilter(lambda i: i[1] != None, iterable)

    def __init__(self, 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_)

    '''Removes node if it's empty'''

    if is_empty(node): remove(node)

    '''Removes node and then parent if it's empty'''

    parent = node.parentNode # save parent before detaching node

    remove(node)

    prune_empty(parent)

    '''Removes empty children'''

    for child in NodeElemIter(node): prune_empty(child)

    '''Removes empty children and then node if it's empty'''

    prune_children(node)

    prune_empty(node)

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

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