Download omnilmm/lib/python3.10/site-packages/lxml/iterparse.pxi from ZTWHHH/envs_2: direct link, hf CLI and curl.
- Browser
- Download file 16.5 kB
-
https://huggingface.co/datasets/ZTWHHH/envs_2/resolve/main/omnilmm/lib/python3.10/site-packages/lxml/iterparse.pxi
- Command line
-
hf download hf://datasets/ZTWHHH/envs_2/omnilmm/lib/python3.10/site-packages/lxml/iterparse.pxi
-
curl -L -o iterparse.pxi https://huggingface.co/datasets/ZTWHHH/envs_2/resolve/main/omnilmm/lib/python3.10/site-packages/lxml/iterparse.pxi
16.5 kB
| # iterparse -- event-driven parsing | |
| DEF __ITERPARSE_CHUNK_SIZE = 32768 | |
| cdef class iterparse: | |
| """iterparse(self, source, events=("end",), tag=None, \ | |
| 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 | |