public
Description: Oliver's Python utilities
Homepage:
Clone URL: git://github.com/osteele/python-utils.git
python-utils / xmlobj.py
100644 65 lines (53 sloc) 2.195 kb
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
__author__ = "Oliver Steele <steele@osteele.com>"
__copyright__ = "Copyright 1999-2001 by Oliver Steele."
__license__ = "Python License"
__version__ = 'alpha (prerelease)'
 
#
# XML Model
#
 
class XMLObject:
    def __init__(self, name, attributes, children):
        self.tagName = name
        self.attributes = attributes
        self.children = children
 
    def __repr__(self):
        attrs = ''.join([" %s=\"%s\"" % (key, value) for (key, value) in self.attributes.items()])
        if self.children:
            from cStringIO import StringIO
            buffer = StringIO()
            buffer.write(str("<%s%s>" % (self.tagName, attrs)))
            for child in self.children:
                buffer.write(str(child))
            buffer.write(str("</%s>" % self.tagName))
            return buffer.getvalue()
        else:
            return str("<%s%s/>" % (self.tagName, attrs))
 
    def __getitem__(self, key):
        return self.attributes[key]
 
    def get(self, key, default=None):
        return self.attributes.get(key, default)
 
class XMLObjectFactory:
    def makeElement(self, name, attributes, children):
        return XMLObject(name, attributes, children)
 
    def makeTextNode(self, data):
        return data
    
    def makeNode(self, node):
        if node.nodeType == node.ELEMENT_NODE:
            element = node
            attributes = {}
            for key in element.attributes.keys():
                attributes[key] = element.attributes[key].value
            children = filter(None, map(self.makeNode, element.childNodes))
            return self.makeElement(element.nodeName, attributes, children)
        elif node.nodeType == node.TEXT_NODE:
            return self.makeTextNode(node.data)
        elif node.nodeType in (node.PROCESSING_INSTRUCTION_NODE,):
            return None
        raise 'unknown node type %r %r' % (node, node.nodeType)
 
    def makeDocument(self, doc):
        root = doc.documentElement
        return self.makeNode(root)
 
    def parseFile(self, file):
        from xml.dom.minidom import parse
        doc = parse(file)
        return self.makeDocument(doc)