|
|
# iterparse -- event-driven parsing |
|
|
|
|
|
DEF __ITERPARSE_CHUNK_SIZE = 32768 |
|
|
|
|
|
cdef class iterparse: |
|
|
"""iterparse(self, source, events=("end |
|
|
attribute_defaults=False, dtd_validation=False, \ |
|
|
load_dtd=False, no_network=True, remove_blank_text=False, \ |
|
|
remove_comments=False, remove_pis=False, encoding=None, \ |
|
|
html=False, recover=None, huge_tree=False, schema=None) |
|
|
|
|
|
Incremental parser. |
|
|
|
|
|
Parses XML into a tree and generates tuples (event, element) in a |
|
|
SAX-like fashion. ``event`` is any of 'start', 'end', 'start-ns', |
|
|
'end-ns'. |
|
|
|
|
|
For 'start' and 'end', ``element`` is the Element that the parser just |
|
|
found opening or closing. For 'start-ns', it is a tuple (prefix, URI) of |
|
|
a new namespace declaration. For 'end-ns', it is simply None. Note that |
|
|
all start and end events are guaranteed to be properly nested. |
|
|
|
|
|
The keyword argument ``events`` specifies a sequence of event type names |
|
|
that should be generated. By default, only 'end' events will be |
|
|
generated. |
|
|
|
|
|
The additional ``tag`` argument restricts the 'start' and 'end' events to |
|
|
those elements that match the given tag. The ``tag`` argument can also be |
|
|
a sequence of tags to allow matching more than one tag. By default, |
|
|
events are generated for all elements. Note that the 'start-ns' and |
|
|
'end-ns' events are not impacted by this restriction. |
|
|
|
|
|
The other keyword arguments in the constructor are mainly based on the |
|
|
libxml2 parser configuration. A DTD will also be loaded if validation or |
|
|
attribute default values are requested. |
|
|
|
|
|
Available boolean keyword arguments: |
|
|
- attribute_defaults: read default attributes from DTD |
|
|
- dtd_validation: validate (if DTD is available) |
|
|
- load_dtd: use DTD for parsing |
|
|
- no_network: prevent network access for related files |
|
|
- remove_blank_text: discard blank text nodes |
|
|
- remove_comments: discard comments |
|
|
- remove_pis: discard processing instructions |
|
|
- strip_cdata: replace CDATA sections by normal text content (default: True) |
|
|
- compact: safe memory for short text content (default: True) |
|
|
- resolve_entities: replace entities by their text value (default: True) |
|
|
- huge_tree: disable security restrictions and support very deep trees |
|
|
and very long text content (only affects libxml2 2.7+) |
|
|
- html: parse input as HTML (default: XML) |
|
|
- recover: try hard to parse through broken input (default: True for HTML, |
|
|
False otherwise) |
|
|
|
|
|
Other keyword arguments: |
|
|
- encoding: override the document encoding |
|
|
- schema: an XMLSchema to validate against |
|
|
"" |
|
|
cdef _FeedParser _parser |
|
|
cdef object _tag |
|
|
cdef object _events |
|
|
cdef readonly object root |
|
|
cdef object _source |
|
|
cdef object _filename |
|
|
cdef object _error |
|
|
cdef bint _close_source_after_read |
|
|
|
|
|
def __init__(self, source, events=("end",), *, tag=None, |
|
|
attribute_defaults=False, dtd_validation=False, |
|
|
load_dtd=False, no_network=True, remove_blank_text=False, |
|
|
compact=True, resolve_entities=True, remove_comments=False, |
|
|
remove_pis=False, strip_cdata=True, encoding=None, |
|
|
html=False, recover=None, huge_tree=False, collect_ids=True, |
|
|
XMLSchema schema=None): |
|
|
if not hasattr(source, 'read'): |
|
|
source = _getFSPathOrObject(source) |
|
|
self._filename = source |
|
|
self._source = open(source, 'rb') |
|
|
self._close_source_after_read = True |
|
|
else: |
|
|
self._filename = _getFilenameForFile(source) |
|
|
self._source = source |
|
|
self._close_source_after_read = False |
|
|
|
|
|
if recover is None: |
|
|
recover = html |
|
|
|
|
|
if html: |
|
|
# make sure we're not looking for namespaces |
|
|
events = [event for event in events |
|
|
if event not in ('start-ns', 'end-ns')] |
|
|
parser = HTMLPullParser( |
|
|
events, |
|
|
tag=tag, |
|
|
recover=recover, |
|
|
base_url=self._filename, |
|
|
encoding=encoding, |
|
|
remove_blank_text=remove_blank_text, |
|
|
remove_comments=remove_comments, |
|
|
remove_pis=remove_pis, |
|
|
strip_cdata=strip_cdata, |
|
|
no_network=no_network, |
|
|
target=None, # TODO |
|
|
schema=schema, |
|
|
compact=compact) |
|
|
else: |
|
|
parser = XMLPullParser( |
|
|
events, |
|
|
tag=tag, |
|
|
recover=recover, |
|
|
base_url=self._filename, |
|
|
encoding=encoding, |
|
|
attribute_defaults=attribute_defaults, |
|
|
dtd_validation=dtd_validation, |
|
|
load_dtd=load_dtd, |
|
|
no_network=no_network, |
|
|
schema=schema, |
|
|
huge_tree=huge_tree, |
|
|
remove_blank_text=remove_blank_text, |
|
|
resolve_entities=resolve_entities, |
|
|
remove_comments=remove_comments, |
|
|
remove_pis=remove_pis, |
|
|
strip_cdata=strip_cdata, |
|
|
collect_ids=True, |
|
|
target=None, # TODO |
|
|
compact=compact) |
|
|
|
|
|
self._events = parser.read_events() |
|
|
self._parser = parser |
|
|
|
|
|
@property |
|
|
def error_log(self): |
|
|
"""The error log of the last (or current) parser run. |
|
|
""" |
|
|
return self._parser.feed_error_log |
|
|
|
|
|
@property |
|
|
def resolvers(self): |
|
|
"""The custom resolver registry of the last (or current) parser run. |
|
|
""" |
|
|
return self._parser.resolvers |
|
|
|
|
|
@property |
|
|
def version(self): |
|
|
"""The version of the underlying XML parser.""" |
|
|
return self._parser.version |
|
|
|
|
|
def set_element_class_lookup(self, ElementClassLookup lookup = None): |
|
|
"""set_element_class_lookup(self, lookup = None) |
|
|
|
|
|
Set a lookup scheme for element classes generated from this parser. |
|
|
|
|
|
Reset it by passing None or nothing. |
|
|
""" |
|
|
self._parser.set_element_class_lookup(lookup) |
|
|
|
|
|
def makeelement(self, _tag, attrib=None, nsmap=None, **_extra): |
|
|
"""makeelement(self, _tag, attrib=None, nsmap=None, **_extra) |
|
|
|
|
|
Creates a new element associated with this parser. |
|
|
""" |
|
|
self._parser.makeelement( |
|
|
_tag, attrib=None, nsmap=None, **_extra) |
|
|
|
|
|
@cython.final |
|
|
cdef _close_source(self): |
|
|
if self._source is None: |
|
|
return |
|
|
if not self._close_source_after_read: |
|
|
self._source = None |
|
|
return |
|
|
try: |
|
|
close = self._source.close |
|
|
except AttributeError: |
|
|
close = None |
|
|
finally: |
|
|
self._source = None |
|
|
if close is not None: |
|
|
close() |
|
|
|
|
|
def __iter__(self): |
|
|
return self |
|
|
|
|
|
def __next__(self): |
|
|
try: |
|
|
return next(self._events) |
|
|
except StopIteration: |
|
|
pass |
|
|
context = <_SaxParserContext>self._parser._getPushParserContext() |
|
|
if self._source is not None: |
|
|
done = False |
|
|
while not done: |
|
|
try: |
|
|
done = self._read_more_events(context) |
|
|
return next(self._events) |
|
|
except StopIteration: |
|
|
pass # no events yet |
|
|
except Exception as e: |
|
|
self._error = e |
|
|
self._close_source() |
|
|
try: |
|
|
return next(self._events) |
|
|
except StopIteration: |
|
|
break |
|
|
# nothing left to read or return |
|
|
if self._error is not None: |
|
|
error = self._error |
|
|
self._error = None |
|
|
raise error |
|
|
if (context._validator is not None |
|
|
and not context._validator.isvalid()): |
|
|
_raiseParseError(context._c_ctxt, self._filename, |
|
|
context._error_log) |
|
|
# no errors => all done |
|
|
raise StopIteration |
|
|
|
|
|
@cython.final |
|
|
cdef bint _read_more_events(self, _SaxParserContext context) except -123: |
|
|
data = self._source.read(__ITERPARSE_CHUNK_SIZE) |
|
|
if not isinstance(data, bytes): |
|
|
self._close_source() |
|
|
raise TypeError("reading file objects must return bytes objects") |
|
|
if not data: |
|
|
try: |
|
|
self.root = self._parser.close() |
|
|
finally: |
|
|
self._close_source() |
|
|
return True |
|
|
self._parser.feed(data) |
|
|
return False |
|
|
|
|
|
|
|
|
cdef enum _IterwalkSkipStates: |
|
|
IWSKIP_NEXT_IS_START |
|
|
IWSKIP_SKIP_NEXT |
|
|
IWSKIP_CAN_SKIP |
|
|
IWSKIP_CANNOT_SKIP |
|
|
|
|
|
|
|
|
cdef class iterwalk: |
|
|
"""iterwalk(self, element_or_tree, events=("end",), tag=None) |
|
|
|
|
|
A tree walker that generates events from an existing tree as if it |
|
|
was parsing XML data with ``iterparse()``. |
|
|
|
|
|
Just as for ``iterparse()``, the ``tag`` argument can be a single tag or a |
|
|
sequence of tags. |
|
|
|
|
|
After receiving a 'start' or 'start-ns' event, the children and |
|
|
descendants of the current element can be excluded from iteration |
|
|
by calling the ``skip_subtree()`` method. |
|
|
""" |
|
|
cdef _MultiTagMatcher _matcher |
|
|
cdef list _node_stack |
|
|
cdef list _events |
|
|
cdef object _pop_event |
|
|
cdef object _include_siblings |
|
|
cdef int _index |
|
|
cdef int _event_filter |
|
|
cdef _IterwalkSkipStates _skip_state |
|
|
|
|
|
def __init__(self, element_or_tree, events=("end",), tag=None): |
|
|
cdef _Element root |
|
|
cdef int ns_count |
|
|
root = _rootNodeOrRaise(element_or_tree) |
|
|
self._event_filter = _buildParseEventFilter(events) |
|
|
if tag is None or tag == '*': |
|
|
self._matcher = None |
|
|
else: |
|
|
self._matcher = _MultiTagMatcher.__new__(_MultiTagMatcher, tag) |
|
|
self._node_stack = [] |
|
|
self._events = [] |
|
|
self._pop_event = self._events.pop |
|
|
self._skip_state = IWSKIP_CANNOT_SKIP # ignore all skip requests by default |
|
|
|
|
|
if self._event_filter: |
|
|
self._index = 0 |
|
|
if self._matcher is not None and self._event_filter & PARSE_EVENT_FILTER_START: |
|
|
self._matcher.cacheTags(root._doc) |
|
|
|
|
|
# When processing an ElementTree, add events for the preceding comments/PIs. |
|
|
if self._event_filter & (PARSE_EVENT_FILTER_COMMENT | PARSE_EVENT_FILTER_PI): |
|
|
if isinstance(element_or_tree, _ElementTree): |
|
|
self._include_siblings = root |
|
|
for elem in list(root.itersiblings(preceding=True))[::-1]: |
|
|
if self._event_filter & PARSE_EVENT_FILTER_COMMENT and elem.tag is Comment: |
|
|
self._events.append(('comment', elem)) |
|
|
elif self._event_filter & PARSE_EVENT_FILTER_PI and elem.tag is PI: |
|
|
self._events.append(('pi', elem)) |
|
|
|
|
|
ns_count = self._start_node(root) |
|
|
self._node_stack.append( (root, ns_count) ) |
|
|
else: |
|
|
self._index = -1 |
|
|
|
|
|
def __iter__(self): |
|
|
return self |
|
|
|
|
|
def __next__(self): |
|
|
cdef xmlNode* c_child |
|
|
cdef _Element node |
|
|
cdef _Element next_node |
|
|
cdef int ns_count = 0 |
|
|
if self._events: |
|
|
return self._next_event() |
|
|
if self._matcher is not None and self._index >= 0: |
|
|
node = self._node_stack[self._index][0] |
|
|
self._matcher.cacheTags(node._doc) |
|
|
|
|
|
# find next node |
|
|
while self._index >= 0: |
|
|
node = self._node_stack[self._index][0] |
|
|
|
|
|
if self._skip_state == IWSKIP_SKIP_NEXT: |
|
|
c_child = NULL |
|
|
else: |
|
|
c_child = self._process_non_elements( |
|
|
node._doc, _findChildForwards(node._c_node, 0)) |
|
|
self._skip_state = IWSKIP_CANNOT_SKIP |
|
|
|
|
|
while c_child is NULL: |
|
|
# back off through parents |
|
|
self._index -= 1 |
|
|
node = self._end_node() |
|
|
if self._index < 0: |
|
|
break |
|
|
c_child = self._process_non_elements( |
|
|
node._doc, _nextElement(node._c_node)) |
|
|
|
|
|
if c_child is not NULL: |
|
|
next_node = _elementFactory(node._doc, c_child) |
|
|
if self._event_filter & (PARSE_EVENT_FILTER_START | |
|
|
PARSE_EVENT_FILTER_START_NS): |
|
|
ns_count = self._start_node(next_node) |
|
|
elif self._event_filter & PARSE_EVENT_FILTER_END_NS: |
|
|
ns_count = _countNsDefs(next_node._c_node) |
|
|
self._node_stack.append( (next_node, ns_count) ) |
|
|
self._index += 1 |
|
|
if self._events: |
|
|
return self._next_event() |
|
|
|
|
|
if self._include_siblings is not None: |
|
|
node, self._include_siblings = self._include_siblings, None |
|
|
self._process_non_elements(node._doc, _nextElement(node._c_node)) |
|
|
if self._events: |
|
|
return self._next_event() |
|
|
|
|
|
raise StopIteration |
|
|
|
|
|
@cython.final |
|
|
cdef xmlNode* _process_non_elements(self, _Document doc, xmlNode* c_node): |
|
|
while c_node is not NULL and c_node.type != tree.XML_ELEMENT_NODE: |
|
|
if c_node.type == tree.XML_COMMENT_NODE: |
|
|
if self._event_filter & PARSE_EVENT_FILTER_COMMENT: |
|
|
self._events.append( |
|
|
("comment", _elementFactory(doc, c_node))) |
|
|
c_node = _nextElement(c_node) |
|
|
elif c_node.type == tree.XML_PI_NODE: |
|
|
if self._event_filter & PARSE_EVENT_FILTER_PI: |
|
|
self._events.append( |
|
|
("pi", _elementFactory(doc, c_node))) |
|
|
c_node = _nextElement(c_node) |
|
|
else: |
|
|
break |
|
|
return c_node |
|
|
|
|
|
@cython.final |
|
|
cdef _next_event(self): |
|
|
if self._skip_state == IWSKIP_NEXT_IS_START: |
|
|
if self._events[0][0] in ('start', 'start-ns'): |
|
|
self._skip_state = IWSKIP_CAN_SKIP |
|
|
return self._pop_event(0) |
|
|
|
|
|
def skip_subtree(self): |
|
|
"""Prevent descending into the current subtree. |
|
|
Instead, the next returned event will be the 'end' event of the current element |
|
|
(if included), ignoring any children or descendants. |
|
|
|
|
|
This has no effect right after an 'end' or 'end-ns' event. |
|
|
""" |
|
|
if self._skip_state == IWSKIP_CAN_SKIP: |
|
|
self._skip_state = IWSKIP_SKIP_NEXT |
|
|
|
|
|
@cython.final |
|
|
cdef int _start_node(self, _Element node) except -1: |
|
|
cdef int ns_count |
|
|
if self._event_filter & PARSE_EVENT_FILTER_START_NS: |
|
|
ns_count = _appendStartNsEvents(node._c_node, self._events) |
|
|
if self._events: |
|
|
self._skip_state = IWSKIP_NEXT_IS_START |
|
|
elif self._event_filter & PARSE_EVENT_FILTER_END_NS: |
|
|
ns_count = _countNsDefs(node._c_node) |
|
|
else: |
|
|
ns_count = 0 |
|
|
if self._event_filter & PARSE_EVENT_FILTER_START: |
|
|
if self._matcher is None or self._matcher.matches(node._c_node): |
|
|
self._events.append( ("start", node) ) |
|
|
self._skip_state = IWSKIP_NEXT_IS_START |
|
|
return ns_count |
|
|
|
|
|
@cython.final |
|
|
cdef _Element _end_node(self): |
|
|
cdef _Element node |
|
|
cdef int i, ns_count |
|
|
node, ns_count = self._node_stack.pop() |
|
|
if self._event_filter & PARSE_EVENT_FILTER_END: |
|
|
if self._matcher is None or self._matcher.matches(node._c_node): |
|
|
self._events.append( ("end", node) ) |
|
|
if self._event_filter & PARSE_EVENT_FILTER_END_NS and ns_count: |
|
|
event = ("end-ns", None) |
|
|
for i in range(ns_count): |
|
|
self._events.append(event) |
|
|
return node |
|
|
|
|
|
|
|
|
cdef int _countNsDefs(xmlNode* c_node) noexcept: |
|
|
cdef xmlNs* c_ns |
|
|
cdef int count |
|
|
count = 0 |
|
|
c_ns = c_node.nsDef |
|
|
while c_ns is not NULL: |
|
|
count += (c_ns.href is not NULL) |
|
|
c_ns = c_ns.next |
|
|
return count |
|
|
|
|
|
|
|
|
cdef int _appendStartNsEvents(xmlNode* c_node, list event_list) except -1: |
|
|
cdef xmlNs* c_ns |
|
|
cdef int count |
|
|
count = 0 |
|
|
c_ns = c_node.nsDef |
|
|
while c_ns is not NULL: |
|
|
if c_ns.href: |
|
|
ns_tuple = (funicodeOrEmpty(c_ns.prefix), |
|
|
funicode(c_ns.href)) |
|
|
event_list.append( ("start-ns", ns_tuple) ) |
|
|
count += 1 |
|
|
c_ns = c_ns.next |
|
|
return count |
|
|
|
