|
39275
|
1 import xml.sax
|
|
|
2 import xml.sax.handler
|
|
|
3 import types
|
|
|
4
|
|
|
5 try:
|
|
|
6 _StringTypes = [types.StringType, types.UnicodeType]
|
|
|
7 except AttributeError:
|
|
|
8 _StringTypes = [types.StringType]
|
|
|
9
|
|
|
10 START_ELEMENT = "START_ELEMENT"
|
|
|
11 END_ELEMENT = "END_ELEMENT"
|
|
|
12 COMMENT = "COMMENT"
|
|
|
13 START_DOCUMENT = "START_DOCUMENT"
|
|
|
14 END_DOCUMENT = "END_DOCUMENT"
|
|
|
15 PROCESSING_INSTRUCTION = "PROCESSING_INSTRUCTION"
|
|
|
16 IGNORABLE_WHITESPACE = "IGNORABLE_WHITESPACE"
|
|
|
17 CHARACTERS = "CHARACTERS"
|
|
|
18
|
|
|
19 class PullDOM(xml.sax.ContentHandler):
|
|
|
20 _locator = None
|
|
|
21 document = None
|
|
|
22
|
|
|
23 def __init__(self, documentFactory=None):
|
|
|
24 from xml.dom import XML_NAMESPACE
|
|
|
25 self.documentFactory = documentFactory
|
|
|
26 self.firstEvent = [None, None]
|
|
|
27 self.lastEvent = self.firstEvent
|
|
|
28 self.elementStack = []
|
|
|
29 self.push = self.elementStack.append
|
|
|
30 try:
|
|
|
31 self.pop = self.elementStack.pop
|
|
|
32 except AttributeError:
|
|
|
33 # use class' pop instead
|
|
|
34 pass
|
|
|
35 self._ns_contexts = [{XML_NAMESPACE:'xml'}] # contains uri -> prefix dicts
|
|
|
36 self._current_context = self._ns_contexts[-1]
|
|
|
37 self.pending_events = []
|
|
|
38
|
|
|
39 def pop(self):
|
|
|
40 result = self.elementStack[-1]
|
|
|
41 del self.elementStack[-1]
|
|
|
42 return result
|
|
|
43
|
|
|
44 def setDocumentLocator(self, locator):
|
|
|
45 self._locator = locator
|
|
|
46
|
|
|
47 def startPrefixMapping(self, prefix, uri):
|
|
|
48 if not hasattr(self, '_xmlns_attrs'):
|
|
|
49 self._xmlns_attrs = []
|
|
|
50 self._xmlns_attrs.append((prefix or 'xmlns', uri))
|
|
|
51 self._ns_contexts.append(self._current_context.copy())
|
|
|
52 self._current_context[uri] = prefix or None
|
|
|
53
|
|
|
54 def endPrefixMapping(self, prefix):
|
|
|
55 self._current_context = self._ns_contexts.pop()
|
|
|
56
|
|
|
57 def startElementNS(self, name, tagName , attrs):
|
|
|
58 # Retrieve xml namespace declaration attributes.
|
|
|
59 xmlns_uri = 'http://www.w3.org/2000/xmlns/'
|
|
|
60 xmlns_attrs = getattr(self, '_xmlns_attrs', None)
|
|
|
61 if xmlns_attrs is not None:
|
|
|
62 for aname, value in xmlns_attrs:
|
|
|
63 attrs._attrs[(xmlns_uri, aname)] = value
|
|
|
64 self._xmlns_attrs = []
|
|
|
65 uri, localname = name
|
|
|
66 if uri:
|
|
|
67 # When using namespaces, the reader may or may not
|
|
|
68 # provide us with the original name. If not, create
|
|
|
69 # *a* valid tagName from the current context.
|
|
|
70 if tagName is None:
|
|
|
71 prefix = self._current_context[uri]
|
|
|
72 if prefix:
|
|
|
73 tagName = prefix + ":" + localname
|
|
|
74 else:
|
|
|
75 tagName = localname
|
|
|
76 if self.document:
|
|
|
77 node = self.document.createElementNS(uri, tagName)
|
|
|
78 else:
|
|
|
79 node = self.buildDocument(uri, tagName)
|
|
|
80 else:
|
|
|
81 # When the tagname is not prefixed, it just appears as
|
|
|
82 # localname
|
|
|
83 if self.document:
|
|
|
84 node = self.document.createElement(localname)
|
|
|
85 else:
|
|
|
86 node = self.buildDocument(None, localname)
|
|
|
87
|
|
|
88 for aname,value in attrs.items():
|
|
|
89 a_uri, a_localname = aname
|
|
|
90 if a_uri == xmlns_uri:
|
|
|
91 if a_localname == 'xmlns':
|
|
|
92 qname = a_localname
|
|
|
93 else:
|
|
|
94 qname = 'xmlns:' + a_localname
|
|
|
95 attr = self.document.createAttributeNS(a_uri, qname)
|
|
|
96 node.setAttributeNodeNS(attr)
|
|
|
97 elif a_uri:
|
|
|
98 prefix = self._current_context[a_uri]
|
|
|
99 if prefix:
|
|
|
100 qname = prefix + ":" + a_localname
|
|
|
101 else:
|
|
|
102 qname = a_localname
|
|
|
103 attr = self.document.createAttributeNS(a_uri, qname)
|
|
|
104 node.setAttributeNodeNS(attr)
|
|
|
105 else:
|
|
|
106 attr = self.document.createAttribute(a_localname)
|
|
|
107 node.setAttributeNode(attr)
|
|
|
108 attr.value = value
|
|
|
109
|
|
|
110 self.lastEvent[1] = [(START_ELEMENT, node), None]
|
|
|
111 self.lastEvent = self.lastEvent[1]
|
|
|
112 self.push(node)
|
|
|
113
|
|
|
114 def endElementNS(self, name, tagName):
|
|
|
115 self.lastEvent[1] = [(END_ELEMENT, self.pop()), None]
|
|
|
116 self.lastEvent = self.lastEvent[1]
|
|
|
117
|
|
|
118 def startElement(self, name, attrs):
|
|
|
119 if self.document:
|
|
|
120 node = self.document.createElement(name)
|
|
|
121 else:
|
|
|
122 node = self.buildDocument(None, name)
|
|
|
123
|
|
|
124 for aname,value in attrs.items():
|
|
|
125 attr = self.document.createAttribute(aname)
|
|
|
126 attr.value = value
|
|
|
127 node.setAttributeNode(attr)
|
|
|
128
|
|
|
129 self.lastEvent[1] = [(START_ELEMENT, node), None]
|
|
|
130 self.lastEvent = self.lastEvent[1]
|
|
|
131 self.push(node)
|
|
|
132
|
|
|
133 def endElement(self, name):
|
|
|
134 self.lastEvent[1] = [(END_ELEMENT, self.pop()), None]
|
|
|
135 self.lastEvent = self.lastEvent[1]
|
|
|
136
|
|
|
137 def comment(self, s):
|
|
|
138 if self.document:
|
|
|
139 node = self.document.createComment(s)
|
|
|
140 self.lastEvent[1] = [(COMMENT, node), None]
|
|
|
141 self.lastEvent = self.lastEvent[1]
|
|
|
142 else:
|
|
|
143 event = [(COMMENT, s), None]
|
|
|
144 self.pending_events.append(event)
|
|
|
145
|
|
|
146 def processingInstruction(self, target, data):
|
|
|
147 if self.document:
|
|
|
148 node = self.document.createProcessingInstruction(target, data)
|
|
|
149 self.lastEvent[1] = [(PROCESSING_INSTRUCTION, node), None]
|
|
|
150 self.lastEvent = self.lastEvent[1]
|
|
|
151 else:
|
|
|
152 event = [(PROCESSING_INSTRUCTION, target, data), None]
|
|
|
153 self.pending_events.append(event)
|
|
|
154
|
|
|
155 def ignorableWhitespace(self, chars):
|
|
|
156 node = self.document.createTextNode(chars)
|
|
|
157 self.lastEvent[1] = [(IGNORABLE_WHITESPACE, node), None]
|
|
|
158 self.lastEvent = self.lastEvent[1]
|
|
|
159
|
|
|
160 def characters(self, chars):
|
|
|
161 node = self.document.createTextNode(chars)
|
|
|
162 self.lastEvent[1] = [(CHARACTERS, node), None]
|
|
|
163 self.lastEvent = self.lastEvent[1]
|
|
|
164
|
|
|
165 def startDocument(self):
|
|
|
166 if self.documentFactory is None:
|
|
|
167 import xml.dom.minidom
|
|
|
168 self.documentFactory = xml.dom.minidom.Document.implementation
|
|
|
169
|
|
|
170 def buildDocument(self, uri, tagname):
|
|
|
171 # Can't do that in startDocument, since we need the tagname
|
|
|
172 # XXX: obtain DocumentType
|
|
|
173 node = self.documentFactory.createDocument(uri, tagname, None)
|
|
|
174 self.document = node
|
|
|
175 self.lastEvent[1] = [(START_DOCUMENT, node), None]
|
|
|
176 self.lastEvent = self.lastEvent[1]
|
|
|
177 self.push(node)
|
|
|
178 # Put everything we have seen so far into the document
|
|
|
179 for e in self.pending_events:
|
|
|
180 if e[0][0] == PROCESSING_INSTRUCTION:
|
|
|
181 _,target,data = e[0]
|
|
|
182 n = self.document.createProcessingInstruction(target, data)
|
|
|
183 e[0] = (PROCESSING_INSTRUCTION, n)
|
|
|
184 elif e[0][0] == COMMENT:
|
|
|
185 n = self.document.createComment(e[0][1])
|
|
|
186 e[0] = (COMMENT, n)
|
|
|
187 else:
|
|
|
188 raise AssertionError("Unknown pending event ",e[0][0])
|
|
|
189 self.lastEvent[1] = e
|
|
|
190 self.lastEvent = e
|
|
|
191 self.pending_events = None
|
|
|
192 return node.firstChild
|
|
|
193
|
|
|
194 def endDocument(self):
|
|
|
195 self.lastEvent[1] = [(END_DOCUMENT, self.document), None]
|
|
|
196 self.pop()
|
|
|
197
|
|
|
198 def clear(self):
|
|
|
199 "clear(): Explicitly release parsing structures"
|
|
|
200 self.document = None
|
|
|
201
|
|
|
202 class ErrorHandler:
|
|
|
203 def warning(self, exception):
|
|
|
204 print exception
|
|
|
205 def error(self, exception):
|
|
|
206 raise exception
|
|
|
207 def fatalError(self, exception):
|
|
|
208 raise exception
|
|
|
209
|
|
|
210 class DOMEventStream:
|
|
|
211 def __init__(self, stream, parser, bufsize):
|
|
|
212 self.stream = stream
|
|
|
213 self.parser = parser
|
|
|
214 self.bufsize = bufsize
|
|
|
215 if not hasattr(self.parser, 'feed'):
|
|
|
216 self.getEvent = self._slurp
|
|
|
217 self.reset()
|
|
|
218
|
|
|
219 def reset(self):
|
|
|
220 self.pulldom = PullDOM()
|
|
|
221 # This content handler relies on namespace support
|
|
|
222 self.parser.setFeature(xml.sax.handler.feature_namespaces, 1)
|
|
|
223 self.parser.setContentHandler(self.pulldom)
|
|
|
224
|
|
|
225 def __getitem__(self, pos):
|
|
|
226 rc = self.getEvent()
|
|
|
227 if rc:
|
|
|
228 return rc
|
|
|
229 raise IndexError
|
|
|
230
|
|
|
231 def next(self):
|
|
|
232 rc = self.getEvent()
|
|
|
233 if rc:
|
|
|
234 return rc
|
|
|
235 raise StopIteration
|
|
|
236
|
|
|
237 def __iter__(self):
|
|
|
238 return self
|
|
|
239
|
|
|
240 def expandNode(self, node):
|
|
|
241 event = self.getEvent()
|
|
|
242 parents = [node]
|
|
|
243 while event:
|
|
|
244 token, cur_node = event
|
|
|
245 if cur_node is node:
|
|
|
246 return
|
|
|
247 if token != END_ELEMENT:
|
|
|
248 parents[-1].appendChild(cur_node)
|
|
|
249 if token == START_ELEMENT:
|
|
|
250 parents.append(cur_node)
|
|
|
251 elif token == END_ELEMENT:
|
|
|
252 del parents[-1]
|
|
|
253 event = self.getEvent()
|
|
|
254
|
|
|
255 def getEvent(self):
|
|
|
256 # use IncrementalParser interface, so we get the desired
|
|
|
257 # pull effect
|
|
|
258 if not self.pulldom.firstEvent[1]:
|
|
|
259 self.pulldom.lastEvent = self.pulldom.firstEvent
|
|
|
260 while not self.pulldom.firstEvent[1]:
|
|
|
261 buf = self.stream.read(self.bufsize)
|
|
|
262 if not buf:
|
|
|
263 self.parser.close()
|
|
|
264 return None
|
|
|
265 self.parser.feed(buf)
|
|
|
266 rc = self.pulldom.firstEvent[1][0]
|
|
|
267 self.pulldom.firstEvent[1] = self.pulldom.firstEvent[1][1]
|
|
|
268 return rc
|
|
|
269
|
|
|
270 def _slurp(self):
|
|
|
271 """ Fallback replacement for getEvent() using the
|
|
|
272 standard SAX2 interface, which means we slurp the
|
|
|
273 SAX events into memory (no performance gain, but
|
|
|
274 we are compatible to all SAX parsers).
|
|
|
275 """
|
|
|
276 self.parser.parse(self.stream)
|
|
|
277 self.getEvent = self._emit
|
|
|
278 return self._emit()
|
|
|
279
|
|
|
280 def _emit(self):
|
|
|
281 """ Fallback replacement for getEvent() that emits
|
|
|
282 the events that _slurp() read previously.
|
|
|
283 """
|
|
|
284 rc = self.pulldom.firstEvent[1][0]
|
|
|
285 self.pulldom.firstEvent[1] = self.pulldom.firstEvent[1][1]
|
|
|
286 return rc
|
|
|
287
|
|
|
288 def clear(self):
|
|
|
289 """clear(): Explicitly release parsing objects"""
|
|
|
290 self.pulldom.clear()
|
|
|
291 del self.pulldom
|
|
|
292 self.parser = None
|
|
|
293 self.stream = None
|
|
|
294
|
|
|
295 class SAX2DOM(PullDOM):
|
|
|
296
|
|
|
297 def startElementNS(self, name, tagName , attrs):
|
|
|
298 PullDOM.startElementNS(self, name, tagName, attrs)
|
|
|
299 curNode = self.elementStack[-1]
|
|
|
300 parentNode = self.elementStack[-2]
|
|
|
301 parentNode.appendChild(curNode)
|
|
|
302
|
|
|
303 def startElement(self, name, attrs):
|
|
|
304 PullDOM.startElement(self, name, attrs)
|
|
|
305 curNode = self.elementStack[-1]
|
|
|
306 parentNode = self.elementStack[-2]
|
|
|
307 parentNode.appendChild(curNode)
|
|
|
308
|
|
|
309 def processingInstruction(self, target, data):
|
|
|
310 PullDOM.processingInstruction(self, target, data)
|
|
|
311 node = self.lastEvent[0][1]
|
|
|
312 parentNode = self.elementStack[-1]
|
|
|
313 parentNode.appendChild(node)
|
|
|
314
|
|
|
315 def ignorableWhitespace(self, chars):
|
|
|
316 PullDOM.ignorableWhitespace(self, chars)
|
|
|
317 node = self.lastEvent[0][1]
|
|
|
318 parentNode = self.elementStack[-1]
|
|
|
319 parentNode.appendChild(node)
|
|
|
320
|
|
|
321 def characters(self, chars):
|
|
|
322 PullDOM.characters(self, chars)
|
|
|
323 node = self.lastEvent[0][1]
|
|
|
324 parentNode = self.elementStack[-1]
|
|
|
325 parentNode.appendChild(node)
|
|
|
326
|
|
|
327
|
|
|
328 default_bufsize = (2 ** 14) - 20
|
|
|
329
|
|
|
330 def parse(stream_or_string, parser=None, bufsize=None):
|
|
|
331 if bufsize is None:
|
|
|
332 bufsize = default_bufsize
|
|
|
333 if type(stream_or_string) in _StringTypes:
|
|
|
334 stream = open(stream_or_string)
|
|
|
335 else:
|
|
|
336 stream = stream_or_string
|
|
|
337 if not parser:
|
|
|
338 parser = xml.sax.make_parser()
|
|
|
339 return DOMEventStream(stream, parser, bufsize)
|
|
|
340
|
|
|
341 def parseString(string, parser=None):
|
|
|
342 try:
|
|
|
343 from cStringIO import StringIO
|
|
|
344 except ImportError:
|
|
|
345 from StringIO import StringIO
|
|
|
346
|
|
|
347 bufsize = len(string)
|
|
|
348 buf = StringIO(string)
|
|
|
349 if not parser:
|
|
|
350 parser = xml.sax.make_parser()
|
|
|
351 return DOMEventStream(buf, parser, bufsize)
|
