diff --git a/.gitattributes b/.gitattributes
index 342c916feb6e744310410ea572d39008a3afe103..db224106266a1d1ecc852aced2d11c69b9946f91 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -671,3 +671,5 @@ llava_video/lib/python3.10/site-packages/matplotlib/_path.cpython-310-x86_64-lin
llava_video/lib/python3.10/site-packages/matplotlib/_image.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
llava_video/lib/python3.10/site-packages/matplotlib/_tri.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
llava_video/lib/python3.10/site-packages/matplotlib/backends/_tkagg.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+llava_video/lib/python3.10/site-packages/matplotlib/__pycache__/widgets.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+llava_video/lib/python3.10/site-packages/matplotlib/__pycache__/colors.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
diff --git a/llava_video/lib/python3.10/site-packages/lxml/ElementInclude.py b/llava_video/lib/python3.10/site-packages/lxml/ElementInclude.py
new file mode 100644
index 0000000000000000000000000000000000000000..21884336f534cd2013165934111146684c9909cf
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/ElementInclude.py
@@ -0,0 +1,244 @@
+#
+# ElementTree
+# $Id: ElementInclude.py 1862 2004-06-18 07:31:02Z Fredrik $
+#
+# limited xinclude support for element trees
+#
+# history:
+# 2003-08-15 fl created
+# 2003-11-14 fl fixed default loader
+#
+# Copyright (c) 2003-2004 by Fredrik Lundh. All rights reserved.
+#
+# fredrik@pythonware.com
+# http://www.pythonware.com
+#
+# --------------------------------------------------------------------
+# The ElementTree toolkit is
+#
+# Copyright (c) 1999-2004 by Fredrik Lundh
+#
+# By obtaining, using, and/or copying this software and/or its
+# associated documentation, you agree that you have read, understood,
+# and will comply with the following terms and conditions:
+#
+# Permission to use, copy, modify, and distribute this software and
+# its associated documentation for any purpose and without fee is
+# hereby granted, provided that the above copyright notice appears in
+# all copies, and that both that copyright notice and this permission
+# notice appear in supporting documentation, and that the name of
+# Secret Labs AB or the author not be used in advertising or publicity
+# pertaining to distribution of the software without specific, written
+# prior permission.
+#
+# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
+# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
+# ABILITY AND FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
+# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
+# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+# OF THIS SOFTWARE.
+# --------------------------------------------------------------------
+
+"""
+Limited XInclude support for the ElementTree package.
+
+While lxml.etree has full support for XInclude (see
+`etree.ElementTree.xinclude()`), this module provides a simpler, pure
+Python, ElementTree compatible implementation that supports a simple
+form of custom URL resolvers.
+"""
+
+from lxml import etree
+try:
+ from urlparse import urljoin
+ from urllib2 import urlopen
+except ImportError:
+ # Python 3
+ from urllib.parse import urljoin
+ from urllib.request import urlopen
+
+XINCLUDE = "{http://www.w3.org/2001/XInclude}"
+
+XINCLUDE_INCLUDE = XINCLUDE + "include"
+XINCLUDE_FALLBACK = XINCLUDE + "fallback"
+XINCLUDE_ITER_TAG = XINCLUDE + "*"
+
+# For security reasons, the inclusion depth is limited to this read-only value by default.
+DEFAULT_MAX_INCLUSION_DEPTH = 6
+
+
+##
+# Fatal include error.
+
+class FatalIncludeError(etree.LxmlSyntaxError):
+ pass
+
+
+class LimitedRecursiveIncludeError(FatalIncludeError):
+ pass
+
+
+##
+# ET compatible default loader.
+# This loader reads an included resource from disk.
+#
+# @param href Resource reference.
+# @param parse Parse mode. Either "xml" or "text".
+# @param encoding Optional text encoding.
+# @return The expanded resource. If the parse mode is "xml", this
+# is an ElementTree instance. If the parse mode is "text", this
+# is a Unicode string. If the loader fails, it can return None
+# or raise an IOError exception.
+# @throws IOError If the loader fails to load the resource.
+
+def default_loader(href, parse, encoding=None):
+ file = open(href, 'rb')
+ if parse == "xml":
+ data = etree.parse(file).getroot()
+ else:
+ data = file.read()
+ if not encoding:
+ encoding = 'utf-8'
+ data = data.decode(encoding)
+ file.close()
+ return data
+
+
+##
+# Default loader used by lxml.etree - handles custom resolvers properly
+#
+
+def _lxml_default_loader(href, parse, encoding=None, parser=None):
+ if parse == "xml":
+ data = etree.parse(href, parser).getroot()
+ else:
+ if "://" in href:
+ f = urlopen(href)
+ else:
+ f = open(href, 'rb')
+ data = f.read()
+ f.close()
+ if not encoding:
+ encoding = 'utf-8'
+ data = data.decode(encoding)
+ return data
+
+
+##
+# Wrapper for ET compatibility - drops the parser
+
+def _wrap_et_loader(loader):
+ def load(href, parse, encoding=None, parser=None):
+ return loader(href, parse, encoding)
+ return load
+
+
+##
+# Expand XInclude directives.
+#
+# @param elem Root element.
+# @param loader Optional resource loader. If omitted, it defaults
+# to {@link default_loader}. If given, it should be a callable
+# that implements the same interface as default_loader .
+# @param base_url The base URL of the original file, to resolve
+# relative include file references.
+# @param max_depth The maximum number of recursive inclusions.
+# Limited to reduce the risk of malicious content explosion.
+# Pass None to disable the limitation.
+# @throws LimitedRecursiveIncludeError If the {@link max_depth} was exceeded.
+# @throws FatalIncludeError If the function fails to include a given
+# resource, or if the tree contains malformed XInclude elements.
+# @throws IOError If the function fails to load a given resource.
+# @returns the node or its replacement if it was an XInclude node
+
+def include(elem, loader=None, base_url=None,
+ max_depth=DEFAULT_MAX_INCLUSION_DEPTH):
+ if max_depth is None:
+ max_depth = -1
+ elif max_depth < 0:
+ raise ValueError("expected non-negative depth or None for 'max_depth', got %r" % max_depth)
+
+ if base_url is None:
+ if hasattr(elem, 'getroot'):
+ tree = elem
+ elem = elem.getroot()
+ else:
+ tree = elem.getroottree()
+ if hasattr(tree, 'docinfo'):
+ base_url = tree.docinfo.URL
+ elif hasattr(elem, 'getroot'):
+ elem = elem.getroot()
+ _include(elem, loader, base_url, max_depth)
+
+
+def _include(elem, loader=None, base_url=None,
+ max_depth=DEFAULT_MAX_INCLUSION_DEPTH, _parent_hrefs=None):
+ if loader is not None:
+ load_include = _wrap_et_loader(loader)
+ else:
+ load_include = _lxml_default_loader
+
+ if _parent_hrefs is None:
+ _parent_hrefs = set()
+
+ parser = elem.getroottree().parser
+
+ include_elements = list(
+ elem.iter(XINCLUDE_ITER_TAG))
+
+ for e in include_elements:
+ if e.tag == XINCLUDE_INCLUDE:
+ # process xinclude directive
+ href = urljoin(base_url, e.get("href"))
+ parse = e.get("parse", "xml")
+ parent = e.getparent()
+ if parse == "xml":
+ if href in _parent_hrefs:
+ raise FatalIncludeError(
+ "recursive include of %r detected" % href
+ )
+ if max_depth == 0:
+ raise LimitedRecursiveIncludeError(
+ "maximum xinclude depth reached when including file %s" % href)
+ node = load_include(href, parse, parser=parser)
+ if node is None:
+ raise FatalIncludeError(
+ "cannot load %r as %r" % (href, parse)
+ )
+ node = _include(node, loader, href, max_depth - 1, {href} | _parent_hrefs)
+ if e.tail:
+ node.tail = (node.tail or "") + e.tail
+ if parent is None:
+ return node # replaced the root node!
+ parent.replace(e, node)
+ elif parse == "text":
+ text = load_include(href, parse, encoding=e.get("encoding"))
+ if text is None:
+ raise FatalIncludeError(
+ "cannot load %r as %r" % (href, parse)
+ )
+ predecessor = e.getprevious()
+ if predecessor is not None:
+ predecessor.tail = (predecessor.tail or "") + text
+ elif parent is None:
+ return text # replaced the root node!
+ else:
+ parent.text = (parent.text or "") + text + (e.tail or "")
+ parent.remove(e)
+ else:
+ raise FatalIncludeError(
+ "unknown parse type in xi:include tag (%r)" % parse
+ )
+ elif e.tag == XINCLUDE_FALLBACK:
+ parent = e.getparent()
+ if parent is not None and parent.tag != XINCLUDE_INCLUDE:
+ raise FatalIncludeError(
+ "xi:fallback tag must be child of xi:include (%r)" % e.tag
+ )
+ else:
+ raise FatalIncludeError(
+ "Invalid element found in XInclude namespace (%r)" % e.tag
+ )
+ return elem
diff --git a/llava_video/lib/python3.10/site-packages/lxml/__init__.py b/llava_video/lib/python3.10/site-packages/lxml/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..45cee20a7e665013eb289efb93775d44540baacc
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/__init__.py
@@ -0,0 +1,22 @@
+# this is a package
+
+__version__ = "5.3.1"
+
+
+def get_include():
+ """
+ Returns a list of header include paths (for lxml itself, libxml2
+ and libxslt) needed to compile C code against lxml if it was built
+ with statically linked libraries.
+ """
+ import os
+ lxml_path = __path__[0]
+ include_path = os.path.join(lxml_path, 'includes')
+ includes = [include_path, lxml_path]
+
+ for name in os.listdir(include_path):
+ path = os.path.join(include_path, name)
+ if os.path.isdir(path):
+ includes.append(path)
+
+ return includes
diff --git a/llava_video/lib/python3.10/site-packages/lxml/_elementpath.py b/llava_video/lib/python3.10/site-packages/lxml/_elementpath.py
new file mode 100644
index 0000000000000000000000000000000000000000..6233a63502600e0d7165ee51b7e3164792089a16
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/_elementpath.py
@@ -0,0 +1,341 @@
+# cython: language_level=2
+
+#
+# ElementTree
+# $Id: ElementPath.py 3375 2008-02-13 08:05:08Z fredrik $
+#
+# limited xpath support for element trees
+#
+# history:
+# 2003-05-23 fl created
+# 2003-05-28 fl added support for // etc
+# 2003-08-27 fl fixed parsing of periods in element names
+# 2007-09-10 fl new selection engine
+# 2007-09-12 fl fixed parent selector
+# 2007-09-13 fl added iterfind; changed findall to return a list
+# 2007-11-30 fl added namespaces support
+# 2009-10-30 fl added child element value filter
+#
+# Copyright (c) 2003-2009 by Fredrik Lundh. All rights reserved.
+#
+# fredrik@pythonware.com
+# http://www.pythonware.com
+#
+# --------------------------------------------------------------------
+# The ElementTree toolkit is
+#
+# Copyright (c) 1999-2009 by Fredrik Lundh
+#
+# By obtaining, using, and/or copying this software and/or its
+# associated documentation, you agree that you have read, understood,
+# and will comply with the following terms and conditions:
+#
+# Permission to use, copy, modify, and distribute this software and
+# its associated documentation for any purpose and without fee is
+# hereby granted, provided that the above copyright notice appears in
+# all copies, and that both that copyright notice and this permission
+# notice appear in supporting documentation, and that the name of
+# Secret Labs AB or the author not be used in advertising or publicity
+# pertaining to distribution of the software without specific, written
+# prior permission.
+#
+# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
+# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
+# ABILITY AND FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
+# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
+# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+# OF THIS SOFTWARE.
+# --------------------------------------------------------------------
+
+##
+# Implementation module for XPath support. There's usually no reason
+# to import this module directly; the ElementTree does this for
+# you, if needed.
+##
+
+
+import re
+
+xpath_tokenizer_re = re.compile(
+ "("
+ "'[^']*'|\"[^\"]*\"|"
+ "::|"
+ "//?|"
+ r"\.\.|"
+ r"\(\)|"
+ r"[/.*:\[\]\(\)@=])|"
+ r"((?:\{[^}]+\})?[^/\[\]\(\)@=\s]+)|"
+ r"\s+"
+ )
+
+def xpath_tokenizer(pattern, namespaces=None, with_prefixes=True):
+ # ElementTree uses '', lxml used None originally.
+ default_namespace = (namespaces.get(None) or namespaces.get('')) if namespaces else None
+ parsing_attribute = False
+ for token in xpath_tokenizer_re.findall(pattern):
+ ttype, tag = token
+ if tag and tag[0] != "{":
+ if ":" in tag and with_prefixes:
+ prefix, uri = tag.split(":", 1)
+ try:
+ if not namespaces:
+ raise KeyError
+ yield ttype, "{%s}%s" % (namespaces[prefix], uri)
+ except KeyError:
+ raise SyntaxError("prefix %r not found in prefix map" % prefix)
+ elif default_namespace and not parsing_attribute:
+ yield ttype, "{%s}%s" % (default_namespace, tag)
+ else:
+ yield token
+ parsing_attribute = False
+ else:
+ yield token
+ parsing_attribute = ttype == '@'
+
+
+def prepare_child(next, token):
+ tag = token[1]
+ def select(result):
+ for elem in result:
+ yield from elem.iterchildren(tag)
+ return select
+
+def prepare_star(next, token):
+ def select(result):
+ for elem in result:
+ yield from elem.iterchildren('*')
+ return select
+
+def prepare_self(next, token):
+ def select(result):
+ return result
+ return select
+
+def prepare_descendant(next, token):
+ token = next()
+ if token[0] == "*":
+ tag = "*"
+ elif not token[0]:
+ tag = token[1]
+ else:
+ raise SyntaxError("invalid descendant")
+ def select(result):
+ for elem in result:
+ yield from elem.iterdescendants(tag)
+ return select
+
+def prepare_parent(next, token):
+ def select(result):
+ for elem in result:
+ parent = elem.getparent()
+ if parent is not None:
+ yield parent
+ return select
+
+def prepare_predicate(next, token):
+ # FIXME: replace with real parser!!! refs:
+ # http://effbot.org/zone/simple-iterator-parser.htm
+ # http://javascript.crockford.com/tdop/tdop.html
+ signature = ''
+ predicate = []
+ while 1:
+ token = next()
+ if token[0] == "]":
+ break
+ if token == ('', ''):
+ # ignore whitespace
+ continue
+ if token[0] and token[0][:1] in "'\"":
+ token = "'", token[0][1:-1]
+ signature += token[0] or "-"
+ predicate.append(token[1])
+
+ # use signature to determine predicate type
+ if signature == "@-":
+ # [@attribute] predicate
+ key = predicate[1]
+ def select(result):
+ for elem in result:
+ if elem.get(key) is not None:
+ yield elem
+ return select
+ if signature == "@-='":
+ # [@attribute='value']
+ key = predicate[1]
+ value = predicate[-1]
+ def select(result):
+ for elem in result:
+ if elem.get(key) == value:
+ yield elem
+ return select
+ if signature == "-" and not re.match(r"-?\d+$", predicate[0]):
+ # [tag]
+ tag = predicate[0]
+ def select(result):
+ for elem in result:
+ for _ in elem.iterchildren(tag):
+ yield elem
+ break
+ return select
+ if signature == ".='" or (signature == "-='" and not re.match(r"-?\d+$", predicate[0])):
+ # [.='value'] or [tag='value']
+ tag = predicate[0]
+ value = predicate[-1]
+ if tag:
+ def select(result):
+ for elem in result:
+ for e in elem.iterchildren(tag):
+ if "".join(e.itertext()) == value:
+ yield elem
+ break
+ else:
+ def select(result):
+ for elem in result:
+ if "".join(elem.itertext()) == value:
+ yield elem
+ return select
+ if signature == "-" or signature == "-()" or signature == "-()-":
+ # [index] or [last()] or [last()-index]
+ if signature == "-":
+ # [index]
+ index = int(predicate[0]) - 1
+ if index < 0:
+ if index == -1:
+ raise SyntaxError(
+ "indices in path predicates are 1-based, not 0-based")
+ else:
+ raise SyntaxError("path index >= 1 expected")
+ else:
+ if predicate[0] != "last":
+ raise SyntaxError("unsupported function")
+ if signature == "-()-":
+ try:
+ index = int(predicate[2]) - 1
+ except ValueError:
+ raise SyntaxError("unsupported expression")
+ else:
+ index = -1
+ def select(result):
+ for elem in result:
+ parent = elem.getparent()
+ if parent is None:
+ continue
+ try:
+ # FIXME: what if the selector is "*" ?
+ elems = list(parent.iterchildren(elem.tag))
+ if elems[index] is elem:
+ yield elem
+ except IndexError:
+ pass
+ return select
+ raise SyntaxError("invalid predicate")
+
+ops = {
+ "": prepare_child,
+ "*": prepare_star,
+ ".": prepare_self,
+ "..": prepare_parent,
+ "//": prepare_descendant,
+ "[": prepare_predicate,
+}
+
+
+# --------------------------------------------------------------------
+
+_cache = {}
+
+
+def _build_path_iterator(path, namespaces, with_prefixes=True):
+ """compile selector pattern"""
+ if path[-1:] == "/":
+ path += "*" # implicit all (FIXME: keep this?)
+
+ cache_key = (path,)
+ if namespaces:
+ # lxml originally used None for the default namespace but ElementTree uses the
+ # more convenient (all-strings-dict) empty string, so we support both here,
+ # preferring the more convenient '', as long as they aren't ambiguous.
+ if None in namespaces:
+ if '' in namespaces and namespaces[None] != namespaces['']:
+ raise ValueError("Ambiguous default namespace provided: %r versus %r" % (
+ namespaces[None], namespaces['']))
+ cache_key += (namespaces[None],) + tuple(sorted(
+ item for item in namespaces.items() if item[0] is not None))
+ else:
+ cache_key += tuple(sorted(namespaces.items()))
+
+ try:
+ return _cache[cache_key]
+ except KeyError:
+ pass
+ if len(_cache) > 100:
+ _cache.clear()
+
+ if path[:1] == "/":
+ raise SyntaxError("cannot use absolute path on element")
+ stream = iter(xpath_tokenizer(path, namespaces, with_prefixes=with_prefixes))
+ try:
+ _next = stream.next
+ except AttributeError:
+ # Python 3
+ _next = stream.__next__
+ try:
+ token = _next()
+ except StopIteration:
+ raise SyntaxError("empty path expression")
+ selector = []
+ while 1:
+ try:
+ selector.append(ops[token[0]](_next, token))
+ except StopIteration:
+ raise SyntaxError("invalid path")
+ try:
+ token = _next()
+ if token[0] == "/":
+ token = _next()
+ except StopIteration:
+ break
+ _cache[cache_key] = selector
+ return selector
+
+
+##
+# Iterate over the matching nodes
+
+def iterfind(elem, path, namespaces=None, with_prefixes=True):
+ selector = _build_path_iterator(path, namespaces, with_prefixes=with_prefixes)
+ result = iter((elem,))
+ for select in selector:
+ result = select(result)
+ return result
+
+
+##
+# Find first matching object.
+
+def find(elem, path, namespaces=None, with_prefixes=True):
+ it = iterfind(elem, path, namespaces, with_prefixes=with_prefixes)
+ try:
+ return next(it)
+ except StopIteration:
+ return None
+
+
+##
+# Find all matching objects.
+
+def findall(elem, path, namespaces=None, with_prefixes=True):
+ return list(iterfind(elem, path, namespaces))
+
+
+##
+# Find text for first matching object.
+
+def findtext(elem, path, default=None, namespaces=None, with_prefixes=True):
+ el = find(elem, path, namespaces, with_prefixes=with_prefixes)
+ if el is None:
+ return default
+ else:
+ return el.text or ''
diff --git a/llava_video/lib/python3.10/site-packages/lxml/apihelpers.pxi b/llava_video/lib/python3.10/site-packages/lxml/apihelpers.pxi
new file mode 100644
index 0000000000000000000000000000000000000000..fb60af7d23766c9b5bd8a10f14a02ad099a8d249
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/apihelpers.pxi
@@ -0,0 +1,1793 @@
+# Private/public helper functions for API functions
+
+from lxml.includes cimport uri
+
+
+cdef void displayNode(xmlNode* c_node, indent) noexcept:
+ # to help with debugging
+ cdef xmlNode* c_child
+ try:
+ print(indent * ' ', c_node)
+ c_child = c_node.children
+ while c_child is not NULL:
+ displayNode(c_child, indent + 1)
+ c_child = c_child.next
+ finally:
+ return # swallow any exceptions
+
+cdef inline bint _isHtmlDocument(_Element element) except -1:
+ cdef xmlNode* c_node = element._c_node
+ return (
+ c_node is not NULL and c_node.doc is not NULL and
+ c_node.doc.properties & tree.XML_DOC_HTML != 0
+ )
+
+cdef inline int _assertValidNode(_Element element) except -1:
+ assert element._c_node is not NULL, "invalid Element proxy at %s" % id(element)
+
+cdef inline int _assertValidDoc(_Document doc) except -1:
+ assert doc._c_doc is not NULL, "invalid Document proxy at %s" % id(doc)
+
+cdef _Document _documentOrRaise(object input):
+ """Call this to get the document of a _Document, _ElementTree or _Element
+ object, or to raise an exception if it can't be determined.
+
+ Should be used in all API functions for consistency.
+ """
+ cdef _Document doc
+ if isinstance(input, _ElementTree):
+ if (<_ElementTree>input)._context_node is not None:
+ doc = (<_ElementTree>input)._context_node._doc
+ else:
+ doc = None
+ elif isinstance(input, _Element):
+ doc = (<_Element>input)._doc
+ elif isinstance(input, _Document):
+ doc = <_Document>input
+ else:
+ raise TypeError, f"Invalid input object: {python._fqtypename(input).decode('utf8')}"
+ if doc is None:
+ raise ValueError, f"Input object has no document: {python._fqtypename(input).decode('utf8')}"
+ _assertValidDoc(doc)
+ return doc
+
+cdef _Element _rootNodeOrRaise(object input):
+ """Call this to get the root node of a _Document, _ElementTree or
+ _Element object, or to raise an exception if it can't be determined.
+
+ Should be used in all API functions for consistency.
+ """
+ cdef _Element node
+ if isinstance(input, _ElementTree):
+ node = (<_ElementTree>input)._context_node
+ elif isinstance(input, _Element):
+ node = <_Element>input
+ elif isinstance(input, _Document):
+ node = (<_Document>input).getroot()
+ else:
+ raise TypeError, f"Invalid input object: {python._fqtypename(input).decode('utf8')}"
+ if (node is None or not node._c_node or
+ node._c_node.type != tree.XML_ELEMENT_NODE):
+ raise ValueError, f"Input object is not an XML element: {python._fqtypename(input).decode('utf8')}"
+ _assertValidNode(node)
+ return node
+
+cdef bint _isAncestorOrSame(xmlNode* c_ancestor, xmlNode* c_node) noexcept:
+ while c_node:
+ if c_node is c_ancestor:
+ return True
+ c_node = c_node.parent
+ return False
+
+cdef _Element _makeElement(tag, xmlDoc* c_doc, _Document doc,
+ _BaseParser parser, text, tail, attrib, nsmap,
+ dict extra_attrs):
+ """Create a new element and initialize text content, namespaces and
+ attributes.
+
+ This helper function will reuse as much of the existing document as
+ possible:
+
+ If 'parser' is None, the parser will be inherited from 'doc' or the
+ default parser will be used.
+
+ If 'doc' is None, 'c_doc' is used to create a new _Document and the new
+ element is made its root node.
+
+ If 'c_doc' is also NULL, a new xmlDoc will be created.
+ """
+ cdef xmlNode* c_node
+ if doc is not None:
+ c_doc = doc._c_doc
+ ns_utf, name_utf = _getNsTag(tag)
+ if parser is not None and parser._for_html:
+ _htmlTagValidOrRaise(name_utf)
+ if c_doc is NULL:
+ c_doc = _newHTMLDoc()
+ else:
+ _tagValidOrRaise(name_utf)
+ if c_doc is NULL:
+ c_doc = _newXMLDoc()
+ c_node = _createElement(c_doc, name_utf)
+ if c_node is NULL:
+ if doc is None and c_doc is not NULL:
+ tree.xmlFreeDoc(c_doc)
+ raise MemoryError()
+ try:
+ if doc is None:
+ tree.xmlDocSetRootElement(c_doc, c_node)
+ doc = _documentFactory(c_doc, parser)
+ if text is not None:
+ _setNodeText(c_node, text)
+ if tail is not None:
+ _setTailText(c_node, tail)
+ # add namespaces to node if necessary
+ _setNodeNamespaces(c_node, doc, ns_utf, nsmap)
+ _initNodeAttributes(c_node, doc, attrib, extra_attrs)
+ return _elementFactory(doc, c_node)
+ except:
+ # free allocated c_node/c_doc unless Python does it for us
+ if c_node.doc is not c_doc:
+ # node not yet in document => will not be freed by document
+ if tail is not None:
+ _removeText(c_node.next) # tail
+ tree.xmlFreeNode(c_node)
+ if doc is None:
+ # c_doc will not be freed by doc
+ tree.xmlFreeDoc(c_doc)
+ raise
+
+cdef int _initNewElement(_Element element, bint is_html, name_utf, ns_utf,
+ _BaseParser parser, attrib, nsmap, dict extra_attrs) except -1:
+ """Initialise a new Element object.
+
+ This is used when users instantiate a Python Element subclass
+ directly, without it being mapped to an existing XML node.
+ """
+ cdef xmlDoc* c_doc
+ cdef xmlNode* c_node
+ cdef _Document doc
+ if is_html:
+ _htmlTagValidOrRaise(name_utf)
+ c_doc = _newHTMLDoc()
+ else:
+ _tagValidOrRaise(name_utf)
+ c_doc = _newXMLDoc()
+ c_node = _createElement(c_doc, name_utf)
+ if c_node is NULL:
+ if c_doc is not NULL:
+ tree.xmlFreeDoc(c_doc)
+ raise MemoryError()
+ tree.xmlDocSetRootElement(c_doc, c_node)
+ doc = _documentFactory(c_doc, parser)
+ # add namespaces to node if necessary
+ _setNodeNamespaces(c_node, doc, ns_utf, nsmap)
+ _initNodeAttributes(c_node, doc, attrib, extra_attrs)
+ _registerProxy(element, doc, c_node)
+ element._init()
+ return 0
+
+cdef _Element _makeSubElement(_Element parent, tag, text, tail,
+ attrib, nsmap, dict extra_attrs):
+ """Create a new child element and initialize text content, namespaces and
+ attributes.
+ """
+ cdef xmlNode* c_node
+ cdef xmlDoc* c_doc
+ if parent is None or parent._doc is None:
+ return None
+ _assertValidNode(parent)
+ ns_utf, name_utf = _getNsTag(tag)
+ c_doc = parent._doc._c_doc
+
+ if parent._doc._parser is not None and parent._doc._parser._for_html:
+ _htmlTagValidOrRaise(name_utf)
+ else:
+ _tagValidOrRaise(name_utf)
+
+ c_node = _createElement(c_doc, name_utf)
+ if c_node is NULL:
+ raise MemoryError()
+ tree.xmlAddChild(parent._c_node, c_node)
+
+ try:
+ if text is not None:
+ _setNodeText(c_node, text)
+ if tail is not None:
+ _setTailText(c_node, tail)
+
+ # add namespaces to node if necessary
+ _setNodeNamespaces(c_node, parent._doc, ns_utf, nsmap)
+ _initNodeAttributes(c_node, parent._doc, attrib, extra_attrs)
+ return _elementFactory(parent._doc, c_node)
+ except:
+ # make sure we clean up in case of an error
+ _removeNode(parent._doc, c_node)
+ raise
+
+
+cdef int _setNodeNamespaces(xmlNode* c_node, _Document doc,
+ object node_ns_utf, object nsmap) except -1:
+ """Lookup current namespace prefixes, then set namespace structure for
+ node (if 'node_ns_utf' was provided) and register new ns-prefix mappings.
+
+ 'node_ns_utf' should only be passed for a newly created node.
+ """
+ cdef xmlNs* c_ns
+ cdef list nsdefs
+
+ if nsmap:
+ for prefix, href in _iter_nsmap(nsmap):
+ href_utf = _utf8(href)
+ _uriValidOrRaise(href_utf)
+ c_href = _xcstr(href_utf)
+ if prefix is not None:
+ prefix_utf = _utf8(prefix)
+ _prefixValidOrRaise(prefix_utf)
+ c_prefix = _xcstr(prefix_utf)
+ else:
+ c_prefix = NULL
+ # add namespace with prefix if it is not already known
+ c_ns = tree.xmlSearchNs(doc._c_doc, c_node, c_prefix)
+ if c_ns is NULL or \
+ c_ns.href is NULL or \
+ tree.xmlStrcmp(c_ns.href, c_href) != 0:
+ c_ns = tree.xmlNewNs(c_node, c_href, c_prefix)
+ if href_utf == node_ns_utf:
+ tree.xmlSetNs(c_node, c_ns)
+ node_ns_utf = None
+
+ if node_ns_utf is not None:
+ _uriValidOrRaise(node_ns_utf)
+ doc._setNodeNs(c_node, _xcstr(node_ns_utf))
+ return 0
+
+
+cdef dict _build_nsmap(xmlNode* c_node):
+ """
+ Namespace prefix->URI mapping known in the context of this Element.
+ This includes all namespace declarations of the parents.
+ """
+ cdef xmlNs* c_ns
+ nsmap = {}
+ while c_node is not NULL and c_node.type == tree.XML_ELEMENT_NODE:
+ c_ns = c_node.nsDef
+ while c_ns is not NULL:
+ if c_ns.prefix or c_ns.href:
+ prefix = funicodeOrNone(c_ns.prefix)
+ if prefix not in nsmap:
+ nsmap[prefix] = funicodeOrNone(c_ns.href)
+ c_ns = c_ns.next
+ c_node = c_node.parent
+ return nsmap
+
+
+cdef _iter_nsmap(nsmap):
+ """
+ Create a reproducibly ordered iterable from an nsmap mapping.
+ Tries to preserve an existing order and sorts if it assumes no order.
+
+ The difference to _iter_attrib() is that None doesn't sort with strings
+ in Py3.x.
+ """
+ if isinstance(nsmap, dict):
+ # dicts are insertion-ordered in Py3.6+ => keep the user provided order.
+ return nsmap.items()
+ if len(nsmap) <= 1:
+ return nsmap.items()
+ # nsmap will usually be a plain unordered dict => avoid type checking overhead
+ if type(nsmap) is not dict and isinstance(nsmap, OrderedDict):
+ return nsmap.items() # keep existing order
+ if None not in nsmap:
+ return sorted(nsmap.items())
+
+ # Move the default namespace to the end. This makes sure libxml2
+ # prefers a prefix if the ns is defined redundantly on the same
+ # element. That way, users can work around a problem themselves
+ # where default namespace attributes on non-default namespaced
+ # elements serialise without prefix (i.e. into the non-default
+ # namespace).
+ default_ns = nsmap[None]
+ nsdefs = [(k, v) for k, v in nsmap.items() if k is not None]
+ nsdefs.sort()
+ nsdefs.append((None, default_ns))
+ return nsdefs
+
+
+cdef _iter_attrib(attrib):
+ """
+ Create a reproducibly ordered iterable from an attrib mapping.
+ Tries to preserve an existing order and sorts if it assumes no order.
+ """
+ # dicts are insertion-ordered in Py3.6+ => keep the user provided order.
+ if isinstance(attrib, (dict, _Attrib, OrderedDict)):
+ return attrib.items()
+ # assume it's an unordered mapping of some kind
+ return sorted(attrib.items())
+
+
+cdef _initNodeAttributes(xmlNode* c_node, _Document doc, attrib, dict extra):
+ """Initialise the attributes of an element node.
+ """
+ cdef bint is_html
+ cdef xmlNs* c_ns
+ if attrib is not None and not hasattr(attrib, 'items'):
+ raise TypeError, f"Invalid attribute dictionary: {python._fqtypename(attrib).decode('utf8')}"
+ if not attrib and not extra:
+ return # nothing to do
+ is_html = doc._parser._for_html
+ seen = set()
+ if extra:
+ for name, value in extra.items():
+ _addAttributeToNode(c_node, doc, is_html, name, value, seen)
+ if attrib:
+ for name, value in _iter_attrib(attrib):
+ _addAttributeToNode(c_node, doc, is_html, name, value, seen)
+
+
+cdef int _addAttributeToNode(xmlNode* c_node, _Document doc, bint is_html,
+ name, value, set seen_tags) except -1:
+ ns_utf, name_utf = tag = _getNsTag(name)
+ if tag in seen_tags:
+ return 0
+ seen_tags.add(tag)
+ if not is_html:
+ _attributeValidOrRaise(name_utf)
+ value_utf = _utf8(value)
+ if ns_utf is None:
+ tree.xmlNewProp(c_node, _xcstr(name_utf), _xcstr(value_utf))
+ else:
+ _uriValidOrRaise(ns_utf)
+ c_ns = doc._findOrBuildNodeNs(c_node, _xcstr(ns_utf), NULL, 1)
+ tree.xmlNewNsProp(c_node, c_ns,
+ _xcstr(name_utf), _xcstr(value_utf))
+ return 0
+
+
+ctypedef struct _ns_node_ref:
+ xmlNs* ns
+ xmlNode* node
+
+
+cdef int _collectNsDefs(xmlNode* c_element, _ns_node_ref **_c_ns_list,
+ size_t *_c_ns_list_len, size_t *_c_ns_list_size) except -1:
+ c_ns_list = _c_ns_list[0]
+ cdef size_t c_ns_list_len = _c_ns_list_len[0]
+ cdef size_t c_ns_list_size = _c_ns_list_size[0]
+
+ c_nsdef = c_element.nsDef
+ while c_nsdef is not NULL:
+ if c_ns_list_len >= c_ns_list_size:
+ if c_ns_list is NULL:
+ c_ns_list_size = 20
+ else:
+ c_ns_list_size *= 2
+ c_nsref_ptr = <_ns_node_ref*> python.lxml_realloc(
+ c_ns_list, c_ns_list_size, sizeof(_ns_node_ref))
+ if c_nsref_ptr is NULL:
+ if c_ns_list is not NULL:
+ python.lxml_free(c_ns_list)
+ _c_ns_list[0] = NULL
+ raise MemoryError()
+ c_ns_list = c_nsref_ptr
+
+ c_ns_list[c_ns_list_len] = _ns_node_ref(c_nsdef, c_element)
+ c_ns_list_len += 1
+ c_nsdef = c_nsdef.next
+
+ _c_ns_list_size[0] = c_ns_list_size
+ _c_ns_list_len[0] = c_ns_list_len
+ _c_ns_list[0] = c_ns_list
+
+
+cdef int _removeUnusedNamespaceDeclarations(xmlNode* c_element, set prefixes_to_keep) except -1:
+ """Remove any namespace declarations from a subtree that are not used by
+ any of its elements (or attributes).
+
+ If a 'prefixes_to_keep' is provided, it must be a set of prefixes.
+ Any corresponding namespace mappings will not be removed as part of the cleanup.
+ """
+ cdef xmlNode* c_node
+ cdef _ns_node_ref* c_ns_list = NULL
+ cdef size_t c_ns_list_size = 0
+ cdef size_t c_ns_list_len = 0
+ cdef size_t i
+
+ if c_element.parent and c_element.parent.type == tree.XML_DOCUMENT_NODE:
+ # include declarations on the document node
+ _collectNsDefs(c_element.parent, &c_ns_list, &c_ns_list_len, &c_ns_list_size)
+
+ tree.BEGIN_FOR_EACH_ELEMENT_FROM(c_element, c_element, 1)
+ # collect all new namespace declarations into the ns list
+ if c_element.nsDef:
+ _collectNsDefs(c_element, &c_ns_list, &c_ns_list_len, &c_ns_list_size)
+
+ # remove all namespace declarations from the list that are referenced
+ if c_ns_list_len and c_element.type == tree.XML_ELEMENT_NODE:
+ c_node = c_element
+ while c_node and c_ns_list_len:
+ if c_node.ns:
+ for i in range(c_ns_list_len):
+ if c_node.ns is c_ns_list[i].ns:
+ c_ns_list_len -= 1
+ c_ns_list[i] = c_ns_list[c_ns_list_len]
+ #c_ns_list[c_ns_list_len] = _ns_node_ref(NULL, NULL)
+ break
+ if c_node is c_element:
+ # continue with attributes
+ c_node = c_element.properties
+ else:
+ c_node = c_node.next
+ tree.END_FOR_EACH_ELEMENT_FROM(c_element)
+
+ if c_ns_list is NULL:
+ return 0
+
+ # free all namespace declarations that remained in the list,
+ # except for those we should keep explicitly
+ cdef xmlNs* c_nsdef
+ for i in range(c_ns_list_len):
+ if prefixes_to_keep is not None:
+ if c_ns_list[i].ns.prefix and c_ns_list[i].ns.prefix in prefixes_to_keep:
+ continue
+ c_node = c_ns_list[i].node
+ c_nsdef = c_node.nsDef
+ if c_nsdef is c_ns_list[i].ns:
+ c_node.nsDef = c_node.nsDef.next
+ else:
+ while c_nsdef.next is not c_ns_list[i].ns:
+ c_nsdef = c_nsdef.next
+ c_nsdef.next = c_nsdef.next.next
+ tree.xmlFreeNs(c_ns_list[i].ns)
+
+ if c_ns_list is not NULL:
+ python.lxml_free(c_ns_list)
+ return 0
+
+cdef xmlNs* _searchNsByHref(xmlNode* c_node, const_xmlChar* c_href, bint is_attribute) noexcept:
+ """Search a namespace declaration that covers a node (element or
+ attribute).
+
+ For attributes, try to find a prefixed namespace declaration
+ instead of the default namespaces. This helps in supporting
+ round-trips for attributes on elements with a different namespace.
+ """
+ cdef xmlNs* c_ns
+ cdef xmlNs* c_default_ns = NULL
+ cdef xmlNode* c_element
+ if c_href is NULL or c_node is NULL or c_node.type == tree.XML_ENTITY_REF_NODE:
+ return NULL
+ if tree.xmlStrcmp(c_href, tree.XML_XML_NAMESPACE) == 0:
+ # no special cases here, let libxml2 handle this
+ return tree.xmlSearchNsByHref(c_node.doc, c_node, c_href)
+ if c_node.type == tree.XML_ATTRIBUTE_NODE:
+ is_attribute = 1
+ while c_node is not NULL and c_node.type != tree.XML_ELEMENT_NODE:
+ c_node = c_node.parent
+ c_element = c_node
+ while c_node is not NULL:
+ if c_node.type == tree.XML_ELEMENT_NODE:
+ c_ns = c_node.nsDef
+ while c_ns is not NULL:
+ if c_ns.href is not NULL and tree.xmlStrcmp(c_href, c_ns.href) == 0:
+ if c_ns.prefix is NULL and is_attribute:
+ # for attributes, continue searching a named
+ # prefix, but keep the first default namespace
+ # declaration that we found
+ if c_default_ns is NULL:
+ c_default_ns = c_ns
+ elif tree.xmlSearchNs(
+ c_element.doc, c_element, c_ns.prefix) is c_ns:
+ # start node is in namespace scope => found!
+ return c_ns
+ c_ns = c_ns.next
+ if c_node is not c_element and c_node.ns is not NULL:
+ # optimise: the node may have the namespace itself
+ c_ns = c_node.ns
+ if c_ns.href is not NULL and tree.xmlStrcmp(c_href, c_ns.href) == 0:
+ if c_ns.prefix is NULL and is_attribute:
+ # for attributes, continue searching a named
+ # prefix, but keep the first default namespace
+ # declaration that we found
+ if c_default_ns is NULL:
+ c_default_ns = c_ns
+ elif tree.xmlSearchNs(
+ c_element.doc, c_element, c_ns.prefix) is c_ns:
+ # start node is in namespace scope => found!
+ return c_ns
+ c_node = c_node.parent
+ # nothing found => use a matching default namespace or fail
+ if c_default_ns is not NULL:
+ if tree.xmlSearchNs(c_element.doc, c_element, NULL) is c_default_ns:
+ return c_default_ns
+ return NULL
+
+cdef int _replaceNodeByChildren(_Document doc, xmlNode* c_node) except -1:
+ # NOTE: this does not deallocate the node, just unlink it!
+ cdef xmlNode* c_parent
+ cdef xmlNode* c_child
+ if c_node.children is NULL:
+ tree.xmlUnlinkNode(c_node)
+ return 0
+
+ c_parent = c_node.parent
+ # fix parent links of children
+ c_child = c_node.children
+ while c_child is not NULL:
+ c_child.parent = c_parent
+ c_child = c_child.next
+
+ # fix namespace references of children if their parent's namespace
+ # declarations get lost
+ if c_node.nsDef is not NULL:
+ c_child = c_node.children
+ while c_child is not NULL:
+ moveNodeToDocument(doc, doc._c_doc, c_child)
+ c_child = c_child.next
+
+ # fix sibling links to/from child slice
+ if c_node.prev is NULL:
+ c_parent.children = c_node.children
+ else:
+ c_node.prev.next = c_node.children
+ c_node.children.prev = c_node.prev
+ if c_node.next is NULL:
+ c_parent.last = c_node.last
+ else:
+ c_node.next.prev = c_node.last
+ c_node.last.next = c_node.next
+
+ # unlink c_node
+ c_node.children = c_node.last = NULL
+ c_node.parent = c_node.next = c_node.prev = NULL
+ return 0
+
+cdef unicode _attributeValue(xmlNode* c_element, xmlAttr* c_attrib_node):
+ c_href = _getNs(c_attrib_node)
+ value = tree.xmlGetNsProp(c_element, c_attrib_node.name, c_href)
+ try:
+ result = funicode(value)
+ finally:
+ tree.xmlFree(value)
+ return result
+
+cdef unicode _attributeValueFromNsName(xmlNode* c_element,
+ const_xmlChar* c_href, const_xmlChar* c_name):
+ c_result = tree.xmlGetNsProp(c_element, c_name, c_href)
+ if c_result is NULL:
+ return None
+ try:
+ result = funicode(c_result)
+ finally:
+ tree.xmlFree(c_result)
+ return result
+
+cdef object _getNodeAttributeValue(xmlNode* c_node, key, default):
+ ns, tag = _getNsTag(key)
+ c_href = NULL if ns is None else _xcstr(ns)
+ c_result = tree.xmlGetNsProp(c_node, _xcstr(tag), c_href)
+ if c_result is NULL:
+ # XXX free namespace that is not in use..?
+ return default
+ try:
+ result = funicode(c_result)
+ finally:
+ tree.xmlFree(c_result)
+ return result
+
+cdef inline object _getAttributeValue(_Element element, key, default):
+ return _getNodeAttributeValue(element._c_node, key, default)
+
+cdef int _setAttributeValue(_Element element, key, value) except -1:
+ cdef const_xmlChar* c_value
+ cdef xmlNs* c_ns
+ ns, tag = _getNsTag(key)
+ is_html = element._doc._parser._for_html
+ if not is_html:
+ _attributeValidOrRaise(tag)
+ c_tag = _xcstr(tag)
+ if value is None and is_html:
+ c_value = NULL
+ else:
+ if isinstance(value, QName):
+ value = _resolveQNameText(element, value)
+ else:
+ value = _utf8(value)
+ c_value = _xcstr(value)
+ if ns is None:
+ c_ns = NULL
+ else:
+ c_ns = element._doc._findOrBuildNodeNs(element._c_node, _xcstr(ns), NULL, 1)
+ tree.xmlSetNsProp(element._c_node, c_ns, c_tag, c_value)
+ return 0
+
+cdef int _delAttribute(_Element element, key) except -1:
+ ns, tag = _getNsTag(key)
+ c_href = NULL if ns is None else _xcstr(ns)
+ if _delAttributeFromNsName(element._c_node, c_href, _xcstr(tag)):
+ raise KeyError, key
+ return 0
+
+cdef int _delAttributeFromNsName(xmlNode* c_node, const_xmlChar* c_href, const_xmlChar* c_name) noexcept:
+ c_attr = tree.xmlHasNsProp(c_node, c_name, c_href)
+ if c_attr is NULL:
+ # XXX free namespace that is not in use..?
+ return -1
+ tree.xmlRemoveProp(c_attr)
+ return 0
+
+cdef list _collectAttributes(xmlNode* c_node, int collecttype):
+ """Collect all attributes of a node in a list. Depending on collecttype,
+ it collects either the name (1), the value (2) or the name-value tuples.
+ """
+ cdef Py_ssize_t count
+ c_attr = c_node.properties
+ count = 0
+ while c_attr is not NULL:
+ if c_attr.type == tree.XML_ATTRIBUTE_NODE:
+ count += 1
+ c_attr = c_attr.next
+
+ if not count:
+ return []
+
+ attributes = [None] * count
+ c_attr = c_node.properties
+ count = 0
+ while c_attr is not NULL:
+ if c_attr.type == tree.XML_ATTRIBUTE_NODE:
+ if collecttype == 1:
+ item = _namespacedName(c_attr)
+ elif collecttype == 2:
+ item = _attributeValue(c_node, c_attr)
+ else:
+ item = (_namespacedName(c_attr),
+ _attributeValue(c_node, c_attr))
+ attributes[count] = item
+ count += 1
+ c_attr = c_attr.next
+ return attributes
+
+cdef object __RE_XML_ENCODING = re.compile(
+ r'^(<\?xml[^>]+)\s+encoding\s*=\s*["\'][^"\']*["\'](\s*\?>|)', re.U)
+
+cdef object __REPLACE_XML_ENCODING = __RE_XML_ENCODING.sub
+cdef object __HAS_XML_ENCODING = __RE_XML_ENCODING.match
+
+cdef object _stripEncodingDeclaration(object xml_string):
+ # this is a hack to remove the XML encoding declaration from unicode
+ return __REPLACE_XML_ENCODING(r'\g<1>\g<2>', xml_string)
+
+cdef bint _hasEncodingDeclaration(object xml_string) except -1:
+ # check if a (unicode) string has an XML encoding declaration
+ return __HAS_XML_ENCODING(xml_string) is not None
+
+cdef inline bint _hasText(xmlNode* c_node) noexcept:
+ return c_node is not NULL and _textNodeOrSkip(c_node.children) is not NULL
+
+cdef inline bint _hasTail(xmlNode* c_node) noexcept:
+ return c_node is not NULL and _textNodeOrSkip(c_node.next) is not NULL
+
+cdef inline bint _hasNonWhitespaceTail(xmlNode* c_node) except -1:
+ return _hasNonWhitespaceText(c_node, tail=True)
+
+cdef bint _hasNonWhitespaceText(xmlNode* c_node, bint tail=False) except -1:
+ c_text_node = c_node and _textNodeOrSkip(c_node.next if tail else c_node.children)
+ if c_text_node is NULL:
+ return False
+ while c_text_node is not NULL:
+ if c_text_node.content[0] != c'\0' and not _collectText(c_text_node).isspace():
+ return True
+ c_text_node = _textNodeOrSkip(c_text_node.next)
+ return False
+
+cdef unicode _collectText(xmlNode* c_node):
+ """Collect all text nodes and return them as a unicode string.
+
+ Start collecting at c_node.
+
+ If there was no text to collect, return None
+ """
+ cdef Py_ssize_t scount
+ cdef xmlChar* c_text
+ cdef xmlNode* c_node_cur
+ # check for multiple text nodes
+ scount = 0
+ c_text = NULL
+ c_node_cur = c_node = _textNodeOrSkip(c_node)
+ while c_node_cur is not NULL:
+ if c_node_cur.content[0] != c'\0':
+ c_text = c_node_cur.content
+ scount += 1
+ c_node_cur = _textNodeOrSkip(c_node_cur.next)
+
+ # handle two most common cases first
+ if c_text is NULL:
+ return '' if scount > 0 else None
+ if scount == 1:
+ return funicode(c_text)
+
+ # the rest is not performance critical anymore
+ result = b''
+ while c_node is not NULL:
+ result += c_node.content
+ c_node = _textNodeOrSkip(c_node.next)
+ return funicode(result)
+
+cdef void _removeText(xmlNode* c_node) noexcept:
+ """Remove all text nodes.
+
+ Start removing at c_node.
+ """
+ cdef xmlNode* c_next
+ c_node = _textNodeOrSkip(c_node)
+ while c_node is not NULL:
+ c_next = _textNodeOrSkip(c_node.next)
+ tree.xmlUnlinkNode(c_node)
+ tree.xmlFreeNode(c_node)
+ c_node = c_next
+
+cdef xmlNode* _createTextNode(xmlDoc* doc, value) except NULL:
+ cdef xmlNode* c_text_node
+ if isinstance(value, CDATA):
+ c_text_node = tree.xmlNewCDataBlock(
+ doc, _xcstr((value)._utf8_data),
+ python.PyBytes_GET_SIZE((value)._utf8_data))
+ else:
+ text = _utf8(value)
+ c_text_node = tree.xmlNewDocText(doc, _xcstr(text))
+ if not c_text_node:
+ raise MemoryError()
+ return c_text_node
+
+cdef int _setNodeText(xmlNode* c_node, value) except -1:
+ # remove all text nodes at the start first
+ _removeText(c_node.children)
+ if value is None:
+ return 0
+ # now add new text node with value at start
+ c_text_node = _createTextNode(c_node.doc, value)
+ if c_node.children is NULL:
+ tree.xmlAddChild(c_node, c_text_node)
+ else:
+ tree.xmlAddPrevSibling(c_node.children, c_text_node)
+ return 0
+
+cdef int _setTailText(xmlNode* c_node, value) except -1:
+ # remove all text nodes at the start first
+ _removeText(c_node.next)
+ if value is None:
+ return 0
+ # now append new text node with value
+ c_text_node = _createTextNode(c_node.doc, value)
+ tree.xmlAddNextSibling(c_node, c_text_node)
+ return 0
+
+cdef bytes _resolveQNameText(_Element element, value):
+ cdef xmlNs* c_ns
+ ns, tag = _getNsTag(value)
+ if ns is None:
+ return tag
+ else:
+ c_ns = element._doc._findOrBuildNodeNs(
+ element._c_node, _xcstr(ns), NULL, 0)
+ return python.PyBytes_FromFormat('%s:%s', c_ns.prefix, _cstr(tag))
+
+cdef inline bint _hasChild(xmlNode* c_node) noexcept:
+ return c_node is not NULL and _findChildForwards(c_node, 0) is not NULL
+
+cdef inline Py_ssize_t _countElements(xmlNode* c_node) noexcept:
+ "Counts the elements within the following siblings and the node itself."
+ cdef Py_ssize_t count
+ count = 0
+ while c_node is not NULL:
+ if _isElement(c_node):
+ count += 1
+ c_node = c_node.next
+ return count
+
+cdef int _findChildSlice(
+ slice sliceobject, xmlNode* c_parent,
+ xmlNode** c_start_node, Py_ssize_t* c_step, Py_ssize_t* c_length) except -1:
+ """Resolve a children slice.
+
+ Returns the start node, step size and the slice length in the
+ pointer arguments.
+ """
+ cdef Py_ssize_t start = 0, stop = 0, childcount
+ childcount = _countElements(c_parent.children)
+ if childcount == 0:
+ c_start_node[0] = NULL
+ c_length[0] = 0
+ if sliceobject.step is None:
+ c_step[0] = 1
+ else:
+ python._PyEval_SliceIndex(sliceobject.step, c_step)
+ return 0
+ python.PySlice_GetIndicesEx(
+ sliceobject, childcount, &start, &stop, c_step, c_length)
+ if start > childcount // 2:
+ c_start_node[0] = _findChildBackwards(c_parent, childcount - start - 1)
+ else:
+ c_start_node[0] = _findChild(c_parent, start)
+ return 0
+
+cdef bint _isFullSlice(slice sliceobject) except -1:
+ """Conservative guess if this slice is a full slice as in ``s[:]``.
+ """
+ cdef Py_ssize_t step = 0
+ if sliceobject is None:
+ return 0
+ if sliceobject.start is None and \
+ sliceobject.stop is None:
+ if sliceobject.step is None:
+ return 1
+ python._PyEval_SliceIndex(sliceobject.step, &step)
+ if step == 1:
+ return 1
+ return 0
+ return 0
+
+cdef _collectChildren(_Element element):
+ cdef xmlNode* c_node
+ cdef list result = []
+ c_node = element._c_node.children
+ if c_node is not NULL:
+ if not _isElement(c_node):
+ c_node = _nextElement(c_node)
+ while c_node is not NULL:
+ result.append(_elementFactory(element._doc, c_node))
+ c_node = _nextElement(c_node)
+ return result
+
+cdef inline xmlNode* _findChild(xmlNode* c_node, Py_ssize_t index) noexcept:
+ if index < 0:
+ return _findChildBackwards(c_node, -index - 1)
+ else:
+ return _findChildForwards(c_node, index)
+
+cdef inline xmlNode* _findChildForwards(xmlNode* c_node, Py_ssize_t index) noexcept:
+ """Return child element of c_node with index, or return NULL if not found.
+ """
+ cdef xmlNode* c_child
+ cdef Py_ssize_t c
+ c_child = c_node.children
+ c = 0
+ while c_child is not NULL:
+ if _isElement(c_child):
+ if c == index:
+ return c_child
+ c += 1
+ c_child = c_child.next
+ return NULL
+
+cdef inline xmlNode* _findChildBackwards(xmlNode* c_node, Py_ssize_t index) noexcept:
+ """Return child element of c_node with index, or return NULL if not found.
+ Search from the end.
+ """
+ cdef xmlNode* c_child
+ cdef Py_ssize_t c
+ c_child = c_node.last
+ c = 0
+ while c_child is not NULL:
+ if _isElement(c_child):
+ if c == index:
+ return c_child
+ c += 1
+ c_child = c_child.prev
+ return NULL
+
+cdef inline xmlNode* _textNodeOrSkip(xmlNode* c_node) noexcept nogil:
+ """Return the node if it's a text node. Skip over ignorable nodes in a
+ series of text nodes. Return NULL if a non-ignorable node is found.
+
+ This is used to skip over XInclude nodes when collecting adjacent text
+ nodes.
+ """
+ while c_node is not NULL:
+ if c_node.type == tree.XML_TEXT_NODE or \
+ c_node.type == tree.XML_CDATA_SECTION_NODE:
+ return c_node
+ elif c_node.type == tree.XML_XINCLUDE_START or \
+ c_node.type == tree.XML_XINCLUDE_END:
+ c_node = c_node.next
+ else:
+ return NULL
+ return NULL
+
+cdef inline xmlNode* _nextElement(xmlNode* c_node) noexcept:
+ """Given a node, find the next sibling that is an element.
+ """
+ if c_node is NULL:
+ return NULL
+ c_node = c_node.next
+ while c_node is not NULL:
+ if _isElement(c_node):
+ return c_node
+ c_node = c_node.next
+ return NULL
+
+cdef inline xmlNode* _previousElement(xmlNode* c_node) noexcept:
+ """Given a node, find the next sibling that is an element.
+ """
+ if c_node is NULL:
+ return NULL
+ c_node = c_node.prev
+ while c_node is not NULL:
+ if _isElement(c_node):
+ return c_node
+ c_node = c_node.prev
+ return NULL
+
+cdef inline xmlNode* _parentElement(xmlNode* c_node) noexcept:
+ "Given a node, find the parent element."
+ if c_node is NULL or not _isElement(c_node):
+ return NULL
+ c_node = c_node.parent
+ if c_node is NULL or not _isElement(c_node):
+ return NULL
+ return c_node
+
+cdef inline bint _tagMatches(xmlNode* c_node, const_xmlChar* c_href, const_xmlChar* c_name) noexcept:
+ """Tests if the node matches namespace URI and tag name.
+
+ A node matches if it matches both c_href and c_name.
+
+ A node matches c_href if any of the following is true:
+ * c_href is NULL
+ * its namespace is NULL and c_href is the empty string
+ * its namespace string equals the c_href string
+
+ A node matches c_name if any of the following is true:
+ * c_name is NULL
+ * its name string equals the c_name string
+ """
+ if c_node is NULL:
+ return 0
+ if c_node.type != tree.XML_ELEMENT_NODE:
+ # not an element, only succeed if we match everything
+ return c_name is NULL and c_href is NULL
+ if c_name is NULL:
+ if c_href is NULL:
+ # always match
+ return 1
+ else:
+ c_node_href = _getNs(c_node)
+ if c_node_href is NULL:
+ return c_href[0] == c'\0'
+ else:
+ return tree.xmlStrcmp(c_node_href, c_href) == 0
+ elif c_href is NULL:
+ if _getNs(c_node) is not NULL:
+ return 0
+ return c_node.name == c_name or tree.xmlStrcmp(c_node.name, c_name) == 0
+ elif c_node.name == c_name or tree.xmlStrcmp(c_node.name, c_name) == 0:
+ c_node_href = _getNs(c_node)
+ if c_node_href is NULL:
+ return c_href[0] == c'\0'
+ else:
+ return tree.xmlStrcmp(c_node_href, c_href) == 0
+ else:
+ return 0
+
+cdef inline bint _tagMatchesExactly(xmlNode* c_node, qname* c_qname) noexcept:
+ """Tests if the node matches namespace URI and tag name.
+
+ This differs from _tagMatches() in that it does not consider a
+ NULL value in qname.href a wildcard, and that it expects the c_name
+ to be taken from the doc dict, i.e. it only compares the names by
+ address.
+
+ A node matches if it matches both href and c_name of the qname.
+
+ A node matches c_href if any of the following is true:
+ * its namespace is NULL and c_href is the empty string
+ * its namespace string equals the c_href string
+
+ A node matches c_name if any of the following is true:
+ * c_name is NULL
+ * its name string points to the same address (!) as c_name
+ """
+ return _nsTagMatchesExactly(_getNs(c_node), c_node.name, c_qname)
+
+cdef inline bint _nsTagMatchesExactly(const_xmlChar* c_node_href,
+ const_xmlChar* c_node_name,
+ qname* c_qname) noexcept:
+ """Tests if name and namespace URI match those of c_qname.
+
+ This differs from _tagMatches() in that it does not consider a
+ NULL value in qname.href a wildcard, and that it expects the c_name
+ to be taken from the doc dict, i.e. it only compares the names by
+ address.
+
+ A node matches if it matches both href and c_name of the qname.
+
+ A node matches c_href if any of the following is true:
+ * its namespace is NULL and c_href is the empty string
+ * its namespace string equals the c_href string
+
+ A node matches c_name if any of the following is true:
+ * c_name is NULL
+ * its name string points to the same address (!) as c_name
+ """
+ cdef char* c_href
+ if c_qname.c_name is not NULL and c_qname.c_name is not c_node_name:
+ return 0
+ if c_qname.href is NULL:
+ return 1
+ c_href = python.__cstr(c_qname.href)
+ if c_href[0] == b'\0':
+ return c_node_href is NULL or c_node_href[0] == b'\0'
+ elif c_node_href is NULL:
+ return 0
+ else:
+ return tree.xmlStrcmp(c_href, c_node_href) == 0
+
+cdef Py_ssize_t _mapTagsToQnameMatchArray(xmlDoc* c_doc, list ns_tags,
+ qname* c_ns_tags, bint force_into_dict) except -1:
+ """Map a sequence of (name, namespace) pairs to a qname array for efficient
+ matching with _tagMatchesExactly() above.
+
+ Note that each qname struct in the array owns its href byte string object
+ if it is not NULL.
+ """
+ cdef Py_ssize_t count = 0, i
+ cdef bytes ns, tag
+ for ns, tag in ns_tags:
+ if tag is None:
+ c_tag = NULL
+ elif force_into_dict:
+ c_tag = tree.xmlDictLookup(c_doc.dict, _xcstr(tag), len(tag))
+ if c_tag is NULL:
+ # clean up before raising the error
+ for i in xrange(count):
+ cpython.ref.Py_XDECREF(c_ns_tags[i].href)
+ raise MemoryError()
+ else:
+ c_tag = tree.xmlDictExists(c_doc.dict, _xcstr(tag), len(tag))
+ if c_tag is NULL:
+ # not in the dict => not in the document
+ continue
+ c_ns_tags[count].c_name = c_tag
+ if ns is None:
+ c_ns_tags[count].href = NULL
+ else:
+ cpython.ref.Py_INCREF(ns) # keep an owned reference!
+ c_ns_tags[count].href = ns
+ count += 1
+ return count
+
+cdef int _removeNode(_Document doc, xmlNode* c_node) except -1:
+ """Unlink and free a node and subnodes if possible. Otherwise, make sure
+ it's self-contained.
+ """
+ cdef xmlNode* c_next
+ c_next = c_node.next
+ tree.xmlUnlinkNode(c_node)
+ _moveTail(c_next, c_node)
+ if not attemptDeallocation(c_node):
+ # make namespaces absolute
+ moveNodeToDocument(doc, c_node.doc, c_node)
+ return 0
+
+cdef int _removeSiblings(xmlNode* c_element, tree.xmlElementType node_type, bint with_tail) except -1:
+ cdef xmlNode* c_node
+ cdef xmlNode* c_next
+ c_node = c_element.next
+ while c_node is not NULL:
+ c_next = _nextElement(c_node)
+ if c_node.type == node_type:
+ if with_tail:
+ _removeText(c_node.next)
+ tree.xmlUnlinkNode(c_node)
+ attemptDeallocation(c_node)
+ c_node = c_next
+ c_node = c_element.prev
+ while c_node is not NULL:
+ c_next = _previousElement(c_node)
+ if c_node.type == node_type:
+ if with_tail:
+ _removeText(c_node.next)
+ tree.xmlUnlinkNode(c_node)
+ attemptDeallocation(c_node)
+ c_node = c_next
+ return 0
+
+cdef void _moveTail(xmlNode* c_tail, xmlNode* c_target) noexcept:
+ cdef xmlNode* c_next
+ # tail support: look for any text nodes trailing this node and
+ # move them too
+ c_tail = _textNodeOrSkip(c_tail)
+ while c_tail is not NULL:
+ c_next = _textNodeOrSkip(c_tail.next)
+ c_target = tree.xmlAddNextSibling(c_target, c_tail)
+ c_tail = c_next
+
+cdef int _copyTail(xmlNode* c_tail, xmlNode* c_target) except -1:
+ cdef xmlNode* c_new_tail
+ # tail copying support: look for any text nodes trailing this node and
+ # copy it to the target node
+ c_tail = _textNodeOrSkip(c_tail)
+ while c_tail is not NULL:
+ if c_target.doc is not c_tail.doc:
+ c_new_tail = tree.xmlDocCopyNode(c_tail, c_target.doc, 0)
+ else:
+ c_new_tail = tree.xmlCopyNode(c_tail, 0)
+ if c_new_tail is NULL:
+ raise MemoryError()
+ c_target = tree.xmlAddNextSibling(c_target, c_new_tail)
+ c_tail = _textNodeOrSkip(c_tail.next)
+ return 0
+
+cdef int _copyNonElementSiblings(xmlNode* c_node, xmlNode* c_target) except -1:
+ cdef xmlNode* c_copy
+ cdef xmlNode* c_sibling = c_node
+ while c_sibling.prev != NULL and \
+ (c_sibling.prev.type == tree.XML_PI_NODE or
+ c_sibling.prev.type == tree.XML_COMMENT_NODE or
+ c_sibling.prev.type == tree.XML_DTD_NODE):
+ c_sibling = c_sibling.prev
+ while c_sibling != c_node:
+ if c_sibling.type == tree.XML_DTD_NODE:
+ c_copy = _copyDtd(c_sibling)
+ if c_sibling == c_node.doc.intSubset:
+ c_target.doc.intSubset = c_copy
+ else: # c_sibling == c_node.doc.extSubset
+ c_target.doc.extSubset = c_copy
+ else:
+ c_copy = tree.xmlDocCopyNode(c_sibling, c_target.doc, 1)
+ if c_copy is NULL:
+ raise MemoryError()
+ tree.xmlAddPrevSibling(c_target, c_copy)
+ c_sibling = c_sibling.next
+ while c_sibling.next != NULL and \
+ (c_sibling.next.type == tree.XML_PI_NODE or
+ c_sibling.next.type == tree.XML_COMMENT_NODE):
+ c_sibling = c_sibling.next
+ c_copy = tree.xmlDocCopyNode(c_sibling, c_target.doc, 1)
+ if c_copy is NULL:
+ raise MemoryError()
+ tree.xmlAddNextSibling(c_target, c_copy)
+
+cdef int _deleteSlice(_Document doc, xmlNode* c_node,
+ Py_ssize_t count, Py_ssize_t step) except -1:
+ """Delete slice, ``count`` items starting with ``c_node`` with a step
+ width of ``step``.
+ """
+ cdef xmlNode* c_next
+ cdef Py_ssize_t c, i
+ cdef _node_to_node_function next_element
+ if c_node is NULL:
+ return 0
+ if step > 0:
+ next_element = _nextElement
+ else:
+ step = -step
+ next_element = _previousElement
+ # now start deleting nodes
+ c = 0
+ c_next = c_node
+ while c_node is not NULL and c < count:
+ for i in range(step):
+ c_next = next_element(c_next)
+ if c_next is NULL:
+ break
+ _removeNode(doc, c_node)
+ c += 1
+ c_node = c_next
+ return 0
+
+cdef int _replaceSlice(_Element parent, xmlNode* c_node,
+ Py_ssize_t slicelength, Py_ssize_t step,
+ bint left_to_right, elements) except -1:
+ """Replace the slice of ``count`` elements starting at ``c_node`` with
+ positive step width ``step`` by the Elements in ``elements``. The
+ direction is given by the boolean argument ``left_to_right``.
+
+ ``c_node`` may be NULL to indicate the end of the children list.
+ """
+ cdef xmlNode* c_orig_neighbour
+ cdef xmlNode* c_next
+ cdef xmlDoc* c_source_doc
+ cdef _Element element
+ cdef Py_ssize_t seqlength, i, c
+ cdef _node_to_node_function next_element
+ assert step > 0
+ if left_to_right:
+ next_element = _nextElement
+ else:
+ next_element = _previousElement
+
+ if not isinstance(elements, (list, tuple)):
+ elements = list(elements)
+
+ if step != 1 or not left_to_right:
+ # *replacing* children stepwise with list => check size!
+ seqlength = len(elements)
+ if seqlength != slicelength:
+ raise ValueError, f"attempt to assign sequence of size {seqlength} " \
+ f"to extended slice of size {slicelength}"
+
+ if c_node is NULL:
+ # no children yet => add all elements straight away
+ if left_to_right:
+ for element in elements:
+ assert element is not None, "Node must not be None"
+ _appendChild(parent, element)
+ else:
+ for element in elements:
+ assert element is not None, "Node must not be None"
+ _prependChild(parent, element)
+ return 0
+
+ # remove the elements first as some might be re-added
+ if left_to_right:
+ # L->R, remember left neighbour
+ c_orig_neighbour = _previousElement(c_node)
+ else:
+ # R->L, remember right neighbour
+ c_orig_neighbour = _nextElement(c_node)
+
+ # We remove the original slice elements one by one. Since we hold
+ # a Python reference to all elements that we will insert, it is
+ # safe to let _removeNode() try (and fail) to free them even if
+ # the element itself or one of its descendents will be reinserted.
+ c = 0
+ c_next = c_node
+ while c_node is not NULL and c < slicelength:
+ for i in range(step):
+ c_next = next_element(c_next)
+ if c_next is NULL:
+ break
+ _removeNode(parent._doc, c_node)
+ c += 1
+ c_node = c_next
+
+ # make sure each element is inserted only once
+ elements = iter(elements)
+
+ # find the first node right of the new insertion point
+ if left_to_right:
+ if c_orig_neighbour is not NULL:
+ c_node = next_element(c_orig_neighbour)
+ else:
+ # before the first element
+ c_node = _findChildForwards(parent._c_node, 0)
+ elif c_orig_neighbour is NULL:
+ # at the end, but reversed stepping
+ # append one element and go to the next insertion point
+ for element in elements:
+ assert element is not None, "Node must not be None"
+ _appendChild(parent, element)
+ c_node = element._c_node
+ if slicelength > 0:
+ slicelength -= 1
+ for i in range(1, step):
+ c_node = next_element(c_node)
+ if c_node is NULL:
+ break
+ break
+ else:
+ c_node = c_orig_neighbour
+
+ if left_to_right:
+ # adjust step size after removing slice as we are not stepping
+ # over the newly inserted elements
+ step -= 1
+
+ # now insert elements where we removed them
+ if c_node is not NULL:
+ for element in elements:
+ assert element is not None, "Node must not be None"
+ _assertValidNode(element)
+ # move element and tail over
+ c_source_doc = element._c_node.doc
+ c_next = element._c_node.next
+ tree.xmlAddPrevSibling(c_node, element._c_node)
+ _moveTail(c_next, element._c_node)
+
+ # integrate element into new document
+ moveNodeToDocument(parent._doc, c_source_doc, element._c_node)
+
+ # stop at the end of the slice
+ if slicelength > 0:
+ slicelength -= 1
+ for i in range(step):
+ c_node = next_element(c_node)
+ if c_node is NULL:
+ break
+ if c_node is NULL:
+ break
+ else:
+ # everything inserted
+ return 0
+
+ # append the remaining elements at the respective end
+ if left_to_right:
+ for element in elements:
+ assert element is not None, "Node must not be None"
+ _assertValidNode(element)
+ _appendChild(parent, element)
+ else:
+ for element in elements:
+ assert element is not None, "Node must not be None"
+ _assertValidNode(element)
+ _prependChild(parent, element)
+
+ return 0
+
+
+cdef int _linkChild(xmlNode* c_parent, xmlNode* c_node) except -1:
+ """Adaptation of 'xmlAddChild()' that deep-fix the document links iteratively.
+ """
+ assert _isElement(c_node)
+ c_node.parent = c_parent
+ if c_parent.children is NULL:
+ c_parent.children = c_parent.last = c_node
+ else:
+ c_node.prev = c_parent.last
+ c_parent.last.next = c_node
+ c_parent.last = c_node
+
+ _setTreeDoc(c_node, c_parent.doc)
+ return 0
+
+
+cdef int _appendChild(_Element parent, _Element child) except -1:
+ """Append a new child to a parent element.
+ """
+ c_node = child._c_node
+ c_source_doc = c_node.doc
+ # prevent cycles
+ if _isAncestorOrSame(c_node, parent._c_node):
+ raise ValueError("cannot append parent to itself")
+ # store possible text node
+ c_next = c_node.next
+ # move node itself
+ tree.xmlUnlinkNode(c_node)
+ # do not call xmlAddChild() here since it would deep-traverse the tree
+ _linkChild(parent._c_node, c_node)
+ _moveTail(c_next, c_node)
+ # uh oh, elements may be pointing to different doc when
+ # parent element has moved; change them too..
+ moveNodeToDocument(parent._doc, c_source_doc, c_node)
+ return 0
+
+cdef int _prependChild(_Element parent, _Element child) except -1:
+ """Prepend a new child to a parent element.
+ """
+ c_node = child._c_node
+ c_source_doc = c_node.doc
+ # prevent cycles
+ if _isAncestorOrSame(c_node, parent._c_node):
+ raise ValueError("cannot append parent to itself")
+ # store possible text node
+ c_next = c_node.next
+ # move node itself
+ c_child = _findChildForwards(parent._c_node, 0)
+ if c_child is NULL:
+ tree.xmlUnlinkNode(c_node)
+ # do not call xmlAddChild() here since it would deep-traverse the tree
+ _linkChild(parent._c_node, c_node)
+ else:
+ tree.xmlAddPrevSibling(c_child, c_node)
+ _moveTail(c_next, c_node)
+ # uh oh, elements may be pointing to different doc when
+ # parent element has moved; change them too..
+ moveNodeToDocument(parent._doc, c_source_doc, c_node)
+ return 0
+
+cdef int _appendSibling(_Element element, _Element sibling) except -1:
+ """Add a new sibling behind an element.
+ """
+ return _addSibling(element, sibling, as_next=True)
+
+cdef int _prependSibling(_Element element, _Element sibling) except -1:
+ """Add a new sibling before an element.
+ """
+ return _addSibling(element, sibling, as_next=False)
+
+cdef int _addSibling(_Element element, _Element sibling, bint as_next) except -1:
+ c_node = sibling._c_node
+ c_source_doc = c_node.doc
+ # prevent cycles
+ if _isAncestorOrSame(c_node, element._c_node):
+ if element._c_node is c_node:
+ return 0 # nothing to do
+ raise ValueError("cannot add ancestor as sibling, please break cycle first")
+ # store possible text node
+ c_next = c_node.next
+ # move node itself
+ if as_next:
+ # must insert after any tail text
+ c_next_node = _nextElement(element._c_node)
+ if c_next_node is NULL:
+ c_next_node = element._c_node
+ while c_next_node.next:
+ c_next_node = c_next_node.next
+ tree.xmlAddNextSibling(c_next_node, c_node)
+ else:
+ tree.xmlAddPrevSibling(c_next_node, c_node)
+ else:
+ tree.xmlAddPrevSibling(element._c_node, c_node)
+ _moveTail(c_next, c_node)
+ # uh oh, elements may be pointing to different doc when
+ # parent element has moved; change them too..
+ moveNodeToDocument(element._doc, c_source_doc, c_node)
+ return 0
+
+cdef inline bint isutf8(const_xmlChar* s) noexcept:
+ cdef xmlChar c = s[0]
+ while c != c'\0':
+ if c & 0x80:
+ return True
+ s += 1
+ c = s[0]
+ return False
+
+cdef bint isutf8l(const_xmlChar* s, size_t length) noexcept:
+ """
+ Search for non-ASCII characters in the string, knowing its length in advance.
+ """
+ cdef unsigned int i
+ cdef unsigned long non_ascii_mask
+ cdef const unsigned long *lptr = s
+
+ cdef const unsigned long *end = lptr + length // sizeof(unsigned long)
+ if length >= sizeof(non_ascii_mask):
+ # Build constant 0x80808080... mask (and let the C compiler fold it).
+ non_ascii_mask = 0
+ for i in range(sizeof(non_ascii_mask) // 2):
+ non_ascii_mask = (non_ascii_mask << 16) | 0x8080
+
+ # Advance to long-aligned character before we start reading longs.
+ while (s) % sizeof(unsigned long) and s < end:
+ if s[0] & 0x80:
+ return True
+ s += 1
+
+ # Read one long at a time
+ lptr = s
+ while lptr < end:
+ if lptr[0] & non_ascii_mask:
+ return True
+ lptr += 1
+ s = lptr
+
+ while s < (end + length % sizeof(unsigned long)):
+ if s[0] & 0x80:
+ return True
+ s += 1
+
+ return False
+
+cdef int _is_valid_xml_ascii(bytes pystring) except -1:
+ """Check if a string is XML ascii content."""
+ cdef signed char ch
+ # When ch is a *signed* char, non-ascii characters are negative integers
+ # and xmlIsChar_ch does not accept them.
+ for ch in pystring:
+ if not tree.xmlIsChar_ch(ch):
+ return 0
+ return 1
+
+cdef bint _is_valid_xml_utf8(bytes pystring) except -1:
+ """Check if a string is like valid UTF-8 XML content."""
+ cdef const_xmlChar* s = _xcstr(pystring)
+ cdef const_xmlChar* c_end = s + len(pystring)
+ cdef unsigned long next3 = 0
+ if s < c_end - 2:
+ next3 = (s[0] << 8) | (s[1])
+
+ while s < c_end - 2:
+ next3 = 0x00ffffff & ((next3 << 8) | s[2])
+ if s[0] & 0x80:
+ # 0xefbfbe and 0xefbfbf are utf-8 encodings of
+ # forbidden characters \ufffe and \uffff
+ if next3 == 0x00efbfbe or next3 == 0x00efbfbf:
+ return 0
+ # 0xeda080 and 0xedbfbf are utf-8 encodings of
+ # \ud800 and \udfff. Anything between them (inclusive)
+ # is forbidden, because they are surrogate blocks in utf-16.
+ if 0x00eda080 <= next3 <= 0x00edbfbf:
+ return 0
+ elif not tree.xmlIsChar_ch(s[0]):
+ return 0 # invalid ascii char
+ s += 1
+
+ while s < c_end:
+ if not s[0] & 0x80 and not tree.xmlIsChar_ch(s[0]):
+ return 0 # invalid ascii char
+ s += 1
+
+ return 1
+
+cdef inline unicode funicodeOrNone(const_xmlChar* s):
+ return funicode(s) if s is not NULL else None
+
+cdef inline unicode funicodeOrEmpty(const_xmlChar* s):
+ return funicode(s) if s is not NULL else ''
+
+cdef unicode funicode(const_xmlChar* s):
+ return s.decode('UTF-8')
+
+cdef bytes _utf8(object s):
+ """Test if a string is valid user input and encode it to UTF-8.
+ Reject all bytes/unicode input that contains non-XML characters.
+ Reject all bytes input that contains non-ASCII characters.
+ """
+ cdef int valid
+ cdef bytes utf8_string
+ if isinstance(s, unicode):
+ utf8_string = (s).encode('utf8')
+ valid = _is_valid_xml_utf8(utf8_string)
+ elif isinstance(s, (bytes, bytearray)):
+ utf8_string = s if type(s) is bytes else bytes(s)
+ valid = _is_valid_xml_ascii(utf8_string)
+ else:
+ raise TypeError("Argument must be bytes or unicode, got '%.200s'" % type(s).__name__)
+ if not valid:
+ raise ValueError(
+ "All strings must be XML compatible: Unicode or ASCII, no NULL bytes or control characters")
+ return utf8_string
+
+
+cdef bytes _utf8orNone(object s):
+ return _utf8(s) if s is not None else None
+
+
+cdef enum:
+ NO_FILE_PATH = 0
+ ABS_UNIX_FILE_PATH = 1
+ ABS_WIN_FILE_PATH = 2
+ REL_FILE_PATH = 3
+
+
+cdef bint _isFilePath(const_xmlChar* c_path) noexcept:
+ "simple heuristic to see if a path is a filename"
+ cdef xmlChar c
+ # test if it looks like an absolute Unix path or a Windows network path
+ if c_path[0] == c'/':
+ return ABS_UNIX_FILE_PATH
+
+ # test if it looks like an absolute Windows path or URL
+ if c'a' <= c_path[0] <= c'z' or c'A' <= c_path[0] <= c'Z':
+ c_path += 1
+ if c_path[0] == c':' and c_path[1] in b'\0\\':
+ return ABS_WIN_FILE_PATH # C: or C:\...
+
+ # test if it looks like a URL with scheme://
+ while c'a' <= c_path[0] <= c'z' or c'A' <= c_path[0] <= c'Z':
+ c_path += 1
+ if c_path[0] == c':' and c_path[1] == c'/' and c_path[2] == c'/':
+ return NO_FILE_PATH
+
+ # assume it's a relative path
+ return REL_FILE_PATH
+
+
+cdef object _getFSPathOrObject(object obj):
+ """
+ Get the __fspath__ attribute of an object if it exists.
+ Otherwise, the original object is returned.
+ """
+ if _isString(obj):
+ return obj
+ try:
+ return python.PyOS_FSPath(obj)
+ except TypeError:
+ return obj
+
+
+cdef object _encodeFilename(object filename):
+ """Make sure a filename is 8-bit encoded (or None).
+ """
+ if filename is None:
+ return None
+ elif isinstance(filename, bytes):
+ return filename
+ elif isinstance(filename, unicode):
+ filename8 = (filename).encode('utf8')
+ if _isFilePath(filename8):
+ try:
+ return python.PyUnicode_AsEncodedString(
+ filename, _C_FILENAME_ENCODING, NULL)
+ except UnicodeEncodeError:
+ pass
+ return filename8
+ else:
+ raise TypeError("Argument must be string or unicode.")
+
+cdef object _decodeFilename(const_xmlChar* c_path):
+ """Make the filename a unicode string if we are in Py3.
+ """
+ return _decodeFilenameWithLength(c_path, tree.xmlStrlen(c_path))
+
+cdef object _decodeFilenameWithLength(const_xmlChar* c_path, size_t c_len):
+ """Make the filename a unicode string if we are in Py3.
+ """
+ if _isFilePath(c_path):
+ try:
+ return python.PyUnicode_Decode(
+ c_path, c_len, _C_FILENAME_ENCODING, NULL)
+ except UnicodeDecodeError:
+ pass
+ try:
+ return (c_path)[:c_len].decode('UTF-8')
+ except UnicodeDecodeError:
+ # this is a stupid fallback, but it might still work...
+ return (c_path)[:c_len].decode('latin-1', 'replace')
+
+cdef object _encodeFilenameUTF8(object filename):
+ """Recode filename as UTF-8. Tries ASCII, local filesystem encoding and
+ UTF-8 as source encoding.
+ """
+ cdef char* c_filename
+ if filename is None:
+ return None
+ elif isinstance(filename, bytes):
+ if not isutf8l(filename, len(filename)):
+ # plain ASCII!
+ return filename
+ c_filename = _cstr(filename)
+ try:
+ # try to decode with default encoding
+ filename = python.PyUnicode_Decode(
+ c_filename, len(filename),
+ _C_FILENAME_ENCODING, NULL)
+ except UnicodeDecodeError as decode_exc:
+ try:
+ # try if it's proper UTF-8
+ (filename).decode('utf8')
+ return filename
+ except UnicodeDecodeError:
+ raise decode_exc # otherwise re-raise original exception
+ if isinstance(filename, unicode):
+ return (filename).encode('utf8')
+ else:
+ raise TypeError("Argument must be string or unicode.")
+
+cdef tuple _getNsTag(tag):
+ """Given a tag, find namespace URI and tag name.
+ Return None for NS uri if no namespace URI provided.
+ """
+ return __getNsTag(tag, 0)
+
+cdef tuple _getNsTagWithEmptyNs(tag):
+ """Given a tag, find namespace URI and tag name. Return None for NS uri
+ if no namespace URI provided, or the empty string if namespace
+ part is '{}'.
+ """
+ return __getNsTag(tag, 1)
+
+cdef tuple __getNsTag(tag, bint empty_ns):
+ cdef char* c_tag
+ cdef char* c_ns_end
+ cdef Py_ssize_t taglen
+ cdef Py_ssize_t nslen
+ cdef bytes ns = None
+ # _isString() is much faster than isinstance()
+ if not _isString(tag) and isinstance(tag, QName):
+ tag = (tag).text
+ tag = _utf8(tag)
+ c_tag = _cstr(tag)
+ if c_tag[0] == c'{':
+ c_tag += 1
+ c_ns_end = cstring_h.strchr(c_tag, c'}')
+ if c_ns_end is NULL:
+ raise ValueError, "Invalid tag name"
+ nslen = c_ns_end - c_tag
+ taglen = python.PyBytes_GET_SIZE(tag) - nslen - 2
+ if taglen == 0:
+ raise ValueError, "Empty tag name"
+ if nslen > 0:
+ ns = c_tag[:nslen]
+ elif empty_ns:
+ ns = b''
+ tag = c_ns_end[1:taglen+1]
+ elif python.PyBytes_GET_SIZE(tag) == 0:
+ raise ValueError, "Empty tag name"
+ return ns, tag
+
+cdef inline int _pyXmlNameIsValid(name_utf8):
+ return _xmlNameIsValid(_xcstr(name_utf8)) and b':' not in name_utf8
+
+cdef inline int _pyHtmlNameIsValid(name_utf8):
+ return _htmlNameIsValid(_xcstr(name_utf8))
+
+cdef inline int _xmlNameIsValid(const_xmlChar* c_name) noexcept:
+ return tree.xmlValidateNameValue(c_name)
+
+cdef int _htmlNameIsValid(const_xmlChar* c_name) noexcept:
+ if c_name is NULL or c_name[0] == c'\0':
+ return 0
+ while c_name[0] != c'\0':
+ if c_name[0] in b'&<>/"\'\t\n\x0B\x0C\r ':
+ return 0
+ c_name += 1
+ return 1
+
+cdef bint _characterReferenceIsValid(const_xmlChar* c_name) noexcept:
+ cdef bint is_hex
+ if c_name[0] == c'x':
+ c_name += 1
+ is_hex = 1
+ else:
+ is_hex = 0
+ if c_name[0] == c'\0':
+ return 0
+ while c_name[0] != c'\0':
+ if c_name[0] < c'0' or c_name[0] > c'9':
+ if not is_hex:
+ return 0
+ if not (c'a' <= c_name[0] <= c'f'):
+ if not (c'A' <= c_name[0] <= c'F'):
+ return 0
+ c_name += 1
+ return 1
+
+cdef int _tagValidOrRaise(tag_utf) except -1:
+ if not _pyXmlNameIsValid(tag_utf):
+ raise ValueError(f"Invalid tag name {(tag_utf).decode('utf8')!r}")
+ return 0
+
+cdef int _htmlTagValidOrRaise(tag_utf) except -1:
+ if not _pyHtmlNameIsValid(tag_utf):
+ raise ValueError(f"Invalid HTML tag name {(tag_utf).decode('utf8')!r}")
+ return 0
+
+cdef int _attributeValidOrRaise(name_utf) except -1:
+ if not _pyXmlNameIsValid(name_utf):
+ raise ValueError(f"Invalid attribute name {(name_utf).decode('utf8')!r}")
+ return 0
+
+cdef int _prefixValidOrRaise(tag_utf) except -1:
+ if not _pyXmlNameIsValid(tag_utf):
+ raise ValueError(f"Invalid namespace prefix {(tag_utf).decode('utf8')!r}")
+ return 0
+
+cdef int _uriValidOrRaise(uri_utf) except -1:
+ cdef uri.xmlURI* c_uri = uri.xmlParseURI(_cstr(uri_utf))
+ if c_uri is NULL:
+ raise ValueError(f"Invalid namespace URI {(uri_utf).decode('utf8')!r}")
+ uri.xmlFreeURI(c_uri)
+ return 0
+
+cdef inline unicode _namespacedName(xmlNode* c_node):
+ return _namespacedNameFromNsName(_getNs(c_node), c_node.name)
+
+
+cdef unicode _namespacedNameFromNsName(const_xmlChar* c_href, const_xmlChar* c_name):
+ name = funicode(c_name)
+ if c_href is NULL:
+ return name
+ href = funicode(c_href)
+ return f"{{{href}}}{name}"
+
+
+cdef _getFilenameForFile(source):
+ """Given a Python File or Gzip object, give filename back.
+
+ Returns None if not a file object.
+ """
+ # urllib2 provides a geturl() method
+ try:
+ return source.geturl()
+ except:
+ pass
+ # file instances have a name attribute
+ try:
+ filename = source.name
+ if _isString(filename):
+ return os_path_abspath(filename)
+ except:
+ pass
+ # gzip file instances have a filename attribute (before Py3k)
+ try:
+ filename = source.filename
+ if _isString(filename):
+ return os_path_abspath(filename)
+ except:
+ pass
+ # can't determine filename
+ return None
diff --git a/llava_video/lib/python3.10/site-packages/lxml/cssselect.py b/llava_video/lib/python3.10/site-packages/lxml/cssselect.py
new file mode 100644
index 0000000000000000000000000000000000000000..54cd75ac9bfecdec7ea81e91b0840c6edd401515
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/cssselect.py
@@ -0,0 +1,101 @@
+"""CSS Selectors based on XPath.
+
+This module supports selecting XML/HTML tags based on CSS selectors.
+See the `CSSSelector` class for details.
+
+This is a thin wrapper around cssselect 0.7 or later.
+"""
+
+
+from . import etree
+try:
+ import cssselect as external_cssselect
+except ImportError:
+ raise ImportError(
+ 'cssselect does not seem to be installed. '
+ 'See https://pypi.org/project/cssselect/')
+
+
+SelectorSyntaxError = external_cssselect.SelectorSyntaxError
+ExpressionError = external_cssselect.ExpressionError
+SelectorError = external_cssselect.SelectorError
+
+
+__all__ = ['SelectorSyntaxError', 'ExpressionError', 'SelectorError',
+ 'CSSSelector']
+
+
+class LxmlTranslator(external_cssselect.GenericTranslator):
+ """
+ A custom CSS selector to XPath translator with lxml-specific extensions.
+ """
+ def xpath_contains_function(self, xpath, function):
+ # Defined there, removed in later drafts:
+ # http://www.w3.org/TR/2001/CR-css3-selectors-20011113/#content-selectors
+ if function.argument_types() not in (['STRING'], ['IDENT']):
+ raise ExpressionError(
+ "Expected a single string or ident for :contains(), got %r"
+ % function.arguments)
+ value = function.arguments[0].value
+ return xpath.add_condition(
+ 'contains(__lxml_internal_css:lower-case(string(.)), %s)'
+ % self.xpath_literal(value.lower()))
+
+
+class LxmlHTMLTranslator(LxmlTranslator, external_cssselect.HTMLTranslator):
+ """
+ lxml extensions + HTML support.
+ """
+
+
+def _make_lower_case(context, s):
+ return s.lower()
+
+ns = etree.FunctionNamespace('http://codespeak.net/lxml/css/')
+ns.prefix = '__lxml_internal_css'
+ns['lower-case'] = _make_lower_case
+
+
+class CSSSelector(etree.XPath):
+ """A CSS selector.
+
+ Usage::
+
+ >>> from lxml import etree, cssselect
+ >>> select = cssselect.CSSSelector("a tag > child")
+
+ >>> root = etree.XML("TEXT '
+ ... 'blah '
+ ... ' ') % rdfns)
+ >>> [(el.tag, el.text) for el in select_ns(rdf)]
+ [('{http://www.w3.org/1999/02/22-rdf-syntax-ns#}Description', 'blah')]
+
+ """
+ def __init__(self, css, namespaces=None, translator='xml'):
+ if translator == 'xml':
+ translator = LxmlTranslator()
+ elif translator == 'html':
+ translator = LxmlHTMLTranslator()
+ elif translator == 'xhtml':
+ translator = LxmlHTMLTranslator(xhtml=True)
+ path = translator.css_to_xpath(css)
+ super().__init__(path, namespaces=namespaces)
+ self.css = css
+
+ def __repr__(self):
+ return '<%s %x for %r>' % (
+ self.__class__.__name__,
+ abs(id(self)),
+ self.css)
diff --git a/llava_video/lib/python3.10/site-packages/lxml/docloader.pxi b/llava_video/lib/python3.10/site-packages/lxml/docloader.pxi
new file mode 100644
index 0000000000000000000000000000000000000000..7b38f43838592445d2618440b178bd9c8557073c
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/docloader.pxi
@@ -0,0 +1,178 @@
+# Custom resolver API
+
+ctypedef enum _InputDocumentDataType:
+ PARSER_DATA_INVALID
+ PARSER_DATA_EMPTY
+ PARSER_DATA_STRING
+ PARSER_DATA_FILENAME
+ PARSER_DATA_FILE
+
+@cython.final
+@cython.internal
+cdef class _InputDocument:
+ cdef _InputDocumentDataType _type
+ cdef bytes _data_bytes
+ cdef object _filename
+ cdef object _file
+ cdef bint _close_file
+
+ def __cinit__(self):
+ self._type = PARSER_DATA_INVALID
+
+
+cdef class Resolver:
+ "This is the base class of all resolvers."
+ def resolve(self, system_url, public_id, context):
+ """resolve(self, system_url, public_id, context)
+
+ Override this method to resolve an external source by
+ ``system_url`` and ``public_id``. The third argument is an
+ opaque context object.
+
+ Return the result of one of the ``resolve_*()`` methods.
+ """
+ return None
+
+ def resolve_empty(self, context):
+ """resolve_empty(self, context)
+
+ Return an empty input document.
+
+ Pass context as parameter.
+ """
+ cdef _InputDocument doc_ref
+ doc_ref = _InputDocument()
+ doc_ref._type = PARSER_DATA_EMPTY
+ return doc_ref
+
+ def resolve_string(self, string, context, *, base_url=None):
+ """resolve_string(self, string, context, base_url=None)
+
+ Return a parsable string as input document.
+
+ Pass data string and context as parameters. You can pass the
+ source URL or filename through the ``base_url`` keyword
+ argument.
+ """
+ cdef _InputDocument doc_ref
+ if isinstance(string, unicode):
+ string = (string).encode('utf8')
+ elif not isinstance(string, bytes):
+ raise TypeError, "argument must be a byte string or unicode string"
+ doc_ref = _InputDocument()
+ doc_ref._type = PARSER_DATA_STRING
+ doc_ref._data_bytes = string
+ if base_url is not None:
+ doc_ref._filename = _encodeFilename(base_url)
+ return doc_ref
+
+ def resolve_filename(self, filename, context):
+ """resolve_filename(self, filename, context)
+
+ Return the name of a parsable file as input document.
+
+ Pass filename and context as parameters. You can also pass a
+ URL with an HTTP, FTP or file target.
+ """
+ cdef _InputDocument doc_ref
+ doc_ref = _InputDocument()
+ doc_ref._type = PARSER_DATA_FILENAME
+ doc_ref._filename = _encodeFilename(filename)
+ return doc_ref
+
+ def resolve_file(self, f, context, *, base_url=None, bint close=True):
+ """resolve_file(self, f, context, base_url=None, close=True)
+
+ Return an open file-like object as input document.
+
+ Pass open file and context as parameters. You can pass the
+ base URL or filename of the file through the ``base_url``
+ keyword argument. If the ``close`` flag is True (the
+ default), the file will be closed after reading.
+
+ Note that using ``.resolve_filename()`` is more efficient,
+ especially in threaded environments.
+ """
+ cdef _InputDocument doc_ref
+ try:
+ f.read
+ except AttributeError:
+ raise TypeError, "Argument is not a file-like object"
+ doc_ref = _InputDocument()
+ doc_ref._type = PARSER_DATA_FILE
+ if base_url is not None:
+ doc_ref._filename = _encodeFilename(base_url)
+ else:
+ doc_ref._filename = _getFilenameForFile(f)
+ doc_ref._close_file = close
+ doc_ref._file = f
+ return doc_ref
+
+@cython.final
+@cython.internal
+cdef class _ResolverRegistry:
+ cdef object _resolvers
+ cdef Resolver _default_resolver
+ def __cinit__(self, Resolver default_resolver=None):
+ self._resolvers = set()
+ self._default_resolver = default_resolver
+
+ def add(self, Resolver resolver not None):
+ """add(self, resolver)
+
+ Register a resolver.
+
+ For each requested entity, the 'resolve' method of the resolver will
+ be called and the result will be passed to the parser. If this method
+ returns None, the request will be delegated to other resolvers or the
+ default resolver. The resolvers will be tested in an arbitrary order
+ until the first match is found.
+ """
+ self._resolvers.add(resolver)
+
+ def remove(self, resolver):
+ "remove(self, resolver)"
+ self._resolvers.discard(resolver)
+
+ cdef _ResolverRegistry _copy(self):
+ cdef _ResolverRegistry registry
+ registry = _ResolverRegistry(self._default_resolver)
+ registry._resolvers = self._resolvers.copy()
+ return registry
+
+ def copy(self):
+ "copy(self)"
+ return self._copy()
+
+ def resolve(self, system_url, public_id, context):
+ "resolve(self, system_url, public_id, context)"
+ for resolver in self._resolvers:
+ result = resolver.resolve(system_url, public_id, context)
+ if result is not None:
+ return result
+ if self._default_resolver is None:
+ return None
+ return self._default_resolver.resolve(system_url, public_id, context)
+
+ def __repr__(self):
+ return repr(self._resolvers)
+
+
+@cython.internal
+cdef class _ResolverContext(_ExceptionContext):
+ cdef _ResolverRegistry _resolvers
+ cdef _TempStore _storage
+
+ cdef int clear(self) except -1:
+ _ExceptionContext.clear(self)
+ self._storage.clear()
+ return 0
+
+
+cdef _initResolverContext(_ResolverContext context,
+ _ResolverRegistry resolvers):
+ if resolvers is None:
+ context._resolvers = _ResolverRegistry()
+ else:
+ context._resolvers = resolvers
+ context._storage = _TempStore()
diff --git a/llava_video/lib/python3.10/site-packages/lxml/doctestcompare.py b/llava_video/lib/python3.10/site-packages/lxml/doctestcompare.py
new file mode 100644
index 0000000000000000000000000000000000000000..8099771de906a37ed007c779f152fe96f182060d
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/doctestcompare.py
@@ -0,0 +1,488 @@
+"""
+lxml-based doctest output comparison.
+
+Note: normally, you should just import the `lxml.usedoctest` and
+`lxml.html.usedoctest` modules from within a doctest, instead of this
+one::
+
+ >>> import lxml.usedoctest # for XML output
+
+ >>> import lxml.html.usedoctest # for HTML output
+
+To use this module directly, you must call ``lxmldoctest.install()``,
+which will cause doctest to use this in all subsequent calls.
+
+This changes the way output is checked and comparisons are made for
+XML or HTML-like content.
+
+XML or HTML content is noticed because the example starts with ``<``
+(it's HTML if it starts with ```` or include an ``any``
+attribute in the tag. An ``any`` tag matches any tag, while the
+attribute matches any and all attributes.
+
+When a match fails, the reformatted example and gotten text is
+displayed (indented), and a rough diff-like output is given. Anything
+marked with ``+`` is in the output but wasn't supposed to be, and
+similarly ``-`` means its in the example but wasn't in the output.
+
+You can disable parsing on one line with ``# doctest:+NOPARSE_MARKUP``
+"""
+
+from lxml import etree
+import sys
+import re
+import doctest
+try:
+ from html import escape as html_escape
+except ImportError:
+ from cgi import escape as html_escape
+
+__all__ = ['PARSE_HTML', 'PARSE_XML', 'NOPARSE_MARKUP', 'LXMLOutputChecker',
+ 'LHTMLOutputChecker', 'install', 'temp_install']
+
+PARSE_HTML = doctest.register_optionflag('PARSE_HTML')
+PARSE_XML = doctest.register_optionflag('PARSE_XML')
+NOPARSE_MARKUP = doctest.register_optionflag('NOPARSE_MARKUP')
+
+OutputChecker = doctest.OutputChecker
+
+def strip(v):
+ if v is None:
+ return None
+ else:
+ return v.strip()
+
+def norm_whitespace(v):
+ return _norm_whitespace_re.sub(' ', v)
+
+_html_parser = etree.HTMLParser(recover=False, remove_blank_text=True)
+
+def html_fromstring(html):
+ return etree.fromstring(html, _html_parser)
+
+# We use this to distinguish repr()s from elements:
+_repr_re = re.compile(r'^<[^>]+ (at|object) ')
+_norm_whitespace_re = re.compile(r'[ \t\n][ \t\n]+')
+
+class LXMLOutputChecker(OutputChecker):
+
+ empty_tags = (
+ 'param', 'img', 'area', 'br', 'basefont', 'input',
+ 'base', 'meta', 'link', 'col')
+
+ def get_default_parser(self):
+ return etree.XML
+
+ def check_output(self, want, got, optionflags):
+ alt_self = getattr(self, '_temp_override_self', None)
+ if alt_self is not None:
+ super_method = self._temp_call_super_check_output
+ self = alt_self
+ else:
+ super_method = OutputChecker.check_output
+ parser = self.get_parser(want, got, optionflags)
+ if not parser:
+ return super_method(
+ self, want, got, optionflags)
+ try:
+ want_doc = parser(want)
+ except etree.XMLSyntaxError:
+ return False
+ try:
+ got_doc = parser(got)
+ except etree.XMLSyntaxError:
+ return False
+ return self.compare_docs(want_doc, got_doc)
+
+ def get_parser(self, want, got, optionflags):
+ parser = None
+ if NOPARSE_MARKUP & optionflags:
+ return None
+ if PARSE_HTML & optionflags:
+ parser = html_fromstring
+ elif PARSE_XML & optionflags:
+ parser = etree.XML
+ elif (want.strip().lower().startswith('' % el.tag
+ return '<%s %s>' % (el.tag, ' '.join(attrs))
+
+ def format_end_tag(self, el):
+ if isinstance(el, etree.CommentBase):
+ # FIXME: probably PIs should be handled specially too?
+ return '-->'
+ return '' % el.tag
+
+ def collect_diff(self, want, got, html, indent):
+ parts = []
+ if not len(want) and not len(got):
+ parts.append(' '*indent)
+ parts.append(self.collect_diff_tag(want, got))
+ if not self.html_empty_tag(got, html):
+ parts.append(self.collect_diff_text(want.text, got.text))
+ parts.append(self.collect_diff_end_tag(want, got))
+ parts.append(self.collect_diff_text(want.tail, got.tail))
+ parts.append('\n')
+ return ''.join(parts)
+ parts.append(' '*indent)
+ parts.append(self.collect_diff_tag(want, got))
+ parts.append('\n')
+ if strip(want.text) or strip(got.text):
+ parts.append(' '*indent)
+ parts.append(self.collect_diff_text(want.text, got.text))
+ parts.append('\n')
+ want_children = list(want)
+ got_children = list(got)
+ while want_children or got_children:
+ if not want_children:
+ parts.append(self.format_doc(got_children.pop(0), html, indent+2, '+'))
+ continue
+ if not got_children:
+ parts.append(self.format_doc(want_children.pop(0), html, indent+2, '-'))
+ continue
+ parts.append(self.collect_diff(
+ want_children.pop(0), got_children.pop(0), html, indent+2))
+ parts.append(' '*indent)
+ parts.append(self.collect_diff_end_tag(want, got))
+ parts.append('\n')
+ if strip(want.tail) or strip(got.tail):
+ parts.append(' '*indent)
+ parts.append(self.collect_diff_text(want.tail, got.tail))
+ parts.append('\n')
+ return ''.join(parts)
+
+ def collect_diff_tag(self, want, got):
+ if not self.tag_compare(want.tag, got.tag):
+ tag = '%s (got: %s)' % (want.tag, got.tag)
+ else:
+ tag = got.tag
+ attrs = []
+ any = want.tag == 'any' or 'any' in want.attrib
+ for name, value in sorted(got.attrib.items()):
+ if name not in want.attrib and not any:
+ attrs.append('+%s="%s"' % (name, self.format_text(value, False)))
+ else:
+ if name in want.attrib:
+ text = self.collect_diff_text(want.attrib[name], value, False)
+ else:
+ text = self.format_text(value, False)
+ attrs.append('%s="%s"' % (name, text))
+ if not any:
+ for name, value in sorted(want.attrib.items()):
+ if name in got.attrib:
+ continue
+ attrs.append('-%s="%s"' % (name, self.format_text(value, False)))
+ if attrs:
+ tag = '<%s %s>' % (tag, ' '.join(attrs))
+ else:
+ tag = '<%s>' % tag
+ return tag
+
+ def collect_diff_end_tag(self, want, got):
+ if want.tag != got.tag:
+ tag = '%s (got: %s)' % (want.tag, got.tag)
+ else:
+ tag = got.tag
+ return '' % tag
+
+ def collect_diff_text(self, want, got, strip=True):
+ if self.text_compare(want, got, strip):
+ if not got:
+ return ''
+ return self.format_text(got, strip)
+ text = '%s (got: %s)' % (want, got)
+ return self.format_text(text, strip)
+
+class LHTMLOutputChecker(LXMLOutputChecker):
+ def get_default_parser(self):
+ return html_fromstring
+
+def install(html=False):
+ """
+ Install doctestcompare for all future doctests.
+
+ If html is true, then by default the HTML parser will be used;
+ otherwise the XML parser is used.
+ """
+ if html:
+ doctest.OutputChecker = LHTMLOutputChecker
+ else:
+ doctest.OutputChecker = LXMLOutputChecker
+
+def temp_install(html=False, del_module=None):
+ """
+ Use this *inside* a doctest to enable this checker for this
+ doctest only.
+
+ If html is true, then by default the HTML parser will be used;
+ otherwise the XML parser is used.
+ """
+ if html:
+ Checker = LHTMLOutputChecker
+ else:
+ Checker = LXMLOutputChecker
+ frame = _find_doctest_frame()
+ dt_self = frame.f_locals['self']
+ checker = Checker()
+ old_checker = dt_self._checker
+ dt_self._checker = checker
+ # The unfortunate thing is that there is a local variable 'check'
+ # in the function that runs the doctests, that is a bound method
+ # into the output checker. We have to update that. We can't
+ # modify the frame, so we have to modify the object in place. The
+ # only way to do this is to actually change the func_code
+ # attribute of the method. We change it, and then wait for
+ # __record_outcome to be run, which signals the end of the __run
+ # method, at which point we restore the previous check_output
+ # implementation.
+ check_func = frame.f_locals['check'].__func__
+ checker_check_func = checker.check_output.__func__
+ # Because we can't patch up func_globals, this is the only global
+ # in check_output that we care about:
+ doctest.etree = etree
+ _RestoreChecker(dt_self, old_checker, checker,
+ check_func, checker_check_func,
+ del_module)
+
+class _RestoreChecker:
+ def __init__(self, dt_self, old_checker, new_checker, check_func, clone_func,
+ del_module):
+ self.dt_self = dt_self
+ self.checker = old_checker
+ self.checker._temp_call_super_check_output = self.call_super
+ self.checker._temp_override_self = new_checker
+ self.check_func = check_func
+ self.clone_func = clone_func
+ self.del_module = del_module
+ self.install_clone()
+ self.install_dt_self()
+ def install_clone(self):
+ self.func_code = self.check_func.__code__
+ self.func_globals = self.check_func.__globals__
+ self.check_func.__code__ = self.clone_func.__code__
+ def uninstall_clone(self):
+ self.check_func.__code__ = self.func_code
+ def install_dt_self(self):
+ self.prev_func = self.dt_self._DocTestRunner__record_outcome
+ self.dt_self._DocTestRunner__record_outcome = self
+ def uninstall_dt_self(self):
+ self.dt_self._DocTestRunner__record_outcome = self.prev_func
+ def uninstall_module(self):
+ if self.del_module:
+ import sys
+ del sys.modules[self.del_module]
+ if '.' in self.del_module:
+ package, module = self.del_module.rsplit('.', 1)
+ package_mod = sys.modules[package]
+ delattr(package_mod, module)
+ def __call__(self, *args, **kw):
+ self.uninstall_clone()
+ self.uninstall_dt_self()
+ del self.checker._temp_override_self
+ del self.checker._temp_call_super_check_output
+ result = self.prev_func(*args, **kw)
+ self.uninstall_module()
+ return result
+ def call_super(self, *args, **kw):
+ self.uninstall_clone()
+ try:
+ return self.check_func(*args, **kw)
+ finally:
+ self.install_clone()
+
+def _find_doctest_frame():
+ import sys
+ frame = sys._getframe(1)
+ while frame:
+ l = frame.f_locals
+ if 'BOOM' in l:
+ # Sign of doctest
+ return frame
+ frame = frame.f_back
+ raise LookupError(
+ "Could not find doctest (only use this function *inside* a doctest)")
+
+__test__ = {
+ 'basic': '''
+ >>> temp_install()
+ >>> print """stuff """
+ ...
+ >>> print """
+
+ >>> print """blahblahblah """ # doctest: +NOPARSE_MARKUP, +ELLIPSIS
+ ...foo />
+ '''}
+
+if __name__ == '__main__':
+ import doctest
+ doctest.testmod()
+
+
diff --git a/llava_video/lib/python3.10/site-packages/lxml/dtd.pxi b/llava_video/lib/python3.10/site-packages/lxml/dtd.pxi
new file mode 100644
index 0000000000000000000000000000000000000000..ee1b3d4750c7596e72bac0eaa905908b60dcb1e8
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/dtd.pxi
@@ -0,0 +1,479 @@
+# support for DTD validation
+from lxml.includes cimport dtdvalid
+
+cdef class DTDError(LxmlError):
+ """Base class for DTD errors.
+ """
+
+cdef class DTDParseError(DTDError):
+ """Error while parsing a DTD.
+ """
+
+cdef class DTDValidateError(DTDError):
+ """Error while validating an XML document with a DTD.
+ """
+
+
+cdef inline int _assertValidDTDNode(node, void *c_node) except -1:
+ assert c_node is not NULL, "invalid DTD proxy at %s" % id(node)
+
+
+@cython.final
+@cython.internal
+@cython.freelist(8)
+cdef class _DTDElementContentDecl:
+ cdef DTD _dtd
+ cdef tree.xmlElementContent* _c_node
+
+ def __repr__(self):
+ return "<%s.%s object name=%r type=%r occur=%r at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.name, self.type, self.occur, id(self))
+
+ @property
+ def name(self):
+ _assertValidDTDNode(self, self._c_node)
+ return funicodeOrNone(self._c_node.name)
+
+ @property
+ def type(self):
+ _assertValidDTDNode(self, self._c_node)
+ cdef int type = self._c_node.type
+ if type == tree.XML_ELEMENT_CONTENT_PCDATA:
+ return "pcdata"
+ elif type == tree.XML_ELEMENT_CONTENT_ELEMENT:
+ return "element"
+ elif type == tree.XML_ELEMENT_CONTENT_SEQ:
+ return "seq"
+ elif type == tree.XML_ELEMENT_CONTENT_OR:
+ return "or"
+ else:
+ return None
+
+ @property
+ def occur(self):
+ _assertValidDTDNode(self, self._c_node)
+ cdef int occur = self._c_node.ocur
+ if occur == tree.XML_ELEMENT_CONTENT_ONCE:
+ return "once"
+ elif occur == tree.XML_ELEMENT_CONTENT_OPT:
+ return "opt"
+ elif occur == tree.XML_ELEMENT_CONTENT_MULT:
+ return "mult"
+ elif occur == tree.XML_ELEMENT_CONTENT_PLUS:
+ return "plus"
+ else:
+ return None
+
+ @property
+ def left(self):
+ _assertValidDTDNode(self, self._c_node)
+ c1 = self._c_node.c1
+ if c1:
+ node = <_DTDElementContentDecl>_DTDElementContentDecl.__new__(_DTDElementContentDecl)
+ node._dtd = self._dtd
+ node._c_node = c1
+ return node
+ else:
+ return None
+
+ @property
+ def right(self):
+ _assertValidDTDNode(self, self._c_node)
+ c2 = self._c_node.c2
+ if c2:
+ node = <_DTDElementContentDecl>_DTDElementContentDecl.__new__(_DTDElementContentDecl)
+ node._dtd = self._dtd
+ node._c_node = c2
+ return node
+ else:
+ return None
+
+
+@cython.final
+@cython.internal
+@cython.freelist(8)
+cdef class _DTDAttributeDecl:
+ cdef DTD _dtd
+ cdef tree.xmlAttribute* _c_node
+
+ def __repr__(self):
+ return "<%s.%s object name=%r elemname=%r prefix=%r type=%r default=%r default_value=%r at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.name, self.elemname, self.prefix, self.type, self.default, self.default_value, id(self))
+
+ @property
+ def name(self):
+ _assertValidDTDNode(self, self._c_node)
+ return funicodeOrNone(self._c_node.name)
+
+ @property
+ def elemname(self):
+ _assertValidDTDNode(self, self._c_node)
+ return funicodeOrNone(self._c_node.elem)
+
+ @property
+ def prefix(self):
+ _assertValidDTDNode(self, self._c_node)
+ return funicodeOrNone(self._c_node.prefix)
+
+ @property
+ def type(self):
+ _assertValidDTDNode(self, self._c_node)
+ cdef int type = self._c_node.atype
+ if type == tree.XML_ATTRIBUTE_CDATA:
+ return "cdata"
+ elif type == tree.XML_ATTRIBUTE_ID:
+ return "id"
+ elif type == tree.XML_ATTRIBUTE_IDREF:
+ return "idref"
+ elif type == tree.XML_ATTRIBUTE_IDREFS:
+ return "idrefs"
+ elif type == tree.XML_ATTRIBUTE_ENTITY:
+ return "entity"
+ elif type == tree.XML_ATTRIBUTE_ENTITIES:
+ return "entities"
+ elif type == tree.XML_ATTRIBUTE_NMTOKEN:
+ return "nmtoken"
+ elif type == tree.XML_ATTRIBUTE_NMTOKENS:
+ return "nmtokens"
+ elif type == tree.XML_ATTRIBUTE_ENUMERATION:
+ return "enumeration"
+ elif type == tree.XML_ATTRIBUTE_NOTATION:
+ return "notation"
+ else:
+ return None
+
+ @property
+ def default(self):
+ _assertValidDTDNode(self, self._c_node)
+ cdef int default = self._c_node.def_
+ if default == tree.XML_ATTRIBUTE_NONE:
+ return "none"
+ elif default == tree.XML_ATTRIBUTE_REQUIRED:
+ return "required"
+ elif default == tree.XML_ATTRIBUTE_IMPLIED:
+ return "implied"
+ elif default == tree.XML_ATTRIBUTE_FIXED:
+ return "fixed"
+ else:
+ return None
+
+ @property
+ def default_value(self):
+ _assertValidDTDNode(self, self._c_node)
+ return funicodeOrNone(self._c_node.defaultValue)
+
+ def itervalues(self):
+ _assertValidDTDNode(self, self._c_node)
+ cdef tree.xmlEnumeration *c_node = self._c_node.tree
+ while c_node is not NULL:
+ yield funicode(c_node.name)
+ c_node = c_node.next
+
+ def values(self):
+ return list(self.itervalues())
+
+
+@cython.final
+@cython.internal
+@cython.freelist(8)
+cdef class _DTDElementDecl:
+ cdef DTD _dtd
+ cdef tree.xmlElement* _c_node
+
+ def __repr__(self):
+ return "<%s.%s object name=%r prefix=%r type=%r at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.name, self.prefix, self.type, id(self))
+
+ @property
+ def name(self):
+ _assertValidDTDNode(self, self._c_node)
+ return funicodeOrNone(self._c_node.name)
+
+ @property
+ def prefix(self):
+ _assertValidDTDNode(self, self._c_node)
+ return funicodeOrNone(self._c_node.prefix)
+
+ @property
+ def type(self):
+ _assertValidDTDNode(self, self._c_node)
+ cdef int type = self._c_node.etype
+ if type == tree.XML_ELEMENT_TYPE_UNDEFINED:
+ return "undefined"
+ elif type == tree.XML_ELEMENT_TYPE_EMPTY:
+ return "empty"
+ elif type == tree.XML_ELEMENT_TYPE_ANY:
+ return "any"
+ elif type == tree.XML_ELEMENT_TYPE_MIXED:
+ return "mixed"
+ elif type == tree.XML_ELEMENT_TYPE_ELEMENT:
+ return "element"
+ else:
+ return None
+
+ @property
+ def content(self):
+ _assertValidDTDNode(self, self._c_node)
+ cdef tree.xmlElementContent *content = self._c_node.content
+ if content:
+ node = <_DTDElementContentDecl>_DTDElementContentDecl.__new__(_DTDElementContentDecl)
+ node._dtd = self._dtd
+ node._c_node = content
+ return node
+ else:
+ return None
+
+ def iterattributes(self):
+ _assertValidDTDNode(self, self._c_node)
+ cdef tree.xmlAttribute *c_node = self._c_node.attributes
+ while c_node:
+ node = <_DTDAttributeDecl>_DTDAttributeDecl.__new__(_DTDAttributeDecl)
+ node._dtd = self._dtd
+ node._c_node = c_node
+ yield node
+ c_node = c_node.nexth
+
+ def attributes(self):
+ return list(self.iterattributes())
+
+
+@cython.final
+@cython.internal
+@cython.freelist(8)
+cdef class _DTDEntityDecl:
+ cdef DTD _dtd
+ cdef tree.xmlEntity* _c_node
+ def __repr__(self):
+ return "<%s.%s object name=%r at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.name, id(self))
+
+ @property
+ def name(self):
+ _assertValidDTDNode(self, self._c_node)
+ return funicodeOrNone(self._c_node.name)
+
+ @property
+ def orig(self):
+ _assertValidDTDNode(self, self._c_node)
+ return funicodeOrNone(self._c_node.orig)
+
+ @property
+ def content(self):
+ _assertValidDTDNode(self, self._c_node)
+ return funicodeOrNone(self._c_node.content)
+
+ @property
+ def system_url(self):
+ _assertValidDTDNode(self, self._c_node)
+ return funicodeOrNone(self._c_node.SystemID)
+
+
+################################################################################
+# DTD
+
+cdef class DTD(_Validator):
+ """DTD(self, file=None, external_id=None)
+ A DTD validator.
+
+ Can load from filesystem directly given a filename or file-like object.
+ Alternatively, pass the keyword parameter ``external_id`` to load from a
+ catalog.
+ """
+ cdef tree.xmlDtd* _c_dtd
+ def __init__(self, file=None, *, external_id=None):
+ _Validator.__init__(self)
+ if file is not None:
+ file = _getFSPathOrObject(file)
+ if _isString(file):
+ file = _encodeFilename(file)
+ with self._error_log:
+ orig_loader = _register_document_loader()
+ self._c_dtd = xmlparser.xmlParseDTD(NULL, _xcstr(file))
+ _reset_document_loader(orig_loader)
+ elif hasattr(file, 'read'):
+ orig_loader = _register_document_loader()
+ self._c_dtd = _parseDtdFromFilelike(file)
+ _reset_document_loader(orig_loader)
+ else:
+ raise DTDParseError, "file must be a filename, file-like or path-like object"
+ elif external_id is not None:
+ external_id_utf = _utf8(external_id)
+ with self._error_log:
+ orig_loader = _register_document_loader()
+ self._c_dtd = xmlparser.xmlParseDTD(external_id_utf, NULL)
+ _reset_document_loader(orig_loader)
+ else:
+ raise DTDParseError, "either filename or external ID required"
+
+ if self._c_dtd is NULL:
+ raise DTDParseError(
+ self._error_log._buildExceptionMessage("error parsing DTD"),
+ self._error_log)
+
+ @property
+ def name(self):
+ if self._c_dtd is NULL:
+ return None
+ return funicodeOrNone(self._c_dtd.name)
+
+ @property
+ def external_id(self):
+ if self._c_dtd is NULL:
+ return None
+ return funicodeOrNone(self._c_dtd.ExternalID)
+
+ @property
+ def system_url(self):
+ if self._c_dtd is NULL:
+ return None
+ return funicodeOrNone(self._c_dtd.SystemID)
+
+ def iterelements(self):
+ cdef tree.xmlNode *c_node = self._c_dtd.children if self._c_dtd is not NULL else NULL
+ while c_node is not NULL:
+ if c_node.type == tree.XML_ELEMENT_DECL:
+ node = _DTDElementDecl()
+ node._dtd = self
+ node._c_node = c_node
+ yield node
+ c_node = c_node.next
+
+ def elements(self):
+ return list(self.iterelements())
+
+ def iterentities(self):
+ cdef tree.xmlNode *c_node = self._c_dtd.children if self._c_dtd is not NULL else NULL
+ while c_node is not NULL:
+ if c_node.type == tree.XML_ENTITY_DECL:
+ node = _DTDEntityDecl()
+ node._dtd = self
+ node._c_node = c_node
+ yield node
+ c_node = c_node.next
+
+ def entities(self):
+ return list(self.iterentities())
+
+ def __dealloc__(self):
+ tree.xmlFreeDtd(self._c_dtd)
+
+ def __call__(self, etree):
+ """__call__(self, etree)
+
+ Validate doc using the DTD.
+
+ Returns true if the document is valid, false if not.
+ """
+ cdef _Document doc
+ cdef _Element root_node
+ cdef xmlDoc* c_doc
+ cdef dtdvalid.xmlValidCtxt* valid_ctxt
+ cdef int ret = -1
+
+ assert self._c_dtd is not NULL, "DTD not initialised"
+ doc = _documentOrRaise(etree)
+ root_node = _rootNodeOrRaise(etree)
+
+ valid_ctxt = dtdvalid.xmlNewValidCtxt()
+ if valid_ctxt is NULL:
+ raise DTDError("Failed to create validation context")
+
+ # work around error reporting bug in libxml2 <= 2.9.1 (and later?)
+ # https://bugzilla.gnome.org/show_bug.cgi?id=724903
+ valid_ctxt.error = _nullGenericErrorFunc
+ valid_ctxt.userData = NULL
+
+ try:
+ with self._error_log:
+ c_doc = _fakeRootDoc(doc._c_doc, root_node._c_node)
+ ret = dtdvalid.xmlValidateDtd(valid_ctxt, c_doc, self._c_dtd)
+ _destroyFakeDoc(doc._c_doc, c_doc)
+ finally:
+ dtdvalid.xmlFreeValidCtxt(valid_ctxt)
+
+ if ret == -1:
+ raise DTDValidateError("Internal error in DTD validation",
+ self._error_log)
+ return ret == 1
+
+
+cdef tree.xmlDtd* _parseDtdFromFilelike(file) except NULL:
+ cdef _ExceptionContext exc_context
+ cdef _FileReaderContext dtd_parser
+ cdef _ErrorLog error_log
+ cdef tree.xmlDtd* c_dtd = NULL
+ exc_context = _ExceptionContext()
+ dtd_parser = _FileReaderContext(file, exc_context, None)
+ error_log = _ErrorLog()
+
+ with error_log:
+ c_dtd = dtd_parser._readDtd()
+
+ exc_context._raise_if_stored()
+ if c_dtd is NULL:
+ raise DTDParseError("error parsing DTD", error_log)
+ return c_dtd
+
+cdef DTD _dtdFactory(tree.xmlDtd* c_dtd):
+ # do not run through DTD.__init__()!
+ cdef DTD dtd
+ if c_dtd is NULL:
+ return None
+ dtd = DTD.__new__(DTD)
+ dtd._c_dtd = _copyDtd(c_dtd)
+ _Validator.__init__(dtd)
+ return dtd
+
+
+cdef tree.xmlDtd* _copyDtd(tree.xmlDtd* c_orig_dtd) except NULL:
+ """
+ Copy a DTD. libxml2 (currently) fails to set up the element->attributes
+ links when copying DTDs, so we have to rebuild them here.
+ """
+ c_dtd = tree.xmlCopyDtd(c_orig_dtd)
+ if not c_dtd:
+ raise MemoryError
+ cdef tree.xmlNode* c_node = c_dtd.children
+ while c_node:
+ if c_node.type == tree.XML_ATTRIBUTE_DECL:
+ _linkDtdAttribute(c_dtd, c_node)
+ c_node = c_node.next
+ return c_dtd
+
+
+cdef void _linkDtdAttribute(tree.xmlDtd* c_dtd, tree.xmlAttribute* c_attr) noexcept:
+ """
+ Create the link to the DTD attribute declaration from the corresponding
+ element declaration.
+ """
+ c_elem = dtdvalid.xmlGetDtdElementDesc(c_dtd, c_attr.elem)
+ if not c_elem:
+ # no such element? something is wrong with the DTD ...
+ return
+ c_pos = c_elem.attributes
+ if not c_pos:
+ c_elem.attributes = c_attr
+ c_attr.nexth = NULL
+ return
+ # libxml2 keeps namespace declarations first, and we need to make
+ # sure we don't re-insert attributes that are already there
+ if _isDtdNsDecl(c_attr):
+ if not _isDtdNsDecl(c_pos):
+ c_elem.attributes = c_attr
+ c_attr.nexth = c_pos
+ return
+ while c_pos != c_attr and c_pos.nexth and _isDtdNsDecl(c_pos.nexth):
+ c_pos = c_pos.nexth
+ else:
+ # append at end
+ while c_pos != c_attr and c_pos.nexth:
+ c_pos = c_pos.nexth
+ if c_pos == c_attr:
+ return
+ c_attr.nexth = c_pos.nexth
+ c_pos.nexth = c_attr
+
+
+cdef bint _isDtdNsDecl(tree.xmlAttribute* c_attr) noexcept:
+ if cstring_h.strcmp(c_attr.name, "xmlns") == 0:
+ return True
+ if (c_attr.prefix is not NULL and
+ cstring_h.strcmp(c_attr.prefix, "xmlns") == 0):
+ return True
+ return False
diff --git a/llava_video/lib/python3.10/site-packages/lxml/etree.h b/llava_video/lib/python3.10/site-packages/lxml/etree.h
new file mode 100644
index 0000000000000000000000000000000000000000..c2a0f5abcb17cebffb5678c0b5d3101583fa831c
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/etree.h
@@ -0,0 +1,248 @@
+/* Generated by Cython 3.0.11 */
+
+#ifndef __PYX_HAVE__lxml__etree
+#define __PYX_HAVE__lxml__etree
+
+#include "Python.h"
+struct LxmlDocument;
+struct LxmlElement;
+struct LxmlElementTree;
+struct LxmlElementTagMatcher;
+struct LxmlElementIterator;
+struct LxmlElementBase;
+struct LxmlElementClassLookup;
+struct LxmlFallbackElementClassLookup;
+
+/* "lxml/etree.pyx":355
+ *
+ * # type of a function that steps from node to node
+ * ctypedef public xmlNode* (*_node_to_node_function)(xmlNode*) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+typedef xmlNode *(*_node_to_node_function)(xmlNode *);
+
+/* "lxml/etree.pyx":371
+ * @cython.final
+ * @cython.freelist(8)
+ * cdef public class _Document [ type LxmlDocumentType, object LxmlDocument ]: # <<<<<<<<<<<<<<
+ * """Internal base class to reference a libxml document.
+ *
+ */
+struct LxmlDocument {
+ PyObject_HEAD
+ struct __pyx_vtabstruct_4lxml_5etree__Document *__pyx_vtab;
+ int _ns_counter;
+ PyObject *_prefix_tail;
+ xmlDoc *_c_doc;
+ struct __pyx_obj_4lxml_5etree__BaseParser *_parser;
+};
+
+/* "lxml/etree.pyx":720
+ *
+ * @cython.no_gc_clear
+ * cdef public class _Element [ type LxmlElementType, object LxmlElement ]: # <<<<<<<<<<<<<<
+ * """Element class.
+ *
+ */
+struct LxmlElement {
+ PyObject_HEAD
+ struct LxmlDocument *_doc;
+ xmlNode *_c_node;
+ PyObject *_tag;
+};
+
+/* "lxml/etree.pyx":1895
+ *
+ *
+ * cdef public class _ElementTree [ type LxmlElementTreeType, # <<<<<<<<<<<<<<
+ * object LxmlElementTree ]:
+ * cdef _Document _doc
+ */
+struct LxmlElementTree {
+ PyObject_HEAD
+ struct __pyx_vtabstruct_4lxml_5etree__ElementTree *__pyx_vtab;
+ struct LxmlDocument *_doc;
+ struct LxmlElement *_context_node;
+};
+
+/* "lxml/etree.pyx":2669
+ *
+ *
+ * cdef public class _ElementTagMatcher [ object LxmlElementTagMatcher, # <<<<<<<<<<<<<<
+ * type LxmlElementTagMatcherType ]:
+ * """
+ */
+struct LxmlElementTagMatcher {
+ PyObject_HEAD
+ struct __pyx_vtabstruct_4lxml_5etree__ElementTagMatcher *__pyx_vtab;
+ PyObject *_pystrings;
+ int _node_type;
+ char *_href;
+ char *_name;
+};
+
+/* "lxml/etree.pyx":2700
+ * self._name = NULL
+ *
+ * cdef public class _ElementIterator(_ElementTagMatcher) [ # <<<<<<<<<<<<<<
+ * object LxmlElementIterator, type LxmlElementIteratorType ]:
+ * """
+ */
+struct LxmlElementIterator {
+ struct LxmlElementTagMatcher __pyx_base;
+ struct LxmlElement *_node;
+ _node_to_node_function _next_element;
+};
+
+/* "src/lxml/classlookup.pxi":6
+ * # Custom Element classes
+ *
+ * cdef public class ElementBase(_Element) [ type LxmlElementBaseType, # <<<<<<<<<<<<<<
+ * object LxmlElementBase ]:
+ * """ElementBase(*children, attrib=None, nsmap=None, **_extra)
+ */
+struct LxmlElementBase {
+ struct LxmlElement __pyx_base;
+};
+
+/* "src/lxml/classlookup.pxi":210
+ * # Element class lookup
+ *
+ * ctypedef public object (*_element_class_lookup_function)(object, _Document, xmlNode*) # <<<<<<<<<<<<<<
+ *
+ * # class to store element class lookup functions
+ */
+typedef PyObject *(*_element_class_lookup_function)(PyObject *, struct LxmlDocument *, xmlNode *);
+
+/* "src/lxml/classlookup.pxi":213
+ *
+ * # class to store element class lookup functions
+ * cdef public class ElementClassLookup [ type LxmlElementClassLookupType, # <<<<<<<<<<<<<<
+ * object LxmlElementClassLookup ]:
+ * """ElementClassLookup(self)
+ */
+struct LxmlElementClassLookup {
+ PyObject_HEAD
+ _element_class_lookup_function _lookup_function;
+};
+
+/* "src/lxml/classlookup.pxi":221
+ *
+ *
+ * cdef public class FallbackElementClassLookup(ElementClassLookup) \ # <<<<<<<<<<<<<<
+ * [ type LxmlFallbackElementClassLookupType,
+ * object LxmlFallbackElementClassLookup ]:
+ */
+struct LxmlFallbackElementClassLookup {
+ struct LxmlElementClassLookup __pyx_base;
+ struct __pyx_vtabstruct_4lxml_5etree_FallbackElementClassLookup *__pyx_vtab;
+ struct LxmlElementClassLookup *fallback;
+ _element_class_lookup_function _fallback_function;
+};
+
+#ifndef __PYX_HAVE_API__lxml__etree
+
+#ifdef CYTHON_EXTERN_C
+ #undef __PYX_EXTERN_C
+ #define __PYX_EXTERN_C CYTHON_EXTERN_C
+#elif defined(__PYX_EXTERN_C)
+ #ifdef _MSC_VER
+ #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.")
+ #else
+ #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.
+ #endif
+#else
+ #ifdef __cplusplus
+ #define __PYX_EXTERN_C extern "C"
+ #else
+ #define __PYX_EXTERN_C extern
+ #endif
+#endif
+
+#ifndef DL_IMPORT
+ #define DL_IMPORT(_T) _T
+#endif
+
+__PYX_EXTERN_C DL_IMPORT(PyTypeObject) LxmlDocumentType;
+__PYX_EXTERN_C DL_IMPORT(PyTypeObject) LxmlElementType;
+__PYX_EXTERN_C DL_IMPORT(PyTypeObject) LxmlElementTreeType;
+__PYX_EXTERN_C DL_IMPORT(PyTypeObject) LxmlElementTagMatcherType;
+__PYX_EXTERN_C DL_IMPORT(PyTypeObject) LxmlElementIteratorType;
+__PYX_EXTERN_C DL_IMPORT(PyTypeObject) LxmlElementBaseType;
+__PYX_EXTERN_C DL_IMPORT(PyTypeObject) LxmlElementClassLookupType;
+__PYX_EXTERN_C DL_IMPORT(PyTypeObject) LxmlFallbackElementClassLookupType;
+
+__PYX_EXTERN_C struct LxmlElement *deepcopyNodeToDocument(struct LxmlDocument *, xmlNode *);
+__PYX_EXTERN_C struct LxmlElementTree *elementTreeFactory(struct LxmlElement *);
+__PYX_EXTERN_C struct LxmlElementTree *newElementTree(struct LxmlElement *, PyObject *);
+__PYX_EXTERN_C struct LxmlElementTree *adoptExternalDocument(xmlDoc *, PyObject *, int);
+__PYX_EXTERN_C struct LxmlElement *elementFactory(struct LxmlDocument *, xmlNode *);
+__PYX_EXTERN_C struct LxmlElement *makeElement(PyObject *, struct LxmlDocument *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *);
+__PYX_EXTERN_C struct LxmlElement *makeSubElement(struct LxmlElement *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *);
+__PYX_EXTERN_C void setElementClassLookupFunction(_element_class_lookup_function, PyObject *);
+__PYX_EXTERN_C PyObject *lookupDefaultElementClass(PyObject *, PyObject *, xmlNode *);
+__PYX_EXTERN_C PyObject *lookupNamespaceElementClass(PyObject *, PyObject *, xmlNode *);
+__PYX_EXTERN_C PyObject *callLookupFallback(struct LxmlFallbackElementClassLookup *, struct LxmlDocument *, xmlNode *);
+__PYX_EXTERN_C int tagMatches(xmlNode *, const xmlChar *, const xmlChar *);
+__PYX_EXTERN_C struct LxmlDocument *documentOrRaise(PyObject *);
+__PYX_EXTERN_C struct LxmlElement *rootNodeOrRaise(PyObject *);
+__PYX_EXTERN_C int hasText(xmlNode *);
+__PYX_EXTERN_C int hasTail(xmlNode *);
+__PYX_EXTERN_C PyObject *textOf(xmlNode *);
+__PYX_EXTERN_C PyObject *tailOf(xmlNode *);
+__PYX_EXTERN_C int setNodeText(xmlNode *, PyObject *);
+__PYX_EXTERN_C int setTailText(xmlNode *, PyObject *);
+__PYX_EXTERN_C PyObject *attributeValue(xmlNode *, xmlAttr *);
+__PYX_EXTERN_C PyObject *attributeValueFromNsName(xmlNode *, const xmlChar *, const xmlChar *);
+__PYX_EXTERN_C PyObject *getAttributeValue(struct LxmlElement *, PyObject *, PyObject *);
+__PYX_EXTERN_C PyObject *iterattributes(struct LxmlElement *, int);
+__PYX_EXTERN_C PyObject *collectAttributes(xmlNode *, int);
+__PYX_EXTERN_C int setAttributeValue(struct LxmlElement *, PyObject *, PyObject *);
+__PYX_EXTERN_C int delAttribute(struct LxmlElement *, PyObject *);
+__PYX_EXTERN_C int delAttributeFromNsName(xmlNode *, const xmlChar *, const xmlChar *);
+__PYX_EXTERN_C int hasChild(xmlNode *);
+__PYX_EXTERN_C xmlNode *findChild(xmlNode *, Py_ssize_t);
+__PYX_EXTERN_C xmlNode *findChildForwards(xmlNode *, Py_ssize_t);
+__PYX_EXTERN_C xmlNode *findChildBackwards(xmlNode *, Py_ssize_t);
+__PYX_EXTERN_C xmlNode *nextElement(xmlNode *);
+__PYX_EXTERN_C xmlNode *previousElement(xmlNode *);
+__PYX_EXTERN_C void appendChild(struct LxmlElement *, struct LxmlElement *);
+__PYX_EXTERN_C int appendChildToElement(struct LxmlElement *, struct LxmlElement *);
+__PYX_EXTERN_C PyObject *pyunicode(const xmlChar *);
+__PYX_EXTERN_C PyObject *utf8(PyObject *);
+__PYX_EXTERN_C PyObject *getNsTag(PyObject *);
+__PYX_EXTERN_C PyObject *getNsTagWithEmptyNs(PyObject *);
+__PYX_EXTERN_C PyObject *namespacedName(xmlNode *);
+__PYX_EXTERN_C PyObject *namespacedNameFromNsName(const xmlChar *, const xmlChar *);
+__PYX_EXTERN_C void iteratorStoreNext(struct LxmlElementIterator *, struct LxmlElement *);
+__PYX_EXTERN_C void initTagMatch(struct LxmlElementTagMatcher *, PyObject *);
+__PYX_EXTERN_C xmlNs *findOrBuildNodeNsPrefix(struct LxmlDocument *, xmlNode *, const xmlChar *, const xmlChar *);
+
+#endif /* !__PYX_HAVE_API__lxml__etree */
+
+/* WARNING: the interface of the module init function changed in CPython 3.5. */
+/* It now returns a PyModuleDef instance instead of a PyModule instance. */
+
+#if PY_MAJOR_VERSION < 3
+PyMODINIT_FUNC initetree(void);
+#else
+/* WARNING: Use PyImport_AppendInittab("etree", PyInit_etree) instead of calling PyInit_etree directly from Python 3.5 */
+PyMODINIT_FUNC PyInit_etree(void);
+
+#if PY_VERSION_HEX >= 0x03050000 && (defined(__GNUC__) || defined(__clang__) || defined(_MSC_VER) || (defined(__cplusplus) && __cplusplus >= 201402L))
+#if defined(__cplusplus) && __cplusplus >= 201402L
+[[deprecated("Use PyImport_AppendInittab(\"etree\", PyInit_etree) instead of calling PyInit_etree directly.")]] inline
+#elif defined(__GNUC__) || defined(__clang__)
+__attribute__ ((__deprecated__("Use PyImport_AppendInittab(\"etree\", PyInit_etree) instead of calling PyInit_etree directly."), __unused__)) __inline__
+#elif defined(_MSC_VER)
+__declspec(deprecated("Use PyImport_AppendInittab(\"etree\", PyInit_etree) instead of calling PyInit_etree directly.")) __inline
+#endif
+static PyObject* __PYX_WARN_IF_PyInit_etree_INIT_CALLED(PyObject* res) {
+ return res;
+}
+#define PyInit_etree() __PYX_WARN_IF_PyInit_etree_INIT_CALLED(PyInit_etree())
+#endif
+#endif
+
+#endif /* !__PYX_HAVE__lxml__etree */
diff --git a/llava_video/lib/python3.10/site-packages/lxml/etree.pyx b/llava_video/lib/python3.10/site-packages/lxml/etree.pyx
new file mode 100644
index 0000000000000000000000000000000000000000..f7da01c1a7c52c60dd37dfd831d0faa31df77d3f
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/etree.pyx
@@ -0,0 +1,3732 @@
+# cython: binding=True
+# cython: auto_pickle=False
+# cython: language_level=3
+
+"""
+The ``lxml.etree`` module implements the extended ElementTree API for XML.
+"""
+
+__docformat__ = "restructuredtext en"
+
+__all__ = [
+ 'AttributeBasedElementClassLookup', 'C14NError', 'C14NWriterTarget', 'CDATA',
+ 'Comment', 'CommentBase', 'CustomElementClassLookup', 'DEBUG',
+ 'DTD', 'DTDError', 'DTDParseError', 'DTDValidateError',
+ 'DocumentInvalid', 'ETCompatXMLParser', 'ETXPath', 'Element',
+ 'ElementBase', 'ElementClassLookup', 'ElementDefaultClassLookup',
+ 'ElementNamespaceClassLookup', 'ElementTree', 'Entity', 'EntityBase',
+ 'Error', 'ErrorDomains', 'ErrorLevels', 'ErrorTypes', 'Extension',
+ 'FallbackElementClassLookup', 'FunctionNamespace', 'HTML', 'HTMLParser',
+ 'ICONV_COMPILED_VERSION',
+ 'LIBXML_COMPILED_VERSION', 'LIBXML_VERSION',
+ 'LIBXSLT_COMPILED_VERSION', 'LIBXSLT_VERSION',
+ 'LXML_VERSION',
+ 'LxmlError', 'LxmlRegistryError', 'LxmlSyntaxError',
+ 'NamespaceRegistryError', 'PI', 'PIBase', 'ParseError',
+ 'ParserBasedElementClassLookup', 'ParserError', 'ProcessingInstruction',
+ 'PyErrorLog', 'PythonElementClassLookup', 'QName', 'RelaxNG',
+ 'RelaxNGError', 'RelaxNGErrorTypes', 'RelaxNGParseError',
+ 'RelaxNGValidateError', 'Resolver', 'Schematron', 'SchematronError',
+ 'SchematronParseError', 'SchematronValidateError', 'SerialisationError',
+ 'SubElement', 'TreeBuilder', 'XInclude', 'XIncludeError', 'XML',
+ 'XMLDTDID', 'XMLID', 'XMLParser', 'XMLSchema', 'XMLSchemaError',
+ 'XMLSchemaParseError', 'XMLSchemaValidateError', 'XMLSyntaxError',
+ 'XMLTreeBuilder', 'XPath', 'XPathDocumentEvaluator', 'XPathError',
+ 'XPathEvalError', 'XPathEvaluator', 'XPathFunctionError', 'XPathResultError',
+ 'XPathSyntaxError', 'XSLT', 'XSLTAccessControl', 'XSLTApplyError',
+ 'XSLTError', 'XSLTExtension', 'XSLTExtensionError', 'XSLTParseError',
+ 'XSLTSaveError', 'canonicalize',
+ 'cleanup_namespaces', 'clear_error_log', 'dump',
+ 'fromstring', 'fromstringlist', 'get_default_parser', 'iselement',
+ 'iterparse', 'iterwalk', 'parse', 'parseid', 'register_namespace',
+ 'set_default_parser', 'set_element_class_lookup', 'strip_attributes',
+ 'strip_elements', 'strip_tags', 'tostring', 'tostringlist', 'tounicode',
+ 'use_global_python_log'
+ ]
+
+cimport cython
+
+from lxml cimport python
+from lxml.includes cimport tree, config
+from lxml.includes.tree cimport xmlDoc, xmlNode, xmlAttr, xmlNs, _isElement, _getNs
+from lxml.includes.tree cimport const_xmlChar, xmlChar, _xcstr
+from lxml.python cimport _cstr, _isString
+from lxml.includes cimport xpath
+from lxml.includes cimport c14n
+
+# Cython's standard declarations
+cimport cpython.mem
+cimport cpython.ref
+from libc cimport limits, stdio, stdlib
+from libc cimport string as cstring_h # not to be confused with stdlib 'string'
+from libc.string cimport const_char
+
+cdef object os_path_abspath
+from os.path import abspath as os_path_abspath
+
+cdef object BytesIO, StringIO
+from io import BytesIO, StringIO
+
+cdef object OrderedDict
+from collections import OrderedDict
+
+cdef object _elementpath
+from lxml import _elementpath
+
+cdef object sys
+import sys
+
+cdef object re
+import re
+
+cdef object partial
+from functools import partial
+
+cdef object islice
+from itertools import islice
+
+cdef object ITER_EMPTY = iter(())
+
+cdef object MutableMapping
+from collections.abc import MutableMapping
+
+class _ImmutableMapping(MutableMapping):
+ def __getitem__(self, key):
+ raise KeyError, key
+
+ def __setitem__(self, key, value):
+ raise KeyError, key
+
+ def __delitem__(self, key):
+ raise KeyError, key
+
+ def __contains__(self, key):
+ return False
+
+ def __len__(self):
+ return 0
+
+ def __iter__(self):
+ return ITER_EMPTY
+ iterkeys = itervalues = iteritems = __iter__
+
+cdef object IMMUTABLE_EMPTY_MAPPING = _ImmutableMapping()
+del _ImmutableMapping
+
+
+# the rules
+# ---------
+# any libxml C argument/variable is prefixed with c_
+# any non-public function/class is prefixed with an underscore
+# instance creation is always through factories
+
+# what to do with libxml2/libxslt error messages?
+# 0 : drop
+# 1 : use log
+DEF __DEBUG = 1
+
+# maximum number of lines in the libxml2/xslt log if __DEBUG == 1
+DEF __MAX_LOG_SIZE = 100
+
+# make the compiled-in debug state publicly available
+DEBUG = __DEBUG
+
+# A struct to store a cached qualified tag name+href pair.
+# While we can borrow the c_name from the document dict,
+# PyPy requires us to store a Python reference for the
+# namespace in order to keep the byte buffer alive.
+cdef struct qname:
+ const_xmlChar* c_name
+ python.PyObject* href
+
+# initialize parser (and threading)
+xmlparser.xmlInitParser()
+
+# global per-thread setup
+tree.xmlThrDefIndentTreeOutput(1)
+tree.xmlThrDefLineNumbersDefaultValue(1)
+
+_initThreadLogging()
+
+# filename encoding
+cdef bytes _FILENAME_ENCODING = (sys.getfilesystemencoding() or sys.getdefaultencoding() or 'ascii').encode("UTF-8")
+cdef char* _C_FILENAME_ENCODING = _cstr(_FILENAME_ENCODING)
+
+# set up some default namespace prefixes
+cdef dict _DEFAULT_NAMESPACE_PREFIXES = {
+ b"http://www.w3.org/XML/1998/namespace": b'xml',
+ b"http://www.w3.org/1999/xhtml": b"html",
+ b"http://www.w3.org/1999/XSL/Transform": b"xsl",
+ b"http://www.w3.org/1999/02/22-rdf-syntax-ns#": b"rdf",
+ b"http://schemas.xmlsoap.org/wsdl/": b"wsdl",
+ # xml schema
+ b"http://www.w3.org/2001/XMLSchema": b"xs",
+ b"http://www.w3.org/2001/XMLSchema-instance": b"xsi",
+ # dublin core
+ b"http://purl.org/dc/elements/1.1/": b"dc",
+ # objectify
+ b"http://codespeak.net/lxml/objectify/pytype" : b"py",
+}
+
+# To avoid runtime encoding overhead, we keep a Unicode copy
+# of the uri-prefix mapping as (str, str) items view.
+cdef object _DEFAULT_NAMESPACE_PREFIXES_ITEMS = []
+
+cdef _update_default_namespace_prefixes_items():
+ cdef bytes ns, prefix
+ global _DEFAULT_NAMESPACE_PREFIXES_ITEMS
+ _DEFAULT_NAMESPACE_PREFIXES_ITEMS = {
+ ns.decode('utf-8') : prefix.decode('utf-8')
+ for ns, prefix in _DEFAULT_NAMESPACE_PREFIXES.items()
+ }.items()
+
+_update_default_namespace_prefixes_items()
+
+cdef object _check_internal_prefix = re.compile(br"ns\d+$").match
+
+def register_namespace(prefix, uri):
+ """Registers a namespace prefix that newly created Elements in that
+ namespace will use. The registry is global, and any existing
+ mapping for either the given prefix or the namespace URI will be
+ removed.
+ """
+ prefix_utf, uri_utf = _utf8(prefix), _utf8(uri)
+ if _check_internal_prefix(prefix_utf):
+ raise ValueError("Prefix format reserved for internal use")
+ _tagValidOrRaise(prefix_utf)
+ _uriValidOrRaise(uri_utf)
+ if (uri_utf == b"http://www.w3.org/XML/1998/namespace" and prefix_utf != b'xml'
+ or prefix_utf == b'xml' and uri_utf != b"http://www.w3.org/XML/1998/namespace"):
+ raise ValueError("Cannot change the 'xml' prefix of the XML namespace")
+ for k, v in list(_DEFAULT_NAMESPACE_PREFIXES.items()):
+ if k == uri_utf or v == prefix_utf:
+ del _DEFAULT_NAMESPACE_PREFIXES[k]
+ _DEFAULT_NAMESPACE_PREFIXES[uri_utf] = prefix_utf
+ _update_default_namespace_prefixes_items()
+
+
+# Error superclass for ElementTree compatibility
+cdef class Error(Exception):
+ pass
+
+# module level superclass for all exceptions
+cdef class LxmlError(Error):
+ """Main exception base class for lxml. All other exceptions inherit from
+ this one.
+ """
+ def __init__(self, message, error_log=None):
+ super(_Error, self).__init__(message)
+ if error_log is None:
+ self.error_log = __copyGlobalErrorLog()
+ else:
+ self.error_log = error_log.copy()
+
+cdef object _Error = Error
+
+
+# superclass for all syntax errors
+class LxmlSyntaxError(LxmlError, SyntaxError):
+ """Base class for all syntax errors.
+ """
+
+cdef class C14NError(LxmlError):
+ """Error during C14N serialisation.
+ """
+
+# version information
+cdef tuple __unpackDottedVersion(version):
+ version_list = []
+ l = (version.decode("ascii").replace('-', '.').split('.') + [0]*4)[:4]
+ for item in l:
+ try:
+ item = int(item)
+ except ValueError:
+ if item.startswith('dev'):
+ count = item[3:]
+ item = -300
+ elif item.startswith('alpha'):
+ count = item[5:]
+ item = -200
+ elif item.startswith('beta'):
+ count = item[4:]
+ item = -100
+ else:
+ count = 0
+ if count:
+ item += int(count)
+ version_list.append(item)
+ return tuple(version_list)
+
+cdef tuple __unpackIntVersion(int c_version, int base=100):
+ return (
+ ((c_version // (base*base)) % base),
+ ((c_version // base) % base),
+ (c_version % base)
+ )
+
+cdef int _LIBXML_VERSION_INT
+try:
+ _LIBXML_VERSION_INT = int(
+ re.match('[0-9]+', (tree.xmlParserVersion).decode("ascii")).group(0))
+except Exception:
+ print("Unknown libxml2 version: " + (tree.xmlParserVersion).decode("latin1"))
+ _LIBXML_VERSION_INT = 0
+
+LIBXML_VERSION = __unpackIntVersion(_LIBXML_VERSION_INT)
+LIBXML_COMPILED_VERSION = __unpackIntVersion(tree.LIBXML_VERSION)
+LXML_VERSION = __unpackDottedVersion(tree.LXML_VERSION_STRING)
+
+__version__ = tree.LXML_VERSION_STRING.decode("ascii")
+
+cdef extern from *:
+ """
+ #ifdef ZLIB_VERNUM
+ #define __lxml_zlib_version (ZLIB_VERNUM >> 4)
+ #else
+ #define __lxml_zlib_version 0
+ #endif
+ #ifdef _LIBICONV_VERSION
+ #define __lxml_iconv_version (_LIBICONV_VERSION << 8)
+ #else
+ #define __lxml_iconv_version 0
+ #endif
+ """
+ # zlib isn't included automatically by libxml2's headers
+ #long ZLIB_HEX_VERSION "__lxml_zlib_version"
+ long LIBICONV_HEX_VERSION "__lxml_iconv_version"
+
+#ZLIB_COMPILED_VERSION = __unpackIntVersion(ZLIB_HEX_VERSION, base=0x10)
+ICONV_COMPILED_VERSION = __unpackIntVersion(LIBICONV_HEX_VERSION, base=0x100)[:2]
+
+
+# class for temporary storage of Python references,
+# used e.g. for XPath results
+@cython.final
+@cython.internal
+cdef class _TempStore:
+ cdef list _storage
+ def __init__(self):
+ self._storage = []
+
+ cdef int add(self, obj) except -1:
+ self._storage.append(obj)
+ return 0
+
+ cdef int clear(self) except -1:
+ del self._storage[:]
+ return 0
+
+
+# class for temporarily storing exceptions raised in extensions
+@cython.internal
+cdef class _ExceptionContext:
+ cdef object _exc_info
+ cdef int clear(self) except -1:
+ self._exc_info = None
+ return 0
+
+ cdef void _store_raised(self) noexcept:
+ try:
+ self._exc_info = sys.exc_info()
+ except BaseException as e:
+ self._store_exception(e)
+ finally:
+ return # and swallow any further exceptions
+
+ cdef int _store_exception(self, exception) except -1:
+ self._exc_info = (exception, None, None)
+ return 0
+
+ cdef bint _has_raised(self) except -1:
+ return self._exc_info is not None
+
+ cdef int _raise_if_stored(self) except -1:
+ if self._exc_info is None:
+ return 0
+ type, value, traceback = self._exc_info
+ self._exc_info = None
+ if value is None and traceback is None:
+ raise type
+ else:
+ raise type, value, traceback
+
+
+# type of a function that steps from node to node
+ctypedef public xmlNode* (*_node_to_node_function)(xmlNode*)
+
+
+################################################################################
+# Include submodules
+
+include "proxy.pxi" # Proxy handling (element backpointers/memory/etc.)
+include "apihelpers.pxi" # Private helper functions
+include "xmlerror.pxi" # Error and log handling
+
+
+################################################################################
+# Public Python API
+
+@cython.final
+@cython.freelist(8)
+cdef public class _Document [ type LxmlDocumentType, object LxmlDocument ]:
+ """Internal base class to reference a libxml document.
+
+ When instances of this class are garbage collected, the libxml
+ document is cleaned up.
+ """
+ cdef int _ns_counter
+ cdef bytes _prefix_tail
+ cdef xmlDoc* _c_doc
+ cdef _BaseParser _parser
+
+ def __dealloc__(self):
+ # if there are no more references to the document, it is safe
+ # to clean the whole thing up, as all nodes have a reference to
+ # the document
+ tree.xmlFreeDoc(self._c_doc)
+
+ @cython.final
+ cdef getroot(self):
+ # return an element proxy for the document root
+ cdef xmlNode* c_node
+ c_node = tree.xmlDocGetRootElement(self._c_doc)
+ if c_node is NULL:
+ return None
+ return _elementFactory(self, c_node)
+
+ @cython.final
+ cdef bint hasdoctype(self) noexcept:
+ # DOCTYPE gets parsed into internal subset (xmlDTD*)
+ return self._c_doc is not NULL and self._c_doc.intSubset is not NULL
+
+ @cython.final
+ cdef getdoctype(self):
+ # get doctype info: root tag, public/system ID (or None if not known)
+ cdef tree.xmlDtd* c_dtd
+ cdef xmlNode* c_root_node
+ public_id = None
+ sys_url = None
+ c_dtd = self._c_doc.intSubset
+ if c_dtd is not NULL:
+ if c_dtd.ExternalID is not NULL:
+ public_id = funicode(c_dtd.ExternalID)
+ if c_dtd.SystemID is not NULL:
+ sys_url = funicode(c_dtd.SystemID)
+ c_dtd = self._c_doc.extSubset
+ if c_dtd is not NULL:
+ if not public_id and c_dtd.ExternalID is not NULL:
+ public_id = funicode(c_dtd.ExternalID)
+ if not sys_url and c_dtd.SystemID is not NULL:
+ sys_url = funicode(c_dtd.SystemID)
+ c_root_node = tree.xmlDocGetRootElement(self._c_doc)
+ if c_root_node is NULL:
+ root_name = None
+ else:
+ root_name = funicode(c_root_node.name)
+ return root_name, public_id, sys_url
+
+ @cython.final
+ cdef getxmlinfo(self):
+ # return XML version and encoding (or None if not known)
+ cdef xmlDoc* c_doc = self._c_doc
+ if c_doc.version is NULL:
+ version = None
+ else:
+ version = funicode(c_doc.version)
+ if c_doc.encoding is NULL:
+ encoding = None
+ else:
+ encoding = funicode(c_doc.encoding)
+ return version, encoding
+
+ @cython.final
+ cdef isstandalone(self):
+ # returns True for "standalone=true",
+ # False for "standalone=false", None if not provided
+ if self._c_doc.standalone == -1:
+ return None
+ else:
+ return (self._c_doc.standalone == 1)
+
+ @cython.final
+ cdef bytes buildNewPrefix(self):
+ # get a new unique prefix ("nsX") for this document
+ cdef bytes ns
+ if self._ns_counter < len(_PREFIX_CACHE):
+ ns = _PREFIX_CACHE[self._ns_counter]
+ else:
+ ns = python.PyBytes_FromFormat("ns%d", self._ns_counter)
+ if self._prefix_tail is not None:
+ ns += self._prefix_tail
+ self._ns_counter += 1
+ if self._ns_counter < 0:
+ # overflow!
+ self._ns_counter = 0
+ if self._prefix_tail is None:
+ self._prefix_tail = b"A"
+ else:
+ self._prefix_tail += b"A"
+ return ns
+
+ @cython.final
+ cdef xmlNs* _findOrBuildNodeNs(self, xmlNode* c_node,
+ const_xmlChar* c_href, const_xmlChar* c_prefix,
+ bint is_attribute) except NULL:
+ """Get or create namespace structure for a node. Reuses the prefix if
+ possible.
+ """
+ cdef xmlNs* c_ns
+ cdef xmlNs* c_doc_ns
+ cdef python.PyObject* dict_result
+ if c_node.type != tree.XML_ELEMENT_NODE:
+ assert c_node.type == tree.XML_ELEMENT_NODE, \
+ "invalid node type %d, expected %d" % (
+ c_node.type, tree.XML_ELEMENT_NODE)
+ # look for existing ns declaration
+ c_ns = _searchNsByHref(c_node, c_href, is_attribute)
+ if c_ns is not NULL:
+ if is_attribute and c_ns.prefix is NULL:
+ # do not put namespaced attributes into the default
+ # namespace as this would break serialisation
+ pass
+ else:
+ return c_ns
+
+ # none found => determine a suitable new prefix
+ if c_prefix is NULL:
+ dict_result = python.PyDict_GetItem(
+ _DEFAULT_NAMESPACE_PREFIXES, c_href)
+ if dict_result is not NULL:
+ prefix = dict_result
+ else:
+ prefix = self.buildNewPrefix()
+ c_prefix = _xcstr(prefix)
+
+ # make sure the prefix is not in use already
+ while tree.xmlSearchNs(self._c_doc, c_node, c_prefix) is not NULL:
+ prefix = self.buildNewPrefix()
+ c_prefix = _xcstr(prefix)
+
+ # declare the namespace and return it
+ c_ns = tree.xmlNewNs(c_node, c_href, c_prefix)
+ if c_ns is NULL:
+ raise MemoryError()
+ return c_ns
+
+ @cython.final
+ cdef int _setNodeNs(self, xmlNode* c_node, const_xmlChar* c_href) except -1:
+ "Lookup namespace structure and set it for the node."
+ c_ns = self._findOrBuildNodeNs(c_node, c_href, NULL, 0)
+ tree.xmlSetNs(c_node, c_ns)
+
+cdef tuple __initPrefixCache():
+ cdef int i
+ return tuple([ python.PyBytes_FromFormat("ns%d", i)
+ for i in range(30) ])
+
+cdef tuple _PREFIX_CACHE = __initPrefixCache()
+
+cdef _Document _documentFactory(xmlDoc* c_doc, _BaseParser parser):
+ cdef _Document result
+ result = _Document.__new__(_Document)
+ result._c_doc = c_doc
+ result._ns_counter = 0
+ result._prefix_tail = None
+ if parser is None:
+ parser = __GLOBAL_PARSER_CONTEXT.getDefaultParser()
+ result._parser = parser
+ return result
+
+
+cdef object _find_invalid_public_id_characters = re.compile(
+ ur"[^\x20\x0D\x0Aa-zA-Z0-9'()+,./:=?;!*#@$_%-]+").search
+
+
+cdef class DocInfo:
+ "Document information provided by parser and DTD."
+ cdef _Document _doc
+ def __cinit__(self, tree):
+ "Create a DocInfo object for an ElementTree object or root Element."
+ self._doc = _documentOrRaise(tree)
+ root_name, public_id, system_url = self._doc.getdoctype()
+ if not root_name and (public_id or system_url):
+ raise ValueError, "Could not find root node"
+
+ @property
+ def root_name(self):
+ """Returns the name of the root node as defined by the DOCTYPE."""
+ root_name, public_id, system_url = self._doc.getdoctype()
+ return root_name
+
+ @cython.final
+ cdef tree.xmlDtd* _get_c_dtd(self):
+ """"Return the DTD. Create it if it does not yet exist."""
+ cdef xmlDoc* c_doc = self._doc._c_doc
+ cdef xmlNode* c_root_node
+ cdef const_xmlChar* c_name
+
+ if c_doc.intSubset:
+ return c_doc.intSubset
+
+ c_root_node = tree.xmlDocGetRootElement(c_doc)
+ c_name = c_root_node.name if c_root_node else NULL
+ return tree.xmlCreateIntSubset(c_doc, c_name, NULL, NULL)
+
+ def clear(self):
+ """Removes DOCTYPE and internal subset from the document."""
+ cdef xmlDoc* c_doc = self._doc._c_doc
+ cdef tree.xmlNode* c_dtd = c_doc.intSubset
+ if c_dtd is NULL:
+ return
+ tree.xmlUnlinkNode(c_dtd)
+ tree.xmlFreeNode(c_dtd)
+
+ property public_id:
+ """Public ID of the DOCTYPE.
+
+ Mutable. May be set to a valid string or None. If a DTD does not
+ exist, setting this variable (even to None) will create one.
+ """
+ def __get__(self):
+ root_name, public_id, system_url = self._doc.getdoctype()
+ return public_id
+
+ def __set__(self, value):
+ cdef xmlChar* c_value = NULL
+ if value is not None:
+ match = _find_invalid_public_id_characters(value)
+ if match:
+ raise ValueError, f'Invalid character(s) {match.group(0)!r} in public_id.'
+ value = _utf8(value)
+ c_value = tree.xmlStrdup(_xcstr(value))
+ if not c_value:
+ raise MemoryError()
+
+ c_dtd = self._get_c_dtd()
+ if not c_dtd:
+ tree.xmlFree(c_value)
+ raise MemoryError()
+ if c_dtd.ExternalID:
+ tree.xmlFree(c_dtd.ExternalID)
+ c_dtd.ExternalID = c_value
+
+ property system_url:
+ """System ID of the DOCTYPE.
+
+ Mutable. May be set to a valid string or None. If a DTD does not
+ exist, setting this variable (even to None) will create one.
+ """
+ def __get__(self):
+ root_name, public_id, system_url = self._doc.getdoctype()
+ return system_url
+
+ def __set__(self, value):
+ cdef xmlChar* c_value = NULL
+ if value is not None:
+ bvalue = _utf8(value)
+ # sys_url may be any valid unicode string that can be
+ # enclosed in single quotes or quotes.
+ if b"'" in bvalue and b'"' in bvalue:
+ raise ValueError(
+ 'System URL may not contain both single (\') and double quotes (").')
+ c_value = tree.xmlStrdup(_xcstr(bvalue))
+ if not c_value:
+ raise MemoryError()
+
+ c_dtd = self._get_c_dtd()
+ if not c_dtd:
+ tree.xmlFree(c_value)
+ raise MemoryError()
+ if c_dtd.SystemID:
+ tree.xmlFree(c_dtd.SystemID)
+ c_dtd.SystemID = c_value
+
+ @property
+ def xml_version(self):
+ """Returns the XML version as declared by the document."""
+ xml_version, encoding = self._doc.getxmlinfo()
+ return xml_version
+
+ @property
+ def encoding(self):
+ """Returns the encoding name as declared by the document."""
+ xml_version, encoding = self._doc.getxmlinfo()
+ return encoding
+
+ @property
+ def standalone(self):
+ """Returns the standalone flag as declared by the document. The possible
+ values are True (``standalone='yes'``), False
+ (``standalone='no'`` or flag not provided in the declaration),
+ and None (unknown or no declaration found). Note that a
+ normal truth test on this value will always tell if the
+ ``standalone`` flag was set to ``'yes'`` or not.
+ """
+ return self._doc.isstandalone()
+
+ property URL:
+ "The source URL of the document (or None if unknown)."
+ def __get__(self):
+ if self._doc._c_doc.URL is NULL:
+ return None
+ return _decodeFilename(self._doc._c_doc.URL)
+ def __set__(self, url):
+ url = _encodeFilename(url)
+ c_oldurl = self._doc._c_doc.URL
+ if url is None:
+ self._doc._c_doc.URL = NULL
+ else:
+ self._doc._c_doc.URL = tree.xmlStrdup(_xcstr(url))
+ if c_oldurl is not NULL:
+ tree.xmlFree(c_oldurl)
+
+ @property
+ def doctype(self):
+ """Returns a DOCTYPE declaration string for the document."""
+ root_name, public_id, system_url = self._doc.getdoctype()
+ if system_url:
+ # If '"' in system_url, we must escape it with single
+ # quotes, otherwise escape with double quotes. If url
+ # contains both a single quote and a double quote, XML
+ # standard is being violated.
+ if '"' in system_url:
+ quoted_system_url = f"'{system_url}'"
+ else:
+ quoted_system_url = f'"{system_url}"'
+ if public_id:
+ if system_url:
+ return f''
+ else:
+ return f''
+ elif system_url:
+ return f''
+ elif self._doc.hasdoctype():
+ return f''
+ else:
+ return ''
+
+ @property
+ def internalDTD(self):
+ """Returns a DTD validator based on the internal subset of the document."""
+ return _dtdFactory(self._doc._c_doc.intSubset)
+
+ @property
+ def externalDTD(self):
+ """Returns a DTD validator based on the external subset of the document."""
+ return _dtdFactory(self._doc._c_doc.extSubset)
+
+
+@cython.no_gc_clear
+cdef public class _Element [ type LxmlElementType, object LxmlElement ]:
+ """Element class.
+
+ References a document object and a libxml node.
+
+ By pointing to a Document instance, a reference is kept to
+ _Document as long as there is some pointer to a node in it.
+ """
+ cdef _Document _doc
+ cdef xmlNode* _c_node
+ cdef object _tag
+
+ def _init(self):
+ """_init(self)
+
+ Called after object initialisation. Custom subclasses may override
+ this if they recursively call _init() in the superclasses.
+ """
+
+ @cython.linetrace(False)
+ @cython.profile(False)
+ def __dealloc__(self):
+ #print("trying to free node:", self._c_node)
+ #displayNode(self._c_node, 0)
+ if self._c_node is not NULL:
+ _unregisterProxy(self)
+ attemptDeallocation(self._c_node)
+
+ # MANIPULATORS
+
+ def __setitem__(self, x, value):
+ """__setitem__(self, x, value)
+
+ Replaces the given subelement index or slice.
+ """
+ cdef xmlNode* c_node = NULL
+ cdef xmlNode* c_next
+ cdef xmlDoc* c_source_doc
+ cdef _Element element
+ cdef bint left_to_right
+ cdef Py_ssize_t slicelength = 0, step = 0
+ _assertValidNode(self)
+ if value is None:
+ raise ValueError, "cannot assign None"
+ if isinstance(x, slice):
+ # slice assignment
+ _findChildSlice(x, self._c_node, &c_node, &step, &slicelength)
+ if step > 0:
+ left_to_right = 1
+ else:
+ left_to_right = 0
+ step = -step
+ _replaceSlice(self, c_node, slicelength, step, left_to_right, value)
+ return
+ else:
+ # otherwise: normal item assignment
+ element = value
+ _assertValidNode(element)
+ c_node = _findChild(self._c_node, x)
+ if c_node is NULL:
+ raise IndexError, "list index out of range"
+ c_source_doc = element._c_node.doc
+ c_next = element._c_node.next
+ _removeText(c_node.next)
+ tree.xmlReplaceNode(c_node, element._c_node)
+ _moveTail(c_next, element._c_node)
+ moveNodeToDocument(self._doc, c_source_doc, element._c_node)
+ if not attemptDeallocation(c_node):
+ moveNodeToDocument(self._doc, c_node.doc, c_node)
+
+ def __delitem__(self, x):
+ """__delitem__(self, x)
+
+ Deletes the given subelement or a slice.
+ """
+ cdef xmlNode* c_node = NULL
+ cdef xmlNode* c_next
+ cdef Py_ssize_t step = 0, slicelength = 0
+ _assertValidNode(self)
+ if isinstance(x, slice):
+ # slice deletion
+ if _isFullSlice(x):
+ c_node = self._c_node.children
+ if c_node is not NULL:
+ if not _isElement(c_node):
+ c_node = _nextElement(c_node)
+ while c_node is not NULL:
+ c_next = _nextElement(c_node)
+ _removeNode(self._doc, c_node)
+ c_node = c_next
+ else:
+ _findChildSlice(x, self._c_node, &c_node, &step, &slicelength)
+ _deleteSlice(self._doc, c_node, slicelength, step)
+ else:
+ # item deletion
+ c_node = _findChild(self._c_node, x)
+ if c_node is NULL:
+ raise IndexError, f"index out of range: {x}"
+ _removeNode(self._doc, c_node)
+
+ def __deepcopy__(self, memo):
+ "__deepcopy__(self, memo)"
+ return self.__copy__()
+
+ def __copy__(self):
+ "__copy__(self)"
+ cdef xmlDoc* c_doc
+ cdef xmlNode* c_node
+ cdef _Document new_doc
+ _assertValidNode(self)
+ c_doc = _copyDocRoot(self._doc._c_doc, self._c_node) # recursive
+ new_doc = _documentFactory(c_doc, self._doc._parser)
+ root = new_doc.getroot()
+ if root is not None:
+ return root
+ # Comment/PI
+ c_node = c_doc.children
+ while c_node is not NULL and c_node.type != self._c_node.type:
+ c_node = c_node.next
+ if c_node is NULL:
+ return None
+ return _elementFactory(new_doc, c_node)
+
+ def set(self, key, value):
+ """set(self, key, value)
+
+ Sets an element attribute.
+ In HTML documents (not XML or XHTML), the value None is allowed and creates
+ an attribute without value (just the attribute name).
+ """
+ _assertValidNode(self)
+ _setAttributeValue(self, key, value)
+
+ def append(self, _Element element not None):
+ """append(self, element)
+
+ Adds a subelement to the end of this element.
+ """
+ _assertValidNode(self)
+ _assertValidNode(element)
+ _appendChild(self, element)
+
+ def addnext(self, _Element element not None):
+ """addnext(self, element)
+
+ Adds the element as a following sibling directly after this
+ element.
+
+ This is normally used to set a processing instruction or comment after
+ the root node of a document. Note that tail text is automatically
+ discarded when adding at the root level.
+ """
+ _assertValidNode(self)
+ _assertValidNode(element)
+ if self._c_node.parent != NULL and not _isElement(self._c_node.parent):
+ if element._c_node.type not in (tree.XML_PI_NODE, tree.XML_COMMENT_NODE):
+ raise TypeError, "Only processing instructions and comments can be siblings of the root element"
+ element.tail = None
+ _appendSibling(self, element)
+
+ def addprevious(self, _Element element not None):
+ """addprevious(self, element)
+
+ Adds the element as a preceding sibling directly before this
+ element.
+
+ This is normally used to set a processing instruction or comment
+ before the root node of a document. Note that tail text is
+ automatically discarded when adding at the root level.
+ """
+ _assertValidNode(self)
+ _assertValidNode(element)
+ if self._c_node.parent != NULL and not _isElement(self._c_node.parent):
+ if element._c_node.type != tree.XML_PI_NODE:
+ if element._c_node.type != tree.XML_COMMENT_NODE:
+ raise TypeError, "Only processing instructions and comments can be siblings of the root element"
+ element.tail = None
+ _prependSibling(self, element)
+
+ def extend(self, elements):
+ """extend(self, elements)
+
+ Extends the current children by the elements in the iterable.
+ """
+ cdef _Element element
+ _assertValidNode(self)
+ for element in elements:
+ if element is None:
+ raise TypeError, "Node must not be None"
+ _assertValidNode(element)
+ _appendChild(self, element)
+
+ def clear(self, bint keep_tail=False):
+ """clear(self, keep_tail=False)
+
+ Resets an element. This function removes all subelements, clears
+ all attributes and sets the text and tail properties to None.
+
+ Pass ``keep_tail=True`` to leave the tail text untouched.
+ """
+ cdef xmlAttr* c_attr
+ cdef xmlAttr* c_attr_next
+ cdef xmlNode* c_node
+ cdef xmlNode* c_node_next
+ _assertValidNode(self)
+ c_node = self._c_node
+ # remove self.text and self.tail
+ _removeText(c_node.children)
+ if not keep_tail:
+ _removeText(c_node.next)
+ # remove all attributes
+ c_attr = c_node.properties
+ if c_attr:
+ c_node.properties = NULL
+ tree.xmlFreePropList(c_attr)
+ # remove all subelements
+ c_node = c_node.children
+ if c_node and not _isElement(c_node):
+ c_node = _nextElement(c_node)
+ while c_node is not NULL:
+ c_node_next = _nextElement(c_node)
+ _removeNode(self._doc, c_node)
+ c_node = c_node_next
+
+ def insert(self, index: int, _Element element not None):
+ """insert(self, index, element)
+
+ Inserts a subelement at the given position in this element
+ """
+ cdef xmlNode* c_node
+ cdef xmlNode* c_next
+ cdef xmlDoc* c_source_doc
+ _assertValidNode(self)
+ _assertValidNode(element)
+ c_node = _findChild(self._c_node, index)
+ if c_node is NULL:
+ _appendChild(self, element)
+ return
+ # prevent cycles
+ if _isAncestorOrSame(element._c_node, self._c_node):
+ raise ValueError("cannot append parent to itself")
+ c_source_doc = element._c_node.doc
+ c_next = element._c_node.next
+ tree.xmlAddPrevSibling(c_node, element._c_node)
+ _moveTail(c_next, element._c_node)
+ moveNodeToDocument(self._doc, c_source_doc, element._c_node)
+
+ def remove(self, _Element element not None):
+ """remove(self, element)
+
+ Removes a matching subelement. Unlike the find methods, this
+ method compares elements based on identity, not on tag value
+ or contents.
+ """
+ cdef xmlNode* c_node
+ cdef xmlNode* c_next
+ _assertValidNode(self)
+ _assertValidNode(element)
+ c_node = element._c_node
+ if c_node.parent is not self._c_node:
+ raise ValueError, "Element is not a child of this node."
+ c_next = element._c_node.next
+ tree.xmlUnlinkNode(c_node)
+ _moveTail(c_next, c_node)
+ # fix namespace declarations
+ moveNodeToDocument(self._doc, c_node.doc, c_node)
+
+ def replace(self, _Element old_element not None,
+ _Element new_element not None):
+ """replace(self, old_element, new_element)
+
+ Replaces a subelement with the element passed as second argument.
+ """
+ cdef xmlNode* c_old_node
+ cdef xmlNode* c_old_next
+ cdef xmlNode* c_new_node
+ cdef xmlNode* c_new_next
+ cdef xmlDoc* c_source_doc
+ _assertValidNode(self)
+ _assertValidNode(old_element)
+ _assertValidNode(new_element)
+ c_old_node = old_element._c_node
+ if c_old_node.parent is not self._c_node:
+ raise ValueError, "Element is not a child of this node."
+ c_new_node = new_element._c_node
+ # prevent cycles
+ if _isAncestorOrSame(c_new_node, self._c_node):
+ raise ValueError("cannot append parent to itself")
+ # replace node
+ c_old_next = c_old_node.next
+ c_new_next = c_new_node.next
+ c_source_doc = c_new_node.doc
+ tree.xmlReplaceNode(c_old_node, c_new_node)
+ _moveTail(c_new_next, c_new_node)
+ _moveTail(c_old_next, c_old_node)
+ moveNodeToDocument(self._doc, c_source_doc, c_new_node)
+ # fix namespace declarations
+ moveNodeToDocument(self._doc, c_old_node.doc, c_old_node)
+
+ # PROPERTIES
+ property tag:
+ """Element tag
+ """
+ def __get__(self):
+ if self._tag is not None:
+ return self._tag
+ _assertValidNode(self)
+ self._tag = _namespacedName(self._c_node)
+ return self._tag
+
+ def __set__(self, value):
+ cdef _BaseParser parser
+ _assertValidNode(self)
+ ns, name = _getNsTag(value)
+ parser = self._doc._parser
+ if parser is not None and parser._for_html:
+ _htmlTagValidOrRaise(name)
+ else:
+ _tagValidOrRaise(name)
+ self._tag = value
+ tree.xmlNodeSetName(self._c_node, _xcstr(name))
+ if ns is None:
+ self._c_node.ns = NULL
+ else:
+ self._doc._setNodeNs(self._c_node, _xcstr(ns))
+
+ @property
+ def attrib(self):
+ """Element attribute dictionary. Where possible, use get(), set(),
+ keys(), values() and items() to access element attributes.
+ """
+ return _Attrib.__new__(_Attrib, self)
+
+ property text:
+ """Text before the first subelement. This is either a string or
+ the value None, if there was no text.
+ """
+ def __get__(self):
+ _assertValidNode(self)
+ return _collectText(self._c_node.children)
+
+ def __set__(self, value):
+ _assertValidNode(self)
+ if isinstance(value, QName):
+ value = _resolveQNameText(self, value).decode('utf8')
+ _setNodeText(self._c_node, value)
+
+ # using 'del el.text' is the wrong thing to do
+ #def __del__(self):
+ # _setNodeText(self._c_node, None)
+
+ property tail:
+ """Text after this element's end tag, but before the next sibling
+ element's start tag. This is either a string or the value None, if
+ there was no text.
+ """
+ def __get__(self):
+ _assertValidNode(self)
+ return _collectText(self._c_node.next)
+
+ def __set__(self, value):
+ _assertValidNode(self)
+ _setTailText(self._c_node, value)
+
+ # using 'del el.tail' is the wrong thing to do
+ #def __del__(self):
+ # _setTailText(self._c_node, None)
+
+ # not in ElementTree, read-only
+ @property
+ def prefix(self):
+ """Namespace prefix or None.
+ """
+ if self._c_node.ns is not NULL:
+ if self._c_node.ns.prefix is not NULL:
+ return funicode(self._c_node.ns.prefix)
+ return None
+
+ # not in ElementTree, read-only
+ property sourceline:
+ """Original line number as found by the parser or None if unknown.
+ """
+ def __get__(self):
+ cdef long line
+ _assertValidNode(self)
+ line = tree.xmlGetLineNo(self._c_node)
+ return line if line > 0 else None
+
+ def __set__(self, line):
+ _assertValidNode(self)
+ if line <= 0:
+ self._c_node.line = 0
+ else:
+ self._c_node.line = line
+
+ # not in ElementTree, read-only
+ @property
+ def nsmap(self):
+ """Namespace prefix->URI mapping known in the context of this
+ Element. This includes all namespace declarations of the
+ parents.
+
+ Note that changing the returned dict has no effect on the Element.
+ """
+ _assertValidNode(self)
+ return _build_nsmap(self._c_node)
+
+ # not in ElementTree, read-only
+ property base:
+ """The base URI of the Element (xml:base or HTML base URL).
+ None if the base URI is unknown.
+
+ Note that the value depends on the URL of the document that
+ holds the Element if there is no xml:base attribute on the
+ Element or its ancestors.
+
+ Setting this property will set an xml:base attribute on the
+ Element, regardless of the document type (XML or HTML).
+ """
+ def __get__(self):
+ _assertValidNode(self)
+ c_base = tree.xmlNodeGetBase(self._doc._c_doc, self._c_node)
+ if c_base is NULL:
+ if self._doc._c_doc.URL is NULL:
+ return None
+ return _decodeFilename(self._doc._c_doc.URL)
+ try:
+ base = _decodeFilename(c_base)
+ finally:
+ tree.xmlFree(c_base)
+ return base
+
+ def __set__(self, url):
+ _assertValidNode(self)
+ if url is None:
+ c_base = NULL
+ else:
+ url = _encodeFilename(url)
+ c_base = _xcstr(url)
+ tree.xmlNodeSetBase(self._c_node, c_base)
+
+ # ACCESSORS
+ def __repr__(self):
+ "__repr__(self)"
+ return "" % (self.tag, id(self))
+
+ def __getitem__(self, x):
+ """Returns the subelement at the given position or the requested
+ slice.
+ """
+ cdef xmlNode* c_node = NULL
+ cdef Py_ssize_t step = 0, slicelength = 0
+ cdef Py_ssize_t c, i
+ cdef _node_to_node_function next_element
+ cdef list result
+ _assertValidNode(self)
+ if isinstance(x, slice):
+ # slicing
+ if _isFullSlice(x):
+ return _collectChildren(self)
+ _findChildSlice(x, self._c_node, &c_node, &step, &slicelength)
+ if c_node is NULL:
+ return []
+ if step > 0:
+ next_element = _nextElement
+ else:
+ step = -step
+ next_element = _previousElement
+ result = []
+ c = 0
+ while c_node is not NULL and c < slicelength:
+ result.append(_elementFactory(self._doc, c_node))
+ c += 1
+ for i in range(step):
+ c_node = next_element(c_node)
+ if c_node is NULL:
+ break
+ return result
+ else:
+ # indexing
+ c_node = _findChild(self._c_node, x)
+ if c_node is NULL:
+ raise IndexError, "list index out of range"
+ return _elementFactory(self._doc, c_node)
+
+ def __len__(self):
+ """__len__(self)
+
+ Returns the number of subelements.
+ """
+ _assertValidNode(self)
+ return _countElements(self._c_node.children)
+
+ def __bool__(self):
+ """__bool__(self)"""
+ import warnings
+ warnings.warn(
+ "Truth-testing of elements was a source of confusion and will always "
+ "return True in future versions. "
+ "Use specific 'len(elem)' or 'elem is not None' test instead.",
+ FutureWarning
+ )
+ # emulate old behaviour
+ _assertValidNode(self)
+ return _hasChild(self._c_node)
+
+ def __contains__(self, element):
+ "__contains__(self, element)"
+ cdef xmlNode* c_node
+ _assertValidNode(self)
+ if not isinstance(element, _Element):
+ return 0
+ c_node = (<_Element>element)._c_node
+ return c_node is not NULL and c_node.parent is self._c_node
+
+ def __iter__(self):
+ "__iter__(self)"
+ return ElementChildIterator(self)
+
+ def __reversed__(self):
+ "__reversed__(self)"
+ return ElementChildIterator(self, reversed=True)
+
+ def index(self, child: _Element, start: int = None, stop: int = None):
+ """index(self, child, start=None, stop=None)
+
+ Find the position of the child within the parent.
+
+ This method is not part of the original ElementTree API.
+ """
+ cdef Py_ssize_t k, l
+ cdef Py_ssize_t c_start, c_stop
+ cdef xmlNode* c_child
+ cdef xmlNode* c_start_node
+ _assertValidNode(self)
+ _assertValidNode(child)
+ c_child = child._c_node
+ if c_child.parent is not self._c_node:
+ raise ValueError, "Element is not a child of this node."
+
+ # handle the unbounded search straight away (normal case)
+ if stop is None and (start is None or start == 0):
+ k = 0
+ c_child = c_child.prev
+ while c_child is not NULL:
+ if _isElement(c_child):
+ k += 1
+ c_child = c_child.prev
+ return k
+
+ # check indices
+ if start is None:
+ c_start = 0
+ else:
+ c_start = start
+ if stop is None:
+ c_stop = 0
+ else:
+ c_stop = stop
+ if c_stop == 0 or \
+ c_start >= c_stop and (c_stop > 0 or c_start < 0):
+ raise ValueError, "list.index(x): x not in slice"
+
+ # for negative slice indices, check slice before searching index
+ if c_start < 0 or c_stop < 0:
+ # start from right, at most up to leftmost(c_start, c_stop)
+ if c_start < c_stop:
+ k = -c_start
+ else:
+ k = -c_stop
+ c_start_node = self._c_node.last
+ l = 1
+ while c_start_node != c_child and l < k:
+ if _isElement(c_start_node):
+ l += 1
+ c_start_node = c_start_node.prev
+ if c_start_node == c_child:
+ # found! before slice end?
+ if c_stop < 0 and l <= -c_stop:
+ raise ValueError, "list.index(x): x not in slice"
+ elif c_start < 0:
+ raise ValueError, "list.index(x): x not in slice"
+
+ # now determine the index backwards from child
+ c_child = c_child.prev
+ k = 0
+ if c_stop > 0:
+ # we can optimize: stop after c_stop elements if not found
+ while c_child != NULL and k < c_stop:
+ if _isElement(c_child):
+ k += 1
+ c_child = c_child.prev
+ if k < c_stop:
+ return k
+ else:
+ # traverse all
+ while c_child != NULL:
+ if _isElement(c_child):
+ k = k + 1
+ c_child = c_child.prev
+ if c_start > 0:
+ if k >= c_start:
+ return k
+ else:
+ return k
+ if c_start != 0 or c_stop != 0:
+ raise ValueError, "list.index(x): x not in slice"
+ else:
+ raise ValueError, "list.index(x): x not in list"
+
+ def get(self, key, default=None):
+ """get(self, key, default=None)
+
+ Gets an element attribute.
+ """
+ _assertValidNode(self)
+ return _getAttributeValue(self, key, default)
+
+ def keys(self):
+ """keys(self)
+
+ Gets a list of attribute names. The names are returned in an
+ arbitrary order (just like for an ordinary Python dictionary).
+ """
+ _assertValidNode(self)
+ return _collectAttributes(self._c_node, 1)
+
+ def values(self):
+ """values(self)
+
+ Gets element attribute values as a sequence of strings. The
+ attributes are returned in an arbitrary order.
+ """
+ _assertValidNode(self)
+ return _collectAttributes(self._c_node, 2)
+
+ def items(self):
+ """items(self)
+
+ Gets element attributes, as a sequence. The attributes are returned in
+ an arbitrary order.
+ """
+ _assertValidNode(self)
+ return _collectAttributes(self._c_node, 3)
+
+ def getchildren(self):
+ """getchildren(self)
+
+ Returns all direct children. The elements are returned in document
+ order.
+
+ :deprecated: Note that this method has been deprecated as of
+ ElementTree 1.3 and lxml 2.0. New code should use
+ ``list(element)`` or simply iterate over elements.
+ """
+ _assertValidNode(self)
+ return _collectChildren(self)
+
+ def getparent(self):
+ """getparent(self)
+
+ Returns the parent of this element or None for the root element.
+ """
+ cdef xmlNode* c_node
+ #_assertValidNode(self) # not needed
+ c_node = _parentElement(self._c_node)
+ if c_node is NULL:
+ return None
+ return _elementFactory(self._doc, c_node)
+
+ def getnext(self):
+ """getnext(self)
+
+ Returns the following sibling of this element or None.
+ """
+ cdef xmlNode* c_node
+ #_assertValidNode(self) # not needed
+ c_node = _nextElement(self._c_node)
+ if c_node is NULL:
+ return None
+ return _elementFactory(self._doc, c_node)
+
+ def getprevious(self):
+ """getprevious(self)
+
+ Returns the preceding sibling of this element or None.
+ """
+ cdef xmlNode* c_node
+ #_assertValidNode(self) # not needed
+ c_node = _previousElement(self._c_node)
+ if c_node is NULL:
+ return None
+ return _elementFactory(self._doc, c_node)
+
+ def itersiblings(self, tag=None, *tags, preceding=False):
+ """itersiblings(self, tag=None, *tags, preceding=False)
+
+ Iterate over the following or preceding siblings of this element.
+
+ The direction is determined by the 'preceding' keyword which
+ defaults to False, i.e. forward iteration over the following
+ siblings. When True, the iterator yields the preceding
+ siblings in reverse document order, i.e. starting right before
+ the current element and going backwards.
+
+ Can be restricted to find only elements with specific tags,
+ see `iter`.
+ """
+ if preceding:
+ if self._c_node and not self._c_node.prev:
+ return ITER_EMPTY
+ elif self._c_node and not self._c_node.next:
+ return ITER_EMPTY
+ if tag is not None:
+ tags += (tag,)
+ return SiblingsIterator(self, tags, preceding=preceding)
+
+ def iterancestors(self, tag=None, *tags):
+ """iterancestors(self, tag=None, *tags)
+
+ Iterate over the ancestors of this element (from parent to parent).
+
+ Can be restricted to find only elements with specific tags,
+ see `iter`.
+ """
+ if self._c_node and not self._c_node.parent:
+ return ITER_EMPTY
+ if tag is not None:
+ tags += (tag,)
+ return AncestorsIterator(self, tags)
+
+ def iterdescendants(self, tag=None, *tags):
+ """iterdescendants(self, tag=None, *tags)
+
+ Iterate over the descendants of this element in document order.
+
+ As opposed to ``el.iter()``, this iterator does not yield the element
+ itself. The returned elements can be restricted to find only elements
+ with specific tags, see `iter`.
+ """
+ if self._c_node and not self._c_node.children:
+ return ITER_EMPTY
+ if tag is not None:
+ tags += (tag,)
+ return ElementDepthFirstIterator(self, tags, inclusive=False)
+
+ def iterchildren(self, tag=None, *tags, reversed=False):
+ """iterchildren(self, tag=None, *tags, reversed=False)
+
+ Iterate over the children of this element.
+
+ As opposed to using normal iteration on this element, the returned
+ elements can be reversed with the 'reversed' keyword and restricted
+ to find only elements with specific tags, see `iter`.
+ """
+ if self._c_node and not self._c_node.children:
+ return ITER_EMPTY
+ if tag is not None:
+ tags += (tag,)
+ return ElementChildIterator(self, tags, reversed=reversed)
+
+ def getroottree(self):
+ """getroottree(self)
+
+ Return an ElementTree for the root node of the document that
+ contains this element.
+
+ This is the same as following element.getparent() up the tree until it
+ returns None (for the root element) and then build an ElementTree for
+ the last parent that was returned."""
+ _assertValidDoc(self._doc)
+ return _elementTreeFactory(self._doc, None)
+
+ def getiterator(self, tag=None, *tags):
+ """getiterator(self, tag=None, *tags)
+
+ Returns a sequence or iterator of all elements in the subtree in
+ document order (depth first pre-order), starting with this
+ element.
+
+ Can be restricted to find only elements with specific tags,
+ see `iter`.
+
+ :deprecated: Note that this method is deprecated as of
+ ElementTree 1.3 and lxml 2.0. It returns an iterator in
+ lxml, which diverges from the original ElementTree
+ behaviour. If you want an efficient iterator, use the
+ ``element.iter()`` method instead. You should only use this
+ method in new code if you require backwards compatibility
+ with older versions of lxml or ElementTree.
+ """
+ if tag is not None:
+ tags += (tag,)
+ return ElementDepthFirstIterator(self, tags)
+
+ def iter(self, tag=None, *tags):
+ """iter(self, tag=None, *tags)
+
+ Iterate over all elements in the subtree in document order (depth
+ first pre-order), starting with this element.
+
+ Can be restricted to find only elements with specific tags:
+ pass ``"{ns}localname"`` as tag. Either or both of ``ns`` and
+ ``localname`` can be ``*`` for a wildcard; ``ns`` can be empty
+ for no namespace. ``"localname"`` is equivalent to ``"{}localname"``
+ (i.e. no namespace) but ``"*"`` is ``"{*}*"`` (any or no namespace),
+ not ``"{}*"``.
+
+ You can also pass the Element, Comment, ProcessingInstruction and
+ Entity factory functions to look only for the specific element type.
+
+ Passing multiple tags (or a sequence of tags) instead of a single tag
+ will let the iterator return all elements matching any of these tags,
+ in document order.
+ """
+ if tag is not None:
+ tags += (tag,)
+ return ElementDepthFirstIterator(self, tags)
+
+ def itertext(self, tag=None, *tags, with_tail=True):
+ """itertext(self, tag=None, *tags, with_tail=True)
+
+ Iterates over the text content of a subtree.
+
+ You can pass tag names to restrict text content to specific elements,
+ see `iter`.
+
+ You can set the ``with_tail`` keyword argument to ``False`` to skip
+ over tail text.
+ """
+ if tag is not None:
+ tags += (tag,)
+ return ElementTextIterator(self, tags, with_tail=with_tail)
+
+ def makeelement(self, _tag, attrib=None, nsmap=None, **_extra):
+ """makeelement(self, _tag, attrib=None, nsmap=None, **_extra)
+
+ Creates a new element associated with the same document.
+ """
+ _assertValidDoc(self._doc)
+ return _makeElement(_tag, NULL, self._doc, None, None, None,
+ attrib, nsmap, _extra)
+
+ def find(self, path, namespaces=None):
+ """find(self, path, namespaces=None)
+
+ Finds the first matching subelement, by tag name or path.
+
+ The optional ``namespaces`` argument accepts a
+ prefix-to-namespace mapping that allows the usage of XPath
+ prefixes in the path expression.
+ """
+ if isinstance(path, QName):
+ path = (path).text
+ return _elementpath.find(self, path, namespaces, with_prefixes=not _isHtmlDocument(self))
+
+ def findtext(self, path, default=None, namespaces=None):
+ """findtext(self, path, default=None, namespaces=None)
+
+ Finds text for the first matching subelement, by tag name or path.
+
+ The optional ``namespaces`` argument accepts a
+ prefix-to-namespace mapping that allows the usage of XPath
+ prefixes in the path expression.
+ """
+ if isinstance(path, QName):
+ path = (path).text
+ return _elementpath.findtext(self, path, default, namespaces, with_prefixes=not _isHtmlDocument(self))
+
+ def findall(self, path, namespaces=None):
+ """findall(self, path, namespaces=None)
+
+ Finds all matching subelements, by tag name or path.
+
+ The optional ``namespaces`` argument accepts a
+ prefix-to-namespace mapping that allows the usage of XPath
+ prefixes in the path expression.
+ """
+ if isinstance(path, QName):
+ path = (path).text
+ return _elementpath.findall(self, path, namespaces, with_prefixes=not _isHtmlDocument(self))
+
+ def iterfind(self, path, namespaces=None):
+ """iterfind(self, path, namespaces=None)
+
+ Iterates over all matching subelements, by tag name or path.
+
+ The optional ``namespaces`` argument accepts a
+ prefix-to-namespace mapping that allows the usage of XPath
+ prefixes in the path expression.
+ """
+ if isinstance(path, QName):
+ path = (path).text
+ return _elementpath.iterfind(self, path, namespaces, with_prefixes=not _isHtmlDocument(self))
+
+ def xpath(self, _path, *, namespaces=None, extensions=None,
+ smart_strings=True, **_variables):
+ """xpath(self, _path, namespaces=None, extensions=None, smart_strings=True, **_variables)
+
+ Evaluate an xpath expression using the element as context node.
+ """
+ evaluator = XPathElementEvaluator(self, namespaces=namespaces,
+ extensions=extensions,
+ smart_strings=smart_strings)
+ return evaluator(_path, **_variables)
+
+ def cssselect(self, expr, *, translator='xml'):
+ """
+ Run the CSS expression on this element and its children,
+ returning a list of the results.
+
+ Equivalent to lxml.cssselect.CSSSelect(expr)(self) -- note
+ that pre-compiling the expression can provide a substantial
+ speedup.
+ """
+ # Do the import here to make the dependency optional.
+ from lxml.cssselect import CSSSelector
+ return CSSSelector(expr, translator=translator)(self)
+
+
+cdef extern from "includes/etree_defs.h":
+ # macro call to 't->tp_new()' for fast instantiation
+ cdef object NEW_ELEMENT "PY_NEW" (object t)
+
+
+@cython.linetrace(False)
+cdef _Element _elementFactory(_Document doc, xmlNode* c_node):
+ cdef _Element result
+ result = getProxy(c_node)
+ if result is not None:
+ return result
+ if c_node is NULL:
+ return None
+
+ element_class = LOOKUP_ELEMENT_CLASS(
+ ELEMENT_CLASS_LOOKUP_STATE, doc, c_node)
+ if hasProxy(c_node):
+ # prevent re-entry race condition - we just called into Python
+ return getProxy(c_node)
+ result = NEW_ELEMENT(element_class)
+ if hasProxy(c_node):
+ # prevent re-entry race condition - we just called into Python
+ result._c_node = NULL
+ return getProxy(c_node)
+
+ _registerProxy(result, doc, c_node)
+ if element_class is not _Element:
+ result._init()
+ return result
+
+
+@cython.internal
+cdef class __ContentOnlyElement(_Element):
+ cdef int _raiseImmutable(self) except -1:
+ raise TypeError, "this element does not have children or attributes"
+
+ def set(self, key, value):
+ "set(self, key, value)"
+ self._raiseImmutable()
+
+ def append(self, value):
+ "append(self, value)"
+ self._raiseImmutable()
+
+ def insert(self, index, value):
+ "insert(self, index, value)"
+ self._raiseImmutable()
+
+ def __setitem__(self, index, value):
+ "__setitem__(self, index, value)"
+ self._raiseImmutable()
+
+ @property
+ def attrib(self):
+ return IMMUTABLE_EMPTY_MAPPING
+
+ property text:
+ def __get__(self):
+ _assertValidNode(self)
+ return funicodeOrEmpty(self._c_node.content)
+
+ def __set__(self, value):
+ cdef tree.xmlDict* c_dict
+ _assertValidNode(self)
+ if value is None:
+ c_text = NULL
+ else:
+ value = _utf8(value)
+ c_text = _xcstr(value)
+ tree.xmlNodeSetContent(self._c_node, c_text)
+
+ # ACCESSORS
+ def __getitem__(self, x):
+ "__getitem__(self, x)"
+ if isinstance(x, slice):
+ return []
+ else:
+ raise IndexError, "list index out of range"
+
+ def __len__(self):
+ "__len__(self)"
+ return 0
+
+ def get(self, key, default=None):
+ "get(self, key, default=None)"
+ return None
+
+ def keys(self):
+ "keys(self)"
+ return []
+
+ def items(self):
+ "items(self)"
+ return []
+
+ def values(self):
+ "values(self)"
+ return []
+
+cdef class _Comment(__ContentOnlyElement):
+ @property
+ def tag(self):
+ return Comment
+
+ def __repr__(self):
+ return "" % self.text
+
+cdef class _ProcessingInstruction(__ContentOnlyElement):
+ @property
+ def tag(self):
+ return ProcessingInstruction
+
+ property target:
+ # not in ElementTree
+ def __get__(self):
+ _assertValidNode(self)
+ return funicode(self._c_node.name)
+
+ def __set__(self, value):
+ _assertValidNode(self)
+ value = _utf8(value)
+ c_text = _xcstr(value)
+ tree.xmlNodeSetName(self._c_node, c_text)
+
+ def __repr__(self):
+ text = self.text
+ if text:
+ return "" % (self.target, text)
+ else:
+ return "" % self.target
+
+ def get(self, key, default=None):
+ """get(self, key, default=None)
+
+ Try to parse pseudo-attributes from the text content of the
+ processing instruction, search for one with the given key as
+ name and return its associated value.
+
+ Note that this is only a convenience method for the most
+ common case that all text content is structured in
+ attribute-like name-value pairs with properly quoted values.
+ It is not guaranteed to work for all possible text content.
+ """
+ return self.attrib.get(key, default)
+
+ @property
+ def attrib(self):
+ """Returns a dict containing all pseudo-attributes that can be
+ parsed from the text content of this processing instruction.
+ Note that modifying the dict currently has no effect on the
+ XML node, although this is not guaranteed to stay this way.
+ """
+ return { attr : (value1 or value2)
+ for attr, value1, value2 in _FIND_PI_ATTRIBUTES(' ' + self.text) }
+
+cdef object _FIND_PI_ATTRIBUTES = re.compile(r'\s+(\w+)\s*=\s*(?:\'([^\']*)\'|"([^"]*)")', re.U).findall
+
+cdef class _Entity(__ContentOnlyElement):
+ @property
+ def tag(self):
+ return Entity
+
+ property name:
+ # not in ElementTree
+ def __get__(self):
+ _assertValidNode(self)
+ return funicode(self._c_node.name)
+
+ def __set__(self, value):
+ _assertValidNode(self)
+ value_utf = _utf8(value)
+ if b'&' in value_utf or b';' in value_utf:
+ raise ValueError, f"Invalid entity name '{value}'"
+ tree.xmlNodeSetName(self._c_node, _xcstr(value_utf))
+
+ @property
+ def text(self):
+ # FIXME: should this be None or '&[VALUE];' or the resolved
+ # entity value ?
+ _assertValidNode(self)
+ return f'&{funicode(self._c_node.name)};'
+
+ def __repr__(self):
+ return "&%s;" % self.name
+
+
+cdef class QName:
+ """QName(text_or_uri_or_element, tag=None)
+
+ QName wrapper for qualified XML names.
+
+ Pass a tag name by itself or a namespace URI and a tag name to
+ create a qualified name. Alternatively, pass an Element to
+ extract its tag name. ``None`` as first argument is ignored in
+ order to allow for generic 2-argument usage.
+
+ The ``text`` property holds the qualified name in
+ ``{namespace}tagname`` notation. The ``namespace`` and
+ ``localname`` properties hold the respective parts of the tag
+ name.
+
+ You can pass QName objects wherever a tag name is expected. Also,
+ setting Element text from a QName will resolve the namespace prefix
+ on assignment and set a qualified text value. This is helpful in XML
+ languages like SOAP or XML-Schema that use prefixed tag names in
+ their text content.
+ """
+ cdef readonly unicode text
+ cdef readonly unicode localname
+ cdef readonly unicode namespace
+ def __init__(self, text_or_uri_or_element, tag=None):
+ if text_or_uri_or_element is None:
+ # Allow None as no namespace.
+ text_or_uri_or_element, tag = tag, None
+ if not _isString(text_or_uri_or_element):
+ if isinstance(text_or_uri_or_element, _Element):
+ text_or_uri_or_element = (<_Element>text_or_uri_or_element).tag
+ if not _isString(text_or_uri_or_element):
+ raise ValueError, f"Invalid input tag of type {type(text_or_uri_or_element)!r}"
+ elif isinstance(text_or_uri_or_element, QName):
+ text_or_uri_or_element = (text_or_uri_or_element).text
+ elif text_or_uri_or_element is not None:
+ text_or_uri_or_element = unicode(text_or_uri_or_element)
+ else:
+ raise ValueError, f"Invalid input tag of type {type(text_or_uri_or_element)!r}"
+
+ ns_utf, tag_utf = _getNsTag(text_or_uri_or_element)
+ if tag is not None:
+ # either ('ns', 'tag') or ('{ns}oldtag', 'newtag')
+ if ns_utf is None:
+ ns_utf = tag_utf # case 1: namespace ended up as tag name
+ tag_utf = _utf8(tag)
+ _tagValidOrRaise(tag_utf)
+ self.localname = (tag_utf).decode('utf8')
+ if ns_utf is None:
+ self.namespace = None
+ self.text = self.localname
+ else:
+ self.namespace = (ns_utf).decode('utf8')
+ self.text = "{%s}%s" % (self.namespace, self.localname)
+ def __str__(self):
+ return self.text
+ def __hash__(self):
+ return hash(self.text)
+ def __richcmp__(self, other, int op):
+ try:
+ if type(other) is QName:
+ other = (other).text
+ elif not isinstance(other, unicode):
+ other = unicode(other)
+ except (ValueError, UnicodeDecodeError):
+ return NotImplemented
+ return python.PyObject_RichCompare(self.text, other, op)
+
+
+cdef public class _ElementTree [ type LxmlElementTreeType,
+ object LxmlElementTree ]:
+ cdef _Document _doc
+ cdef _Element _context_node
+
+ # Note that _doc is only used to store the original document if we do not
+ # have a _context_node. All methods should prefer self._context_node._doc
+ # to honour tree restructuring. _doc can happily be None!
+
+ @cython.final
+ cdef int _assertHasRoot(self) except -1:
+ """We have to take care here: the document may not have a root node!
+ This can happen if ElementTree() is called without any argument and
+ the caller 'forgets' to call parse() afterwards, so this is a bug in
+ the caller program.
+ """
+ assert self._context_node is not None, \
+ "ElementTree not initialized, missing root"
+ return 0
+
+ def parse(self, source, _BaseParser parser=None, *, base_url=None):
+ """parse(self, source, parser=None, base_url=None)
+
+ Updates self with the content of source and returns its root.
+ """
+ cdef _Document doc = None
+ try:
+ doc = _parseDocument(source, parser, base_url)
+ except _TargetParserResult as result_container:
+ # raises a TypeError if we don't get an _Element
+ self._context_node = result_container.result
+ else:
+ self._context_node = doc.getroot()
+ self._doc = None if self._context_node is not None else doc
+ return self._context_node
+
+ def _setroot(self, _Element root not None):
+ """_setroot(self, root)
+
+ Relocate the ElementTree to a new root node.
+ """
+ _assertValidNode(root)
+ if root._c_node.type != tree.XML_ELEMENT_NODE:
+ raise TypeError, "Only elements can be the root of an ElementTree"
+ self._context_node = root
+ self._doc = None
+
+ def getroot(self):
+ """getroot(self)
+
+ Gets the root element for this tree.
+ """
+ return self._context_node
+
+ def __copy__(self):
+ return _elementTreeFactory(self._doc, self._context_node)
+
+ def __deepcopy__(self, memo):
+ cdef _Element root
+ cdef _Document doc
+ cdef xmlDoc* c_doc
+ if self._context_node is not None:
+ root = self._context_node.__copy__()
+ assert root is not None
+ _assertValidNode(root)
+ _copyNonElementSiblings(self._context_node._c_node, root._c_node)
+ return _elementTreeFactory(None, root)
+ elif self._doc is not None:
+ _assertValidDoc(self._doc)
+ c_doc = tree.xmlCopyDoc(self._doc._c_doc, 1)
+ if c_doc is NULL:
+ raise MemoryError()
+ doc = _documentFactory(c_doc, self._doc._parser)
+ return _elementTreeFactory(doc, None)
+ else:
+ # so what ...
+ return self
+
+ # not in ElementTree
+ @property
+ def docinfo(self) -> DocInfo:
+ """Information about the document provided by parser and DTD."""
+ self._assertHasRoot()
+ return DocInfo(self._context_node._doc)
+
+ # not in ElementTree, read-only
+ @property
+ def parser(self):
+ """The parser that was used to parse the document in this ElementTree.
+ """
+ if self._context_node is not None and \
+ self._context_node._doc is not None:
+ return self._context_node._doc._parser
+ if self._doc is not None:
+ return self._doc._parser
+ return None
+
+ def write(self, file, *, encoding=None, method="xml",
+ bint pretty_print=False, xml_declaration=None, bint with_tail=True,
+ standalone=None, doctype=None, compression=0,
+ bint exclusive=False, inclusive_ns_prefixes=None,
+ bint with_comments=True, bint strip_text=False,
+ docstring=None):
+ """write(self, file, encoding=None, method="xml",
+ pretty_print=False, xml_declaration=None, with_tail=True,
+ standalone=None, doctype=None, compression=0,
+ exclusive=False, inclusive_ns_prefixes=None,
+ with_comments=True, strip_text=False)
+
+ Write the tree to a filename, file or file-like object.
+
+ Defaults to ASCII encoding and writing a declaration as needed.
+
+ The keyword argument 'method' selects the output method:
+ 'xml', 'html', 'text', 'c14n' or 'c14n2'. Default is 'xml'.
+
+ With ``method="c14n"`` (C14N version 1), the options ``exclusive``,
+ ``with_comments`` and ``inclusive_ns_prefixes`` request exclusive
+ C14N, include comments, and list the inclusive prefixes respectively.
+
+ With ``method="c14n2"`` (C14N version 2), the ``with_comments`` and
+ ``strip_text`` options control the output of comments and text space
+ according to C14N 2.0.
+
+ Passing a boolean value to the ``standalone`` option will
+ output an XML declaration with the corresponding
+ ``standalone`` flag.
+
+ The ``doctype`` option allows passing in a plain string that will
+ be serialised before the XML tree. Note that passing in non
+ well-formed content here will make the XML output non well-formed.
+ Also, an existing doctype in the document tree will not be removed
+ when serialising an ElementTree instance.
+
+ The ``compression`` option enables GZip compression level 1-9.
+
+ The ``inclusive_ns_prefixes`` should be a list of namespace strings
+ (i.e. ['xs', 'xsi']) that will be promoted to the top-level element
+ during exclusive C14N serialisation. This parameter is ignored if
+ exclusive mode=False.
+
+ If exclusive=True and no list is provided, a namespace will only be
+ rendered if it is used by the immediate parent or one of its attributes
+ and its prefix and values have not already been rendered by an ancestor
+ of the namespace node's parent element.
+ """
+ cdef bint write_declaration
+ cdef int is_standalone
+
+ self._assertHasRoot()
+ _assertValidNode(self._context_node)
+ if compression is None or compression < 0:
+ compression = 0
+
+ # C14N serialisation
+ if method in ('c14n', 'c14n2'):
+ if encoding is not None:
+ raise ValueError("Cannot specify encoding with C14N")
+ if xml_declaration:
+ raise ValueError("Cannot enable XML declaration in C14N")
+
+ if method == 'c14n':
+ _tofilelikeC14N(file, self._context_node, exclusive, with_comments,
+ compression, inclusive_ns_prefixes)
+ else: # c14n2
+ with _open_utf8_file(file, compression=compression) as f:
+ target = C14NWriterTarget(
+ f.write, with_comments=with_comments, strip_text=strip_text)
+ _tree_to_target(self, target)
+ return
+
+ if not with_comments:
+ raise ValueError("Can only discard comments in C14N serialisation")
+ # suppress decl. in default case (purely for ElementTree compatibility)
+ if xml_declaration is not None:
+ write_declaration = xml_declaration
+ if encoding is None:
+ encoding = 'ASCII'
+ else:
+ encoding = encoding.upper()
+ elif encoding is None:
+ encoding = 'ASCII'
+ write_declaration = 0
+ else:
+ encoding = encoding.upper()
+ write_declaration = encoding not in (
+ 'US-ASCII', 'ASCII', 'UTF8', 'UTF-8')
+ if standalone is None:
+ is_standalone = -1
+ elif standalone:
+ write_declaration = 1
+ is_standalone = 1
+ else:
+ write_declaration = 1
+ is_standalone = 0
+
+ if docstring is not None and doctype is None:
+ import warnings
+ warnings.warn(
+ "The 'docstring' option is deprecated. Use 'doctype' instead.",
+ DeprecationWarning)
+ doctype = docstring
+
+ _tofilelike(file, self._context_node, encoding, doctype, method,
+ write_declaration, 1, pretty_print, with_tail,
+ is_standalone, compression)
+
+ def getpath(self, _Element element not None):
+ """getpath(self, element)
+
+ Returns a structural, absolute XPath expression to find the element.
+
+ For namespaced elements, the expression uses prefixes from the
+ document, which therefore need to be provided in order to make any
+ use of the expression in XPath.
+
+ Also see the method getelementpath(self, element), which returns a
+ self-contained ElementPath expression.
+ """
+ cdef _Document doc
+ cdef _Element root
+ cdef xmlDoc* c_doc
+ _assertValidNode(element)
+ if self._context_node is not None:
+ root = self._context_node
+ doc = root._doc
+ elif self._doc is not None:
+ doc = self._doc
+ root = doc.getroot()
+ else:
+ raise ValueError, "Element is not in this tree."
+ _assertValidDoc(doc)
+ _assertValidNode(root)
+ if element._doc is not doc:
+ raise ValueError, "Element is not in this tree."
+
+ c_doc = _fakeRootDoc(doc._c_doc, root._c_node)
+ c_path = tree.xmlGetNodePath(element._c_node)
+ _destroyFakeDoc(doc._c_doc, c_doc)
+ if c_path is NULL:
+ raise MemoryError()
+ path = funicode(c_path)
+ tree.xmlFree(c_path)
+ return path
+
+ def getelementpath(self, _Element element not None):
+ """getelementpath(self, element)
+
+ Returns a structural, absolute ElementPath expression to find the
+ element. This path can be used in the .find() method to look up
+ the element, provided that the elements along the path and their
+ list of immediate children were not modified in between.
+
+ ElementPath has the advantage over an XPath expression (as returned
+ by the .getpath() method) that it does not require additional prefix
+ declarations. It is always self-contained.
+ """
+ cdef _Element root
+ cdef Py_ssize_t count
+ _assertValidNode(element)
+ if element._c_node.type != tree.XML_ELEMENT_NODE:
+ raise ValueError, "input is not an Element"
+ if self._context_node is not None:
+ root = self._context_node
+ elif self._doc is not None:
+ root = self._doc.getroot()
+ else:
+ raise ValueError, "Element is not in this tree"
+ _assertValidNode(root)
+ if element._doc is not root._doc:
+ raise ValueError, "Element is not in this tree"
+
+ path = []
+ c_element = element._c_node
+ while c_element is not root._c_node:
+ c_name = c_element.name
+ c_href = _getNs(c_element)
+ tag = _namespacedNameFromNsName(c_href, c_name)
+ if c_href is NULL:
+ c_href = b'' # no namespace (NULL is wildcard)
+ # use tag[N] if there are preceding siblings with the same tag
+ count = 0
+ c_node = c_element.prev
+ while c_node is not NULL:
+ if c_node.type == tree.XML_ELEMENT_NODE:
+ if _tagMatches(c_node, c_href, c_name):
+ count += 1
+ c_node = c_node.prev
+ if count:
+ tag = f'{tag}[{count+1}]'
+ else:
+ # use tag[1] if there are following siblings with the same tag
+ c_node = c_element.next
+ while c_node is not NULL:
+ if c_node.type == tree.XML_ELEMENT_NODE:
+ if _tagMatches(c_node, c_href, c_name):
+ tag += '[1]'
+ break
+ c_node = c_node.next
+
+ path.append(tag)
+ c_element = c_element.parent
+ if c_element is NULL or c_element.type != tree.XML_ELEMENT_NODE:
+ raise ValueError, "Element is not in this tree."
+ if not path:
+ return '.'
+ path.reverse()
+ return '/'.join(path)
+
+ def getiterator(self, tag=None, *tags):
+ """getiterator(self, *tags, tag=None)
+
+ Returns a sequence or iterator of all elements in document order
+ (depth first pre-order), starting with the root element.
+
+ Can be restricted to find only elements with specific tags,
+ see `_Element.iter`.
+
+ :deprecated: Note that this method is deprecated as of
+ ElementTree 1.3 and lxml 2.0. It returns an iterator in
+ lxml, which diverges from the original ElementTree
+ behaviour. If you want an efficient iterator, use the
+ ``tree.iter()`` method instead. You should only use this
+ method in new code if you require backwards compatibility
+ with older versions of lxml or ElementTree.
+ """
+ root = self.getroot()
+ if root is None:
+ return ITER_EMPTY
+ if tag is not None:
+ tags += (tag,)
+ return root.getiterator(*tags)
+
+ def iter(self, tag=None, *tags):
+ """iter(self, tag=None, *tags)
+
+ Creates an iterator for the root element. The iterator loops over
+ all elements in this tree, in document order. Note that siblings
+ of the root element (comments or processing instructions) are not
+ returned by the iterator.
+
+ Can be restricted to find only elements with specific tags,
+ see `_Element.iter`.
+ """
+ root = self.getroot()
+ if root is None:
+ return ITER_EMPTY
+ if tag is not None:
+ tags += (tag,)
+ return root.iter(*tags)
+
+ def find(self, path, namespaces=None):
+ """find(self, path, namespaces=None)
+
+ Finds the first toplevel element with given tag. Same as
+ ``tree.getroot().find(path)``.
+
+ The optional ``namespaces`` argument accepts a
+ prefix-to-namespace mapping that allows the usage of XPath
+ prefixes in the path expression.
+ """
+ self._assertHasRoot()
+ root = self.getroot()
+ if _isString(path):
+ if path[:1] == "/":
+ path = "." + path
+ from warnings import warn
+ warn(
+ "This search incorrectly ignores the root element, and will be "
+ "fixed in a future version. If you rely on the current "
+ f"behaviour, change it to {path!r}",
+ FutureWarning, stacklevel=1
+ )
+ return root.find(path, namespaces)
+
+ def findtext(self, path, default=None, namespaces=None):
+ """findtext(self, path, default=None, namespaces=None)
+
+ Finds the text for the first element matching the ElementPath
+ expression. Same as getroot().findtext(path)
+
+ The optional ``namespaces`` argument accepts a
+ prefix-to-namespace mapping that allows the usage of XPath
+ prefixes in the path expression.
+ """
+ self._assertHasRoot()
+ root = self.getroot()
+ if _isString(path):
+ if path[:1] == "/":
+ path = "." + path
+ from warnings import warn
+ warn(
+ "This search incorrectly ignores the root element, and will be "
+ "fixed in a future version. If you rely on the current "
+ f"behaviour, change it to {path!r}",
+ FutureWarning, stacklevel=1
+ )
+ return root.findtext(path, default, namespaces)
+
+ def findall(self, path, namespaces=None):
+ """findall(self, path, namespaces=None)
+
+ Finds all elements matching the ElementPath expression. Same as
+ getroot().findall(path).
+
+ The optional ``namespaces`` argument accepts a
+ prefix-to-namespace mapping that allows the usage of XPath
+ prefixes in the path expression.
+ """
+ self._assertHasRoot()
+ root = self.getroot()
+ if _isString(path):
+ if path[:1] == "/":
+ path = "." + path
+ from warnings import warn
+ warn(
+ "This search incorrectly ignores the root element, and will be "
+ "fixed in a future version. If you rely on the current "
+ f"behaviour, change it to {path!r}",
+ FutureWarning, stacklevel=1
+ )
+ return root.findall(path, namespaces)
+
+ def iterfind(self, path, namespaces=None):
+ """iterfind(self, path, namespaces=None)
+
+ Iterates over all elements matching the ElementPath expression.
+ Same as getroot().iterfind(path).
+
+ The optional ``namespaces`` argument accepts a
+ prefix-to-namespace mapping that allows the usage of XPath
+ prefixes in the path expression.
+ """
+ self._assertHasRoot()
+ root = self.getroot()
+ if _isString(path):
+ if path[:1] == "/":
+ path = "." + path
+ from warnings import warn
+ warn(
+ "This search incorrectly ignores the root element, and will be "
+ "fixed in a future version. If you rely on the current "
+ f"behaviour, change it to {path!r}",
+ FutureWarning, stacklevel=1
+ )
+ return root.iterfind(path, namespaces)
+
+ def xpath(self, _path, *, namespaces=None, extensions=None,
+ smart_strings=True, **_variables):
+ """xpath(self, _path, namespaces=None, extensions=None, smart_strings=True, **_variables)
+
+ XPath evaluate in context of document.
+
+ ``namespaces`` is an optional dictionary with prefix to namespace URI
+ mappings, used by XPath. ``extensions`` defines additional extension
+ functions.
+
+ Returns a list (nodeset), or bool, float or string.
+
+ In case of a list result, return Element for element nodes,
+ string for text and attribute values.
+
+ Note: if you are going to apply multiple XPath expressions
+ against the same document, it is more efficient to use
+ XPathEvaluator directly.
+ """
+ self._assertHasRoot()
+ evaluator = XPathDocumentEvaluator(self, namespaces=namespaces,
+ extensions=extensions,
+ smart_strings=smart_strings)
+ return evaluator(_path, **_variables)
+
+ def xslt(self, _xslt, extensions=None, access_control=None, **_kw):
+ """xslt(self, _xslt, extensions=None, access_control=None, **_kw)
+
+ Transform this document using other document.
+
+ xslt is a tree that should be XSLT
+ keyword parameters are XSLT transformation parameters.
+
+ Returns the transformed tree.
+
+ Note: if you are going to apply the same XSLT stylesheet against
+ multiple documents, it is more efficient to use the XSLT
+ class directly.
+ """
+ self._assertHasRoot()
+ style = XSLT(_xslt, extensions=extensions,
+ access_control=access_control)
+ return style(self, **_kw)
+
+ def relaxng(self, relaxng):
+ """relaxng(self, relaxng)
+
+ Validate this document using other document.
+
+ The relaxng argument is a tree that should contain a Relax NG schema.
+
+ Returns True or False, depending on whether validation
+ succeeded.
+
+ Note: if you are going to apply the same Relax NG schema against
+ multiple documents, it is more efficient to use the RelaxNG
+ class directly.
+ """
+ self._assertHasRoot()
+ schema = RelaxNG(relaxng)
+ return schema.validate(self)
+
+ def xmlschema(self, xmlschema):
+ """xmlschema(self, xmlschema)
+
+ Validate this document using other document.
+
+ The xmlschema argument is a tree that should contain an XML Schema.
+
+ Returns True or False, depending on whether validation
+ succeeded.
+
+ Note: If you are going to apply the same XML Schema against
+ multiple documents, it is more efficient to use the XMLSchema
+ class directly.
+ """
+ self._assertHasRoot()
+ schema = XMLSchema(xmlschema)
+ return schema.validate(self)
+
+ def xinclude(self):
+ """xinclude(self)
+
+ Process the XInclude nodes in this document and include the
+ referenced XML fragments.
+
+ There is support for loading files through the file system, HTTP and
+ FTP.
+
+ Note that XInclude does not support custom resolvers in Python space
+ due to restrictions of libxml2 <= 2.6.29.
+ """
+ self._assertHasRoot()
+ XInclude()(self._context_node)
+
+ def write_c14n(self, file, *, bint exclusive=False, bint with_comments=True,
+ compression=0, inclusive_ns_prefixes=None):
+ """write_c14n(self, file, exclusive=False, with_comments=True,
+ compression=0, inclusive_ns_prefixes=None)
+
+ C14N write of document. Always writes UTF-8.
+
+ The ``compression`` option enables GZip compression level 1-9.
+
+ The ``inclusive_ns_prefixes`` should be a list of namespace strings
+ (i.e. ['xs', 'xsi']) that will be promoted to the top-level element
+ during exclusive C14N serialisation. This parameter is ignored if
+ exclusive mode=False.
+
+ If exclusive=True and no list is provided, a namespace will only be
+ rendered if it is used by the immediate parent or one of its attributes
+ and its prefix and values have not already been rendered by an ancestor
+ of the namespace node's parent element.
+
+ NOTE: This method is deprecated as of lxml 4.4 and will be removed in a
+ future release. Use ``.write(f, method="c14n")`` instead.
+ """
+ self._assertHasRoot()
+ _assertValidNode(self._context_node)
+ if compression is None or compression < 0:
+ compression = 0
+
+ _tofilelikeC14N(file, self._context_node, exclusive, with_comments,
+ compression, inclusive_ns_prefixes)
+
+cdef _ElementTree _elementTreeFactory(_Document doc, _Element context_node):
+ return _newElementTree(doc, context_node, _ElementTree)
+
+cdef _ElementTree _newElementTree(_Document doc, _Element context_node,
+ object baseclass):
+ cdef _ElementTree result
+ result = baseclass()
+ if context_node is None and doc is not None:
+ context_node = doc.getroot()
+ if context_node is None:
+ _assertValidDoc(doc)
+ result._doc = doc
+ else:
+ _assertValidNode(context_node)
+ result._context_node = context_node
+ return result
+
+
+@cython.final
+@cython.freelist(16)
+cdef class _Attrib:
+ """A dict-like proxy for the ``Element.attrib`` property.
+ """
+ cdef _Element _element
+ def __cinit__(self, _Element element not None):
+ _assertValidNode(element)
+ self._element = element
+
+ # MANIPULATORS
+ def __setitem__(self, key, value):
+ _assertValidNode(self._element)
+ _setAttributeValue(self._element, key, value)
+
+ def __delitem__(self, key):
+ _assertValidNode(self._element)
+ _delAttribute(self._element, key)
+
+ def update(self, sequence_or_dict):
+ _assertValidNode(self._element)
+ if isinstance(sequence_or_dict, (dict, _Attrib)):
+ sequence_or_dict = sequence_or_dict.items()
+ for key, value in sequence_or_dict:
+ _setAttributeValue(self._element, key, value)
+
+ def pop(self, key, *default):
+ if len(default) > 1:
+ raise TypeError, f"pop expected at most 2 arguments, got {len(default)+1}"
+ _assertValidNode(self._element)
+ result = _getAttributeValue(self._element, key, None)
+ if result is None:
+ if not default:
+ raise KeyError, key
+ result = default[0]
+ else:
+ _delAttribute(self._element, key)
+ return result
+
+ def clear(self):
+ _assertValidNode(self._element)
+ c_attrs = self._element._c_node.properties
+ if c_attrs:
+ self._element._c_node.properties = NULL
+ tree.xmlFreePropList(c_attrs)
+
+ # ACCESSORS
+ def __repr__(self):
+ _assertValidNode(self._element)
+ return repr(dict( _collectAttributes(self._element._c_node, 3) ))
+
+ def __copy__(self):
+ _assertValidNode(self._element)
+ return dict(_collectAttributes(self._element._c_node, 3))
+
+ def __deepcopy__(self, memo):
+ _assertValidNode(self._element)
+ return dict(_collectAttributes(self._element._c_node, 3))
+
+ def __getitem__(self, key):
+ _assertValidNode(self._element)
+ result = _getAttributeValue(self._element, key, None)
+ if result is None:
+ raise KeyError, key
+ return result
+
+ def __bool__(self):
+ _assertValidNode(self._element)
+ cdef xmlAttr* c_attr = self._element._c_node.properties
+ while c_attr is not NULL:
+ if c_attr.type == tree.XML_ATTRIBUTE_NODE:
+ return 1
+ c_attr = c_attr.next
+ return 0
+
+ def __len__(self):
+ _assertValidNode(self._element)
+ cdef xmlAttr* c_attr = self._element._c_node.properties
+ cdef Py_ssize_t c = 0
+ while c_attr is not NULL:
+ if c_attr.type == tree.XML_ATTRIBUTE_NODE:
+ c += 1
+ c_attr = c_attr.next
+ return c
+
+ def get(self, key, default=None):
+ _assertValidNode(self._element)
+ return _getAttributeValue(self._element, key, default)
+
+ def keys(self):
+ _assertValidNode(self._element)
+ return _collectAttributes(self._element._c_node, 1)
+
+ def __iter__(self):
+ _assertValidNode(self._element)
+ return iter(_collectAttributes(self._element._c_node, 1))
+
+ def iterkeys(self):
+ _assertValidNode(self._element)
+ return iter(_collectAttributes(self._element._c_node, 1))
+
+ def values(self):
+ _assertValidNode(self._element)
+ return _collectAttributes(self._element._c_node, 2)
+
+ def itervalues(self):
+ _assertValidNode(self._element)
+ return iter(_collectAttributes(self._element._c_node, 2))
+
+ def items(self):
+ _assertValidNode(self._element)
+ return _collectAttributes(self._element._c_node, 3)
+
+ def iteritems(self):
+ _assertValidNode(self._element)
+ return iter(_collectAttributes(self._element._c_node, 3))
+
+ def has_key(self, key):
+ _assertValidNode(self._element)
+ return key in self
+
+ def __contains__(self, key):
+ _assertValidNode(self._element)
+ cdef xmlNode* c_node
+ ns, tag = _getNsTag(key)
+ c_node = self._element._c_node
+ c_href = NULL if ns is None else _xcstr(ns)
+ return 1 if tree.xmlHasNsProp(c_node, _xcstr(tag), c_href) else 0
+
+ def __richcmp__(self, other, int op):
+ try:
+ one = dict(self.items())
+ if not isinstance(other, dict):
+ other = dict(other)
+ except (TypeError, ValueError):
+ return NotImplemented
+ return python.PyObject_RichCompare(one, other, op)
+
+MutableMapping.register(_Attrib)
+
+
+@cython.final
+@cython.internal
+cdef class _AttribIterator:
+ """Attribute iterator - for internal use only!
+ """
+ # XML attributes must not be removed while running!
+ cdef _Element _node
+ cdef xmlAttr* _c_attr
+ cdef int _keysvalues # 1 - keys, 2 - values, 3 - items (key, value)
+ def __iter__(self):
+ return self
+
+ def __next__(self):
+ cdef xmlAttr* c_attr
+ if self._node is None:
+ raise StopIteration
+ c_attr = self._c_attr
+ while c_attr is not NULL and c_attr.type != tree.XML_ATTRIBUTE_NODE:
+ c_attr = c_attr.next
+ if c_attr is NULL:
+ self._node = None
+ raise StopIteration
+
+ self._c_attr = c_attr.next
+ if self._keysvalues == 1:
+ return _namespacedName(c_attr)
+ elif self._keysvalues == 2:
+ return _attributeValue(self._node._c_node, c_attr)
+ else:
+ return (_namespacedName(c_attr),
+ _attributeValue(self._node._c_node, c_attr))
+
+cdef object _attributeIteratorFactory(_Element element, int keysvalues):
+ cdef _AttribIterator attribs
+ if element._c_node.properties is NULL:
+ return ITER_EMPTY
+ attribs = _AttribIterator()
+ attribs._node = element
+ attribs._c_attr = element._c_node.properties
+ attribs._keysvalues = keysvalues
+ return attribs
+
+
+cdef public class _ElementTagMatcher [ object LxmlElementTagMatcher,
+ type LxmlElementTagMatcherType ]:
+ """
+ Dead but public. :)
+ """
+ cdef object _pystrings
+ cdef int _node_type
+ cdef char* _href
+ cdef char* _name
+ cdef _initTagMatch(self, tag):
+ self._href = NULL
+ self._name = NULL
+ if tag is None:
+ self._node_type = 0
+ elif tag is Comment:
+ self._node_type = tree.XML_COMMENT_NODE
+ elif tag is ProcessingInstruction:
+ self._node_type = tree.XML_PI_NODE
+ elif tag is Entity:
+ self._node_type = tree.XML_ENTITY_REF_NODE
+ elif tag is Element:
+ self._node_type = tree.XML_ELEMENT_NODE
+ else:
+ self._node_type = tree.XML_ELEMENT_NODE
+ self._pystrings = _getNsTag(tag)
+ if self._pystrings[0] is not None:
+ self._href = _cstr(self._pystrings[0])
+ self._name = _cstr(self._pystrings[1])
+ if self._name[0] == c'*' and self._name[1] == c'\0':
+ self._name = NULL
+
+cdef public class _ElementIterator(_ElementTagMatcher) [
+ object LxmlElementIterator, type LxmlElementIteratorType ]:
+ """
+ Dead but public. :)
+ """
+ # we keep Python references here to control GC
+ cdef _Element _node
+ cdef _node_to_node_function _next_element
+ def __iter__(self):
+ return self
+
+ cdef void _storeNext(self, _Element node):
+ cdef xmlNode* c_node
+ c_node = self._next_element(node._c_node)
+ while c_node is not NULL and \
+ self._node_type != 0 and \
+ (self._node_type != c_node.type or
+ not _tagMatches(c_node, self._href, self._name)):
+ c_node = self._next_element(c_node)
+ if c_node is NULL:
+ self._node = None
+ else:
+ # Python ref:
+ self._node = _elementFactory(node._doc, c_node)
+
+ def __next__(self):
+ cdef xmlNode* c_node
+ cdef _Element current_node
+ if self._node is None:
+ raise StopIteration
+ # Python ref:
+ current_node = self._node
+ self._storeNext(current_node)
+ return current_node
+
+@cython.final
+@cython.internal
+cdef class _MultiTagMatcher:
+ """
+ Match an xmlNode against a list of tags.
+ """
+ cdef list _py_tags
+ cdef qname* _cached_tags
+ cdef size_t _tag_count
+ cdef size_t _cached_size
+ cdef _Document _cached_doc
+ cdef int _node_types
+
+ def __cinit__(self, tags):
+ self._py_tags = []
+ self.initTagMatch(tags)
+
+ def __dealloc__(self):
+ self._clear()
+
+ cdef bint rejectsAll(self) noexcept:
+ return not self._tag_count and not self._node_types
+
+ cdef bint rejectsAllAttributes(self) noexcept:
+ return not self._tag_count
+
+ cdef bint matchesType(self, int node_type) noexcept:
+ if node_type == tree.XML_ELEMENT_NODE and self._tag_count:
+ return True
+ return self._node_types & (1 << node_type)
+
+ cdef void _clear(self) noexcept:
+ cdef size_t i, count
+ count = self._tag_count
+ self._tag_count = 0
+ if self._cached_tags:
+ for i in range(count):
+ cpython.ref.Py_XDECREF(self._cached_tags[i].href)
+ python.lxml_free(self._cached_tags)
+ self._cached_tags = NULL
+
+ cdef initTagMatch(self, tags):
+ self._cached_doc = None
+ del self._py_tags[:]
+ self._clear()
+ if tags is None or tags == ():
+ # no selection in tags argument => match anything
+ self._node_types = (
+ 1 << tree.XML_COMMENT_NODE |
+ 1 << tree.XML_PI_NODE |
+ 1 << tree.XML_ENTITY_REF_NODE |
+ 1 << tree.XML_ELEMENT_NODE)
+ else:
+ self._node_types = 0
+ self._storeTags(tags, set())
+
+ cdef _storeTags(self, tag, set seen):
+ if tag is Comment:
+ self._node_types |= 1 << tree.XML_COMMENT_NODE
+ elif tag is ProcessingInstruction:
+ self._node_types |= 1 << tree.XML_PI_NODE
+ elif tag is Entity:
+ self._node_types |= 1 << tree.XML_ENTITY_REF_NODE
+ elif tag is Element:
+ self._node_types |= 1 << tree.XML_ELEMENT_NODE
+ elif python._isString(tag):
+ if tag in seen:
+ return
+ seen.add(tag)
+ if tag in ('*', '{*}*'):
+ self._node_types |= 1 << tree.XML_ELEMENT_NODE
+ else:
+ href, name = _getNsTag(tag)
+ if name == b'*':
+ name = None
+ if href is None:
+ href = b'' # no namespace
+ elif href == b'*':
+ href = None # wildcard: any namespace, including none
+ self._py_tags.append((href, name))
+ elif isinstance(tag, QName):
+ self._storeTags(tag.text, seen)
+ else:
+ # support a sequence of tags
+ for item in tag:
+ self._storeTags(item, seen)
+
+ cdef inline int cacheTags(self, _Document doc, bint force_into_dict=False) except -1:
+ """
+ Look up the tag names in the doc dict to enable string pointer comparisons.
+ """
+ cdef size_t dict_size = tree.xmlDictSize(doc._c_doc.dict)
+ if doc is self._cached_doc and dict_size == self._cached_size:
+ # doc and dict didn't change => names already cached
+ return 0
+ self._tag_count = 0
+ if not self._py_tags:
+ self._cached_doc = doc
+ self._cached_size = dict_size
+ return 0
+ if not self._cached_tags:
+ self._cached_tags = python.lxml_malloc(len(self._py_tags), sizeof(qname))
+ if not self._cached_tags:
+ self._cached_doc = None
+ raise MemoryError()
+ self._tag_count = _mapTagsToQnameMatchArray(
+ doc._c_doc, self._py_tags, self._cached_tags, force_into_dict)
+ self._cached_doc = doc
+ self._cached_size = dict_size
+ return 0
+
+ cdef inline bint matches(self, xmlNode* c_node) noexcept:
+ cdef qname* c_qname
+ if self._node_types & (1 << c_node.type):
+ return True
+ elif c_node.type == tree.XML_ELEMENT_NODE:
+ for c_qname in self._cached_tags[:self._tag_count]:
+ if _tagMatchesExactly(c_node, c_qname):
+ return True
+ return False
+
+ cdef inline bint matchesNsTag(self, const_xmlChar* c_href,
+ const_xmlChar* c_name) noexcept:
+ cdef qname* c_qname
+ if self._node_types & (1 << tree.XML_ELEMENT_NODE):
+ return True
+ for c_qname in self._cached_tags[:self._tag_count]:
+ if _nsTagMatchesExactly(c_href, c_name, c_qname):
+ return True
+ return False
+
+ cdef inline bint matchesAttribute(self, xmlAttr* c_attr) noexcept:
+ """Attribute matches differ from Element matches in that they do
+ not care about node types.
+ """
+ cdef qname* c_qname
+ for c_qname in self._cached_tags[:self._tag_count]:
+ if _tagMatchesExactly(c_attr, c_qname):
+ return True
+ return False
+
+cdef class _ElementMatchIterator:
+ cdef _Element _node
+ cdef _node_to_node_function _next_element
+ cdef _MultiTagMatcher _matcher
+
+ @cython.final
+ cdef _initTagMatcher(self, tags):
+ self._matcher = _MultiTagMatcher.__new__(_MultiTagMatcher, tags)
+
+ def __iter__(self):
+ return self
+
+ @cython.final
+ cdef int _storeNext(self, _Element node) except -1:
+ self._matcher.cacheTags(node._doc)
+ c_node = self._next_element(node._c_node)
+ while c_node is not NULL and not self._matcher.matches(c_node):
+ c_node = self._next_element(c_node)
+ # store Python ref to next node to make sure it's kept alive
+ self._node = _elementFactory(node._doc, c_node) if c_node is not NULL else None
+ return 0
+
+ def __next__(self):
+ cdef _Element current_node = self._node
+ if current_node is None:
+ raise StopIteration
+ self._storeNext(current_node)
+ return current_node
+
+cdef class ElementChildIterator(_ElementMatchIterator):
+ """ElementChildIterator(self, node, tag=None, reversed=False)
+ Iterates over the children of an element.
+ """
+ def __cinit__(self, _Element node not None, tag=None, *, bint reversed=False):
+ cdef xmlNode* c_node
+ _assertValidNode(node)
+ self._initTagMatcher(tag)
+ if reversed:
+ c_node = _findChildBackwards(node._c_node, 0)
+ self._next_element = _previousElement
+ else:
+ c_node = _findChildForwards(node._c_node, 0)
+ self._next_element = _nextElement
+ self._matcher.cacheTags(node._doc)
+ while c_node is not NULL and not self._matcher.matches(c_node):
+ c_node = self._next_element(c_node)
+ # store Python ref to next node to make sure it's kept alive
+ self._node = _elementFactory(node._doc, c_node) if c_node is not NULL else None
+
+cdef class SiblingsIterator(_ElementMatchIterator):
+ """SiblingsIterator(self, node, tag=None, preceding=False)
+ Iterates over the siblings of an element.
+
+ You can pass the boolean keyword ``preceding`` to specify the direction.
+ """
+ def __cinit__(self, _Element node not None, tag=None, *, bint preceding=False):
+ _assertValidNode(node)
+ self._initTagMatcher(tag)
+ if preceding:
+ self._next_element = _previousElement
+ else:
+ self._next_element = _nextElement
+ self._storeNext(node)
+
+cdef class AncestorsIterator(_ElementMatchIterator):
+ """AncestorsIterator(self, node, tag=None)
+ Iterates over the ancestors of an element (from parent to parent).
+ """
+ def __cinit__(self, _Element node not None, tag=None):
+ _assertValidNode(node)
+ self._initTagMatcher(tag)
+ self._next_element = _parentElement
+ self._storeNext(node)
+
+cdef class ElementDepthFirstIterator:
+ """ElementDepthFirstIterator(self, node, tag=None, inclusive=True)
+ Iterates over an element and its sub-elements in document order (depth
+ first pre-order).
+
+ Note that this also includes comments, entities and processing
+ instructions. To filter them out, check if the ``tag`` property
+ of the returned element is a string (i.e. not None and not a
+ factory function), or pass the ``Element`` factory for the ``tag``
+ argument to receive only Elements.
+
+ If the optional ``tag`` argument is not None, the iterator returns only
+ the elements that match the respective name and namespace.
+
+ The optional boolean argument 'inclusive' defaults to True and can be set
+ to False to exclude the start element itself.
+
+ Note that the behaviour of this iterator is completely undefined if the
+ tree it traverses is modified during iteration.
+ """
+ # we keep Python references here to control GC
+ # keep the next Element after the one we return, and the (s)top node
+ cdef _Element _next_node
+ cdef _Element _top_node
+ cdef _MultiTagMatcher _matcher
+ def __cinit__(self, _Element node not None, tag=None, *, bint inclusive=True):
+ _assertValidNode(node)
+ self._top_node = node
+ self._next_node = node
+ self._matcher = _MultiTagMatcher.__new__(_MultiTagMatcher, tag)
+ self._matcher.cacheTags(node._doc)
+ if not inclusive or not self._matcher.matches(node._c_node):
+ # find start node (this cannot raise StopIteration, self._next_node != None)
+ next(self)
+
+ def __iter__(self):
+ return self
+
+ def __next__(self):
+ cdef xmlNode* c_node
+ cdef _Element current_node = self._next_node
+ if current_node is None:
+ raise StopIteration
+ c_node = current_node._c_node
+ self._matcher.cacheTags(current_node._doc)
+ if not self._matcher._tag_count:
+ # no tag name was found in the dict => not in document either
+ # try to match by node type
+ c_node = self._nextNodeAnyTag(c_node)
+ else:
+ c_node = self._nextNodeMatchTag(c_node)
+ if c_node is NULL:
+ self._next_node = None
+ else:
+ self._next_node = _elementFactory(current_node._doc, c_node)
+ return current_node
+
+ @cython.final
+ cdef xmlNode* _nextNodeAnyTag(self, xmlNode* c_node) noexcept:
+ cdef int node_types = self._matcher._node_types
+ if not node_types:
+ return NULL
+ tree.BEGIN_FOR_EACH_ELEMENT_FROM(self._top_node._c_node, c_node, 0)
+ if node_types & (1 << c_node.type):
+ return c_node
+ tree.END_FOR_EACH_ELEMENT_FROM(c_node)
+ return NULL
+
+ @cython.final
+ cdef xmlNode* _nextNodeMatchTag(self, xmlNode* c_node) noexcept:
+ tree.BEGIN_FOR_EACH_ELEMENT_FROM(self._top_node._c_node, c_node, 0)
+ if self._matcher.matches(c_node):
+ return c_node
+ tree.END_FOR_EACH_ELEMENT_FROM(c_node)
+ return NULL
+
+
+cdef class ElementTextIterator:
+ """ElementTextIterator(self, element, tag=None, with_tail=True)
+ Iterates over the text content of a subtree.
+
+ You can pass the ``tag`` keyword argument to restrict text content to a
+ specific tag name.
+
+ You can set the ``with_tail`` keyword argument to ``False`` to skip over
+ tail text (e.g. if you know that it's only whitespace from pretty-printing).
+ """
+ cdef object _events
+ cdef _Element _start_element
+ def __cinit__(self, _Element element not None, tag=None, *, bint with_tail=True):
+ _assertValidNode(element)
+ if with_tail:
+ events = ("start", "comment", "pi", "end")
+ else:
+ events = ("start",)
+ self._start_element = element
+ self._events = iterwalk(element, events=events, tag=tag)
+
+ def __iter__(self):
+ return self
+
+ def __next__(self):
+ cdef _Element element
+ result = None
+ while result is None:
+ event, element = next(self._events) # raises StopIteration
+ if event == "start":
+ result = element.text
+ elif element is not self._start_element:
+ result = element.tail
+ return result
+
+
+cdef xmlNode* _createElement(xmlDoc* c_doc, object name_utf) except NULL:
+ cdef xmlNode* c_node
+ c_node = tree.xmlNewDocNode(c_doc, NULL, _xcstr(name_utf), NULL)
+ return c_node
+
+cdef xmlNode* _createComment(xmlDoc* c_doc, const_xmlChar* text) noexcept:
+ cdef xmlNode* c_node
+ c_node = tree.xmlNewDocComment(c_doc, text)
+ return c_node
+
+cdef xmlNode* _createPI(xmlDoc* c_doc, const_xmlChar* target, const_xmlChar* text) noexcept:
+ cdef xmlNode* c_node
+ c_node = tree.xmlNewDocPI(c_doc, target, text)
+ return c_node
+
+cdef xmlNode* _createEntity(xmlDoc* c_doc, const_xmlChar* name) noexcept:
+ cdef xmlNode* c_node
+ c_node = tree.xmlNewReference(c_doc, name)
+ return c_node
+
+# module-level API for ElementTree
+
+def Element(_tag, attrib=None, nsmap=None, **_extra):
+ """Element(_tag, attrib=None, nsmap=None, **_extra)
+
+ Element factory. This function returns an object implementing the
+ Element interface.
+
+ Also look at the `_Element.makeelement()` and
+ `_BaseParser.makeelement()` methods, which provide a faster way to
+ create an Element within a specific document or parser context.
+ """
+ return _makeElement(_tag, NULL, None, None, None, None,
+ attrib, nsmap, _extra)
+
+
+def Comment(text=None):
+ """Comment(text=None)
+
+ Comment element factory. This factory function creates a special element that will
+ be serialized as an XML comment.
+ """
+ cdef _Document doc
+ cdef xmlNode* c_node
+ cdef xmlDoc* c_doc
+
+ if text is None:
+ text = b''
+ else:
+ text = _utf8(text)
+ if b'--' in text or text.endswith(b'-'):
+ raise ValueError("Comment may not contain '--' or end with '-'")
+
+ c_doc = _newXMLDoc()
+ doc = _documentFactory(c_doc, None)
+ c_node = _createComment(c_doc, _xcstr(text))
+ tree.xmlAddChild(c_doc, c_node)
+ return _elementFactory(doc, c_node)
+
+
+def ProcessingInstruction(target, text=None):
+ """ProcessingInstruction(target, text=None)
+
+ ProcessingInstruction element factory. This factory function creates a
+ special element that will be serialized as an XML processing instruction.
+ """
+ cdef _Document doc
+ cdef xmlNode* c_node
+ cdef xmlDoc* c_doc
+
+ target = _utf8(target)
+ _tagValidOrRaise(target)
+ if target.lower() == b'xml':
+ raise ValueError, f"Invalid PI name '{target}'"
+
+ if text is None:
+ text = b''
+ else:
+ text = _utf8(text)
+ if b'?>' in text:
+ raise ValueError, "PI text must not contain '?>'"
+
+ c_doc = _newXMLDoc()
+ doc = _documentFactory(c_doc, None)
+ c_node = _createPI(c_doc, _xcstr(target), _xcstr(text))
+ tree.xmlAddChild(c_doc, c_node)
+ return _elementFactory(doc, c_node)
+
+PI = ProcessingInstruction
+
+
+cdef class CDATA:
+ """CDATA(data)
+
+ CDATA factory. This factory creates an opaque data object that
+ can be used to set Element text. The usual way to use it is::
+
+ >>> el = Element('content')
+ >>> el.text = CDATA('a string')
+
+ >>> print(el.text)
+ a string
+ >>> print(tostring(el, encoding="unicode"))
+ c_doc, c_node)
+ return _elementFactory(doc, c_node)
+
+
+def SubElement(_Element _parent not None, _tag,
+ attrib=None, nsmap=None, **_extra):
+ """SubElement(_parent, _tag, attrib=None, nsmap=None, **_extra)
+
+ Subelement factory. This function creates an element instance, and
+ appends it to an existing element.
+ """
+ return _makeSubElement(_parent, _tag, None, None, attrib, nsmap, _extra)
+
+
+def ElementTree(_Element element=None, *, file=None, _BaseParser parser=None):
+ """ElementTree(element=None, file=None, parser=None)
+
+ ElementTree wrapper class.
+ """
+ cdef xmlNode* c_next
+ cdef xmlNode* c_node
+ cdef xmlNode* c_node_copy
+ cdef xmlDoc* c_doc
+ cdef _ElementTree etree
+ cdef _Document doc
+
+ if element is not None:
+ doc = element._doc
+ elif file is not None:
+ try:
+ doc = _parseDocument(file, parser, None)
+ except _TargetParserResult as result_container:
+ return result_container.result
+ else:
+ c_doc = _newXMLDoc()
+ doc = _documentFactory(c_doc, parser)
+
+ return _elementTreeFactory(doc, element)
+
+
+def HTML(text, _BaseParser parser=None, *, base_url=None):
+ """HTML(text, parser=None, base_url=None)
+
+ Parses an HTML document from a string constant. Returns the root
+ node (or the result returned by a parser target). This function
+ can be used to embed "HTML literals" in Python code.
+
+ To override the parser with a different ``HTMLParser`` you can pass it to
+ the ``parser`` keyword argument.
+
+ The ``base_url`` keyword argument allows to set the original base URL of
+ the document to support relative Paths when looking up external entities
+ (DTD, XInclude, ...).
+ """
+ cdef _Document doc
+ if parser is None:
+ parser = __GLOBAL_PARSER_CONTEXT.getDefaultParser()
+ if not isinstance(parser, HTMLParser):
+ parser = __DEFAULT_HTML_PARSER
+ try:
+ doc = _parseMemoryDocument(text, base_url, parser)
+ return doc.getroot()
+ except _TargetParserResult as result_container:
+ return result_container.result
+
+
+def XML(text, _BaseParser parser=None, *, base_url=None):
+ """XML(text, parser=None, base_url=None)
+
+ Parses an XML document or fragment from a string constant.
+ Returns the root node (or the result returned by a parser target).
+ This function can be used to embed "XML literals" in Python code,
+ like in
+
+ >>> root = XML(" python.lxml_unpack_xmldoc_capsule(capsule, &is_owned)
+ doc = _adoptForeignDoc(c_doc, parser, is_owned)
+ return _elementTreeFactory(doc, None)
+
+
+################################################################################
+# Include submodules
+
+include "readonlytree.pxi" # Read-only implementation of Element proxies
+include "classlookup.pxi" # Element class lookup mechanisms
+include "nsclasses.pxi" # Namespace implementation and registry
+include "docloader.pxi" # Support for custom document loaders
+include "parser.pxi" # XML and HTML parsers
+include "saxparser.pxi" # SAX-like Parser interface and tree builder
+include "parsertarget.pxi" # ET Parser target
+include "serializer.pxi" # XML output functions
+include "iterparse.pxi" # incremental XML parsing
+include "xmlid.pxi" # XMLID and IDDict
+include "xinclude.pxi" # XInclude
+include "cleanup.pxi" # Cleanup and recursive element removal functions
+
+
+################################################################################
+# Include submodules for XPath and XSLT
+
+include "extensions.pxi" # XPath/XSLT extension functions
+include "xpath.pxi" # XPath evaluation
+include "xslt.pxi" # XSL transformations
+include "xsltext.pxi" # XSL extension elements
+
+
+################################################################################
+# Validation
+
+cdef class DocumentInvalid(LxmlError):
+ """Validation error.
+
+ Raised by all document validators when their ``assertValid(tree)``
+ method fails.
+ """
+
+
+cdef class _Validator:
+ "Base class for XML validators."
+ cdef _ErrorLog _error_log
+ def __cinit__(self):
+ self._error_log = _ErrorLog()
+
+ def validate(self, etree):
+ """validate(self, etree)
+
+ Validate the document using this schema.
+
+ Returns true if document is valid, false if not.
+ """
+ return self(etree)
+
+ def assertValid(self, etree):
+ """assertValid(self, etree)
+
+ Raises `DocumentInvalid` if the document does not comply with the schema.
+ """
+ if not self(etree):
+ raise DocumentInvalid(self._error_log._buildExceptionMessage(
+ "Document does not comply with schema"),
+ self._error_log)
+
+ def assert_(self, etree):
+ """assert_(self, etree)
+
+ Raises `AssertionError` if the document does not comply with the schema.
+ """
+ if not self(etree):
+ raise AssertionError, self._error_log._buildExceptionMessage(
+ "Document does not comply with schema")
+
+ cpdef _append_log_message(self, int domain, int type, int level, int line,
+ message, filename):
+ self._error_log._receiveGeneric(domain, type, level, line, message,
+ filename)
+
+ cpdef _clear_error_log(self):
+ self._error_log.clear()
+
+ @property
+ def error_log(self):
+ """The log of validation errors and warnings."""
+ assert self._error_log is not None, "XPath evaluator not initialised"
+ return self._error_log.copy()
+
+include "dtd.pxi" # DTD
+include "relaxng.pxi" # RelaxNG
+include "xmlschema.pxi" # XMLSchema
+include "schematron.pxi" # Schematron (requires libxml2 2.6.21+)
+
+################################################################################
+# Public C API
+
+include "public-api.pxi"
+
+################################################################################
+# Other stuff
+
+include "debug.pxi"
diff --git a/llava_video/lib/python3.10/site-packages/lxml/etree_api.h b/llava_video/lib/python3.10/site-packages/lxml/etree_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..1c9b461653369186de02d847d1d18f81a5a76bfd
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/etree_api.h
@@ -0,0 +1,195 @@
+/* Generated by Cython 3.0.11 */
+
+#ifndef __PYX_HAVE_API__lxml__etree
+#define __PYX_HAVE_API__lxml__etree
+#ifdef __MINGW64__
+#define MS_WIN64
+#endif
+#include "Python.h"
+#include "etree.h"
+
+static struct LxmlElement *(*__pyx_api_f_4lxml_5etree_deepcopyNodeToDocument)(struct LxmlDocument *, xmlNode *) = 0;
+#define deepcopyNodeToDocument __pyx_api_f_4lxml_5etree_deepcopyNodeToDocument
+static struct LxmlElementTree *(*__pyx_api_f_4lxml_5etree_elementTreeFactory)(struct LxmlElement *) = 0;
+#define elementTreeFactory __pyx_api_f_4lxml_5etree_elementTreeFactory
+static struct LxmlElementTree *(*__pyx_api_f_4lxml_5etree_newElementTree)(struct LxmlElement *, PyObject *) = 0;
+#define newElementTree __pyx_api_f_4lxml_5etree_newElementTree
+static struct LxmlElementTree *(*__pyx_api_f_4lxml_5etree_adoptExternalDocument)(xmlDoc *, PyObject *, int) = 0;
+#define adoptExternalDocument __pyx_api_f_4lxml_5etree_adoptExternalDocument
+static struct LxmlElement *(*__pyx_api_f_4lxml_5etree_elementFactory)(struct LxmlDocument *, xmlNode *) = 0;
+#define elementFactory __pyx_api_f_4lxml_5etree_elementFactory
+static struct LxmlElement *(*__pyx_api_f_4lxml_5etree_makeElement)(PyObject *, struct LxmlDocument *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *) = 0;
+#define makeElement __pyx_api_f_4lxml_5etree_makeElement
+static struct LxmlElement *(*__pyx_api_f_4lxml_5etree_makeSubElement)(struct LxmlElement *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *) = 0;
+#define makeSubElement __pyx_api_f_4lxml_5etree_makeSubElement
+static void (*__pyx_api_f_4lxml_5etree_setElementClassLookupFunction)(_element_class_lookup_function, PyObject *) = 0;
+#define setElementClassLookupFunction __pyx_api_f_4lxml_5etree_setElementClassLookupFunction
+static PyObject *(*__pyx_api_f_4lxml_5etree_lookupDefaultElementClass)(PyObject *, PyObject *, xmlNode *) = 0;
+#define lookupDefaultElementClass __pyx_api_f_4lxml_5etree_lookupDefaultElementClass
+static PyObject *(*__pyx_api_f_4lxml_5etree_lookupNamespaceElementClass)(PyObject *, PyObject *, xmlNode *) = 0;
+#define lookupNamespaceElementClass __pyx_api_f_4lxml_5etree_lookupNamespaceElementClass
+static PyObject *(*__pyx_api_f_4lxml_5etree_callLookupFallback)(struct LxmlFallbackElementClassLookup *, struct LxmlDocument *, xmlNode *) = 0;
+#define callLookupFallback __pyx_api_f_4lxml_5etree_callLookupFallback
+static int (*__pyx_api_f_4lxml_5etree_tagMatches)(xmlNode *, const xmlChar *, const xmlChar *) = 0;
+#define tagMatches __pyx_api_f_4lxml_5etree_tagMatches
+static struct LxmlDocument *(*__pyx_api_f_4lxml_5etree_documentOrRaise)(PyObject *) = 0;
+#define documentOrRaise __pyx_api_f_4lxml_5etree_documentOrRaise
+static struct LxmlElement *(*__pyx_api_f_4lxml_5etree_rootNodeOrRaise)(PyObject *) = 0;
+#define rootNodeOrRaise __pyx_api_f_4lxml_5etree_rootNodeOrRaise
+static int (*__pyx_api_f_4lxml_5etree_hasText)(xmlNode *) = 0;
+#define hasText __pyx_api_f_4lxml_5etree_hasText
+static int (*__pyx_api_f_4lxml_5etree_hasTail)(xmlNode *) = 0;
+#define hasTail __pyx_api_f_4lxml_5etree_hasTail
+static PyObject *(*__pyx_api_f_4lxml_5etree_textOf)(xmlNode *) = 0;
+#define textOf __pyx_api_f_4lxml_5etree_textOf
+static PyObject *(*__pyx_api_f_4lxml_5etree_tailOf)(xmlNode *) = 0;
+#define tailOf __pyx_api_f_4lxml_5etree_tailOf
+static int (*__pyx_api_f_4lxml_5etree_setNodeText)(xmlNode *, PyObject *) = 0;
+#define setNodeText __pyx_api_f_4lxml_5etree_setNodeText
+static int (*__pyx_api_f_4lxml_5etree_setTailText)(xmlNode *, PyObject *) = 0;
+#define setTailText __pyx_api_f_4lxml_5etree_setTailText
+static PyObject *(*__pyx_api_f_4lxml_5etree_attributeValue)(xmlNode *, xmlAttr *) = 0;
+#define attributeValue __pyx_api_f_4lxml_5etree_attributeValue
+static PyObject *(*__pyx_api_f_4lxml_5etree_attributeValueFromNsName)(xmlNode *, const xmlChar *, const xmlChar *) = 0;
+#define attributeValueFromNsName __pyx_api_f_4lxml_5etree_attributeValueFromNsName
+static PyObject *(*__pyx_api_f_4lxml_5etree_getAttributeValue)(struct LxmlElement *, PyObject *, PyObject *) = 0;
+#define getAttributeValue __pyx_api_f_4lxml_5etree_getAttributeValue
+static PyObject *(*__pyx_api_f_4lxml_5etree_iterattributes)(struct LxmlElement *, int) = 0;
+#define iterattributes __pyx_api_f_4lxml_5etree_iterattributes
+static PyObject *(*__pyx_api_f_4lxml_5etree_collectAttributes)(xmlNode *, int) = 0;
+#define collectAttributes __pyx_api_f_4lxml_5etree_collectAttributes
+static int (*__pyx_api_f_4lxml_5etree_setAttributeValue)(struct LxmlElement *, PyObject *, PyObject *) = 0;
+#define setAttributeValue __pyx_api_f_4lxml_5etree_setAttributeValue
+static int (*__pyx_api_f_4lxml_5etree_delAttribute)(struct LxmlElement *, PyObject *) = 0;
+#define delAttribute __pyx_api_f_4lxml_5etree_delAttribute
+static int (*__pyx_api_f_4lxml_5etree_delAttributeFromNsName)(xmlNode *, const xmlChar *, const xmlChar *) = 0;
+#define delAttributeFromNsName __pyx_api_f_4lxml_5etree_delAttributeFromNsName
+static int (*__pyx_api_f_4lxml_5etree_hasChild)(xmlNode *) = 0;
+#define hasChild __pyx_api_f_4lxml_5etree_hasChild
+static xmlNode *(*__pyx_api_f_4lxml_5etree_findChild)(xmlNode *, Py_ssize_t) = 0;
+#define findChild __pyx_api_f_4lxml_5etree_findChild
+static xmlNode *(*__pyx_api_f_4lxml_5etree_findChildForwards)(xmlNode *, Py_ssize_t) = 0;
+#define findChildForwards __pyx_api_f_4lxml_5etree_findChildForwards
+static xmlNode *(*__pyx_api_f_4lxml_5etree_findChildBackwards)(xmlNode *, Py_ssize_t) = 0;
+#define findChildBackwards __pyx_api_f_4lxml_5etree_findChildBackwards
+static xmlNode *(*__pyx_api_f_4lxml_5etree_nextElement)(xmlNode *) = 0;
+#define nextElement __pyx_api_f_4lxml_5etree_nextElement
+static xmlNode *(*__pyx_api_f_4lxml_5etree_previousElement)(xmlNode *) = 0;
+#define previousElement __pyx_api_f_4lxml_5etree_previousElement
+static void (*__pyx_api_f_4lxml_5etree_appendChild)(struct LxmlElement *, struct LxmlElement *) = 0;
+#define appendChild __pyx_api_f_4lxml_5etree_appendChild
+static int (*__pyx_api_f_4lxml_5etree_appendChildToElement)(struct LxmlElement *, struct LxmlElement *) = 0;
+#define appendChildToElement __pyx_api_f_4lxml_5etree_appendChildToElement
+static PyObject *(*__pyx_api_f_4lxml_5etree_pyunicode)(const xmlChar *) = 0;
+#define pyunicode __pyx_api_f_4lxml_5etree_pyunicode
+static PyObject *(*__pyx_api_f_4lxml_5etree_utf8)(PyObject *) = 0;
+#define utf8 __pyx_api_f_4lxml_5etree_utf8
+static PyObject *(*__pyx_api_f_4lxml_5etree_getNsTag)(PyObject *) = 0;
+#define getNsTag __pyx_api_f_4lxml_5etree_getNsTag
+static PyObject *(*__pyx_api_f_4lxml_5etree_getNsTagWithEmptyNs)(PyObject *) = 0;
+#define getNsTagWithEmptyNs __pyx_api_f_4lxml_5etree_getNsTagWithEmptyNs
+static PyObject *(*__pyx_api_f_4lxml_5etree_namespacedName)(xmlNode *) = 0;
+#define namespacedName __pyx_api_f_4lxml_5etree_namespacedName
+static PyObject *(*__pyx_api_f_4lxml_5etree_namespacedNameFromNsName)(const xmlChar *, const xmlChar *) = 0;
+#define namespacedNameFromNsName __pyx_api_f_4lxml_5etree_namespacedNameFromNsName
+static void (*__pyx_api_f_4lxml_5etree_iteratorStoreNext)(struct LxmlElementIterator *, struct LxmlElement *) = 0;
+#define iteratorStoreNext __pyx_api_f_4lxml_5etree_iteratorStoreNext
+static void (*__pyx_api_f_4lxml_5etree_initTagMatch)(struct LxmlElementTagMatcher *, PyObject *) = 0;
+#define initTagMatch __pyx_api_f_4lxml_5etree_initTagMatch
+static xmlNs *(*__pyx_api_f_4lxml_5etree_findOrBuildNodeNsPrefix)(struct LxmlDocument *, xmlNode *, const xmlChar *, const xmlChar *) = 0;
+#define findOrBuildNodeNsPrefix __pyx_api_f_4lxml_5etree_findOrBuildNodeNsPrefix
+#ifndef __PYX_HAVE_RT_ImportFunction_3_0_11
+#define __PYX_HAVE_RT_ImportFunction_3_0_11
+static int __Pyx_ImportFunction_3_0_11(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
+ PyObject *d = 0;
+ PyObject *cobj = 0;
+ union {
+ void (*fp)(void);
+ void *p;
+ } tmp;
+ d = PyObject_GetAttrString(module, (char *)"__pyx_capi__");
+ if (!d)
+ goto bad;
+ cobj = PyDict_GetItemString(d, funcname);
+ if (!cobj) {
+ PyErr_Format(PyExc_ImportError,
+ "%.200s does not export expected C function %.200s",
+ PyModule_GetName(module), funcname);
+ goto bad;
+ }
+ if (!PyCapsule_IsValid(cobj, sig)) {
+ PyErr_Format(PyExc_TypeError,
+ "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
+ PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj));
+ goto bad;
+ }
+ tmp.p = PyCapsule_GetPointer(cobj, sig);
+ *f = tmp.fp;
+ if (!(*f))
+ goto bad;
+ Py_DECREF(d);
+ return 0;
+bad:
+ Py_XDECREF(d);
+ return -1;
+}
+#endif
+
+
+static int import_lxml__etree(void) {
+ PyObject *module = 0;
+ module = PyImport_ImportModule("lxml.etree");
+ if (!module) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "deepcopyNodeToDocument", (void (**)(void))&__pyx_api_f_4lxml_5etree_deepcopyNodeToDocument, "struct LxmlElement *(struct LxmlDocument *, xmlNode *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "elementTreeFactory", (void (**)(void))&__pyx_api_f_4lxml_5etree_elementTreeFactory, "struct LxmlElementTree *(struct LxmlElement *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "newElementTree", (void (**)(void))&__pyx_api_f_4lxml_5etree_newElementTree, "struct LxmlElementTree *(struct LxmlElement *, PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "adoptExternalDocument", (void (**)(void))&__pyx_api_f_4lxml_5etree_adoptExternalDocument, "struct LxmlElementTree *(xmlDoc *, PyObject *, int)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "elementFactory", (void (**)(void))&__pyx_api_f_4lxml_5etree_elementFactory, "struct LxmlElement *(struct LxmlDocument *, xmlNode *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "makeElement", (void (**)(void))&__pyx_api_f_4lxml_5etree_makeElement, "struct LxmlElement *(PyObject *, struct LxmlDocument *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "makeSubElement", (void (**)(void))&__pyx_api_f_4lxml_5etree_makeSubElement, "struct LxmlElement *(struct LxmlElement *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "setElementClassLookupFunction", (void (**)(void))&__pyx_api_f_4lxml_5etree_setElementClassLookupFunction, "void (_element_class_lookup_function, PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "lookupDefaultElementClass", (void (**)(void))&__pyx_api_f_4lxml_5etree_lookupDefaultElementClass, "PyObject *(PyObject *, PyObject *, xmlNode *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "lookupNamespaceElementClass", (void (**)(void))&__pyx_api_f_4lxml_5etree_lookupNamespaceElementClass, "PyObject *(PyObject *, PyObject *, xmlNode *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "callLookupFallback", (void (**)(void))&__pyx_api_f_4lxml_5etree_callLookupFallback, "PyObject *(struct LxmlFallbackElementClassLookup *, struct LxmlDocument *, xmlNode *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "tagMatches", (void (**)(void))&__pyx_api_f_4lxml_5etree_tagMatches, "int (xmlNode *, const xmlChar *, const xmlChar *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "documentOrRaise", (void (**)(void))&__pyx_api_f_4lxml_5etree_documentOrRaise, "struct LxmlDocument *(PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "rootNodeOrRaise", (void (**)(void))&__pyx_api_f_4lxml_5etree_rootNodeOrRaise, "struct LxmlElement *(PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "hasText", (void (**)(void))&__pyx_api_f_4lxml_5etree_hasText, "int (xmlNode *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "hasTail", (void (**)(void))&__pyx_api_f_4lxml_5etree_hasTail, "int (xmlNode *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "textOf", (void (**)(void))&__pyx_api_f_4lxml_5etree_textOf, "PyObject *(xmlNode *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "tailOf", (void (**)(void))&__pyx_api_f_4lxml_5etree_tailOf, "PyObject *(xmlNode *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "setNodeText", (void (**)(void))&__pyx_api_f_4lxml_5etree_setNodeText, "int (xmlNode *, PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "setTailText", (void (**)(void))&__pyx_api_f_4lxml_5etree_setTailText, "int (xmlNode *, PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "attributeValue", (void (**)(void))&__pyx_api_f_4lxml_5etree_attributeValue, "PyObject *(xmlNode *, xmlAttr *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "attributeValueFromNsName", (void (**)(void))&__pyx_api_f_4lxml_5etree_attributeValueFromNsName, "PyObject *(xmlNode *, const xmlChar *, const xmlChar *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "getAttributeValue", (void (**)(void))&__pyx_api_f_4lxml_5etree_getAttributeValue, "PyObject *(struct LxmlElement *, PyObject *, PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "iterattributes", (void (**)(void))&__pyx_api_f_4lxml_5etree_iterattributes, "PyObject *(struct LxmlElement *, int)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "collectAttributes", (void (**)(void))&__pyx_api_f_4lxml_5etree_collectAttributes, "PyObject *(xmlNode *, int)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "setAttributeValue", (void (**)(void))&__pyx_api_f_4lxml_5etree_setAttributeValue, "int (struct LxmlElement *, PyObject *, PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "delAttribute", (void (**)(void))&__pyx_api_f_4lxml_5etree_delAttribute, "int (struct LxmlElement *, PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "delAttributeFromNsName", (void (**)(void))&__pyx_api_f_4lxml_5etree_delAttributeFromNsName, "int (xmlNode *, const xmlChar *, const xmlChar *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "hasChild", (void (**)(void))&__pyx_api_f_4lxml_5etree_hasChild, "int (xmlNode *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "findChild", (void (**)(void))&__pyx_api_f_4lxml_5etree_findChild, "xmlNode *(xmlNode *, Py_ssize_t)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "findChildForwards", (void (**)(void))&__pyx_api_f_4lxml_5etree_findChildForwards, "xmlNode *(xmlNode *, Py_ssize_t)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "findChildBackwards", (void (**)(void))&__pyx_api_f_4lxml_5etree_findChildBackwards, "xmlNode *(xmlNode *, Py_ssize_t)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "nextElement", (void (**)(void))&__pyx_api_f_4lxml_5etree_nextElement, "xmlNode *(xmlNode *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "previousElement", (void (**)(void))&__pyx_api_f_4lxml_5etree_previousElement, "xmlNode *(xmlNode *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "appendChild", (void (**)(void))&__pyx_api_f_4lxml_5etree_appendChild, "void (struct LxmlElement *, struct LxmlElement *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "appendChildToElement", (void (**)(void))&__pyx_api_f_4lxml_5etree_appendChildToElement, "int (struct LxmlElement *, struct LxmlElement *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "pyunicode", (void (**)(void))&__pyx_api_f_4lxml_5etree_pyunicode, "PyObject *(const xmlChar *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "utf8", (void (**)(void))&__pyx_api_f_4lxml_5etree_utf8, "PyObject *(PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "getNsTag", (void (**)(void))&__pyx_api_f_4lxml_5etree_getNsTag, "PyObject *(PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "getNsTagWithEmptyNs", (void (**)(void))&__pyx_api_f_4lxml_5etree_getNsTagWithEmptyNs, "PyObject *(PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "namespacedName", (void (**)(void))&__pyx_api_f_4lxml_5etree_namespacedName, "PyObject *(xmlNode *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "namespacedNameFromNsName", (void (**)(void))&__pyx_api_f_4lxml_5etree_namespacedNameFromNsName, "PyObject *(const xmlChar *, const xmlChar *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "iteratorStoreNext", (void (**)(void))&__pyx_api_f_4lxml_5etree_iteratorStoreNext, "void (struct LxmlElementIterator *, struct LxmlElement *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "initTagMatch", (void (**)(void))&__pyx_api_f_4lxml_5etree_initTagMatch, "void (struct LxmlElementTagMatcher *, PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "findOrBuildNodeNsPrefix", (void (**)(void))&__pyx_api_f_4lxml_5etree_findOrBuildNodeNsPrefix, "xmlNs *(struct LxmlDocument *, xmlNode *, const xmlChar *, const xmlChar *)") < 0) goto bad;
+ Py_DECREF(module); module = 0;
+ return 0;
+ bad:
+ Py_XDECREF(module);
+ return -1;
+}
+
+#endif /* !__PYX_HAVE_API__lxml__etree */
diff --git a/llava_video/lib/python3.10/site-packages/lxml/extensions.pxi b/llava_video/lib/python3.10/site-packages/lxml/extensions.pxi
new file mode 100644
index 0000000000000000000000000000000000000000..2a2c94ecc7a6baae223ff7d613bf76d1b699be99
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/extensions.pxi
@@ -0,0 +1,833 @@
+# support for extension functions in XPath and XSLT
+
+cdef class XPathError(LxmlError):
+ """Base class of all XPath errors.
+ """
+
+cdef class XPathEvalError(XPathError):
+ """Error during XPath evaluation.
+ """
+
+cdef class XPathFunctionError(XPathEvalError):
+ """Internal error looking up an XPath extension function.
+ """
+
+cdef class XPathResultError(XPathEvalError):
+ """Error handling an XPath result.
+ """
+
+
+# forward declarations
+
+ctypedef int (*_register_function)(void* ctxt, name_utf, ns_uri_utf)
+cdef class _ExsltRegExp
+
+################################################################################
+# Base class for XSLT and XPath evaluation contexts: functions, namespaces, ...
+
+@cython.internal
+cdef class _BaseContext:
+ cdef xpath.xmlXPathContext* _xpathCtxt
+ cdef _Document _doc
+ cdef dict _extensions
+ cdef list _namespaces
+ cdef list _global_namespaces
+ cdef dict _utf_refs
+ cdef dict _function_cache
+ cdef dict _eval_context_dict
+ cdef bint _build_smart_strings
+ # for exception handling and temporary reference keeping:
+ cdef _TempStore _temp_refs
+ cdef set _temp_documents
+ cdef _ExceptionContext _exc
+ cdef _ErrorLog _error_log
+
+ def __cinit__(self):
+ self._xpathCtxt = NULL
+
+ def __init__(self, namespaces, extensions, error_log, enable_regexp,
+ build_smart_strings):
+ cdef _ExsltRegExp _regexp
+ cdef dict new_extensions
+ cdef list ns
+ self._utf_refs = {}
+ self._global_namespaces = []
+ self._function_cache = {}
+ self._eval_context_dict = None
+ self._error_log = error_log
+
+ if extensions is not None:
+ # convert extensions to UTF-8
+ if isinstance(extensions, dict):
+ extensions = (extensions,)
+ # format: [ {(ns, name):function} ] -> {(ns_utf, name_utf):function}
+ new_extensions = {}
+ for extension in extensions:
+ for (ns_uri, name), function in extension.items():
+ if name is None:
+ raise ValueError, "extensions must have non empty names"
+ ns_utf = self._to_utf(ns_uri)
+ name_utf = self._to_utf(name)
+ new_extensions[(ns_utf, name_utf)] = function
+ extensions = new_extensions or None
+
+ if namespaces is not None:
+ if isinstance(namespaces, dict):
+ namespaces = namespaces.items()
+ if namespaces:
+ ns = []
+ for prefix, ns_uri in namespaces:
+ if prefix is None or not prefix:
+ raise TypeError, \
+ "empty namespace prefix is not supported in XPath"
+ if ns_uri is None or not ns_uri:
+ raise TypeError, \
+ "setting default namespace is not supported in XPath"
+ prefix_utf = self._to_utf(prefix)
+ ns_uri_utf = self._to_utf(ns_uri)
+ ns.append( (prefix_utf, ns_uri_utf) )
+ namespaces = ns
+ else:
+ namespaces = None
+
+ self._doc = None
+ self._exc = _ExceptionContext()
+ self._extensions = extensions
+ self._namespaces = namespaces
+ self._temp_refs = _TempStore()
+ self._temp_documents = set()
+ self._build_smart_strings = build_smart_strings
+
+ if enable_regexp:
+ _regexp = _ExsltRegExp()
+ _regexp._register_in_context(self)
+
+ cdef _BaseContext _copy(self):
+ cdef _BaseContext context
+ if self._namespaces is not None:
+ namespaces = self._namespaces[:]
+ else:
+ namespaces = None
+ context = self.__class__(namespaces, None, self._error_log, False,
+ self._build_smart_strings)
+ if self._extensions is not None:
+ context._extensions = self._extensions.copy()
+ return context
+
+ cdef bytes _to_utf(self, s):
+ "Convert to UTF-8 and keep a reference to the encoded string"
+ cdef python.PyObject* dict_result
+ if s is None:
+ return None
+ dict_result = python.PyDict_GetItem(self._utf_refs, s)
+ if dict_result is not NULL:
+ return dict_result
+ utf = _utf8(s)
+ self._utf_refs[s] = utf
+ if python.IS_PYPY:
+ # use C level refs, PyPy refs are not enough!
+ python.Py_INCREF(utf)
+ return utf
+
+ cdef void _set_xpath_context(self, xpath.xmlXPathContext* xpathCtxt) noexcept:
+ self._xpathCtxt = xpathCtxt
+ xpathCtxt.userData = self
+ # Need a cast here because older libxml2 releases do not use 'const' in the functype.
+ xpathCtxt.error = _receiveXPathError
+
+ @cython.final
+ cdef _register_context(self, _Document doc):
+ self._doc = doc
+ self._exc.clear()
+
+ @cython.final
+ cdef _cleanup_context(self):
+ #xpath.xmlXPathRegisteredNsCleanup(self._xpathCtxt)
+ #self.unregisterGlobalNamespaces()
+ if python.IS_PYPY:
+ # clean up double refs in PyPy (see "_to_utf()" method)
+ for ref in self._utf_refs.itervalues():
+ python.Py_DECREF(ref)
+ self._utf_refs.clear()
+ self._eval_context_dict = None
+ self._doc = None
+
+ @cython.final
+ cdef _release_context(self):
+ if self._xpathCtxt is not NULL:
+ self._xpathCtxt.userData = NULL
+ self._xpathCtxt = NULL
+
+ # namespaces (internal UTF-8 methods with leading '_')
+
+ cdef addNamespace(self, prefix, ns_uri):
+ cdef list namespaces
+ if prefix is None:
+ raise TypeError, "empty prefix is not supported in XPath"
+ prefix_utf = self._to_utf(prefix)
+ ns_uri_utf = self._to_utf(ns_uri)
+ new_item = (prefix_utf, ns_uri_utf)
+ if self._namespaces is None:
+ self._namespaces = [new_item]
+ else:
+ namespaces = []
+ for item in self._namespaces:
+ if item[0] == prefix_utf:
+ item = new_item
+ new_item = None
+ namespaces.append(item)
+ if new_item is not None:
+ namespaces.append(new_item)
+ self._namespaces = namespaces
+ if self._xpathCtxt is not NULL:
+ xpath.xmlXPathRegisterNs(
+ self._xpathCtxt, _xcstr(prefix_utf), _xcstr(ns_uri_utf))
+
+ cdef registerNamespace(self, prefix, ns_uri):
+ if prefix is None:
+ raise TypeError, "empty prefix is not supported in XPath"
+ prefix_utf = self._to_utf(prefix)
+ ns_uri_utf = self._to_utf(ns_uri)
+ self._global_namespaces.append(prefix_utf)
+ xpath.xmlXPathRegisterNs(self._xpathCtxt,
+ _xcstr(prefix_utf), _xcstr(ns_uri_utf))
+
+ cdef registerLocalNamespaces(self):
+ if self._namespaces is None:
+ return
+ for prefix_utf, ns_uri_utf in self._namespaces:
+ xpath.xmlXPathRegisterNs(
+ self._xpathCtxt, _xcstr(prefix_utf), _xcstr(ns_uri_utf))
+
+ cdef registerGlobalNamespaces(self):
+ cdef list ns_prefixes = _find_all_extension_prefixes()
+ if python.PyList_GET_SIZE(ns_prefixes) > 0:
+ for prefix_utf, ns_uri_utf in ns_prefixes:
+ self._global_namespaces.append(prefix_utf)
+ xpath.xmlXPathRegisterNs(
+ self._xpathCtxt, _xcstr(prefix_utf), _xcstr(ns_uri_utf))
+
+ cdef unregisterGlobalNamespaces(self):
+ if python.PyList_GET_SIZE(self._global_namespaces) > 0:
+ for prefix_utf in self._global_namespaces:
+ xpath.xmlXPathRegisterNs(self._xpathCtxt,
+ _xcstr(prefix_utf), NULL)
+ del self._global_namespaces[:]
+
+ cdef void _unregisterNamespace(self, prefix_utf) noexcept:
+ xpath.xmlXPathRegisterNs(self._xpathCtxt,
+ _xcstr(prefix_utf), NULL)
+
+ # extension functions
+
+ cdef int _addLocalExtensionFunction(self, ns_utf, name_utf, function) except -1:
+ if self._extensions is None:
+ self._extensions = {}
+ self._extensions[(ns_utf, name_utf)] = function
+ return 0
+
+ cdef registerGlobalFunctions(self, void* ctxt,
+ _register_function reg_func):
+ cdef python.PyObject* dict_result
+ cdef dict d
+ for ns_utf, ns_functions in __FUNCTION_NAMESPACE_REGISTRIES.iteritems():
+ dict_result = python.PyDict_GetItem(
+ self._function_cache, ns_utf)
+ if dict_result is not NULL:
+ d = dict_result
+ else:
+ d = {}
+ self._function_cache[ns_utf] = d
+ for name_utf, function in ns_functions.iteritems():
+ d[name_utf] = function
+ reg_func(ctxt, name_utf, ns_utf)
+
+ cdef registerLocalFunctions(self, void* ctxt,
+ _register_function reg_func):
+ cdef python.PyObject* dict_result
+ cdef dict d
+ if self._extensions is None:
+ return # done
+ last_ns = None
+ d = None
+ for (ns_utf, name_utf), function in self._extensions.iteritems():
+ if ns_utf is not last_ns or d is None:
+ last_ns = ns_utf
+ dict_result = python.PyDict_GetItem(
+ self._function_cache, ns_utf)
+ if dict_result is not NULL:
+ d = dict_result
+ else:
+ d = {}
+ self._function_cache[ns_utf] = d
+ d[name_utf] = function
+ reg_func(ctxt, name_utf, ns_utf)
+
+ cdef unregisterAllFunctions(self, void* ctxt,
+ _register_function unreg_func):
+ for ns_utf, functions in self._function_cache.iteritems():
+ for name_utf in functions:
+ unreg_func(ctxt, name_utf, ns_utf)
+
+ cdef unregisterGlobalFunctions(self, void* ctxt,
+ _register_function unreg_func):
+ for ns_utf, functions in self._function_cache.items():
+ for name_utf in functions:
+ if self._extensions is None or \
+ (ns_utf, name_utf) not in self._extensions:
+ unreg_func(ctxt, name_utf, ns_utf)
+
+ @cython.final
+ cdef _find_cached_function(self, const_xmlChar* c_ns_uri, const_xmlChar* c_name):
+ """Lookup an extension function in the cache and return it.
+
+ Parameters: c_ns_uri may be NULL, c_name must not be NULL
+ """
+ cdef python.PyObject* c_dict
+ cdef python.PyObject* dict_result
+ c_dict = python.PyDict_GetItem(
+ self._function_cache, None if c_ns_uri is NULL else c_ns_uri)
+ if c_dict is not NULL:
+ dict_result = python.PyDict_GetItem(
+ c_dict, c_name)
+ if dict_result is not NULL:
+ return dict_result
+ return None
+
+ # Python access to the XPath context for extension functions
+
+ @property
+ def context_node(self):
+ cdef xmlNode* c_node
+ if self._xpathCtxt is NULL:
+ raise XPathError, \
+ "XPath context is only usable during the evaluation"
+ c_node = self._xpathCtxt.node
+ if c_node is NULL:
+ raise XPathError, "no context node"
+ if c_node.doc != self._xpathCtxt.doc:
+ raise XPathError, \
+ "document-external context nodes are not supported"
+ if self._doc is None:
+ raise XPathError, "document context is missing"
+ return _elementFactory(self._doc, c_node)
+
+ @property
+ def eval_context(self):
+ if self._eval_context_dict is None:
+ self._eval_context_dict = {}
+ return self._eval_context_dict
+
+ # Python reference keeping during XPath function evaluation
+
+ @cython.final
+ cdef _release_temp_refs(self):
+ "Free temporarily referenced objects from this context."
+ self._temp_refs.clear()
+ self._temp_documents.clear()
+
+ @cython.final
+ cdef _hold(self, obj):
+ """A way to temporarily hold references to nodes in the evaluator.
+
+ This is needed because otherwise nodes created in XPath extension
+ functions would be reference counted too soon, during the XPath
+ evaluation. This is most important in the case of exceptions.
+ """
+ cdef _Element element
+ if isinstance(obj, _Element):
+ self._temp_refs.add(obj)
+ self._temp_documents.add((<_Element>obj)._doc)
+ return
+ elif _isString(obj) or not python.PySequence_Check(obj):
+ return
+ for o in obj:
+ if isinstance(o, _Element):
+ #print "Holding element:", element._c_node
+ self._temp_refs.add(o)
+ #print "Holding document:", element._doc._c_doc
+ self._temp_documents.add((<_Element>o)._doc)
+
+ @cython.final
+ cdef _Document _findDocumentForNode(self, xmlNode* c_node):
+ """If an XPath expression returns an element from a different
+ document than the current context document, we call this to
+ see if it was possibly created by an extension and is a known
+ document instance.
+ """
+ cdef _Document doc
+ for doc in self._temp_documents:
+ if doc is not None and doc._c_doc is c_node.doc:
+ return doc
+ return None
+
+
+# libxml2 keeps these error messages in a static array in its code
+# and doesn't give us access to them ...
+
+cdef tuple LIBXML2_XPATH_ERROR_MESSAGES = (
+ b"Ok",
+ b"Number encoding",
+ b"Unfinished literal",
+ b"Start of literal",
+ b"Expected $ for variable reference",
+ b"Undefined variable",
+ b"Invalid predicate",
+ b"Invalid expression",
+ b"Missing closing curly brace",
+ b"Unregistered function",
+ b"Invalid operand",
+ b"Invalid type",
+ b"Invalid number of arguments",
+ b"Invalid context size",
+ b"Invalid context position",
+ b"Memory allocation error",
+ b"Syntax error",
+ b"Resource error",
+ b"Sub resource error",
+ b"Undefined namespace prefix",
+ b"Encoding error",
+ b"Char out of XML range",
+ b"Invalid or incomplete context",
+ b"Stack usage error",
+ b"Forbidden variable\n",
+ b"?? Unknown error ??\n",
+)
+
+cdef void _forwardXPathError(void* c_ctxt, const xmlerror.xmlError* c_error) noexcept with gil:
+ cdef xmlerror.xmlError error
+ cdef int xpath_code
+ if c_error.message is not NULL:
+ error.message = c_error.message
+ else:
+ xpath_code = c_error.code - xmlerror.XML_XPATH_EXPRESSION_OK
+ if 0 <= xpath_code < len(LIBXML2_XPATH_ERROR_MESSAGES):
+ error.message = _cstr(LIBXML2_XPATH_ERROR_MESSAGES[xpath_code])
+ else:
+ error.message = b"unknown error"
+ error.domain = c_error.domain
+ error.code = c_error.code
+ error.level = c_error.level
+ error.line = c_error.line
+ error.int2 = c_error.int1 # column
+ error.file = c_error.file
+ error.node = NULL
+
+ (<_BaseContext>c_ctxt)._error_log._receive(&error)
+
+cdef void _receiveXPathError(void* c_context, const xmlerror.xmlError* error) noexcept nogil:
+ if not __DEBUG:
+ return
+ if c_context is NULL:
+ _forwardError(NULL, error)
+ else:
+ _forwardXPathError(c_context, error)
+
+
+def Extension(module, function_mapping=None, *, ns=None):
+ """Extension(module, function_mapping=None, ns=None)
+
+ Build a dictionary of extension functions from the functions
+ defined in a module or the methods of an object.
+
+ As second argument, you can pass an additional mapping of
+ attribute names to XPath function names, or a list of function
+ names that should be taken.
+
+ The ``ns`` keyword argument accepts a namespace URI for the XPath
+ functions.
+ """
+ cdef dict functions = {}
+ if isinstance(function_mapping, dict):
+ for function_name, xpath_name in function_mapping.items():
+ functions[(ns, xpath_name)] = getattr(module, function_name)
+ else:
+ if function_mapping is None:
+ function_mapping = [ name for name in dir(module)
+ if not name.startswith('_') ]
+ for function_name in function_mapping:
+ functions[(ns, function_name)] = getattr(module, function_name)
+ return functions
+
+################################################################################
+# EXSLT regexp implementation
+
+@cython.final
+@cython.internal
+cdef class _ExsltRegExp:
+ cdef dict _compile_map
+ def __cinit__(self):
+ self._compile_map = {}
+
+ cdef _make_string(self, value):
+ if _isString(value):
+ return value
+ elif isinstance(value, list):
+ # node set: take recursive text concatenation of first element
+ if python.PyList_GET_SIZE(value) == 0:
+ return ''
+ firstnode = value[0]
+ if _isString(firstnode):
+ return firstnode
+ elif isinstance(firstnode, _Element):
+ c_text = tree.xmlNodeGetContent((<_Element>firstnode)._c_node)
+ if c_text is NULL:
+ raise MemoryError()
+ try:
+ return funicode(c_text)
+ finally:
+ tree.xmlFree(c_text)
+ else:
+ return unicode(firstnode)
+ else:
+ return unicode(value)
+
+ cdef _compile(self, rexp, ignore_case):
+ cdef python.PyObject* c_result
+ rexp = self._make_string(rexp)
+ key = (rexp, ignore_case)
+ c_result = python.PyDict_GetItem(self._compile_map, key)
+ if c_result is not NULL:
+ return c_result
+ py_flags = re.UNICODE
+ if ignore_case:
+ py_flags = py_flags | re.IGNORECASE
+ rexp_compiled = re.compile(rexp, py_flags)
+ self._compile_map[key] = rexp_compiled
+ return rexp_compiled
+
+ def test(self, ctxt, s, rexp, flags=''):
+ flags = self._make_string(flags)
+ s = self._make_string(s)
+ rexpc = self._compile(rexp, 'i' in flags)
+ if rexpc.search(s) is None:
+ return False
+ else:
+ return True
+
+ def match(self, ctxt, s, rexp, flags=''):
+ cdef list result_list
+ flags = self._make_string(flags)
+ s = self._make_string(s)
+ rexpc = self._compile(rexp, 'i' in flags)
+ if 'g' in flags:
+ results = rexpc.findall(s)
+ if not results:
+ return ()
+ else:
+ result = rexpc.search(s)
+ if not result:
+ return ()
+ results = [ result.group() ]
+ results.extend( result.groups('') )
+ result_list = []
+ root = Element('matches')
+ for s_match in results:
+ if python.PyTuple_CheckExact(s_match):
+ s_match = ''.join(s_match)
+ elem = SubElement(root, 'match')
+ elem.text = s_match
+ result_list.append(elem)
+ return result_list
+
+ def replace(self, ctxt, s, rexp, flags, replacement):
+ replacement = self._make_string(replacement)
+ flags = self._make_string(flags)
+ s = self._make_string(s)
+ rexpc = self._compile(rexp, 'i' in flags)
+ count: object = 0 if 'g' in flags else 1
+ return rexpc.sub(replacement, s, count)
+
+ cdef _register_in_context(self, _BaseContext context):
+ ns = b"http://exslt.org/regular-expressions"
+ context._addLocalExtensionFunction(ns, b"test", self.test)
+ context._addLocalExtensionFunction(ns, b"match", self.match)
+ context._addLocalExtensionFunction(ns, b"replace", self.replace)
+
+
+################################################################################
+# helper functions
+
+cdef xpath.xmlXPathObject* _wrapXPathObject(object obj, _Document doc,
+ _BaseContext context) except NULL:
+ cdef xpath.xmlNodeSet* resultSet
+ cdef _Element fake_node = None
+ cdef xmlNode* c_node
+
+ if isinstance(obj, unicode):
+ obj = _utf8(obj)
+ if isinstance(obj, bytes):
+ # libxml2 copies the string value
+ return xpath.xmlXPathNewCString(_cstr(obj))
+ if isinstance(obj, bool):
+ return xpath.xmlXPathNewBoolean(obj)
+ if python.PyNumber_Check(obj):
+ return xpath.xmlXPathNewFloat(obj)
+ if obj is None:
+ resultSet = xpath.xmlXPathNodeSetCreate(NULL)
+ elif isinstance(obj, _Element):
+ resultSet = xpath.xmlXPathNodeSetCreate((<_Element>obj)._c_node)
+ elif python.PySequence_Check(obj):
+ resultSet = xpath.xmlXPathNodeSetCreate(NULL)
+ try:
+ for value in obj:
+ if isinstance(value, _Element):
+ if context is not None:
+ context._hold(value)
+ xpath.xmlXPathNodeSetAdd(resultSet, (<_Element>value)._c_node)
+ else:
+ if context is None or doc is None:
+ raise XPathResultError, \
+ f"Non-Element values not supported at this point - got {value!r}"
+ # support strings by appending text nodes to an Element
+ if isinstance(value, unicode):
+ value = _utf8(value)
+ if isinstance(value, bytes):
+ if fake_node is None:
+ fake_node = _makeElement("text-root", NULL, doc, None,
+ None, None, None, None, None)
+ context._hold(fake_node)
+ else:
+ # append a comment node to keep the text nodes separate
+ c_node = tree.xmlNewDocComment(doc._c_doc, "")
+ if c_node is NULL:
+ raise MemoryError()
+ tree.xmlAddChild(fake_node._c_node, c_node)
+ context._hold(value)
+ c_node = tree.xmlNewDocText(doc._c_doc, _xcstr(value))
+ if c_node is NULL:
+ raise MemoryError()
+ tree.xmlAddChild(fake_node._c_node, c_node)
+ xpath.xmlXPathNodeSetAdd(resultSet, c_node)
+ else:
+ raise XPathResultError, \
+ f"This is not a supported node-set result: {value!r}"
+ except:
+ xpath.xmlXPathFreeNodeSet(resultSet)
+ raise
+ else:
+ raise XPathResultError, f"Unknown return type: {python._fqtypename(obj).decode('utf8')}"
+ return xpath.xmlXPathWrapNodeSet(resultSet)
+
+cdef object _unwrapXPathObject(xpath.xmlXPathObject* xpathObj,
+ _Document doc, _BaseContext context):
+ if xpathObj.type == xpath.XPATH_UNDEFINED:
+ raise XPathResultError, "Undefined xpath result"
+ elif xpathObj.type == xpath.XPATH_NODESET:
+ return _createNodeSetResult(xpathObj, doc, context)
+ elif xpathObj.type == xpath.XPATH_BOOLEAN:
+ return xpathObj.boolval
+ elif xpathObj.type == xpath.XPATH_NUMBER:
+ return xpathObj.floatval
+ elif xpathObj.type == xpath.XPATH_STRING:
+ stringval = funicode(xpathObj.stringval)
+ if context._build_smart_strings:
+ stringval = _elementStringResultFactory(
+ stringval, None, None, False)
+ return stringval
+ elif xpathObj.type == xpath.XPATH_POINT:
+ raise NotImplementedError, "XPATH_POINT"
+ elif xpathObj.type == xpath.XPATH_RANGE:
+ raise NotImplementedError, "XPATH_RANGE"
+ elif xpathObj.type == xpath.XPATH_LOCATIONSET:
+ raise NotImplementedError, "XPATH_LOCATIONSET"
+ elif xpathObj.type == xpath.XPATH_USERS:
+ raise NotImplementedError, "XPATH_USERS"
+ elif xpathObj.type == xpath.XPATH_XSLT_TREE:
+ return _createNodeSetResult(xpathObj, doc, context)
+ else:
+ raise XPathResultError, f"Unknown xpath result {xpathObj.type}"
+
+cdef object _createNodeSetResult(xpath.xmlXPathObject* xpathObj, _Document doc,
+ _BaseContext context):
+ cdef xmlNode* c_node
+ cdef int i
+ cdef list result
+ result = []
+ if xpathObj.nodesetval is NULL:
+ return result
+ for i in range(xpathObj.nodesetval.nodeNr):
+ c_node = xpathObj.nodesetval.nodeTab[i]
+ _unpackNodeSetEntry(result, c_node, doc, context,
+ xpathObj.type == xpath.XPATH_XSLT_TREE)
+ return result
+
+cdef _unpackNodeSetEntry(list results, xmlNode* c_node, _Document doc,
+ _BaseContext context, bint is_fragment):
+ cdef xmlNode* c_child
+ if _isElement(c_node):
+ if c_node.doc != doc._c_doc and c_node.doc._private is NULL:
+ # XXX: works, but maybe not always the right thing to do?
+ # XPath: only runs when extensions create or copy trees
+ # -> we store Python refs to these, so that is OK
+ # XSLT: can it leak when merging trees from multiple sources?
+ c_node = tree.xmlDocCopyNode(c_node, doc._c_doc, 1)
+ # FIXME: call _instantiateElementFromXPath() instead?
+ results.append(
+ _fakeDocElementFactory(doc, c_node))
+ elif c_node.type == tree.XML_TEXT_NODE or \
+ c_node.type == tree.XML_CDATA_SECTION_NODE or \
+ c_node.type == tree.XML_ATTRIBUTE_NODE:
+ results.append(
+ _buildElementStringResult(doc, c_node, context))
+ elif c_node.type == tree.XML_NAMESPACE_DECL:
+ results.append( (funicodeOrNone((c_node).prefix),
+ funicodeOrNone((c_node).href)) )
+ elif c_node.type == tree.XML_DOCUMENT_NODE or \
+ c_node.type == tree.XML_HTML_DOCUMENT_NODE:
+ # ignored for everything but result tree fragments
+ if is_fragment:
+ c_child = c_node.children
+ while c_child is not NULL:
+ _unpackNodeSetEntry(results, c_child, doc, context, 0)
+ c_child = c_child.next
+ elif c_node.type == tree.XML_XINCLUDE_START or \
+ c_node.type == tree.XML_XINCLUDE_END:
+ pass
+ else:
+ raise NotImplementedError, \
+ f"Not yet implemented result node type: {c_node.type}"
+
+cdef void _freeXPathObject(xpath.xmlXPathObject* xpathObj) noexcept:
+ """Free the XPath object, but *never* free the *content* of node sets.
+ Python dealloc will do that for us.
+ """
+ if xpathObj.nodesetval is not NULL:
+ xpath.xmlXPathFreeNodeSet(xpathObj.nodesetval)
+ xpathObj.nodesetval = NULL
+ xpath.xmlXPathFreeObject(xpathObj)
+
+cdef _Element _instantiateElementFromXPath(xmlNode* c_node, _Document doc,
+ _BaseContext context):
+ # NOTE: this may copy the element - only call this when it can't leak
+ if c_node.doc != doc._c_doc and c_node.doc._private is NULL:
+ # not from the context document and not from a fake document
+ # either => may still be from a known document, e.g. one
+ # created by an extension function
+ node_doc = context._findDocumentForNode(c_node)
+ if node_doc is None:
+ # not from a known document at all! => can only make a
+ # safety copy here
+ c_node = tree.xmlDocCopyNode(c_node, doc._c_doc, 1)
+ else:
+ doc = node_doc
+ return _fakeDocElementFactory(doc, c_node)
+
+################################################################################
+# special str/unicode subclasses
+
+@cython.final
+cdef class _ElementUnicodeResult(unicode):
+ cdef _Element _parent
+ cdef readonly object attrname
+ cdef readonly bint is_tail
+
+ def getparent(self):
+ return self._parent
+
+ @property
+ def is_text(self):
+ return self._parent is not None and not (self.is_tail or self.attrname is not None)
+
+ @property
+ def is_attribute(self):
+ return self.attrname is not None
+
+cdef object _elementStringResultFactory(string_value, _Element parent,
+ attrname, bint is_tail):
+ result = _ElementUnicodeResult(string_value)
+ result._parent = parent
+ result.is_tail = is_tail
+ result.attrname = attrname
+ return result
+
+cdef object _buildElementStringResult(_Document doc, xmlNode* c_node,
+ _BaseContext context):
+ cdef _Element parent = None
+ cdef object attrname = None
+ cdef xmlNode* c_element
+ cdef bint is_tail
+
+ if c_node.type == tree.XML_ATTRIBUTE_NODE:
+ attrname = _namespacedName(c_node)
+ is_tail = 0
+ s = tree.xmlNodeGetContent(c_node)
+ try:
+ value = funicode(s)
+ finally:
+ tree.xmlFree(s)
+ c_element = NULL
+ else:
+ #assert c_node.type == tree.XML_TEXT_NODE or c_node.type == tree.XML_CDATA_SECTION_NODE, "invalid node type"
+ # may be tail text or normal text
+ value = funicode(c_node.content)
+ c_element = _previousElement(c_node)
+ is_tail = c_element is not NULL
+
+ if not context._build_smart_strings:
+ return value
+
+ if c_element is NULL:
+ # non-tail text or attribute text
+ c_element = c_node.parent
+ while c_element is not NULL and not _isElement(c_element):
+ c_element = c_element.parent
+
+ if c_element is not NULL:
+ parent = _instantiateElementFromXPath(c_element, doc, context)
+
+ return _elementStringResultFactory(
+ value, parent, attrname, is_tail)
+
+################################################################################
+# callbacks for XPath/XSLT extension functions
+
+cdef void _extension_function_call(_BaseContext context, function,
+ xpath.xmlXPathParserContext* ctxt, int nargs) noexcept:
+ cdef _Document doc
+ cdef xpath.xmlXPathObject* obj
+ cdef list args
+ cdef int i
+ doc = context._doc
+ try:
+ args = []
+ for i in range(nargs):
+ obj = xpath.valuePop(ctxt)
+ o = _unwrapXPathObject(obj, doc, context)
+ _freeXPathObject(obj)
+ args.append(o)
+ args.reverse()
+
+ res = function(context, *args)
+ # wrap result for XPath consumption
+ obj = _wrapXPathObject(res, doc, context)
+ # prevent Python from deallocating elements handed to libxml2
+ context._hold(res)
+ xpath.valuePush(ctxt, obj)
+ except:
+ xpath.xmlXPathErr(ctxt, xpath.XPATH_EXPR_ERROR)
+ context._exc._store_raised()
+ finally:
+ return # swallow any further exceptions
+
+# lookup the function by name and call it
+
+cdef void _xpath_function_call(xpath.xmlXPathParserContext* ctxt,
+ int nargs) noexcept with gil:
+ cdef _BaseContext context
+ cdef xpath.xmlXPathContext* rctxt = ctxt.context
+ context = <_BaseContext> rctxt.userData
+ try:
+ function = context._find_cached_function(rctxt.functionURI, rctxt.function)
+ if function is not None:
+ _extension_function_call(context, function, ctxt, nargs)
+ else:
+ xpath.xmlXPathErr(ctxt, xpath.XPATH_UNKNOWN_FUNC_ERROR)
+ context._exc._store_exception(XPathFunctionError(
+ f"XPath function '{_namespacedNameFromNsName(rctxt.functionURI, rctxt.function)}' not found"))
+ except:
+ # may not be the right error, but we need to tell libxml2 *something*
+ xpath.xmlXPathErr(ctxt, xpath.XPATH_UNKNOWN_FUNC_ERROR)
+ context._exc._store_raised()
+ finally:
+ return # swallow any further exceptions
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/__init__.pxd b/llava_video/lib/python3.10/site-packages/lxml/includes/__init__.pxd
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/__init__.py b/llava_video/lib/python3.10/site-packages/lxml/includes/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/c14n.pxd b/llava_video/lib/python3.10/site-packages/lxml/includes/c14n.pxd
new file mode 100644
index 0000000000000000000000000000000000000000..8b1f3c4c516b23ec938da286e0ddb7b8f5795ee2
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/includes/c14n.pxd
@@ -0,0 +1,25 @@
+from lxml.includes.tree cimport xmlDoc, xmlOutputBuffer, xmlChar
+from lxml.includes.xpath cimport xmlNodeSet
+
+cdef extern from "libxml/c14n.h" nogil:
+ cdef int xmlC14NDocDumpMemory(xmlDoc* doc,
+ xmlNodeSet* nodes,
+ int exclusive,
+ xmlChar** inclusive_ns_prefixes,
+ int with_comments,
+ xmlChar** doc_txt_ptr)
+
+ cdef int xmlC14NDocSave(xmlDoc* doc,
+ xmlNodeSet* nodes,
+ int exclusive,
+ xmlChar** inclusive_ns_prefixes,
+ int with_comments,
+ char* filename,
+ int compression)
+
+ cdef int xmlC14NDocSaveTo(xmlDoc* doc,
+ xmlNodeSet* nodes,
+ int exclusive,
+ xmlChar** inclusive_ns_prefixes,
+ int with_comments,
+ xmlOutputBuffer* buffer)
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/config.pxd b/llava_video/lib/python3.10/site-packages/lxml/includes/config.pxd
new file mode 100644
index 0000000000000000000000000000000000000000..9c04438f737374901d92acc497e4175ebc216891
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/includes/config.pxd
@@ -0,0 +1,3 @@
+cdef extern from "etree_defs.h":
+ cdef bint ENABLE_THREADING
+ cdef bint ENABLE_SCHEMATRON
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/dtdvalid.pxd b/llava_video/lib/python3.10/site-packages/lxml/includes/dtdvalid.pxd
new file mode 100644
index 0000000000000000000000000000000000000000..2ad49db11b20e4e710f4f55cf5590ef3928f1058
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/includes/dtdvalid.pxd
@@ -0,0 +1,18 @@
+from lxml.includes cimport tree
+from lxml.includes.tree cimport xmlDoc, xmlDtd
+
+cdef extern from "libxml/valid.h" nogil:
+ ctypedef void (*xmlValidityErrorFunc)(void * ctx, const char * msg, ...) noexcept
+ ctypedef void (*xmlValidityWarningFunc)(void * ctx, const char * msg, ...) noexcept
+
+ ctypedef struct xmlValidCtxt:
+ void *userData
+ xmlValidityErrorFunc error
+ xmlValidityWarningFunc warning
+
+ cdef xmlValidCtxt* xmlNewValidCtxt()
+ cdef void xmlFreeValidCtxt(xmlValidCtxt* cur)
+
+ cdef int xmlValidateDtd(xmlValidCtxt* ctxt, xmlDoc* doc, xmlDtd* dtd)
+ cdef tree.xmlElement* xmlGetDtdElementDesc(
+ xmlDtd* dtd, tree.const_xmlChar* name)
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/etree_defs.h b/llava_video/lib/python3.10/site-packages/lxml/includes/etree_defs.h
new file mode 100644
index 0000000000000000000000000000000000000000..17d470d03ae251880e70d33940bfcda14399ce8a
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/includes/etree_defs.h
@@ -0,0 +1,379 @@
+#ifndef HAS_ETREE_DEFS_H
+#define HAS_ETREE_DEFS_H
+
+/* quick check for Python/libxml2/libxslt devel setup */
+#include "Python.h"
+#ifndef PY_VERSION_HEX
+# error the development package of Python (header files etc.) is not installed correctly
+#elif PY_VERSION_HEX < 0x03060000
+# error this version of lxml requires Python 3.6 or later
+#endif
+
+#include "libxml/xmlversion.h"
+#ifndef LIBXML_VERSION
+# error the development package of libxml2 (header files etc.) is not installed correctly
+#elif LIBXML_VERSION < 20700
+# error minimum required version of libxml2 is 2.7.0
+#endif
+
+#include "libxslt/xsltconfig.h"
+#ifndef LIBXSLT_VERSION
+# error the development package of libxslt (header files etc.) is not installed correctly
+#elif LIBXSLT_VERSION < 10123
+# error minimum required version of libxslt is 1.1.23
+#endif
+
+
+/* v_arg functions */
+#define va_int(ap) va_arg(ap, int)
+#define va_charptr(ap) va_arg(ap, char *)
+
+#ifdef PYPY_VERSION
+# define IS_PYPY 1
+#else
+# define IS_PYPY 0
+#endif
+
+/* unused */
+#define IS_PYTHON2 0
+#define IS_PYTHON3 1
+#undef LXML_UNICODE_STRINGS
+#define LXML_UNICODE_STRINGS 1
+
+#if !IS_PYPY
+# define PyWeakref_LockObject(obj) (NULL)
+#endif
+
+/* Threading is not currently supported by PyPy */
+#if IS_PYPY
+# ifndef WITHOUT_THREADING
+# define WITHOUT_THREADING
+# endif
+#endif
+
+#if IS_PYPY
+# ifndef PyUnicode_FromFormat
+# define PyUnicode_FromFormat PyString_FromFormat
+# endif
+# if !defined(PyBytes_FromFormat)
+# ifdef PyString_FromFormat
+# define PyBytes_FromFormat PyString_FromFormat
+# else
+#include
+static PyObject* PyBytes_FromFormat(const char* format, ...) {
+ PyObject *string;
+ va_list vargs;
+#ifdef HAVE_STDARG_PROTOTYPES
+ va_start(vargs, format);
+#else
+ va_start(vargs);
+#endif
+ string = PyUnicode_FromFormatV(format, vargs);
+ va_end(vargs);
+ if (string && PyUnicode_Check(string)) {
+ PyObject *bstring = PyUnicode_AsUTF8String(string);
+ Py_DECREF(string);
+ string = bstring;
+ }
+ if (string && !PyBytes_CheckExact(string)) {
+ Py_DECREF(string);
+ string = NULL;
+ PyErr_SetString(PyExc_TypeError, "String formatting and encoding failed to return bytes object");
+ }
+ return string;
+}
+# endif
+# endif
+#endif
+
+#if PY_VERSION_HEX >= 0x030B00A1
+/* Python 3.12 doesn't have wstr Unicode strings any more. */
+#undef PyUnicode_GET_DATA_SIZE
+#define PyUnicode_GET_DATA_SIZE(ustr) (0)
+#undef PyUnicode_AS_DATA
+#define PyUnicode_AS_DATA(ustr) (NULL)
+#undef PyUnicode_IS_READY
+#define PyUnicode_IS_READY(ustr) (1)
+#endif
+
+#ifdef WITHOUT_THREADING
+# undef PyEval_SaveThread
+# define PyEval_SaveThread() (NULL)
+# undef PyEval_RestoreThread
+# define PyEval_RestoreThread(state) if (state); else {}
+# undef PyGILState_Ensure
+# define PyGILState_Ensure() (PyGILState_UNLOCKED)
+# undef PyGILState_Release
+# define PyGILState_Release(state) if (state); else {}
+# undef Py_UNBLOCK_THREADS
+# define Py_UNBLOCK_THREADS _save = NULL;
+# undef Py_BLOCK_THREADS
+# define Py_BLOCK_THREADS if (_save); else {}
+#endif
+
+#ifdef WITHOUT_THREADING
+# define ENABLE_THREADING 0
+#else
+# define ENABLE_THREADING 1
+#endif
+
+#if LIBXML_VERSION < 20704
+/* FIXME: hack to make new error reporting compile in old libxml2 versions */
+# define xmlStructuredErrorContext NULL
+# define xmlXIncludeProcessTreeFlagsData(n,o,d) xmlXIncludeProcessTreeFlags(n,o)
+#endif
+
+/* schematron was added in libxml2 2.6.21 */
+#ifdef LIBXML_SCHEMATRON_ENABLED
+# define ENABLE_SCHEMATRON 1
+#else
+# define ENABLE_SCHEMATRON 0
+# define XML_SCHEMATRON_OUT_QUIET 0
+# define XML_SCHEMATRON_OUT_XML 0
+# define XML_SCHEMATRON_OUT_ERROR 0
+ typedef void xmlSchematron;
+ typedef void xmlSchematronParserCtxt;
+ typedef void xmlSchematronValidCtxt;
+# define xmlSchematronNewDocParserCtxt(doc) NULL
+# define xmlSchematronNewParserCtxt(file) NULL
+# define xmlSchematronParse(ctxt) NULL
+# define xmlSchematronFreeParserCtxt(ctxt)
+# define xmlSchematronFree(schema)
+# define xmlSchematronNewValidCtxt(schema, options) NULL
+# define xmlSchematronValidateDoc(ctxt, doc) 0
+# define xmlSchematronFreeValidCtxt(ctxt)
+# define xmlSchematronSetValidStructuredErrors(ctxt, errorfunc, data)
+#endif
+
+#if LIBXML_VERSION < 20708
+# define HTML_PARSE_NODEFDTD 4
+#endif
+#if LIBXML_VERSION < 20900
+# define XML_PARSE_BIG_LINES 4194304
+#endif
+
+#include "libxml/tree.h"
+#ifndef LIBXML2_NEW_BUFFER
+ typedef xmlBuffer xmlBuf;
+# define xmlBufContent(buf) xmlBufferContent(buf)
+# define xmlBufUse(buf) xmlBufferLength(buf)
+#endif
+
+/* libexslt 1.1.25+ support EXSLT functions in XPath */
+#if LIBXSLT_VERSION < 10125
+#define exsltDateXpathCtxtRegister(ctxt, prefix)
+#define exsltSetsXpathCtxtRegister(ctxt, prefix)
+#define exsltMathXpathCtxtRegister(ctxt, prefix)
+#define exsltStrXpathCtxtRegister(ctxt, prefix)
+#endif
+
+#define LXML_GET_XSLT_ENCODING(result_var, style) XSLT_GET_IMPORT_PTR(result_var, style, encoding)
+
+/* work around MSDEV 6.0 */
+#if (_MSC_VER == 1200) && (WINVER < 0x0500)
+long _ftol( double ); //defined by VC6 C libs
+long _ftol2( double dblSource ) { return _ftol( dblSource ); }
+#endif
+
+#ifdef __GNUC__
+/* Test for GCC > 2.95 */
+#if __GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))
+#define unlikely_condition(x) __builtin_expect((x), 0)
+#else /* __GNUC__ > 2 ... */
+#define unlikely_condition(x) (x)
+#endif /* __GNUC__ > 2 ... */
+#else /* __GNUC__ */
+#define unlikely_condition(x) (x)
+#endif /* __GNUC__ */
+
+#ifndef Py_TYPE
+ #define Py_TYPE(ob) (((PyObject*)(ob))->ob_type)
+#endif
+
+#define PY_NEW(T) \
+ (((PyTypeObject*)(T))->tp_new( \
+ (PyTypeObject*)(T), __pyx_empty_tuple, NULL))
+
+#define _fqtypename(o) ((Py_TYPE(o))->tp_name)
+
+#define lxml_malloc(count, item_size) \
+ (unlikely_condition((size_t)(count) > (size_t) (PY_SSIZE_T_MAX / item_size)) ? NULL : \
+ (PyMem_Malloc((count) * item_size)))
+
+#define lxml_realloc(mem, count, item_size) \
+ (unlikely_condition((size_t)(count) > (size_t) (PY_SSIZE_T_MAX / item_size)) ? NULL : \
+ (PyMem_Realloc(mem, (count) * item_size)))
+
+#define lxml_free(mem) PyMem_Free(mem)
+
+#define _isString(obj) (PyUnicode_Check(obj) || PyBytes_Check(obj))
+
+#define _isElement(c_node) \
+ (((c_node)->type == XML_ELEMENT_NODE) || \
+ ((c_node)->type == XML_COMMENT_NODE) || \
+ ((c_node)->type == XML_ENTITY_REF_NODE) || \
+ ((c_node)->type == XML_PI_NODE))
+
+#define _isElementOrXInclude(c_node) \
+ (_isElement(c_node) || \
+ ((c_node)->type == XML_XINCLUDE_START) || \
+ ((c_node)->type == XML_XINCLUDE_END))
+
+#define _getNs(c_node) \
+ (((c_node)->ns == 0) ? 0 : ((c_node)->ns->href))
+
+
+#include "string.h"
+static void* lxml_unpack_xmldoc_capsule(PyObject* capsule, int* is_owned) {
+ xmlDoc *c_doc;
+ void *context;
+ *is_owned = 0;
+ if (unlikely_condition(!PyCapsule_IsValid(capsule, (const char*)"libxml2:xmlDoc"))) {
+ PyErr_SetString(
+ PyExc_TypeError,
+ "Not a valid capsule. The capsule argument must be a capsule object with name libxml2:xmlDoc");
+ return NULL;
+ }
+ c_doc = (xmlDoc*) PyCapsule_GetPointer(capsule, (const char*)"libxml2:xmlDoc");
+ if (unlikely_condition(!c_doc)) return NULL;
+
+ if (unlikely_condition(c_doc->type != XML_DOCUMENT_NODE && c_doc->type != XML_HTML_DOCUMENT_NODE)) {
+ PyErr_Format(
+ PyExc_ValueError,
+ "Illegal document provided: expected XML or HTML, found %d", (int)c_doc->type);
+ return NULL;
+ }
+
+ context = PyCapsule_GetContext(capsule);
+ if (unlikely_condition(!context && PyErr_Occurred())) return NULL;
+ if (context && strcmp((const char*) context, "destructor:xmlFreeDoc") == 0) {
+ /* take ownership by setting destructor to NULL */
+ if (PyCapsule_SetDestructor(capsule, NULL) == 0) {
+ /* ownership transferred => invalidate capsule by clearing its name */
+ if (unlikely_condition(PyCapsule_SetName(capsule, NULL))) {
+ /* this should never happen since everything above succeeded */
+ xmlFreeDoc(c_doc);
+ return NULL;
+ }
+ *is_owned = 1;
+ }
+ }
+ return c_doc;
+}
+
+/* Macro pair implementation of a depth first tree walker
+ *
+ * Calls the code block between the BEGIN and END macros for all elements
+ * below c_tree_top (exclusively), starting at c_node (inclusively iff
+ * 'inclusive' is 1). The _ELEMENT_ variants will only stop on nodes
+ * that match _isElement(), the normal variant will stop on every node
+ * except text nodes.
+ *
+ * To traverse the node and all of its children and siblings in Pyrex, call
+ * cdef xmlNode* some_node
+ * BEGIN_FOR_EACH_ELEMENT_FROM(some_node.parent, some_node, 1)
+ * # do something with some_node
+ * END_FOR_EACH_ELEMENT_FROM(some_node)
+ *
+ * To traverse only the children and siblings of a node, call
+ * cdef xmlNode* some_node
+ * BEGIN_FOR_EACH_ELEMENT_FROM(some_node.parent, some_node, 0)
+ * # do something with some_node
+ * END_FOR_EACH_ELEMENT_FROM(some_node)
+ *
+ * To traverse only the children, do:
+ * cdef xmlNode* some_node
+ * some_node = parent_node.children
+ * BEGIN_FOR_EACH_ELEMENT_FROM(parent_node, some_node, 1)
+ * # do something with some_node
+ * END_FOR_EACH_ELEMENT_FROM(some_node)
+ *
+ * NOTE: 'some_node' MUST be a plain 'xmlNode*' !
+ *
+ * NOTE: parent modification during the walk can divert the iterator, but
+ * should not segfault !
+ */
+
+#define _LX__ELEMENT_MATCH(c_node, only_elements) \
+ ((only_elements) ? (_isElement(c_node)) : 1)
+
+#define _LX__ADVANCE_TO_NEXT(c_node, only_elements) \
+ while ((c_node != 0) && (!_LX__ELEMENT_MATCH(c_node, only_elements))) \
+ c_node = c_node->next;
+
+#define _LX__TRAVERSE_TO_NEXT(c_stop_node, c_node, only_elements) \
+{ \
+ /* walk through children first */ \
+ xmlNode* _lx__next = c_node->children; \
+ if (_lx__next != 0) { \
+ if (c_node->type == XML_ENTITY_REF_NODE || c_node->type == XML_DTD_NODE) { \
+ _lx__next = 0; \
+ } else { \
+ _LX__ADVANCE_TO_NEXT(_lx__next, only_elements) \
+ } \
+ } \
+ if ((_lx__next == 0) && (c_node != c_stop_node)) { \
+ /* try siblings */ \
+ _lx__next = c_node->next; \
+ _LX__ADVANCE_TO_NEXT(_lx__next, only_elements) \
+ /* back off through parents */ \
+ while (_lx__next == 0) { \
+ c_node = c_node->parent; \
+ if (c_node == 0) \
+ break; \
+ if (c_node == c_stop_node) \
+ break; \
+ if ((only_elements) && !_isElement(c_node)) \
+ break; \
+ /* we already traversed the parents -> siblings */ \
+ _lx__next = c_node->next; \
+ _LX__ADVANCE_TO_NEXT(_lx__next, only_elements) \
+ } \
+ } \
+ c_node = _lx__next; \
+}
+
+#define _LX__BEGIN_FOR_EACH_FROM(c_tree_top, c_node, inclusive, only_elements) \
+{ \
+ if (c_node != 0) { \
+ const xmlNode* _lx__tree_top = (c_tree_top); \
+ const int _lx__only_elements = (only_elements); \
+ /* make sure we start at an element */ \
+ if (!_LX__ELEMENT_MATCH(c_node, _lx__only_elements)) { \
+ /* we skip the node, so 'inclusive' is irrelevant */ \
+ if (c_node == _lx__tree_top) \
+ c_node = 0; /* nothing to traverse */ \
+ else { \
+ c_node = c_node->next; \
+ _LX__ADVANCE_TO_NEXT(c_node, _lx__only_elements) \
+ } \
+ } else if (! (inclusive)) { \
+ /* skip the first node */ \
+ _LX__TRAVERSE_TO_NEXT(_lx__tree_top, c_node, _lx__only_elements) \
+ } \
+ \
+ /* now run the user code on the elements we find */ \
+ while (c_node != 0) { \
+ /* here goes the code to be run for each element */
+
+#define _LX__END_FOR_EACH_FROM(c_node) \
+ _LX__TRAVERSE_TO_NEXT(_lx__tree_top, c_node, _lx__only_elements) \
+ } \
+ } \
+}
+
+
+#define BEGIN_FOR_EACH_ELEMENT_FROM(c_tree_top, c_node, inclusive) \
+ _LX__BEGIN_FOR_EACH_FROM(c_tree_top, c_node, inclusive, 1)
+
+#define END_FOR_EACH_ELEMENT_FROM(c_node) \
+ _LX__END_FOR_EACH_FROM(c_node)
+
+#define BEGIN_FOR_EACH_FROM(c_tree_top, c_node, inclusive) \
+ _LX__BEGIN_FOR_EACH_FROM(c_tree_top, c_node, inclusive, 0)
+
+#define END_FOR_EACH_FROM(c_node) \
+ _LX__END_FOR_EACH_FROM(c_node)
+
+
+#endif /* HAS_ETREE_DEFS_H */
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/etreepublic.pxd b/llava_video/lib/python3.10/site-packages/lxml/includes/etreepublic.pxd
new file mode 100644
index 0000000000000000000000000000000000000000..7ef001b17b765de2a94172412681e6029e931c54
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/includes/etreepublic.pxd
@@ -0,0 +1,237 @@
+# public Cython/C interface to lxml.etree
+
+from lxml.includes cimport tree
+from lxml.includes.tree cimport const_xmlChar
+
+cdef extern from "lxml-version.h":
+ cdef char* LXML_VERSION_STRING
+
+cdef extern from "etree_defs.h":
+ # test if c_node is considered an Element (i.e. Element, Comment, etc.)
+ cdef bint _isElement(tree.xmlNode* c_node) noexcept nogil
+
+ # return the namespace URI of the node or NULL
+ cdef const_xmlChar* _getNs(tree.xmlNode* node) noexcept nogil
+
+ # pair of macros for tree traversal
+ cdef void BEGIN_FOR_EACH_ELEMENT_FROM(tree.xmlNode* tree_top,
+ tree.xmlNode* start_node,
+ int start_node_inclusive) noexcept nogil
+ cdef void END_FOR_EACH_ELEMENT_FROM(tree.xmlNode* start_node) noexcept nogil
+
+cdef extern from "etree_api.h":
+
+ # first function to call!
+ cdef int import_lxml__etree() except -1
+
+ ##########################################################################
+ # public ElementTree API classes
+
+ cdef class lxml.etree._Document [ object LxmlDocument ]:
+ cdef tree.xmlDoc* _c_doc
+
+ cdef class lxml.etree._Element [ object LxmlElement ]:
+ cdef _Document _doc
+ cdef tree.xmlNode* _c_node
+
+ cdef class lxml.etree.ElementBase(_Element) [ object LxmlElementBase ]:
+ pass
+
+ cdef class lxml.etree._ElementTree [ object LxmlElementTree ]:
+ cdef _Document _doc
+ cdef _Element _context_node
+
+ cdef class lxml.etree.ElementClassLookup [ object LxmlElementClassLookup ]:
+ cdef object (*_lookup_function)(object, _Document, tree.xmlNode*)
+
+ cdef class lxml.etree.FallbackElementClassLookup(ElementClassLookup) \
+ [ object LxmlFallbackElementClassLookup ]:
+ cdef ElementClassLookup fallback
+ cdef object (*_fallback_function)(object, _Document, tree.xmlNode*)
+
+ ##########################################################################
+ # creating Element objects
+
+ # create an Element for a C-node in the Document
+ cdef _Element elementFactory(_Document doc, tree.xmlNode* c_node)
+
+ # create an ElementTree for an Element
+ cdef _ElementTree elementTreeFactory(_Element context_node)
+
+ # create an ElementTree subclass for an Element
+ cdef _ElementTree newElementTree(_Element context_node, object subclass)
+
+ # create an ElementTree from an external document
+ cdef _ElementTree adoptExternalDocument(tree.xmlDoc* c_doc, parser, bint is_owned)
+
+ # create a new Element for an existing or new document (doc = None)
+ # builds Python object after setting text, tail, namespaces and attributes
+ cdef _Element makeElement(tag, _Document doc, parser,
+ text, tail, attrib, nsmap)
+
+ # create a new SubElement for an existing parent
+ # builds Python object after setting text, tail, namespaces and attributes
+ cdef _Element makeSubElement(_Element parent, tag, text, tail,
+ attrib, nsmap)
+
+ # deep copy a node to include it in the Document
+ cdef _Element deepcopyNodeToDocument(_Document doc, tree.xmlNode* c_root)
+
+ # set the internal lookup function for Element/Comment/PI classes
+ # use setElementClassLookupFunction(NULL, None) to reset it
+ # note that the lookup function *must always* return an _Element subclass!
+ cdef void setElementClassLookupFunction(
+ object (*function)(object, _Document, tree.xmlNode*), object state)
+
+ # lookup function that always returns the default Element class
+ # note that the first argument is expected to be None!
+ cdef object lookupDefaultElementClass(_1, _Document _2,
+ tree.xmlNode* c_node)
+
+ # lookup function for namespace/tag specific Element classes
+ # note that the first argument is expected to be None!
+ cdef object lookupNamespaceElementClass(_1, _Document _2,
+ tree.xmlNode* c_node)
+
+ # call the fallback lookup function of a FallbackElementClassLookup
+ cdef object callLookupFallback(FallbackElementClassLookup lookup,
+ _Document doc, tree.xmlNode* c_node)
+
+ ##########################################################################
+ # XML attribute access
+
+ # return an attribute value for a C attribute on a C element node
+ cdef unicode attributeValue(tree.xmlNode* c_element,
+ tree.xmlAttr* c_attrib_node)
+
+ # return the value of the attribute with 'ns' and 'name' (or None)
+ cdef unicode attributeValueFromNsName(tree.xmlNode* c_element,
+ const_xmlChar* c_ns, const_xmlChar* c_name)
+
+ # return the value of attribute "{ns}name", or the default value
+ cdef object getAttributeValue(_Element element, key, default)
+
+ # return an iterator over attribute names (1), values (2) or items (3)
+ # attributes must not be removed during iteration!
+ cdef object iterattributes(_Element element, int keysvalues)
+
+ # return the list of all attribute names (1), values (2) or items (3)
+ cdef list collectAttributes(tree.xmlNode* c_element, int keysvalues)
+
+ # set an attribute value on an element
+ # on failure, sets an exception and returns -1
+ cdef int setAttributeValue(_Element element, key, value) except -1
+
+ # delete an attribute
+ # on failure, sets an exception and returns -1
+ cdef int delAttribute(_Element element, key) except -1
+
+ # delete an attribute based on name and namespace URI
+ # returns -1 if the attribute was not found (no exception)
+ cdef int delAttributeFromNsName(tree.xmlNode* c_element,
+ const_xmlChar* c_href, const_xmlChar* c_name) noexcept
+
+ ##########################################################################
+ # XML node helper functions
+
+ # check if the element has at least one child
+ cdef bint hasChild(tree.xmlNode* c_node) noexcept nogil
+
+ # find child element number 'index' (supports negative indexes)
+ cdef tree.xmlNode* findChild(tree.xmlNode* c_node,
+ Py_ssize_t index) noexcept nogil
+
+ # find child element number 'index' starting at first one
+ cdef tree.xmlNode* findChildForwards(tree.xmlNode* c_node,
+ Py_ssize_t index) nogil
+
+ # find child element number 'index' starting at last one
+ cdef tree.xmlNode* findChildBackwards(tree.xmlNode* c_node,
+ Py_ssize_t index) nogil
+
+ # return next/previous sibling element of the node
+ cdef tree.xmlNode* nextElement(tree.xmlNode* c_node) nogil
+ cdef tree.xmlNode* previousElement(tree.xmlNode* c_node) nogil
+
+ ##########################################################################
+ # iterators (DEPRECATED API, don't use in new code!)
+
+ cdef class lxml.etree._ElementTagMatcher [ object LxmlElementTagMatcher ]:
+ cdef char* _href
+ cdef char* _name
+
+ # store "{ns}tag" (or None) filter for this matcher or element iterator
+ # ** unless _href *and* _name are set up 'by hand', this function *must*
+ # ** be called when subclassing the iterator below!
+ cdef void initTagMatch(_ElementTagMatcher matcher, tag)
+
+ cdef class lxml.etree._ElementIterator(_ElementTagMatcher) [
+ object LxmlElementIterator ]:
+ cdef _Element _node
+ cdef tree.xmlNode* (*_next_element)(tree.xmlNode*)
+
+ # store the initial node of the iterator if it matches the required tag
+ # or its next matching sibling if not
+ cdef void iteratorStoreNext(_ElementIterator iterator, _Element node)
+
+ ##########################################################################
+ # other helper functions
+
+ # check if a C node matches a tag name and namespace
+ # (NULL allowed for each => always matches)
+ cdef int tagMatches(tree.xmlNode* c_node, const_xmlChar* c_href, const_xmlChar* c_name)
+
+ # convert a UTF-8 char* to a Python unicode string
+ cdef unicode pyunicode(const_xmlChar* s)
+
+ # convert the string to UTF-8 using the normal lxml.etree semantics
+ cdef bytes utf8(object s)
+
+ # split a tag into a (URI, name) tuple, return None as URI for '{}tag'
+ cdef tuple getNsTag(object tag)
+
+ # split a tag into a (URI, name) tuple, return b'' as URI for '{}tag'
+ cdef tuple getNsTagWithEmptyNs(object tag)
+
+ # get the "{ns}tag" string for a C node
+ cdef unicode namespacedName(tree.xmlNode* c_node)
+
+ # get the "{ns}tag" string for a href/tagname pair (c_ns may be NULL)
+ cdef unicode namespacedNameFromNsName(const_xmlChar* c_ns, const_xmlChar* c_tag)
+
+ # check if the node has a text value (which may be '')
+ cdef bint hasText(tree.xmlNode* c_node) nogil
+
+ # check if the node has a tail value (which may be '')
+ cdef bint hasTail(tree.xmlNode* c_node) nogil
+
+ # get the text content of an element (or None)
+ cdef unicode textOf(tree.xmlNode* c_node)
+
+ # get the tail content of an element (or None)
+ cdef unicode tailOf(tree.xmlNode* c_node)
+
+ # set the text value of an element
+ cdef int setNodeText(tree.xmlNode* c_node, text) except -1
+
+ # set the tail text value of an element
+ cdef int setTailText(tree.xmlNode* c_node, text) except -1
+
+ # append an element to the children of a parent element
+ # deprecated: don't use, does not propagate exceptions!
+ # use appendChildToElement() instead
+ cdef void appendChild(_Element parent, _Element child)
+
+ # added in lxml 3.3 as a safe replacement for appendChild()
+ # return -1 for exception, 0 for ok
+ cdef int appendChildToElement(_Element parent, _Element child) except -1
+
+ # recursively lookup a namespace in element or ancestors, or create it
+ cdef tree.xmlNs* findOrBuildNodeNsPrefix(
+ _Document doc, tree.xmlNode* c_node, const_xmlChar* href, const_xmlChar* prefix)
+
+ # find the Document of an Element, ElementTree or Document (itself!)
+ cdef _Document documentOrRaise(object input)
+
+ # find the root Element of an Element (itself!), ElementTree or Document
+ cdef _Element rootNodeOrRaise(object input)
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/htmlparser.pxd b/llava_video/lib/python3.10/site-packages/lxml/includes/htmlparser.pxd
new file mode 100644
index 0000000000000000000000000000000000000000..31dcc406cdc3d006afe811e7e1f778b56407510f
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/includes/htmlparser.pxd
@@ -0,0 +1,56 @@
+from libc.string cimport const_char
+
+from lxml.includes.tree cimport xmlDoc
+from lxml.includes.tree cimport xmlInputReadCallback, xmlInputCloseCallback
+from lxml.includes.xmlparser cimport xmlParserCtxt, xmlSAXHandler, xmlSAXHandlerV1
+
+cdef extern from "libxml/HTMLparser.h" nogil:
+ ctypedef enum htmlParserOption:
+ HTML_PARSE_NOERROR # suppress error reports
+ HTML_PARSE_NOWARNING # suppress warning reports
+ HTML_PARSE_PEDANTIC # pedantic error reporting
+ HTML_PARSE_NOBLANKS # remove blank nodes
+ HTML_PARSE_NONET # Forbid network access
+ # libxml2 2.6.21+ only:
+ HTML_PARSE_RECOVER # Relaxed parsing
+ HTML_PARSE_COMPACT # compact small text nodes
+ # libxml2 2.7.7+ only:
+ HTML_PARSE_NOIMPLIED # Do not add implied html/body... elements
+ # libxml2 2.7.8+ only:
+ HTML_PARSE_NODEFDTD # do not default a doctype if not found
+ # libxml2 2.8.0+ only:
+ XML_PARSE_IGNORE_ENC # ignore internal document encoding hint
+
+ xmlSAXHandlerV1 htmlDefaultSAXHandler
+
+ cdef xmlParserCtxt* htmlCreateMemoryParserCtxt(
+ char* buffer, int size)
+ cdef xmlParserCtxt* htmlCreateFileParserCtxt(
+ char* filename, char* encoding)
+ cdef xmlParserCtxt* htmlCreatePushParserCtxt(xmlSAXHandler* sax,
+ void* user_data,
+ char* chunk, int size,
+ char* filename, int enc)
+ cdef void htmlFreeParserCtxt(xmlParserCtxt* ctxt)
+ cdef void htmlCtxtReset(xmlParserCtxt* ctxt)
+ cdef int htmlCtxtUseOptions(xmlParserCtxt* ctxt, int options)
+ cdef int htmlParseDocument(xmlParserCtxt* ctxt)
+ cdef int htmlParseChunk(xmlParserCtxt* ctxt,
+ char* chunk, int size, int terminate)
+
+ cdef xmlDoc* htmlCtxtReadFile(xmlParserCtxt* ctxt,
+ char* filename, const_char* encoding,
+ int options)
+ cdef xmlDoc* htmlCtxtReadDoc(xmlParserCtxt* ctxt,
+ char* buffer, char* URL, const_char* encoding,
+ int options)
+ cdef xmlDoc* htmlCtxtReadIO(xmlParserCtxt* ctxt,
+ xmlInputReadCallback ioread,
+ xmlInputCloseCallback ioclose,
+ void* ioctx,
+ char* URL, const_char* encoding,
+ int options)
+ cdef xmlDoc* htmlCtxtReadMemory(xmlParserCtxt* ctxt,
+ char* buffer, int size,
+ char* filename, const_char* encoding,
+ int options)
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/libxml/SAX2.h b/llava_video/lib/python3.10/site-packages/lxml/includes/libxml/SAX2.h
new file mode 100644
index 0000000000000000000000000000000000000000..4c4ecce8e598b2bb2011f9daf6367bcc8f028b88
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/includes/libxml/SAX2.h
@@ -0,0 +1,171 @@
+/*
+ * Summary: SAX2 parser interface used to build the DOM tree
+ * Description: those are the default SAX2 interfaces used by
+ * the library when building DOM tree.
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+
+#ifndef __XML_SAX2_H__
+#define __XML_SAX2_H__
+
+#include
+#include
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+XMLPUBFUN const xmlChar *
+ xmlSAX2GetPublicId (void *ctx);
+XMLPUBFUN const xmlChar *
+ xmlSAX2GetSystemId (void *ctx);
+XMLPUBFUN void
+ xmlSAX2SetDocumentLocator (void *ctx,
+ xmlSAXLocatorPtr loc);
+
+XMLPUBFUN int
+ xmlSAX2GetLineNumber (void *ctx);
+XMLPUBFUN int
+ xmlSAX2GetColumnNumber (void *ctx);
+
+XMLPUBFUN int
+ xmlSAX2IsStandalone (void *ctx);
+XMLPUBFUN int
+ xmlSAX2HasInternalSubset (void *ctx);
+XMLPUBFUN int
+ xmlSAX2HasExternalSubset (void *ctx);
+
+XMLPUBFUN void
+ xmlSAX2InternalSubset (void *ctx,
+ const xmlChar *name,
+ const xmlChar *ExternalID,
+ const xmlChar *SystemID);
+XMLPUBFUN void
+ xmlSAX2ExternalSubset (void *ctx,
+ const xmlChar *name,
+ const xmlChar *ExternalID,
+ const xmlChar *SystemID);
+XMLPUBFUN xmlEntityPtr
+ xmlSAX2GetEntity (void *ctx,
+ const xmlChar *name);
+XMLPUBFUN xmlEntityPtr
+ xmlSAX2GetParameterEntity (void *ctx,
+ const xmlChar *name);
+XMLPUBFUN xmlParserInputPtr
+ xmlSAX2ResolveEntity (void *ctx,
+ const xmlChar *publicId,
+ const xmlChar *systemId);
+
+XMLPUBFUN void
+ xmlSAX2EntityDecl (void *ctx,
+ const xmlChar *name,
+ int type,
+ const xmlChar *publicId,
+ const xmlChar *systemId,
+ xmlChar *content);
+XMLPUBFUN void
+ xmlSAX2AttributeDecl (void *ctx,
+ const xmlChar *elem,
+ const xmlChar *fullname,
+ int type,
+ int def,
+ const xmlChar *defaultValue,
+ xmlEnumerationPtr tree);
+XMLPUBFUN void
+ xmlSAX2ElementDecl (void *ctx,
+ const xmlChar *name,
+ int type,
+ xmlElementContentPtr content);
+XMLPUBFUN void
+ xmlSAX2NotationDecl (void *ctx,
+ const xmlChar *name,
+ const xmlChar *publicId,
+ const xmlChar *systemId);
+XMLPUBFUN void
+ xmlSAX2UnparsedEntityDecl (void *ctx,
+ const xmlChar *name,
+ const xmlChar *publicId,
+ const xmlChar *systemId,
+ const xmlChar *notationName);
+
+XMLPUBFUN void
+ xmlSAX2StartDocument (void *ctx);
+XMLPUBFUN void
+ xmlSAX2EndDocument (void *ctx);
+#if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || \
+ defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_LEGACY_ENABLED)
+XMLPUBFUN void
+ xmlSAX2StartElement (void *ctx,
+ const xmlChar *fullname,
+ const xmlChar **atts);
+XMLPUBFUN void
+ xmlSAX2EndElement (void *ctx,
+ const xmlChar *name);
+#endif /* LIBXML_SAX1_ENABLED or LIBXML_HTML_ENABLED or LIBXML_LEGACY_ENABLED */
+XMLPUBFUN void
+ xmlSAX2StartElementNs (void *ctx,
+ const xmlChar *localname,
+ const xmlChar *prefix,
+ const xmlChar *URI,
+ int nb_namespaces,
+ const xmlChar **namespaces,
+ int nb_attributes,
+ int nb_defaulted,
+ const xmlChar **attributes);
+XMLPUBFUN void
+ xmlSAX2EndElementNs (void *ctx,
+ const xmlChar *localname,
+ const xmlChar *prefix,
+ const xmlChar *URI);
+XMLPUBFUN void
+ xmlSAX2Reference (void *ctx,
+ const xmlChar *name);
+XMLPUBFUN void
+ xmlSAX2Characters (void *ctx,
+ const xmlChar *ch,
+ int len);
+XMLPUBFUN void
+ xmlSAX2IgnorableWhitespace (void *ctx,
+ const xmlChar *ch,
+ int len);
+XMLPUBFUN void
+ xmlSAX2ProcessingInstruction (void *ctx,
+ const xmlChar *target,
+ const xmlChar *data);
+XMLPUBFUN void
+ xmlSAX2Comment (void *ctx,
+ const xmlChar *value);
+XMLPUBFUN void
+ xmlSAX2CDataBlock (void *ctx,
+ const xmlChar *value,
+ int len);
+
+#ifdef LIBXML_SAX1_ENABLED
+XML_DEPRECATED
+XMLPUBFUN int
+ xmlSAXDefaultVersion (int version);
+#endif /* LIBXML_SAX1_ENABLED */
+
+XMLPUBFUN int
+ xmlSAXVersion (xmlSAXHandler *hdlr,
+ int version);
+XMLPUBFUN void
+ xmlSAX2InitDefaultSAXHandler (xmlSAXHandler *hdlr,
+ int warning);
+#ifdef LIBXML_HTML_ENABLED
+XMLPUBFUN void
+ xmlSAX2InitHtmlDefaultSAXHandler(xmlSAXHandler *hdlr);
+XML_DEPRECATED
+XMLPUBFUN void
+ htmlDefaultSAXHandlerInit (void);
+#endif
+XML_DEPRECATED
+XMLPUBFUN void
+ xmlDefaultSAXHandlerInit (void);
+#ifdef __cplusplus
+}
+#endif
+#endif /* __XML_SAX2_H__ */
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/libxml/entities.h b/llava_video/lib/python3.10/site-packages/lxml/includes/libxml/entities.h
new file mode 100644
index 0000000000000000000000000000000000000000..f679375321e6499e8ca4faa7a312b1b88bfa325a
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/includes/libxml/entities.h
@@ -0,0 +1,155 @@
+/*
+ * Summary: interface for the XML entities handling
+ * Description: this module provides some of the entity API needed
+ * for the parser and applications.
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_ENTITIES_H__
+#define __XML_ENTITIES_H__
+
+#include
+#define XML_TREE_INTERNALS
+#include
+#undef XML_TREE_INTERNALS
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * The different valid entity types.
+ */
+typedef enum {
+ XML_INTERNAL_GENERAL_ENTITY = 1,
+ XML_EXTERNAL_GENERAL_PARSED_ENTITY = 2,
+ XML_EXTERNAL_GENERAL_UNPARSED_ENTITY = 3,
+ XML_INTERNAL_PARAMETER_ENTITY = 4,
+ XML_EXTERNAL_PARAMETER_ENTITY = 5,
+ XML_INTERNAL_PREDEFINED_ENTITY = 6
+} xmlEntityType;
+
+/*
+ * An unit of storage for an entity, contains the string, the value
+ * and the linkind data needed for the linking in the hash table.
+ */
+
+struct _xmlEntity {
+ void *_private; /* application data */
+ xmlElementType type; /* XML_ENTITY_DECL, must be second ! */
+ const xmlChar *name; /* Entity name */
+ struct _xmlNode *children; /* First child link */
+ struct _xmlNode *last; /* Last child link */
+ struct _xmlDtd *parent; /* -> DTD */
+ struct _xmlNode *next; /* next sibling link */
+ struct _xmlNode *prev; /* previous sibling link */
+ struct _xmlDoc *doc; /* the containing document */
+
+ xmlChar *orig; /* content without ref substitution */
+ xmlChar *content; /* content or ndata if unparsed */
+ int length; /* the content length */
+ xmlEntityType etype; /* The entity type */
+ const xmlChar *ExternalID; /* External identifier for PUBLIC */
+ const xmlChar *SystemID; /* URI for a SYSTEM or PUBLIC Entity */
+
+ struct _xmlEntity *nexte; /* unused */
+ const xmlChar *URI; /* the full URI as computed */
+ int owner; /* does the entity own the childrens */
+ int flags; /* various flags */
+ unsigned long expandedSize; /* expanded size */
+};
+
+/*
+ * All entities are stored in an hash table.
+ * There is 2 separate hash tables for global and parameter entities.
+ */
+
+typedef struct _xmlHashTable xmlEntitiesTable;
+typedef xmlEntitiesTable *xmlEntitiesTablePtr;
+
+/*
+ * External functions:
+ */
+
+#ifdef LIBXML_LEGACY_ENABLED
+XML_DEPRECATED
+XMLPUBFUN void
+ xmlInitializePredefinedEntities (void);
+#endif /* LIBXML_LEGACY_ENABLED */
+
+XMLPUBFUN xmlEntityPtr
+ xmlNewEntity (xmlDocPtr doc,
+ const xmlChar *name,
+ int type,
+ const xmlChar *ExternalID,
+ const xmlChar *SystemID,
+ const xmlChar *content);
+XMLPUBFUN void
+ xmlFreeEntity (xmlEntityPtr entity);
+XMLPUBFUN xmlEntityPtr
+ xmlAddDocEntity (xmlDocPtr doc,
+ const xmlChar *name,
+ int type,
+ const xmlChar *ExternalID,
+ const xmlChar *SystemID,
+ const xmlChar *content);
+XMLPUBFUN xmlEntityPtr
+ xmlAddDtdEntity (xmlDocPtr doc,
+ const xmlChar *name,
+ int type,
+ const xmlChar *ExternalID,
+ const xmlChar *SystemID,
+ const xmlChar *content);
+XMLPUBFUN xmlEntityPtr
+ xmlGetPredefinedEntity (const xmlChar *name);
+XMLPUBFUN xmlEntityPtr
+ xmlGetDocEntity (const xmlDoc *doc,
+ const xmlChar *name);
+XMLPUBFUN xmlEntityPtr
+ xmlGetDtdEntity (xmlDocPtr doc,
+ const xmlChar *name);
+XMLPUBFUN xmlEntityPtr
+ xmlGetParameterEntity (xmlDocPtr doc,
+ const xmlChar *name);
+#ifdef LIBXML_LEGACY_ENABLED
+XML_DEPRECATED
+XMLPUBFUN const xmlChar *
+ xmlEncodeEntities (xmlDocPtr doc,
+ const xmlChar *input);
+#endif /* LIBXML_LEGACY_ENABLED */
+XMLPUBFUN xmlChar *
+ xmlEncodeEntitiesReentrant(xmlDocPtr doc,
+ const xmlChar *input);
+XMLPUBFUN xmlChar *
+ xmlEncodeSpecialChars (const xmlDoc *doc,
+ const xmlChar *input);
+XMLPUBFUN xmlEntitiesTablePtr
+ xmlCreateEntitiesTable (void);
+#ifdef LIBXML_TREE_ENABLED
+XMLPUBFUN xmlEntitiesTablePtr
+ xmlCopyEntitiesTable (xmlEntitiesTablePtr table);
+#endif /* LIBXML_TREE_ENABLED */
+XMLPUBFUN void
+ xmlFreeEntitiesTable (xmlEntitiesTablePtr table);
+#ifdef LIBXML_OUTPUT_ENABLED
+XMLPUBFUN void
+ xmlDumpEntitiesTable (xmlBufferPtr buf,
+ xmlEntitiesTablePtr table);
+XMLPUBFUN void
+ xmlDumpEntityDecl (xmlBufferPtr buf,
+ xmlEntityPtr ent);
+#endif /* LIBXML_OUTPUT_ENABLED */
+#ifdef LIBXML_LEGACY_ENABLED
+XMLPUBFUN void
+ xmlCleanupPredefinedEntities(void);
+#endif /* LIBXML_LEGACY_ENABLED */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+# endif /* __XML_ENTITIES_H__ */
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/libxml/parserInternals.h b/llava_video/lib/python3.10/site-packages/lxml/includes/libxml/parserInternals.h
new file mode 100644
index 0000000000000000000000000000000000000000..017ed27358adcb1dc7d4da40fac3f1c7b8bfde35
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/includes/libxml/parserInternals.h
@@ -0,0 +1,663 @@
+/*
+ * Summary: internals routines and limits exported by the parser.
+ * Description: this module exports a number of internal parsing routines
+ * they are not really all intended for applications but
+ * can prove useful doing low level processing.
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_PARSER_INTERNALS_H__
+#define __XML_PARSER_INTERNALS_H__
+
+#include
+#include
+#include
+#include
+#include
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * xmlParserMaxDepth:
+ *
+ * arbitrary depth limit for the XML documents that we allow to
+ * process. This is not a limitation of the parser but a safety
+ * boundary feature, use XML_PARSE_HUGE option to override it.
+ */
+XMLPUBVAR unsigned int xmlParserMaxDepth;
+
+/**
+ * XML_MAX_TEXT_LENGTH:
+ *
+ * Maximum size allowed for a single text node when building a tree.
+ * This is not a limitation of the parser but a safety boundary feature,
+ * use XML_PARSE_HUGE option to override it.
+ * Introduced in 2.9.0
+ */
+#define XML_MAX_TEXT_LENGTH 10000000
+
+/**
+ * XML_MAX_HUGE_LENGTH:
+ *
+ * Maximum size allowed when XML_PARSE_HUGE is set.
+ */
+#define XML_MAX_HUGE_LENGTH 1000000000
+
+/**
+ * XML_MAX_NAME_LENGTH:
+ *
+ * Maximum size allowed for a markup identifier.
+ * This is not a limitation of the parser but a safety boundary feature,
+ * use XML_PARSE_HUGE option to override it.
+ * Note that with the use of parsing dictionaries overriding the limit
+ * may result in more runtime memory usage in face of "unfriendly' content
+ * Introduced in 2.9.0
+ */
+#define XML_MAX_NAME_LENGTH 50000
+
+/**
+ * XML_MAX_DICTIONARY_LIMIT:
+ *
+ * Maximum size allowed by the parser for a dictionary by default
+ * This is not a limitation of the parser but a safety boundary feature,
+ * use XML_PARSE_HUGE option to override it.
+ * Introduced in 2.9.0
+ */
+#define XML_MAX_DICTIONARY_LIMIT 10000000
+
+/**
+ * XML_MAX_LOOKUP_LIMIT:
+ *
+ * Maximum size allowed by the parser for ahead lookup
+ * This is an upper boundary enforced by the parser to avoid bad
+ * behaviour on "unfriendly' content
+ * Introduced in 2.9.0
+ */
+#define XML_MAX_LOOKUP_LIMIT 10000000
+
+/**
+ * XML_MAX_NAMELEN:
+ *
+ * Identifiers can be longer, but this will be more costly
+ * at runtime.
+ */
+#define XML_MAX_NAMELEN 100
+
+/**
+ * INPUT_CHUNK:
+ *
+ * The parser tries to always have that amount of input ready.
+ * One of the point is providing context when reporting errors.
+ */
+#define INPUT_CHUNK 250
+
+/************************************************************************
+ * *
+ * UNICODE version of the macros. *
+ * *
+ ************************************************************************/
+/**
+ * IS_BYTE_CHAR:
+ * @c: an byte value (int)
+ *
+ * Macro to check the following production in the XML spec:
+ *
+ * [2] Char ::= #x9 | #xA | #xD | [#x20...]
+ * any byte character in the accepted range
+ */
+#define IS_BYTE_CHAR(c) xmlIsChar_ch(c)
+
+/**
+ * IS_CHAR:
+ * @c: an UNICODE value (int)
+ *
+ * Macro to check the following production in the XML spec:
+ *
+ * [2] Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD]
+ * | [#x10000-#x10FFFF]
+ * any Unicode character, excluding the surrogate blocks, FFFE, and FFFF.
+ */
+#define IS_CHAR(c) xmlIsCharQ(c)
+
+/**
+ * IS_CHAR_CH:
+ * @c: an xmlChar (usually an unsigned char)
+ *
+ * Behaves like IS_CHAR on single-byte value
+ */
+#define IS_CHAR_CH(c) xmlIsChar_ch(c)
+
+/**
+ * IS_BLANK:
+ * @c: an UNICODE value (int)
+ *
+ * Macro to check the following production in the XML spec:
+ *
+ * [3] S ::= (#x20 | #x9 | #xD | #xA)+
+ */
+#define IS_BLANK(c) xmlIsBlankQ(c)
+
+/**
+ * IS_BLANK_CH:
+ * @c: an xmlChar value (normally unsigned char)
+ *
+ * Behaviour same as IS_BLANK
+ */
+#define IS_BLANK_CH(c) xmlIsBlank_ch(c)
+
+/**
+ * IS_BASECHAR:
+ * @c: an UNICODE value (int)
+ *
+ * Macro to check the following production in the XML spec:
+ *
+ * [85] BaseChar ::= ... long list see REC ...
+ */
+#define IS_BASECHAR(c) xmlIsBaseCharQ(c)
+
+/**
+ * IS_DIGIT:
+ * @c: an UNICODE value (int)
+ *
+ * Macro to check the following production in the XML spec:
+ *
+ * [88] Digit ::= ... long list see REC ...
+ */
+#define IS_DIGIT(c) xmlIsDigitQ(c)
+
+/**
+ * IS_DIGIT_CH:
+ * @c: an xmlChar value (usually an unsigned char)
+ *
+ * Behaves like IS_DIGIT but with a single byte argument
+ */
+#define IS_DIGIT_CH(c) xmlIsDigit_ch(c)
+
+/**
+ * IS_COMBINING:
+ * @c: an UNICODE value (int)
+ *
+ * Macro to check the following production in the XML spec:
+ *
+ * [87] CombiningChar ::= ... long list see REC ...
+ */
+#define IS_COMBINING(c) xmlIsCombiningQ(c)
+
+/**
+ * IS_COMBINING_CH:
+ * @c: an xmlChar (usually an unsigned char)
+ *
+ * Always false (all combining chars > 0xff)
+ */
+#define IS_COMBINING_CH(c) 0
+
+/**
+ * IS_EXTENDER:
+ * @c: an UNICODE value (int)
+ *
+ * Macro to check the following production in the XML spec:
+ *
+ *
+ * [89] Extender ::= #x00B7 | #x02D0 | #x02D1 | #x0387 | #x0640 |
+ * #x0E46 | #x0EC6 | #x3005 | [#x3031-#x3035] |
+ * [#x309D-#x309E] | [#x30FC-#x30FE]
+ */
+#define IS_EXTENDER(c) xmlIsExtenderQ(c)
+
+/**
+ * IS_EXTENDER_CH:
+ * @c: an xmlChar value (usually an unsigned char)
+ *
+ * Behaves like IS_EXTENDER but with a single-byte argument
+ */
+#define IS_EXTENDER_CH(c) xmlIsExtender_ch(c)
+
+/**
+ * IS_IDEOGRAPHIC:
+ * @c: an UNICODE value (int)
+ *
+ * Macro to check the following production in the XML spec:
+ *
+ *
+ * [86] Ideographic ::= [#x4E00-#x9FA5] | #x3007 | [#x3021-#x3029]
+ */
+#define IS_IDEOGRAPHIC(c) xmlIsIdeographicQ(c)
+
+/**
+ * IS_LETTER:
+ * @c: an UNICODE value (int)
+ *
+ * Macro to check the following production in the XML spec:
+ *
+ *
+ * [84] Letter ::= BaseChar | Ideographic
+ */
+#define IS_LETTER(c) (IS_BASECHAR(c) || IS_IDEOGRAPHIC(c))
+
+/**
+ * IS_LETTER_CH:
+ * @c: an xmlChar value (normally unsigned char)
+ *
+ * Macro behaves like IS_LETTER, but only check base chars
+ *
+ */
+#define IS_LETTER_CH(c) xmlIsBaseChar_ch(c)
+
+/**
+ * IS_ASCII_LETTER:
+ * @c: an xmlChar value
+ *
+ * Macro to check [a-zA-Z]
+ *
+ */
+#define IS_ASCII_LETTER(c) (((0x41 <= (c)) && ((c) <= 0x5a)) || \
+ ((0x61 <= (c)) && ((c) <= 0x7a)))
+
+/**
+ * IS_ASCII_DIGIT:
+ * @c: an xmlChar value
+ *
+ * Macro to check [0-9]
+ *
+ */
+#define IS_ASCII_DIGIT(c) ((0x30 <= (c)) && ((c) <= 0x39))
+
+/**
+ * IS_PUBIDCHAR:
+ * @c: an UNICODE value (int)
+ *
+ * Macro to check the following production in the XML spec:
+ *
+ *
+ * [13] PubidChar ::= #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%]
+ */
+#define IS_PUBIDCHAR(c) xmlIsPubidCharQ(c)
+
+/**
+ * IS_PUBIDCHAR_CH:
+ * @c: an xmlChar value (normally unsigned char)
+ *
+ * Same as IS_PUBIDCHAR but for single-byte value
+ */
+#define IS_PUBIDCHAR_CH(c) xmlIsPubidChar_ch(c)
+
+/**
+ * Global variables used for predefined strings.
+ */
+XMLPUBVAR const xmlChar xmlStringText[];
+XMLPUBVAR const xmlChar xmlStringTextNoenc[];
+XMLPUBVAR const xmlChar xmlStringComment[];
+
+/*
+ * Function to finish the work of the macros where needed.
+ */
+XMLPUBFUN int xmlIsLetter (int c);
+
+/**
+ * Parser context.
+ */
+XMLPUBFUN xmlParserCtxtPtr
+ xmlCreateFileParserCtxt (const char *filename);
+XMLPUBFUN xmlParserCtxtPtr
+ xmlCreateURLParserCtxt (const char *filename,
+ int options);
+XMLPUBFUN xmlParserCtxtPtr
+ xmlCreateMemoryParserCtxt(const char *buffer,
+ int size);
+XMLPUBFUN xmlParserCtxtPtr
+ xmlCreateEntityParserCtxt(const xmlChar *URL,
+ const xmlChar *ID,
+ const xmlChar *base);
+XMLPUBFUN int
+ xmlSwitchEncoding (xmlParserCtxtPtr ctxt,
+ xmlCharEncoding enc);
+XMLPUBFUN int
+ xmlSwitchToEncoding (xmlParserCtxtPtr ctxt,
+ xmlCharEncodingHandlerPtr handler);
+XML_DEPRECATED
+XMLPUBFUN int
+ xmlSwitchInputEncoding (xmlParserCtxtPtr ctxt,
+ xmlParserInputPtr input,
+ xmlCharEncodingHandlerPtr handler);
+
+/**
+ * Input Streams.
+ */
+XMLPUBFUN xmlParserInputPtr
+ xmlNewStringInputStream (xmlParserCtxtPtr ctxt,
+ const xmlChar *buffer);
+XML_DEPRECATED
+XMLPUBFUN xmlParserInputPtr
+ xmlNewEntityInputStream (xmlParserCtxtPtr ctxt,
+ xmlEntityPtr entity);
+XMLPUBFUN int
+ xmlPushInput (xmlParserCtxtPtr ctxt,
+ xmlParserInputPtr input);
+XMLPUBFUN xmlChar
+ xmlPopInput (xmlParserCtxtPtr ctxt);
+XMLPUBFUN void
+ xmlFreeInputStream (xmlParserInputPtr input);
+XMLPUBFUN xmlParserInputPtr
+ xmlNewInputFromFile (xmlParserCtxtPtr ctxt,
+ const char *filename);
+XMLPUBFUN xmlParserInputPtr
+ xmlNewInputStream (xmlParserCtxtPtr ctxt);
+
+/**
+ * Namespaces.
+ */
+XMLPUBFUN xmlChar *
+ xmlSplitQName (xmlParserCtxtPtr ctxt,
+ const xmlChar *name,
+ xmlChar **prefix);
+
+/**
+ * Generic production rules.
+ */
+XML_DEPRECATED
+XMLPUBFUN const xmlChar *
+ xmlParseName (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN xmlChar *
+ xmlParseNmtoken (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN xmlChar *
+ xmlParseEntityValue (xmlParserCtxtPtr ctxt,
+ xmlChar **orig);
+XML_DEPRECATED
+XMLPUBFUN xmlChar *
+ xmlParseAttValue (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN xmlChar *
+ xmlParseSystemLiteral (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN xmlChar *
+ xmlParsePubidLiteral (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN void
+ xmlParseCharData (xmlParserCtxtPtr ctxt,
+ int cdata);
+XML_DEPRECATED
+XMLPUBFUN xmlChar *
+ xmlParseExternalID (xmlParserCtxtPtr ctxt,
+ xmlChar **publicID,
+ int strict);
+XML_DEPRECATED
+XMLPUBFUN void
+ xmlParseComment (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN const xmlChar *
+ xmlParsePITarget (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN void
+ xmlParsePI (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN void
+ xmlParseNotationDecl (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN void
+ xmlParseEntityDecl (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN int
+ xmlParseDefaultDecl (xmlParserCtxtPtr ctxt,
+ xmlChar **value);
+XML_DEPRECATED
+XMLPUBFUN xmlEnumerationPtr
+ xmlParseNotationType (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN xmlEnumerationPtr
+ xmlParseEnumerationType (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN int
+ xmlParseEnumeratedType (xmlParserCtxtPtr ctxt,
+ xmlEnumerationPtr *tree);
+XML_DEPRECATED
+XMLPUBFUN int
+ xmlParseAttributeType (xmlParserCtxtPtr ctxt,
+ xmlEnumerationPtr *tree);
+XML_DEPRECATED
+XMLPUBFUN void
+ xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN xmlElementContentPtr
+ xmlParseElementMixedContentDecl
+ (xmlParserCtxtPtr ctxt,
+ int inputchk);
+XML_DEPRECATED
+XMLPUBFUN xmlElementContentPtr
+ xmlParseElementChildrenContentDecl
+ (xmlParserCtxtPtr ctxt,
+ int inputchk);
+XML_DEPRECATED
+XMLPUBFUN int
+ xmlParseElementContentDecl(xmlParserCtxtPtr ctxt,
+ const xmlChar *name,
+ xmlElementContentPtr *result);
+XML_DEPRECATED
+XMLPUBFUN int
+ xmlParseElementDecl (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN void
+ xmlParseMarkupDecl (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN int
+ xmlParseCharRef (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN xmlEntityPtr
+ xmlParseEntityRef (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN void
+ xmlParseReference (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN void
+ xmlParsePEReference (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN void
+ xmlParseDocTypeDecl (xmlParserCtxtPtr ctxt);
+#ifdef LIBXML_SAX1_ENABLED
+XML_DEPRECATED
+XMLPUBFUN const xmlChar *
+ xmlParseAttribute (xmlParserCtxtPtr ctxt,
+ xmlChar **value);
+XML_DEPRECATED
+XMLPUBFUN const xmlChar *
+ xmlParseStartTag (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN void
+ xmlParseEndTag (xmlParserCtxtPtr ctxt);
+#endif /* LIBXML_SAX1_ENABLED */
+XML_DEPRECATED
+XMLPUBFUN void
+ xmlParseCDSect (xmlParserCtxtPtr ctxt);
+XMLPUBFUN void
+ xmlParseContent (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN void
+ xmlParseElement (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN xmlChar *
+ xmlParseVersionNum (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN xmlChar *
+ xmlParseVersionInfo (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN xmlChar *
+ xmlParseEncName (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN const xmlChar *
+ xmlParseEncodingDecl (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN int
+ xmlParseSDDecl (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN void
+ xmlParseXMLDecl (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN void
+ xmlParseTextDecl (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN void
+ xmlParseMisc (xmlParserCtxtPtr ctxt);
+XMLPUBFUN void
+ xmlParseExternalSubset (xmlParserCtxtPtr ctxt,
+ const xmlChar *ExternalID,
+ const xmlChar *SystemID);
+/**
+ * XML_SUBSTITUTE_NONE:
+ *
+ * If no entities need to be substituted.
+ */
+#define XML_SUBSTITUTE_NONE 0
+/**
+ * XML_SUBSTITUTE_REF:
+ *
+ * Whether general entities need to be substituted.
+ */
+#define XML_SUBSTITUTE_REF 1
+/**
+ * XML_SUBSTITUTE_PEREF:
+ *
+ * Whether parameter entities need to be substituted.
+ */
+#define XML_SUBSTITUTE_PEREF 2
+/**
+ * XML_SUBSTITUTE_BOTH:
+ *
+ * Both general and parameter entities need to be substituted.
+ */
+#define XML_SUBSTITUTE_BOTH 3
+
+XML_DEPRECATED
+XMLPUBFUN xmlChar *
+ xmlStringDecodeEntities (xmlParserCtxtPtr ctxt,
+ const xmlChar *str,
+ int what,
+ xmlChar end,
+ xmlChar end2,
+ xmlChar end3);
+XML_DEPRECATED
+XMLPUBFUN xmlChar *
+ xmlStringLenDecodeEntities (xmlParserCtxtPtr ctxt,
+ const xmlChar *str,
+ int len,
+ int what,
+ xmlChar end,
+ xmlChar end2,
+ xmlChar end3);
+
+/*
+ * Generated by MACROS on top of parser.c c.f. PUSH_AND_POP.
+ */
+XML_DEPRECATED
+XMLPUBFUN int nodePush (xmlParserCtxtPtr ctxt,
+ xmlNodePtr value);
+XML_DEPRECATED
+XMLPUBFUN xmlNodePtr nodePop (xmlParserCtxtPtr ctxt);
+XMLPUBFUN int inputPush (xmlParserCtxtPtr ctxt,
+ xmlParserInputPtr value);
+XMLPUBFUN xmlParserInputPtr inputPop (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN const xmlChar * namePop (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN int namePush (xmlParserCtxtPtr ctxt,
+ const xmlChar *value);
+
+/*
+ * other commodities shared between parser.c and parserInternals.
+ */
+XML_DEPRECATED
+XMLPUBFUN int xmlSkipBlankChars (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN int xmlStringCurrentChar (xmlParserCtxtPtr ctxt,
+ const xmlChar *cur,
+ int *len);
+XML_DEPRECATED
+XMLPUBFUN void xmlParserHandlePEReference(xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN int xmlCheckLanguageID (const xmlChar *lang);
+
+/*
+ * Really core function shared with HTML parser.
+ */
+XML_DEPRECATED
+XMLPUBFUN int xmlCurrentChar (xmlParserCtxtPtr ctxt,
+ int *len);
+XMLPUBFUN int xmlCopyCharMultiByte (xmlChar *out,
+ int val);
+XMLPUBFUN int xmlCopyChar (int len,
+ xmlChar *out,
+ int val);
+XML_DEPRECATED
+XMLPUBFUN void xmlNextChar (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN void xmlParserInputShrink (xmlParserInputPtr in);
+
+/*
+ * Specific function to keep track of entities references
+ * and used by the XSLT debugger.
+ */
+#ifdef LIBXML_LEGACY_ENABLED
+/**
+ * xmlEntityReferenceFunc:
+ * @ent: the entity
+ * @firstNode: the fist node in the chunk
+ * @lastNode: the last nod in the chunk
+ *
+ * Callback function used when one needs to be able to track back the
+ * provenance of a chunk of nodes inherited from an entity replacement.
+ */
+typedef void (*xmlEntityReferenceFunc) (xmlEntityPtr ent,
+ xmlNodePtr firstNode,
+ xmlNodePtr lastNode);
+
+XML_DEPRECATED
+XMLPUBFUN void xmlSetEntityReferenceFunc (xmlEntityReferenceFunc func);
+
+XML_DEPRECATED
+XMLPUBFUN xmlChar *
+ xmlParseQuotedString (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN void
+ xmlParseNamespace (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN xmlChar *
+ xmlNamespaceParseNSDef (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN xmlChar *
+ xmlScanName (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN xmlChar *
+ xmlNamespaceParseNCName (xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN void xmlParserHandleReference(xmlParserCtxtPtr ctxt);
+XML_DEPRECATED
+XMLPUBFUN xmlChar *
+ xmlNamespaceParseQName (xmlParserCtxtPtr ctxt,
+ xmlChar **prefix);
+/**
+ * Entities
+ */
+XML_DEPRECATED
+XMLPUBFUN xmlChar *
+ xmlDecodeEntities (xmlParserCtxtPtr ctxt,
+ int len,
+ int what,
+ xmlChar end,
+ xmlChar end2,
+ xmlChar end3);
+XML_DEPRECATED
+XMLPUBFUN void
+ xmlHandleEntity (xmlParserCtxtPtr ctxt,
+ xmlEntityPtr entity);
+
+#endif /* LIBXML_LEGACY_ENABLED */
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __XML_PARSER_INTERNALS_H__ */
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/libxml/schemasInternals.h b/llava_video/lib/python3.10/site-packages/lxml/includes/libxml/schemasInternals.h
new file mode 100644
index 0000000000000000000000000000000000000000..e9d3b3c7abb1e5b6fa1b1f25fb9bc2ee5e46d56f
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/includes/libxml/schemasInternals.h
@@ -0,0 +1,959 @@
+/*
+ * Summary: internal interfaces for XML Schemas
+ * Description: internal interfaces for the XML Schemas handling
+ * and schema validity checking
+ * The Schemas development is a Work In Progress.
+ * Some of those interfaces are not guaranteed to be API or ABI stable !
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+
+#ifndef __XML_SCHEMA_INTERNALS_H__
+#define __XML_SCHEMA_INTERNALS_H__
+
+#include
+
+#ifdef LIBXML_SCHEMAS_ENABLED
+
+#include
+#include
+#include
+#include
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+ XML_SCHEMAS_UNKNOWN = 0,
+ XML_SCHEMAS_STRING = 1,
+ XML_SCHEMAS_NORMSTRING = 2,
+ XML_SCHEMAS_DECIMAL = 3,
+ XML_SCHEMAS_TIME = 4,
+ XML_SCHEMAS_GDAY = 5,
+ XML_SCHEMAS_GMONTH = 6,
+ XML_SCHEMAS_GMONTHDAY = 7,
+ XML_SCHEMAS_GYEAR = 8,
+ XML_SCHEMAS_GYEARMONTH = 9,
+ XML_SCHEMAS_DATE = 10,
+ XML_SCHEMAS_DATETIME = 11,
+ XML_SCHEMAS_DURATION = 12,
+ XML_SCHEMAS_FLOAT = 13,
+ XML_SCHEMAS_DOUBLE = 14,
+ XML_SCHEMAS_BOOLEAN = 15,
+ XML_SCHEMAS_TOKEN = 16,
+ XML_SCHEMAS_LANGUAGE = 17,
+ XML_SCHEMAS_NMTOKEN = 18,
+ XML_SCHEMAS_NMTOKENS = 19,
+ XML_SCHEMAS_NAME = 20,
+ XML_SCHEMAS_QNAME = 21,
+ XML_SCHEMAS_NCNAME = 22,
+ XML_SCHEMAS_ID = 23,
+ XML_SCHEMAS_IDREF = 24,
+ XML_SCHEMAS_IDREFS = 25,
+ XML_SCHEMAS_ENTITY = 26,
+ XML_SCHEMAS_ENTITIES = 27,
+ XML_SCHEMAS_NOTATION = 28,
+ XML_SCHEMAS_ANYURI = 29,
+ XML_SCHEMAS_INTEGER = 30,
+ XML_SCHEMAS_NPINTEGER = 31,
+ XML_SCHEMAS_NINTEGER = 32,
+ XML_SCHEMAS_NNINTEGER = 33,
+ XML_SCHEMAS_PINTEGER = 34,
+ XML_SCHEMAS_INT = 35,
+ XML_SCHEMAS_UINT = 36,
+ XML_SCHEMAS_LONG = 37,
+ XML_SCHEMAS_ULONG = 38,
+ XML_SCHEMAS_SHORT = 39,
+ XML_SCHEMAS_USHORT = 40,
+ XML_SCHEMAS_BYTE = 41,
+ XML_SCHEMAS_UBYTE = 42,
+ XML_SCHEMAS_HEXBINARY = 43,
+ XML_SCHEMAS_BASE64BINARY = 44,
+ XML_SCHEMAS_ANYTYPE = 45,
+ XML_SCHEMAS_ANYSIMPLETYPE = 46
+} xmlSchemaValType;
+
+/*
+ * XML Schemas defines multiple type of types.
+ */
+typedef enum {
+ XML_SCHEMA_TYPE_BASIC = 1, /* A built-in datatype */
+ XML_SCHEMA_TYPE_ANY,
+ XML_SCHEMA_TYPE_FACET,
+ XML_SCHEMA_TYPE_SIMPLE,
+ XML_SCHEMA_TYPE_COMPLEX,
+ XML_SCHEMA_TYPE_SEQUENCE = 6,
+ XML_SCHEMA_TYPE_CHOICE,
+ XML_SCHEMA_TYPE_ALL,
+ XML_SCHEMA_TYPE_SIMPLE_CONTENT,
+ XML_SCHEMA_TYPE_COMPLEX_CONTENT,
+ XML_SCHEMA_TYPE_UR,
+ XML_SCHEMA_TYPE_RESTRICTION,
+ XML_SCHEMA_TYPE_EXTENSION,
+ XML_SCHEMA_TYPE_ELEMENT,
+ XML_SCHEMA_TYPE_ATTRIBUTE,
+ XML_SCHEMA_TYPE_ATTRIBUTEGROUP,
+ XML_SCHEMA_TYPE_GROUP,
+ XML_SCHEMA_TYPE_NOTATION,
+ XML_SCHEMA_TYPE_LIST,
+ XML_SCHEMA_TYPE_UNION,
+ XML_SCHEMA_TYPE_ANY_ATTRIBUTE,
+ XML_SCHEMA_TYPE_IDC_UNIQUE,
+ XML_SCHEMA_TYPE_IDC_KEY,
+ XML_SCHEMA_TYPE_IDC_KEYREF,
+ XML_SCHEMA_TYPE_PARTICLE = 25,
+ XML_SCHEMA_TYPE_ATTRIBUTE_USE,
+ XML_SCHEMA_FACET_MININCLUSIVE = 1000,
+ XML_SCHEMA_FACET_MINEXCLUSIVE,
+ XML_SCHEMA_FACET_MAXINCLUSIVE,
+ XML_SCHEMA_FACET_MAXEXCLUSIVE,
+ XML_SCHEMA_FACET_TOTALDIGITS,
+ XML_SCHEMA_FACET_FRACTIONDIGITS,
+ XML_SCHEMA_FACET_PATTERN,
+ XML_SCHEMA_FACET_ENUMERATION,
+ XML_SCHEMA_FACET_WHITESPACE,
+ XML_SCHEMA_FACET_LENGTH,
+ XML_SCHEMA_FACET_MAXLENGTH,
+ XML_SCHEMA_FACET_MINLENGTH,
+ XML_SCHEMA_EXTRA_QNAMEREF = 2000,
+ XML_SCHEMA_EXTRA_ATTR_USE_PROHIB
+} xmlSchemaTypeType;
+
+typedef enum {
+ XML_SCHEMA_CONTENT_UNKNOWN = 0,
+ XML_SCHEMA_CONTENT_EMPTY = 1,
+ XML_SCHEMA_CONTENT_ELEMENTS,
+ XML_SCHEMA_CONTENT_MIXED,
+ XML_SCHEMA_CONTENT_SIMPLE,
+ XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS, /* Obsolete */
+ XML_SCHEMA_CONTENT_BASIC,
+ XML_SCHEMA_CONTENT_ANY
+} xmlSchemaContentType;
+
+typedef struct _xmlSchemaVal xmlSchemaVal;
+typedef xmlSchemaVal *xmlSchemaValPtr;
+
+typedef struct _xmlSchemaType xmlSchemaType;
+typedef xmlSchemaType *xmlSchemaTypePtr;
+
+typedef struct _xmlSchemaFacet xmlSchemaFacet;
+typedef xmlSchemaFacet *xmlSchemaFacetPtr;
+
+/**
+ * Annotation
+ */
+typedef struct _xmlSchemaAnnot xmlSchemaAnnot;
+typedef xmlSchemaAnnot *xmlSchemaAnnotPtr;
+struct _xmlSchemaAnnot {
+ struct _xmlSchemaAnnot *next;
+ xmlNodePtr content; /* the annotation */
+};
+
+/**
+ * XML_SCHEMAS_ANYATTR_SKIP:
+ *
+ * Skip unknown attribute from validation
+ * Obsolete, not used anymore.
+ */
+#define XML_SCHEMAS_ANYATTR_SKIP 1
+/**
+ * XML_SCHEMAS_ANYATTR_LAX:
+ *
+ * Ignore validation non definition on attributes
+ * Obsolete, not used anymore.
+ */
+#define XML_SCHEMAS_ANYATTR_LAX 2
+/**
+ * XML_SCHEMAS_ANYATTR_STRICT:
+ *
+ * Apply strict validation rules on attributes
+ * Obsolete, not used anymore.
+ */
+#define XML_SCHEMAS_ANYATTR_STRICT 3
+/**
+ * XML_SCHEMAS_ANY_SKIP:
+ *
+ * Skip unknown attribute from validation
+ */
+#define XML_SCHEMAS_ANY_SKIP 1
+/**
+ * XML_SCHEMAS_ANY_LAX:
+ *
+ * Used by wildcards.
+ * Validate if type found, don't worry if not found
+ */
+#define XML_SCHEMAS_ANY_LAX 2
+/**
+ * XML_SCHEMAS_ANY_STRICT:
+ *
+ * Used by wildcards.
+ * Apply strict validation rules
+ */
+#define XML_SCHEMAS_ANY_STRICT 3
+/**
+ * XML_SCHEMAS_ATTR_USE_PROHIBITED:
+ *
+ * Used by wildcards.
+ * The attribute is prohibited.
+ */
+#define XML_SCHEMAS_ATTR_USE_PROHIBITED 0
+/**
+ * XML_SCHEMAS_ATTR_USE_REQUIRED:
+ *
+ * The attribute is required.
+ */
+#define XML_SCHEMAS_ATTR_USE_REQUIRED 1
+/**
+ * XML_SCHEMAS_ATTR_USE_OPTIONAL:
+ *
+ * The attribute is optional.
+ */
+#define XML_SCHEMAS_ATTR_USE_OPTIONAL 2
+/**
+ * XML_SCHEMAS_ATTR_GLOBAL:
+ *
+ * allow elements in no namespace
+ */
+#define XML_SCHEMAS_ATTR_GLOBAL 1 << 0
+/**
+ * XML_SCHEMAS_ATTR_NSDEFAULT:
+ *
+ * allow elements in no namespace
+ */
+#define XML_SCHEMAS_ATTR_NSDEFAULT 1 << 7
+/**
+ * XML_SCHEMAS_ATTR_INTERNAL_RESOLVED:
+ *
+ * this is set when the "type" and "ref" references
+ * have been resolved.
+ */
+#define XML_SCHEMAS_ATTR_INTERNAL_RESOLVED 1 << 8
+/**
+ * XML_SCHEMAS_ATTR_FIXED:
+ *
+ * the attribute has a fixed value
+ */
+#define XML_SCHEMAS_ATTR_FIXED 1 << 9
+
+/**
+ * xmlSchemaAttribute:
+ * An attribute definition.
+ */
+
+typedef struct _xmlSchemaAttribute xmlSchemaAttribute;
+typedef xmlSchemaAttribute *xmlSchemaAttributePtr;
+struct _xmlSchemaAttribute {
+ xmlSchemaTypeType type;
+ struct _xmlSchemaAttribute *next; /* the next attribute (not used?) */
+ const xmlChar *name; /* the name of the declaration */
+ const xmlChar *id; /* Deprecated; not used */
+ const xmlChar *ref; /* Deprecated; not used */
+ const xmlChar *refNs; /* Deprecated; not used */
+ const xmlChar *typeName; /* the local name of the type definition */
+ const xmlChar *typeNs; /* the ns URI of the type definition */
+ xmlSchemaAnnotPtr annot;
+
+ xmlSchemaTypePtr base; /* Deprecated; not used */
+ int occurs; /* Deprecated; not used */
+ const xmlChar *defValue; /* The initial value of the value constraint */
+ xmlSchemaTypePtr subtypes; /* the type definition */
+ xmlNodePtr node;
+ const xmlChar *targetNamespace;
+ int flags;
+ const xmlChar *refPrefix; /* Deprecated; not used */
+ xmlSchemaValPtr defVal; /* The compiled value constraint */
+ xmlSchemaAttributePtr refDecl; /* Deprecated; not used */
+};
+
+/**
+ * xmlSchemaAttributeLink:
+ * Used to build a list of attribute uses on complexType definitions.
+ * WARNING: Deprecated; not used.
+ */
+typedef struct _xmlSchemaAttributeLink xmlSchemaAttributeLink;
+typedef xmlSchemaAttributeLink *xmlSchemaAttributeLinkPtr;
+struct _xmlSchemaAttributeLink {
+ struct _xmlSchemaAttributeLink *next;/* the next attribute link ... */
+ struct _xmlSchemaAttribute *attr;/* the linked attribute */
+};
+
+/**
+ * XML_SCHEMAS_WILDCARD_COMPLETE:
+ *
+ * If the wildcard is complete.
+ */
+#define XML_SCHEMAS_WILDCARD_COMPLETE 1 << 0
+
+/**
+ * xmlSchemaCharValueLink:
+ * Used to build a list of namespaces on wildcards.
+ */
+typedef struct _xmlSchemaWildcardNs xmlSchemaWildcardNs;
+typedef xmlSchemaWildcardNs *xmlSchemaWildcardNsPtr;
+struct _xmlSchemaWildcardNs {
+ struct _xmlSchemaWildcardNs *next;/* the next constraint link ... */
+ const xmlChar *value;/* the value */
+};
+
+/**
+ * xmlSchemaWildcard.
+ * A wildcard.
+ */
+typedef struct _xmlSchemaWildcard xmlSchemaWildcard;
+typedef xmlSchemaWildcard *xmlSchemaWildcardPtr;
+struct _xmlSchemaWildcard {
+ xmlSchemaTypeType type; /* The kind of type */
+ const xmlChar *id; /* Deprecated; not used */
+ xmlSchemaAnnotPtr annot;
+ xmlNodePtr node;
+ int minOccurs; /* Deprecated; not used */
+ int maxOccurs; /* Deprecated; not used */
+ int processContents;
+ int any; /* Indicates if the ns constraint is of ##any */
+ xmlSchemaWildcardNsPtr nsSet; /* The list of allowed namespaces */
+ xmlSchemaWildcardNsPtr negNsSet; /* The negated namespace */
+ int flags;
+};
+
+/**
+ * XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED:
+ *
+ * The attribute wildcard has been built.
+ */
+#define XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED 1 << 0
+/**
+ * XML_SCHEMAS_ATTRGROUP_GLOBAL:
+ *
+ * The attribute group has been defined.
+ */
+#define XML_SCHEMAS_ATTRGROUP_GLOBAL 1 << 1
+/**
+ * XML_SCHEMAS_ATTRGROUP_MARKED:
+ *
+ * Marks the attr group as marked; used for circular checks.
+ */
+#define XML_SCHEMAS_ATTRGROUP_MARKED 1 << 2
+
+/**
+ * XML_SCHEMAS_ATTRGROUP_REDEFINED:
+ *
+ * The attr group was redefined.
+ */
+#define XML_SCHEMAS_ATTRGROUP_REDEFINED 1 << 3
+/**
+ * XML_SCHEMAS_ATTRGROUP_HAS_REFS:
+ *
+ * Whether this attr. group contains attr. group references.
+ */
+#define XML_SCHEMAS_ATTRGROUP_HAS_REFS 1 << 4
+
+/**
+ * An attribute group definition.
+ *
+ * xmlSchemaAttribute and xmlSchemaAttributeGroup start of structures
+ * must be kept similar
+ */
+typedef struct _xmlSchemaAttributeGroup xmlSchemaAttributeGroup;
+typedef xmlSchemaAttributeGroup *xmlSchemaAttributeGroupPtr;
+struct _xmlSchemaAttributeGroup {
+ xmlSchemaTypeType type; /* The kind of type */
+ struct _xmlSchemaAttribute *next;/* the next attribute if in a group ... */
+ const xmlChar *name;
+ const xmlChar *id;
+ const xmlChar *ref; /* Deprecated; not used */
+ const xmlChar *refNs; /* Deprecated; not used */
+ xmlSchemaAnnotPtr annot;
+
+ xmlSchemaAttributePtr attributes; /* Deprecated; not used */
+ xmlNodePtr node;
+ int flags;
+ xmlSchemaWildcardPtr attributeWildcard;
+ const xmlChar *refPrefix; /* Deprecated; not used */
+ xmlSchemaAttributeGroupPtr refItem; /* Deprecated; not used */
+ const xmlChar *targetNamespace;
+ void *attrUses;
+};
+
+/**
+ * xmlSchemaTypeLink:
+ * Used to build a list of types (e.g. member types of
+ * simpleType with variety "union").
+ */
+typedef struct _xmlSchemaTypeLink xmlSchemaTypeLink;
+typedef xmlSchemaTypeLink *xmlSchemaTypeLinkPtr;
+struct _xmlSchemaTypeLink {
+ struct _xmlSchemaTypeLink *next;/* the next type link ... */
+ xmlSchemaTypePtr type;/* the linked type */
+};
+
+/**
+ * xmlSchemaFacetLink:
+ * Used to build a list of facets.
+ */
+typedef struct _xmlSchemaFacetLink xmlSchemaFacetLink;
+typedef xmlSchemaFacetLink *xmlSchemaFacetLinkPtr;
+struct _xmlSchemaFacetLink {
+ struct _xmlSchemaFacetLink *next;/* the next facet link ... */
+ xmlSchemaFacetPtr facet;/* the linked facet */
+};
+
+/**
+ * XML_SCHEMAS_TYPE_MIXED:
+ *
+ * the element content type is mixed
+ */
+#define XML_SCHEMAS_TYPE_MIXED 1 << 0
+/**
+ * XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION:
+ *
+ * the simple or complex type has a derivation method of "extension".
+ */
+#define XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION 1 << 1
+/**
+ * XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION:
+ *
+ * the simple or complex type has a derivation method of "restriction".
+ */
+#define XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION 1 << 2
+/**
+ * XML_SCHEMAS_TYPE_GLOBAL:
+ *
+ * the type is global
+ */
+#define XML_SCHEMAS_TYPE_GLOBAL 1 << 3
+/**
+ * XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD:
+ *
+ * the complexType owns an attribute wildcard, i.e.
+ * it can be freed by the complexType
+ */
+#define XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD 1 << 4 /* Obsolete. */
+/**
+ * XML_SCHEMAS_TYPE_VARIETY_ABSENT:
+ *
+ * the simpleType has a variety of "absent".
+ * TODO: Actually not necessary :-/, since if
+ * none of the variety flags occur then it's
+ * automatically absent.
+ */
+#define XML_SCHEMAS_TYPE_VARIETY_ABSENT 1 << 5
+/**
+ * XML_SCHEMAS_TYPE_VARIETY_LIST:
+ *
+ * the simpleType has a variety of "list".
+ */
+#define XML_SCHEMAS_TYPE_VARIETY_LIST 1 << 6
+/**
+ * XML_SCHEMAS_TYPE_VARIETY_UNION:
+ *
+ * the simpleType has a variety of "union".
+ */
+#define XML_SCHEMAS_TYPE_VARIETY_UNION 1 << 7
+/**
+ * XML_SCHEMAS_TYPE_VARIETY_ATOMIC:
+ *
+ * the simpleType has a variety of "union".
+ */
+#define XML_SCHEMAS_TYPE_VARIETY_ATOMIC 1 << 8
+/**
+ * XML_SCHEMAS_TYPE_FINAL_EXTENSION:
+ *
+ * the complexType has a final of "extension".
+ */
+#define XML_SCHEMAS_TYPE_FINAL_EXTENSION 1 << 9
+/**
+ * XML_SCHEMAS_TYPE_FINAL_RESTRICTION:
+ *
+ * the simpleType/complexType has a final of "restriction".
+ */
+#define XML_SCHEMAS_TYPE_FINAL_RESTRICTION 1 << 10
+/**
+ * XML_SCHEMAS_TYPE_FINAL_LIST:
+ *
+ * the simpleType has a final of "list".
+ */
+#define XML_SCHEMAS_TYPE_FINAL_LIST 1 << 11
+/**
+ * XML_SCHEMAS_TYPE_FINAL_UNION:
+ *
+ * the simpleType has a final of "union".
+ */
+#define XML_SCHEMAS_TYPE_FINAL_UNION 1 << 12
+/**
+ * XML_SCHEMAS_TYPE_FINAL_DEFAULT:
+ *
+ * the simpleType has a final of "default".
+ */
+#define XML_SCHEMAS_TYPE_FINAL_DEFAULT 1 << 13
+/**
+ * XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE:
+ *
+ * Marks the item as a builtin primitive.
+ */
+#define XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE 1 << 14
+/**
+ * XML_SCHEMAS_TYPE_MARKED:
+ *
+ * Marks the item as marked; used for circular checks.
+ */
+#define XML_SCHEMAS_TYPE_MARKED 1 << 16
+/**
+ * XML_SCHEMAS_TYPE_BLOCK_DEFAULT:
+ *
+ * the complexType did not specify 'block' so use the default of the
+ * item.
+ */
+#define XML_SCHEMAS_TYPE_BLOCK_DEFAULT 1 << 17
+/**
+ * XML_SCHEMAS_TYPE_BLOCK_EXTENSION:
+ *
+ * the complexType has a 'block' of "extension".
+ */
+#define XML_SCHEMAS_TYPE_BLOCK_EXTENSION 1 << 18
+/**
+ * XML_SCHEMAS_TYPE_BLOCK_RESTRICTION:
+ *
+ * the complexType has a 'block' of "restriction".
+ */
+#define XML_SCHEMAS_TYPE_BLOCK_RESTRICTION 1 << 19
+/**
+ * XML_SCHEMAS_TYPE_ABSTRACT:
+ *
+ * the simple/complexType is abstract.
+ */
+#define XML_SCHEMAS_TYPE_ABSTRACT 1 << 20
+/**
+ * XML_SCHEMAS_TYPE_FACETSNEEDVALUE:
+ *
+ * indicates if the facets need a computed value
+ */
+#define XML_SCHEMAS_TYPE_FACETSNEEDVALUE 1 << 21
+/**
+ * XML_SCHEMAS_TYPE_INTERNAL_RESOLVED:
+ *
+ * indicates that the type was typefixed
+ */
+#define XML_SCHEMAS_TYPE_INTERNAL_RESOLVED 1 << 22
+/**
+ * XML_SCHEMAS_TYPE_INTERNAL_INVALID:
+ *
+ * indicates that the type is invalid
+ */
+#define XML_SCHEMAS_TYPE_INTERNAL_INVALID 1 << 23
+/**
+ * XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE:
+ *
+ * a whitespace-facet value of "preserve"
+ */
+#define XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE 1 << 24
+/**
+ * XML_SCHEMAS_TYPE_WHITESPACE_REPLACE:
+ *
+ * a whitespace-facet value of "replace"
+ */
+#define XML_SCHEMAS_TYPE_WHITESPACE_REPLACE 1 << 25
+/**
+ * XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE:
+ *
+ * a whitespace-facet value of "collapse"
+ */
+#define XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE 1 << 26
+/**
+ * XML_SCHEMAS_TYPE_HAS_FACETS:
+ *
+ * has facets
+ */
+#define XML_SCHEMAS_TYPE_HAS_FACETS 1 << 27
+/**
+ * XML_SCHEMAS_TYPE_NORMVALUENEEDED:
+ *
+ * indicates if the facets (pattern) need a normalized value
+ */
+#define XML_SCHEMAS_TYPE_NORMVALUENEEDED 1 << 28
+
+/**
+ * XML_SCHEMAS_TYPE_FIXUP_1:
+ *
+ * First stage of fixup was done.
+ */
+#define XML_SCHEMAS_TYPE_FIXUP_1 1 << 29
+
+/**
+ * XML_SCHEMAS_TYPE_REDEFINED:
+ *
+ * The type was redefined.
+ */
+#define XML_SCHEMAS_TYPE_REDEFINED 1 << 30
+/**
+ * XML_SCHEMAS_TYPE_REDEFINING:
+ *
+ * The type redefines an other type.
+ */
+/* #define XML_SCHEMAS_TYPE_REDEFINING 1 << 31 */
+
+/**
+ * _xmlSchemaType:
+ *
+ * Schemas type definition.
+ */
+struct _xmlSchemaType {
+ xmlSchemaTypeType type; /* The kind of type */
+ struct _xmlSchemaType *next; /* the next type if in a sequence ... */
+ const xmlChar *name;
+ const xmlChar *id ; /* Deprecated; not used */
+ const xmlChar *ref; /* Deprecated; not used */
+ const xmlChar *refNs; /* Deprecated; not used */
+ xmlSchemaAnnotPtr annot;
+ xmlSchemaTypePtr subtypes;
+ xmlSchemaAttributePtr attributes; /* Deprecated; not used */
+ xmlNodePtr node;
+ int minOccurs; /* Deprecated; not used */
+ int maxOccurs; /* Deprecated; not used */
+
+ int flags;
+ xmlSchemaContentType contentType;
+ const xmlChar *base; /* Base type's local name */
+ const xmlChar *baseNs; /* Base type's target namespace */
+ xmlSchemaTypePtr baseType; /* The base type component */
+ xmlSchemaFacetPtr facets; /* Local facets */
+ struct _xmlSchemaType *redef; /* Deprecated; not used */
+ int recurse; /* Obsolete */
+ xmlSchemaAttributeLinkPtr *attributeUses; /* Deprecated; not used */
+ xmlSchemaWildcardPtr attributeWildcard;
+ int builtInType; /* Type of built-in types. */
+ xmlSchemaTypeLinkPtr memberTypes; /* member-types if a union type. */
+ xmlSchemaFacetLinkPtr facetSet; /* All facets (incl. inherited) */
+ const xmlChar *refPrefix; /* Deprecated; not used */
+ xmlSchemaTypePtr contentTypeDef; /* Used for the simple content of complex types.
+ Could we use @subtypes for this? */
+ xmlRegexpPtr contModel; /* Holds the automaton of the content model */
+ const xmlChar *targetNamespace;
+ void *attrUses;
+};
+
+/*
+ * xmlSchemaElement:
+ * An element definition.
+ *
+ * xmlSchemaType, xmlSchemaFacet and xmlSchemaElement start of
+ * structures must be kept similar
+ */
+/**
+ * XML_SCHEMAS_ELEM_NILLABLE:
+ *
+ * the element is nillable
+ */
+#define XML_SCHEMAS_ELEM_NILLABLE 1 << 0
+/**
+ * XML_SCHEMAS_ELEM_GLOBAL:
+ *
+ * the element is global
+ */
+#define XML_SCHEMAS_ELEM_GLOBAL 1 << 1
+/**
+ * XML_SCHEMAS_ELEM_DEFAULT:
+ *
+ * the element has a default value
+ */
+#define XML_SCHEMAS_ELEM_DEFAULT 1 << 2
+/**
+ * XML_SCHEMAS_ELEM_FIXED:
+ *
+ * the element has a fixed value
+ */
+#define XML_SCHEMAS_ELEM_FIXED 1 << 3
+/**
+ * XML_SCHEMAS_ELEM_ABSTRACT:
+ *
+ * the element is abstract
+ */
+#define XML_SCHEMAS_ELEM_ABSTRACT 1 << 4
+/**
+ * XML_SCHEMAS_ELEM_TOPLEVEL:
+ *
+ * the element is top level
+ * obsolete: use XML_SCHEMAS_ELEM_GLOBAL instead
+ */
+#define XML_SCHEMAS_ELEM_TOPLEVEL 1 << 5
+/**
+ * XML_SCHEMAS_ELEM_REF:
+ *
+ * the element is a reference to a type
+ */
+#define XML_SCHEMAS_ELEM_REF 1 << 6
+/**
+ * XML_SCHEMAS_ELEM_NSDEFAULT:
+ *
+ * allow elements in no namespace
+ * Obsolete, not used anymore.
+ */
+#define XML_SCHEMAS_ELEM_NSDEFAULT 1 << 7
+/**
+ * XML_SCHEMAS_ELEM_INTERNAL_RESOLVED:
+ *
+ * this is set when "type", "ref", "substitutionGroup"
+ * references have been resolved.
+ */
+#define XML_SCHEMAS_ELEM_INTERNAL_RESOLVED 1 << 8
+ /**
+ * XML_SCHEMAS_ELEM_CIRCULAR:
+ *
+ * a helper flag for the search of circular references.
+ */
+#define XML_SCHEMAS_ELEM_CIRCULAR 1 << 9
+/**
+ * XML_SCHEMAS_ELEM_BLOCK_ABSENT:
+ *
+ * the "block" attribute is absent
+ */
+#define XML_SCHEMAS_ELEM_BLOCK_ABSENT 1 << 10
+/**
+ * XML_SCHEMAS_ELEM_BLOCK_EXTENSION:
+ *
+ * disallowed substitutions are absent
+ */
+#define XML_SCHEMAS_ELEM_BLOCK_EXTENSION 1 << 11
+/**
+ * XML_SCHEMAS_ELEM_BLOCK_RESTRICTION:
+ *
+ * disallowed substitutions: "restriction"
+ */
+#define XML_SCHEMAS_ELEM_BLOCK_RESTRICTION 1 << 12
+/**
+ * XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION:
+ *
+ * disallowed substitutions: "substitution"
+ */
+#define XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION 1 << 13
+/**
+ * XML_SCHEMAS_ELEM_FINAL_ABSENT:
+ *
+ * substitution group exclusions are absent
+ */
+#define XML_SCHEMAS_ELEM_FINAL_ABSENT 1 << 14
+/**
+ * XML_SCHEMAS_ELEM_FINAL_EXTENSION:
+ *
+ * substitution group exclusions: "extension"
+ */
+#define XML_SCHEMAS_ELEM_FINAL_EXTENSION 1 << 15
+/**
+ * XML_SCHEMAS_ELEM_FINAL_RESTRICTION:
+ *
+ * substitution group exclusions: "restriction"
+ */
+#define XML_SCHEMAS_ELEM_FINAL_RESTRICTION 1 << 16
+/**
+ * XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD:
+ *
+ * the declaration is a substitution group head
+ */
+#define XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD 1 << 17
+/**
+ * XML_SCHEMAS_ELEM_INTERNAL_CHECKED:
+ *
+ * this is set when the elem decl has been checked against
+ * all constraints
+ */
+#define XML_SCHEMAS_ELEM_INTERNAL_CHECKED 1 << 18
+
+typedef struct _xmlSchemaElement xmlSchemaElement;
+typedef xmlSchemaElement *xmlSchemaElementPtr;
+struct _xmlSchemaElement {
+ xmlSchemaTypeType type; /* The kind of type */
+ struct _xmlSchemaType *next; /* Not used? */
+ const xmlChar *name;
+ const xmlChar *id; /* Deprecated; not used */
+ const xmlChar *ref; /* Deprecated; not used */
+ const xmlChar *refNs; /* Deprecated; not used */
+ xmlSchemaAnnotPtr annot;
+ xmlSchemaTypePtr subtypes; /* the type definition */
+ xmlSchemaAttributePtr attributes;
+ xmlNodePtr node;
+ int minOccurs; /* Deprecated; not used */
+ int maxOccurs; /* Deprecated; not used */
+
+ int flags;
+ const xmlChar *targetNamespace;
+ const xmlChar *namedType;
+ const xmlChar *namedTypeNs;
+ const xmlChar *substGroup;
+ const xmlChar *substGroupNs;
+ const xmlChar *scope;
+ const xmlChar *value; /* The original value of the value constraint. */
+ struct _xmlSchemaElement *refDecl; /* This will now be used for the
+ substitution group affiliation */
+ xmlRegexpPtr contModel; /* Obsolete for WXS, maybe used for RelaxNG */
+ xmlSchemaContentType contentType;
+ const xmlChar *refPrefix; /* Deprecated; not used */
+ xmlSchemaValPtr defVal; /* The compiled value constraint. */
+ void *idcs; /* The identity-constraint defs */
+};
+
+/*
+ * XML_SCHEMAS_FACET_UNKNOWN:
+ *
+ * unknown facet handling
+ */
+#define XML_SCHEMAS_FACET_UNKNOWN 0
+/*
+ * XML_SCHEMAS_FACET_PRESERVE:
+ *
+ * preserve the type of the facet
+ */
+#define XML_SCHEMAS_FACET_PRESERVE 1
+/*
+ * XML_SCHEMAS_FACET_REPLACE:
+ *
+ * replace the type of the facet
+ */
+#define XML_SCHEMAS_FACET_REPLACE 2
+/*
+ * XML_SCHEMAS_FACET_COLLAPSE:
+ *
+ * collapse the types of the facet
+ */
+#define XML_SCHEMAS_FACET_COLLAPSE 3
+/**
+ * A facet definition.
+ */
+struct _xmlSchemaFacet {
+ xmlSchemaTypeType type; /* The kind of type */
+ struct _xmlSchemaFacet *next;/* the next type if in a sequence ... */
+ const xmlChar *value; /* The original value */
+ const xmlChar *id; /* Obsolete */
+ xmlSchemaAnnotPtr annot;
+ xmlNodePtr node;
+ int fixed; /* XML_SCHEMAS_FACET_PRESERVE, etc. */
+ int whitespace;
+ xmlSchemaValPtr val; /* The compiled value */
+ xmlRegexpPtr regexp; /* The regex for patterns */
+};
+
+/**
+ * A notation definition.
+ */
+typedef struct _xmlSchemaNotation xmlSchemaNotation;
+typedef xmlSchemaNotation *xmlSchemaNotationPtr;
+struct _xmlSchemaNotation {
+ xmlSchemaTypeType type; /* The kind of type */
+ const xmlChar *name;
+ xmlSchemaAnnotPtr annot;
+ const xmlChar *identifier;
+ const xmlChar *targetNamespace;
+};
+
+/*
+* TODO: Actually all those flags used for the schema should sit
+* on the schema parser context, since they are used only
+* during parsing an XML schema document, and not available
+* on the component level as per spec.
+*/
+/**
+ * XML_SCHEMAS_QUALIF_ELEM:
+ *
+ * Reflects elementFormDefault == qualified in
+ * an XML schema document.
+ */
+#define XML_SCHEMAS_QUALIF_ELEM 1 << 0
+/**
+ * XML_SCHEMAS_QUALIF_ATTR:
+ *
+ * Reflects attributeFormDefault == qualified in
+ * an XML schema document.
+ */
+#define XML_SCHEMAS_QUALIF_ATTR 1 << 1
+/**
+ * XML_SCHEMAS_FINAL_DEFAULT_EXTENSION:
+ *
+ * the schema has "extension" in the set of finalDefault.
+ */
+#define XML_SCHEMAS_FINAL_DEFAULT_EXTENSION 1 << 2
+/**
+ * XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION:
+ *
+ * the schema has "restriction" in the set of finalDefault.
+ */
+#define XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION 1 << 3
+/**
+ * XML_SCHEMAS_FINAL_DEFAULT_LIST:
+ *
+ * the schema has "list" in the set of finalDefault.
+ */
+#define XML_SCHEMAS_FINAL_DEFAULT_LIST 1 << 4
+/**
+ * XML_SCHEMAS_FINAL_DEFAULT_UNION:
+ *
+ * the schema has "union" in the set of finalDefault.
+ */
+#define XML_SCHEMAS_FINAL_DEFAULT_UNION 1 << 5
+/**
+ * XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION:
+ *
+ * the schema has "extension" in the set of blockDefault.
+ */
+#define XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION 1 << 6
+/**
+ * XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION:
+ *
+ * the schema has "restriction" in the set of blockDefault.
+ */
+#define XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION 1 << 7
+/**
+ * XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION:
+ *
+ * the schema has "substitution" in the set of blockDefault.
+ */
+#define XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION 1 << 8
+/**
+ * XML_SCHEMAS_INCLUDING_CONVERT_NS:
+ *
+ * the schema is currently including an other schema with
+ * no target namespace.
+ */
+#define XML_SCHEMAS_INCLUDING_CONVERT_NS 1 << 9
+/**
+ * _xmlSchema:
+ *
+ * A Schemas definition
+ */
+struct _xmlSchema {
+ const xmlChar *name; /* schema name */
+ const xmlChar *targetNamespace; /* the target namespace */
+ const xmlChar *version;
+ const xmlChar *id; /* Obsolete */
+ xmlDocPtr doc;
+ xmlSchemaAnnotPtr annot;
+ int flags;
+
+ xmlHashTablePtr typeDecl;
+ xmlHashTablePtr attrDecl;
+ xmlHashTablePtr attrgrpDecl;
+ xmlHashTablePtr elemDecl;
+ xmlHashTablePtr notaDecl;
+
+ xmlHashTablePtr schemasImports;
+
+ void *_private; /* unused by the library for users or bindings */
+ xmlHashTablePtr groupDecl;
+ xmlDictPtr dict;
+ void *includes; /* the includes, this is opaque for now */
+ int preserve; /* whether to free the document */
+ int counter; /* used to give anonymous components unique names */
+ xmlHashTablePtr idcDef; /* All identity-constraint defs. */
+ void *volatiles; /* Obsolete */
+};
+
+XMLPUBFUN void xmlSchemaFreeType (xmlSchemaTypePtr type);
+XMLPUBFUN void xmlSchemaFreeWildcard(xmlSchemaWildcardPtr wildcard);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LIBXML_SCHEMAS_ENABLED */
+#endif /* __XML_SCHEMA_INTERNALS_H__ */
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/libxml/xlink.h b/llava_video/lib/python3.10/site-packages/lxml/includes/libxml/xlink.h
new file mode 100644
index 0000000000000000000000000000000000000000..106573666ae462f2b4c1dafe86b39b1afb84530e
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/includes/libxml/xlink.h
@@ -0,0 +1,189 @@
+/*
+ * Summary: unfinished XLink detection module
+ * Description: unfinished XLink detection module
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_XLINK_H__
+#define __XML_XLINK_H__
+
+#include
+#include
+
+#ifdef LIBXML_XPTR_ENABLED
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Various defines for the various Link properties.
+ *
+ * NOTE: the link detection layer will try to resolve QName expansion
+ * of namespaces. If "foo" is the prefix for "http://foo.com/"
+ * then the link detection layer will expand role="foo:myrole"
+ * to "http://foo.com/:myrole".
+ * NOTE: the link detection layer will expand URI-References found on
+ * href attributes by using the base mechanism if found.
+ */
+typedef xmlChar *xlinkHRef;
+typedef xmlChar *xlinkRole;
+typedef xmlChar *xlinkTitle;
+
+typedef enum {
+ XLINK_TYPE_NONE = 0,
+ XLINK_TYPE_SIMPLE,
+ XLINK_TYPE_EXTENDED,
+ XLINK_TYPE_EXTENDED_SET
+} xlinkType;
+
+typedef enum {
+ XLINK_SHOW_NONE = 0,
+ XLINK_SHOW_NEW,
+ XLINK_SHOW_EMBED,
+ XLINK_SHOW_REPLACE
+} xlinkShow;
+
+typedef enum {
+ XLINK_ACTUATE_NONE = 0,
+ XLINK_ACTUATE_AUTO,
+ XLINK_ACTUATE_ONREQUEST
+} xlinkActuate;
+
+/**
+ * xlinkNodeDetectFunc:
+ * @ctx: user data pointer
+ * @node: the node to check
+ *
+ * This is the prototype for the link detection routine.
+ * It calls the default link detection callbacks upon link detection.
+ */
+typedef void (*xlinkNodeDetectFunc) (void *ctx, xmlNodePtr node);
+
+/*
+ * The link detection module interact with the upper layers using
+ * a set of callback registered at parsing time.
+ */
+
+/**
+ * xlinkSimpleLinkFunk:
+ * @ctx: user data pointer
+ * @node: the node carrying the link
+ * @href: the target of the link
+ * @role: the role string
+ * @title: the link title
+ *
+ * This is the prototype for a simple link detection callback.
+ */
+typedef void
+(*xlinkSimpleLinkFunk) (void *ctx,
+ xmlNodePtr node,
+ const xlinkHRef href,
+ const xlinkRole role,
+ const xlinkTitle title);
+
+/**
+ * xlinkExtendedLinkFunk:
+ * @ctx: user data pointer
+ * @node: the node carrying the link
+ * @nbLocators: the number of locators detected on the link
+ * @hrefs: pointer to the array of locator hrefs
+ * @roles: pointer to the array of locator roles
+ * @nbArcs: the number of arcs detected on the link
+ * @from: pointer to the array of source roles found on the arcs
+ * @to: pointer to the array of target roles found on the arcs
+ * @show: array of values for the show attributes found on the arcs
+ * @actuate: array of values for the actuate attributes found on the arcs
+ * @nbTitles: the number of titles detected on the link
+ * @title: array of titles detected on the link
+ * @langs: array of xml:lang values for the titles
+ *
+ * This is the prototype for a extended link detection callback.
+ */
+typedef void
+(*xlinkExtendedLinkFunk)(void *ctx,
+ xmlNodePtr node,
+ int nbLocators,
+ const xlinkHRef *hrefs,
+ const xlinkRole *roles,
+ int nbArcs,
+ const xlinkRole *from,
+ const xlinkRole *to,
+ xlinkShow *show,
+ xlinkActuate *actuate,
+ int nbTitles,
+ const xlinkTitle *titles,
+ const xmlChar **langs);
+
+/**
+ * xlinkExtendedLinkSetFunk:
+ * @ctx: user data pointer
+ * @node: the node carrying the link
+ * @nbLocators: the number of locators detected on the link
+ * @hrefs: pointer to the array of locator hrefs
+ * @roles: pointer to the array of locator roles
+ * @nbTitles: the number of titles detected on the link
+ * @title: array of titles detected on the link
+ * @langs: array of xml:lang values for the titles
+ *
+ * This is the prototype for a extended link set detection callback.
+ */
+typedef void
+(*xlinkExtendedLinkSetFunk) (void *ctx,
+ xmlNodePtr node,
+ int nbLocators,
+ const xlinkHRef *hrefs,
+ const xlinkRole *roles,
+ int nbTitles,
+ const xlinkTitle *titles,
+ const xmlChar **langs);
+
+/**
+ * This is the structure containing a set of Links detection callbacks.
+ *
+ * There is no default xlink callbacks, if one want to get link
+ * recognition activated, those call backs must be provided before parsing.
+ */
+typedef struct _xlinkHandler xlinkHandler;
+typedef xlinkHandler *xlinkHandlerPtr;
+struct _xlinkHandler {
+ xlinkSimpleLinkFunk simple;
+ xlinkExtendedLinkFunk extended;
+ xlinkExtendedLinkSetFunk set;
+};
+
+/*
+ * The default detection routine, can be overridden, they call the default
+ * detection callbacks.
+ */
+
+XMLPUBFUN xlinkNodeDetectFunc
+ xlinkGetDefaultDetect (void);
+XMLPUBFUN void
+ xlinkSetDefaultDetect (xlinkNodeDetectFunc func);
+
+/*
+ * Routines to set/get the default handlers.
+ */
+XMLPUBFUN xlinkHandlerPtr
+ xlinkGetDefaultHandler (void);
+XMLPUBFUN void
+ xlinkSetDefaultHandler (xlinkHandlerPtr handler);
+
+/*
+ * Link detection module itself.
+ */
+XMLPUBFUN xlinkType
+ xlinkIsLink (xmlDocPtr doc,
+ xmlNodePtr node);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LIBXML_XPTR_ENABLED */
+
+#endif /* __XML_XLINK_H__ */
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/libxml/xmlversion.h b/llava_video/lib/python3.10/site-packages/lxml/includes/libxml/xmlversion.h
new file mode 100644
index 0000000000000000000000000000000000000000..cec304f6809828bc053f26021a1b6ef473b8952c
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/includes/libxml/xmlversion.h
@@ -0,0 +1,511 @@
+/*
+ * Summary: compile-time version information
+ * Description: compile-time version information for the XML library
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_VERSION_H__
+#define __XML_VERSION_H__
+
+#include
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * use those to be sure nothing nasty will happen if
+ * your library and includes mismatch
+ */
+#ifndef LIBXML2_COMPILING_MSCCDEF
+XMLPUBFUN void xmlCheckVersion(int version);
+#endif /* LIBXML2_COMPILING_MSCCDEF */
+
+/**
+ * LIBXML_DOTTED_VERSION:
+ *
+ * the version string like "1.2.3"
+ */
+#define LIBXML_DOTTED_VERSION "2.12.9"
+
+/**
+ * LIBXML_VERSION:
+ *
+ * the version number: 1.2.3 value is 10203
+ */
+#define LIBXML_VERSION 21209
+
+/**
+ * LIBXML_VERSION_STRING:
+ *
+ * the version number string, 1.2.3 value is "10203"
+ */
+#define LIBXML_VERSION_STRING "21209"
+
+/**
+ * LIBXML_VERSION_EXTRA:
+ *
+ * extra version information, used to show a git commit description
+ */
+#define LIBXML_VERSION_EXTRA ""
+
+/**
+ * LIBXML_TEST_VERSION:
+ *
+ * Macro to check that the libxml version in use is compatible with
+ * the version the software has been compiled against
+ */
+#define LIBXML_TEST_VERSION xmlCheckVersion(21209);
+
+#ifndef VMS
+#if 0
+/**
+ * WITH_TRIO:
+ *
+ * defined if the trio support need to be configured in
+ */
+#define WITH_TRIO
+#else
+/**
+ * WITHOUT_TRIO:
+ *
+ * defined if the trio support should not be configured in
+ */
+#define WITHOUT_TRIO
+#endif
+#else /* VMS */
+/**
+ * WITH_TRIO:
+ *
+ * defined if the trio support need to be configured in
+ */
+#define WITH_TRIO 1
+#endif /* VMS */
+
+/**
+ * LIBXML_THREAD_ENABLED:
+ *
+ * Whether the thread support is configured in
+ */
+#if 1
+#define LIBXML_THREAD_ENABLED
+#endif
+
+/**
+ * LIBXML_THREAD_ALLOC_ENABLED:
+ *
+ * Whether the allocation hooks are per-thread
+ */
+#if 0
+#define LIBXML_THREAD_ALLOC_ENABLED
+#endif
+
+/**
+ * LIBXML_TREE_ENABLED:
+ *
+ * Whether the DOM like tree manipulation API support is configured in
+ */
+#if 1
+#define LIBXML_TREE_ENABLED
+#endif
+
+/**
+ * LIBXML_OUTPUT_ENABLED:
+ *
+ * Whether the serialization/saving support is configured in
+ */
+#if 1
+#define LIBXML_OUTPUT_ENABLED
+#endif
+
+/**
+ * LIBXML_PUSH_ENABLED:
+ *
+ * Whether the push parsing interfaces are configured in
+ */
+#if 1
+#define LIBXML_PUSH_ENABLED
+#endif
+
+/**
+ * LIBXML_READER_ENABLED:
+ *
+ * Whether the xmlReader parsing interface is configured in
+ */
+#if 1
+#define LIBXML_READER_ENABLED
+#endif
+
+/**
+ * LIBXML_PATTERN_ENABLED:
+ *
+ * Whether the xmlPattern node selection interface is configured in
+ */
+#if 1
+#define LIBXML_PATTERN_ENABLED
+#endif
+
+/**
+ * LIBXML_WRITER_ENABLED:
+ *
+ * Whether the xmlWriter saving interface is configured in
+ */
+#if 1
+#define LIBXML_WRITER_ENABLED
+#endif
+
+/**
+ * LIBXML_SAX1_ENABLED:
+ *
+ * Whether the older SAX1 interface is configured in
+ */
+#if 1
+#define LIBXML_SAX1_ENABLED
+#endif
+
+/**
+ * LIBXML_FTP_ENABLED:
+ *
+ * Whether the FTP support is configured in
+ */
+#if 0
+#define LIBXML_FTP_ENABLED
+#endif
+
+/**
+ * LIBXML_HTTP_ENABLED:
+ *
+ * Whether the HTTP support is configured in
+ */
+#if 1
+#define LIBXML_HTTP_ENABLED
+#endif
+
+/**
+ * LIBXML_VALID_ENABLED:
+ *
+ * Whether the DTD validation support is configured in
+ */
+#if 1
+#define LIBXML_VALID_ENABLED
+#endif
+
+/**
+ * LIBXML_HTML_ENABLED:
+ *
+ * Whether the HTML support is configured in
+ */
+#if 1
+#define LIBXML_HTML_ENABLED
+#endif
+
+/**
+ * LIBXML_LEGACY_ENABLED:
+ *
+ * Whether the deprecated APIs are compiled in for compatibility
+ */
+#if 0
+#define LIBXML_LEGACY_ENABLED
+#endif
+
+/**
+ * LIBXML_C14N_ENABLED:
+ *
+ * Whether the Canonicalization support is configured in
+ */
+#if 1
+#define LIBXML_C14N_ENABLED
+#endif
+
+/**
+ * LIBXML_CATALOG_ENABLED:
+ *
+ * Whether the Catalog support is configured in
+ */
+#if 1
+#define LIBXML_CATALOG_ENABLED
+#endif
+
+/**
+ * LIBXML_XPATH_ENABLED:
+ *
+ * Whether XPath is configured in
+ */
+#if 1
+#define LIBXML_XPATH_ENABLED
+#endif
+
+/**
+ * LIBXML_XPTR_ENABLED:
+ *
+ * Whether XPointer is configured in
+ */
+#if 1
+#define LIBXML_XPTR_ENABLED
+#endif
+
+/**
+ * LIBXML_XPTR_LOCS_ENABLED:
+ *
+ * Whether support for XPointer locations is configured in
+ */
+#if 0
+#define LIBXML_XPTR_LOCS_ENABLED
+#endif
+
+/**
+ * LIBXML_XINCLUDE_ENABLED:
+ *
+ * Whether XInclude is configured in
+ */
+#if 1
+#define LIBXML_XINCLUDE_ENABLED
+#endif
+
+/**
+ * LIBXML_ICONV_ENABLED:
+ *
+ * Whether iconv support is available
+ */
+#if 1
+#define LIBXML_ICONV_ENABLED
+#endif
+
+/**
+ * LIBXML_ICU_ENABLED:
+ *
+ * Whether icu support is available
+ */
+#if 0
+#define LIBXML_ICU_ENABLED
+#endif
+
+/**
+ * LIBXML_ISO8859X_ENABLED:
+ *
+ * Whether ISO-8859-* support is made available in case iconv is not
+ */
+#if 1
+#define LIBXML_ISO8859X_ENABLED
+#endif
+
+/**
+ * LIBXML_DEBUG_ENABLED:
+ *
+ * Whether Debugging module is configured in
+ */
+#if 1
+#define LIBXML_DEBUG_ENABLED
+#endif
+
+/**
+ * DEBUG_MEMORY_LOCATION:
+ *
+ * Whether the memory debugging is configured in
+ */
+#if 0
+#define DEBUG_MEMORY_LOCATION
+#endif
+
+/**
+ * LIBXML_DEBUG_RUNTIME:
+ *
+ * Removed
+ */
+#if 0
+#define LIBXML_DEBUG_RUNTIME
+#endif
+
+/**
+ * LIBXML_UNICODE_ENABLED:
+ *
+ * Whether the Unicode related interfaces are compiled in
+ */
+#if 1
+#define LIBXML_UNICODE_ENABLED
+#endif
+
+/**
+ * LIBXML_REGEXP_ENABLED:
+ *
+ * Whether the regular expressions interfaces are compiled in
+ */
+#if 1
+#define LIBXML_REGEXP_ENABLED
+#endif
+
+/**
+ * LIBXML_AUTOMATA_ENABLED:
+ *
+ * Whether the automata interfaces are compiled in
+ */
+#if 1
+#define LIBXML_AUTOMATA_ENABLED
+#endif
+
+/**
+ * LIBXML_EXPR_ENABLED:
+ *
+ * Whether the formal expressions interfaces are compiled in
+ *
+ * This code is unused and disabled unconditionally for now.
+ */
+#if 0
+#define LIBXML_EXPR_ENABLED
+#endif
+
+/**
+ * LIBXML_SCHEMAS_ENABLED:
+ *
+ * Whether the Schemas validation interfaces are compiled in
+ */
+#if 1
+#define LIBXML_SCHEMAS_ENABLED
+#endif
+
+/**
+ * LIBXML_SCHEMATRON_ENABLED:
+ *
+ * Whether the Schematron validation interfaces are compiled in
+ */
+#if 1
+#define LIBXML_SCHEMATRON_ENABLED
+#endif
+
+/**
+ * LIBXML_MODULES_ENABLED:
+ *
+ * Whether the module interfaces are compiled in
+ */
+#if 1
+#define LIBXML_MODULES_ENABLED
+/**
+ * LIBXML_MODULE_EXTENSION:
+ *
+ * the string suffix used by dynamic modules (usually shared libraries)
+ */
+#define LIBXML_MODULE_EXTENSION ".so"
+#endif
+
+/**
+ * LIBXML_ZLIB_ENABLED:
+ *
+ * Whether the Zlib support is compiled in
+ */
+#if 1
+#define LIBXML_ZLIB_ENABLED
+#endif
+
+/**
+ * LIBXML_LZMA_ENABLED:
+ *
+ * Whether the Lzma support is compiled in
+ */
+#if 0
+#define LIBXML_LZMA_ENABLED
+#endif
+
+#ifdef __GNUC__
+/** DOC_DISABLE */
+
+#ifndef ATTRIBUTE_UNUSED
+# if ((__GNUC__ > 2) || ((__GNUC__ == 2) && (__GNUC_MINOR__ >= 7)))
+# define ATTRIBUTE_UNUSED __attribute__((unused))
+# else
+# define ATTRIBUTE_UNUSED
+# endif
+#endif
+
+#ifndef LIBXML_ATTR_ALLOC_SIZE
+# if (!defined(__clang__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3))))
+# define LIBXML_ATTR_ALLOC_SIZE(x) __attribute__((alloc_size(x)))
+# else
+# define LIBXML_ATTR_ALLOC_SIZE(x)
+# endif
+#else
+# define LIBXML_ATTR_ALLOC_SIZE(x)
+#endif
+
+#ifndef LIBXML_ATTR_FORMAT
+# if ((__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)))
+# define LIBXML_ATTR_FORMAT(fmt,args) __attribute__((__format__(__printf__,fmt,args)))
+# else
+# define LIBXML_ATTR_FORMAT(fmt,args)
+# endif
+#else
+# define LIBXML_ATTR_FORMAT(fmt,args)
+#endif
+
+#ifndef XML_DEPRECATED
+# if defined (IN_LIBXML) || (__GNUC__ * 100 + __GNUC_MINOR__ < 301)
+# define XML_DEPRECATED
+/* Available since at least GCC 3.1 */
+# else
+# define XML_DEPRECATED __attribute__((deprecated))
+# endif
+#endif
+
+#if defined(__clang__) || (__GNUC__ * 100 + __GNUC_MINOR__ >= 406)
+ #if defined(__clang__) || (__GNUC__ * 100 + __GNUC_MINOR__ >= 800)
+ #define XML_IGNORE_FPTR_CAST_WARNINGS \
+ _Pragma("GCC diagnostic push") \
+ _Pragma("GCC diagnostic ignored \"-Wpedantic\"") \
+ _Pragma("GCC diagnostic ignored \"-Wcast-function-type\"")
+ #else
+ #define XML_IGNORE_FPTR_CAST_WARNINGS \
+ _Pragma("GCC diagnostic push") \
+ _Pragma("GCC diagnostic ignored \"-Wpedantic\"")
+ #endif
+ #define XML_POP_WARNINGS \
+ _Pragma("GCC diagnostic pop")
+#else
+ #define XML_IGNORE_FPTR_CAST_WARNINGS
+ #define XML_POP_WARNINGS
+#endif
+
+#else /* ! __GNUC__ */
+#define ATTRIBUTE_UNUSED
+#define LIBXML_ATTR_ALLOC_SIZE(x)
+#define LIBXML_ATTR_FORMAT(fmt,args)
+#ifndef XML_DEPRECATED
+# if defined (IN_LIBXML) || !defined (_MSC_VER)
+# define XML_DEPRECATED
+/* Available since Visual Studio 2005 */
+# elif defined (_MSC_VER) && (_MSC_VER >= 1400)
+# define XML_DEPRECATED __declspec(deprecated)
+# endif
+#endif
+#if defined (_MSC_VER) && (_MSC_VER >= 1400)
+# define XML_IGNORE_FPTR_CAST_WARNINGS __pragma(warning(push))
+#else
+# define XML_IGNORE_FPTR_CAST_WARNINGS
+#endif
+#ifndef XML_POP_WARNINGS
+# if defined (_MSC_VER) && (_MSC_VER >= 1400)
+# define XML_POP_WARNINGS __pragma(warning(pop))
+# else
+# define XML_POP_WARNINGS
+# endif
+#endif
+#endif /* __GNUC__ */
+
+#define XML_NO_ATTR
+
+#ifdef LIBXML_THREAD_ENABLED
+ #define XML_DECLARE_GLOBAL(name, type, attrs) \
+ attrs XMLPUBFUN type *__##name(void);
+ #define XML_GLOBAL_MACRO(name) (*__##name())
+#else
+ #define XML_DECLARE_GLOBAL(name, type, attrs) \
+ attrs XMLPUBVAR type name;
+#endif
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif
+
+
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/libxml/xmlwriter.h b/llava_video/lib/python3.10/site-packages/lxml/includes/libxml/xmlwriter.h
new file mode 100644
index 0000000000000000000000000000000000000000..339f25114b59be0571615e3b2fb13a0121cabdca
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/includes/libxml/xmlwriter.h
@@ -0,0 +1,488 @@
+/*
+ * Summary: text writing API for XML
+ * Description: text writing API for XML
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Alfred Mickautsch
+ */
+
+#ifndef __XML_XMLWRITER_H__
+#define __XML_XMLWRITER_H__
+
+#include
+
+#ifdef LIBXML_WRITER_ENABLED
+
+#include
+#include
+#include
+#include
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ typedef struct _xmlTextWriter xmlTextWriter;
+ typedef xmlTextWriter *xmlTextWriterPtr;
+
+/*
+ * Constructors & Destructor
+ */
+ XMLPUBFUN xmlTextWriterPtr
+ xmlNewTextWriter(xmlOutputBufferPtr out);
+ XMLPUBFUN xmlTextWriterPtr
+ xmlNewTextWriterFilename(const char *uri, int compression);
+ XMLPUBFUN xmlTextWriterPtr
+ xmlNewTextWriterMemory(xmlBufferPtr buf, int compression);
+ XMLPUBFUN xmlTextWriterPtr
+ xmlNewTextWriterPushParser(xmlParserCtxtPtr ctxt, int compression);
+ XMLPUBFUN xmlTextWriterPtr
+ xmlNewTextWriterDoc(xmlDocPtr * doc, int compression);
+ XMLPUBFUN xmlTextWriterPtr
+ xmlNewTextWriterTree(xmlDocPtr doc, xmlNodePtr node,
+ int compression);
+ XMLPUBFUN void xmlFreeTextWriter(xmlTextWriterPtr writer);
+
+/*
+ * Functions
+ */
+
+
+/*
+ * Document
+ */
+ XMLPUBFUN int
+ xmlTextWriterStartDocument(xmlTextWriterPtr writer,
+ const char *version,
+ const char *encoding,
+ const char *standalone);
+ XMLPUBFUN int xmlTextWriterEndDocument(xmlTextWriterPtr
+ writer);
+
+/*
+ * Comments
+ */
+ XMLPUBFUN int xmlTextWriterStartComment(xmlTextWriterPtr
+ writer);
+ XMLPUBFUN int xmlTextWriterEndComment(xmlTextWriterPtr writer);
+ XMLPUBFUN int
+ xmlTextWriterWriteFormatComment(xmlTextWriterPtr writer,
+ const char *format, ...)
+ LIBXML_ATTR_FORMAT(2,3);
+ XMLPUBFUN int
+ xmlTextWriterWriteVFormatComment(xmlTextWriterPtr writer,
+ const char *format,
+ va_list argptr)
+ LIBXML_ATTR_FORMAT(2,0);
+ XMLPUBFUN int xmlTextWriterWriteComment(xmlTextWriterPtr
+ writer,
+ const xmlChar *
+ content);
+
+/*
+ * Elements
+ */
+ XMLPUBFUN int
+ xmlTextWriterStartElement(xmlTextWriterPtr writer,
+ const xmlChar * name);
+ XMLPUBFUN int xmlTextWriterStartElementNS(xmlTextWriterPtr
+ writer,
+ const xmlChar *
+ prefix,
+ const xmlChar * name,
+ const xmlChar *
+ namespaceURI);
+ XMLPUBFUN int xmlTextWriterEndElement(xmlTextWriterPtr writer);
+ XMLPUBFUN int xmlTextWriterFullEndElement(xmlTextWriterPtr
+ writer);
+
+/*
+ * Elements conveniency functions
+ */
+ XMLPUBFUN int
+ xmlTextWriterWriteFormatElement(xmlTextWriterPtr writer,
+ const xmlChar * name,
+ const char *format, ...)
+ LIBXML_ATTR_FORMAT(3,4);
+ XMLPUBFUN int
+ xmlTextWriterWriteVFormatElement(xmlTextWriterPtr writer,
+ const xmlChar * name,
+ const char *format,
+ va_list argptr)
+ LIBXML_ATTR_FORMAT(3,0);
+ XMLPUBFUN int xmlTextWriterWriteElement(xmlTextWriterPtr
+ writer,
+ const xmlChar * name,
+ const xmlChar *
+ content);
+ XMLPUBFUN int
+ xmlTextWriterWriteFormatElementNS(xmlTextWriterPtr writer,
+ const xmlChar * prefix,
+ const xmlChar * name,
+ const xmlChar * namespaceURI,
+ const char *format, ...)
+ LIBXML_ATTR_FORMAT(5,6);
+ XMLPUBFUN int
+ xmlTextWriterWriteVFormatElementNS(xmlTextWriterPtr writer,
+ const xmlChar * prefix,
+ const xmlChar * name,
+ const xmlChar * namespaceURI,
+ const char *format,
+ va_list argptr)
+ LIBXML_ATTR_FORMAT(5,0);
+ XMLPUBFUN int xmlTextWriterWriteElementNS(xmlTextWriterPtr
+ writer,
+ const xmlChar *
+ prefix,
+ const xmlChar * name,
+ const xmlChar *
+ namespaceURI,
+ const xmlChar *
+ content);
+
+/*
+ * Text
+ */
+ XMLPUBFUN int
+ xmlTextWriterWriteFormatRaw(xmlTextWriterPtr writer,
+ const char *format, ...)
+ LIBXML_ATTR_FORMAT(2,3);
+ XMLPUBFUN int
+ xmlTextWriterWriteVFormatRaw(xmlTextWriterPtr writer,
+ const char *format, va_list argptr)
+ LIBXML_ATTR_FORMAT(2,0);
+ XMLPUBFUN int
+ xmlTextWriterWriteRawLen(xmlTextWriterPtr writer,
+ const xmlChar * content, int len);
+ XMLPUBFUN int
+ xmlTextWriterWriteRaw(xmlTextWriterPtr writer,
+ const xmlChar * content);
+ XMLPUBFUN int xmlTextWriterWriteFormatString(xmlTextWriterPtr
+ writer,
+ const char
+ *format, ...)
+ LIBXML_ATTR_FORMAT(2,3);
+ XMLPUBFUN int xmlTextWriterWriteVFormatString(xmlTextWriterPtr
+ writer,
+ const char
+ *format,
+ va_list argptr)
+ LIBXML_ATTR_FORMAT(2,0);
+ XMLPUBFUN int xmlTextWriterWriteString(xmlTextWriterPtr writer,
+ const xmlChar *
+ content);
+ XMLPUBFUN int xmlTextWriterWriteBase64(xmlTextWriterPtr writer,
+ const char *data,
+ int start, int len);
+ XMLPUBFUN int xmlTextWriterWriteBinHex(xmlTextWriterPtr writer,
+ const char *data,
+ int start, int len);
+
+/*
+ * Attributes
+ */
+ XMLPUBFUN int
+ xmlTextWriterStartAttribute(xmlTextWriterPtr writer,
+ const xmlChar * name);
+ XMLPUBFUN int xmlTextWriterStartAttributeNS(xmlTextWriterPtr
+ writer,
+ const xmlChar *
+ prefix,
+ const xmlChar *
+ name,
+ const xmlChar *
+ namespaceURI);
+ XMLPUBFUN int xmlTextWriterEndAttribute(xmlTextWriterPtr
+ writer);
+
+/*
+ * Attributes conveniency functions
+ */
+ XMLPUBFUN int
+ xmlTextWriterWriteFormatAttribute(xmlTextWriterPtr writer,
+ const xmlChar * name,
+ const char *format, ...)
+ LIBXML_ATTR_FORMAT(3,4);
+ XMLPUBFUN int
+ xmlTextWriterWriteVFormatAttribute(xmlTextWriterPtr writer,
+ const xmlChar * name,
+ const char *format,
+ va_list argptr)
+ LIBXML_ATTR_FORMAT(3,0);
+ XMLPUBFUN int xmlTextWriterWriteAttribute(xmlTextWriterPtr
+ writer,
+ const xmlChar * name,
+ const xmlChar *
+ content);
+ XMLPUBFUN int
+ xmlTextWriterWriteFormatAttributeNS(xmlTextWriterPtr writer,
+ const xmlChar * prefix,
+ const xmlChar * name,
+ const xmlChar * namespaceURI,
+ const char *format, ...)
+ LIBXML_ATTR_FORMAT(5,6);
+ XMLPUBFUN int
+ xmlTextWriterWriteVFormatAttributeNS(xmlTextWriterPtr writer,
+ const xmlChar * prefix,
+ const xmlChar * name,
+ const xmlChar * namespaceURI,
+ const char *format,
+ va_list argptr)
+ LIBXML_ATTR_FORMAT(5,0);
+ XMLPUBFUN int xmlTextWriterWriteAttributeNS(xmlTextWriterPtr
+ writer,
+ const xmlChar *
+ prefix,
+ const xmlChar *
+ name,
+ const xmlChar *
+ namespaceURI,
+ const xmlChar *
+ content);
+
+/*
+ * PI's
+ */
+ XMLPUBFUN int
+ xmlTextWriterStartPI(xmlTextWriterPtr writer,
+ const xmlChar * target);
+ XMLPUBFUN int xmlTextWriterEndPI(xmlTextWriterPtr writer);
+
+/*
+ * PI conveniency functions
+ */
+ XMLPUBFUN int
+ xmlTextWriterWriteFormatPI(xmlTextWriterPtr writer,
+ const xmlChar * target,
+ const char *format, ...)
+ LIBXML_ATTR_FORMAT(3,4);
+ XMLPUBFUN int
+ xmlTextWriterWriteVFormatPI(xmlTextWriterPtr writer,
+ const xmlChar * target,
+ const char *format, va_list argptr)
+ LIBXML_ATTR_FORMAT(3,0);
+ XMLPUBFUN int
+ xmlTextWriterWritePI(xmlTextWriterPtr writer,
+ const xmlChar * target,
+ const xmlChar * content);
+
+/**
+ * xmlTextWriterWriteProcessingInstruction:
+ *
+ * This macro maps to xmlTextWriterWritePI
+ */
+#define xmlTextWriterWriteProcessingInstruction xmlTextWriterWritePI
+
+/*
+ * CDATA
+ */
+ XMLPUBFUN int xmlTextWriterStartCDATA(xmlTextWriterPtr writer);
+ XMLPUBFUN int xmlTextWriterEndCDATA(xmlTextWriterPtr writer);
+
+/*
+ * CDATA conveniency functions
+ */
+ XMLPUBFUN int
+ xmlTextWriterWriteFormatCDATA(xmlTextWriterPtr writer,
+ const char *format, ...)
+ LIBXML_ATTR_FORMAT(2,3);
+ XMLPUBFUN int
+ xmlTextWriterWriteVFormatCDATA(xmlTextWriterPtr writer,
+ const char *format, va_list argptr)
+ LIBXML_ATTR_FORMAT(2,0);
+ XMLPUBFUN int
+ xmlTextWriterWriteCDATA(xmlTextWriterPtr writer,
+ const xmlChar * content);
+
+/*
+ * DTD
+ */
+ XMLPUBFUN int
+ xmlTextWriterStartDTD(xmlTextWriterPtr writer,
+ const xmlChar * name,
+ const xmlChar * pubid,
+ const xmlChar * sysid);
+ XMLPUBFUN int xmlTextWriterEndDTD(xmlTextWriterPtr writer);
+
+/*
+ * DTD conveniency functions
+ */
+ XMLPUBFUN int
+ xmlTextWriterWriteFormatDTD(xmlTextWriterPtr writer,
+ const xmlChar * name,
+ const xmlChar * pubid,
+ const xmlChar * sysid,
+ const char *format, ...)
+ LIBXML_ATTR_FORMAT(5,6);
+ XMLPUBFUN int
+ xmlTextWriterWriteVFormatDTD(xmlTextWriterPtr writer,
+ const xmlChar * name,
+ const xmlChar * pubid,
+ const xmlChar * sysid,
+ const char *format, va_list argptr)
+ LIBXML_ATTR_FORMAT(5,0);
+ XMLPUBFUN int
+ xmlTextWriterWriteDTD(xmlTextWriterPtr writer,
+ const xmlChar * name,
+ const xmlChar * pubid,
+ const xmlChar * sysid,
+ const xmlChar * subset);
+
+/**
+ * xmlTextWriterWriteDocType:
+ *
+ * this macro maps to xmlTextWriterWriteDTD
+ */
+#define xmlTextWriterWriteDocType xmlTextWriterWriteDTD
+
+/*
+ * DTD element definition
+ */
+ XMLPUBFUN int
+ xmlTextWriterStartDTDElement(xmlTextWriterPtr writer,
+ const xmlChar * name);
+ XMLPUBFUN int xmlTextWriterEndDTDElement(xmlTextWriterPtr
+ writer);
+
+/*
+ * DTD element definition conveniency functions
+ */
+ XMLPUBFUN int
+ xmlTextWriterWriteFormatDTDElement(xmlTextWriterPtr writer,
+ const xmlChar * name,
+ const char *format, ...)
+ LIBXML_ATTR_FORMAT(3,4);
+ XMLPUBFUN int
+ xmlTextWriterWriteVFormatDTDElement(xmlTextWriterPtr writer,
+ const xmlChar * name,
+ const char *format,
+ va_list argptr)
+ LIBXML_ATTR_FORMAT(3,0);
+ XMLPUBFUN int xmlTextWriterWriteDTDElement(xmlTextWriterPtr
+ writer,
+ const xmlChar *
+ name,
+ const xmlChar *
+ content);
+
+/*
+ * DTD attribute list definition
+ */
+ XMLPUBFUN int
+ xmlTextWriterStartDTDAttlist(xmlTextWriterPtr writer,
+ const xmlChar * name);
+ XMLPUBFUN int xmlTextWriterEndDTDAttlist(xmlTextWriterPtr
+ writer);
+
+/*
+ * DTD attribute list definition conveniency functions
+ */
+ XMLPUBFUN int
+ xmlTextWriterWriteFormatDTDAttlist(xmlTextWriterPtr writer,
+ const xmlChar * name,
+ const char *format, ...)
+ LIBXML_ATTR_FORMAT(3,4);
+ XMLPUBFUN int
+ xmlTextWriterWriteVFormatDTDAttlist(xmlTextWriterPtr writer,
+ const xmlChar * name,
+ const char *format,
+ va_list argptr)
+ LIBXML_ATTR_FORMAT(3,0);
+ XMLPUBFUN int xmlTextWriterWriteDTDAttlist(xmlTextWriterPtr
+ writer,
+ const xmlChar *
+ name,
+ const xmlChar *
+ content);
+
+/*
+ * DTD entity definition
+ */
+ XMLPUBFUN int
+ xmlTextWriterStartDTDEntity(xmlTextWriterPtr writer,
+ int pe, const xmlChar * name);
+ XMLPUBFUN int xmlTextWriterEndDTDEntity(xmlTextWriterPtr
+ writer);
+
+/*
+ * DTD entity definition conveniency functions
+ */
+ XMLPUBFUN int
+ xmlTextWriterWriteFormatDTDInternalEntity(xmlTextWriterPtr writer,
+ int pe,
+ const xmlChar * name,
+ const char *format, ...)
+ LIBXML_ATTR_FORMAT(4,5);
+ XMLPUBFUN int
+ xmlTextWriterWriteVFormatDTDInternalEntity(xmlTextWriterPtr writer,
+ int pe,
+ const xmlChar * name,
+ const char *format,
+ va_list argptr)
+ LIBXML_ATTR_FORMAT(4,0);
+ XMLPUBFUN int
+ xmlTextWriterWriteDTDInternalEntity(xmlTextWriterPtr writer,
+ int pe,
+ const xmlChar * name,
+ const xmlChar * content);
+ XMLPUBFUN int
+ xmlTextWriterWriteDTDExternalEntity(xmlTextWriterPtr writer,
+ int pe,
+ const xmlChar * name,
+ const xmlChar * pubid,
+ const xmlChar * sysid,
+ const xmlChar * ndataid);
+ XMLPUBFUN int
+ xmlTextWriterWriteDTDExternalEntityContents(xmlTextWriterPtr
+ writer,
+ const xmlChar * pubid,
+ const xmlChar * sysid,
+ const xmlChar *
+ ndataid);
+ XMLPUBFUN int xmlTextWriterWriteDTDEntity(xmlTextWriterPtr
+ writer, int pe,
+ const xmlChar * name,
+ const xmlChar *
+ pubid,
+ const xmlChar *
+ sysid,
+ const xmlChar *
+ ndataid,
+ const xmlChar *
+ content);
+
+/*
+ * DTD notation definition
+ */
+ XMLPUBFUN int
+ xmlTextWriterWriteDTDNotation(xmlTextWriterPtr writer,
+ const xmlChar * name,
+ const xmlChar * pubid,
+ const xmlChar * sysid);
+
+/*
+ * Indentation
+ */
+ XMLPUBFUN int
+ xmlTextWriterSetIndent(xmlTextWriterPtr writer, int indent);
+ XMLPUBFUN int
+ xmlTextWriterSetIndentString(xmlTextWriterPtr writer,
+ const xmlChar * str);
+
+ XMLPUBFUN int
+ xmlTextWriterSetQuoteChar(xmlTextWriterPtr writer, xmlChar quotechar);
+
+
+/*
+ * misc
+ */
+ XMLPUBFUN int xmlTextWriterFlush(xmlTextWriterPtr writer);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LIBXML_WRITER_ENABLED */
+
+#endif /* __XML_XMLWRITER_H__ */
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/libxml/xpath.h b/llava_video/lib/python3.10/site-packages/lxml/includes/libxml/xpath.h
new file mode 100644
index 0000000000000000000000000000000000000000..6dae0780d830c4725f05e6323f64f2fc1c33ad1b
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/includes/libxml/xpath.h
@@ -0,0 +1,575 @@
+/*
+ * Summary: XML Path Language implementation
+ * Description: API for the XML Path Language implementation
+ *
+ * XML Path Language implementation
+ * XPath is a language for addressing parts of an XML document,
+ * designed to be used by both XSLT and XPointer
+ * http://www.w3.org/TR/xpath
+ *
+ * Implements
+ * W3C Recommendation 16 November 1999
+ * http://www.w3.org/TR/1999/REC-xpath-19991116
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#ifndef __XML_XPATH_H__
+#define __XML_XPATH_H__
+
+#include
+
+#ifdef LIBXML_XPATH_ENABLED
+
+#include
+#include
+#include
+#endif /* LIBXML_XPATH_ENABLED */
+
+#if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
+#ifdef __cplusplus
+extern "C" {
+#endif
+#endif /* LIBXML_XPATH_ENABLED or LIBXML_SCHEMAS_ENABLED */
+
+#ifdef LIBXML_XPATH_ENABLED
+
+typedef struct _xmlXPathContext xmlXPathContext;
+typedef xmlXPathContext *xmlXPathContextPtr;
+typedef struct _xmlXPathParserContext xmlXPathParserContext;
+typedef xmlXPathParserContext *xmlXPathParserContextPtr;
+
+/**
+ * The set of XPath error codes.
+ */
+
+typedef enum {
+ XPATH_EXPRESSION_OK = 0,
+ XPATH_NUMBER_ERROR,
+ XPATH_UNFINISHED_LITERAL_ERROR,
+ XPATH_START_LITERAL_ERROR,
+ XPATH_VARIABLE_REF_ERROR,
+ XPATH_UNDEF_VARIABLE_ERROR,
+ XPATH_INVALID_PREDICATE_ERROR,
+ XPATH_EXPR_ERROR,
+ XPATH_UNCLOSED_ERROR,
+ XPATH_UNKNOWN_FUNC_ERROR,
+ XPATH_INVALID_OPERAND,
+ XPATH_INVALID_TYPE,
+ XPATH_INVALID_ARITY,
+ XPATH_INVALID_CTXT_SIZE,
+ XPATH_INVALID_CTXT_POSITION,
+ XPATH_MEMORY_ERROR,
+ XPTR_SYNTAX_ERROR,
+ XPTR_RESOURCE_ERROR,
+ XPTR_SUB_RESOURCE_ERROR,
+ XPATH_UNDEF_PREFIX_ERROR,
+ XPATH_ENCODING_ERROR,
+ XPATH_INVALID_CHAR_ERROR,
+ XPATH_INVALID_CTXT,
+ XPATH_STACK_ERROR,
+ XPATH_FORBID_VARIABLE_ERROR,
+ XPATH_OP_LIMIT_EXCEEDED,
+ XPATH_RECURSION_LIMIT_EXCEEDED
+} xmlXPathError;
+
+/*
+ * A node-set (an unordered collection of nodes without duplicates).
+ */
+typedef struct _xmlNodeSet xmlNodeSet;
+typedef xmlNodeSet *xmlNodeSetPtr;
+struct _xmlNodeSet {
+ int nodeNr; /* number of nodes in the set */
+ int nodeMax; /* size of the array as allocated */
+ xmlNodePtr *nodeTab; /* array of nodes in no particular order */
+ /* @@ with_ns to check whether namespace nodes should be looked at @@ */
+};
+
+/*
+ * An expression is evaluated to yield an object, which
+ * has one of the following four basic types:
+ * - node-set
+ * - boolean
+ * - number
+ * - string
+ *
+ * @@ XPointer will add more types !
+ */
+
+typedef enum {
+ XPATH_UNDEFINED = 0,
+ XPATH_NODESET = 1,
+ XPATH_BOOLEAN = 2,
+ XPATH_NUMBER = 3,
+ XPATH_STRING = 4,
+#ifdef LIBXML_XPTR_LOCS_ENABLED
+ XPATH_POINT = 5,
+ XPATH_RANGE = 6,
+ XPATH_LOCATIONSET = 7,
+#endif
+ XPATH_USERS = 8,
+ XPATH_XSLT_TREE = 9 /* An XSLT value tree, non modifiable */
+} xmlXPathObjectType;
+
+#ifndef LIBXML_XPTR_LOCS_ENABLED
+/** DOC_DISABLE */
+#define XPATH_POINT 5
+#define XPATH_RANGE 6
+#define XPATH_LOCATIONSET 7
+/** DOC_ENABLE */
+#endif
+
+typedef struct _xmlXPathObject xmlXPathObject;
+typedef xmlXPathObject *xmlXPathObjectPtr;
+struct _xmlXPathObject {
+ xmlXPathObjectType type;
+ xmlNodeSetPtr nodesetval;
+ int boolval;
+ double floatval;
+ xmlChar *stringval;
+ void *user;
+ int index;
+ void *user2;
+ int index2;
+};
+
+/**
+ * xmlXPathConvertFunc:
+ * @obj: an XPath object
+ * @type: the number of the target type
+ *
+ * A conversion function is associated to a type and used to cast
+ * the new type to primitive values.
+ *
+ * Returns -1 in case of error, 0 otherwise
+ */
+typedef int (*xmlXPathConvertFunc) (xmlXPathObjectPtr obj, int type);
+
+/*
+ * Extra type: a name and a conversion function.
+ */
+
+typedef struct _xmlXPathType xmlXPathType;
+typedef xmlXPathType *xmlXPathTypePtr;
+struct _xmlXPathType {
+ const xmlChar *name; /* the type name */
+ xmlXPathConvertFunc func; /* the conversion function */
+};
+
+/*
+ * Extra variable: a name and a value.
+ */
+
+typedef struct _xmlXPathVariable xmlXPathVariable;
+typedef xmlXPathVariable *xmlXPathVariablePtr;
+struct _xmlXPathVariable {
+ const xmlChar *name; /* the variable name */
+ xmlXPathObjectPtr value; /* the value */
+};
+
+/**
+ * xmlXPathEvalFunc:
+ * @ctxt: an XPath parser context
+ * @nargs: the number of arguments passed to the function
+ *
+ * An XPath evaluation function, the parameters are on the XPath context stack.
+ */
+
+typedef void (*xmlXPathEvalFunc)(xmlXPathParserContextPtr ctxt,
+ int nargs);
+
+/*
+ * Extra function: a name and a evaluation function.
+ */
+
+typedef struct _xmlXPathFunct xmlXPathFunct;
+typedef xmlXPathFunct *xmlXPathFuncPtr;
+struct _xmlXPathFunct {
+ const xmlChar *name; /* the function name */
+ xmlXPathEvalFunc func; /* the evaluation function */
+};
+
+/**
+ * xmlXPathAxisFunc:
+ * @ctxt: the XPath interpreter context
+ * @cur: the previous node being explored on that axis
+ *
+ * An axis traversal function. To traverse an axis, the engine calls
+ * the first time with cur == NULL and repeat until the function returns
+ * NULL indicating the end of the axis traversal.
+ *
+ * Returns the next node in that axis or NULL if at the end of the axis.
+ */
+
+typedef xmlXPathObjectPtr (*xmlXPathAxisFunc) (xmlXPathParserContextPtr ctxt,
+ xmlXPathObjectPtr cur);
+
+/*
+ * Extra axis: a name and an axis function.
+ */
+
+typedef struct _xmlXPathAxis xmlXPathAxis;
+typedef xmlXPathAxis *xmlXPathAxisPtr;
+struct _xmlXPathAxis {
+ const xmlChar *name; /* the axis name */
+ xmlXPathAxisFunc func; /* the search function */
+};
+
+/**
+ * xmlXPathFunction:
+ * @ctxt: the XPath interprestation context
+ * @nargs: the number of arguments
+ *
+ * An XPath function.
+ * The arguments (if any) are popped out from the context stack
+ * and the result is pushed on the stack.
+ */
+
+typedef void (*xmlXPathFunction) (xmlXPathParserContextPtr ctxt, int nargs);
+
+/*
+ * Function and Variable Lookup.
+ */
+
+/**
+ * xmlXPathVariableLookupFunc:
+ * @ctxt: an XPath context
+ * @name: name of the variable
+ * @ns_uri: the namespace name hosting this variable
+ *
+ * Prototype for callbacks used to plug variable lookup in the XPath
+ * engine.
+ *
+ * Returns the XPath object value or NULL if not found.
+ */
+typedef xmlXPathObjectPtr (*xmlXPathVariableLookupFunc) (void *ctxt,
+ const xmlChar *name,
+ const xmlChar *ns_uri);
+
+/**
+ * xmlXPathFuncLookupFunc:
+ * @ctxt: an XPath context
+ * @name: name of the function
+ * @ns_uri: the namespace name hosting this function
+ *
+ * Prototype for callbacks used to plug function lookup in the XPath
+ * engine.
+ *
+ * Returns the XPath function or NULL if not found.
+ */
+typedef xmlXPathFunction (*xmlXPathFuncLookupFunc) (void *ctxt,
+ const xmlChar *name,
+ const xmlChar *ns_uri);
+
+/**
+ * xmlXPathFlags:
+ * Flags for XPath engine compilation and runtime
+ */
+/**
+ * XML_XPATH_CHECKNS:
+ *
+ * check namespaces at compilation
+ */
+#define XML_XPATH_CHECKNS (1<<0)
+/**
+ * XML_XPATH_NOVAR:
+ *
+ * forbid variables in expression
+ */
+#define XML_XPATH_NOVAR (1<<1)
+
+/**
+ * xmlXPathContext:
+ *
+ * Expression evaluation occurs with respect to a context.
+ * he context consists of:
+ * - a node (the context node)
+ * - a node list (the context node list)
+ * - a set of variable bindings
+ * - a function library
+ * - the set of namespace declarations in scope for the expression
+ * Following the switch to hash tables, this need to be trimmed up at
+ * the next binary incompatible release.
+ * The node may be modified when the context is passed to libxml2
+ * for an XPath evaluation so you may need to initialize it again
+ * before the next call.
+ */
+
+struct _xmlXPathContext {
+ xmlDocPtr doc; /* The current document */
+ xmlNodePtr node; /* The current node */
+
+ int nb_variables_unused; /* unused (hash table) */
+ int max_variables_unused; /* unused (hash table) */
+ xmlHashTablePtr varHash; /* Hash table of defined variables */
+
+ int nb_types; /* number of defined types */
+ int max_types; /* max number of types */
+ xmlXPathTypePtr types; /* Array of defined types */
+
+ int nb_funcs_unused; /* unused (hash table) */
+ int max_funcs_unused; /* unused (hash table) */
+ xmlHashTablePtr funcHash; /* Hash table of defined funcs */
+
+ int nb_axis; /* number of defined axis */
+ int max_axis; /* max number of axis */
+ xmlXPathAxisPtr axis; /* Array of defined axis */
+
+ /* the namespace nodes of the context node */
+ xmlNsPtr *namespaces; /* Array of namespaces */
+ int nsNr; /* number of namespace in scope */
+ void *user; /* function to free */
+
+ /* extra variables */
+ int contextSize; /* the context size */
+ int proximityPosition; /* the proximity position */
+
+ /* extra stuff for XPointer */
+ int xptr; /* is this an XPointer context? */
+ xmlNodePtr here; /* for here() */
+ xmlNodePtr origin; /* for origin() */
+
+ /* the set of namespace declarations in scope for the expression */
+ xmlHashTablePtr nsHash; /* The namespaces hash table */
+ xmlXPathVariableLookupFunc varLookupFunc;/* variable lookup func */
+ void *varLookupData; /* variable lookup data */
+
+ /* Possibility to link in an extra item */
+ void *extra; /* needed for XSLT */
+
+ /* The function name and URI when calling a function */
+ const xmlChar *function;
+ const xmlChar *functionURI;
+
+ /* function lookup function and data */
+ xmlXPathFuncLookupFunc funcLookupFunc;/* function lookup func */
+ void *funcLookupData; /* function lookup data */
+
+ /* temporary namespace lists kept for walking the namespace axis */
+ xmlNsPtr *tmpNsList; /* Array of namespaces */
+ int tmpNsNr; /* number of namespaces in scope */
+
+ /* error reporting mechanism */
+ void *userData; /* user specific data block */
+ xmlStructuredErrorFunc error; /* the callback in case of errors */
+ xmlError lastError; /* the last error */
+ xmlNodePtr debugNode; /* the source node XSLT */
+
+ /* dictionary */
+ xmlDictPtr dict; /* dictionary if any */
+
+ int flags; /* flags to control compilation */
+
+ /* Cache for reusal of XPath objects */
+ void *cache;
+
+ /* Resource limits */
+ unsigned long opLimit;
+ unsigned long opCount;
+ int depth;
+};
+
+/*
+ * The structure of a compiled expression form is not public.
+ */
+
+typedef struct _xmlXPathCompExpr xmlXPathCompExpr;
+typedef xmlXPathCompExpr *xmlXPathCompExprPtr;
+
+/**
+ * xmlXPathParserContext:
+ *
+ * An XPath parser context. It contains pure parsing information,
+ * an xmlXPathContext, and the stack of objects.
+ */
+struct _xmlXPathParserContext {
+ const xmlChar *cur; /* the current char being parsed */
+ const xmlChar *base; /* the full expression */
+
+ int error; /* error code */
+
+ xmlXPathContextPtr context; /* the evaluation context */
+ xmlXPathObjectPtr value; /* the current value */
+ int valueNr; /* number of values stacked */
+ int valueMax; /* max number of values stacked */
+ xmlXPathObjectPtr *valueTab; /* stack of values */
+
+ xmlXPathCompExprPtr comp; /* the precompiled expression */
+ int xptr; /* it this an XPointer expression */
+ xmlNodePtr ancestor; /* used for walking preceding axis */
+
+ int valueFrame; /* always zero for compatibility */
+};
+
+/************************************************************************
+ * *
+ * Public API *
+ * *
+ ************************************************************************/
+
+/**
+ * Objects and Nodesets handling
+ */
+
+XMLPUBVAR double xmlXPathNAN;
+XMLPUBVAR double xmlXPathPINF;
+XMLPUBVAR double xmlXPathNINF;
+
+/* These macros may later turn into functions */
+/**
+ * xmlXPathNodeSetGetLength:
+ * @ns: a node-set
+ *
+ * Implement a functionality similar to the DOM NodeList.length.
+ *
+ * Returns the number of nodes in the node-set.
+ */
+#define xmlXPathNodeSetGetLength(ns) ((ns) ? (ns)->nodeNr : 0)
+/**
+ * xmlXPathNodeSetItem:
+ * @ns: a node-set
+ * @index: index of a node in the set
+ *
+ * Implements a functionality similar to the DOM NodeList.item().
+ *
+ * Returns the xmlNodePtr at the given @index in @ns or NULL if
+ * @index is out of range (0 to length-1)
+ */
+#define xmlXPathNodeSetItem(ns, index) \
+ ((((ns) != NULL) && \
+ ((index) >= 0) && ((index) < (ns)->nodeNr)) ? \
+ (ns)->nodeTab[(index)] \
+ : NULL)
+/**
+ * xmlXPathNodeSetIsEmpty:
+ * @ns: a node-set
+ *
+ * Checks whether @ns is empty or not.
+ *
+ * Returns %TRUE if @ns is an empty node-set.
+ */
+#define xmlXPathNodeSetIsEmpty(ns) \
+ (((ns) == NULL) || ((ns)->nodeNr == 0) || ((ns)->nodeTab == NULL))
+
+
+XMLPUBFUN void
+ xmlXPathFreeObject (xmlXPathObjectPtr obj);
+XMLPUBFUN xmlNodeSetPtr
+ xmlXPathNodeSetCreate (xmlNodePtr val);
+XMLPUBFUN void
+ xmlXPathFreeNodeSetList (xmlXPathObjectPtr obj);
+XMLPUBFUN void
+ xmlXPathFreeNodeSet (xmlNodeSetPtr obj);
+XMLPUBFUN xmlXPathObjectPtr
+ xmlXPathObjectCopy (xmlXPathObjectPtr val);
+XMLPUBFUN int
+ xmlXPathCmpNodes (xmlNodePtr node1,
+ xmlNodePtr node2);
+/**
+ * Conversion functions to basic types.
+ */
+XMLPUBFUN int
+ xmlXPathCastNumberToBoolean (double val);
+XMLPUBFUN int
+ xmlXPathCastStringToBoolean (const xmlChar * val);
+XMLPUBFUN int
+ xmlXPathCastNodeSetToBoolean(xmlNodeSetPtr ns);
+XMLPUBFUN int
+ xmlXPathCastToBoolean (xmlXPathObjectPtr val);
+
+XMLPUBFUN double
+ xmlXPathCastBooleanToNumber (int val);
+XMLPUBFUN double
+ xmlXPathCastStringToNumber (const xmlChar * val);
+XMLPUBFUN double
+ xmlXPathCastNodeToNumber (xmlNodePtr node);
+XMLPUBFUN double
+ xmlXPathCastNodeSetToNumber (xmlNodeSetPtr ns);
+XMLPUBFUN double
+ xmlXPathCastToNumber (xmlXPathObjectPtr val);
+
+XMLPUBFUN xmlChar *
+ xmlXPathCastBooleanToString (int val);
+XMLPUBFUN xmlChar *
+ xmlXPathCastNumberToString (double val);
+XMLPUBFUN xmlChar *
+ xmlXPathCastNodeToString (xmlNodePtr node);
+XMLPUBFUN xmlChar *
+ xmlXPathCastNodeSetToString (xmlNodeSetPtr ns);
+XMLPUBFUN xmlChar *
+ xmlXPathCastToString (xmlXPathObjectPtr val);
+
+XMLPUBFUN xmlXPathObjectPtr
+ xmlXPathConvertBoolean (xmlXPathObjectPtr val);
+XMLPUBFUN xmlXPathObjectPtr
+ xmlXPathConvertNumber (xmlXPathObjectPtr val);
+XMLPUBFUN xmlXPathObjectPtr
+ xmlXPathConvertString (xmlXPathObjectPtr val);
+
+/**
+ * Context handling.
+ */
+XMLPUBFUN xmlXPathContextPtr
+ xmlXPathNewContext (xmlDocPtr doc);
+XMLPUBFUN void
+ xmlXPathFreeContext (xmlXPathContextPtr ctxt);
+XMLPUBFUN int
+ xmlXPathContextSetCache(xmlXPathContextPtr ctxt,
+ int active,
+ int value,
+ int options);
+/**
+ * Evaluation functions.
+ */
+XMLPUBFUN long
+ xmlXPathOrderDocElems (xmlDocPtr doc);
+XMLPUBFUN int
+ xmlXPathSetContextNode (xmlNodePtr node,
+ xmlXPathContextPtr ctx);
+XMLPUBFUN xmlXPathObjectPtr
+ xmlXPathNodeEval (xmlNodePtr node,
+ const xmlChar *str,
+ xmlXPathContextPtr ctx);
+XMLPUBFUN xmlXPathObjectPtr
+ xmlXPathEval (const xmlChar *str,
+ xmlXPathContextPtr ctx);
+XMLPUBFUN xmlXPathObjectPtr
+ xmlXPathEvalExpression (const xmlChar *str,
+ xmlXPathContextPtr ctxt);
+XMLPUBFUN int
+ xmlXPathEvalPredicate (xmlXPathContextPtr ctxt,
+ xmlXPathObjectPtr res);
+/**
+ * Separate compilation/evaluation entry points.
+ */
+XMLPUBFUN xmlXPathCompExprPtr
+ xmlXPathCompile (const xmlChar *str);
+XMLPUBFUN xmlXPathCompExprPtr
+ xmlXPathCtxtCompile (xmlXPathContextPtr ctxt,
+ const xmlChar *str);
+XMLPUBFUN xmlXPathObjectPtr
+ xmlXPathCompiledEval (xmlXPathCompExprPtr comp,
+ xmlXPathContextPtr ctx);
+XMLPUBFUN int
+ xmlXPathCompiledEvalToBoolean(xmlXPathCompExprPtr comp,
+ xmlXPathContextPtr ctxt);
+XMLPUBFUN void
+ xmlXPathFreeCompExpr (xmlXPathCompExprPtr comp);
+#endif /* LIBXML_XPATH_ENABLED */
+#if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
+XML_DEPRECATED
+XMLPUBFUN void
+ xmlXPathInit (void);
+XMLPUBFUN int
+ xmlXPathIsNaN (double val);
+XMLPUBFUN int
+ xmlXPathIsInf (double val);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LIBXML_XPATH_ENABLED or LIBXML_SCHEMAS_ENABLED*/
+#endif /* ! __XML_XPATH_H__ */
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/lxml-version.h b/llava_video/lib/python3.10/site-packages/lxml/includes/lxml-version.h
new file mode 100644
index 0000000000000000000000000000000000000000..101c7c9189014a95ca439a933063cdd294346dff
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/includes/lxml-version.h
@@ -0,0 +1,3 @@
+#ifndef LXML_VERSION_STRING
+#define LXML_VERSION_STRING "5.3.1"
+#endif
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/relaxng.pxd b/llava_video/lib/python3.10/site-packages/lxml/includes/relaxng.pxd
new file mode 100644
index 0000000000000000000000000000000000000000..5ac96711e7b8124400fe6a8acb59f0e4192d2949
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/includes/relaxng.pxd
@@ -0,0 +1,64 @@
+from lxml.includes.tree cimport xmlDoc
+from lxml.includes.xmlerror cimport xmlStructuredErrorFunc
+
+cdef extern from "libxml/relaxng.h" nogil:
+ ctypedef struct xmlRelaxNG
+ ctypedef struct xmlRelaxNGParserCtxt
+
+ ctypedef struct xmlRelaxNGValidCtxt
+
+ ctypedef enum xmlRelaxNGValidErr:
+ XML_RELAXNG_OK = 0
+ XML_RELAXNG_ERR_MEMORY = 1
+ XML_RELAXNG_ERR_TYPE = 2
+ XML_RELAXNG_ERR_TYPEVAL = 3
+ XML_RELAXNG_ERR_DUPID = 4
+ XML_RELAXNG_ERR_TYPECMP = 5
+ XML_RELAXNG_ERR_NOSTATE = 6
+ XML_RELAXNG_ERR_NODEFINE = 7
+ XML_RELAXNG_ERR_LISTEXTRA = 8
+ XML_RELAXNG_ERR_LISTEMPTY = 9
+ XML_RELAXNG_ERR_INTERNODATA = 10
+ XML_RELAXNG_ERR_INTERSEQ = 11
+ XML_RELAXNG_ERR_INTEREXTRA = 12
+ XML_RELAXNG_ERR_ELEMNAME = 13
+ XML_RELAXNG_ERR_ATTRNAME = 14
+ XML_RELAXNG_ERR_ELEMNONS = 15
+ XML_RELAXNG_ERR_ATTRNONS = 16
+ XML_RELAXNG_ERR_ELEMWRONGNS = 17
+ XML_RELAXNG_ERR_ATTRWRONGNS = 18
+ XML_RELAXNG_ERR_ELEMEXTRANS = 19
+ XML_RELAXNG_ERR_ATTREXTRANS = 20
+ XML_RELAXNG_ERR_ELEMNOTEMPTY = 21
+ XML_RELAXNG_ERR_NOELEM = 22
+ XML_RELAXNG_ERR_NOTELEM = 23
+ XML_RELAXNG_ERR_ATTRVALID = 24
+ XML_RELAXNG_ERR_CONTENTVALID = 25
+ XML_RELAXNG_ERR_EXTRACONTENT = 26
+ XML_RELAXNG_ERR_INVALIDATTR = 27
+ XML_RELAXNG_ERR_DATAELEM = 28
+ XML_RELAXNG_ERR_VALELEM = 29
+ XML_RELAXNG_ERR_LISTELEM = 30
+ XML_RELAXNG_ERR_DATATYPE = 31
+ XML_RELAXNG_ERR_VALUE = 32
+ XML_RELAXNG_ERR_LIST = 33
+ XML_RELAXNG_ERR_NOGRAMMAR = 34
+ XML_RELAXNG_ERR_EXTRADATA = 35
+ XML_RELAXNG_ERR_LACKDATA = 36
+ XML_RELAXNG_ERR_INTERNAL = 37
+ XML_RELAXNG_ERR_ELEMWRONG = 38
+ XML_RELAXNG_ERR_TEXTWRONG = 39
+
+ cdef xmlRelaxNGValidCtxt* xmlRelaxNGNewValidCtxt(xmlRelaxNG* schema)
+ cdef int xmlRelaxNGValidateDoc(xmlRelaxNGValidCtxt* ctxt, xmlDoc* doc)
+ cdef xmlRelaxNG* xmlRelaxNGParse(xmlRelaxNGParserCtxt* ctxt)
+ cdef xmlRelaxNGParserCtxt* xmlRelaxNGNewParserCtxt(char* URL)
+ cdef xmlRelaxNGParserCtxt* xmlRelaxNGNewDocParserCtxt(xmlDoc* doc)
+ cdef void xmlRelaxNGFree(xmlRelaxNG* schema)
+ cdef void xmlRelaxNGFreeParserCtxt(xmlRelaxNGParserCtxt* ctxt)
+ cdef void xmlRelaxNGFreeValidCtxt(xmlRelaxNGValidCtxt* ctxt)
+
+ cdef void xmlRelaxNGSetValidStructuredErrors(
+ xmlRelaxNGValidCtxt* ctxt, xmlStructuredErrorFunc serror, void *ctx)
+ cdef void xmlRelaxNGSetParserStructuredErrors(
+ xmlRelaxNGParserCtxt* ctxt, xmlStructuredErrorFunc serror, void *ctx)
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/schematron.pxd b/llava_video/lib/python3.10/site-packages/lxml/includes/schematron.pxd
new file mode 100644
index 0000000000000000000000000000000000000000..181248afd6ab89811c896f2992aa8bf4c69affe9
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/includes/schematron.pxd
@@ -0,0 +1,34 @@
+from lxml.includes cimport xmlerror
+from lxml.includes.tree cimport xmlDoc
+
+cdef extern from "libxml/schematron.h" nogil:
+ ctypedef struct xmlSchematron
+ ctypedef struct xmlSchematronParserCtxt
+ ctypedef struct xmlSchematronValidCtxt
+
+ ctypedef enum xmlSchematronValidOptions:
+ XML_SCHEMATRON_OUT_QUIET = 1 # quiet no report
+ XML_SCHEMATRON_OUT_TEXT = 2 # build a textual report
+ XML_SCHEMATRON_OUT_XML = 4 # output SVRL
+ XML_SCHEMATRON_OUT_ERROR = 8 # output via xmlStructuredErrorFunc
+ XML_SCHEMATRON_OUT_FILE = 256 # output to a file descriptor
+ XML_SCHEMATRON_OUT_BUFFER = 512 # output to a buffer
+ XML_SCHEMATRON_OUT_IO = 1024 # output to I/O mechanism
+
+ cdef xmlSchematronParserCtxt* xmlSchematronNewDocParserCtxt(
+ xmlDoc* doc)
+ cdef xmlSchematronParserCtxt* xmlSchematronNewParserCtxt(
+ char* filename) nogil
+ cdef xmlSchematronValidCtxt* xmlSchematronNewValidCtxt(
+ xmlSchematron* schema, int options)
+
+ cdef xmlSchematron* xmlSchematronParse(xmlSchematronParserCtxt* ctxt)
+ cdef int xmlSchematronValidateDoc(xmlSchematronValidCtxt* ctxt,
+ xmlDoc* instance)
+
+ cdef void xmlSchematronFreeParserCtxt(xmlSchematronParserCtxt* ctxt)
+ cdef void xmlSchematronFreeValidCtxt(xmlSchematronValidCtxt* ctxt)
+ cdef void xmlSchematronFree(xmlSchematron* schema)
+ cdef void xmlSchematronSetValidStructuredErrors(
+ xmlSchematronValidCtxt* ctxt,
+ xmlerror.xmlStructuredErrorFunc error_func, void *data)
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/tree.pxd b/llava_video/lib/python3.10/site-packages/lxml/includes/tree.pxd
new file mode 100644
index 0000000000000000000000000000000000000000..5e37d9d6a54d6b3d19787d6c271f919986215bb4
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/includes/tree.pxd
@@ -0,0 +1,494 @@
+from libc cimport stdio
+from libc.string cimport const_char, const_uchar
+
+cdef extern from "lxml-version.h":
+ # deprecated declaration, use etreepublic.pxd instead
+ cdef char* LXML_VERSION_STRING
+
+cdef extern from "libxml/xmlversion.h":
+ cdef const_char* xmlParserVersion
+ cdef int LIBXML_VERSION
+
+cdef extern from "libxml/xmlstring.h" nogil:
+ ctypedef unsigned char xmlChar
+ ctypedef const xmlChar const_xmlChar "const xmlChar"
+ cdef int xmlStrlen(const_xmlChar* str)
+ cdef xmlChar* xmlStrdup(const_xmlChar* cur)
+ cdef int xmlStrncmp(const_xmlChar* str1, const_xmlChar* str2, int length)
+ cdef int xmlStrcmp(const_xmlChar* str1, const_xmlChar* str2)
+ cdef int xmlStrcasecmp(const xmlChar *str1, const xmlChar *str2)
+ cdef const_xmlChar* xmlStrstr(const_xmlChar* str1, const_xmlChar* str2)
+ cdef const_xmlChar* xmlStrchr(const_xmlChar* str1, xmlChar ch)
+ cdef const_xmlChar* _xcstr "(const xmlChar*)PyBytes_AS_STRING" (object s)
+
+cdef extern from "libxml/encoding.h" nogil:
+ ctypedef enum xmlCharEncoding:
+ XML_CHAR_ENCODING_ERROR = -1 # No char encoding detected
+ XML_CHAR_ENCODING_NONE = 0 # No char encoding detected
+ XML_CHAR_ENCODING_UTF8 = 1 # UTF-8
+ XML_CHAR_ENCODING_UTF16LE = 2 # UTF-16 little endian
+ XML_CHAR_ENCODING_UTF16BE = 3 # UTF-16 big endian
+ XML_CHAR_ENCODING_UCS4LE = 4 # UCS-4 little endian
+ XML_CHAR_ENCODING_UCS4BE = 5 # UCS-4 big endian
+ XML_CHAR_ENCODING_EBCDIC = 6 # EBCDIC uh!
+ XML_CHAR_ENCODING_UCS4_2143 = 7 # UCS-4 unusual ordering
+ XML_CHAR_ENCODING_UCS4_3412 = 8 # UCS-4 unusual ordering
+ XML_CHAR_ENCODING_UCS2 = 9 # UCS-2
+ XML_CHAR_ENCODING_8859_1 = 10 # ISO-8859-1 ISO Latin 1
+ XML_CHAR_ENCODING_8859_2 = 11 # ISO-8859-2 ISO Latin 2
+ XML_CHAR_ENCODING_8859_3 = 12 # ISO-8859-3
+ XML_CHAR_ENCODING_8859_4 = 13 # ISO-8859-4
+ XML_CHAR_ENCODING_8859_5 = 14 # ISO-8859-5
+ XML_CHAR_ENCODING_8859_6 = 15 # ISO-8859-6
+ XML_CHAR_ENCODING_8859_7 = 16 # ISO-8859-7
+ XML_CHAR_ENCODING_8859_8 = 17 # ISO-8859-8
+ XML_CHAR_ENCODING_8859_9 = 18 # ISO-8859-9
+ XML_CHAR_ENCODING_2022_JP = 19 # ISO-2022-JP
+ XML_CHAR_ENCODING_SHIFT_JIS = 20 # Shift_JIS
+ XML_CHAR_ENCODING_EUC_JP = 21 # EUC-JP
+ XML_CHAR_ENCODING_ASCII = 22 # pure ASCII
+
+ ctypedef struct xmlCharEncodingHandler:
+ char* name
+
+ cdef xmlCharEncodingHandler* xmlFindCharEncodingHandler(char* name)
+ cdef xmlCharEncodingHandler* xmlGetCharEncodingHandler(
+ xmlCharEncoding enc)
+ cdef int xmlCharEncCloseFunc(xmlCharEncodingHandler* handler)
+ cdef xmlCharEncoding xmlDetectCharEncoding(const_xmlChar* text, int len)
+ cdef const_char* xmlGetCharEncodingName(xmlCharEncoding enc)
+ cdef xmlCharEncoding xmlParseCharEncoding(char* name)
+ ctypedef int (*xmlCharEncodingOutputFunc)(
+ unsigned char *out_buf, int *outlen, const_uchar *in_buf, int *inlen)
+
+cdef extern from "libxml/chvalid.h" nogil:
+ cdef int xmlIsChar_ch(char c)
+ cdef int xmlIsCharQ(int ch)
+
+cdef extern from "libxml/hash.h":
+ ctypedef struct xmlHashTable
+ ctypedef void (*xmlHashScanner)(void* payload, void* data, const_xmlChar* name) noexcept # may require GIL!
+ void xmlHashScan(xmlHashTable* table, xmlHashScanner f, void* data) nogil
+ void* xmlHashLookup(xmlHashTable* table, const_xmlChar* name) nogil
+ ctypedef void (*xmlHashDeallocator)(void *payload, xmlChar *name) noexcept
+ cdef xmlHashTable* xmlHashCreate(int size) nogil
+ cdef xmlHashTable* xmlHashCreateDict(int size, xmlDict *dict) nogil
+ cdef int xmlHashSize(xmlHashTable* table) nogil
+ cdef void xmlHashFree(xmlHashTable* table, xmlHashDeallocator f) nogil
+
+cdef extern from * nogil: # actually "libxml/dict.h"
+ # libxml/dict.h appears to be broken to include in C
+ ctypedef struct xmlDict
+ cdef const_xmlChar* xmlDictLookup(xmlDict* dict, const_xmlChar* name, int len)
+ cdef const_xmlChar* xmlDictExists(xmlDict* dict, const_xmlChar* name, int len)
+ cdef int xmlDictOwns(xmlDict* dict, const_xmlChar* name)
+ cdef size_t xmlDictSize(xmlDict* dict)
+
+cdef extern from "libxml/tree.h" nogil:
+ ctypedef struct xmlDoc
+ ctypedef struct xmlAttr
+ ctypedef struct xmlNotationTable
+
+ ctypedef enum xmlElementType:
+ XML_ELEMENT_NODE= 1
+ XML_ATTRIBUTE_NODE= 2
+ XML_TEXT_NODE= 3
+ XML_CDATA_SECTION_NODE= 4
+ XML_ENTITY_REF_NODE= 5
+ XML_ENTITY_NODE= 6
+ XML_PI_NODE= 7
+ XML_COMMENT_NODE= 8
+ XML_DOCUMENT_NODE= 9
+ XML_DOCUMENT_TYPE_NODE= 10
+ XML_DOCUMENT_FRAG_NODE= 11
+ XML_NOTATION_NODE= 12
+ XML_HTML_DOCUMENT_NODE= 13
+ XML_DTD_NODE= 14
+ XML_ELEMENT_DECL= 15
+ XML_ATTRIBUTE_DECL= 16
+ XML_ENTITY_DECL= 17
+ XML_NAMESPACE_DECL= 18
+ XML_XINCLUDE_START= 19
+ XML_XINCLUDE_END= 20
+
+ ctypedef enum xmlElementTypeVal:
+ XML_ELEMENT_TYPE_UNDEFINED= 0
+ XML_ELEMENT_TYPE_EMPTY= 1
+ XML_ELEMENT_TYPE_ANY= 2
+ XML_ELEMENT_TYPE_MIXED= 3
+ XML_ELEMENT_TYPE_ELEMENT= 4
+
+ ctypedef enum xmlElementContentType:
+ XML_ELEMENT_CONTENT_PCDATA= 1
+ XML_ELEMENT_CONTENT_ELEMENT= 2
+ XML_ELEMENT_CONTENT_SEQ= 3
+ XML_ELEMENT_CONTENT_OR= 4
+
+ ctypedef enum xmlElementContentOccur:
+ XML_ELEMENT_CONTENT_ONCE= 1
+ XML_ELEMENT_CONTENT_OPT= 2
+ XML_ELEMENT_CONTENT_MULT= 3
+ XML_ELEMENT_CONTENT_PLUS= 4
+
+ ctypedef enum xmlAttributeType:
+ XML_ATTRIBUTE_CDATA = 1
+ XML_ATTRIBUTE_ID= 2
+ XML_ATTRIBUTE_IDREF= 3
+ XML_ATTRIBUTE_IDREFS= 4
+ XML_ATTRIBUTE_ENTITY= 5
+ XML_ATTRIBUTE_ENTITIES= 6
+ XML_ATTRIBUTE_NMTOKEN= 7
+ XML_ATTRIBUTE_NMTOKENS= 8
+ XML_ATTRIBUTE_ENUMERATION= 9
+ XML_ATTRIBUTE_NOTATION= 10
+
+ ctypedef enum xmlAttributeDefault:
+ XML_ATTRIBUTE_NONE= 1
+ XML_ATTRIBUTE_REQUIRED= 2
+ XML_ATTRIBUTE_IMPLIED= 3
+ XML_ATTRIBUTE_FIXED= 4
+
+ ctypedef enum xmlEntityType:
+ XML_INTERNAL_GENERAL_ENTITY= 1
+ XML_EXTERNAL_GENERAL_PARSED_ENTITY= 2
+ XML_EXTERNAL_GENERAL_UNPARSED_ENTITY= 3
+ XML_INTERNAL_PARAMETER_ENTITY= 4
+ XML_EXTERNAL_PARAMETER_ENTITY= 5
+ XML_INTERNAL_PREDEFINED_ENTITY= 6
+
+ ctypedef enum xmlDocProperties:
+ XML_DOC_WELLFORMED = 1 # /* document is XML well formed */
+ XML_DOC_NSVALID = 2 # /* document is Namespace valid */
+ XML_DOC_OLD10 = 4 # /* parsed with old XML-1.0 parser */
+ XML_DOC_DTDVALID = 8 # /* DTD validation was successful */
+ XML_DOC_XINCLUDE = 16 # /* XInclude substitution was done */
+ XML_DOC_USERBUILT = 32 # /* Document was built using the API
+ # and not by parsing an instance */
+ XML_DOC_INTERNAL = 64 # /* built for internal processing */
+ XML_DOC_HTML = 128 # /* parsed or built HTML document */
+
+ ctypedef struct xmlNs:
+ const_xmlChar* href
+ const_xmlChar* prefix
+ xmlNs* next
+
+ ctypedef struct xmlNode:
+ void* _private
+ xmlElementType type
+ const_xmlChar* name
+ xmlNode* children
+ xmlNode* last
+ xmlNode* parent
+ xmlNode* next
+ xmlNode* prev
+ xmlDoc* doc
+ xmlChar* content
+ xmlAttr* properties
+ xmlNs* ns
+ xmlNs* nsDef
+ unsigned short line
+
+ ctypedef struct xmlElementContent:
+ xmlElementContentType type
+ xmlElementContentOccur ocur
+ const_xmlChar *name
+ xmlElementContent *c1
+ xmlElementContent *c2
+ xmlElementContent *parent
+ const_xmlChar *prefix
+
+ ctypedef struct xmlEnumeration:
+ xmlEnumeration *next
+ const_xmlChar *name
+
+ ctypedef struct xmlAttribute:
+ void* _private
+ xmlElementType type
+ const_xmlChar* name
+ xmlNode* children
+ xmlNode* last
+ xmlDtd* parent
+ xmlNode* next
+ xmlNode* prev
+ xmlDoc* doc
+ xmlAttribute* nexth
+ xmlAttributeType atype
+ xmlAttributeDefault def_ "def"
+ const_xmlChar* defaultValue
+ xmlEnumeration* tree
+ const_xmlChar* prefix
+ const_xmlChar* elem
+
+ ctypedef struct xmlElement:
+ void* _private
+ xmlElementType type
+ const_xmlChar* name
+ xmlNode* children
+ xmlNode* last
+ xmlNode* parent
+ xmlNode* next
+ xmlNode* prev
+ xmlDoc* doc
+ xmlElementTypeVal etype
+ xmlElementContent* content
+ xmlAttribute* attributes
+ const_xmlChar* prefix
+ void *contModel
+
+ ctypedef struct xmlEntity:
+ void* _private
+ xmlElementType type
+ const_xmlChar* name
+ xmlNode* children
+ xmlNode* last
+ xmlDtd* parent
+ xmlNode* next
+ xmlNode* prev
+ xmlDoc* doc
+ xmlChar* orig
+ xmlChar* content
+ int length
+ xmlEntityType etype
+ const_xmlChar* ExternalID
+ const_xmlChar* SystemID
+ xmlEntity* nexte
+ const_xmlChar* URI
+ int owner
+ int checked
+
+ ctypedef struct xmlDtd:
+ const_xmlChar* name
+ const_xmlChar* ExternalID
+ const_xmlChar* SystemID
+ void* notations
+ void* entities
+ void* pentities
+ void* attributes
+ void* elements
+ xmlNode* children
+ xmlNode* last
+ xmlDoc* doc
+
+ ctypedef struct xmlDoc:
+ xmlElementType type
+ char* name
+ xmlNode* children
+ xmlNode* last
+ xmlNode* parent
+ xmlNode* next
+ xmlNode* prev
+ xmlDoc* doc
+ xmlDict* dict
+ xmlHashTable* ids
+ int standalone
+ const_xmlChar* version
+ const_xmlChar* encoding
+ const_xmlChar* URL
+ void* _private
+ xmlDtd* intSubset
+ xmlDtd* extSubset
+ int properties
+
+ ctypedef struct xmlAttr:
+ void* _private
+ xmlElementType type
+ const_xmlChar* name
+ xmlNode* children
+ xmlNode* last
+ xmlNode* parent
+ xmlAttr* next
+ xmlAttr* prev
+ xmlDoc* doc
+ xmlNs* ns
+ xmlAttributeType atype
+
+ ctypedef struct xmlID:
+ const_xmlChar* value
+ const_xmlChar* name
+ xmlAttr* attr
+ xmlDoc* doc
+
+ ctypedef struct xmlBuffer
+
+ ctypedef struct xmlBuf # new in libxml2 2.9
+
+ ctypedef struct xmlOutputBuffer:
+ xmlBuf* buffer
+ xmlBuf* conv
+ int error
+
+ const_xmlChar* XML_XML_NAMESPACE
+
+ cdef void xmlFreeDoc(xmlDoc* cur)
+ cdef void xmlFreeDtd(xmlDtd* cur)
+ cdef void xmlFreeNode(xmlNode* cur)
+ cdef void xmlFreeNsList(xmlNs* ns)
+ cdef void xmlFreeNs(xmlNs* ns)
+ cdef void xmlFree(void* buf)
+
+ cdef xmlNode* xmlNewNode(xmlNs* ns, const_xmlChar* name)
+ cdef xmlNode* xmlNewDocText(xmlDoc* doc, const_xmlChar* content)
+ cdef xmlNode* xmlNewDocComment(xmlDoc* doc, const_xmlChar* content)
+ cdef xmlNode* xmlNewDocPI(xmlDoc* doc, const_xmlChar* name, const_xmlChar* content)
+ cdef xmlNode* xmlNewReference(xmlDoc* doc, const_xmlChar* name)
+ cdef xmlNode* xmlNewCDataBlock(xmlDoc* doc, const_xmlChar* text, int len)
+ cdef xmlNs* xmlNewNs(xmlNode* node, const_xmlChar* href, const_xmlChar* prefix)
+ cdef xmlNode* xmlAddChild(xmlNode* parent, xmlNode* cur)
+ cdef xmlNode* xmlReplaceNode(xmlNode* old, xmlNode* cur)
+ cdef xmlNode* xmlAddPrevSibling(xmlNode* cur, xmlNode* elem)
+ cdef xmlNode* xmlAddNextSibling(xmlNode* cur, xmlNode* elem)
+ cdef xmlNode* xmlNewDocNode(xmlDoc* doc, xmlNs* ns,
+ const_xmlChar* name, const_xmlChar* content)
+ cdef xmlDoc* xmlNewDoc(const_xmlChar* version)
+ cdef xmlAttr* xmlNewProp(xmlNode* node, const_xmlChar* name, const_xmlChar* value)
+ cdef xmlAttr* xmlNewNsProp(xmlNode* node, xmlNs* ns,
+ const_xmlChar* name, const_xmlChar* value)
+ cdef xmlChar* xmlGetNoNsProp(xmlNode* node, const_xmlChar* name)
+ cdef xmlChar* xmlGetNsProp(xmlNode* node, const_xmlChar* name, const_xmlChar* nameSpace)
+ cdef void xmlSetNs(xmlNode* node, xmlNs* ns)
+ cdef xmlAttr* xmlSetProp(xmlNode* node, const_xmlChar* name, const_xmlChar* value)
+ cdef xmlAttr* xmlSetNsProp(xmlNode* node, xmlNs* ns,
+ const_xmlChar* name, const_xmlChar* value)
+ cdef int xmlRemoveID(xmlDoc* doc, xmlAttr* cur)
+ cdef int xmlRemoveProp(xmlAttr* cur)
+ cdef void xmlFreePropList(xmlAttr* cur)
+ cdef xmlChar* xmlGetNodePath(xmlNode* node)
+ cdef void xmlDocDumpMemory(xmlDoc* cur, char** mem, int* size)
+ cdef void xmlDocDumpMemoryEnc(xmlDoc* cur, char** mem, int* size,
+ char* encoding)
+ cdef int xmlSaveFileTo(xmlOutputBuffer* out, xmlDoc* cur,
+ char* encoding)
+
+ cdef void xmlUnlinkNode(xmlNode* cur)
+ cdef xmlNode* xmlDocSetRootElement(xmlDoc* doc, xmlNode* root)
+ cdef xmlNode* xmlDocGetRootElement(xmlDoc* doc)
+ cdef void xmlSetTreeDoc(xmlNode* tree, xmlDoc* doc)
+ cdef xmlAttr* xmlHasProp(xmlNode* node, const_xmlChar* name)
+ cdef xmlAttr* xmlHasNsProp(xmlNode* node, const_xmlChar* name, const_xmlChar* nameSpace)
+ cdef xmlChar* xmlNodeGetContent(xmlNode* cur)
+ cdef int xmlNodeBufGetContent(xmlBuffer* buffer, xmlNode* cur)
+ cdef xmlNs* xmlSearchNs(xmlDoc* doc, xmlNode* node, const_xmlChar* prefix)
+ cdef xmlNs* xmlSearchNsByHref(xmlDoc* doc, xmlNode* node, const_xmlChar* href)
+ cdef int xmlIsBlankNode(xmlNode* node)
+ cdef long xmlGetLineNo(xmlNode* node)
+ cdef void xmlElemDump(stdio.FILE* f, xmlDoc* doc, xmlNode* cur)
+ cdef void xmlNodeDumpOutput(xmlOutputBuffer* buf,
+ xmlDoc* doc, xmlNode* cur, int level,
+ int format, const_char* encoding)
+ cdef void xmlBufAttrSerializeTxtContent(xmlOutputBuffer *buf, xmlDoc *doc,
+ xmlAttr *attr, const_xmlChar *string)
+ cdef void xmlNodeSetName(xmlNode* cur, const_xmlChar* name)
+ cdef void xmlNodeSetContent(xmlNode* cur, const_xmlChar* content)
+ cdef xmlDtd* xmlCopyDtd(xmlDtd* dtd)
+ cdef xmlDoc* xmlCopyDoc(xmlDoc* doc, int recursive)
+ cdef xmlNode* xmlCopyNode(xmlNode* node, int extended)
+ cdef xmlNode* xmlDocCopyNode(xmlNode* node, xmlDoc* doc, int extended)
+ cdef int xmlReconciliateNs(xmlDoc* doc, xmlNode* tree)
+ cdef xmlNs* xmlNewReconciliedNs(xmlDoc* doc, xmlNode* tree, xmlNs* ns)
+ cdef xmlBuffer* xmlBufferCreate()
+ cdef void xmlBufferWriteChar(xmlBuffer* buf, char* string)
+ cdef void xmlBufferFree(xmlBuffer* buf)
+ cdef const_xmlChar* xmlBufferContent(xmlBuffer* buf)
+ cdef int xmlBufferLength(xmlBuffer* buf)
+ cdef const_xmlChar* xmlBufContent(xmlBuf* buf) # new in libxml2 2.9
+ cdef size_t xmlBufUse(xmlBuf* buf) # new in libxml2 2.9
+ cdef int xmlKeepBlanksDefault(int val)
+ cdef xmlChar* xmlNodeGetBase(xmlDoc* doc, xmlNode* node)
+ cdef xmlDtd* xmlCreateIntSubset(xmlDoc* doc, const_xmlChar* name,
+ const_xmlChar* ExternalID, const_xmlChar* SystemID)
+ cdef void xmlNodeSetBase(xmlNode* node, const_xmlChar* uri)
+ cdef int xmlValidateNCName(const_xmlChar* value, int space)
+
+cdef extern from "libxml/uri.h" nogil:
+ cdef const_xmlChar* xmlBuildURI(const_xmlChar* href, const_xmlChar* base)
+
+cdef extern from "libxml/HTMLtree.h" nogil:
+ cdef void htmlNodeDumpFormatOutput(xmlOutputBuffer* buf,
+ xmlDoc* doc, xmlNode* cur,
+ char* encoding, int format)
+ cdef xmlDoc* htmlNewDoc(const_xmlChar* uri, const_xmlChar* externalID)
+
+cdef extern from "libxml/valid.h" nogil:
+ cdef xmlAttr* xmlGetID(xmlDoc* doc, const_xmlChar* ID)
+ cdef void xmlDumpNotationTable(xmlBuffer* buffer,
+ xmlNotationTable* table)
+ cdef int xmlValidateNameValue(const_xmlChar* value)
+
+cdef extern from "libxml/xmlIO.h":
+ cdef int xmlOutputBufferWrite(xmlOutputBuffer* out,
+ int len, const_char* str) nogil
+ cdef int xmlOutputBufferWriteString(xmlOutputBuffer* out, const_char* str) nogil
+ cdef int xmlOutputBufferWriteEscape(xmlOutputBuffer* out,
+ const_xmlChar* str,
+ xmlCharEncodingOutputFunc escapefunc) nogil
+ cdef int xmlOutputBufferFlush(xmlOutputBuffer* out) nogil
+ cdef int xmlOutputBufferClose(xmlOutputBuffer* out) nogil
+
+ ctypedef int (*xmlInputReadCallback)(void* context,
+ char* buffer, int len) noexcept nogil
+ ctypedef int (*xmlInputCloseCallback)(void* context) noexcept nogil
+
+ ctypedef int (*xmlOutputWriteCallback)(void* context,
+ char* buffer, int len) noexcept
+ ctypedef int (*xmlOutputCloseCallback)(void* context) noexcept
+
+ cdef xmlOutputBuffer* xmlAllocOutputBuffer(
+ xmlCharEncodingHandler* encoder) nogil
+ cdef xmlOutputBuffer* xmlOutputBufferCreateIO(
+ xmlOutputWriteCallback iowrite,
+ xmlOutputCloseCallback ioclose,
+ void * ioctx,
+ xmlCharEncodingHandler* encoder) nogil
+ cdef xmlOutputBuffer* xmlOutputBufferCreateFile(
+ stdio.FILE* file, xmlCharEncodingHandler* encoder) nogil
+ cdef xmlOutputBuffer* xmlOutputBufferCreateFilename(
+ char* URI, xmlCharEncodingHandler* encoder, int compression) nogil
+
+cdef extern from "libxml/xmlsave.h" nogil:
+ ctypedef struct xmlSaveCtxt
+
+ ctypedef enum xmlSaveOption:
+ XML_SAVE_FORMAT = 1 # format save output (2.6.17)
+ XML_SAVE_NO_DECL = 2 # drop the xml declaration (2.6.21)
+ XML_SAVE_NO_EMPTY = 4 # no empty tags (2.6.22)
+ XML_SAVE_NO_XHTML = 8 # disable XHTML1 specific rules (2.6.22)
+ XML_SAVE_XHTML = 16 # force XHTML1 specific rules (2.7.2)
+ XML_SAVE_AS_XML = 32 # force XML serialization on HTML doc (2.7.2)
+ XML_SAVE_AS_HTML = 64 # force HTML serialization on XML doc (2.7.2)
+
+ cdef xmlSaveCtxt* xmlSaveToFilename(char* filename, char* encoding,
+ int options)
+ cdef xmlSaveCtxt* xmlSaveToBuffer(xmlBuffer* buffer, char* encoding,
+ int options) # libxml2 2.6.23
+ cdef long xmlSaveDoc(xmlSaveCtxt* ctxt, xmlDoc* doc)
+ cdef long xmlSaveTree(xmlSaveCtxt* ctxt, xmlNode* node)
+ cdef int xmlSaveClose(xmlSaveCtxt* ctxt)
+ cdef int xmlSaveFlush(xmlSaveCtxt* ctxt)
+ cdef int xmlSaveSetAttrEscape(xmlSaveCtxt* ctxt, void* escape_func)
+ cdef int xmlSaveSetEscape(xmlSaveCtxt* ctxt, void* escape_func)
+
+cdef extern from "libxml/globals.h" nogil:
+ cdef int xmlThrDefKeepBlanksDefaultValue(int onoff)
+ cdef int xmlThrDefLineNumbersDefaultValue(int onoff)
+ cdef int xmlThrDefIndentTreeOutput(int onoff)
+
+cdef extern from "libxml/xmlmemory.h" nogil:
+ cdef void* xmlMalloc(size_t size)
+ cdef int xmlMemBlocks()
+ cdef int xmlMemUsed()
+ cdef void xmlMemDisplay(stdio.FILE* file)
+ cdef void xmlMemDisplayLast(stdio.FILE* file, long num_bytes)
+ cdef void xmlMemShow(stdio.FILE* file, int count)
+
+cdef extern from "etree_defs.h" nogil:
+ cdef bint _isElement(xmlNode* node)
+ cdef bint _isElementOrXInclude(xmlNode* node)
+ cdef const_xmlChar* _getNs(xmlNode* node)
+ cdef void BEGIN_FOR_EACH_ELEMENT_FROM(xmlNode* tree_top,
+ xmlNode* start_node,
+ bint inclusive)
+ cdef void END_FOR_EACH_ELEMENT_FROM(xmlNode* start_node)
+ cdef void BEGIN_FOR_EACH_FROM(xmlNode* tree_top,
+ xmlNode* start_node,
+ bint inclusive)
+ cdef void END_FOR_EACH_FROM(xmlNode* start_node)
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/uri.pxd b/llava_video/lib/python3.10/site-packages/lxml/includes/uri.pxd
new file mode 100644
index 0000000000000000000000000000000000000000..f886a54b9a9d7fc3094f99210f54edd98f12fab7
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/includes/uri.pxd
@@ -0,0 +1,5 @@
+cdef extern from "libxml/uri.h" nogil:
+ ctypedef struct xmlURI
+
+ cdef xmlURI* xmlParseURI(char* str)
+ cdef void xmlFreeURI(xmlURI* uri)
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/xinclude.pxd b/llava_video/lib/python3.10/site-packages/lxml/includes/xinclude.pxd
new file mode 100644
index 0000000000000000000000000000000000000000..68267175afa602f6bb0970566bd5f71f2d318af7
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/includes/xinclude.pxd
@@ -0,0 +1,22 @@
+from lxml.includes.tree cimport xmlDoc, xmlNode
+
+cdef extern from "libxml/xinclude.h" nogil:
+
+ ctypedef struct xmlXIncludeCtxt
+
+ cdef int xmlXIncludeProcess(xmlDoc* doc)
+ cdef int xmlXIncludeProcessFlags(xmlDoc* doc, int parser_opts)
+ cdef int xmlXIncludeProcessTree(xmlNode* doc)
+ cdef int xmlXIncludeProcessTreeFlags(xmlNode* doc, int parser_opts)
+
+ # libxml2 >= 2.7.4
+ cdef int xmlXIncludeProcessTreeFlagsData(
+ xmlNode* doc, int parser_opts, void* data)
+
+ cdef xmlXIncludeCtxt* xmlXIncludeNewContext(xmlDoc* doc)
+ cdef int xmlXIncludeProcessNode(xmlXIncludeCtxt* ctxt, xmlNode* node)
+ cdef int xmlXIncludeSetFlags(xmlXIncludeCtxt* ctxt, int flags)
+
+ # libxml2 >= 2.6.27
+ cdef int xmlXIncludeProcessFlagsData(
+ xmlDoc* doc, int flags, void* data)
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/xmlerror.pxd b/llava_video/lib/python3.10/site-packages/lxml/includes/xmlerror.pxd
new file mode 100644
index 0000000000000000000000000000000000000000..589e38eabdf7fc8b2c8a90261a25feec4d843998
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/includes/xmlerror.pxd
@@ -0,0 +1,852 @@
+
+# --- BEGIN: GENERATED CONSTANTS ---
+
+# This section is generated by the script 'update-error-constants.py'.
+
+cdef extern from "libxml/xmlerror.h":
+ ctypedef enum xmlErrorLevel:
+ XML_ERR_NONE = 0
+ XML_ERR_WARNING = 1 # A simple warning
+ XML_ERR_ERROR = 2 # A recoverable error
+ XML_ERR_FATAL = 3 # A fatal error
+
+ ctypedef enum xmlErrorDomain:
+ XML_FROM_NONE = 0
+ XML_FROM_PARSER = 1 # The XML parser
+ XML_FROM_TREE = 2 # The tree module
+ XML_FROM_NAMESPACE = 3 # The XML Namespace module
+ XML_FROM_DTD = 4 # The XML DTD validation with parser contex
+ XML_FROM_HTML = 5 # The HTML parser
+ XML_FROM_MEMORY = 6 # The memory allocator
+ XML_FROM_OUTPUT = 7 # The serialization code
+ XML_FROM_IO = 8 # The Input/Output stack
+ XML_FROM_FTP = 9 # The FTP module
+ XML_FROM_HTTP = 10 # The HTTP module
+ XML_FROM_XINCLUDE = 11 # The XInclude processing
+ XML_FROM_XPATH = 12 # The XPath module
+ XML_FROM_XPOINTER = 13 # The XPointer module
+ XML_FROM_REGEXP = 14 # The regular expressions module
+ XML_FROM_DATATYPE = 15 # The W3C XML Schemas Datatype module
+ XML_FROM_SCHEMASP = 16 # The W3C XML Schemas parser module
+ XML_FROM_SCHEMASV = 17 # The W3C XML Schemas validation module
+ XML_FROM_RELAXNGP = 18 # The Relax-NG parser module
+ XML_FROM_RELAXNGV = 19 # The Relax-NG validator module
+ XML_FROM_CATALOG = 20 # The Catalog module
+ XML_FROM_C14N = 21 # The Canonicalization module
+ XML_FROM_XSLT = 22 # The XSLT engine from libxslt
+ XML_FROM_VALID = 23 # The XML DTD validation with valid context
+ XML_FROM_CHECK = 24 # The error checking module
+ XML_FROM_WRITER = 25 # The xmlwriter module
+ XML_FROM_MODULE = 26 # The dynamically loaded module modul
+ XML_FROM_I18N = 27 # The module handling character conversion
+ XML_FROM_SCHEMATRONV = 28 # The Schematron validator module
+ XML_FROM_BUFFER = 29 # The buffers module
+ XML_FROM_URI = 30 # The URI module
+
+ ctypedef enum xmlParserErrors:
+ XML_ERR_OK = 0
+ XML_ERR_INTERNAL_ERROR = 1
+ XML_ERR_NO_MEMORY = 2
+ XML_ERR_DOCUMENT_START = 3
+ XML_ERR_DOCUMENT_EMPTY = 4
+ XML_ERR_DOCUMENT_END = 5
+ XML_ERR_INVALID_HEX_CHARREF = 6
+ XML_ERR_INVALID_DEC_CHARREF = 7
+ XML_ERR_INVALID_CHARREF = 8
+ XML_ERR_INVALID_CHAR = 9
+ XML_ERR_CHARREF_AT_EOF = 10
+ XML_ERR_CHARREF_IN_PROLOG = 11
+ XML_ERR_CHARREF_IN_EPILOG = 12
+ XML_ERR_CHARREF_IN_DTD = 13
+ XML_ERR_ENTITYREF_AT_EOF = 14
+ XML_ERR_ENTITYREF_IN_PROLOG = 15
+ XML_ERR_ENTITYREF_IN_EPILOG = 16
+ XML_ERR_ENTITYREF_IN_DTD = 17
+ XML_ERR_PEREF_AT_EOF = 18
+ XML_ERR_PEREF_IN_PROLOG = 19
+ XML_ERR_PEREF_IN_EPILOG = 20
+ XML_ERR_PEREF_IN_INT_SUBSET = 21
+ XML_ERR_ENTITYREF_NO_NAME = 22
+ XML_ERR_ENTITYREF_SEMICOL_MISSING = 23
+ XML_ERR_PEREF_NO_NAME = 24
+ XML_ERR_PEREF_SEMICOL_MISSING = 25
+ XML_ERR_UNDECLARED_ENTITY = 26
+ XML_WAR_UNDECLARED_ENTITY = 27
+ XML_ERR_UNPARSED_ENTITY = 28
+ XML_ERR_ENTITY_IS_EXTERNAL = 29
+ XML_ERR_ENTITY_IS_PARAMETER = 30
+ XML_ERR_UNKNOWN_ENCODING = 31
+ XML_ERR_UNSUPPORTED_ENCODING = 32
+ XML_ERR_STRING_NOT_STARTED = 33
+ XML_ERR_STRING_NOT_CLOSED = 34
+ XML_ERR_NS_DECL_ERROR = 35
+ XML_ERR_ENTITY_NOT_STARTED = 36
+ XML_ERR_ENTITY_NOT_FINISHED = 37
+ XML_ERR_LT_IN_ATTRIBUTE = 38
+ XML_ERR_ATTRIBUTE_NOT_STARTED = 39
+ XML_ERR_ATTRIBUTE_NOT_FINISHED = 40
+ XML_ERR_ATTRIBUTE_WITHOUT_VALUE = 41
+ XML_ERR_ATTRIBUTE_REDEFINED = 42
+ XML_ERR_LITERAL_NOT_STARTED = 43
+ XML_ERR_LITERAL_NOT_FINISHED = 44
+ XML_ERR_COMMENT_NOT_FINISHED = 45
+ XML_ERR_PI_NOT_STARTED = 46
+ XML_ERR_PI_NOT_FINISHED = 47
+ XML_ERR_NOTATION_NOT_STARTED = 48
+ XML_ERR_NOTATION_NOT_FINISHED = 49
+ XML_ERR_ATTLIST_NOT_STARTED = 50
+ XML_ERR_ATTLIST_NOT_FINISHED = 51
+ XML_ERR_MIXED_NOT_STARTED = 52
+ XML_ERR_MIXED_NOT_FINISHED = 53
+ XML_ERR_ELEMCONTENT_NOT_STARTED = 54
+ XML_ERR_ELEMCONTENT_NOT_FINISHED = 55
+ XML_ERR_XMLDECL_NOT_STARTED = 56
+ XML_ERR_XMLDECL_NOT_FINISHED = 57
+ XML_ERR_CONDSEC_NOT_STARTED = 58
+ XML_ERR_CONDSEC_NOT_FINISHED = 59
+ XML_ERR_EXT_SUBSET_NOT_FINISHED = 60
+ XML_ERR_DOCTYPE_NOT_FINISHED = 61
+ XML_ERR_MISPLACED_CDATA_END = 62
+ XML_ERR_CDATA_NOT_FINISHED = 63
+ XML_ERR_RESERVED_XML_NAME = 64
+ XML_ERR_SPACE_REQUIRED = 65
+ XML_ERR_SEPARATOR_REQUIRED = 66
+ XML_ERR_NMTOKEN_REQUIRED = 67
+ XML_ERR_NAME_REQUIRED = 68
+ XML_ERR_PCDATA_REQUIRED = 69
+ XML_ERR_URI_REQUIRED = 70
+ XML_ERR_PUBID_REQUIRED = 71
+ XML_ERR_LT_REQUIRED = 72
+ XML_ERR_GT_REQUIRED = 73
+ XML_ERR_LTSLASH_REQUIRED = 74
+ XML_ERR_EQUAL_REQUIRED = 75
+ XML_ERR_TAG_NAME_MISMATCH = 76
+ XML_ERR_TAG_NOT_FINISHED = 77
+ XML_ERR_STANDALONE_VALUE = 78
+ XML_ERR_ENCODING_NAME = 79
+ XML_ERR_HYPHEN_IN_COMMENT = 80
+ XML_ERR_INVALID_ENCODING = 81
+ XML_ERR_EXT_ENTITY_STANDALONE = 82
+ XML_ERR_CONDSEC_INVALID = 83
+ XML_ERR_VALUE_REQUIRED = 84
+ XML_ERR_NOT_WELL_BALANCED = 85
+ XML_ERR_EXTRA_CONTENT = 86
+ XML_ERR_ENTITY_CHAR_ERROR = 87
+ XML_ERR_ENTITY_PE_INTERNAL = 88
+ XML_ERR_ENTITY_LOOP = 89
+ XML_ERR_ENTITY_BOUNDARY = 90
+ XML_ERR_INVALID_URI = 91
+ XML_ERR_URI_FRAGMENT = 92
+ XML_WAR_CATALOG_PI = 93
+ XML_ERR_NO_DTD = 94
+ XML_ERR_CONDSEC_INVALID_KEYWORD = 95
+ XML_ERR_VERSION_MISSING = 96
+ XML_WAR_UNKNOWN_VERSION = 97
+ XML_WAR_LANG_VALUE = 98
+ XML_WAR_NS_URI = 99
+ XML_WAR_NS_URI_RELATIVE = 100
+ XML_ERR_MISSING_ENCODING = 101
+ XML_WAR_SPACE_VALUE = 102
+ XML_ERR_NOT_STANDALONE = 103
+ XML_ERR_ENTITY_PROCESSING = 104
+ XML_ERR_NOTATION_PROCESSING = 105
+ XML_WAR_NS_COLUMN = 106
+ XML_WAR_ENTITY_REDEFINED = 107
+ XML_ERR_UNKNOWN_VERSION = 108
+ XML_ERR_VERSION_MISMATCH = 109
+ XML_ERR_NAME_TOO_LONG = 110
+ XML_ERR_USER_STOP = 111
+ XML_ERR_COMMENT_ABRUPTLY_ENDED = 112
+ XML_NS_ERR_XML_NAMESPACE = 200
+ XML_NS_ERR_UNDEFINED_NAMESPACE = 201
+ XML_NS_ERR_QNAME = 202
+ XML_NS_ERR_ATTRIBUTE_REDEFINED = 203
+ XML_NS_ERR_EMPTY = 204
+ XML_NS_ERR_COLON = 205
+ XML_DTD_ATTRIBUTE_DEFAULT = 500
+ XML_DTD_ATTRIBUTE_REDEFINED = 501
+ XML_DTD_ATTRIBUTE_VALUE = 502
+ XML_DTD_CONTENT_ERROR = 503
+ XML_DTD_CONTENT_MODEL = 504
+ XML_DTD_CONTENT_NOT_DETERMINIST = 505
+ XML_DTD_DIFFERENT_PREFIX = 506
+ XML_DTD_ELEM_DEFAULT_NAMESPACE = 507
+ XML_DTD_ELEM_NAMESPACE = 508
+ XML_DTD_ELEM_REDEFINED = 509
+ XML_DTD_EMPTY_NOTATION = 510
+ XML_DTD_ENTITY_TYPE = 511
+ XML_DTD_ID_FIXED = 512
+ XML_DTD_ID_REDEFINED = 513
+ XML_DTD_ID_SUBSET = 514
+ XML_DTD_INVALID_CHILD = 515
+ XML_DTD_INVALID_DEFAULT = 516
+ XML_DTD_LOAD_ERROR = 517
+ XML_DTD_MISSING_ATTRIBUTE = 518
+ XML_DTD_MIXED_CORRUPT = 519
+ XML_DTD_MULTIPLE_ID = 520
+ XML_DTD_NO_DOC = 521
+ XML_DTD_NO_DTD = 522
+ XML_DTD_NO_ELEM_NAME = 523
+ XML_DTD_NO_PREFIX = 524
+ XML_DTD_NO_ROOT = 525
+ XML_DTD_NOTATION_REDEFINED = 526
+ XML_DTD_NOTATION_VALUE = 527
+ XML_DTD_NOT_EMPTY = 528
+ XML_DTD_NOT_PCDATA = 529
+ XML_DTD_NOT_STANDALONE = 530
+ XML_DTD_ROOT_NAME = 531
+ XML_DTD_STANDALONE_WHITE_SPACE = 532
+ XML_DTD_UNKNOWN_ATTRIBUTE = 533
+ XML_DTD_UNKNOWN_ELEM = 534
+ XML_DTD_UNKNOWN_ENTITY = 535
+ XML_DTD_UNKNOWN_ID = 536
+ XML_DTD_UNKNOWN_NOTATION = 537
+ XML_DTD_STANDALONE_DEFAULTED = 538
+ XML_DTD_XMLID_VALUE = 539
+ XML_DTD_XMLID_TYPE = 540
+ XML_DTD_DUP_TOKEN = 541
+ XML_HTML_STRUCURE_ERROR = 800
+ XML_HTML_UNKNOWN_TAG = 801
+ XML_RNGP_ANYNAME_ATTR_ANCESTOR = 1000
+ XML_RNGP_ATTR_CONFLICT = 1001
+ XML_RNGP_ATTRIBUTE_CHILDREN = 1002
+ XML_RNGP_ATTRIBUTE_CONTENT = 1003
+ XML_RNGP_ATTRIBUTE_EMPTY = 1004
+ XML_RNGP_ATTRIBUTE_NOOP = 1005
+ XML_RNGP_CHOICE_CONTENT = 1006
+ XML_RNGP_CHOICE_EMPTY = 1007
+ XML_RNGP_CREATE_FAILURE = 1008
+ XML_RNGP_DATA_CONTENT = 1009
+ XML_RNGP_DEF_CHOICE_AND_INTERLEAVE = 1010
+ XML_RNGP_DEFINE_CREATE_FAILED = 1011
+ XML_RNGP_DEFINE_EMPTY = 1012
+ XML_RNGP_DEFINE_MISSING = 1013
+ XML_RNGP_DEFINE_NAME_MISSING = 1014
+ XML_RNGP_ELEM_CONTENT_EMPTY = 1015
+ XML_RNGP_ELEM_CONTENT_ERROR = 1016
+ XML_RNGP_ELEMENT_EMPTY = 1017
+ XML_RNGP_ELEMENT_CONTENT = 1018
+ XML_RNGP_ELEMENT_NAME = 1019
+ XML_RNGP_ELEMENT_NO_CONTENT = 1020
+ XML_RNGP_ELEM_TEXT_CONFLICT = 1021
+ XML_RNGP_EMPTY = 1022
+ XML_RNGP_EMPTY_CONSTRUCT = 1023
+ XML_RNGP_EMPTY_CONTENT = 1024
+ XML_RNGP_EMPTY_NOT_EMPTY = 1025
+ XML_RNGP_ERROR_TYPE_LIB = 1026
+ XML_RNGP_EXCEPT_EMPTY = 1027
+ XML_RNGP_EXCEPT_MISSING = 1028
+ XML_RNGP_EXCEPT_MULTIPLE = 1029
+ XML_RNGP_EXCEPT_NO_CONTENT = 1030
+ XML_RNGP_EXTERNALREF_EMTPY = 1031
+ XML_RNGP_EXTERNAL_REF_FAILURE = 1032
+ XML_RNGP_EXTERNALREF_RECURSE = 1033
+ XML_RNGP_FORBIDDEN_ATTRIBUTE = 1034
+ XML_RNGP_FOREIGN_ELEMENT = 1035
+ XML_RNGP_GRAMMAR_CONTENT = 1036
+ XML_RNGP_GRAMMAR_EMPTY = 1037
+ XML_RNGP_GRAMMAR_MISSING = 1038
+ XML_RNGP_GRAMMAR_NO_START = 1039
+ XML_RNGP_GROUP_ATTR_CONFLICT = 1040
+ XML_RNGP_HREF_ERROR = 1041
+ XML_RNGP_INCLUDE_EMPTY = 1042
+ XML_RNGP_INCLUDE_FAILURE = 1043
+ XML_RNGP_INCLUDE_RECURSE = 1044
+ XML_RNGP_INTERLEAVE_ADD = 1045
+ XML_RNGP_INTERLEAVE_CREATE_FAILED = 1046
+ XML_RNGP_INTERLEAVE_EMPTY = 1047
+ XML_RNGP_INTERLEAVE_NO_CONTENT = 1048
+ XML_RNGP_INVALID_DEFINE_NAME = 1049
+ XML_RNGP_INVALID_URI = 1050
+ XML_RNGP_INVALID_VALUE = 1051
+ XML_RNGP_MISSING_HREF = 1052
+ XML_RNGP_NAME_MISSING = 1053
+ XML_RNGP_NEED_COMBINE = 1054
+ XML_RNGP_NOTALLOWED_NOT_EMPTY = 1055
+ XML_RNGP_NSNAME_ATTR_ANCESTOR = 1056
+ XML_RNGP_NSNAME_NO_NS = 1057
+ XML_RNGP_PARAM_FORBIDDEN = 1058
+ XML_RNGP_PARAM_NAME_MISSING = 1059
+ XML_RNGP_PARENTREF_CREATE_FAILED = 1060
+ XML_RNGP_PARENTREF_NAME_INVALID = 1061
+ XML_RNGP_PARENTREF_NO_NAME = 1062
+ XML_RNGP_PARENTREF_NO_PARENT = 1063
+ XML_RNGP_PARENTREF_NOT_EMPTY = 1064
+ XML_RNGP_PARSE_ERROR = 1065
+ XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME = 1066
+ XML_RNGP_PAT_ATTR_ATTR = 1067
+ XML_RNGP_PAT_ATTR_ELEM = 1068
+ XML_RNGP_PAT_DATA_EXCEPT_ATTR = 1069
+ XML_RNGP_PAT_DATA_EXCEPT_ELEM = 1070
+ XML_RNGP_PAT_DATA_EXCEPT_EMPTY = 1071
+ XML_RNGP_PAT_DATA_EXCEPT_GROUP = 1072
+ XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE = 1073
+ XML_RNGP_PAT_DATA_EXCEPT_LIST = 1074
+ XML_RNGP_PAT_DATA_EXCEPT_ONEMORE = 1075
+ XML_RNGP_PAT_DATA_EXCEPT_REF = 1076
+ XML_RNGP_PAT_DATA_EXCEPT_TEXT = 1077
+ XML_RNGP_PAT_LIST_ATTR = 1078
+ XML_RNGP_PAT_LIST_ELEM = 1079
+ XML_RNGP_PAT_LIST_INTERLEAVE = 1080
+ XML_RNGP_PAT_LIST_LIST = 1081
+ XML_RNGP_PAT_LIST_REF = 1082
+ XML_RNGP_PAT_LIST_TEXT = 1083
+ XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME = 1084
+ XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME = 1085
+ XML_RNGP_PAT_ONEMORE_GROUP_ATTR = 1086
+ XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR = 1087
+ XML_RNGP_PAT_START_ATTR = 1088
+ XML_RNGP_PAT_START_DATA = 1089
+ XML_RNGP_PAT_START_EMPTY = 1090
+ XML_RNGP_PAT_START_GROUP = 1091
+ XML_RNGP_PAT_START_INTERLEAVE = 1092
+ XML_RNGP_PAT_START_LIST = 1093
+ XML_RNGP_PAT_START_ONEMORE = 1094
+ XML_RNGP_PAT_START_TEXT = 1095
+ XML_RNGP_PAT_START_VALUE = 1096
+ XML_RNGP_PREFIX_UNDEFINED = 1097
+ XML_RNGP_REF_CREATE_FAILED = 1098
+ XML_RNGP_REF_CYCLE = 1099
+ XML_RNGP_REF_NAME_INVALID = 1100
+ XML_RNGP_REF_NO_DEF = 1101
+ XML_RNGP_REF_NO_NAME = 1102
+ XML_RNGP_REF_NOT_EMPTY = 1103
+ XML_RNGP_START_CHOICE_AND_INTERLEAVE = 1104
+ XML_RNGP_START_CONTENT = 1105
+ XML_RNGP_START_EMPTY = 1106
+ XML_RNGP_START_MISSING = 1107
+ XML_RNGP_TEXT_EXPECTED = 1108
+ XML_RNGP_TEXT_HAS_CHILD = 1109
+ XML_RNGP_TYPE_MISSING = 1110
+ XML_RNGP_TYPE_NOT_FOUND = 1111
+ XML_RNGP_TYPE_VALUE = 1112
+ XML_RNGP_UNKNOWN_ATTRIBUTE = 1113
+ XML_RNGP_UNKNOWN_COMBINE = 1114
+ XML_RNGP_UNKNOWN_CONSTRUCT = 1115
+ XML_RNGP_UNKNOWN_TYPE_LIB = 1116
+ XML_RNGP_URI_FRAGMENT = 1117
+ XML_RNGP_URI_NOT_ABSOLUTE = 1118
+ XML_RNGP_VALUE_EMPTY = 1119
+ XML_RNGP_VALUE_NO_CONTENT = 1120
+ XML_RNGP_XMLNS_NAME = 1121
+ XML_RNGP_XML_NS = 1122
+ XML_XPATH_EXPRESSION_OK = 1200
+ XML_XPATH_NUMBER_ERROR = 1201
+ XML_XPATH_UNFINISHED_LITERAL_ERROR = 1202
+ XML_XPATH_START_LITERAL_ERROR = 1203
+ XML_XPATH_VARIABLE_REF_ERROR = 1204
+ XML_XPATH_UNDEF_VARIABLE_ERROR = 1205
+ XML_XPATH_INVALID_PREDICATE_ERROR = 1206
+ XML_XPATH_EXPR_ERROR = 1207
+ XML_XPATH_UNCLOSED_ERROR = 1208
+ XML_XPATH_UNKNOWN_FUNC_ERROR = 1209
+ XML_XPATH_INVALID_OPERAND = 1210
+ XML_XPATH_INVALID_TYPE = 1211
+ XML_XPATH_INVALID_ARITY = 1212
+ XML_XPATH_INVALID_CTXT_SIZE = 1213
+ XML_XPATH_INVALID_CTXT_POSITION = 1214
+ XML_XPATH_MEMORY_ERROR = 1215
+ XML_XPTR_SYNTAX_ERROR = 1216
+ XML_XPTR_RESOURCE_ERROR = 1217
+ XML_XPTR_SUB_RESOURCE_ERROR = 1218
+ XML_XPATH_UNDEF_PREFIX_ERROR = 1219
+ XML_XPATH_ENCODING_ERROR = 1220
+ XML_XPATH_INVALID_CHAR_ERROR = 1221
+ XML_TREE_INVALID_HEX = 1300
+ XML_TREE_INVALID_DEC = 1301
+ XML_TREE_UNTERMINATED_ENTITY = 1302
+ XML_TREE_NOT_UTF8 = 1303
+ XML_SAVE_NOT_UTF8 = 1400
+ XML_SAVE_CHAR_INVALID = 1401
+ XML_SAVE_NO_DOCTYPE = 1402
+ XML_SAVE_UNKNOWN_ENCODING = 1403
+ XML_REGEXP_COMPILE_ERROR = 1450
+ XML_IO_UNKNOWN = 1500
+ XML_IO_EACCES = 1501
+ XML_IO_EAGAIN = 1502
+ XML_IO_EBADF = 1503
+ XML_IO_EBADMSG = 1504
+ XML_IO_EBUSY = 1505
+ XML_IO_ECANCELED = 1506
+ XML_IO_ECHILD = 1507
+ XML_IO_EDEADLK = 1508
+ XML_IO_EDOM = 1509
+ XML_IO_EEXIST = 1510
+ XML_IO_EFAULT = 1511
+ XML_IO_EFBIG = 1512
+ XML_IO_EINPROGRESS = 1513
+ XML_IO_EINTR = 1514
+ XML_IO_EINVAL = 1515
+ XML_IO_EIO = 1516
+ XML_IO_EISDIR = 1517
+ XML_IO_EMFILE = 1518
+ XML_IO_EMLINK = 1519
+ XML_IO_EMSGSIZE = 1520
+ XML_IO_ENAMETOOLONG = 1521
+ XML_IO_ENFILE = 1522
+ XML_IO_ENODEV = 1523
+ XML_IO_ENOENT = 1524
+ XML_IO_ENOEXEC = 1525
+ XML_IO_ENOLCK = 1526
+ XML_IO_ENOMEM = 1527
+ XML_IO_ENOSPC = 1528
+ XML_IO_ENOSYS = 1529
+ XML_IO_ENOTDIR = 1530
+ XML_IO_ENOTEMPTY = 1531
+ XML_IO_ENOTSUP = 1532
+ XML_IO_ENOTTY = 1533
+ XML_IO_ENXIO = 1534
+ XML_IO_EPERM = 1535
+ XML_IO_EPIPE = 1536
+ XML_IO_ERANGE = 1537
+ XML_IO_EROFS = 1538
+ XML_IO_ESPIPE = 1539
+ XML_IO_ESRCH = 1540
+ XML_IO_ETIMEDOUT = 1541
+ XML_IO_EXDEV = 1542
+ XML_IO_NETWORK_ATTEMPT = 1543
+ XML_IO_ENCODER = 1544
+ XML_IO_FLUSH = 1545
+ XML_IO_WRITE = 1546
+ XML_IO_NO_INPUT = 1547
+ XML_IO_BUFFER_FULL = 1548
+ XML_IO_LOAD_ERROR = 1549
+ XML_IO_ENOTSOCK = 1550
+ XML_IO_EISCONN = 1551
+ XML_IO_ECONNREFUSED = 1552
+ XML_IO_ENETUNREACH = 1553
+ XML_IO_EADDRINUSE = 1554
+ XML_IO_EALREADY = 1555
+ XML_IO_EAFNOSUPPORT = 1556
+ XML_XINCLUDE_RECURSION = 1600
+ XML_XINCLUDE_PARSE_VALUE = 1601
+ XML_XINCLUDE_ENTITY_DEF_MISMATCH = 1602
+ XML_XINCLUDE_NO_HREF = 1603
+ XML_XINCLUDE_NO_FALLBACK = 1604
+ XML_XINCLUDE_HREF_URI = 1605
+ XML_XINCLUDE_TEXT_FRAGMENT = 1606
+ XML_XINCLUDE_TEXT_DOCUMENT = 1607
+ XML_XINCLUDE_INVALID_CHAR = 1608
+ XML_XINCLUDE_BUILD_FAILED = 1609
+ XML_XINCLUDE_UNKNOWN_ENCODING = 1610
+ XML_XINCLUDE_MULTIPLE_ROOT = 1611
+ XML_XINCLUDE_XPTR_FAILED = 1612
+ XML_XINCLUDE_XPTR_RESULT = 1613
+ XML_XINCLUDE_INCLUDE_IN_INCLUDE = 1614
+ XML_XINCLUDE_FALLBACKS_IN_INCLUDE = 1615
+ XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE = 1616
+ XML_XINCLUDE_DEPRECATED_NS = 1617
+ XML_XINCLUDE_FRAGMENT_ID = 1618
+ XML_CATALOG_MISSING_ATTR = 1650
+ XML_CATALOG_ENTRY_BROKEN = 1651
+ XML_CATALOG_PREFER_VALUE = 1652
+ XML_CATALOG_NOT_CATALOG = 1653
+ XML_CATALOG_RECURSION = 1654
+ XML_SCHEMAP_PREFIX_UNDEFINED = 1700
+ XML_SCHEMAP_ATTRFORMDEFAULT_VALUE = 1701
+ XML_SCHEMAP_ATTRGRP_NONAME_NOREF = 1702
+ XML_SCHEMAP_ATTR_NONAME_NOREF = 1703
+ XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF = 1704
+ XML_SCHEMAP_ELEMFORMDEFAULT_VALUE = 1705
+ XML_SCHEMAP_ELEM_NONAME_NOREF = 1706
+ XML_SCHEMAP_EXTENSION_NO_BASE = 1707
+ XML_SCHEMAP_FACET_NO_VALUE = 1708
+ XML_SCHEMAP_FAILED_BUILD_IMPORT = 1709
+ XML_SCHEMAP_GROUP_NONAME_NOREF = 1710
+ XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI = 1711
+ XML_SCHEMAP_IMPORT_REDEFINE_NSNAME = 1712
+ XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI = 1713
+ XML_SCHEMAP_INVALID_BOOLEAN = 1714
+ XML_SCHEMAP_INVALID_ENUM = 1715
+ XML_SCHEMAP_INVALID_FACET = 1716
+ XML_SCHEMAP_INVALID_FACET_VALUE = 1717
+ XML_SCHEMAP_INVALID_MAXOCCURS = 1718
+ XML_SCHEMAP_INVALID_MINOCCURS = 1719
+ XML_SCHEMAP_INVALID_REF_AND_SUBTYPE = 1720
+ XML_SCHEMAP_INVALID_WHITE_SPACE = 1721
+ XML_SCHEMAP_NOATTR_NOREF = 1722
+ XML_SCHEMAP_NOTATION_NO_NAME = 1723
+ XML_SCHEMAP_NOTYPE_NOREF = 1724
+ XML_SCHEMAP_REF_AND_SUBTYPE = 1725
+ XML_SCHEMAP_RESTRICTION_NONAME_NOREF = 1726
+ XML_SCHEMAP_SIMPLETYPE_NONAME = 1727
+ XML_SCHEMAP_TYPE_AND_SUBTYPE = 1728
+ XML_SCHEMAP_UNKNOWN_ALL_CHILD = 1729
+ XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD = 1730
+ XML_SCHEMAP_UNKNOWN_ATTR_CHILD = 1731
+ XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD = 1732
+ XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP = 1733
+ XML_SCHEMAP_UNKNOWN_BASE_TYPE = 1734
+ XML_SCHEMAP_UNKNOWN_CHOICE_CHILD = 1735
+ XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD = 1736
+ XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD = 1737
+ XML_SCHEMAP_UNKNOWN_ELEM_CHILD = 1738
+ XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD = 1739
+ XML_SCHEMAP_UNKNOWN_FACET_CHILD = 1740
+ XML_SCHEMAP_UNKNOWN_FACET_TYPE = 1741
+ XML_SCHEMAP_UNKNOWN_GROUP_CHILD = 1742
+ XML_SCHEMAP_UNKNOWN_IMPORT_CHILD = 1743
+ XML_SCHEMAP_UNKNOWN_LIST_CHILD = 1744
+ XML_SCHEMAP_UNKNOWN_NOTATION_CHILD = 1745
+ XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD = 1746
+ XML_SCHEMAP_UNKNOWN_REF = 1747
+ XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD = 1748
+ XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD = 1749
+ XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD = 1750
+ XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD = 1751
+ XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD = 1752
+ XML_SCHEMAP_UNKNOWN_TYPE = 1753
+ XML_SCHEMAP_UNKNOWN_UNION_CHILD = 1754
+ XML_SCHEMAP_ELEM_DEFAULT_FIXED = 1755
+ XML_SCHEMAP_REGEXP_INVALID = 1756
+ XML_SCHEMAP_FAILED_LOAD = 1757
+ XML_SCHEMAP_NOTHING_TO_PARSE = 1758
+ XML_SCHEMAP_NOROOT = 1759
+ XML_SCHEMAP_REDEFINED_GROUP = 1760
+ XML_SCHEMAP_REDEFINED_TYPE = 1761
+ XML_SCHEMAP_REDEFINED_ELEMENT = 1762
+ XML_SCHEMAP_REDEFINED_ATTRGROUP = 1763
+ XML_SCHEMAP_REDEFINED_ATTR = 1764
+ XML_SCHEMAP_REDEFINED_NOTATION = 1765
+ XML_SCHEMAP_FAILED_PARSE = 1766
+ XML_SCHEMAP_UNKNOWN_PREFIX = 1767
+ XML_SCHEMAP_DEF_AND_PREFIX = 1768
+ XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD = 1769
+ XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI = 1770
+ XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI = 1771
+ XML_SCHEMAP_NOT_SCHEMA = 1772
+ XML_SCHEMAP_UNKNOWN_MEMBER_TYPE = 1773
+ XML_SCHEMAP_INVALID_ATTR_USE = 1774
+ XML_SCHEMAP_RECURSIVE = 1775
+ XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE = 1776
+ XML_SCHEMAP_INVALID_ATTR_COMBINATION = 1777
+ XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION = 1778
+ XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD = 1779
+ XML_SCHEMAP_INVALID_ATTR_NAME = 1780
+ XML_SCHEMAP_REF_AND_CONTENT = 1781
+ XML_SCHEMAP_CT_PROPS_CORRECT_1 = 1782
+ XML_SCHEMAP_CT_PROPS_CORRECT_2 = 1783
+ XML_SCHEMAP_CT_PROPS_CORRECT_3 = 1784
+ XML_SCHEMAP_CT_PROPS_CORRECT_4 = 1785
+ XML_SCHEMAP_CT_PROPS_CORRECT_5 = 1786
+ XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1 = 1787
+ XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1 = 1788
+ XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2 = 1789
+ XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2 = 1790
+ XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3 = 1791
+ XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER = 1792
+ XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE = 1793
+ XML_SCHEMAP_UNION_NOT_EXPRESSIBLE = 1794
+ XML_SCHEMAP_SRC_IMPORT_3_1 = 1795
+ XML_SCHEMAP_SRC_IMPORT_3_2 = 1796
+ XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1 = 1797
+ XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2 = 1798
+ XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3 = 1799
+ XML_SCHEMAP_COS_CT_EXTENDS_1_3 = 1800
+ XML_SCHEMAV_NOROOT = 1801
+ XML_SCHEMAV_UNDECLAREDELEM = 1802
+ XML_SCHEMAV_NOTTOPLEVEL = 1803
+ XML_SCHEMAV_MISSING = 1804
+ XML_SCHEMAV_WRONGELEM = 1805
+ XML_SCHEMAV_NOTYPE = 1806
+ XML_SCHEMAV_NOROLLBACK = 1807
+ XML_SCHEMAV_ISABSTRACT = 1808
+ XML_SCHEMAV_NOTEMPTY = 1809
+ XML_SCHEMAV_ELEMCONT = 1810
+ XML_SCHEMAV_HAVEDEFAULT = 1811
+ XML_SCHEMAV_NOTNILLABLE = 1812
+ XML_SCHEMAV_EXTRACONTENT = 1813
+ XML_SCHEMAV_INVALIDATTR = 1814
+ XML_SCHEMAV_INVALIDELEM = 1815
+ XML_SCHEMAV_NOTDETERMINIST = 1816
+ XML_SCHEMAV_CONSTRUCT = 1817
+ XML_SCHEMAV_INTERNAL = 1818
+ XML_SCHEMAV_NOTSIMPLE = 1819
+ XML_SCHEMAV_ATTRUNKNOWN = 1820
+ XML_SCHEMAV_ATTRINVALID = 1821
+ XML_SCHEMAV_VALUE = 1822
+ XML_SCHEMAV_FACET = 1823
+ XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1 = 1824
+ XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2 = 1825
+ XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3 = 1826
+ XML_SCHEMAV_CVC_TYPE_3_1_1 = 1827
+ XML_SCHEMAV_CVC_TYPE_3_1_2 = 1828
+ XML_SCHEMAV_CVC_FACET_VALID = 1829
+ XML_SCHEMAV_CVC_LENGTH_VALID = 1830
+ XML_SCHEMAV_CVC_MINLENGTH_VALID = 1831
+ XML_SCHEMAV_CVC_MAXLENGTH_VALID = 1832
+ XML_SCHEMAV_CVC_MININCLUSIVE_VALID = 1833
+ XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID = 1834
+ XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID = 1835
+ XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID = 1836
+ XML_SCHEMAV_CVC_TOTALDIGITS_VALID = 1837
+ XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID = 1838
+ XML_SCHEMAV_CVC_PATTERN_VALID = 1839
+ XML_SCHEMAV_CVC_ENUMERATION_VALID = 1840
+ XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1 = 1841
+ XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2 = 1842
+ XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3 = 1843
+ XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4 = 1844
+ XML_SCHEMAV_CVC_ELT_1 = 1845
+ XML_SCHEMAV_CVC_ELT_2 = 1846
+ XML_SCHEMAV_CVC_ELT_3_1 = 1847
+ XML_SCHEMAV_CVC_ELT_3_2_1 = 1848
+ XML_SCHEMAV_CVC_ELT_3_2_2 = 1849
+ XML_SCHEMAV_CVC_ELT_4_1 = 1850
+ XML_SCHEMAV_CVC_ELT_4_2 = 1851
+ XML_SCHEMAV_CVC_ELT_4_3 = 1852
+ XML_SCHEMAV_CVC_ELT_5_1_1 = 1853
+ XML_SCHEMAV_CVC_ELT_5_1_2 = 1854
+ XML_SCHEMAV_CVC_ELT_5_2_1 = 1855
+ XML_SCHEMAV_CVC_ELT_5_2_2_1 = 1856
+ XML_SCHEMAV_CVC_ELT_5_2_2_2_1 = 1857
+ XML_SCHEMAV_CVC_ELT_5_2_2_2_2 = 1858
+ XML_SCHEMAV_CVC_ELT_6 = 1859
+ XML_SCHEMAV_CVC_ELT_7 = 1860
+ XML_SCHEMAV_CVC_ATTRIBUTE_1 = 1861
+ XML_SCHEMAV_CVC_ATTRIBUTE_2 = 1862
+ XML_SCHEMAV_CVC_ATTRIBUTE_3 = 1863
+ XML_SCHEMAV_CVC_ATTRIBUTE_4 = 1864
+ XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1 = 1865
+ XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1 = 1866
+ XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2 = 1867
+ XML_SCHEMAV_CVC_COMPLEX_TYPE_4 = 1868
+ XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1 = 1869
+ XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2 = 1870
+ XML_SCHEMAV_ELEMENT_CONTENT = 1871
+ XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING = 1872
+ XML_SCHEMAV_CVC_COMPLEX_TYPE_1 = 1873
+ XML_SCHEMAV_CVC_AU = 1874
+ XML_SCHEMAV_CVC_TYPE_1 = 1875
+ XML_SCHEMAV_CVC_TYPE_2 = 1876
+ XML_SCHEMAV_CVC_IDC = 1877
+ XML_SCHEMAV_CVC_WILDCARD = 1878
+ XML_SCHEMAV_MISC = 1879
+ XML_XPTR_UNKNOWN_SCHEME = 1900
+ XML_XPTR_CHILDSEQ_START = 1901
+ XML_XPTR_EVAL_FAILED = 1902
+ XML_XPTR_EXTRA_OBJECTS = 1903
+ XML_C14N_CREATE_CTXT = 1950
+ XML_C14N_REQUIRES_UTF8 = 1951
+ XML_C14N_CREATE_STACK = 1952
+ XML_C14N_INVALID_NODE = 1953
+ XML_C14N_UNKNOW_NODE = 1954
+ XML_C14N_RELATIVE_NAMESPACE = 1955
+ XML_FTP_PASV_ANSWER = 2000
+ XML_FTP_EPSV_ANSWER = 2001
+ XML_FTP_ACCNT = 2002
+ XML_FTP_URL_SYNTAX = 2003
+ XML_HTTP_URL_SYNTAX = 2020
+ XML_HTTP_USE_IP = 2021
+ XML_HTTP_UNKNOWN_HOST = 2022
+ XML_SCHEMAP_SRC_SIMPLE_TYPE_1 = 3000
+ XML_SCHEMAP_SRC_SIMPLE_TYPE_2 = 3001
+ XML_SCHEMAP_SRC_SIMPLE_TYPE_3 = 3002
+ XML_SCHEMAP_SRC_SIMPLE_TYPE_4 = 3003
+ XML_SCHEMAP_SRC_RESOLVE = 3004
+ XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE = 3005
+ XML_SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE = 3006
+ XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES = 3007
+ XML_SCHEMAP_ST_PROPS_CORRECT_1 = 3008
+ XML_SCHEMAP_ST_PROPS_CORRECT_2 = 3009
+ XML_SCHEMAP_ST_PROPS_CORRECT_3 = 3010
+ XML_SCHEMAP_COS_ST_RESTRICTS_1_1 = 3011
+ XML_SCHEMAP_COS_ST_RESTRICTS_1_2 = 3012
+ XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1 = 3013
+ XML_SCHEMAP_COS_ST_RESTRICTS_1_3_2 = 3014
+ XML_SCHEMAP_COS_ST_RESTRICTS_2_1 = 3015
+ XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1 = 3016
+ XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2 = 3017
+ XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1 = 3018
+ XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2 = 3019
+ XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3 = 3020
+ XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4 = 3021
+ XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_5 = 3022
+ XML_SCHEMAP_COS_ST_RESTRICTS_3_1 = 3023
+ XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1 = 3024
+ XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2 = 3025
+ XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2 = 3026
+ XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1 = 3027
+ XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3 = 3028
+ XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4 = 3029
+ XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_5 = 3030
+ XML_SCHEMAP_COS_ST_DERIVED_OK_2_1 = 3031
+ XML_SCHEMAP_COS_ST_DERIVED_OK_2_2 = 3032
+ XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED = 3033
+ XML_SCHEMAP_S4S_ELEM_MISSING = 3034
+ XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED = 3035
+ XML_SCHEMAP_S4S_ATTR_MISSING = 3036
+ XML_SCHEMAP_S4S_ATTR_INVALID_VALUE = 3037
+ XML_SCHEMAP_SRC_ELEMENT_1 = 3038
+ XML_SCHEMAP_SRC_ELEMENT_2_1 = 3039
+ XML_SCHEMAP_SRC_ELEMENT_2_2 = 3040
+ XML_SCHEMAP_SRC_ELEMENT_3 = 3041
+ XML_SCHEMAP_P_PROPS_CORRECT_1 = 3042
+ XML_SCHEMAP_P_PROPS_CORRECT_2_1 = 3043
+ XML_SCHEMAP_P_PROPS_CORRECT_2_2 = 3044
+ XML_SCHEMAP_E_PROPS_CORRECT_2 = 3045
+ XML_SCHEMAP_E_PROPS_CORRECT_3 = 3046
+ XML_SCHEMAP_E_PROPS_CORRECT_4 = 3047
+ XML_SCHEMAP_E_PROPS_CORRECT_5 = 3048
+ XML_SCHEMAP_E_PROPS_CORRECT_6 = 3049
+ XML_SCHEMAP_SRC_INCLUDE = 3050
+ XML_SCHEMAP_SRC_ATTRIBUTE_1 = 3051
+ XML_SCHEMAP_SRC_ATTRIBUTE_2 = 3052
+ XML_SCHEMAP_SRC_ATTRIBUTE_3_1 = 3053
+ XML_SCHEMAP_SRC_ATTRIBUTE_3_2 = 3054
+ XML_SCHEMAP_SRC_ATTRIBUTE_4 = 3055
+ XML_SCHEMAP_NO_XMLNS = 3056
+ XML_SCHEMAP_NO_XSI = 3057
+ XML_SCHEMAP_COS_VALID_DEFAULT_1 = 3058
+ XML_SCHEMAP_COS_VALID_DEFAULT_2_1 = 3059
+ XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1 = 3060
+ XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2 = 3061
+ XML_SCHEMAP_CVC_SIMPLE_TYPE = 3062
+ XML_SCHEMAP_COS_CT_EXTENDS_1_1 = 3063
+ XML_SCHEMAP_SRC_IMPORT_1_1 = 3064
+ XML_SCHEMAP_SRC_IMPORT_1_2 = 3065
+ XML_SCHEMAP_SRC_IMPORT_2 = 3066
+ XML_SCHEMAP_SRC_IMPORT_2_1 = 3067
+ XML_SCHEMAP_SRC_IMPORT_2_2 = 3068
+ XML_SCHEMAP_INTERNAL = 3069 # 3069 non-W3C
+ XML_SCHEMAP_NOT_DETERMINISTIC = 3070 # 3070 non-W3C
+ XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_1 = 3071
+ XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_2 = 3072
+ XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3 = 3073
+ XML_SCHEMAP_MG_PROPS_CORRECT_1 = 3074
+ XML_SCHEMAP_MG_PROPS_CORRECT_2 = 3075
+ XML_SCHEMAP_SRC_CT_1 = 3076
+ XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3 = 3077
+ XML_SCHEMAP_AU_PROPS_CORRECT_2 = 3078
+ XML_SCHEMAP_A_PROPS_CORRECT_2 = 3079
+ XML_SCHEMAP_C_PROPS_CORRECT = 3080
+ XML_SCHEMAP_SRC_REDEFINE = 3081
+ XML_SCHEMAP_SRC_IMPORT = 3082
+ XML_SCHEMAP_WARN_SKIP_SCHEMA = 3083
+ XML_SCHEMAP_WARN_UNLOCATED_SCHEMA = 3084
+ XML_SCHEMAP_WARN_ATTR_REDECL_PROH = 3085
+ XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH = 3086 # 3085
+ XML_SCHEMAP_AG_PROPS_CORRECT = 3087 # 3086
+ XML_SCHEMAP_COS_CT_EXTENDS_1_2 = 3088 # 3087
+ XML_SCHEMAP_AU_PROPS_CORRECT = 3089 # 3088
+ XML_SCHEMAP_A_PROPS_CORRECT_3 = 3090 # 3089
+ XML_SCHEMAP_COS_ALL_LIMITED = 3091 # 3090
+ XML_SCHEMATRONV_ASSERT = 4000
+ XML_SCHEMATRONV_REPORT = 4001
+ XML_MODULE_OPEN = 4900
+ XML_MODULE_CLOSE = 4901
+ XML_CHECK_FOUND_ELEMENT = 5000
+ XML_CHECK_FOUND_ATTRIBUTE = 5001
+ XML_CHECK_FOUND_TEXT = 5002
+ XML_CHECK_FOUND_CDATA = 5003
+ XML_CHECK_FOUND_ENTITYREF = 5004
+ XML_CHECK_FOUND_ENTITY = 5005
+ XML_CHECK_FOUND_PI = 5006
+ XML_CHECK_FOUND_COMMENT = 5007
+ XML_CHECK_FOUND_DOCTYPE = 5008
+ XML_CHECK_FOUND_FRAGMENT = 5009
+ XML_CHECK_FOUND_NOTATION = 5010
+ XML_CHECK_UNKNOWN_NODE = 5011
+ XML_CHECK_ENTITY_TYPE = 5012
+ XML_CHECK_NO_PARENT = 5013
+ XML_CHECK_NO_DOC = 5014
+ XML_CHECK_NO_NAME = 5015
+ XML_CHECK_NO_ELEM = 5016
+ XML_CHECK_WRONG_DOC = 5017
+ XML_CHECK_NO_PREV = 5018
+ XML_CHECK_WRONG_PREV = 5019
+ XML_CHECK_NO_NEXT = 5020
+ XML_CHECK_WRONG_NEXT = 5021
+ XML_CHECK_NOT_DTD = 5022
+ XML_CHECK_NOT_ATTR = 5023
+ XML_CHECK_NOT_ATTR_DECL = 5024
+ XML_CHECK_NOT_ELEM_DECL = 5025
+ XML_CHECK_NOT_ENTITY_DECL = 5026
+ XML_CHECK_NOT_NS_DECL = 5027
+ XML_CHECK_NO_HREF = 5028
+ XML_CHECK_WRONG_PARENT = 5029
+ XML_CHECK_NS_SCOPE = 5030
+ XML_CHECK_NS_ANCESTOR = 5031
+ XML_CHECK_NOT_UTF8 = 5032
+ XML_CHECK_NO_DICT = 5033
+ XML_CHECK_NOT_NCNAME = 5034
+ XML_CHECK_OUTSIDE_DICT = 5035
+ XML_CHECK_WRONG_NAME = 5036
+ XML_CHECK_NAME_NOT_NULL = 5037
+ XML_I18N_NO_NAME = 6000
+ XML_I18N_NO_HANDLER = 6001
+ XML_I18N_EXCESS_HANDLER = 6002
+ XML_I18N_CONV_FAILED = 6003
+ XML_I18N_NO_OUTPUT = 6004
+ XML_BUF_OVERFLOW = 7000
+
+ ctypedef enum xmlRelaxNGValidErr:
+ XML_RELAXNG_OK = 0
+ XML_RELAXNG_ERR_MEMORY = 1
+ XML_RELAXNG_ERR_TYPE = 2
+ XML_RELAXNG_ERR_TYPEVAL = 3
+ XML_RELAXNG_ERR_DUPID = 4
+ XML_RELAXNG_ERR_TYPECMP = 5
+ XML_RELAXNG_ERR_NOSTATE = 6
+ XML_RELAXNG_ERR_NODEFINE = 7
+ XML_RELAXNG_ERR_LISTEXTRA = 8
+ XML_RELAXNG_ERR_LISTEMPTY = 9
+ XML_RELAXNG_ERR_INTERNODATA = 10
+ XML_RELAXNG_ERR_INTERSEQ = 11
+ XML_RELAXNG_ERR_INTEREXTRA = 12
+ XML_RELAXNG_ERR_ELEMNAME = 13
+ XML_RELAXNG_ERR_ATTRNAME = 14
+ XML_RELAXNG_ERR_ELEMNONS = 15
+ XML_RELAXNG_ERR_ATTRNONS = 16
+ XML_RELAXNG_ERR_ELEMWRONGNS = 17
+ XML_RELAXNG_ERR_ATTRWRONGNS = 18
+ XML_RELAXNG_ERR_ELEMEXTRANS = 19
+ XML_RELAXNG_ERR_ATTREXTRANS = 20
+ XML_RELAXNG_ERR_ELEMNOTEMPTY = 21
+ XML_RELAXNG_ERR_NOELEM = 22
+ XML_RELAXNG_ERR_NOTELEM = 23
+ XML_RELAXNG_ERR_ATTRVALID = 24
+ XML_RELAXNG_ERR_CONTENTVALID = 25
+ XML_RELAXNG_ERR_EXTRACONTENT = 26
+ XML_RELAXNG_ERR_INVALIDATTR = 27
+ XML_RELAXNG_ERR_DATAELEM = 28
+ XML_RELAXNG_ERR_VALELEM = 29
+ XML_RELAXNG_ERR_LISTELEM = 30
+ XML_RELAXNG_ERR_DATATYPE = 31
+ XML_RELAXNG_ERR_VALUE = 32
+ XML_RELAXNG_ERR_LIST = 33
+ XML_RELAXNG_ERR_NOGRAMMAR = 34
+ XML_RELAXNG_ERR_EXTRADATA = 35
+ XML_RELAXNG_ERR_LACKDATA = 36
+ XML_RELAXNG_ERR_INTERNAL = 37
+ XML_RELAXNG_ERR_ELEMWRONG = 38
+ XML_RELAXNG_ERR_TEXTWRONG = 39
+# --- END: GENERATED CONSTANTS ---
+
+cdef extern from "libxml/xmlerror.h" nogil:
+ ctypedef struct xmlError:
+ int domain
+ int code
+ char* message
+ xmlErrorLevel level
+ char* file
+ char* str1
+ char* str2
+ char* str3
+ int line
+ int int1
+ int int2
+ void* node
+
+ ctypedef void (*xmlGenericErrorFunc)(void* ctxt, char* msg, ...) noexcept
+ ctypedef void (*xmlStructuredErrorFunc)(void* userData,
+ const xmlError* error) noexcept
+
+ cdef void xmlSetGenericErrorFunc(
+ void* ctxt, xmlGenericErrorFunc func)
+ cdef void xmlSetStructuredErrorFunc(
+ void* ctxt, xmlStructuredErrorFunc func)
+
+cdef extern from "libxml/globals.h" nogil:
+ cdef xmlStructuredErrorFunc xmlStructuredError
+ cdef void* xmlStructuredErrorContext
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/xmlparser.pxd b/llava_video/lib/python3.10/site-packages/lxml/includes/xmlparser.pxd
new file mode 100644
index 0000000000000000000000000000000000000000..a43c74cf4be64dfa0956838984f1152dbc35f10f
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/includes/xmlparser.pxd
@@ -0,0 +1,265 @@
+from libc.string cimport const_char
+
+from lxml.includes.tree cimport (
+ xmlDoc, xmlNode, xmlEntity, xmlDict, xmlDtd, xmlChar, const_xmlChar)
+from lxml.includes.tree cimport xmlInputReadCallback, xmlInputCloseCallback
+from lxml.includes.xmlerror cimport xmlError, xmlStructuredErrorFunc, xmlErrorLevel
+
+
+cdef extern from "libxml/parser.h" nogil:
+ ctypedef void (*startElementNsSAX2Func)(void* ctx,
+ const_xmlChar* localname,
+ const_xmlChar* prefix,
+ const_xmlChar* URI,
+ int nb_namespaces,
+ const_xmlChar** namespaces,
+ int nb_attributes,
+ int nb_defaulted,
+ const_xmlChar** attributes) noexcept
+
+ ctypedef void (*endElementNsSAX2Func)(void* ctx,
+ const_xmlChar* localname,
+ const_xmlChar* prefix,
+ const_xmlChar* URI) noexcept
+
+ ctypedef void (*startElementSAXFunc)(void* ctx, const_xmlChar* name, const_xmlChar** atts) noexcept
+
+ ctypedef void (*endElementSAXFunc)(void* ctx, const_xmlChar* name) noexcept
+
+ ctypedef void (*charactersSAXFunc)(void* ctx, const_xmlChar* ch, int len) noexcept
+
+ ctypedef void (*cdataBlockSAXFunc)(void* ctx, const_xmlChar* value, int len) noexcept
+
+ ctypedef void (*commentSAXFunc)(void* ctx, const_xmlChar* value) noexcept
+
+ ctypedef void (*processingInstructionSAXFunc)(void* ctx,
+ const_xmlChar* target,
+ const_xmlChar* data) noexcept
+
+ ctypedef void (*internalSubsetSAXFunc)(void* ctx,
+ const_xmlChar* name,
+ const_xmlChar* externalID,
+ const_xmlChar* systemID) noexcept
+
+ ctypedef void (*endDocumentSAXFunc)(void* ctx) noexcept
+
+ ctypedef void (*startDocumentSAXFunc)(void* ctx) noexcept
+
+ ctypedef void (*referenceSAXFunc)(void * ctx, const_xmlChar* name) noexcept
+
+ ctypedef xmlEntity* (*getEntitySAXFunc)(void* ctx, const_xmlChar* name) noexcept
+
+ cdef int XML_SAX2_MAGIC
+
+cdef extern from "libxml/tree.h" nogil:
+ ctypedef struct xmlParserInput:
+ int line
+ int col
+ int length
+ const_xmlChar* base
+ const_xmlChar* cur
+ const_xmlChar* end
+ const_char *filename
+
+ ctypedef struct xmlParserInputBuffer:
+ void* context
+ xmlInputReadCallback readcallback
+ xmlInputCloseCallback closecallback
+
+ ctypedef struct xmlSAXHandlerV1:
+ # same as xmlSAXHandler, but without namespaces
+ pass
+
+ ctypedef struct xmlSAXHandler:
+ internalSubsetSAXFunc internalSubset
+ startElementNsSAX2Func startElementNs
+ endElementNsSAX2Func endElementNs
+ startElementSAXFunc startElement
+ endElementSAXFunc endElement
+ charactersSAXFunc characters
+ cdataBlockSAXFunc cdataBlock
+ referenceSAXFunc reference
+ getEntitySAXFunc getEntity
+ commentSAXFunc comment
+ processingInstructionSAXFunc processingInstruction
+ startDocumentSAXFunc startDocument
+ endDocumentSAXFunc endDocument
+ int initialized
+ xmlStructuredErrorFunc serror
+ void* _private
+
+
+cdef extern from "libxml/SAX2.h" nogil:
+ cdef void xmlSAX2StartDocument(void* ctxt)
+
+
+cdef extern from "libxml/xmlIO.h" nogil:
+ cdef xmlParserInputBuffer* xmlAllocParserInputBuffer(int enc)
+
+
+cdef extern from "libxml/parser.h" nogil:
+
+ cdef xmlDict* xmlDictCreate()
+ cdef xmlDict* xmlDictCreateSub(xmlDict* subdict)
+ cdef void xmlDictFree(xmlDict* sub)
+ cdef int xmlDictReference(xmlDict* dict)
+
+ cdef int XML_COMPLETE_ATTRS # SAX option for adding DTD default attributes
+ cdef int XML_SKIP_IDS # SAX option for not building an XML ID dict
+
+ ctypedef enum xmlParserInputState:
+ XML_PARSER_EOF = -1 # nothing is to be parsed
+ XML_PARSER_START = 0 # nothing has been parsed
+ XML_PARSER_MISC = 1 # Misc* before int subset
+ XML_PARSER_PI = 2 # Within a processing instruction
+ XML_PARSER_DTD = 3 # within some DTD content
+ XML_PARSER_PROLOG = 4 # Misc* after internal subset
+ XML_PARSER_COMMENT = 5 # within a comment
+ XML_PARSER_START_TAG = 6 # within a start tag
+ XML_PARSER_CONTENT = 7 # within the content
+ XML_PARSER_CDATA_SECTION = 8 # within a CDATA section
+ XML_PARSER_END_TAG = 9 # within a closing tag
+ XML_PARSER_ENTITY_DECL = 10 # within an entity declaration
+ XML_PARSER_ENTITY_VALUE = 11 # within an entity value in a decl
+ XML_PARSER_ATTRIBUTE_VALUE = 12 # within an attribute value
+ XML_PARSER_SYSTEM_LITERAL = 13 # within a SYSTEM value
+ XML_PARSER_EPILOG = 14 # the Misc* after the last end tag
+ XML_PARSER_IGNORE = 15 # within an IGNORED section
+ XML_PARSER_PUBLIC_LITERAL = 16 # within a PUBLIC value
+
+
+ ctypedef struct xmlParserCtxt:
+ xmlDoc* myDoc
+ xmlDict* dict
+ int dictNames
+ void* _private
+ bint wellFormed
+ bint recovery
+ int options
+ bint disableSAX
+ int errNo
+ xmlParserInputState instate
+ bint replaceEntities
+ int loadsubset # != 0 if enabled, int value == why
+ bint validate
+ xmlError lastError
+ xmlNode* node
+ xmlSAXHandler* sax
+ void* userData
+ int* spaceTab
+ int spaceMax
+ int nsNr
+ bint html
+ bint progressive
+ int inSubset
+ int charset
+ xmlParserInput* input
+ int inputNr
+ xmlParserInput* inputTab[]
+
+ ctypedef enum xmlParserOption:
+ XML_PARSE_RECOVER = 1 # recover on errors
+ XML_PARSE_NOENT = 2 # substitute entities
+ XML_PARSE_DTDLOAD = 4 # load the external subset
+ XML_PARSE_DTDATTR = 8 # default DTD attributes
+ XML_PARSE_DTDVALID = 16 # validate with the DTD
+ XML_PARSE_NOERROR = 32 # suppress error reports
+ XML_PARSE_NOWARNING = 64 # suppress warning reports
+ XML_PARSE_PEDANTIC = 128 # pedantic error reporting
+ XML_PARSE_NOBLANKS = 256 # remove blank nodes
+ XML_PARSE_SAX1 = 512 # use the SAX1 interface internally
+ XML_PARSE_XINCLUDE = 1024 # Implement XInclude substitution
+ XML_PARSE_NONET = 2048 # Forbid network access
+ XML_PARSE_NODICT = 4096 # Do not reuse the context dictionary
+ XML_PARSE_NSCLEAN = 8192 # remove redundant namespaces declarations
+ XML_PARSE_NOCDATA = 16384 # merge CDATA as text nodes
+ XML_PARSE_NOXINCNODE = 32768 # do not generate XINCLUDE START/END nodes
+ # libxml2 2.6.21+ only:
+ XML_PARSE_COMPACT = 65536 # compact small text nodes
+ # libxml2 2.7.0+ only:
+ XML_PARSE_OLD10 = 131072 # parse using XML-1.0 before update 5
+ XML_PARSE_NOBASEFIX = 262144 # do not fixup XINCLUDE xml:base uris
+ XML_PARSE_HUGE = 524288 # relax any hardcoded limit from the parser
+ # libxml2 2.7.3+ only:
+ XML_PARSE_OLDSAX = 1048576 # parse using SAX2 interface before 2.7.0
+ # libxml2 2.8.0+ only:
+ XML_PARSE_IGNORE_ENC = 2097152 # ignore internal document encoding hint
+ # libxml2 2.9.0+ only:
+ XML_PARSE_BIG_LINES = 4194304 # Store big lines numbers in text PSVI field
+
+ cdef void xmlInitParser()
+ cdef void xmlCleanupParser()
+
+ cdef int xmlLineNumbersDefault(int onoff)
+ cdef xmlParserCtxt* xmlNewParserCtxt()
+ cdef xmlParserInput* xmlNewIOInputStream(xmlParserCtxt* ctxt,
+ xmlParserInputBuffer* input,
+ int enc)
+ cdef int xmlCtxtUseOptions(xmlParserCtxt* ctxt, int options)
+ cdef void xmlFreeParserCtxt(xmlParserCtxt* ctxt)
+ cdef void xmlCtxtReset(xmlParserCtxt* ctxt)
+ cdef void xmlClearParserCtxt(xmlParserCtxt* ctxt)
+ cdef int xmlParseChunk(xmlParserCtxt* ctxt,
+ char* chunk, int size, int terminate)
+ cdef xmlDoc* xmlCtxtReadDoc(xmlParserCtxt* ctxt,
+ char* cur, char* URL, char* encoding,
+ int options)
+ cdef xmlDoc* xmlCtxtReadFile(xmlParserCtxt* ctxt,
+ char* filename, char* encoding,
+ int options)
+ cdef xmlDoc* xmlCtxtReadIO(xmlParserCtxt* ctxt,
+ xmlInputReadCallback ioread,
+ xmlInputCloseCallback ioclose,
+ void* ioctx,
+ char* URL, char* encoding,
+ int options)
+ cdef xmlDoc* xmlCtxtReadMemory(xmlParserCtxt* ctxt,
+ char* buffer, int size,
+ char* filename, const_char* encoding,
+ int options)
+
+ cdef void xmlErrParser(xmlParserCtxt* ctxt, xmlNode* node,
+ int domain, int code, xmlErrorLevel level,
+ const xmlChar *str1, const xmlChar *str2, const xmlChar *str3,
+ int int1, const char *msg, ...)
+
+
+# iterparse:
+
+ cdef xmlParserCtxt* xmlCreatePushParserCtxt(xmlSAXHandler* sax,
+ void* user_data,
+ char* chunk,
+ int size,
+ char* filename)
+
+ cdef int xmlCtxtResetPush(xmlParserCtxt* ctxt,
+ char* chunk,
+ int size,
+ char* filename,
+ char* encoding)
+
+# entity loaders:
+
+ ctypedef xmlParserInput* (*xmlExternalEntityLoader)(
+ const_char * URL, const_char * ID, xmlParserCtxt* context) noexcept
+ cdef xmlExternalEntityLoader xmlGetExternalEntityLoader()
+ cdef void xmlSetExternalEntityLoader(xmlExternalEntityLoader f)
+
+ cdef xmlEntity* xmlSAX2GetEntity(void* ctxt, const_xmlChar* name) noexcept
+
+# DTDs:
+
+ cdef xmlDtd* xmlParseDTD(const_xmlChar* ExternalID, const_xmlChar* SystemID)
+ cdef xmlDtd* xmlIOParseDTD(xmlSAXHandler* sax,
+ xmlParserInputBuffer* input,
+ int enc)
+
+
+cdef extern from "libxml/parserInternals.h" nogil:
+ cdef xmlParserInput* xmlNewInputStream(xmlParserCtxt* ctxt)
+ cdef xmlParserInput* xmlNewStringInputStream(xmlParserCtxt* ctxt,
+ char* buffer)
+ cdef xmlParserInput* xmlNewInputFromFile(xmlParserCtxt* ctxt,
+ char* filename)
+ cdef void xmlFreeInputStream(xmlParserInput* input)
+ cdef int xmlSwitchEncoding(xmlParserCtxt* ctxt, int enc)
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/xmlschema.pxd b/llava_video/lib/python3.10/site-packages/lxml/includes/xmlschema.pxd
new file mode 100644
index 0000000000000000000000000000000000000000..0674111132ee3c2da8f2a3ec1db7d9dbb462ad30
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/includes/xmlschema.pxd
@@ -0,0 +1,35 @@
+from lxml.includes.tree cimport xmlDoc
+from lxml.includes.xmlparser cimport xmlSAXHandler
+from lxml.includes.xmlerror cimport xmlStructuredErrorFunc
+
+cdef extern from "libxml/xmlschemas.h" nogil:
+ ctypedef struct xmlSchema
+ ctypedef struct xmlSchemaParserCtxt
+
+ ctypedef struct xmlSchemaSAXPlugStruct
+ ctypedef struct xmlSchemaValidCtxt
+
+ ctypedef enum xmlSchemaValidOption:
+ XML_SCHEMA_VAL_VC_I_CREATE = 1
+
+ cdef xmlSchemaValidCtxt* xmlSchemaNewValidCtxt(xmlSchema* schema) nogil
+ cdef void xmlSchemaSetParserStructuredErrors(xmlSchemaParserCtxt* ctxt,
+ xmlStructuredErrorFunc serror, void *ctx)
+ cdef void xmlSchemaSetValidStructuredErrors(xmlSchemaValidCtxt* ctxt,
+ xmlStructuredErrorFunc serror, void *ctx)
+
+ cdef int xmlSchemaValidateDoc(xmlSchemaValidCtxt* ctxt, xmlDoc* doc) nogil
+ cdef xmlSchema* xmlSchemaParse(xmlSchemaParserCtxt* ctxt) nogil
+ cdef xmlSchemaParserCtxt* xmlSchemaNewParserCtxt(char* URL) nogil
+ cdef xmlSchemaParserCtxt* xmlSchemaNewDocParserCtxt(xmlDoc* doc) nogil
+ cdef void xmlSchemaFree(xmlSchema* schema) nogil
+ cdef void xmlSchemaFreeParserCtxt(xmlSchemaParserCtxt* ctxt) nogil
+ cdef void xmlSchemaFreeValidCtxt(xmlSchemaValidCtxt* ctxt) nogil
+ cdef int xmlSchemaSetValidOptions(xmlSchemaValidCtxt* ctxt,
+ int options) nogil
+
+ cdef xmlSchemaSAXPlugStruct* xmlSchemaSAXPlug(xmlSchemaValidCtxt* ctxt,
+ xmlSAXHandler** sax,
+ void** data) nogil
+ cdef int xmlSchemaSAXUnplug(xmlSchemaSAXPlugStruct* sax_plug)
+ cdef int xmlSchemaIsValid(xmlSchemaValidCtxt* ctxt)
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/xpath.pxd b/llava_video/lib/python3.10/site-packages/lxml/includes/xpath.pxd
new file mode 100644
index 0000000000000000000000000000000000000000..22069eb7cbb576b6236f53912f8529863a07cd08
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/includes/xpath.pxd
@@ -0,0 +1,136 @@
+from lxml.includes cimport tree
+from lxml.includes cimport xmlerror
+
+from libc.string cimport const_char
+from lxml.includes.tree cimport xmlChar, const_xmlChar
+
+
+cdef extern from "libxml/xpath.h" nogil:
+ ctypedef enum xmlXPathObjectType:
+ XPATH_UNDEFINED = 0
+ XPATH_NODESET = 1
+ XPATH_BOOLEAN = 2
+ XPATH_NUMBER = 3
+ XPATH_STRING = 4
+ XPATH_POINT = 5
+ XPATH_RANGE = 6
+ XPATH_LOCATIONSET = 7
+ XPATH_USERS = 8
+ XPATH_XSLT_TREE = 9
+
+ ctypedef enum xmlXPathError:
+ XPATH_EXPRESSION_OK = 0
+ XPATH_NUMBER_ERROR = 1
+ XPATH_UNFINISHED_LITERAL_ERROR = 2
+ XPATH_START_LITERAL_ERROR = 3
+ XPATH_VARIABLE_REF_ERROR = 4
+ XPATH_UNDEF_VARIABLE_ERROR = 5
+ XPATH_INVALID_PREDICATE_ERROR = 6
+ XPATH_EXPR_ERROR = 7
+ XPATH_UNCLOSED_ERROR = 8
+ XPATH_UNKNOWN_FUNC_ERROR = 9
+ XPATH_INVALID_OPERAND = 10
+ XPATH_INVALID_TYPE = 11
+ XPATH_INVALID_ARITY = 12
+ XPATH_INVALID_CTXT_SIZE = 13
+ XPATH_INVALID_CTXT_POSITION = 14
+ XPATH_MEMORY_ERROR = 15
+ XPTR_SYNTAX_ERROR = 16
+ XPTR_RESOURCE_ERROR = 17
+ XPTR_SUB_RESOURCE_ERROR = 18
+ XPATH_UNDEF_PREFIX_ERROR = 19
+ XPATH_ENCODING_ERROR = 20
+ XPATH_INVALID_CHAR_ERROR = 21
+ XPATH_INVALID_CTXT = 22
+
+ ctypedef struct xmlNodeSet:
+ int nodeNr
+ int nodeMax
+ tree.xmlNode** nodeTab
+
+ ctypedef struct xmlXPathObject:
+ xmlXPathObjectType type
+ xmlNodeSet* nodesetval
+ bint boolval
+ double floatval
+ xmlChar* stringval
+
+ ctypedef struct xmlXPathContext:
+ tree.xmlDoc* doc
+ tree.xmlNode* node
+ tree.xmlDict* dict
+ tree.xmlHashTable* nsHash
+ const_xmlChar* function
+ const_xmlChar* functionURI
+ xmlerror.xmlStructuredErrorFunc error
+ xmlerror.xmlError lastError
+ void* userData
+
+ ctypedef struct xmlXPathParserContext:
+ xmlXPathContext* context
+ xmlXPathObject* value
+ tree.xmlNode* ancestor
+ int error
+
+ ctypedef struct xmlXPathCompExpr
+
+ ctypedef void (*xmlXPathFunction)(xmlXPathParserContext* ctxt, int nargs)
+ ctypedef xmlXPathFunction (*xmlXPathFuncLookupFunc)(void* ctxt,
+ const_xmlChar* name,
+ const_xmlChar* ns_uri)
+
+ cdef xmlXPathContext* xmlXPathNewContext(tree.xmlDoc* doc)
+ cdef xmlXPathObject* xmlXPathEvalExpression(const_xmlChar* str,
+ xmlXPathContext* ctxt)
+ cdef xmlXPathObject* xmlXPathCompiledEval(xmlXPathCompExpr* comp,
+ xmlXPathContext* ctxt)
+ cdef xmlXPathCompExpr* xmlXPathCompile(const_xmlChar* str)
+ cdef xmlXPathCompExpr* xmlXPathCtxtCompile(xmlXPathContext* ctxt,
+ const_xmlChar* str)
+ cdef void xmlXPathFreeContext(xmlXPathContext* ctxt)
+ cdef void xmlXPathFreeCompExpr(xmlXPathCompExpr* comp)
+ cdef void xmlXPathFreeObject(xmlXPathObject* obj)
+ cdef int xmlXPathRegisterNs(xmlXPathContext* ctxt,
+ const_xmlChar* prefix, const_xmlChar* ns_uri)
+
+ cdef xmlNodeSet* xmlXPathNodeSetCreate(tree.xmlNode* val)
+ cdef void xmlXPathFreeNodeSet(xmlNodeSet* val)
+
+
+cdef extern from "libxml/xpathInternals.h" nogil:
+ cdef int xmlXPathRegisterFunc(xmlXPathContext* ctxt,
+ const_xmlChar* name,
+ xmlXPathFunction f)
+ cdef int xmlXPathRegisterFuncNS(xmlXPathContext* ctxt,
+ const_xmlChar* name,
+ const_xmlChar* ns_uri,
+ xmlXPathFunction f)
+ cdef void xmlXPathRegisterFuncLookup(xmlXPathContext *ctxt,
+ xmlXPathFuncLookupFunc f,
+ void *funcCtxt)
+ cdef int xmlXPathRegisterVariable(xmlXPathContext *ctxt,
+ const_xmlChar* name,
+ xmlXPathObject* value)
+ cdef int xmlXPathRegisterVariableNS(xmlXPathContext *ctxt,
+ const_xmlChar* name,
+ const_xmlChar* ns_uri,
+ xmlXPathObject* value)
+ cdef void xmlXPathRegisteredVariablesCleanup(xmlXPathContext *ctxt)
+ cdef void xmlXPathRegisteredNsCleanup(xmlXPathContext *ctxt)
+ cdef xmlXPathObject* valuePop (xmlXPathParserContext *ctxt)
+ cdef int valuePush(xmlXPathParserContext* ctxt, xmlXPathObject *value)
+
+ cdef xmlXPathObject* xmlXPathNewCString(const_char *val)
+ cdef xmlXPathObject* xmlXPathWrapCString(const_char * val)
+ cdef xmlXPathObject* xmlXPathNewString(const_xmlChar *val)
+ cdef xmlXPathObject* xmlXPathWrapString(const_xmlChar * val)
+ cdef xmlXPathObject* xmlXPathNewFloat(double val)
+ cdef xmlXPathObject* xmlXPathNewBoolean(int val)
+ cdef xmlXPathObject* xmlXPathNewNodeSet(tree.xmlNode* val)
+ cdef xmlXPathObject* xmlXPathNewValueTree(tree.xmlNode* val)
+ cdef void xmlXPathNodeSetAdd(xmlNodeSet* cur,
+ tree.xmlNode* val)
+ cdef void xmlXPathNodeSetAddUnique(xmlNodeSet* cur,
+ tree.xmlNode* val)
+ cdef xmlXPathObject* xmlXPathWrapNodeSet(xmlNodeSet* val)
+ cdef void xmlXPathErr(xmlXPathParserContext* ctxt, int error)
diff --git a/llava_video/lib/python3.10/site-packages/lxml/includes/xslt.pxd b/llava_video/lib/python3.10/site-packages/lxml/includes/xslt.pxd
new file mode 100644
index 0000000000000000000000000000000000000000..abafe4325c9147e77590ff0f1647100bb5e9c56a
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/includes/xslt.pxd
@@ -0,0 +1,190 @@
+from lxml.includes.tree cimport xmlDoc, xmlNode, xmlDict, xmlChar, const_xmlChar, xmlOutputBuffer
+from lxml.includes.xmlerror cimport xmlGenericErrorFunc
+from lxml.includes.xpath cimport xmlXPathContext, xmlXPathFunction
+
+from libc.string cimport const_char
+
+cdef extern from "libxslt/xslt.h":
+ cdef int xsltLibxsltVersion
+ cdef int xsltMaxDepth
+
+cdef extern from "libxslt/xsltconfig.h":
+ cdef int LIBXSLT_VERSION
+
+cdef extern from "libxslt/xsltInternals.h" nogil:
+ ctypedef enum xsltTransformState:
+ XSLT_STATE_OK # 0
+ XSLT_STATE_ERROR # 1
+ XSLT_STATE_STOPPED # 2
+
+ ctypedef struct xsltDocument:
+ xmlDoc* doc
+
+ ctypedef struct xsltStylesheet:
+ xmlChar* encoding
+ xmlDoc* doc
+ int errors
+
+ ctypedef struct xsltTransformContext:
+ xsltStylesheet* style
+ xmlXPathContext* xpathCtxt
+ xsltDocument* document
+ void* _private
+ xmlDict* dict
+ int profile
+ xmlNode* node
+ xmlDoc* output
+ xmlNode* insert
+ xmlNode* inst
+ xsltTransformState state
+
+ ctypedef struct xsltStackElem
+
+ ctypedef struct xsltTemplate
+
+ cdef xsltStylesheet* xsltParseStylesheetDoc(xmlDoc* doc)
+ cdef void xsltFreeStylesheet(xsltStylesheet* sheet)
+
+cdef extern from "libxslt/imports.h" nogil:
+ # actually defined in "etree_defs.h"
+ cdef void LXML_GET_XSLT_ENCODING(const_xmlChar* result_var, xsltStylesheet* style)
+
+cdef extern from "libxslt/extensions.h" nogil:
+ ctypedef void (*xsltTransformFunction)(xsltTransformContext* ctxt,
+ xmlNode* context_node,
+ xmlNode* inst,
+ void* precomp_unused) noexcept
+
+ cdef int xsltRegisterExtFunction(xsltTransformContext* ctxt,
+ const_xmlChar* name,
+ const_xmlChar* URI,
+ xmlXPathFunction function)
+ cdef int xsltRegisterExtModuleFunction(const_xmlChar* name, const_xmlChar* URI,
+ xmlXPathFunction function)
+ cdef int xsltUnregisterExtModuleFunction(const_xmlChar* name, const_xmlChar* URI)
+ cdef xmlXPathFunction xsltExtModuleFunctionLookup(
+ const_xmlChar* name, const_xmlChar* URI)
+ cdef int xsltRegisterExtPrefix(xsltStylesheet* style,
+ const_xmlChar* prefix, const_xmlChar* URI)
+ cdef int xsltRegisterExtElement(xsltTransformContext* ctxt,
+ const_xmlChar* name, const_xmlChar* URI,
+ xsltTransformFunction function)
+
+cdef extern from "libxslt/documents.h" nogil:
+ ctypedef enum xsltLoadType:
+ XSLT_LOAD_START
+ XSLT_LOAD_STYLESHEET
+ XSLT_LOAD_DOCUMENT
+
+ ctypedef xmlDoc* (*xsltDocLoaderFunc)(const_xmlChar* URI, xmlDict* dict,
+ int options,
+ void* ctxt,
+ xsltLoadType type) noexcept
+ cdef xsltDocLoaderFunc xsltDocDefaultLoader
+ cdef void xsltSetLoaderFunc(xsltDocLoaderFunc f)
+
+cdef extern from "libxslt/transform.h" nogil:
+ cdef xmlDoc* xsltApplyStylesheet(xsltStylesheet* style, xmlDoc* doc,
+ const_char** params)
+ cdef xmlDoc* xsltApplyStylesheetUser(xsltStylesheet* style, xmlDoc* doc,
+ const_char** params, const_char* output,
+ void* profile,
+ xsltTransformContext* context)
+ cdef void xsltProcessOneNode(xsltTransformContext* ctxt,
+ xmlNode* contextNode,
+ xsltStackElem* params)
+ cdef xsltTransformContext* xsltNewTransformContext(xsltStylesheet* style,
+ xmlDoc* doc)
+ cdef void xsltFreeTransformContext(xsltTransformContext* context)
+ cdef void xsltApplyOneTemplate(xsltTransformContext* ctxt,
+ xmlNode* contextNode, xmlNode* list,
+ xsltTemplate* templ,
+ xsltStackElem* params)
+
+
+cdef extern from "libxslt/xsltutils.h" nogil:
+ cdef int xsltSaveResultToString(xmlChar** doc_txt_ptr,
+ int* doc_txt_len,
+ xmlDoc* result,
+ xsltStylesheet* style)
+ cdef int xsltSaveResultToFilename(const_char *URL,
+ xmlDoc* result,
+ xsltStylesheet* style,
+ int compression)
+ cdef int xsltSaveResultTo(xmlOutputBuffer* buf,
+ xmlDoc* result,
+ xsltStylesheet* style)
+ cdef xmlGenericErrorFunc xsltGenericError
+ cdef void *xsltGenericErrorContext
+ cdef void xsltSetGenericErrorFunc(
+ void* ctxt, void (*handler)(void* ctxt, char* msg, ...) nogil)
+ cdef void xsltSetTransformErrorFunc(
+ xsltTransformContext*, void* ctxt,
+ void (*handler)(void* ctxt, char* msg, ...) nogil)
+ cdef void xsltTransformError(xsltTransformContext* ctxt,
+ xsltStylesheet* style,
+ xmlNode* node, char* msg, ...)
+ cdef void xsltSetCtxtParseOptions(
+ xsltTransformContext* ctxt, int options)
+
+
+cdef extern from "libxslt/security.h" nogil:
+ ctypedef struct xsltSecurityPrefs
+ ctypedef enum xsltSecurityOption:
+ XSLT_SECPREF_READ_FILE = 1
+ XSLT_SECPREF_WRITE_FILE = 2
+ XSLT_SECPREF_CREATE_DIRECTORY = 3
+ XSLT_SECPREF_READ_NETWORK = 4
+ XSLT_SECPREF_WRITE_NETWORK = 5
+
+ ctypedef int (*xsltSecurityCheck)(xsltSecurityPrefs* sec,
+ xsltTransformContext* ctxt,
+ char* value) noexcept
+
+ cdef xsltSecurityPrefs* xsltNewSecurityPrefs()
+ cdef void xsltFreeSecurityPrefs(xsltSecurityPrefs* sec)
+ cdef int xsltSecurityForbid(xsltSecurityPrefs* sec,
+ xsltTransformContext* ctxt,
+ char* value)
+ cdef int xsltSecurityAllow(xsltSecurityPrefs* sec,
+ xsltTransformContext* ctxt,
+ char* value)
+ cdef int xsltSetSecurityPrefs(xsltSecurityPrefs* sec,
+ xsltSecurityOption option,
+ xsltSecurityCheck func)
+ cdef xsltSecurityCheck xsltGetSecurityPrefs(
+ xsltSecurityPrefs* sec,
+ xsltSecurityOption option)
+ cdef int xsltSetCtxtSecurityPrefs(xsltSecurityPrefs* sec,
+ xsltTransformContext* ctxt)
+ cdef xmlDoc* xsltGetProfileInformation(xsltTransformContext* ctxt)
+
+cdef extern from "libxslt/variables.h" nogil:
+ cdef int xsltQuoteUserParams(xsltTransformContext* ctxt,
+ const_char** params)
+ cdef int xsltQuoteOneUserParam(xsltTransformContext* ctxt,
+ const_xmlChar* name,
+ const_xmlChar* value)
+
+cdef extern from "libxslt/extra.h" nogil:
+ const_xmlChar* XSLT_LIBXSLT_NAMESPACE
+ const_xmlChar* XSLT_XALAN_NAMESPACE
+ const_xmlChar* XSLT_SAXON_NAMESPACE
+ const_xmlChar* XSLT_XT_NAMESPACE
+
+ cdef xmlXPathFunction xsltFunctionNodeSet
+ cdef void xsltRegisterAllExtras()
+
+cdef extern from "libexslt/exslt.h" nogil:
+ cdef void exsltRegisterAll()
+
+ # libexslt 1.1.25+
+ const_xmlChar* EXSLT_DATE_NAMESPACE
+ const_xmlChar* EXSLT_SETS_NAMESPACE
+ const_xmlChar* EXSLT_MATH_NAMESPACE
+ const_xmlChar* EXSLT_STRINGS_NAMESPACE
+
+ cdef int exsltDateXpathCtxtRegister(xmlXPathContext* ctxt, const_xmlChar* prefix)
+ cdef int exsltSetsXpathCtxtRegister(xmlXPathContext* ctxt, const_xmlChar* prefix)
+ cdef int exsltMathXpathCtxtRegister(xmlXPathContext* ctxt, const_xmlChar* prefix)
+ cdef int exsltStrXpathCtxtRegister(xmlXPathContext* ctxt, const_xmlChar* prefix)
diff --git a/llava_video/lib/python3.10/site-packages/lxml/iterparse.pxi b/llava_video/lib/python3.10/site-packages/lxml/iterparse.pxi
new file mode 100644
index 0000000000000000000000000000000000000000..42b7524998f8633ae4ba8014314b0c9ad5d30628
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/iterparse.pxi
@@ -0,0 +1,438 @@
+# 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 for XML, ignored otherwise)
+ - 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,
+ 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
diff --git a/llava_video/lib/python3.10/site-packages/lxml/lxml.etree.h b/llava_video/lib/python3.10/site-packages/lxml/lxml.etree.h
new file mode 100644
index 0000000000000000000000000000000000000000..c2a0f5abcb17cebffb5678c0b5d3101583fa831c
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/lxml.etree.h
@@ -0,0 +1,248 @@
+/* Generated by Cython 3.0.11 */
+
+#ifndef __PYX_HAVE__lxml__etree
+#define __PYX_HAVE__lxml__etree
+
+#include "Python.h"
+struct LxmlDocument;
+struct LxmlElement;
+struct LxmlElementTree;
+struct LxmlElementTagMatcher;
+struct LxmlElementIterator;
+struct LxmlElementBase;
+struct LxmlElementClassLookup;
+struct LxmlFallbackElementClassLookup;
+
+/* "lxml/etree.pyx":355
+ *
+ * # type of a function that steps from node to node
+ * ctypedef public xmlNode* (*_node_to_node_function)(xmlNode*) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+typedef xmlNode *(*_node_to_node_function)(xmlNode *);
+
+/* "lxml/etree.pyx":371
+ * @cython.final
+ * @cython.freelist(8)
+ * cdef public class _Document [ type LxmlDocumentType, object LxmlDocument ]: # <<<<<<<<<<<<<<
+ * """Internal base class to reference a libxml document.
+ *
+ */
+struct LxmlDocument {
+ PyObject_HEAD
+ struct __pyx_vtabstruct_4lxml_5etree__Document *__pyx_vtab;
+ int _ns_counter;
+ PyObject *_prefix_tail;
+ xmlDoc *_c_doc;
+ struct __pyx_obj_4lxml_5etree__BaseParser *_parser;
+};
+
+/* "lxml/etree.pyx":720
+ *
+ * @cython.no_gc_clear
+ * cdef public class _Element [ type LxmlElementType, object LxmlElement ]: # <<<<<<<<<<<<<<
+ * """Element class.
+ *
+ */
+struct LxmlElement {
+ PyObject_HEAD
+ struct LxmlDocument *_doc;
+ xmlNode *_c_node;
+ PyObject *_tag;
+};
+
+/* "lxml/etree.pyx":1895
+ *
+ *
+ * cdef public class _ElementTree [ type LxmlElementTreeType, # <<<<<<<<<<<<<<
+ * object LxmlElementTree ]:
+ * cdef _Document _doc
+ */
+struct LxmlElementTree {
+ PyObject_HEAD
+ struct __pyx_vtabstruct_4lxml_5etree__ElementTree *__pyx_vtab;
+ struct LxmlDocument *_doc;
+ struct LxmlElement *_context_node;
+};
+
+/* "lxml/etree.pyx":2669
+ *
+ *
+ * cdef public class _ElementTagMatcher [ object LxmlElementTagMatcher, # <<<<<<<<<<<<<<
+ * type LxmlElementTagMatcherType ]:
+ * """
+ */
+struct LxmlElementTagMatcher {
+ PyObject_HEAD
+ struct __pyx_vtabstruct_4lxml_5etree__ElementTagMatcher *__pyx_vtab;
+ PyObject *_pystrings;
+ int _node_type;
+ char *_href;
+ char *_name;
+};
+
+/* "lxml/etree.pyx":2700
+ * self._name = NULL
+ *
+ * cdef public class _ElementIterator(_ElementTagMatcher) [ # <<<<<<<<<<<<<<
+ * object LxmlElementIterator, type LxmlElementIteratorType ]:
+ * """
+ */
+struct LxmlElementIterator {
+ struct LxmlElementTagMatcher __pyx_base;
+ struct LxmlElement *_node;
+ _node_to_node_function _next_element;
+};
+
+/* "src/lxml/classlookup.pxi":6
+ * # Custom Element classes
+ *
+ * cdef public class ElementBase(_Element) [ type LxmlElementBaseType, # <<<<<<<<<<<<<<
+ * object LxmlElementBase ]:
+ * """ElementBase(*children, attrib=None, nsmap=None, **_extra)
+ */
+struct LxmlElementBase {
+ struct LxmlElement __pyx_base;
+};
+
+/* "src/lxml/classlookup.pxi":210
+ * # Element class lookup
+ *
+ * ctypedef public object (*_element_class_lookup_function)(object, _Document, xmlNode*) # <<<<<<<<<<<<<<
+ *
+ * # class to store element class lookup functions
+ */
+typedef PyObject *(*_element_class_lookup_function)(PyObject *, struct LxmlDocument *, xmlNode *);
+
+/* "src/lxml/classlookup.pxi":213
+ *
+ * # class to store element class lookup functions
+ * cdef public class ElementClassLookup [ type LxmlElementClassLookupType, # <<<<<<<<<<<<<<
+ * object LxmlElementClassLookup ]:
+ * """ElementClassLookup(self)
+ */
+struct LxmlElementClassLookup {
+ PyObject_HEAD
+ _element_class_lookup_function _lookup_function;
+};
+
+/* "src/lxml/classlookup.pxi":221
+ *
+ *
+ * cdef public class FallbackElementClassLookup(ElementClassLookup) \ # <<<<<<<<<<<<<<
+ * [ type LxmlFallbackElementClassLookupType,
+ * object LxmlFallbackElementClassLookup ]:
+ */
+struct LxmlFallbackElementClassLookup {
+ struct LxmlElementClassLookup __pyx_base;
+ struct __pyx_vtabstruct_4lxml_5etree_FallbackElementClassLookup *__pyx_vtab;
+ struct LxmlElementClassLookup *fallback;
+ _element_class_lookup_function _fallback_function;
+};
+
+#ifndef __PYX_HAVE_API__lxml__etree
+
+#ifdef CYTHON_EXTERN_C
+ #undef __PYX_EXTERN_C
+ #define __PYX_EXTERN_C CYTHON_EXTERN_C
+#elif defined(__PYX_EXTERN_C)
+ #ifdef _MSC_VER
+ #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.")
+ #else
+ #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.
+ #endif
+#else
+ #ifdef __cplusplus
+ #define __PYX_EXTERN_C extern "C"
+ #else
+ #define __PYX_EXTERN_C extern
+ #endif
+#endif
+
+#ifndef DL_IMPORT
+ #define DL_IMPORT(_T) _T
+#endif
+
+__PYX_EXTERN_C DL_IMPORT(PyTypeObject) LxmlDocumentType;
+__PYX_EXTERN_C DL_IMPORT(PyTypeObject) LxmlElementType;
+__PYX_EXTERN_C DL_IMPORT(PyTypeObject) LxmlElementTreeType;
+__PYX_EXTERN_C DL_IMPORT(PyTypeObject) LxmlElementTagMatcherType;
+__PYX_EXTERN_C DL_IMPORT(PyTypeObject) LxmlElementIteratorType;
+__PYX_EXTERN_C DL_IMPORT(PyTypeObject) LxmlElementBaseType;
+__PYX_EXTERN_C DL_IMPORT(PyTypeObject) LxmlElementClassLookupType;
+__PYX_EXTERN_C DL_IMPORT(PyTypeObject) LxmlFallbackElementClassLookupType;
+
+__PYX_EXTERN_C struct LxmlElement *deepcopyNodeToDocument(struct LxmlDocument *, xmlNode *);
+__PYX_EXTERN_C struct LxmlElementTree *elementTreeFactory(struct LxmlElement *);
+__PYX_EXTERN_C struct LxmlElementTree *newElementTree(struct LxmlElement *, PyObject *);
+__PYX_EXTERN_C struct LxmlElementTree *adoptExternalDocument(xmlDoc *, PyObject *, int);
+__PYX_EXTERN_C struct LxmlElement *elementFactory(struct LxmlDocument *, xmlNode *);
+__PYX_EXTERN_C struct LxmlElement *makeElement(PyObject *, struct LxmlDocument *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *);
+__PYX_EXTERN_C struct LxmlElement *makeSubElement(struct LxmlElement *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *);
+__PYX_EXTERN_C void setElementClassLookupFunction(_element_class_lookup_function, PyObject *);
+__PYX_EXTERN_C PyObject *lookupDefaultElementClass(PyObject *, PyObject *, xmlNode *);
+__PYX_EXTERN_C PyObject *lookupNamespaceElementClass(PyObject *, PyObject *, xmlNode *);
+__PYX_EXTERN_C PyObject *callLookupFallback(struct LxmlFallbackElementClassLookup *, struct LxmlDocument *, xmlNode *);
+__PYX_EXTERN_C int tagMatches(xmlNode *, const xmlChar *, const xmlChar *);
+__PYX_EXTERN_C struct LxmlDocument *documentOrRaise(PyObject *);
+__PYX_EXTERN_C struct LxmlElement *rootNodeOrRaise(PyObject *);
+__PYX_EXTERN_C int hasText(xmlNode *);
+__PYX_EXTERN_C int hasTail(xmlNode *);
+__PYX_EXTERN_C PyObject *textOf(xmlNode *);
+__PYX_EXTERN_C PyObject *tailOf(xmlNode *);
+__PYX_EXTERN_C int setNodeText(xmlNode *, PyObject *);
+__PYX_EXTERN_C int setTailText(xmlNode *, PyObject *);
+__PYX_EXTERN_C PyObject *attributeValue(xmlNode *, xmlAttr *);
+__PYX_EXTERN_C PyObject *attributeValueFromNsName(xmlNode *, const xmlChar *, const xmlChar *);
+__PYX_EXTERN_C PyObject *getAttributeValue(struct LxmlElement *, PyObject *, PyObject *);
+__PYX_EXTERN_C PyObject *iterattributes(struct LxmlElement *, int);
+__PYX_EXTERN_C PyObject *collectAttributes(xmlNode *, int);
+__PYX_EXTERN_C int setAttributeValue(struct LxmlElement *, PyObject *, PyObject *);
+__PYX_EXTERN_C int delAttribute(struct LxmlElement *, PyObject *);
+__PYX_EXTERN_C int delAttributeFromNsName(xmlNode *, const xmlChar *, const xmlChar *);
+__PYX_EXTERN_C int hasChild(xmlNode *);
+__PYX_EXTERN_C xmlNode *findChild(xmlNode *, Py_ssize_t);
+__PYX_EXTERN_C xmlNode *findChildForwards(xmlNode *, Py_ssize_t);
+__PYX_EXTERN_C xmlNode *findChildBackwards(xmlNode *, Py_ssize_t);
+__PYX_EXTERN_C xmlNode *nextElement(xmlNode *);
+__PYX_EXTERN_C xmlNode *previousElement(xmlNode *);
+__PYX_EXTERN_C void appendChild(struct LxmlElement *, struct LxmlElement *);
+__PYX_EXTERN_C int appendChildToElement(struct LxmlElement *, struct LxmlElement *);
+__PYX_EXTERN_C PyObject *pyunicode(const xmlChar *);
+__PYX_EXTERN_C PyObject *utf8(PyObject *);
+__PYX_EXTERN_C PyObject *getNsTag(PyObject *);
+__PYX_EXTERN_C PyObject *getNsTagWithEmptyNs(PyObject *);
+__PYX_EXTERN_C PyObject *namespacedName(xmlNode *);
+__PYX_EXTERN_C PyObject *namespacedNameFromNsName(const xmlChar *, const xmlChar *);
+__PYX_EXTERN_C void iteratorStoreNext(struct LxmlElementIterator *, struct LxmlElement *);
+__PYX_EXTERN_C void initTagMatch(struct LxmlElementTagMatcher *, PyObject *);
+__PYX_EXTERN_C xmlNs *findOrBuildNodeNsPrefix(struct LxmlDocument *, xmlNode *, const xmlChar *, const xmlChar *);
+
+#endif /* !__PYX_HAVE_API__lxml__etree */
+
+/* WARNING: the interface of the module init function changed in CPython 3.5. */
+/* It now returns a PyModuleDef instance instead of a PyModule instance. */
+
+#if PY_MAJOR_VERSION < 3
+PyMODINIT_FUNC initetree(void);
+#else
+/* WARNING: Use PyImport_AppendInittab("etree", PyInit_etree) instead of calling PyInit_etree directly from Python 3.5 */
+PyMODINIT_FUNC PyInit_etree(void);
+
+#if PY_VERSION_HEX >= 0x03050000 && (defined(__GNUC__) || defined(__clang__) || defined(_MSC_VER) || (defined(__cplusplus) && __cplusplus >= 201402L))
+#if defined(__cplusplus) && __cplusplus >= 201402L
+[[deprecated("Use PyImport_AppendInittab(\"etree\", PyInit_etree) instead of calling PyInit_etree directly.")]] inline
+#elif defined(__GNUC__) || defined(__clang__)
+__attribute__ ((__deprecated__("Use PyImport_AppendInittab(\"etree\", PyInit_etree) instead of calling PyInit_etree directly."), __unused__)) __inline__
+#elif defined(_MSC_VER)
+__declspec(deprecated("Use PyImport_AppendInittab(\"etree\", PyInit_etree) instead of calling PyInit_etree directly.")) __inline
+#endif
+static PyObject* __PYX_WARN_IF_PyInit_etree_INIT_CALLED(PyObject* res) {
+ return res;
+}
+#define PyInit_etree() __PYX_WARN_IF_PyInit_etree_INIT_CALLED(PyInit_etree())
+#endif
+#endif
+
+#endif /* !__PYX_HAVE__lxml__etree */
diff --git a/llava_video/lib/python3.10/site-packages/lxml/lxml.etree_api.h b/llava_video/lib/python3.10/site-packages/lxml/lxml.etree_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..ff0ca50c7682fe506fa7a47d1374a053f93dfd6d
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/lxml.etree_api.h
@@ -0,0 +1,195 @@
+/* Generated by Cython 3.0.11 */
+
+#ifndef __PYX_HAVE_API__lxml__etree
+#define __PYX_HAVE_API__lxml__etree
+#ifdef __MINGW64__
+#define MS_WIN64
+#endif
+#include "Python.h"
+#include "lxml.etree.h"
+
+static struct LxmlElement *(*__pyx_api_f_4lxml_5etree_deepcopyNodeToDocument)(struct LxmlDocument *, xmlNode *) = 0;
+#define deepcopyNodeToDocument __pyx_api_f_4lxml_5etree_deepcopyNodeToDocument
+static struct LxmlElementTree *(*__pyx_api_f_4lxml_5etree_elementTreeFactory)(struct LxmlElement *) = 0;
+#define elementTreeFactory __pyx_api_f_4lxml_5etree_elementTreeFactory
+static struct LxmlElementTree *(*__pyx_api_f_4lxml_5etree_newElementTree)(struct LxmlElement *, PyObject *) = 0;
+#define newElementTree __pyx_api_f_4lxml_5etree_newElementTree
+static struct LxmlElementTree *(*__pyx_api_f_4lxml_5etree_adoptExternalDocument)(xmlDoc *, PyObject *, int) = 0;
+#define adoptExternalDocument __pyx_api_f_4lxml_5etree_adoptExternalDocument
+static struct LxmlElement *(*__pyx_api_f_4lxml_5etree_elementFactory)(struct LxmlDocument *, xmlNode *) = 0;
+#define elementFactory __pyx_api_f_4lxml_5etree_elementFactory
+static struct LxmlElement *(*__pyx_api_f_4lxml_5etree_makeElement)(PyObject *, struct LxmlDocument *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *) = 0;
+#define makeElement __pyx_api_f_4lxml_5etree_makeElement
+static struct LxmlElement *(*__pyx_api_f_4lxml_5etree_makeSubElement)(struct LxmlElement *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *) = 0;
+#define makeSubElement __pyx_api_f_4lxml_5etree_makeSubElement
+static void (*__pyx_api_f_4lxml_5etree_setElementClassLookupFunction)(_element_class_lookup_function, PyObject *) = 0;
+#define setElementClassLookupFunction __pyx_api_f_4lxml_5etree_setElementClassLookupFunction
+static PyObject *(*__pyx_api_f_4lxml_5etree_lookupDefaultElementClass)(PyObject *, PyObject *, xmlNode *) = 0;
+#define lookupDefaultElementClass __pyx_api_f_4lxml_5etree_lookupDefaultElementClass
+static PyObject *(*__pyx_api_f_4lxml_5etree_lookupNamespaceElementClass)(PyObject *, PyObject *, xmlNode *) = 0;
+#define lookupNamespaceElementClass __pyx_api_f_4lxml_5etree_lookupNamespaceElementClass
+static PyObject *(*__pyx_api_f_4lxml_5etree_callLookupFallback)(struct LxmlFallbackElementClassLookup *, struct LxmlDocument *, xmlNode *) = 0;
+#define callLookupFallback __pyx_api_f_4lxml_5etree_callLookupFallback
+static int (*__pyx_api_f_4lxml_5etree_tagMatches)(xmlNode *, const xmlChar *, const xmlChar *) = 0;
+#define tagMatches __pyx_api_f_4lxml_5etree_tagMatches
+static struct LxmlDocument *(*__pyx_api_f_4lxml_5etree_documentOrRaise)(PyObject *) = 0;
+#define documentOrRaise __pyx_api_f_4lxml_5etree_documentOrRaise
+static struct LxmlElement *(*__pyx_api_f_4lxml_5etree_rootNodeOrRaise)(PyObject *) = 0;
+#define rootNodeOrRaise __pyx_api_f_4lxml_5etree_rootNodeOrRaise
+static int (*__pyx_api_f_4lxml_5etree_hasText)(xmlNode *) = 0;
+#define hasText __pyx_api_f_4lxml_5etree_hasText
+static int (*__pyx_api_f_4lxml_5etree_hasTail)(xmlNode *) = 0;
+#define hasTail __pyx_api_f_4lxml_5etree_hasTail
+static PyObject *(*__pyx_api_f_4lxml_5etree_textOf)(xmlNode *) = 0;
+#define textOf __pyx_api_f_4lxml_5etree_textOf
+static PyObject *(*__pyx_api_f_4lxml_5etree_tailOf)(xmlNode *) = 0;
+#define tailOf __pyx_api_f_4lxml_5etree_tailOf
+static int (*__pyx_api_f_4lxml_5etree_setNodeText)(xmlNode *, PyObject *) = 0;
+#define setNodeText __pyx_api_f_4lxml_5etree_setNodeText
+static int (*__pyx_api_f_4lxml_5etree_setTailText)(xmlNode *, PyObject *) = 0;
+#define setTailText __pyx_api_f_4lxml_5etree_setTailText
+static PyObject *(*__pyx_api_f_4lxml_5etree_attributeValue)(xmlNode *, xmlAttr *) = 0;
+#define attributeValue __pyx_api_f_4lxml_5etree_attributeValue
+static PyObject *(*__pyx_api_f_4lxml_5etree_attributeValueFromNsName)(xmlNode *, const xmlChar *, const xmlChar *) = 0;
+#define attributeValueFromNsName __pyx_api_f_4lxml_5etree_attributeValueFromNsName
+static PyObject *(*__pyx_api_f_4lxml_5etree_getAttributeValue)(struct LxmlElement *, PyObject *, PyObject *) = 0;
+#define getAttributeValue __pyx_api_f_4lxml_5etree_getAttributeValue
+static PyObject *(*__pyx_api_f_4lxml_5etree_iterattributes)(struct LxmlElement *, int) = 0;
+#define iterattributes __pyx_api_f_4lxml_5etree_iterattributes
+static PyObject *(*__pyx_api_f_4lxml_5etree_collectAttributes)(xmlNode *, int) = 0;
+#define collectAttributes __pyx_api_f_4lxml_5etree_collectAttributes
+static int (*__pyx_api_f_4lxml_5etree_setAttributeValue)(struct LxmlElement *, PyObject *, PyObject *) = 0;
+#define setAttributeValue __pyx_api_f_4lxml_5etree_setAttributeValue
+static int (*__pyx_api_f_4lxml_5etree_delAttribute)(struct LxmlElement *, PyObject *) = 0;
+#define delAttribute __pyx_api_f_4lxml_5etree_delAttribute
+static int (*__pyx_api_f_4lxml_5etree_delAttributeFromNsName)(xmlNode *, const xmlChar *, const xmlChar *) = 0;
+#define delAttributeFromNsName __pyx_api_f_4lxml_5etree_delAttributeFromNsName
+static int (*__pyx_api_f_4lxml_5etree_hasChild)(xmlNode *) = 0;
+#define hasChild __pyx_api_f_4lxml_5etree_hasChild
+static xmlNode *(*__pyx_api_f_4lxml_5etree_findChild)(xmlNode *, Py_ssize_t) = 0;
+#define findChild __pyx_api_f_4lxml_5etree_findChild
+static xmlNode *(*__pyx_api_f_4lxml_5etree_findChildForwards)(xmlNode *, Py_ssize_t) = 0;
+#define findChildForwards __pyx_api_f_4lxml_5etree_findChildForwards
+static xmlNode *(*__pyx_api_f_4lxml_5etree_findChildBackwards)(xmlNode *, Py_ssize_t) = 0;
+#define findChildBackwards __pyx_api_f_4lxml_5etree_findChildBackwards
+static xmlNode *(*__pyx_api_f_4lxml_5etree_nextElement)(xmlNode *) = 0;
+#define nextElement __pyx_api_f_4lxml_5etree_nextElement
+static xmlNode *(*__pyx_api_f_4lxml_5etree_previousElement)(xmlNode *) = 0;
+#define previousElement __pyx_api_f_4lxml_5etree_previousElement
+static void (*__pyx_api_f_4lxml_5etree_appendChild)(struct LxmlElement *, struct LxmlElement *) = 0;
+#define appendChild __pyx_api_f_4lxml_5etree_appendChild
+static int (*__pyx_api_f_4lxml_5etree_appendChildToElement)(struct LxmlElement *, struct LxmlElement *) = 0;
+#define appendChildToElement __pyx_api_f_4lxml_5etree_appendChildToElement
+static PyObject *(*__pyx_api_f_4lxml_5etree_pyunicode)(const xmlChar *) = 0;
+#define pyunicode __pyx_api_f_4lxml_5etree_pyunicode
+static PyObject *(*__pyx_api_f_4lxml_5etree_utf8)(PyObject *) = 0;
+#define utf8 __pyx_api_f_4lxml_5etree_utf8
+static PyObject *(*__pyx_api_f_4lxml_5etree_getNsTag)(PyObject *) = 0;
+#define getNsTag __pyx_api_f_4lxml_5etree_getNsTag
+static PyObject *(*__pyx_api_f_4lxml_5etree_getNsTagWithEmptyNs)(PyObject *) = 0;
+#define getNsTagWithEmptyNs __pyx_api_f_4lxml_5etree_getNsTagWithEmptyNs
+static PyObject *(*__pyx_api_f_4lxml_5etree_namespacedName)(xmlNode *) = 0;
+#define namespacedName __pyx_api_f_4lxml_5etree_namespacedName
+static PyObject *(*__pyx_api_f_4lxml_5etree_namespacedNameFromNsName)(const xmlChar *, const xmlChar *) = 0;
+#define namespacedNameFromNsName __pyx_api_f_4lxml_5etree_namespacedNameFromNsName
+static void (*__pyx_api_f_4lxml_5etree_iteratorStoreNext)(struct LxmlElementIterator *, struct LxmlElement *) = 0;
+#define iteratorStoreNext __pyx_api_f_4lxml_5etree_iteratorStoreNext
+static void (*__pyx_api_f_4lxml_5etree_initTagMatch)(struct LxmlElementTagMatcher *, PyObject *) = 0;
+#define initTagMatch __pyx_api_f_4lxml_5etree_initTagMatch
+static xmlNs *(*__pyx_api_f_4lxml_5etree_findOrBuildNodeNsPrefix)(struct LxmlDocument *, xmlNode *, const xmlChar *, const xmlChar *) = 0;
+#define findOrBuildNodeNsPrefix __pyx_api_f_4lxml_5etree_findOrBuildNodeNsPrefix
+#ifndef __PYX_HAVE_RT_ImportFunction_3_0_11
+#define __PYX_HAVE_RT_ImportFunction_3_0_11
+static int __Pyx_ImportFunction_3_0_11(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
+ PyObject *d = 0;
+ PyObject *cobj = 0;
+ union {
+ void (*fp)(void);
+ void *p;
+ } tmp;
+ d = PyObject_GetAttrString(module, (char *)"__pyx_capi__");
+ if (!d)
+ goto bad;
+ cobj = PyDict_GetItemString(d, funcname);
+ if (!cobj) {
+ PyErr_Format(PyExc_ImportError,
+ "%.200s does not export expected C function %.200s",
+ PyModule_GetName(module), funcname);
+ goto bad;
+ }
+ if (!PyCapsule_IsValid(cobj, sig)) {
+ PyErr_Format(PyExc_TypeError,
+ "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
+ PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj));
+ goto bad;
+ }
+ tmp.p = PyCapsule_GetPointer(cobj, sig);
+ *f = tmp.fp;
+ if (!(*f))
+ goto bad;
+ Py_DECREF(d);
+ return 0;
+bad:
+ Py_XDECREF(d);
+ return -1;
+}
+#endif
+
+
+static int import_lxml__etree(void) {
+ PyObject *module = 0;
+ module = PyImport_ImportModule("lxml.etree");
+ if (!module) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "deepcopyNodeToDocument", (void (**)(void))&__pyx_api_f_4lxml_5etree_deepcopyNodeToDocument, "struct LxmlElement *(struct LxmlDocument *, xmlNode *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "elementTreeFactory", (void (**)(void))&__pyx_api_f_4lxml_5etree_elementTreeFactory, "struct LxmlElementTree *(struct LxmlElement *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "newElementTree", (void (**)(void))&__pyx_api_f_4lxml_5etree_newElementTree, "struct LxmlElementTree *(struct LxmlElement *, PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "adoptExternalDocument", (void (**)(void))&__pyx_api_f_4lxml_5etree_adoptExternalDocument, "struct LxmlElementTree *(xmlDoc *, PyObject *, int)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "elementFactory", (void (**)(void))&__pyx_api_f_4lxml_5etree_elementFactory, "struct LxmlElement *(struct LxmlDocument *, xmlNode *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "makeElement", (void (**)(void))&__pyx_api_f_4lxml_5etree_makeElement, "struct LxmlElement *(PyObject *, struct LxmlDocument *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "makeSubElement", (void (**)(void))&__pyx_api_f_4lxml_5etree_makeSubElement, "struct LxmlElement *(struct LxmlElement *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "setElementClassLookupFunction", (void (**)(void))&__pyx_api_f_4lxml_5etree_setElementClassLookupFunction, "void (_element_class_lookup_function, PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "lookupDefaultElementClass", (void (**)(void))&__pyx_api_f_4lxml_5etree_lookupDefaultElementClass, "PyObject *(PyObject *, PyObject *, xmlNode *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "lookupNamespaceElementClass", (void (**)(void))&__pyx_api_f_4lxml_5etree_lookupNamespaceElementClass, "PyObject *(PyObject *, PyObject *, xmlNode *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "callLookupFallback", (void (**)(void))&__pyx_api_f_4lxml_5etree_callLookupFallback, "PyObject *(struct LxmlFallbackElementClassLookup *, struct LxmlDocument *, xmlNode *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "tagMatches", (void (**)(void))&__pyx_api_f_4lxml_5etree_tagMatches, "int (xmlNode *, const xmlChar *, const xmlChar *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "documentOrRaise", (void (**)(void))&__pyx_api_f_4lxml_5etree_documentOrRaise, "struct LxmlDocument *(PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "rootNodeOrRaise", (void (**)(void))&__pyx_api_f_4lxml_5etree_rootNodeOrRaise, "struct LxmlElement *(PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "hasText", (void (**)(void))&__pyx_api_f_4lxml_5etree_hasText, "int (xmlNode *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "hasTail", (void (**)(void))&__pyx_api_f_4lxml_5etree_hasTail, "int (xmlNode *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "textOf", (void (**)(void))&__pyx_api_f_4lxml_5etree_textOf, "PyObject *(xmlNode *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "tailOf", (void (**)(void))&__pyx_api_f_4lxml_5etree_tailOf, "PyObject *(xmlNode *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "setNodeText", (void (**)(void))&__pyx_api_f_4lxml_5etree_setNodeText, "int (xmlNode *, PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "setTailText", (void (**)(void))&__pyx_api_f_4lxml_5etree_setTailText, "int (xmlNode *, PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "attributeValue", (void (**)(void))&__pyx_api_f_4lxml_5etree_attributeValue, "PyObject *(xmlNode *, xmlAttr *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "attributeValueFromNsName", (void (**)(void))&__pyx_api_f_4lxml_5etree_attributeValueFromNsName, "PyObject *(xmlNode *, const xmlChar *, const xmlChar *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "getAttributeValue", (void (**)(void))&__pyx_api_f_4lxml_5etree_getAttributeValue, "PyObject *(struct LxmlElement *, PyObject *, PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "iterattributes", (void (**)(void))&__pyx_api_f_4lxml_5etree_iterattributes, "PyObject *(struct LxmlElement *, int)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "collectAttributes", (void (**)(void))&__pyx_api_f_4lxml_5etree_collectAttributes, "PyObject *(xmlNode *, int)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "setAttributeValue", (void (**)(void))&__pyx_api_f_4lxml_5etree_setAttributeValue, "int (struct LxmlElement *, PyObject *, PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "delAttribute", (void (**)(void))&__pyx_api_f_4lxml_5etree_delAttribute, "int (struct LxmlElement *, PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "delAttributeFromNsName", (void (**)(void))&__pyx_api_f_4lxml_5etree_delAttributeFromNsName, "int (xmlNode *, const xmlChar *, const xmlChar *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "hasChild", (void (**)(void))&__pyx_api_f_4lxml_5etree_hasChild, "int (xmlNode *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "findChild", (void (**)(void))&__pyx_api_f_4lxml_5etree_findChild, "xmlNode *(xmlNode *, Py_ssize_t)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "findChildForwards", (void (**)(void))&__pyx_api_f_4lxml_5etree_findChildForwards, "xmlNode *(xmlNode *, Py_ssize_t)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "findChildBackwards", (void (**)(void))&__pyx_api_f_4lxml_5etree_findChildBackwards, "xmlNode *(xmlNode *, Py_ssize_t)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "nextElement", (void (**)(void))&__pyx_api_f_4lxml_5etree_nextElement, "xmlNode *(xmlNode *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "previousElement", (void (**)(void))&__pyx_api_f_4lxml_5etree_previousElement, "xmlNode *(xmlNode *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "appendChild", (void (**)(void))&__pyx_api_f_4lxml_5etree_appendChild, "void (struct LxmlElement *, struct LxmlElement *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "appendChildToElement", (void (**)(void))&__pyx_api_f_4lxml_5etree_appendChildToElement, "int (struct LxmlElement *, struct LxmlElement *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "pyunicode", (void (**)(void))&__pyx_api_f_4lxml_5etree_pyunicode, "PyObject *(const xmlChar *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "utf8", (void (**)(void))&__pyx_api_f_4lxml_5etree_utf8, "PyObject *(PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "getNsTag", (void (**)(void))&__pyx_api_f_4lxml_5etree_getNsTag, "PyObject *(PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "getNsTagWithEmptyNs", (void (**)(void))&__pyx_api_f_4lxml_5etree_getNsTagWithEmptyNs, "PyObject *(PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "namespacedName", (void (**)(void))&__pyx_api_f_4lxml_5etree_namespacedName, "PyObject *(xmlNode *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "namespacedNameFromNsName", (void (**)(void))&__pyx_api_f_4lxml_5etree_namespacedNameFromNsName, "PyObject *(const xmlChar *, const xmlChar *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "iteratorStoreNext", (void (**)(void))&__pyx_api_f_4lxml_5etree_iteratorStoreNext, "void (struct LxmlElementIterator *, struct LxmlElement *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "initTagMatch", (void (**)(void))&__pyx_api_f_4lxml_5etree_initTagMatch, "void (struct LxmlElementTagMatcher *, PyObject *)") < 0) goto bad;
+ if (__Pyx_ImportFunction_3_0_11(module, "findOrBuildNodeNsPrefix", (void (**)(void))&__pyx_api_f_4lxml_5etree_findOrBuildNodeNsPrefix, "xmlNs *(struct LxmlDocument *, xmlNode *, const xmlChar *, const xmlChar *)") < 0) goto bad;
+ Py_DECREF(module); module = 0;
+ return 0;
+ bad:
+ Py_XDECREF(module);
+ return -1;
+}
+
+#endif /* !__PYX_HAVE_API__lxml__etree */
diff --git a/llava_video/lib/python3.10/site-packages/lxml/nsclasses.pxi b/llava_video/lib/python3.10/site-packages/lxml/nsclasses.pxi
new file mode 100644
index 0000000000000000000000000000000000000000..a3c86f0e0140557c0f3f2c5a2557dab1c62bfe3c
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/nsclasses.pxi
@@ -0,0 +1,281 @@
+# module-level API for namespace implementations
+
+cdef class LxmlRegistryError(LxmlError):
+ """Base class of lxml registry errors.
+ """
+
+cdef class NamespaceRegistryError(LxmlRegistryError):
+ """Error registering a namespace extension.
+ """
+
+
+@cython.internal
+cdef class _NamespaceRegistry:
+ "Dictionary-like namespace registry"
+ cdef object _ns_uri
+ cdef bytes _ns_uri_utf
+ cdef dict _entries
+ cdef char* _c_ns_uri_utf
+ def __cinit__(self, ns_uri):
+ self._ns_uri = ns_uri
+ if ns_uri is None:
+ self._ns_uri_utf = None
+ self._c_ns_uri_utf = NULL
+ else:
+ self._ns_uri_utf = _utf8(ns_uri)
+ self._c_ns_uri_utf = _cstr(self._ns_uri_utf)
+ self._entries = {}
+
+ def update(self, class_dict_iterable):
+ """update(self, class_dict_iterable)
+
+ Forgivingly update the registry.
+
+ ``class_dict_iterable`` may be a dict or some other iterable
+ that yields (name, value) pairs.
+
+ If a value does not match the required type for this registry,
+ or if the name starts with '_', it will be silently discarded.
+ This allows registrations at the module or class level using
+ vars(), globals() etc."""
+ if hasattr(class_dict_iterable, 'items'):
+ class_dict_iterable = class_dict_iterable.items()
+ for name, item in class_dict_iterable:
+ if (name is None or name[:1] != '_') and callable(item):
+ self[name] = item
+
+ def __getitem__(self, name):
+ if name is not None:
+ name = _utf8(name)
+ return self._get(name)
+
+ def __delitem__(self, name):
+ if name is not None:
+ name = _utf8(name)
+ del self._entries[name]
+
+ cdef object _get(self, object name):
+ cdef python.PyObject* dict_result
+ dict_result = python.PyDict_GetItem(self._entries, name)
+ if dict_result is NULL:
+ raise KeyError, "Name not registered."
+ return dict_result
+
+ cdef object _getForString(self, char* name):
+ cdef python.PyObject* dict_result
+ dict_result = python.PyDict_GetItem(self._entries, name)
+ if dict_result is NULL:
+ raise KeyError, "Name not registered."
+ return dict_result
+
+ def __iter__(self):
+ return iter(self._entries)
+
+ def items(self):
+ return list(self._entries.items())
+
+ def iteritems(self):
+ return iter(self._entries.items())
+
+ def clear(self):
+ self._entries.clear()
+
+ def __call__(self, obj):
+ # Usage as decorator:
+ # ns = lookup.get_namespace("...")
+ # @ns('abc')
+ # class element(ElementBase): pass
+ #
+ # @ns
+ # class elementname(ElementBase): pass
+
+ if obj is None or python._isString(obj):
+ # @ns(None) or @ns('tag')
+ return partial(self.__deco, obj)
+ # plain @ns decorator
+ self[obj.__name__] = obj
+ return obj
+
+ def __deco(self, name, obj):
+ self[name] = obj
+ return obj
+
+
+@cython.final
+@cython.internal
+cdef class _ClassNamespaceRegistry(_NamespaceRegistry):
+ "Dictionary-like registry for namespace implementation classes"
+ def __setitem__(self, name, item):
+ if not isinstance(item, type) or not issubclass(item, ElementBase):
+ raise NamespaceRegistryError, \
+ "Registered element classes must be subtypes of ElementBase"
+ if name is not None:
+ name = _utf8(name)
+ self._entries[name] = item
+
+ def __repr__(self):
+ return "Namespace(%r)" % self._ns_uri
+
+
+cdef class ElementNamespaceClassLookup(FallbackElementClassLookup):
+ """ElementNamespaceClassLookup(self, fallback=None)
+
+ Element class lookup scheme that searches the Element class in the
+ Namespace registry.
+
+ Usage:
+
+ >>> lookup = ElementNamespaceClassLookup()
+ >>> ns_elements = lookup.get_namespace("http://schema.org/Movie")
+
+ >>> @ns_elements
+ ... class movie(ElementBase):
+ ... "Element implementation for 'movie' tag (using class name) in schema namespace."
+
+ >>> @ns_elements("movie")
+ ... class MovieElement(ElementBase):
+ ... "Element implementation for 'movie' tag (explicit tag name) in schema namespace."
+ """
+ cdef dict _namespace_registries
+ def __cinit__(self):
+ self._namespace_registries = {}
+
+ def __init__(self, ElementClassLookup fallback=None):
+ FallbackElementClassLookup.__init__(self, fallback)
+ self._lookup_function = _find_nselement_class
+
+ def get_namespace(self, ns_uri):
+ """get_namespace(self, ns_uri)
+
+ Retrieve the namespace object associated with the given URI.
+ Pass None for the empty namespace.
+
+ Creates a new namespace object if it does not yet exist."""
+ if ns_uri:
+ ns_utf = _utf8(ns_uri)
+ else:
+ ns_utf = None
+ try:
+ return self._namespace_registries[ns_utf]
+ except KeyError:
+ registry = self._namespace_registries[ns_utf] = \
+ _ClassNamespaceRegistry(ns_uri)
+ return registry
+
+cdef object _find_nselement_class(state, _Document doc, xmlNode* c_node):
+ cdef python.PyObject* dict_result
+ cdef ElementNamespaceClassLookup lookup
+ cdef _NamespaceRegistry registry
+ if state is None:
+ return _lookupDefaultElementClass(None, doc, c_node)
+
+ lookup = state
+ if c_node.type != tree.XML_ELEMENT_NODE:
+ return _callLookupFallback(lookup, doc, c_node)
+
+ c_namespace_utf = _getNs(c_node)
+ if c_namespace_utf is not NULL:
+ dict_result = python.PyDict_GetItem(
+ lookup._namespace_registries, c_namespace_utf)
+ else:
+ dict_result = python.PyDict_GetItem(
+ lookup._namespace_registries, None)
+ if dict_result is not NULL:
+ registry = <_NamespaceRegistry>dict_result
+ classes = registry._entries
+
+ if c_node.name is not NULL:
+ dict_result = python.PyDict_GetItem(
+ classes, c_node.name)
+ else:
+ dict_result = NULL
+
+ if dict_result is NULL:
+ dict_result = python.PyDict_GetItem(classes, None)
+
+ if dict_result is not NULL:
+ return dict_result
+ return _callLookupFallback(lookup, doc, c_node)
+
+
+################################################################################
+# XPath extension functions
+
+cdef dict __FUNCTION_NAMESPACE_REGISTRIES
+__FUNCTION_NAMESPACE_REGISTRIES = {}
+
+def FunctionNamespace(ns_uri):
+ """FunctionNamespace(ns_uri)
+
+ Retrieve the function namespace object associated with the given
+ URI.
+
+ Creates a new one if it does not yet exist. A function namespace
+ can only be used to register extension functions.
+
+ Usage:
+
+ >>> ns_functions = FunctionNamespace("http://schema.org/Movie")
+
+ >>> @ns_functions # uses function name
+ ... def add2(x):
+ ... return x + 2
+
+ >>> @ns_functions("add3") # uses explicit name
+ ... def add_three(x):
+ ... return x + 3
+ """
+ ns_utf = _utf8(ns_uri) if ns_uri else None
+ try:
+ return __FUNCTION_NAMESPACE_REGISTRIES[ns_utf]
+ except KeyError:
+ registry = __FUNCTION_NAMESPACE_REGISTRIES[ns_utf] = \
+ _XPathFunctionNamespaceRegistry(ns_uri)
+ return registry
+
+@cython.internal
+cdef class _FunctionNamespaceRegistry(_NamespaceRegistry):
+ def __setitem__(self, name, item):
+ if not callable(item):
+ raise NamespaceRegistryError, \
+ "Registered functions must be callable."
+ if not name:
+ raise ValueError, \
+ "extensions must have non empty names"
+ self._entries[_utf8(name)] = item
+
+ def __repr__(self):
+ return "FunctionNamespace(%r)" % self._ns_uri
+
+@cython.final
+@cython.internal
+cdef class _XPathFunctionNamespaceRegistry(_FunctionNamespaceRegistry):
+ cdef object _prefix
+ cdef bytes _prefix_utf
+
+ property prefix:
+ "Namespace prefix for extension functions."
+ def __del__(self):
+ self._prefix = None # no prefix configured
+ self._prefix_utf = None
+ def __get__(self):
+ if self._prefix is None:
+ return ''
+ else:
+ return self._prefix
+ def __set__(self, prefix):
+ if prefix == '':
+ prefix = None # empty prefix
+ self._prefix_utf = _utf8(prefix) if prefix is not None else None
+ self._prefix = prefix
+
+cdef list _find_all_extension_prefixes():
+ "Internal lookup function to find all function prefixes for XSLT/XPath."
+ cdef _XPathFunctionNamespaceRegistry registry
+ cdef list ns_prefixes = []
+ for registry in __FUNCTION_NAMESPACE_REGISTRIES.itervalues():
+ if registry._prefix_utf is not None:
+ if registry._ns_uri_utf is not None:
+ ns_prefixes.append(
+ (registry._prefix_utf, registry._ns_uri_utf))
+ return ns_prefixes
diff --git a/llava_video/lib/python3.10/site-packages/lxml/objectify.pyx b/llava_video/lib/python3.10/site-packages/lxml/objectify.pyx
new file mode 100644
index 0000000000000000000000000000000000000000..0ff922262ed55ef2d04bdea0f196bd724b736550
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/objectify.pyx
@@ -0,0 +1,2145 @@
+# cython: binding=True
+# cython: auto_pickle=False
+# cython: language_level=3
+
+"""
+The ``lxml.objectify`` module implements a Python object API for XML.
+It is based on `lxml.etree`.
+"""
+
+cimport cython
+
+from lxml.includes.etreepublic cimport _Document, _Element, ElementBase, ElementClassLookup
+from lxml.includes.etreepublic cimport elementFactory, import_lxml__etree, textOf, pyunicode
+from lxml.includes.tree cimport const_xmlChar, _xcstr
+from lxml cimport python
+from lxml.includes cimport tree
+
+cimport lxml.includes.etreepublic as cetree
+cimport libc.string as cstring_h # not to be confused with stdlib 'string'
+from libc.string cimport const_char
+
+__all__ = ['BoolElement', 'DataElement', 'E', 'Element', 'ElementMaker',
+ 'FloatElement', 'IntElement', 'NoneElement',
+ 'NumberElement', 'ObjectPath', 'ObjectifiedDataElement',
+ 'ObjectifiedElement', 'ObjectifyElementClassLookup',
+ 'PYTYPE_ATTRIBUTE', 'PyType', 'StringElement', 'SubElement',
+ 'XML', 'annotate', 'deannotate', 'dump', 'enable_recursive_str',
+ 'fromstring', 'getRegisteredTypes', 'makeparser', 'parse',
+ 'pyannotate', 'pytypename', 'set_default_parser',
+ 'set_pytype_attribute_tag', 'xsiannotate']
+
+cdef object etree
+from lxml import etree
+# initialize C-API of lxml.etree
+import_lxml__etree()
+
+__version__ = etree.__version__
+
+cdef object _float_is_inf, _float_is_nan
+from math import isinf as _float_is_inf, isnan as _float_is_nan
+
+cdef object re
+import re
+
+cdef tuple IGNORABLE_ERRORS = (ValueError, TypeError)
+cdef object is_special_method = re.compile('__.*__$').match
+
+
+cdef object _typename(object t):
+ cdef const_char* c_name
+ c_name = python._fqtypename(t)
+ s = cstring_h.strrchr(c_name, c'.')
+ if s is not NULL:
+ c_name = s + 1
+ return pyunicode(c_name)
+
+
+# namespace/name for "pytype" hint attribute
+cdef object PYTYPE_NAMESPACE
+cdef bytes PYTYPE_NAMESPACE_UTF8
+cdef const_xmlChar* _PYTYPE_NAMESPACE
+
+cdef object PYTYPE_ATTRIBUTE_NAME
+cdef bytes PYTYPE_ATTRIBUTE_NAME_UTF8
+cdef const_xmlChar* _PYTYPE_ATTRIBUTE_NAME
+
+PYTYPE_ATTRIBUTE = None
+
+cdef unicode TREE_PYTYPE_NAME = "TREE"
+
+cdef tuple _unicodeAndUtf8(s):
+ return s, python.PyUnicode_AsUTF8String(s)
+
+def set_pytype_attribute_tag(attribute_tag=None):
+ """set_pytype_attribute_tag(attribute_tag=None)
+ Change name and namespace of the XML attribute that holds Python type
+ information.
+
+ Do not use this unless you know what you are doing.
+
+ Reset by calling without argument.
+
+ Default: "{http://codespeak.net/lxml/objectify/pytype}pytype"
+ """
+ global PYTYPE_ATTRIBUTE, _PYTYPE_NAMESPACE, _PYTYPE_ATTRIBUTE_NAME
+ global PYTYPE_NAMESPACE, PYTYPE_NAMESPACE_UTF8
+ global PYTYPE_ATTRIBUTE_NAME, PYTYPE_ATTRIBUTE_NAME_UTF8
+ if attribute_tag is None:
+ PYTYPE_NAMESPACE, PYTYPE_NAMESPACE_UTF8 = \
+ _unicodeAndUtf8("http://codespeak.net/lxml/objectify/pytype")
+ PYTYPE_ATTRIBUTE_NAME, PYTYPE_ATTRIBUTE_NAME_UTF8 = \
+ _unicodeAndUtf8("pytype")
+ else:
+ PYTYPE_NAMESPACE_UTF8, PYTYPE_ATTRIBUTE_NAME_UTF8 = \
+ cetree.getNsTag(attribute_tag)
+ PYTYPE_NAMESPACE = PYTYPE_NAMESPACE_UTF8.decode('utf8')
+ PYTYPE_ATTRIBUTE_NAME = PYTYPE_ATTRIBUTE_NAME_UTF8.decode('utf8')
+
+ _PYTYPE_NAMESPACE = PYTYPE_NAMESPACE_UTF8
+ _PYTYPE_ATTRIBUTE_NAME = PYTYPE_ATTRIBUTE_NAME_UTF8
+ PYTYPE_ATTRIBUTE = cetree.namespacedNameFromNsName(
+ _PYTYPE_NAMESPACE, _PYTYPE_ATTRIBUTE_NAME)
+
+set_pytype_attribute_tag()
+
+
+# namespaces for XML Schema
+cdef object XML_SCHEMA_NS, XML_SCHEMA_NS_UTF8
+XML_SCHEMA_NS, XML_SCHEMA_NS_UTF8 = \
+ _unicodeAndUtf8("http://www.w3.org/2001/XMLSchema")
+cdef const_xmlChar* _XML_SCHEMA_NS = _xcstr(XML_SCHEMA_NS_UTF8)
+
+cdef object XML_SCHEMA_INSTANCE_NS, XML_SCHEMA_INSTANCE_NS_UTF8
+XML_SCHEMA_INSTANCE_NS, XML_SCHEMA_INSTANCE_NS_UTF8 = \
+ _unicodeAndUtf8("http://www.w3.org/2001/XMLSchema-instance")
+cdef const_xmlChar* _XML_SCHEMA_INSTANCE_NS = _xcstr(XML_SCHEMA_INSTANCE_NS_UTF8)
+
+cdef object XML_SCHEMA_INSTANCE_NIL_ATTR = "{%s}nil" % XML_SCHEMA_INSTANCE_NS
+cdef object XML_SCHEMA_INSTANCE_TYPE_ATTR = "{%s}type" % XML_SCHEMA_INSTANCE_NS
+
+
+################################################################################
+# Element class for the main API
+
+cdef class ObjectifiedElement(ElementBase):
+ """Main XML Element class.
+
+ Element children are accessed as object attributes. Multiple children
+ with the same name are available through a list index. Example::
+
+ >>> root = XML("0 1 ''
+ else:
+ c_href = _xcstr(ns)
+ c_result = _findFollowingSibling(c_node.children, c_href, c_tag, 0)
+ if c_result is NULL:
+ return None
+ return elementFactory(parent._doc, c_result)
+
+cdef object _lookupChildOrRaise(_Element parent, tag):
+ element = _lookupChild(parent, tag)
+ if element is None:
+ raise AttributeError, "no such child: " + _buildChildTag(parent, tag)
+ return element
+
+cdef object _buildChildTag(_Element parent, tag):
+ ns, tag = cetree.getNsTag(tag)
+ c_tag = _xcstr(tag)
+ c_href = tree._getNs(parent._c_node) if ns is None else _xcstr(ns)
+ return cetree.namespacedNameFromNsName(c_href, c_tag)
+
+cdef _replaceElement(_Element element, value):
+ cdef _Element new_element
+ if isinstance(value, _Element):
+ # deep copy the new element
+ new_element = cetree.deepcopyNodeToDocument(
+ element._doc, (<_Element>value)._c_node)
+ new_element.tag = element.tag
+ elif isinstance(value, (list, tuple)):
+ element[:] = value
+ return
+ else:
+ new_element = element.makeelement(element.tag)
+ _setElementValue(new_element, value)
+ element.getparent().replace(element, new_element)
+
+cdef _appendValue(_Element parent, tag, value):
+ cdef _Element new_element
+ if isinstance(value, _Element):
+ # deep copy the new element
+ new_element = cetree.deepcopyNodeToDocument(
+ parent._doc, (<_Element>value)._c_node)
+ new_element.tag = tag
+ cetree.appendChildToElement(parent, new_element)
+ elif isinstance(value, (list, tuple)):
+ for item in value:
+ _appendValue(parent, tag, item)
+ else:
+ new_element = cetree.makeElement(
+ tag, parent._doc, None, None, None, None, None)
+ _setElementValue(new_element, value)
+ cetree.appendChildToElement(parent, new_element)
+
+cdef _setElementValue(_Element element, value):
+ if value is None:
+ cetree.setAttributeValue(
+ element, XML_SCHEMA_INSTANCE_NIL_ATTR, "true")
+ elif isinstance(value, _Element):
+ _replaceElement(element, value)
+ return
+ else:
+ cetree.delAttributeFromNsName(
+ element._c_node, _XML_SCHEMA_INSTANCE_NS, "nil")
+ if python._isString(value):
+ pytype_name = "str"
+ py_type = _PYTYPE_DICT.get(pytype_name)
+ else:
+ pytype_name = _typename(value)
+ py_type = _PYTYPE_DICT.get(pytype_name)
+ if py_type is not None:
+ value = py_type.stringify(value)
+ else:
+ value = unicode(value)
+ if py_type is not None:
+ cetree.setAttributeValue(element, PYTYPE_ATTRIBUTE, pytype_name)
+ else:
+ cetree.delAttributeFromNsName(
+ element._c_node, _PYTYPE_NAMESPACE, _PYTYPE_ATTRIBUTE_NAME)
+ cetree.setNodeText(element._c_node, value)
+
+cdef _setSlice(sliceobject, _Element target, items):
+ cdef _Element parent
+ cdef tree.xmlNode* c_node
+ cdef Py_ssize_t c_step, c_start, pos
+ # collect existing slice
+ if (sliceobject).step is None:
+ c_step = 1
+ else:
+ c_step = (sliceobject).step
+ if c_step == 0:
+ raise ValueError, "Invalid slice"
+ cdef list del_items = target[sliceobject]
+
+ # collect new values
+ new_items = []
+ tag = target.tag
+ for item in items:
+ if isinstance(item, _Element):
+ # deep copy the new element
+ new_element = cetree.deepcopyNodeToDocument(
+ target._doc, (<_Element>item)._c_node)
+ new_element.tag = tag
+ else:
+ new_element = cetree.makeElement(
+ tag, target._doc, None, None, None, None, None)
+ _setElementValue(new_element, item)
+ new_items.append(new_element)
+
+ # sanity check - raise what a list would raise
+ if c_step != 1 and len(del_items) != len(new_items):
+ raise ValueError, \
+ f"attempt to assign sequence of size {len(new_items)} to extended slice of size {len(del_items)}"
+
+ # replace existing items
+ pos = 0
+ parent = target.getparent()
+ replace = parent.replace
+ while pos < len(new_items) and pos < len(del_items):
+ replace(del_items[pos], new_items[pos])
+ pos += 1
+ # remove leftover items
+ if pos < len(del_items):
+ remove = parent.remove
+ while pos < len(del_items):
+ remove(del_items[pos])
+ pos += 1
+ # append remaining new items
+ if pos < len(new_items):
+ # the sanity check above guarantees (step == 1)
+ if pos > 0:
+ item = new_items[pos-1]
+ else:
+ if (sliceobject).start > 0:
+ c_node = parent._c_node.children
+ else:
+ c_node = parent._c_node.last
+ c_node = _findFollowingSibling(
+ c_node, tree._getNs(target._c_node), target._c_node.name,
+ (sliceobject).start - 1)
+ if c_node is NULL:
+ while pos < len(new_items):
+ cetree.appendChildToElement(parent, new_items[pos])
+ pos += 1
+ return
+ item = cetree.elementFactory(parent._doc, c_node)
+ while pos < len(new_items):
+ add = item.addnext
+ item = new_items[pos]
+ add(item)
+ pos += 1
+
+################################################################################
+# Data type support in subclasses
+
+cdef class ObjectifiedDataElement(ObjectifiedElement):
+ """This is the base class for all data type Elements. Subclasses should
+ override the 'pyval' property and possibly the __str__ method.
+ """
+ @property
+ def pyval(self):
+ return textOf(self._c_node)
+
+ def __str__(self):
+ return textOf(self._c_node) or ''
+
+ def __repr__(self):
+ return textOf(self._c_node) or ''
+
+ def _setText(self, s):
+ """For use in subclasses only. Don't use unless you know what you are
+ doing.
+ """
+ cetree.setNodeText(self._c_node, s)
+
+
+cdef class NumberElement(ObjectifiedDataElement):
+ cdef object _parse_value
+
+ def _setValueParser(self, function):
+ """Set the function that parses the Python value from a string.
+
+ Do not use this unless you know what you are doing.
+ """
+ self._parse_value = function
+
+ @property
+ def pyval(self):
+ return _parseNumber(self)
+
+ def __int__(self):
+ return int(_parseNumber(self))
+
+ def __float__(self):
+ return float(_parseNumber(self))
+
+ def __complex__(self):
+ return complex(_parseNumber(self))
+
+ def __str__(self):
+ return unicode(_parseNumber(self))
+
+ def __repr__(self):
+ return repr(_parseNumber(self))
+
+ def __oct__(self):
+ return oct(_parseNumber(self))
+
+ def __hex__(self):
+ return hex(_parseNumber(self))
+
+ def __richcmp__(self, other, int op):
+ return _richcmpPyvals(self, other, op)
+
+ def __hash__(self):
+ return hash(_parseNumber(self))
+
+ def __add__(self, other):
+ return _numericValueOf(self) + _numericValueOf(other)
+
+ def __radd__(self, other):
+ return _numericValueOf(other) + _numericValueOf(self)
+
+ def __sub__(self, other):
+ return _numericValueOf(self) - _numericValueOf(other)
+
+ def __rsub__(self, other):
+ return _numericValueOf(other) - _numericValueOf(self)
+
+ def __mul__(self, other):
+ return _numericValueOf(self) * _numericValueOf(other)
+
+ def __rmul__(self, other):
+ return _numericValueOf(other) * _numericValueOf(self)
+
+ def __div__(self, other):
+ return _numericValueOf(self) / _numericValueOf(other)
+
+ def __rdiv__(self, other):
+ return _numericValueOf(other) / _numericValueOf(self)
+
+ def __truediv__(self, other):
+ return _numericValueOf(self) / _numericValueOf(other)
+
+ def __rtruediv__(self, other):
+ return _numericValueOf(other) / _numericValueOf(self)
+
+ def __floordiv__(self, other):
+ return _numericValueOf(self) // _numericValueOf(other)
+
+ def __rfloordiv__(self, other):
+ return _numericValueOf(other) // _numericValueOf(self)
+
+ def __mod__(self, other):
+ return _numericValueOf(self) % _numericValueOf(other)
+
+ def __rmod__(self, other):
+ return _numericValueOf(other) % _numericValueOf(self)
+
+ def __divmod__(self, other):
+ return divmod(_numericValueOf(self), _numericValueOf(other))
+
+ def __rdivmod__(self, other):
+ return divmod(_numericValueOf(other), _numericValueOf(self))
+
+ def __pow__(self, other, modulo):
+ if modulo is None:
+ return _numericValueOf(self) ** _numericValueOf(other)
+ else:
+ return pow(_numericValueOf(self), _numericValueOf(other), modulo)
+
+ def __rpow__(self, other, modulo):
+ if modulo is None:
+ return _numericValueOf(other) ** _numericValueOf(self)
+ else:
+ return pow(_numericValueOf(other), _numericValueOf(self), modulo)
+
+ def __neg__(self):
+ return - _numericValueOf(self)
+
+ def __pos__(self):
+ return + _numericValueOf(self)
+
+ def __abs__(self):
+ return abs( _numericValueOf(self) )
+
+ def __bool__(self):
+ return bool(_numericValueOf(self))
+
+ def __invert__(self):
+ return ~ _numericValueOf(self)
+
+ def __lshift__(self, other):
+ return _numericValueOf(self) << _numericValueOf(other)
+
+ def __rlshift__(self, other):
+ return _numericValueOf(other) << _numericValueOf(self)
+
+ def __rshift__(self, other):
+ return _numericValueOf(self) >> _numericValueOf(other)
+
+ def __rrshift__(self, other):
+ return _numericValueOf(other) >> _numericValueOf(self)
+
+ def __and__(self, other):
+ return _numericValueOf(self) & _numericValueOf(other)
+
+ def __rand__(self, other):
+ return _numericValueOf(other) & _numericValueOf(self)
+
+ def __or__(self, other):
+ return _numericValueOf(self) | _numericValueOf(other)
+
+ def __ror__(self, other):
+ return _numericValueOf(other) | _numericValueOf(self)
+
+ def __xor__(self, other):
+ return _numericValueOf(self) ^ _numericValueOf(other)
+
+ def __rxor__(self, other):
+ return _numericValueOf(other) ^ _numericValueOf(self)
+
+
+cdef class IntElement(NumberElement):
+ def _init(self):
+ self._parse_value = int
+
+ def __index__(self):
+ return int(_parseNumber(self))
+
+
+cdef class FloatElement(NumberElement):
+ def _init(self):
+ self._parse_value = float
+
+
+cdef class StringElement(ObjectifiedDataElement):
+ """String data class.
+
+ Note that this class does *not* support the sequence protocol of strings:
+ len(), iter(), str_attr[0], str_attr[0:1], etc. are *not* supported.
+ Instead, use the .text attribute to get a 'real' string.
+ """
+ @property
+ def pyval(self):
+ return textOf(self._c_node) or ''
+
+ def __repr__(self):
+ return repr(textOf(self._c_node) or '')
+
+ def strlen(self):
+ text = textOf(self._c_node)
+ if text is None:
+ return 0
+ else:
+ return len(text)
+
+ def __bool__(self):
+ return bool(textOf(self._c_node))
+
+ def __richcmp__(self, other, int op):
+ return _richcmpPyvals(self, other, op)
+
+ def __hash__(self):
+ return hash(textOf(self._c_node) or '')
+
+ def __add__(self, other):
+ text = _strValueOf(self)
+ other = _strValueOf(other)
+ return text + other
+
+ def __radd__(self, other):
+ text = _strValueOf(self)
+ other = _strValueOf(other)
+ return other + text
+
+ def __mul__(self, other):
+ if isinstance(self, StringElement):
+ return (textOf((self)._c_node) or '') * _numericValueOf(other)
+ elif isinstance(other, StringElement):
+ return _numericValueOf(self) * (textOf((other)._c_node) or '')
+ else:
+ return NotImplemented
+
+ def __rmul__(self, other):
+ return _numericValueOf(other) * (textOf((self)._c_node) or '')
+
+ def __mod__(self, other):
+ return (_strValueOf(self) or '') % other
+
+ def __int__(self):
+ return int(textOf(self._c_node))
+
+ def __float__(self):
+ return float(textOf(self._c_node))
+
+ def __complex__(self):
+ return complex(textOf(self._c_node))
+
+
+cdef class NoneElement(ObjectifiedDataElement):
+ def __str__(self):
+ return "None"
+
+ def __repr__(self):
+ return "None"
+
+ def __bool__(self):
+ return False
+
+ def __richcmp__(self, other, int op):
+ if other is None or self is None:
+ return python.PyObject_RichCompare(None, None, op)
+ if isinstance(self, NoneElement):
+ return python.PyObject_RichCompare(None, other, op)
+ else:
+ return python.PyObject_RichCompare(self, None, op)
+
+ def __hash__(self):
+ return hash(None)
+
+ @property
+ def pyval(self):
+ return None
+
+
+cdef class BoolElement(IntElement):
+ """Boolean type base on string values: 'true' or 'false'.
+
+ Note that this inherits from IntElement to mimic the behaviour of
+ Python's bool type.
+ """
+ def _init(self):
+ self._parse_value = _parseBool # wraps as Python callable
+
+ def __bool__(self):
+ return _parseBool(textOf(self._c_node))
+
+ def __int__(self):
+ return 0 + _parseBool(textOf(self._c_node))
+
+ def __float__(self):
+ return 0.0 + _parseBool(textOf(self._c_node))
+
+ def __richcmp__(self, other, int op):
+ return _richcmpPyvals(self, other, op)
+
+ def __hash__(self):
+ return hash(_parseBool(textOf(self._c_node)))
+
+ def __str__(self):
+ return unicode(_parseBool(textOf(self._c_node)))
+
+ def __repr__(self):
+ return repr(_parseBool(textOf(self._c_node)))
+
+ @property
+ def pyval(self):
+ return _parseBool(textOf(self._c_node))
+
+
+cdef _checkBool(s):
+ cdef int value = -1
+ if s is not None:
+ value = __parseBoolAsInt(s)
+ if value == -1:
+ raise ValueError
+
+
+cdef bint _parseBool(s) except -1:
+ cdef int value
+ if s is None:
+ return False
+ value = __parseBoolAsInt(s)
+ if value == -1:
+ raise ValueError, f"Invalid boolean value: '{s}'"
+ return value
+
+
+cdef inline int __parseBoolAsInt(text) except -2:
+ if text == 'false':
+ return 0
+ elif text == 'true':
+ return 1
+ elif text == '0':
+ return 0
+ elif text == '1':
+ return 1
+ return -1
+
+
+cdef object _parseNumber(NumberElement element):
+ return element._parse_value(textOf(element._c_node))
+
+
+cdef enum NumberParserState:
+ NPS_SPACE_PRE = 0
+ NPS_SIGN = 1
+ NPS_DIGITS = 2
+ NPS_POINT_LEAD = 3
+ NPS_POINT = 4
+ NPS_FRACTION = 5
+ NPS_EXP = 6
+ NPS_EXP_SIGN = 7
+ NPS_DIGITS_EXP = 8
+ NPS_SPACE_TAIL = 9
+ NPS_INF1 = 20
+ NPS_INF2 = 21
+ NPS_INF3 = 22
+ NPS_NAN1 = 23
+ NPS_NAN2 = 24
+ NPS_NAN3 = 25
+ NPS_ERROR = 99
+
+
+ctypedef fused bytes_unicode:
+ bytes
+ unicode
+
+
+cdef _checkNumber(bytes_unicode s, bint allow_float):
+ cdef Py_UCS4 c
+ cdef NumberParserState state = NPS_SPACE_PRE
+
+ for c in s:
+ if c in '0123456789':
+ if state in (NPS_DIGITS, NPS_FRACTION, NPS_DIGITS_EXP):
+ pass
+ elif state in (NPS_SPACE_PRE, NPS_SIGN):
+ state = NPS_DIGITS
+ elif state in (NPS_POINT_LEAD, NPS_POINT):
+ state = NPS_FRACTION
+ elif state in (NPS_EXP, NPS_EXP_SIGN):
+ state = NPS_DIGITS_EXP
+ else:
+ state = NPS_ERROR
+ else:
+ if c == '.':
+ if state in (NPS_SPACE_PRE, NPS_SIGN):
+ state = NPS_POINT_LEAD
+ elif state == NPS_DIGITS:
+ state = NPS_POINT
+ else:
+ state = NPS_ERROR
+ if not allow_float:
+ state = NPS_ERROR
+ elif c in '-+':
+ if state == NPS_SPACE_PRE:
+ state = NPS_SIGN
+ elif state == NPS_EXP:
+ state = NPS_EXP_SIGN
+ else:
+ state = NPS_ERROR
+ elif c == 'E':
+ if state in (NPS_DIGITS, NPS_POINT, NPS_FRACTION):
+ state = NPS_EXP
+ else:
+ state = NPS_ERROR
+ if not allow_float:
+ state = NPS_ERROR
+ # Allow INF and NaN. XMLSchema requires case, we don't, like Python.
+ elif c in 'iI':
+ state = NPS_INF1 if allow_float and state in (NPS_SPACE_PRE, NPS_SIGN) else NPS_ERROR
+ elif c in 'fF':
+ state = NPS_INF3 if state == NPS_INF2 else NPS_ERROR
+ elif c in 'aA':
+ state = NPS_NAN2 if state == NPS_NAN1 else NPS_ERROR
+ elif c in 'nN':
+ # Python also allows [+-]NaN, so let's accept that.
+ if state in (NPS_SPACE_PRE, NPS_SIGN):
+ state = NPS_NAN1 if allow_float else NPS_ERROR
+ elif state == NPS_NAN2:
+ state = NPS_NAN3
+ elif state == NPS_INF1:
+ state = NPS_INF2
+ else:
+ state = NPS_ERROR
+ # Allow spaces around text values.
+ else:
+ if c.isspace() if (bytes_unicode is unicode) else c in b'\x09\x0a\x0b\x0c\x0d\x20':
+ if state in (NPS_SPACE_PRE, NPS_SPACE_TAIL):
+ pass
+ elif state in (NPS_DIGITS, NPS_POINT, NPS_FRACTION, NPS_DIGITS_EXP, NPS_INF3, NPS_NAN3):
+ state = NPS_SPACE_TAIL
+ else:
+ state = NPS_ERROR
+ else:
+ state = NPS_ERROR
+
+ if state == NPS_ERROR:
+ break
+
+ if state not in (NPS_DIGITS, NPS_FRACTION, NPS_POINT, NPS_DIGITS_EXP, NPS_INF3, NPS_NAN3, NPS_SPACE_TAIL):
+ raise ValueError
+
+
+cdef _checkInt(s):
+ return _checkNumber(s, allow_float=False)
+
+
+cdef _checkFloat(s):
+ return _checkNumber(s, allow_float=True)
+
+
+cdef object _strValueOf(obj):
+ if python._isString(obj):
+ return obj
+ if isinstance(obj, _Element):
+ return textOf((<_Element>obj)._c_node) or ''
+ if obj is None:
+ return ''
+ return unicode(obj)
+
+
+cdef object _numericValueOf(obj):
+ if isinstance(obj, NumberElement):
+ return _parseNumber(obj)
+ try:
+ # not always numeric, but Python will raise the right exception
+ return obj.pyval
+ except AttributeError:
+ pass
+ return obj
+
+
+cdef _richcmpPyvals(left, right, int op):
+ left = getattr(left, 'pyval', left)
+ right = getattr(right, 'pyval', right)
+ return python.PyObject_RichCompare(left, right, op)
+
+
+################################################################################
+# Python type registry
+
+cdef class PyType:
+ """PyType(self, name, type_check, type_class, stringify=None)
+ User defined type.
+
+ Named type that contains a type check function, a type class that
+ inherits from ObjectifiedDataElement and an optional "stringification"
+ function. The type check must take a string as argument and raise
+ ValueError or TypeError if it cannot handle the string value. It may be
+ None in which case it is not considered for type guessing. For registered
+ named types, the 'stringify' function (or unicode() if None) is used to
+ convert a Python object with type name 'name' to the string representation
+ stored in the XML tree.
+
+ Example::
+
+ PyType('int', int, MyIntClass).register()
+
+ Note that the order in which types are registered matters. The first
+ matching type will be used.
+ """
+ cdef readonly object name
+ cdef readonly object type_check
+ cdef readonly object stringify
+ cdef object _type
+ cdef list _schema_types
+ def __init__(self, name, type_check, type_class, stringify=None):
+ if isinstance(name, bytes):
+ name = (name).decode('ascii')
+ elif not isinstance(name, unicode):
+ raise TypeError, "Type name must be a string"
+ if type_check is not None and not callable(type_check):
+ raise TypeError, "Type check function must be callable (or None)"
+ if name != TREE_PYTYPE_NAME and \
+ not issubclass(type_class, ObjectifiedDataElement):
+ raise TypeError, \
+ "Data classes must inherit from ObjectifiedDataElement"
+ self.name = name
+ self._type = type_class
+ self.type_check = type_check
+ if stringify is None:
+ stringify = unicode
+ self.stringify = stringify
+ self._schema_types = []
+
+ def __repr__(self):
+ return "PyType(%s, %s)" % (self.name, self._type.__name__)
+
+ def register(self, before=None, after=None):
+ """register(self, before=None, after=None)
+
+ Register the type.
+
+ The additional keyword arguments 'before' and 'after' accept a
+ sequence of type names that must appear before/after the new type in
+ the type list. If any of them is not currently known, it is simply
+ ignored. Raises ValueError if the dependencies cannot be fulfilled.
+ """
+ if self.name == TREE_PYTYPE_NAME:
+ raise ValueError, "Cannot register tree type"
+ if self.type_check is not None:
+ for item in _TYPE_CHECKS:
+ if item[0] is self.type_check:
+ _TYPE_CHECKS.remove(item)
+ break
+ entry = (self.type_check, self)
+ first_pos = 0
+ last_pos = -1
+ if before or after:
+ if before is None:
+ before = ()
+ elif after is None:
+ after = ()
+ for i, (check, pytype) in enumerate(_TYPE_CHECKS):
+ if last_pos == -1 and pytype.name in before:
+ last_pos = i
+ if pytype.name in after:
+ first_pos = i+1
+ if last_pos == -1:
+ _TYPE_CHECKS.append(entry)
+ elif first_pos > last_pos:
+ raise ValueError, "inconsistent before/after dependencies"
+ else:
+ _TYPE_CHECKS.insert(last_pos, entry)
+
+ _PYTYPE_DICT[self.name] = self
+ for xs_type in self._schema_types:
+ _SCHEMA_TYPE_DICT[xs_type] = self
+
+ def unregister(self):
+ "unregister(self)"
+ if _PYTYPE_DICT.get(self.name) is self:
+ del _PYTYPE_DICT[self.name]
+ for xs_type, pytype in list(_SCHEMA_TYPE_DICT.items()):
+ if pytype is self:
+ del _SCHEMA_TYPE_DICT[xs_type]
+ if self.type_check is None:
+ return
+ try:
+ _TYPE_CHECKS.remove( (self.type_check, self) )
+ except ValueError:
+ pass
+
+ property xmlSchemaTypes:
+ """The list of XML Schema datatypes this Python type maps to.
+
+ Note that this must be set before registering the type!
+ """
+ def __get__(self):
+ return self._schema_types
+ def __set__(self, types):
+ self._schema_types = list(map(unicode, types))
+
+
+cdef dict _PYTYPE_DICT = {}
+cdef dict _SCHEMA_TYPE_DICT = {}
+cdef list _TYPE_CHECKS = []
+
+cdef unicode _xml_bool(value):
+ return "true" if value else "false"
+
+cdef unicode _xml_float(value):
+ if _float_is_inf(value):
+ if value > 0:
+ return "INF"
+ return "-INF"
+ if _float_is_nan(value):
+ return "NaN"
+ return unicode(repr(value))
+
+cdef _pytypename(obj):
+ return "str" if python._isString(obj) else _typename(obj)
+
+def pytypename(obj):
+ """pytypename(obj)
+
+ Find the name of the corresponding PyType for a Python object.
+ """
+ return _pytypename(obj)
+
+cdef _registerPyTypes():
+ pytype = PyType('int', _checkInt, IntElement) # wraps functions for Python
+ pytype.xmlSchemaTypes = ("integer", "int", "short", "byte", "unsignedShort",
+ "unsignedByte", "nonPositiveInteger",
+ "negativeInteger", "long", "nonNegativeInteger",
+ "unsignedLong", "unsignedInt", "positiveInteger",)
+ pytype.register()
+
+ # 'long' type just for backwards compatibility
+ pytype = PyType('long', None, IntElement)
+ pytype.register()
+
+ pytype = PyType('float', _checkFloat, FloatElement, _xml_float) # wraps functions for Python
+ pytype.xmlSchemaTypes = ("double", "float")
+ pytype.register()
+
+ pytype = PyType('bool', _checkBool, BoolElement, _xml_bool) # wraps functions for Python
+ pytype.xmlSchemaTypes = ("boolean",)
+ pytype.register()
+
+ pytype = PyType('str', None, StringElement)
+ pytype.xmlSchemaTypes = ("string", "normalizedString", "token", "language",
+ "Name", "NCName", "ID", "IDREF", "ENTITY",
+ "NMTOKEN", )
+ pytype.register()
+
+ # since lxml 2.0
+ pytype = PyType('NoneType', None, NoneElement)
+ pytype.register()
+
+ # backwards compatibility
+ pytype = PyType('none', None, NoneElement)
+ pytype.register()
+
+# non-registered PyType for inner tree elements
+cdef PyType TREE_PYTYPE = PyType(TREE_PYTYPE_NAME, None, ObjectifiedElement)
+
+_registerPyTypes()
+
+def getRegisteredTypes():
+ """getRegisteredTypes()
+
+ Returns a list of the currently registered PyType objects.
+
+ To add a new type, retrieve this list and call unregister() for all
+ entries. Then add the new type at a suitable position (possibly replacing
+ an existing one) and call register() for all entries.
+
+ This is necessary if the new type interferes with the type check functions
+ of existing ones (normally only int/float/bool) and must the tried before
+ other types. To add a type that is not yet parsable by the current type
+ check functions, you can simply register() it, which will append it to the
+ end of the type list.
+ """
+ cdef list types = []
+ cdef set known = set()
+ for check, pytype in _TYPE_CHECKS:
+ name = pytype.name
+ if name not in known:
+ known.add(name)
+ types.append(pytype)
+ for pytype in _PYTYPE_DICT.values():
+ name = pytype.name
+ if name not in known:
+ known.add(name)
+ types.append(pytype)
+ return types
+
+cdef PyType _guessPyType(value, PyType defaulttype):
+ if value is None:
+ return None
+ for type_check, tested_pytype in _TYPE_CHECKS:
+ try:
+ type_check(value)
+ return tested_pytype
+ except IGNORABLE_ERRORS:
+ # could not be parsed as the specified type => ignore
+ pass
+ return defaulttype
+
+cdef object _guessElementClass(tree.xmlNode* c_node):
+ value = textOf(c_node)
+ if value is None:
+ return None
+ if value == '':
+ return StringElement
+
+ for type_check, pytype in _TYPE_CHECKS:
+ try:
+ type_check(value)
+ return (pytype)._type
+ except IGNORABLE_ERRORS:
+ pass
+ return None
+
+################################################################################
+# adapted ElementMaker supports registered PyTypes
+
+@cython.final
+@cython.internal
+cdef class _ObjectifyElementMakerCaller:
+ cdef object _tag
+ cdef object _nsmap
+ cdef object _element_factory
+ cdef bint _annotate
+
+ def __call__(self, *children, **attrib):
+ "__call__(self, *children, **attrib)"
+ cdef _ObjectifyElementMakerCaller elementMaker
+ cdef _Element element
+ cdef _Element childElement
+ cdef bint has_children
+ cdef bint has_string_value
+ if self._element_factory is None:
+ element = _makeElement(self._tag, None, attrib, self._nsmap)
+ else:
+ element = self._element_factory(self._tag, attrib, self._nsmap)
+
+ pytype_name = None
+ has_children = False
+ has_string_value = False
+ for child in children:
+ if child is None:
+ if len(children) == 1:
+ cetree.setAttributeValue(
+ element, XML_SCHEMA_INSTANCE_NIL_ATTR, "true")
+ elif python._isString(child):
+ _add_text(element, child)
+ has_string_value = True
+ elif isinstance(child, _Element):
+ cetree.appendChildToElement(element, <_Element>child)
+ has_children = True
+ elif isinstance(child, _ObjectifyElementMakerCaller):
+ elementMaker = <_ObjectifyElementMakerCaller>child
+ if elementMaker._element_factory is None:
+ cetree.makeSubElement(element, elementMaker._tag,
+ None, None, None, None)
+ else:
+ childElement = elementMaker._element_factory(
+ elementMaker._tag)
+ cetree.appendChildToElement(element, childElement)
+ has_children = True
+ elif isinstance(child, dict):
+ for name, value in child.items():
+ # keyword arguments in attrib take precedence
+ if name in attrib:
+ continue
+ pytype = _PYTYPE_DICT.get(_typename(value))
+ if pytype is not None:
+ value = (pytype).stringify(value)
+ elif not python._isString(value):
+ value = unicode(value)
+ cetree.setAttributeValue(element, name, value)
+ else:
+ if pytype_name is not None:
+ # concatenation always makes the result a string
+ has_string_value = True
+ pytype_name = _typename(child)
+ pytype = _PYTYPE_DICT.get(_typename(child))
+ if pytype is not None:
+ _add_text(element, (pytype).stringify(child))
+ else:
+ has_string_value = True
+ child = unicode(child)
+ _add_text(element, child)
+
+ if self._annotate and not has_children:
+ if has_string_value:
+ cetree.setAttributeValue(element, PYTYPE_ATTRIBUTE, "str")
+ elif pytype_name is not None:
+ cetree.setAttributeValue(element, PYTYPE_ATTRIBUTE, pytype_name)
+
+ return element
+
+cdef _add_text(_Element elem, text):
+ # add text to the tree in construction, either as element text or
+ # tail text, depending on the current tree state
+ cdef tree.xmlNode* c_child
+ c_child = cetree.findChildBackwards(elem._c_node, 0)
+ if c_child is not NULL:
+ old = cetree.tailOf(c_child)
+ if old is not None:
+ text = old + text
+ cetree.setTailText(c_child, text)
+ else:
+ old = cetree.textOf(elem._c_node)
+ if old is not None:
+ text = old + text
+ cetree.setNodeText(elem._c_node, text)
+
+cdef class ElementMaker:
+ """ElementMaker(self, namespace=None, nsmap=None, annotate=True, makeelement=None)
+
+ An ElementMaker that can be used for constructing trees.
+
+ Example::
+
+ >>> M = ElementMaker(annotate=False)
+ >>> attributes = {'class': 'par'}
+ >>> html = M.html( M.body( M.p('hello', attributes, M.br, 'objectify', style="font-weight: bold") ) )
+
+ >>> from lxml.etree import tostring
+ >>> print(tostring(html, method='html').decode('ascii'))
+ hello
+
+ To create tags that are not valid Python identifiers, call the factory
+ directly and pass the tag name as first argument::
+
+ >>> root = M('tricky-tag', 'some text')
+ >>> print(root.tag)
+ tricky-tag
+ >>> print(root.text)
+ some text
+
+ Note that this module has a predefined ElementMaker instance called ``E``.
+ """
+ cdef object _makeelement
+ cdef object _namespace
+ cdef object _nsmap
+ cdef bint _annotate
+ cdef dict _cache
+ def __init__(self, *, namespace=None, nsmap=None, annotate=True,
+ makeelement=None):
+ if nsmap is None:
+ nsmap = _DEFAULT_NSMAP if annotate else {}
+ self._nsmap = nsmap
+ self._namespace = None if namespace is None else "{%s}" % namespace
+ self._annotate = annotate
+ if makeelement is not None:
+ if not callable(makeelement):
+ raise TypeError(
+ f"argument of 'makeelement' parameter must be callable, got {type(makeelement)}")
+ self._makeelement = makeelement
+ else:
+ self._makeelement = None
+ self._cache = {}
+
+ @cython.final
+ cdef _build_element_maker(self, tag, bint caching):
+ cdef _ObjectifyElementMakerCaller element_maker
+ element_maker = _ObjectifyElementMakerCaller.__new__(_ObjectifyElementMakerCaller)
+ if self._namespace is not None and tag[0] != "{":
+ element_maker._tag = self._namespace + tag
+ else:
+ element_maker._tag = tag
+ element_maker._nsmap = self._nsmap
+ element_maker._annotate = self._annotate
+ element_maker._element_factory = self._makeelement
+ if caching:
+ if len(self._cache) > 200:
+ self._cache.clear()
+ self._cache[tag] = element_maker
+ return element_maker
+
+ def __getattr__(self, tag):
+ element_maker = self._cache.get(tag)
+ if element_maker is None:
+ return self._build_element_maker(tag, caching=True)
+ return element_maker
+
+ def __call__(self, tag, *args, **kwargs):
+ element_maker = self._cache.get(tag)
+ if element_maker is None:
+ element_maker = self._build_element_maker(
+ tag, caching=not is_special_method(tag))
+ return element_maker(*args, **kwargs)
+
+################################################################################
+# Recursive element dumping
+
+cdef bint __RECURSIVE_STR = 0 # default: off
+
+def enable_recursive_str(on=True):
+ """enable_recursive_str(on=True)
+
+ Enable a recursively generated tree representation for str(element),
+ based on objectify.dump(element).
+ """
+ global __RECURSIVE_STR
+ __RECURSIVE_STR = on
+
+def dump(_Element element not None):
+ """dump(_Element element not None)
+
+ Return a recursively generated string representation of an element.
+ """
+ return _dump(element, 0)
+
+cdef object _dump(_Element element, int indent):
+ indentstr = " " * indent
+ if isinstance(element, ObjectifiedDataElement):
+ value = repr(element)
+ else:
+ value = textOf(element._c_node)
+ if value is not None:
+ if not value.strip():
+ value = None
+ else:
+ value = repr(value)
+ result = f"{indentstr}{element.tag} = {value} [{_typename(element)}]\n"
+ xsi_ns = "{%s}" % XML_SCHEMA_INSTANCE_NS
+ pytype_ns = "{%s}" % PYTYPE_NAMESPACE
+ for name, value in sorted(cetree.iterattributes(element, 3)):
+ if '{' in name:
+ if name == PYTYPE_ATTRIBUTE:
+ if value == TREE_PYTYPE_NAME:
+ continue
+ else:
+ name = name.replace(pytype_ns, 'py:')
+ name = name.replace(xsi_ns, 'xsi:')
+ result += f"{indentstr} * {name} = {value!r}\n"
+
+ indent += 1
+ for child in element.iterchildren():
+ result += _dump(child, indent)
+ if indent == 1:
+ return result[:-1] # strip last '\n'
+ else:
+ return result
+
+
+################################################################################
+# Pickle support for objectified ElementTree
+
+def __unpickleElementTree(data):
+ return etree.ElementTree(fromstring(data))
+
+cdef _setupPickle(elementTreeReduceFunction):
+ import copyreg
+ copyreg.pickle(etree._ElementTree,
+ elementTreeReduceFunction, __unpickleElementTree)
+
+def pickleReduceElementTree(obj):
+ return __unpickleElementTree, (etree.tostring(obj),)
+
+_setupPickle(pickleReduceElementTree)
+del pickleReduceElementTree
+
+################################################################################
+# Element class lookup
+
+cdef class ObjectifyElementClassLookup(ElementClassLookup):
+ """ObjectifyElementClassLookup(self, tree_class=None, empty_data_class=None)
+ Element class lookup method that uses the objectify classes.
+ """
+ cdef object empty_data_class
+ cdef object tree_class
+ def __init__(self, tree_class=None, empty_data_class=None):
+ """Lookup mechanism for objectify.
+
+ The default Element classes can be replaced by passing subclasses of
+ ObjectifiedElement and ObjectifiedDataElement as keyword arguments.
+ 'tree_class' defines inner tree classes (defaults to
+ ObjectifiedElement), 'empty_data_class' defines the default class for
+ empty data elements (defaults to StringElement).
+ """
+ self._lookup_function = _lookupElementClass
+ if tree_class is None:
+ tree_class = ObjectifiedElement
+ self.tree_class = tree_class
+ if empty_data_class is None:
+ empty_data_class = StringElement
+ self.empty_data_class = empty_data_class
+
+cdef object _lookupElementClass(state, _Document doc, tree.xmlNode* c_node):
+ cdef ObjectifyElementClassLookup lookup
+ lookup = state
+ # if element has children => no data class
+ if cetree.hasChild(c_node):
+ return lookup.tree_class
+
+ # if element is defined as xsi:nil, return NoneElement class
+ if "true" == cetree.attributeValueFromNsName(
+ c_node, _XML_SCHEMA_INSTANCE_NS, "nil"):
+ return NoneElement
+
+ # check for Python type hint
+ value = cetree.attributeValueFromNsName(
+ c_node, _PYTYPE_NAMESPACE, _PYTYPE_ATTRIBUTE_NAME)
+ if value is not None:
+ if value == TREE_PYTYPE_NAME:
+ return lookup.tree_class
+ py_type = _PYTYPE_DICT.get(value)
+ if py_type is not None:
+ return py_type._type
+ # unknown 'pyval' => try to figure it out ourself, just go on
+
+ # check for XML Schema type hint
+ value = cetree.attributeValueFromNsName(
+ c_node, _XML_SCHEMA_INSTANCE_NS, "type")
+
+ if value is not None:
+ schema_type = _SCHEMA_TYPE_DICT.get(value)
+ if schema_type is None and ':' in value:
+ prefix, value = value.split(':', 1)
+ schema_type = _SCHEMA_TYPE_DICT.get(value)
+ if schema_type is not None:
+ return schema_type._type
+
+ # otherwise determine class based on text content type
+ el_class = _guessElementClass(c_node)
+ if el_class is not None:
+ return el_class
+
+ # if element is a root node => default to tree node
+ if c_node.parent is NULL or not tree._isElement(c_node.parent):
+ return lookup.tree_class
+
+ return lookup.empty_data_class
+
+
+################################################################################
+# Type annotations
+
+cdef PyType _check_type(tree.xmlNode* c_node, PyType pytype):
+ if pytype is None:
+ return None
+ value = textOf(c_node)
+ try:
+ pytype.type_check(value)
+ return pytype
+ except IGNORABLE_ERRORS:
+ # could not be parsed as the specified type => ignore
+ pass
+ return None
+
+def pyannotate(element_or_tree, *, ignore_old=False, ignore_xsi=False,
+ empty_pytype=None):
+ """pyannotate(element_or_tree, ignore_old=False, ignore_xsi=False, empty_pytype=None)
+
+ Recursively annotates the elements of an XML tree with 'pytype'
+ attributes.
+
+ If the 'ignore_old' keyword argument is True (the default), current 'pytype'
+ attributes will be ignored and replaced. Otherwise, they will be checked
+ and only replaced if they no longer fit the current text value.
+
+ Setting the keyword argument ``ignore_xsi`` to True makes the function
+ additionally ignore existing ``xsi:type`` annotations. The default is to
+ use them as a type hint.
+
+ The default annotation of empty elements can be set with the
+ ``empty_pytype`` keyword argument. The default is not to annotate empty
+ elements. Pass 'str', for example, to make string values the default.
+ """
+ cdef _Element element
+ element = cetree.rootNodeOrRaise(element_or_tree)
+ _annotate(element, 0, 1, ignore_xsi, ignore_old, None, empty_pytype)
+
+def xsiannotate(element_or_tree, *, ignore_old=False, ignore_pytype=False,
+ empty_type=None):
+ """xsiannotate(element_or_tree, ignore_old=False, ignore_pytype=False, empty_type=None)
+
+ Recursively annotates the elements of an XML tree with 'xsi:type'
+ attributes.
+
+ If the 'ignore_old' keyword argument is True (the default), current
+ 'xsi:type' attributes will be ignored and replaced. Otherwise, they will be
+ checked and only replaced if they no longer fit the current text value.
+
+ Note that the mapping from Python types to XSI types is usually ambiguous.
+ Currently, only the first XSI type name in the corresponding PyType
+ definition will be used for annotation. Thus, you should consider naming
+ the widest type first if you define additional types.
+
+ Setting the keyword argument ``ignore_pytype`` to True makes the function
+ additionally ignore existing ``pytype`` annotations. The default is to
+ use them as a type hint.
+
+ The default annotation of empty elements can be set with the
+ ``empty_type`` keyword argument. The default is not to annotate empty
+ elements. Pass 'string', for example, to make string values the default.
+ """
+ cdef _Element element
+ element = cetree.rootNodeOrRaise(element_or_tree)
+ _annotate(element, 1, 0, ignore_old, ignore_pytype, empty_type, None)
+
+def annotate(element_or_tree, *, ignore_old=True, ignore_xsi=False,
+ empty_pytype=None, empty_type=None, annotate_xsi=0,
+ annotate_pytype=1):
+ """annotate(element_or_tree, ignore_old=True, ignore_xsi=False, empty_pytype=None, empty_type=None, annotate_xsi=0, annotate_pytype=1)
+
+ Recursively annotates the elements of an XML tree with 'xsi:type'
+ and/or 'py:pytype' attributes.
+
+ If the 'ignore_old' keyword argument is True (the default), current
+ 'py:pytype' attributes will be ignored for the type annotation. Set to False
+ if you want reuse existing 'py:pytype' information (iff appropriate for the
+ element text value).
+
+ If the 'ignore_xsi' keyword argument is False (the default), existing
+ 'xsi:type' attributes will be used for the type annotation, if they fit the
+ element text values.
+
+ Note that the mapping from Python types to XSI types is usually ambiguous.
+ Currently, only the first XSI type name in the corresponding PyType
+ definition will be used for annotation. Thus, you should consider naming
+ the widest type first if you define additional types.
+
+ The default 'py:pytype' annotation of empty elements can be set with the
+ ``empty_pytype`` keyword argument. Pass 'str', for example, to make
+ string values the default.
+
+ The default 'xsi:type' annotation of empty elements can be set with the
+ ``empty_type`` keyword argument. The default is not to annotate empty
+ elements. Pass 'string', for example, to make string values the default.
+
+ The keyword arguments 'annotate_xsi' (default: 0) and 'annotate_pytype'
+ (default: 1) control which kind(s) of annotation to use.
+ """
+ cdef _Element element
+ element = cetree.rootNodeOrRaise(element_or_tree)
+ _annotate(element, annotate_xsi, annotate_pytype, ignore_xsi,
+ ignore_old, empty_type, empty_pytype)
+
+
+cdef _annotate(_Element element, bint annotate_xsi, bint annotate_pytype,
+ bint ignore_xsi, bint ignore_pytype,
+ empty_type_name, empty_pytype_name):
+ cdef _Document doc
+ cdef tree.xmlNode* c_node
+ cdef PyType empty_pytype, StrType, NoneType
+
+ if not annotate_xsi and not annotate_pytype:
+ return
+
+ if empty_type_name is not None:
+ if isinstance(empty_type_name, bytes):
+ empty_type_name = (empty_type_name).decode("ascii")
+ empty_pytype = _SCHEMA_TYPE_DICT.get(empty_type_name)
+ elif empty_pytype_name is not None:
+ if isinstance(empty_pytype_name, bytes):
+ empty_pytype_name = (empty_pytype_name).decode("ascii")
+ empty_pytype = _PYTYPE_DICT.get(empty_pytype_name)
+ else:
+ empty_pytype = None
+
+ StrType = _PYTYPE_DICT.get('str')
+ NoneType = _PYTYPE_DICT.get('NoneType')
+
+ doc = element._doc
+ c_node = element._c_node
+ tree.BEGIN_FOR_EACH_ELEMENT_FROM(c_node, c_node, 1)
+ if c_node.type == tree.XML_ELEMENT_NODE:
+ _annotate_element(c_node, doc, annotate_xsi, annotate_pytype,
+ ignore_xsi, ignore_pytype,
+ empty_type_name, empty_pytype, StrType, NoneType)
+ tree.END_FOR_EACH_ELEMENT_FROM(c_node)
+
+cdef int _annotate_element(tree.xmlNode* c_node, _Document doc,
+ bint annotate_xsi, bint annotate_pytype,
+ bint ignore_xsi, bint ignore_pytype,
+ empty_type_name, PyType empty_pytype,
+ PyType StrType, PyType NoneType) except -1:
+ cdef tree.xmlNs* c_ns
+ cdef PyType pytype = None
+ typename = None
+ istree = 0
+
+ # if element is defined as xsi:nil, represent it as None
+ if cetree.attributeValueFromNsName(
+ c_node, _XML_SCHEMA_INSTANCE_NS, "nil") == "true":
+ pytype = NoneType
+
+ if pytype is None and not ignore_xsi:
+ # check that old xsi type value is valid
+ typename = cetree.attributeValueFromNsName(
+ c_node, _XML_SCHEMA_INSTANCE_NS, "type")
+ if typename is not None:
+ pytype = _SCHEMA_TYPE_DICT.get(typename)
+ if pytype is None and ':' in typename:
+ prefix, typename = typename.split(':', 1)
+ pytype = _SCHEMA_TYPE_DICT.get(typename)
+ if pytype is not None and pytype is not StrType:
+ # StrType does not have a typecheck but is the default
+ # anyway, so just accept it if given as type
+ # information
+ pytype = _check_type(c_node, pytype)
+ if pytype is None:
+ typename = None
+
+ if pytype is None and not ignore_pytype:
+ # check that old pytype value is valid
+ old_pytypename = cetree.attributeValueFromNsName(
+ c_node, _PYTYPE_NAMESPACE, _PYTYPE_ATTRIBUTE_NAME)
+ if old_pytypename is not None:
+ if old_pytypename == TREE_PYTYPE_NAME:
+ if not cetree.hasChild(c_node):
+ # only case where we should keep it,
+ # everything else is clear enough
+ pytype = TREE_PYTYPE
+ else:
+ if old_pytypename == 'none':
+ # transition from lxml 1.x
+ old_pytypename = "NoneType"
+ pytype = _PYTYPE_DICT.get(old_pytypename)
+ if pytype is not None and pytype is not StrType:
+ # StrType does not have a typecheck but is the
+ # default anyway, so just accept it if given as
+ # type information
+ pytype = _check_type(c_node, pytype)
+
+ if pytype is None:
+ # try to guess type
+ if not cetree.hasChild(c_node):
+ # element has no children => data class
+ pytype = _guessPyType(textOf(c_node), StrType)
+ else:
+ istree = 1
+
+ if pytype is None:
+ # use default type for empty elements
+ if cetree.hasText(c_node):
+ pytype = StrType
+ else:
+ pytype = empty_pytype
+ if typename is None:
+ typename = empty_type_name
+
+ if pytype is not None:
+ if typename is None:
+ if not istree:
+ if pytype._schema_types:
+ # pytype->xsi:type is a 1:n mapping
+ # simply take the first
+ typename = pytype._schema_types[0]
+ elif typename not in pytype._schema_types:
+ typename = pytype._schema_types[0]
+
+ if annotate_xsi:
+ if typename is None or istree:
+ cetree.delAttributeFromNsName(
+ c_node, _XML_SCHEMA_INSTANCE_NS, "type")
+ else:
+ # update or create attribute
+ typename_utf8 = cetree.utf8(typename)
+ c_ns = cetree.findOrBuildNodeNsPrefix(
+ doc, c_node, _XML_SCHEMA_NS, 'xsd')
+ if c_ns is not NULL:
+ if b':' in typename_utf8:
+ prefix, name = typename_utf8.split(b':', 1)
+ if c_ns.prefix is NULL or c_ns.prefix[0] == c'\0':
+ typename_utf8 = name
+ elif tree.xmlStrcmp(_xcstr(prefix), c_ns.prefix) != 0:
+ typename_utf8 = (c_ns.prefix) + b':' + name
+ elif c_ns.prefix is not NULL and c_ns.prefix[0] != c'\0':
+ typename_utf8 = (c_ns.prefix) + b':' + typename_utf8
+ c_ns = cetree.findOrBuildNodeNsPrefix(
+ doc, c_node, _XML_SCHEMA_INSTANCE_NS, 'xsi')
+ tree.xmlSetNsProp(c_node, c_ns, "type", _xcstr(typename_utf8))
+
+ if annotate_pytype:
+ if pytype is None:
+ # delete attribute if it exists
+ cetree.delAttributeFromNsName(
+ c_node, _PYTYPE_NAMESPACE, _PYTYPE_ATTRIBUTE_NAME)
+ else:
+ # update or create attribute
+ c_ns = cetree.findOrBuildNodeNsPrefix(
+ doc, c_node, _PYTYPE_NAMESPACE, 'py')
+ pytype_name = cetree.utf8(pytype.name)
+ tree.xmlSetNsProp(c_node, c_ns, _PYTYPE_ATTRIBUTE_NAME,
+ _xcstr(pytype_name))
+ if pytype is NoneType:
+ c_ns = cetree.findOrBuildNodeNsPrefix(
+ doc, c_node, _XML_SCHEMA_INSTANCE_NS, 'xsi')
+ tree.xmlSetNsProp(c_node, c_ns, "nil", "true")
+
+ return 0
+
+cdef object _strip_attributes = etree.strip_attributes
+cdef object _cleanup_namespaces = etree.cleanup_namespaces
+
+def deannotate(element_or_tree, *, bint pytype=True, bint xsi=True,
+ bint xsi_nil=False, bint cleanup_namespaces=False):
+ """deannotate(element_or_tree, pytype=True, xsi=True, xsi_nil=False, cleanup_namespaces=False)
+
+ Recursively de-annotate the elements of an XML tree by removing 'py:pytype'
+ and/or 'xsi:type' attributes and/or 'xsi:nil' attributes.
+
+ If the 'pytype' keyword argument is True (the default), 'py:pytype'
+ attributes will be removed. If the 'xsi' keyword argument is True (the
+ default), 'xsi:type' attributes will be removed.
+ If the 'xsi_nil' keyword argument is True (default: False), 'xsi:nil'
+ attributes will be removed.
+
+ Note that this does not touch the namespace declarations by
+ default. If you want to remove unused namespace declarations from
+ the tree, pass the option ``cleanup_namespaces=True``.
+ """
+ cdef list attribute_names = []
+
+ if pytype:
+ attribute_names.append(PYTYPE_ATTRIBUTE)
+ if xsi:
+ attribute_names.append(XML_SCHEMA_INSTANCE_TYPE_ATTR)
+ if xsi_nil:
+ attribute_names.append(XML_SCHEMA_INSTANCE_NIL_ATTR)
+
+ _strip_attributes(element_or_tree, *attribute_names)
+ if cleanup_namespaces:
+ _cleanup_namespaces(element_or_tree)
+
+################################################################################
+# Module level parser setup
+
+cdef object __DEFAULT_PARSER
+__DEFAULT_PARSER = etree.XMLParser(remove_blank_text=True)
+__DEFAULT_PARSER.set_element_class_lookup( ObjectifyElementClassLookup() )
+
+cdef object objectify_parser
+objectify_parser = __DEFAULT_PARSER
+
+def set_default_parser(new_parser = None):
+ """set_default_parser(new_parser = None)
+
+ Replace the default parser used by objectify's Element() and
+ fromstring() functions.
+
+ The new parser must be an etree.XMLParser.
+
+ Call without arguments to reset to the original parser.
+ """
+ global objectify_parser
+ if new_parser is None:
+ objectify_parser = __DEFAULT_PARSER
+ elif isinstance(new_parser, etree.XMLParser):
+ objectify_parser = new_parser
+ else:
+ raise TypeError, "parser must inherit from lxml.etree.XMLParser"
+
+def makeparser(**kw):
+ """makeparser(remove_blank_text=True, **kw)
+
+ Create a new XML parser for objectify trees.
+
+ You can pass all keyword arguments that are supported by
+ ``etree.XMLParser()``. Note that this parser defaults to removing
+ blank text. You can disable this by passing the
+ ``remove_blank_text`` boolean keyword option yourself.
+ """
+ if 'remove_blank_text' not in kw:
+ kw['remove_blank_text'] = True
+ parser = etree.XMLParser(**kw)
+ parser.set_element_class_lookup( ObjectifyElementClassLookup() )
+ return parser
+
+cdef _Element _makeElement(tag, text, attrib, nsmap):
+ return cetree.makeElement(tag, None, objectify_parser, text, None, attrib, nsmap)
+
+################################################################################
+# Module level factory functions
+
+cdef object _fromstring
+_fromstring = etree.fromstring
+
+SubElement = etree.SubElement
+
+def fromstring(xml, parser=None, *, base_url=None):
+ """fromstring(xml, parser=None, base_url=None)
+
+ Objectify specific version of the lxml.etree fromstring() function
+ that uses the objectify parser.
+
+ You can pass a different parser as second argument.
+
+ The ``base_url`` keyword argument allows to set the original base URL of
+ the document to support relative Paths when looking up external entities
+ (DTD, XInclude, ...).
+ """
+ if parser is None:
+ parser = objectify_parser
+ return _fromstring(xml, parser, base_url=base_url)
+
+def XML(xml, parser=None, *, base_url=None):
+ """XML(xml, parser=None, base_url=None)
+
+ Objectify specific version of the lxml.etree XML() literal factory
+ that uses the objectify parser.
+
+ You can pass a different parser as second argument.
+
+ The ``base_url`` keyword argument allows to set the original base URL of
+ the document to support relative Paths when looking up external entities
+ (DTD, XInclude, ...).
+ """
+ if parser is None:
+ parser = objectify_parser
+ return _fromstring(xml, parser, base_url=base_url)
+
+cdef object _parse
+_parse = etree.parse
+
+def parse(f, parser=None, *, base_url=None):
+ """parse(f, parser=None, base_url=None)
+
+ Parse a file or file-like object with the objectify parser.
+
+ You can pass a different parser as second argument.
+
+ The ``base_url`` keyword allows setting a URL for the document
+ when parsing from a file-like object. This is needed when looking
+ up external entities (DTD, XInclude, ...) with relative paths.
+ """
+ if parser is None:
+ parser = objectify_parser
+ return _parse(f, parser, base_url=base_url)
+
+cdef dict _DEFAULT_NSMAP = {
+ "py" : PYTYPE_NAMESPACE,
+ "xsi" : XML_SCHEMA_INSTANCE_NS,
+ "xsd" : XML_SCHEMA_NS
+}
+
+E = ElementMaker()
+
+def Element(_tag, attrib=None, nsmap=None, *, _pytype=None, **_attributes):
+ """Element(_tag, attrib=None, nsmap=None, _pytype=None, **_attributes)
+
+ Objectify specific version of the lxml.etree Element() factory that
+ always creates a structural (tree) element.
+
+ NOTE: requires parser based element class lookup activated in lxml.etree!
+ """
+ if attrib is not None:
+ if _attributes:
+ attrib = dict(attrib)
+ attrib.update(_attributes)
+ _attributes = attrib
+ if _pytype is None:
+ _pytype = TREE_PYTYPE_NAME
+ if nsmap is None:
+ nsmap = _DEFAULT_NSMAP
+ _attributes[PYTYPE_ATTRIBUTE] = _pytype
+ return _makeElement(_tag, None, _attributes, nsmap)
+
+def DataElement(_value, attrib=None, nsmap=None, *, _pytype=None, _xsi=None,
+ **_attributes):
+ """DataElement(_value, attrib=None, nsmap=None, _pytype=None, _xsi=None, **_attributes)
+
+ Create a new element from a Python value and XML attributes taken from
+ keyword arguments or a dictionary passed as second argument.
+
+ Automatically adds a 'pytype' attribute for the Python type of the value,
+ if the type can be identified. If '_pytype' or '_xsi' are among the
+ keyword arguments, they will be used instead.
+
+ If the _value argument is an ObjectifiedDataElement instance, its py:pytype,
+ xsi:type and other attributes and nsmap are reused unless they are redefined
+ in attrib and/or keyword arguments.
+ """
+ if nsmap is None:
+ nsmap = _DEFAULT_NSMAP
+ if attrib is not None and attrib:
+ if _attributes:
+ attrib = dict(attrib)
+ attrib.update(_attributes)
+ _attributes = attrib
+ if isinstance(_value, ObjectifiedElement):
+ if _pytype is None:
+ if _xsi is None and not _attributes and nsmap is _DEFAULT_NSMAP:
+ # special case: no change!
+ return _value.__copy__()
+ if isinstance(_value, ObjectifiedDataElement):
+ # reuse existing nsmap unless redefined in nsmap parameter
+ temp = _value.nsmap
+ if temp is not None and temp:
+ temp = dict(temp)
+ temp.update(nsmap)
+ nsmap = temp
+ # reuse existing attributes unless redefined in attrib/_attributes
+ temp = _value.attrib
+ if temp is not None and temp:
+ temp = dict(temp)
+ temp.update(_attributes)
+ _attributes = temp
+ # reuse existing xsi:type or py:pytype attributes, unless provided as
+ # arguments
+ if _xsi is None and _pytype is None:
+ _xsi = _attributes.get(XML_SCHEMA_INSTANCE_TYPE_ATTR)
+ _pytype = _attributes.get(PYTYPE_ATTRIBUTE)
+
+ if _xsi is not None:
+ if ':' in _xsi:
+ prefix, name = _xsi.split(':', 1)
+ ns = nsmap.get(prefix)
+ if ns != XML_SCHEMA_NS:
+ raise ValueError, "XSD types require the XSD namespace"
+ elif nsmap is _DEFAULT_NSMAP:
+ name = _xsi
+ _xsi = 'xsd:' + _xsi
+ else:
+ name = _xsi
+ for prefix, ns in nsmap.items():
+ if ns == XML_SCHEMA_NS:
+ if prefix is not None and prefix:
+ _xsi = prefix + ':' + _xsi
+ break
+ else:
+ raise ValueError, "XSD types require the XSD namespace"
+ _attributes[XML_SCHEMA_INSTANCE_TYPE_ATTR] = _xsi
+ if _pytype is None:
+ # allow using unregistered or even wrong xsi:type names
+ py_type = _SCHEMA_TYPE_DICT.get(_xsi)
+ if py_type is None:
+ py_type = _SCHEMA_TYPE_DICT.get(name)
+ if py_type is not None:
+ _pytype = py_type.name
+
+ if _pytype is None:
+ _pytype = _pytypename(_value)
+
+ if _value is None and _pytype != "str":
+ _pytype = _pytype or "NoneType"
+ strval = None
+ elif python._isString(_value):
+ strval = _value
+ elif isinstance(_value, bool):
+ if _value:
+ strval = "true"
+ else:
+ strval = "false"
+ else:
+ py_type = _PYTYPE_DICT.get(_pytype)
+ stringify = unicode if py_type is None else py_type.stringify
+ strval = stringify(_value)
+
+ if _pytype is not None:
+ if _pytype == "NoneType" or _pytype == "none":
+ strval = None
+ _attributes[XML_SCHEMA_INSTANCE_NIL_ATTR] = "true"
+ else:
+ # check if type information from arguments is valid
+ py_type = _PYTYPE_DICT.get(_pytype)
+ if py_type is not None:
+ if py_type.type_check is not None:
+ py_type.type_check(strval)
+ _attributes[PYTYPE_ATTRIBUTE] = _pytype
+
+ return _makeElement("value", strval, _attributes, nsmap)
+
+
+################################################################################
+# ObjectPath
+
+include "objectpath.pxi"
diff --git a/llava_video/lib/python3.10/site-packages/lxml/objectpath.pxi b/llava_video/lib/python3.10/site-packages/lxml/objectpath.pxi
new file mode 100644
index 0000000000000000000000000000000000000000..e562a365015830bfd3d24650d1109fe891c31039
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/objectpath.pxi
@@ -0,0 +1,332 @@
+################################################################################
+# ObjectPath
+
+ctypedef struct _ObjectPath:
+ const_xmlChar* href
+ const_xmlChar* name
+ Py_ssize_t index
+
+
+cdef object _NO_DEFAULT = object()
+
+
+cdef class ObjectPath:
+ """ObjectPath(path)
+ Immutable object that represents a compiled object path.
+
+ Example for a path: 'root.child[1].{other}child[25]'
+ """
+ cdef readonly object find
+ cdef list _path
+ cdef object _path_str
+ cdef _ObjectPath* _c_path
+ cdef Py_ssize_t _path_len
+ def __init__(self, path):
+ if python._isString(path):
+ self._path = _parse_object_path_string(path)
+ self._path_str = path
+ else:
+ self._path = _parse_object_path_list(path)
+ self._path_str = '.'.join(path)
+ self._path_len = len(self._path)
+ self._c_path = _build_object_path_segments(self._path)
+ self.find = self.__call__
+
+ def __dealloc__(self):
+ if self._c_path is not NULL:
+ python.lxml_free(self._c_path)
+
+ def __str__(self):
+ return self._path_str
+
+ def __call__(self, _Element root not None, *_default):
+ """Follow the attribute path in the object structure and return the
+ target attribute value.
+
+ If it it not found, either returns a default value (if one was passed
+ as second argument) or raises AttributeError.
+ """
+ if _default:
+ if len(_default) > 1:
+ raise TypeError, "invalid number of arguments: needs one or two"
+ default = _default[0]
+ else:
+ default = _NO_DEFAULT
+ return _find_object_path(root, self._c_path, self._path_len, default)
+
+ def hasattr(self, _Element root not None):
+ "hasattr(self, root)"
+ try:
+ _find_object_path(root, self._c_path, self._path_len, _NO_DEFAULT)
+ except AttributeError:
+ return False
+ return True
+
+ def setattr(self, _Element root not None, value):
+ """setattr(self, root, value)
+
+ Set the value of the target element in a subtree.
+
+ If any of the children on the path does not exist, it is created.
+ """
+ _create_object_path(root, self._c_path, self._path_len, 1, value)
+
+ def addattr(self, _Element root not None, value):
+ """addattr(self, root, value)
+
+ Append a value to the target element in a subtree.
+
+ If any of the children on the path does not exist, it is created.
+ """
+ _create_object_path(root, self._c_path, self._path_len, 0, value)
+
+
+cdef object __MATCH_PATH_SEGMENT = re.compile(
+ r"(\.?)\s*(?:\{([^}]*)\})?\s*([^.{}\[\]\s]+)\s*(?:\[\s*([-0-9]+)\s*\])?",
+ re.U).match
+
+cdef tuple _RELATIVE_PATH_SEGMENT = (None, None, 0)
+
+
+cdef list _parse_object_path_string(_path):
+ """Parse object path string into a (ns, name, index) list.
+ """
+ cdef bint has_dot
+ cdef unicode path
+ new_path = []
+ if isinstance(_path, bytes):
+ path = (_path).decode('ascii')
+ elif type(_path) is not unicode:
+ path = unicode(_path)
+ else:
+ path = _path
+ path = path.strip()
+ if path == '.':
+ return [_RELATIVE_PATH_SEGMENT]
+ path_pos = 0
+ while path:
+ match = __MATCH_PATH_SEGMENT(path, path_pos)
+ if match is None:
+ break
+
+ dot, ns, name, index = match.groups()
+ index = int(index) if index else 0
+ has_dot = dot == '.'
+ if not new_path:
+ if has_dot:
+ # path '.child' => ignore root
+ new_path.append(_RELATIVE_PATH_SEGMENT)
+ elif index:
+ raise ValueError, "index not allowed on root node"
+ elif not has_dot:
+ raise ValueError, "invalid path"
+ if ns is not None:
+ ns = python.PyUnicode_AsUTF8String(ns)
+ name = python.PyUnicode_AsUTF8String(name)
+ new_path.append( (ns, name, index) )
+
+ path_pos = match.end()
+ if not new_path or len(path) > path_pos:
+ raise ValueError, "invalid path"
+ return new_path
+
+
+cdef list _parse_object_path_list(path):
+ """Parse object path sequence into a (ns, name, index) list.
+ """
+ new_path = []
+ for item in path:
+ item = item.strip()
+ if not new_path and item == '':
+ # path '.child' => ignore root
+ ns = name = None
+ index = 0
+ else:
+ ns, name = cetree.getNsTag(item)
+ c_name = _xcstr(name)
+ index_pos = tree.xmlStrchr(c_name, c'[')
+ if index_pos is NULL:
+ index = 0
+ else:
+ index_end = tree.xmlStrchr(index_pos + 1, c']')
+ if index_end is NULL:
+ raise ValueError, "index must be enclosed in []"
+ index = int(index_pos[1:index_end - index_pos])
+ if not new_path and index != 0:
+ raise ValueError, "index not allowed on root node"
+ name = c_name[:index_pos - c_name]
+ new_path.append( (ns, name, index) )
+ if not new_path:
+ raise ValueError, "invalid path"
+ return new_path
+
+
+cdef _ObjectPath* _build_object_path_segments(list path_list) except NULL:
+ cdef _ObjectPath* c_path
+ cdef _ObjectPath* c_path_segments
+ c_path_segments = <_ObjectPath*>python.lxml_malloc(len(path_list), sizeof(_ObjectPath))
+ if c_path_segments is NULL:
+ raise MemoryError()
+ c_path = c_path_segments
+ for href, name, index in path_list:
+ c_path[0].href = _xcstr(href) if href is not None else NULL
+ c_path[0].name = _xcstr(name) if name is not None else NULL
+ c_path[0].index = index
+ c_path += 1
+ return c_path_segments
+
+
+cdef _find_object_path(_Element root, _ObjectPath* c_path, Py_ssize_t c_path_len, default_value):
+ """Follow the path to find the target element.
+ """
+ cdef tree.xmlNode* c_node
+ cdef Py_ssize_t c_index
+ c_node = root._c_node
+ c_name = c_path[0].name
+ c_href = c_path[0].href
+ if c_href is NULL or c_href[0] == c'\0':
+ c_href = tree._getNs(c_node)
+ if not cetree.tagMatches(c_node, c_href, c_name):
+ if default_value is not _NO_DEFAULT:
+ return default_value
+ else:
+ raise ValueError(
+ f"root element does not match: need {cetree.namespacedNameFromNsName(c_href, c_name)}, got {root.tag}")
+
+ while c_node is not NULL:
+ c_path_len -= 1
+ if c_path_len <= 0:
+ break
+
+ c_path += 1
+ if c_path[0].href is not NULL:
+ c_href = c_path[0].href # otherwise: keep parent namespace
+ c_name = tree.xmlDictExists(c_node.doc.dict, c_path[0].name, -1)
+ if c_name is NULL:
+ c_name = c_path[0].name
+ c_node = NULL
+ break
+ c_index = c_path[0].index
+ c_node = c_node.last if c_index < 0 else c_node.children
+ c_node = _findFollowingSibling(c_node, c_href, c_name, c_index)
+
+ if c_node is not NULL:
+ return cetree.elementFactory(root._doc, c_node)
+ elif default_value is not _NO_DEFAULT:
+ return default_value
+ else:
+ tag = cetree.namespacedNameFromNsName(c_href, c_name)
+ raise AttributeError, f"no such child: {tag}"
+
+
+cdef _create_object_path(_Element root, _ObjectPath* c_path,
+ Py_ssize_t c_path_len, int replace, value):
+ """Follow the path to find the target element, build the missing children
+ as needed and set the target element to 'value'. If replace is true, an
+ existing value is replaced, otherwise the new value is added.
+ """
+ cdef _Element child
+ cdef tree.xmlNode* c_node
+ cdef tree.xmlNode* c_child
+ cdef Py_ssize_t c_index
+ if c_path_len == 1:
+ raise TypeError, "cannot update root node"
+
+ c_node = root._c_node
+ c_name = c_path[0].name
+ c_href = c_path[0].href
+ if c_href is NULL or c_href[0] == c'\0':
+ c_href = tree._getNs(c_node)
+ if not cetree.tagMatches(c_node, c_href, c_name):
+ raise ValueError(
+ f"root element does not match: need {cetree.namespacedNameFromNsName(c_href, c_name)}, got {root.tag}")
+
+ while c_path_len > 1:
+ c_path_len -= 1
+ c_path += 1
+ if c_path[0].href is not NULL:
+ c_href = c_path[0].href # otherwise: keep parent namespace
+ c_index = c_path[0].index
+ c_name = tree.xmlDictExists(c_node.doc.dict, c_path[0].name, -1)
+ if c_name is NULL:
+ c_name = c_path[0].name
+ c_child = NULL
+ else:
+ c_child = c_node.last if c_index < 0 else c_node.children
+ c_child = _findFollowingSibling(c_child, c_href, c_name, c_index)
+
+ if c_child is not NULL:
+ c_node = c_child
+ elif c_index != 0:
+ raise TypeError, "creating indexed path attributes is not supported"
+ elif c_path_len == 1:
+ _appendValue(cetree.elementFactory(root._doc, c_node),
+ cetree.namespacedNameFromNsName(c_href, c_name),
+ value)
+ return
+ else:
+ child = cetree.makeSubElement(
+ cetree.elementFactory(root._doc, c_node),
+ cetree.namespacedNameFromNsName(c_href, c_name),
+ None, None, None, None)
+ c_node = child._c_node
+
+ # if we get here, the entire path was already there
+ if replace:
+ element = cetree.elementFactory(root._doc, c_node)
+ _replaceElement(element, value)
+ else:
+ _appendValue(cetree.elementFactory(root._doc, c_node.parent),
+ cetree.namespacedName(c_node), value)
+
+
+cdef list _build_descendant_paths(tree.xmlNode* c_node, prefix_string):
+ """Returns a list of all descendant paths.
+ """
+ cdef list path, path_list
+ tag = cetree.namespacedName(c_node)
+ if prefix_string:
+ if prefix_string[-1] != '.':
+ prefix_string += '.'
+ prefix_string = prefix_string + tag
+ else:
+ prefix_string = tag
+ path = [prefix_string]
+ path_list = []
+ _recursive_build_descendant_paths(c_node, path, path_list)
+ return path_list
+
+
+cdef int _recursive_build_descendant_paths(tree.xmlNode* c_node,
+ list path, list path_list) except -1:
+ """Fills the list 'path_list' with all descendant paths, initial prefix
+ being in the list 'path'.
+ """
+ cdef tree.xmlNode* c_child
+ tags = {}
+ path_list.append('.'.join(path))
+ c_href = tree._getNs(c_node)
+ c_child = c_node.children
+ while c_child is not NULL:
+ while c_child.type != tree.XML_ELEMENT_NODE:
+ c_child = c_child.next
+ if c_child is NULL:
+ return 0
+ if c_href is tree._getNs(c_child):
+ tag = pyunicode(c_child.name)
+ elif c_href is not NULL and tree._getNs(c_child) is NULL:
+ # special case: parent has namespace, child does not
+ tag = '{}' + pyunicode(c_child.name)
+ else:
+ tag = cetree.namespacedName(c_child)
+ count = tags.get(tag)
+ if count is None:
+ tags[tag] = 1
+ else:
+ tags[tag] = count + 1
+ tag += f'[{count}]'
+ path.append(tag)
+ _recursive_build_descendant_paths(c_child, path, path_list)
+ del path[-1]
+ c_child = c_child.next
+ return 0
diff --git a/llava_video/lib/python3.10/site-packages/lxml/parser.pxi b/llava_video/lib/python3.10/site-packages/lxml/parser.pxi
new file mode 100644
index 0000000000000000000000000000000000000000..70337d87127888670d0fb3a396a1975b9052b354
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/parser.pxi
@@ -0,0 +1,2000 @@
+# Parsers for XML and HTML
+
+from lxml.includes cimport xmlparser
+from lxml.includes cimport htmlparser
+
+
+class ParseError(LxmlSyntaxError):
+ """Syntax error while parsing an XML document.
+
+ For compatibility with ElementTree 1.3 and later.
+ """
+ def __init__(self, message, code, line, column, filename=None):
+ super(_ParseError, self).__init__(message)
+ self.lineno, self.offset = (line, column - 1)
+ self.code = code
+ self.filename = filename
+
+ @property
+ def position(self):
+ return self.lineno, self.offset + 1
+
+ @position.setter
+ def position(self, new_pos):
+ self.lineno, column = new_pos
+ self.offset = column - 1
+
+cdef object _ParseError = ParseError
+
+
+class XMLSyntaxError(ParseError):
+ """Syntax error while parsing an XML document.
+ """
+
+cdef class ParserError(LxmlError):
+ """Internal lxml parser error.
+ """
+
+
+@cython.final
+@cython.internal
+cdef class _ParserDictionaryContext:
+ # Global parser context to share the string dictionary.
+ #
+ # This class is a delegate singleton!
+ #
+ # It creates _ParserDictionaryContext objects for each thread to keep thread state,
+ # but those must never be used directly. Always stick to using the static
+ # __GLOBAL_PARSER_CONTEXT as defined below the class.
+ #
+
+ cdef tree.xmlDict* _c_dict
+ cdef _BaseParser _default_parser
+ cdef list _implied_parser_contexts
+
+ def __cinit__(self):
+ self._c_dict = NULL
+ self._implied_parser_contexts = []
+
+ def __dealloc__(self):
+ if self._c_dict is not NULL:
+ xmlparser.xmlDictFree(self._c_dict)
+
+ cdef int initMainParserContext(self) except -1:
+ """Put the global context into the thread dictionary of the main
+ thread. To be called once and only in the main thread."""
+ thread_dict = python.PyThreadState_GetDict()
+ if thread_dict is not NULL:
+ (thread_dict)["_ParserDictionaryContext"] = self
+
+ cdef _ParserDictionaryContext _findThreadParserContext(self):
+ "Find (or create) the _ParserDictionaryContext object for the current thread"
+ cdef _ParserDictionaryContext context
+ thread_dict = python.PyThreadState_GetDict()
+ if thread_dict is NULL:
+ return self
+ d = thread_dict
+ result = python.PyDict_GetItem(d, "_ParserDictionaryContext")
+ if result is not NULL:
+ return result
+ context = <_ParserDictionaryContext>_ParserDictionaryContext.__new__(_ParserDictionaryContext)
+ d["_ParserDictionaryContext"] = context
+ return context
+
+ cdef int setDefaultParser(self, _BaseParser parser) except -1:
+ "Set the default parser for the current thread"
+ cdef _ParserDictionaryContext context
+ context = self._findThreadParserContext()
+ context._default_parser = parser
+
+ cdef _BaseParser getDefaultParser(self):
+ "Return (or create) the default parser of the current thread"
+ cdef _ParserDictionaryContext context
+ context = self._findThreadParserContext()
+ if context._default_parser is None:
+ if self._default_parser is None:
+ self._default_parser = __DEFAULT_XML_PARSER._copy()
+ if context is not self:
+ context._default_parser = self._default_parser._copy()
+ return context._default_parser
+
+ cdef tree.xmlDict* _getThreadDict(self, tree.xmlDict* default):
+ "Return the thread-local dict or create a new one if necessary."
+ cdef _ParserDictionaryContext context
+ context = self._findThreadParserContext()
+ if context._c_dict is NULL:
+ # thread dict not yet set up => use default or create a new one
+ if default is not NULL:
+ context._c_dict = default
+ xmlparser.xmlDictReference(default)
+ return default
+ if self._c_dict is NULL:
+ self._c_dict = xmlparser.xmlDictCreate()
+ if context is not self:
+ context._c_dict = xmlparser.xmlDictCreateSub(self._c_dict)
+ return context._c_dict
+
+ cdef int initThreadDictRef(self, tree.xmlDict** c_dict_ref) except -1:
+ c_dict = c_dict_ref[0]
+ c_thread_dict = self._getThreadDict(c_dict)
+ if c_dict is c_thread_dict:
+ return 0
+ if c_dict is not NULL:
+ xmlparser.xmlDictFree(c_dict)
+ c_dict_ref[0] = c_thread_dict
+ xmlparser.xmlDictReference(c_thread_dict)
+
+ cdef int initParserDict(self, xmlparser.xmlParserCtxt* pctxt) except -1:
+ "Assure we always use the same string dictionary."
+ self.initThreadDictRef(&pctxt.dict)
+ pctxt.dictNames = 1
+
+ cdef int initXPathParserDict(self, xpath.xmlXPathContext* pctxt) except -1:
+ "Assure we always use the same string dictionary."
+ self.initThreadDictRef(&pctxt.dict)
+
+ cdef int initDocDict(self, xmlDoc* result) except -1:
+ "Store dict of last object parsed if no shared dict yet"
+ # XXX We also free the result dict here if there already was one.
+ # This case should only occur for new documents with empty dicts,
+ # otherwise we'd free data that's in use => segfault
+ self.initThreadDictRef(&result.dict)
+
+ cdef _ParserContext findImpliedContext(self):
+ """Return any current implied xml parser context for the current
+ thread. This is used when the resolver functions are called
+ with an xmlParserCtxt that was generated from within libxml2
+ (i.e. without a _ParserContext) - which happens when parsing
+ schema and xinclude external references."""
+ cdef _ParserDictionaryContext context
+ cdef _ParserContext implied_context
+
+ # see if we have a current implied parser
+ context = self._findThreadParserContext()
+ if context._implied_parser_contexts:
+ implied_context = context._implied_parser_contexts[-1]
+ return implied_context
+ return None
+
+ cdef int pushImpliedContextFromParser(self, _BaseParser parser) except -1:
+ "Push a new implied context object taken from the parser."
+ if parser is not None:
+ self.pushImpliedContext(parser._getParserContext())
+ else:
+ self.pushImpliedContext(None)
+
+ cdef int pushImpliedContext(self, _ParserContext parser_context) except -1:
+ "Push a new implied context object."
+ cdef _ParserDictionaryContext context
+ context = self._findThreadParserContext()
+ context._implied_parser_contexts.append(parser_context)
+
+ cdef int popImpliedContext(self) except -1:
+ "Pop the current implied context object."
+ cdef _ParserDictionaryContext context
+ context = self._findThreadParserContext()
+ context._implied_parser_contexts.pop()
+
+cdef _ParserDictionaryContext __GLOBAL_PARSER_CONTEXT = _ParserDictionaryContext()
+__GLOBAL_PARSER_CONTEXT.initMainParserContext()
+
+############################################################
+## support for Python unicode I/O
+############################################################
+
+# name of Python Py_UNICODE encoding as known to libxml2
+cdef const_char* _PY_UNICODE_ENCODING = NULL
+
+cdef int _setupPythonUnicode() except -1:
+ """Sets _PY_UNICODE_ENCODING to the internal encoding name of Python unicode
+ strings if libxml2 supports reading native Python unicode. This depends
+ on iconv and the local Python installation, so we simply check if we find
+ a matching encoding handler.
+ """
+ cdef tree.xmlCharEncodingHandler* enchandler
+ cdef Py_ssize_t l
+ cdef const_char* enc
+ cdef Py_UNICODE *uchars = [c'<', c't', c'e', c's', c't', c'/', c'>']
+ cdef const_xmlChar* buffer = uchars
+ # apparently, libxml2 can't detect UTF-16 on some systems
+ if (buffer[0] == c'<' and buffer[1] == c'\0' and
+ buffer[2] == c't' and buffer[3] == c'\0'):
+ enc = "UTF-16LE"
+ elif (buffer[0] == c'\0' and buffer[1] == c'<' and
+ buffer[2] == c'\0' and buffer[3] == c't'):
+ enc = "UTF-16BE"
+ else:
+ # let libxml2 give it a try
+ enc = _findEncodingName(buffer, sizeof(Py_UNICODE) * 7)
+ if enc is NULL:
+ # not my fault, it's YOUR broken system :)
+ return 0
+ enchandler = tree.xmlFindCharEncodingHandler(enc)
+ if enchandler is not NULL:
+ global _PY_UNICODE_ENCODING
+ tree.xmlCharEncCloseFunc(enchandler)
+ _PY_UNICODE_ENCODING = enc
+ return 0
+
+cdef const_char* _findEncodingName(const_xmlChar* buffer, int size):
+ "Work around bug in libxml2: find iconv name of encoding on our own."
+ cdef tree.xmlCharEncoding enc
+ enc = tree.xmlDetectCharEncoding(buffer, size)
+ if enc == tree.XML_CHAR_ENCODING_UTF16LE:
+ if size >= 4 and (buffer[0] == b'\xFF' and
+ buffer[1] == b'\xFE' and
+ buffer[2] == 0 and buffer[3] == 0):
+ return "UTF-32LE" # according to BOM
+ else:
+ return "UTF-16LE"
+ elif enc == tree.XML_CHAR_ENCODING_UTF16BE:
+ return "UTF-16BE"
+ elif enc == tree.XML_CHAR_ENCODING_UCS4LE:
+ return "UCS-4LE"
+ elif enc == tree.XML_CHAR_ENCODING_UCS4BE:
+ return "UCS-4BE"
+ elif enc == tree.XML_CHAR_ENCODING_NONE:
+ return NULL
+ else:
+ # returns a constant char*, no need to free it
+ return tree.xmlGetCharEncodingName(enc)
+
+# Python 3.12 removed support for "Py_UNICODE".
+if python.PY_VERSION_HEX < 0x030C0000:
+ _setupPythonUnicode()
+
+
+cdef unicode _find_PyUCS4EncodingName():
+ """
+ Find a suitable encoding for Py_UCS4 PyUnicode strings in libxml2.
+ """
+ ustring = "\U0001F92A "
+ cdef const xmlChar* buffer = python.PyUnicode_DATA(ustring)
+ cdef Py_ssize_t py_buffer_len = python.PyUnicode_GET_LENGTH(ustring)
+
+ encoding_name = ''
+ cdef tree.xmlCharEncoding enc = tree.xmlDetectCharEncoding(buffer, py_buffer_len)
+ enchandler = tree.xmlGetCharEncodingHandler(enc)
+ if enchandler is not NULL:
+ try:
+ if enchandler.name:
+ encoding_name = enchandler.name.decode('UTF-8')
+ finally:
+ tree.xmlCharEncCloseFunc(enchandler)
+ else:
+ c_name = tree.xmlGetCharEncodingName(enc)
+ if c_name:
+ encoding_name = c_name.decode('UTF-8')
+
+
+ if encoding_name and not encoding_name.endswith('LE') and not encoding_name.endswith('BE'):
+ encoding_name += 'BE' if python.PY_BIG_ENDIAN else 'LE'
+ return encoding_name or None
+
+_pyucs4_encoding_name = _find_PyUCS4EncodingName()
+
+
+############################################################
+## support for file-like objects
+############################################################
+
+@cython.final
+@cython.internal
+cdef class _FileReaderContext:
+ cdef object _filelike
+ cdef object _encoding
+ cdef object _url
+ cdef object _bytes
+ cdef _ExceptionContext _exc_context
+ cdef Py_ssize_t _bytes_read
+ cdef char* _c_url
+ cdef bint _close_file_after_read
+
+ def __cinit__(self, filelike, exc_context not None, url, encoding=None, bint close_file=False):
+ self._exc_context = exc_context
+ self._filelike = filelike
+ self._close_file_after_read = close_file
+ self._encoding = encoding
+ if url is None:
+ self._c_url = NULL
+ else:
+ url = _encodeFilename(url)
+ self._c_url = _cstr(url)
+ self._url = url
+ self._bytes = b''
+ self._bytes_read = 0
+
+ cdef _close_file(self):
+ if self._filelike is None or not self._close_file_after_read:
+ return
+ try:
+ close = self._filelike.close
+ except AttributeError:
+ close = None
+ finally:
+ self._filelike = None
+ if close is not None:
+ close()
+
+ cdef xmlparser.xmlParserInputBuffer* _createParserInputBuffer(self) noexcept:
+ cdef xmlparser.xmlParserInputBuffer* c_buffer = xmlparser.xmlAllocParserInputBuffer(0)
+ if c_buffer:
+ c_buffer.readcallback = _readFilelikeParser
+ c_buffer.context = self
+ return c_buffer
+
+ cdef xmlparser.xmlParserInput* _createParserInput(
+ self, xmlparser.xmlParserCtxt* ctxt) noexcept:
+ cdef xmlparser.xmlParserInputBuffer* c_buffer = self._createParserInputBuffer()
+ if not c_buffer:
+ return NULL
+ return xmlparser.xmlNewIOInputStream(ctxt, c_buffer, 0)
+
+ cdef tree.xmlDtd* _readDtd(self) noexcept:
+ cdef xmlparser.xmlParserInputBuffer* c_buffer = self._createParserInputBuffer()
+ if not c_buffer:
+ return NULL
+ with nogil:
+ return xmlparser.xmlIOParseDTD(NULL, c_buffer, 0)
+
+ cdef xmlDoc* _readDoc(self, xmlparser.xmlParserCtxt* ctxt, int options) noexcept:
+ cdef xmlDoc* result
+ cdef void* c_callback_context = self
+ cdef char* c_encoding = _cstr(self._encoding) if self._encoding is not None else NULL
+
+ orig_options = ctxt.options
+ with nogil:
+ if ctxt.html:
+ result = htmlparser.htmlCtxtReadIO(
+ ctxt, _readFilelikeParser, NULL, c_callback_context,
+ self._c_url, c_encoding, options)
+ if result is not NULL:
+ if _fixHtmlDictNames(ctxt.dict, result) < 0:
+ tree.xmlFreeDoc(result)
+ result = NULL
+ else:
+ result = xmlparser.xmlCtxtReadIO(
+ ctxt, _readFilelikeParser, NULL, c_callback_context,
+ self._c_url, c_encoding, options)
+ ctxt.options = orig_options # work around libxml2 problem
+
+ try:
+ self._close_file()
+ except:
+ self._exc_context._store_raised()
+ finally:
+ return result # swallow any exceptions
+
+ cdef int copyToBuffer(self, char* c_buffer, int c_requested) noexcept:
+ cdef int c_byte_count = 0
+ cdef char* c_start
+ cdef Py_ssize_t byte_count, remaining
+ if self._bytes_read < 0:
+ return 0
+ try:
+ byte_count = python.PyBytes_GET_SIZE(self._bytes)
+ remaining = byte_count - self._bytes_read
+ while c_requested > remaining:
+ c_start = _cstr(self._bytes) + self._bytes_read
+ cstring_h.memcpy(c_buffer, c_start, remaining)
+ c_byte_count += remaining
+ c_buffer += remaining
+ c_requested -= remaining
+
+ self._bytes = self._filelike.read(c_requested)
+ if not isinstance(self._bytes, bytes):
+ if isinstance(self._bytes, unicode):
+ if self._encoding is None:
+ self._bytes = (self._bytes).encode('utf8')
+ else:
+ self._bytes = python.PyUnicode_AsEncodedString(
+ self._bytes, _cstr(self._encoding), NULL)
+ else:
+ self._close_file()
+ raise TypeError, \
+ "reading from file-like objects must return byte strings or unicode strings"
+
+ remaining = python.PyBytes_GET_SIZE(self._bytes)
+ if remaining == 0:
+ self._bytes_read = -1
+ self._close_file()
+ return c_byte_count
+ self._bytes_read = 0
+
+ if c_requested > 0:
+ c_start = _cstr(self._bytes) + self._bytes_read
+ cstring_h.memcpy(c_buffer, c_start, c_requested)
+ c_byte_count += c_requested
+ self._bytes_read += c_requested
+ except:
+ c_byte_count = -1
+ self._exc_context._store_raised()
+ try:
+ self._close_file()
+ except:
+ self._exc_context._store_raised()
+ finally:
+ return c_byte_count # swallow any exceptions
+
+cdef int _readFilelikeParser(void* ctxt, char* c_buffer, int c_size) noexcept with gil:
+ return (<_FileReaderContext>ctxt).copyToBuffer(c_buffer, c_size)
+
+cdef int _readFileParser(void* ctxt, char* c_buffer, int c_size) noexcept nogil:
+ return stdio.fread(c_buffer, 1, c_size, ctxt)
+
+############################################################
+## support for custom document loaders
+############################################################
+
+cdef xmlparser.xmlParserInput* _local_resolver(const_char* c_url, const_char* c_pubid,
+ xmlparser.xmlParserCtxt* c_context) noexcept with gil:
+ cdef _ResolverContext context
+ cdef xmlparser.xmlParserInput* c_input
+ cdef _InputDocument doc_ref
+ cdef _FileReaderContext file_context
+ # if there is no _ParserContext associated with the xmlParserCtxt
+ # passed, check to see if the thread state object has an implied
+ # context.
+ if c_context._private is not NULL:
+ context = <_ResolverContext>c_context._private
+ else:
+ context = __GLOBAL_PARSER_CONTEXT.findImpliedContext()
+
+ if context is None:
+ if __DEFAULT_ENTITY_LOADER is NULL:
+ return NULL
+ with nogil:
+ # free the GIL as we might do serious I/O here (e.g. HTTP)
+ c_input = __DEFAULT_ENTITY_LOADER(c_url, c_pubid, c_context)
+ return c_input
+
+ try:
+ if c_url is NULL:
+ url = None
+ else:
+ # parsing a related document (DTD etc.) => UTF-8 encoded URL?
+ url = _decodeFilename(c_url)
+ if c_pubid is NULL:
+ pubid = None
+ else:
+ pubid = funicode(c_pubid) # always UTF-8
+
+ doc_ref = context._resolvers.resolve(url, pubid, context)
+ except:
+ context._store_raised()
+ return NULL
+
+ if doc_ref is not None:
+ if doc_ref._type == PARSER_DATA_STRING:
+ data = doc_ref._data_bytes
+ filename = doc_ref._filename
+ if not filename:
+ filename = None
+ elif not isinstance(filename, bytes):
+ # most likely a text URL
+ filename = filename.encode('utf8')
+ if not isinstance(filename, bytes):
+ filename = None
+
+ c_input = xmlparser.xmlNewInputStream(c_context)
+ if c_input is not NULL:
+ if filename is not None:
+ c_input.filename = tree.xmlStrdup(_xcstr(filename))
+ c_input.base = _xcstr(data)
+ c_input.length = python.PyBytes_GET_SIZE(data)
+ c_input.cur = c_input.base
+ c_input.end = c_input.base + c_input.length
+ elif doc_ref._type == PARSER_DATA_FILENAME:
+ data = None
+ c_filename = _cstr(doc_ref._filename)
+ with nogil:
+ # free the GIL as we might do serious I/O here
+ c_input = xmlparser.xmlNewInputFromFile(
+ c_context, c_filename)
+ elif doc_ref._type == PARSER_DATA_FILE:
+ file_context = _FileReaderContext(doc_ref._file, context, url,
+ None, doc_ref._close_file)
+ c_input = file_context._createParserInput(c_context)
+ data = file_context
+ else:
+ data = None
+ c_input = NULL
+
+ if data is not None:
+ context._storage.add(data)
+ if c_input is not NULL:
+ return c_input
+
+ if __DEFAULT_ENTITY_LOADER is NULL:
+ return NULL
+
+ with nogil:
+ # free the GIL as we might do serious I/O here (e.g. HTTP)
+ c_input = __DEFAULT_ENTITY_LOADER(c_url, c_pubid, c_context)
+ return c_input
+
+cdef xmlparser.xmlExternalEntityLoader __DEFAULT_ENTITY_LOADER
+__DEFAULT_ENTITY_LOADER = xmlparser.xmlGetExternalEntityLoader()
+
+
+cdef xmlparser.xmlExternalEntityLoader _register_document_loader() noexcept nogil:
+ cdef xmlparser.xmlExternalEntityLoader old = xmlparser.xmlGetExternalEntityLoader()
+ xmlparser.xmlSetExternalEntityLoader(_local_resolver)
+ return old
+
+cdef void _reset_document_loader(xmlparser.xmlExternalEntityLoader old) noexcept nogil:
+ xmlparser.xmlSetExternalEntityLoader(old)
+
+
+############################################################
+## Parsers
+############################################################
+
+@cython.no_gc_clear # May have to call "self._validator.disconnect()" on dealloc.
+@cython.internal
+cdef class _ParserContext(_ResolverContext):
+ cdef _ErrorLog _error_log
+ cdef _ParserSchemaValidationContext _validator
+ cdef xmlparser.xmlParserCtxt* _c_ctxt
+ cdef xmlparser.xmlExternalEntityLoader _orig_loader
+ cdef python.PyThread_type_lock _lock
+ cdef _Document _doc
+ cdef bint _collect_ids
+
+ def __cinit__(self):
+ self._c_ctxt = NULL
+ self._collect_ids = True
+ if not config.ENABLE_THREADING:
+ self._lock = NULL
+ else:
+ self._lock = python.PyThread_allocate_lock()
+ self._error_log = _ErrorLog()
+
+ def __dealloc__(self):
+ if config.ENABLE_THREADING and self._lock is not NULL:
+ python.PyThread_free_lock(self._lock)
+ self._lock = NULL
+ if self._c_ctxt is not NULL:
+ if self._validator is not NULL and self._validator is not None:
+ # If the parser was not closed correctly (e.g. interrupted iterparse()),
+ # and the schema validator wasn't freed and cleaned up yet, the libxml2 SAX
+ # validator plug might still be in place, which will make xmlFreeParserCtxt()
+ # crash when trying to xmlFree() a static SAX handler.
+ # Thus, make sure we disconnect the handler interceptor here at the latest.
+ self._validator.disconnect()
+ xmlparser.xmlFreeParserCtxt(self._c_ctxt)
+
+ cdef _ParserContext _copy(self):
+ cdef _ParserContext context
+ context = self.__class__()
+ context._collect_ids = self._collect_ids
+ context._validator = self._validator.copy()
+ _initParserContext(context, self._resolvers._copy(), NULL)
+ return context
+
+ cdef void _initParserContext(self, xmlparser.xmlParserCtxt* c_ctxt) noexcept:
+ self._c_ctxt = c_ctxt
+ c_ctxt._private = self
+
+ cdef void _resetParserContext(self) noexcept:
+ if self._c_ctxt is not NULL:
+ if self._c_ctxt.html:
+ htmlparser.htmlCtxtReset(self._c_ctxt)
+ self._c_ctxt.disableSAX = 0 # work around bug in libxml2
+ else:
+ xmlparser.xmlClearParserCtxt(self._c_ctxt)
+ # work around bug in libxml2 [2.9.10 .. 2.9.14]:
+ # https://gitlab.gnome.org/GNOME/libxml2/-/issues/378
+ self._c_ctxt.nsNr = 0
+
+ cdef int prepare(self, bint set_document_loader=True) except -1:
+ cdef int result
+ if config.ENABLE_THREADING and self._lock is not NULL:
+ with nogil:
+ result = python.PyThread_acquire_lock(
+ self._lock, python.WAIT_LOCK)
+ if result == 0:
+ raise ParserError, "parser locking failed"
+ self._error_log.clear()
+ self._doc = None
+ # Need a cast here because older libxml2 releases do not use 'const' in the functype.
+ self._c_ctxt.sax.serror = _receiveParserError
+ self._orig_loader = _register_document_loader() if set_document_loader else NULL
+ if self._validator is not None:
+ self._validator.connect(self._c_ctxt, self._error_log)
+ return 0
+
+ cdef int cleanup(self) except -1:
+ if self._orig_loader is not NULL:
+ _reset_document_loader(self._orig_loader)
+ try:
+ if self._validator is not None:
+ self._validator.disconnect()
+ self._resetParserContext()
+ self.clear()
+ self._doc = None
+ self._c_ctxt.sax.serror = NULL
+ finally:
+ if config.ENABLE_THREADING and self._lock is not NULL:
+ python.PyThread_release_lock(self._lock)
+ return 0
+
+ cdef object _handleParseResult(self, _BaseParser parser,
+ xmlDoc* result, filename):
+ c_doc = self._handleParseResultDoc(parser, result, filename)
+ if self._doc is not None and self._doc._c_doc is c_doc:
+ return self._doc
+ else:
+ return _documentFactory(c_doc, parser)
+
+ cdef xmlDoc* _handleParseResultDoc(self, _BaseParser parser,
+ xmlDoc* result, filename) except NULL:
+ recover = parser._parse_options & xmlparser.XML_PARSE_RECOVER
+ return _handleParseResult(self, self._c_ctxt, result,
+ filename, recover,
+ free_doc=self._doc is None)
+
+cdef _initParserContext(_ParserContext context,
+ _ResolverRegistry resolvers,
+ xmlparser.xmlParserCtxt* c_ctxt):
+ _initResolverContext(context, resolvers)
+ if c_ctxt is not NULL:
+ context._initParserContext(c_ctxt)
+
+cdef void _forwardParserError(xmlparser.xmlParserCtxt* _parser_context, const xmlerror.xmlError* error) noexcept with gil:
+ (<_ParserContext>_parser_context._private)._error_log._receive(error)
+
+cdef void _receiveParserError(void* c_context, const xmlerror.xmlError* error) noexcept nogil:
+ if __DEBUG:
+ if c_context is NULL or (c_context)._private is NULL:
+ _forwardError(NULL, error)
+ else:
+ _forwardParserError(c_context, error)
+
+cdef int _raiseParseError(xmlparser.xmlParserCtxt* ctxt, filename,
+ _ErrorLog error_log) except -1:
+ if filename is not None and \
+ ctxt.lastError.domain == xmlerror.XML_FROM_IO:
+ if isinstance(filename, bytes):
+ filename = _decodeFilenameWithLength(
+ filename, len(filename))
+ if ctxt.lastError.message is not NULL:
+ try:
+ message = ctxt.lastError.message.decode('utf-8')
+ except UnicodeDecodeError:
+ # the filename may be in there => play it safe
+ message = ctxt.lastError.message.decode('iso8859-1')
+ message = f"Error reading file '{filename}': {message.strip()}"
+ else:
+ message = f"Error reading '{filename}'"
+ raise IOError, message
+ elif error_log:
+ raise error_log._buildParseException(
+ XMLSyntaxError, "Document is not well formed")
+ elif ctxt.lastError.message is not NULL:
+ message = ctxt.lastError.message.strip()
+ code = ctxt.lastError.code
+ line = ctxt.lastError.line
+ column = ctxt.lastError.int2
+ if ctxt.lastError.line > 0:
+ message = f"line {line}: {message}"
+ raise XMLSyntaxError(message, code, line, column, filename)
+ else:
+ raise XMLSyntaxError(None, xmlerror.XML_ERR_INTERNAL_ERROR, 0, 0,
+ filename)
+
+cdef xmlDoc* _handleParseResult(_ParserContext context,
+ xmlparser.xmlParserCtxt* c_ctxt,
+ xmlDoc* result, filename,
+ bint recover, bint free_doc) except NULL:
+ cdef bint well_formed
+ if result is not NULL:
+ __GLOBAL_PARSER_CONTEXT.initDocDict(result)
+
+ if c_ctxt.myDoc is not NULL:
+ if c_ctxt.myDoc is not result:
+ __GLOBAL_PARSER_CONTEXT.initDocDict(c_ctxt.myDoc)
+ tree.xmlFreeDoc(c_ctxt.myDoc)
+ c_ctxt.myDoc = NULL
+
+ if result is not NULL:
+ if (context._validator is not None and
+ not context._validator.isvalid()):
+ well_formed = 0 # actually not 'valid', but anyway ...
+ elif (not c_ctxt.wellFormed and not c_ctxt.html and
+ c_ctxt.charset == tree.XML_CHAR_ENCODING_8859_1 and
+ [1 for error in context._error_log
+ if error.type == ErrorTypes.ERR_INVALID_CHAR]):
+ # An encoding error occurred and libxml2 switched from UTF-8
+ # input to (undecoded) Latin-1, at some arbitrary point in the
+ # document. Better raise an error than allowing for a broken
+ # tree with mixed encodings. This is fixed in libxml2 2.12.
+ well_formed = 0
+ elif recover or (c_ctxt.wellFormed and
+ c_ctxt.lastError.level < xmlerror.XML_ERR_ERROR):
+ well_formed = 1
+ elif not c_ctxt.replaceEntities and not c_ctxt.validate \
+ and context is not None:
+ # in this mode, we ignore errors about undefined entities
+ for error in context._error_log.filter_from_errors():
+ if error.type != ErrorTypes.WAR_UNDECLARED_ENTITY and \
+ error.type != ErrorTypes.ERR_UNDECLARED_ENTITY:
+ well_formed = 0
+ break
+ else:
+ well_formed = 1
+ else:
+ well_formed = 0
+
+ if not well_formed:
+ if free_doc:
+ tree.xmlFreeDoc(result)
+ result = NULL
+
+ if context is not None and context._has_raised():
+ if result is not NULL:
+ if free_doc:
+ tree.xmlFreeDoc(result)
+ result = NULL
+ context._raise_if_stored()
+
+ if result is NULL:
+ if context is not None:
+ _raiseParseError(c_ctxt, filename, context._error_log)
+ else:
+ _raiseParseError(c_ctxt, filename, None)
+ else:
+ if result.URL is NULL and filename is not None:
+ result.URL = tree.xmlStrdup(_xcstr(filename))
+ if result.encoding is NULL:
+ result.encoding = tree.xmlStrdup("UTF-8")
+
+ if context._validator is not None and \
+ context._validator._add_default_attributes:
+ # we currently need to do this here as libxml2 does not
+ # support inserting default attributes during parse-time
+ # validation
+ context._validator.inject_default_attributes(result)
+
+ return result
+
+cdef int _fixHtmlDictNames(tree.xmlDict* c_dict, xmlDoc* c_doc) noexcept nogil:
+ cdef xmlNode* c_node
+ if c_doc is NULL:
+ return 0
+ c_node = c_doc.children
+ tree.BEGIN_FOR_EACH_ELEMENT_FROM(c_doc, c_node, 1)
+ if c_node.type == tree.XML_ELEMENT_NODE:
+ if _fixHtmlDictNodeNames(c_dict, c_node) < 0:
+ return -1
+ tree.END_FOR_EACH_ELEMENT_FROM(c_node)
+ return 0
+
+cdef int _fixHtmlDictSubtreeNames(tree.xmlDict* c_dict, xmlDoc* c_doc,
+ xmlNode* c_start_node) noexcept nogil:
+ """
+ Move names to the dict, iterating in document order, starting at
+ c_start_node. This is used in incremental parsing after each chunk.
+ """
+ cdef xmlNode* c_node
+ if not c_doc:
+ return 0
+ if not c_start_node:
+ return _fixHtmlDictNames(c_dict, c_doc)
+ c_node = c_start_node
+ tree.BEGIN_FOR_EACH_ELEMENT_FROM(c_doc, c_node, 1)
+ if c_node.type == tree.XML_ELEMENT_NODE:
+ if _fixHtmlDictNodeNames(c_dict, c_node) < 0:
+ return -1
+ tree.END_FOR_EACH_ELEMENT_FROM(c_node)
+ return 0
+
+cdef inline int _fixHtmlDictNodeNames(tree.xmlDict* c_dict,
+ xmlNode* c_node) noexcept nogil:
+ cdef xmlNode* c_attr
+ c_name = tree.xmlDictLookup(c_dict, c_node.name, -1)
+ if c_name is NULL:
+ return -1
+ if c_name is not c_node.name:
+ tree.xmlFree(c_node.name)
+ c_node.name = c_name
+ c_attr = c_node.properties
+ while c_attr is not NULL:
+ c_name = tree.xmlDictLookup(c_dict, c_attr.name, -1)
+ if c_name is NULL:
+ return -1
+ if c_name is not c_attr.name:
+ tree.xmlFree(c_attr.name)
+ c_attr.name = c_name
+ c_attr = c_attr.next
+ return 0
+
+
+@cython.internal
+cdef class _BaseParser:
+ cdef ElementClassLookup _class_lookup
+ cdef _ResolverRegistry _resolvers
+ cdef _ParserContext _parser_context
+ cdef _ParserContext _push_parser_context
+ cdef int _parse_options
+ cdef bint _for_html
+ cdef bint _remove_comments
+ cdef bint _remove_pis
+ cdef bint _strip_cdata
+ cdef bint _collect_ids
+ cdef bint _resolve_external_entities
+ cdef XMLSchema _schema
+ cdef bytes _filename
+ cdef readonly object target
+ cdef object _default_encoding
+ cdef tuple _events_to_collect # (event_types, tag)
+
+ def __init__(self, int parse_options, bint for_html, XMLSchema schema,
+ remove_comments, remove_pis, strip_cdata, collect_ids,
+ target, encoding, bint resolve_external_entities=True):
+ cdef tree.xmlCharEncodingHandler* enchandler
+ cdef int c_encoding
+ if not isinstance(self, (XMLParser, HTMLParser)):
+ raise TypeError, "This class cannot be instantiated"
+
+ self._parse_options = parse_options
+ self.target = target
+ self._for_html = for_html
+ self._remove_comments = remove_comments
+ self._remove_pis = remove_pis
+ self._strip_cdata = strip_cdata
+ self._collect_ids = collect_ids
+ self._resolve_external_entities = resolve_external_entities
+ self._schema = schema
+
+ self._resolvers = _ResolverRegistry()
+
+ if encoding is None:
+ self._default_encoding = None
+ else:
+ encoding = _utf8(encoding)
+ enchandler = tree.xmlFindCharEncodingHandler(_cstr(encoding))
+ if enchandler is NULL:
+ raise LookupError, f"unknown encoding: '{encoding}'"
+ tree.xmlCharEncCloseFunc(enchandler)
+ self._default_encoding = encoding
+
+ cdef _setBaseURL(self, base_url):
+ self._filename = _encodeFilename(base_url)
+
+ cdef _collectEvents(self, event_types, tag):
+ if event_types is None:
+ event_types = ()
+ else:
+ event_types = tuple(set(event_types))
+ _buildParseEventFilter(event_types) # purely for validation
+ self._events_to_collect = (event_types, tag)
+
+ cdef _ParserContext _getParserContext(self):
+ cdef xmlparser.xmlParserCtxt* pctxt
+ if self._parser_context is None:
+ self._parser_context = self._createContext(self.target, None)
+ self._parser_context._collect_ids = self._collect_ids
+ if self._schema is not None:
+ self._parser_context._validator = \
+ self._schema._newSaxValidator(
+ self._parse_options & xmlparser.XML_PARSE_DTDATTR)
+ pctxt = self._newParserCtxt()
+ _initParserContext(self._parser_context, self._resolvers, pctxt)
+ self._configureSaxContext(pctxt)
+ return self._parser_context
+
+ cdef _ParserContext _getPushParserContext(self):
+ cdef xmlparser.xmlParserCtxt* pctxt
+ if self._push_parser_context is None:
+ self._push_parser_context = self._createContext(
+ self.target, self._events_to_collect)
+ self._push_parser_context._collect_ids = self._collect_ids
+ if self._schema is not None:
+ self._push_parser_context._validator = \
+ self._schema._newSaxValidator(
+ self._parse_options & xmlparser.XML_PARSE_DTDATTR)
+ pctxt = self._newPushParserCtxt()
+ _initParserContext(
+ self._push_parser_context, self._resolvers, pctxt)
+ self._configureSaxContext(pctxt)
+ return self._push_parser_context
+
+ cdef _ParserContext _createContext(self, target, events_to_collect):
+ cdef _SaxParserContext sax_context
+ if target is not None:
+ sax_context = _TargetParserContext(self)
+ (<_TargetParserContext>sax_context)._setTarget(target)
+ elif events_to_collect:
+ sax_context = _SaxParserContext(self)
+ else:
+ # nothing special to configure
+ return _ParserContext()
+ if events_to_collect:
+ events, tag = events_to_collect
+ sax_context._setEventFilter(events, tag)
+ return sax_context
+
+ @cython.final
+ cdef int _configureSaxContext(self, xmlparser.xmlParserCtxt* pctxt) except -1:
+ if self._remove_comments:
+ pctxt.sax.comment = NULL
+ if self._remove_pis:
+ pctxt.sax.processingInstruction = NULL
+ if self._strip_cdata:
+ # hard switch-off for CDATA nodes => makes them plain text
+ pctxt.sax.cdataBlock = NULL
+ if not self._resolve_external_entities:
+ pctxt.sax.getEntity = _getInternalEntityOnly
+
+ cdef int _registerHtmlErrorHandler(self, xmlparser.xmlParserCtxt* c_ctxt) except -1:
+ cdef xmlparser.xmlSAXHandler* sax = c_ctxt.sax
+ if sax is not NULL and sax.initialized and sax.initialized != xmlparser.XML_SAX2_MAGIC:
+ # need to extend SAX1 context to SAX2 to get proper error reports
+ if sax is &htmlparser.htmlDefaultSAXHandler:
+ sax = tree.xmlMalloc(sizeof(xmlparser.xmlSAXHandler))
+ if sax is NULL:
+ raise MemoryError()
+ cstring_h.memcpy(sax, &htmlparser.htmlDefaultSAXHandler,
+ sizeof(htmlparser.htmlDefaultSAXHandler))
+ c_ctxt.sax = sax
+ sax.initialized = xmlparser.XML_SAX2_MAGIC
+ # Need a cast here because older libxml2 releases do not use 'const' in the functype.
+ sax.serror = _receiveParserError
+ sax.startElementNs = NULL
+ sax.endElementNs = NULL
+ sax._private = NULL
+ return 0
+
+ cdef xmlparser.xmlParserCtxt* _newParserCtxt(self) except NULL:
+ cdef xmlparser.xmlParserCtxt* c_ctxt
+ if self._for_html:
+ c_ctxt = htmlparser.htmlCreateMemoryParserCtxt('dummy', 5)
+ if c_ctxt is not NULL:
+ self._registerHtmlErrorHandler(c_ctxt)
+ else:
+ c_ctxt = xmlparser.xmlNewParserCtxt()
+ if c_ctxt is NULL:
+ raise MemoryError
+ c_ctxt.sax.startDocument = _initSaxDocument
+ return c_ctxt
+
+ cdef xmlparser.xmlParserCtxt* _newPushParserCtxt(self) except NULL:
+ cdef xmlparser.xmlParserCtxt* c_ctxt
+ cdef char* c_filename = _cstr(self._filename) if self._filename is not None else NULL
+ if self._for_html:
+ c_ctxt = htmlparser.htmlCreatePushParserCtxt(
+ NULL, NULL, NULL, 0, c_filename, tree.XML_CHAR_ENCODING_NONE)
+ if c_ctxt is not NULL:
+ self._registerHtmlErrorHandler(c_ctxt)
+ htmlparser.htmlCtxtUseOptions(c_ctxt, self._parse_options)
+ else:
+ c_ctxt = xmlparser.xmlCreatePushParserCtxt(
+ NULL, NULL, NULL, 0, c_filename)
+ if c_ctxt is not NULL:
+ xmlparser.xmlCtxtUseOptions(c_ctxt, self._parse_options)
+ if c_ctxt is NULL:
+ raise MemoryError()
+ c_ctxt.sax.startDocument = _initSaxDocument
+ return c_ctxt
+
+ @property
+ def error_log(self):
+ """The error log of the last parser run.
+ """
+ cdef _ParserContext context
+ context = self._getParserContext()
+ return context._error_log.copy()
+
+ @property
+ def resolvers(self):
+ """The custom resolver registry of this parser."""
+ return self._resolvers
+
+ @property
+ def version(self):
+ """The version of the underlying XML parser."""
+ return "libxml2 %d.%d.%d" % LIBXML_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._class_lookup = lookup
+
+ cdef _BaseParser _copy(self):
+ "Create a new parser with the same configuration."
+ cdef _BaseParser parser
+ parser = self.__class__()
+ parser._parse_options = self._parse_options
+ parser._for_html = self._for_html
+ parser._remove_comments = self._remove_comments
+ parser._remove_pis = self._remove_pis
+ parser._strip_cdata = self._strip_cdata
+ parser._filename = self._filename
+ parser._resolvers = self._resolvers
+ parser.target = self.target
+ parser._class_lookup = self._class_lookup
+ parser._default_encoding = self._default_encoding
+ parser._schema = self._schema
+ parser._events_to_collect = self._events_to_collect
+ return parser
+
+ def copy(self):
+ """copy(self)
+
+ Create a new parser with the same configuration.
+ """
+ return self._copy()
+
+ 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.
+ """
+ return _makeElement(_tag, NULL, None, self, None, None,
+ attrib, nsmap, _extra)
+
+ # internal parser methods
+
+ cdef xmlDoc* _parseUnicodeDoc(self, utext, char* c_filename) except NULL:
+ """Parse unicode document, share dictionary if possible.
+ """
+ cdef _ParserContext context
+ cdef xmlDoc* result
+ cdef xmlparser.xmlParserCtxt* pctxt
+ cdef Py_ssize_t py_buffer_len
+ cdef int buffer_len, c_kind
+ cdef const_char* c_text
+ cdef const_char* c_encoding = _PY_UNICODE_ENCODING
+ if python.PyUnicode_IS_READY(utext):
+ # PEP-393 string
+ c_text = python.PyUnicode_DATA(utext)
+ py_buffer_len = python.PyUnicode_GET_LENGTH(utext)
+ c_kind = python.PyUnicode_KIND(utext)
+ if c_kind == 1:
+ if python.PyUnicode_MAX_CHAR_VALUE(utext) <= 127:
+ c_encoding = 'UTF-8'
+ else:
+ c_encoding = 'ISO-8859-1'
+ elif c_kind == 2:
+ py_buffer_len *= 2
+ if python.PY_BIG_ENDIAN:
+ c_encoding = 'UTF-16BE' # actually UCS-2
+ else:
+ c_encoding = 'UTF-16LE' # actually UCS-2
+ elif c_kind == 4:
+ py_buffer_len *= 4
+ if python.PY_BIG_ENDIAN:
+ c_encoding = 'UTF-32BE' # actually UCS-4
+ else:
+ c_encoding = 'UTF-32LE' # actually UCS-4
+ else:
+ assert False, f"Illegal Unicode kind {c_kind}"
+ else:
+ # old Py_UNICODE string
+ py_buffer_len = python.PyUnicode_GET_DATA_SIZE(utext)
+ c_text = python.PyUnicode_AS_DATA(utext)
+ assert 0 <= py_buffer_len <= limits.INT_MAX
+ buffer_len = py_buffer_len
+
+ context = self._getParserContext()
+ context.prepare()
+ try:
+ pctxt = context._c_ctxt
+ __GLOBAL_PARSER_CONTEXT.initParserDict(pctxt)
+ orig_options = pctxt.options
+ with nogil:
+ if self._for_html:
+ result = htmlparser.htmlCtxtReadMemory(
+ pctxt, c_text, buffer_len, c_filename, c_encoding,
+ self._parse_options)
+ if result is not NULL:
+ if _fixHtmlDictNames(pctxt.dict, result) < 0:
+ tree.xmlFreeDoc(result)
+ result = NULL
+ else:
+ result = xmlparser.xmlCtxtReadMemory(
+ pctxt, c_text, buffer_len, c_filename, c_encoding,
+ self._parse_options)
+ pctxt.options = orig_options # work around libxml2 problem
+
+ return context._handleParseResultDoc(self, result, None)
+ finally:
+ context.cleanup()
+
+ cdef xmlDoc* _parseDoc(self, char* c_text, int c_len,
+ char* c_filename) except NULL:
+ """Parse document, share dictionary if possible.
+ """
+ cdef _ParserContext context
+ cdef xmlDoc* result
+ cdef xmlparser.xmlParserCtxt* pctxt
+ cdef char* c_encoding
+ cdef tree.xmlCharEncoding enc
+ context = self._getParserContext()
+ context.prepare()
+ try:
+ pctxt = context._c_ctxt
+ __GLOBAL_PARSER_CONTEXT.initParserDict(pctxt)
+
+ if self._default_encoding is None:
+ c_encoding = NULL
+ # libxml2 (at least 2.9.3) does not recognise UTF-32 BOMs
+ # NOTE: limit to problematic cases because it changes character offsets
+ if c_len >= 4 and (c_text[0] == b'\xFF' and c_text[1] == b'\xFE' and
+ c_text[2] == 0 and c_text[3] == 0):
+ c_encoding = "UTF-32LE"
+ c_text += 4
+ c_len -= 4
+ elif c_len >= 4 and (c_text[0] == 0 and c_text[1] == 0 and
+ c_text[2] == b'\xFE' and c_text[3] == b'\xFF'):
+ c_encoding = "UTF-32BE"
+ c_text += 4
+ c_len -= 4
+ else:
+ # no BOM => try to determine encoding
+ enc = tree.xmlDetectCharEncoding(c_text, c_len)
+ if enc == tree.XML_CHAR_ENCODING_UCS4LE:
+ c_encoding = 'UTF-32LE'
+ elif enc == tree.XML_CHAR_ENCODING_UCS4BE:
+ c_encoding = 'UTF-32BE'
+ else:
+ c_encoding = _cstr(self._default_encoding)
+
+ orig_options = pctxt.options
+ with nogil:
+ if self._for_html:
+ result = htmlparser.htmlCtxtReadMemory(
+ pctxt, c_text, c_len, c_filename,
+ c_encoding, self._parse_options)
+ if result is not NULL:
+ if _fixHtmlDictNames(pctxt.dict, result) < 0:
+ tree.xmlFreeDoc(result)
+ result = NULL
+ else:
+ result = xmlparser.xmlCtxtReadMemory(
+ pctxt, c_text, c_len, c_filename,
+ c_encoding, self._parse_options)
+ pctxt.options = orig_options # work around libxml2 problem
+
+ return context._handleParseResultDoc(self, result, None)
+ finally:
+ context.cleanup()
+
+ cdef xmlDoc* _parseDocFromFile(self, char* c_filename) except NULL:
+ cdef _ParserContext context
+ cdef xmlDoc* result
+ cdef xmlparser.xmlParserCtxt* pctxt
+ cdef char* c_encoding
+ result = NULL
+
+ context = self._getParserContext()
+ context.prepare()
+ try:
+ pctxt = context._c_ctxt
+ __GLOBAL_PARSER_CONTEXT.initParserDict(pctxt)
+
+ if self._default_encoding is None:
+ c_encoding = NULL
+ else:
+ c_encoding = _cstr(self._default_encoding)
+
+ orig_options = pctxt.options
+ with nogil:
+ if self._for_html:
+ result = htmlparser.htmlCtxtReadFile(
+ pctxt, c_filename, c_encoding, self._parse_options)
+ if result is not NULL:
+ if _fixHtmlDictNames(pctxt.dict, result) < 0:
+ tree.xmlFreeDoc(result)
+ result = NULL
+ else:
+ result = xmlparser.xmlCtxtReadFile(
+ pctxt, c_filename, c_encoding, self._parse_options)
+ pctxt.options = orig_options # work around libxml2 problem
+
+ return context._handleParseResultDoc(self, result, c_filename)
+ finally:
+ context.cleanup()
+
+ cdef xmlDoc* _parseDocFromFilelike(self, filelike, filename,
+ encoding) except NULL:
+ cdef _ParserContext context
+ cdef _FileReaderContext file_context
+ cdef xmlDoc* result
+ cdef xmlparser.xmlParserCtxt* pctxt
+ cdef char* c_filename
+ if not filename:
+ filename = None
+
+ context = self._getParserContext()
+ context.prepare()
+ try:
+ pctxt = context._c_ctxt
+ __GLOBAL_PARSER_CONTEXT.initParserDict(pctxt)
+ file_context = _FileReaderContext(
+ filelike, context, filename,
+ encoding or self._default_encoding)
+ result = file_context._readDoc(pctxt, self._parse_options)
+
+ return context._handleParseResultDoc(
+ self, result, filename)
+ finally:
+ context.cleanup()
+
+
+cdef tree.xmlEntity* _getInternalEntityOnly(void* ctxt, const_xmlChar* name) noexcept nogil:
+ """
+ Callback function to intercept the entity resolution when external entity loading is disabled.
+ """
+ cdef tree.xmlEntity* entity = xmlparser.xmlSAX2GetEntity(ctxt, name)
+ if not entity:
+ return NULL
+ if entity.etype not in (
+ tree.xmlEntityType.XML_EXTERNAL_GENERAL_PARSED_ENTITY,
+ tree.xmlEntityType.XML_EXTERNAL_GENERAL_UNPARSED_ENTITY,
+ tree.xmlEntityType.XML_EXTERNAL_PARAMETER_ENTITY):
+ return entity
+
+ # Reject all external entities and fail the parsing instead. There is currently
+ # no way in libxml2 to just prevent the entity resolution in this case.
+ cdef xmlerror.xmlError c_error
+ cdef xmlerror.xmlStructuredErrorFunc err_func
+ cdef xmlparser.xmlParserInput* parser_input
+ cdef void* err_context
+
+ c_ctxt = ctxt
+ err_func = xmlerror.xmlStructuredError
+ if err_func:
+ parser_input = c_ctxt.input
+ # Copied from xmlVErrParser() in libxml2: get current input from stack.
+ if parser_input and parser_input.filename is NULL and c_ctxt.inputNr > 1:
+ parser_input = c_ctxt.inputTab[c_ctxt.inputNr - 2]
+
+ c_error = xmlerror.xmlError(
+ domain=xmlerror.xmlErrorDomain.XML_FROM_PARSER,
+ code=xmlerror.xmlParserErrors.XML_ERR_EXT_ENTITY_STANDALONE,
+ level=xmlerror.xmlErrorLevel.XML_ERR_FATAL,
+ message=b"External entity resolution is disabled for security reasons "
+ b"when resolving '&%s;'. Use 'XMLParser(resolve_entities=True)' "
+ b"if you consider it safe to enable it.",
+ file=parser_input.filename,
+ node=entity,
+ str1= name,
+ str2=NULL,
+ str3=NULL,
+ line=parser_input.line if parser_input else 0,
+ int1=0,
+ int2=parser_input.col if parser_input else 0,
+ )
+ err_context = xmlerror.xmlStructuredErrorContext
+ err_func(err_context, &c_error)
+
+ c_ctxt.wellFormed = 0
+ # The entity was looked up and does not need to be freed.
+ return NULL
+
+
+cdef void _initSaxDocument(void* ctxt) noexcept with gil:
+ xmlparser.xmlSAX2StartDocument(ctxt)
+ c_ctxt = ctxt
+ c_doc = c_ctxt.myDoc
+
+ # set up document dict
+ if c_doc and c_ctxt.dict and not c_doc.dict:
+ # I have no idea why libxml2 disables this - we need it
+ c_ctxt.dictNames = 1
+ c_doc.dict = c_ctxt.dict
+ xmlparser.xmlDictReference(c_ctxt.dict)
+
+ # set up XML ID hash table
+ if c_ctxt._private:
+ context = <_ParserContext>c_ctxt._private
+ if context._collect_ids:
+ # keep the global parser dict from filling up with XML IDs
+ if c_doc and not c_doc.ids:
+ # memory errors are not fatal here
+ c_dict = xmlparser.xmlDictCreate()
+ if c_dict:
+ c_doc.ids = tree.xmlHashCreateDict(0, c_dict)
+ xmlparser.xmlDictFree(c_dict)
+ else:
+ c_doc.ids = tree.xmlHashCreate(0)
+ else:
+ c_ctxt.loadsubset |= xmlparser.XML_SKIP_IDS
+ if c_doc and c_doc.ids and not tree.xmlHashSize(c_doc.ids):
+ # already initialised but empty => clear
+ tree.xmlHashFree(c_doc.ids, NULL)
+ c_doc.ids = NULL
+
+
+############################################################
+## ET feed parser
+############################################################
+
+cdef class _FeedParser(_BaseParser):
+ cdef bint _feed_parser_running
+
+ @property
+ def feed_error_log(self):
+ """The error log of the last (or current) run of the feed parser.
+
+ Note that this is local to the feed parser and thus is
+ different from what the ``error_log`` property returns.
+ """
+ return self._getPushParserContext()._error_log.copy()
+
+ cpdef feed(self, data):
+ """feed(self, data)
+
+ Feeds data to the parser. The argument should be an 8-bit string
+ buffer containing encoded data, although Unicode is supported as long
+ as both string types are not mixed.
+
+ This is the main entry point to the consumer interface of a
+ parser. The parser will parse as much of the XML stream as it
+ can on each call. To finish parsing or to reset the parser,
+ call the ``close()`` method. Both methods may raise
+ ParseError if errors occur in the input data. If an error is
+ raised, there is no longer a need to call ``close()``.
+
+ The feed parser interface is independent of the normal parser
+ usage. You can use the same parser as a feed parser and in
+ the ``parse()`` function concurrently.
+ """
+ cdef _ParserContext context
+ cdef bytes bstring
+ cdef xmlparser.xmlParserCtxt* pctxt
+ cdef Py_ssize_t py_buffer_len, ustart
+ cdef const_char* char_data
+ cdef const_char* c_encoding
+ cdef int buffer_len
+ cdef int error
+ cdef bint recover = self._parse_options & xmlparser.XML_PARSE_RECOVER
+
+ if isinstance(data, bytes):
+ if self._default_encoding is None:
+ c_encoding = NULL
+ else:
+ c_encoding = self._default_encoding
+ char_data = _cstr(data)
+ py_buffer_len = python.PyBytes_GET_SIZE(data)
+ ustart = 0
+ elif isinstance(data, unicode):
+ c_encoding = b"UTF-8"
+ char_data = NULL
+ py_buffer_len = len( data)
+ ustart = 0
+ else:
+ raise TypeError, "Parsing requires string data"
+
+ context = self._getPushParserContext()
+ pctxt = context._c_ctxt
+ error = 0
+ if not self._feed_parser_running:
+ context.prepare(set_document_loader=False)
+ self._feed_parser_running = 1
+ c_filename = (_cstr(self._filename)
+ if self._filename is not None else NULL)
+
+ # We have to give *mlCtxtResetPush() enough input to figure
+ # out the character encoding (at least four bytes),
+ # however if we give it all we got, we'll have nothing for
+ # *mlParseChunk() and things go wrong.
+ buffer_len = 0
+ if char_data is not NULL:
+ buffer_len = 4 if py_buffer_len > 4 else py_buffer_len
+ orig_loader = _register_document_loader()
+ if self._for_html:
+ error = _htmlCtxtResetPush(
+ pctxt, char_data, buffer_len, c_filename, c_encoding,
+ self._parse_options)
+ else:
+ xmlparser.xmlCtxtUseOptions(pctxt, self._parse_options)
+ error = xmlparser.xmlCtxtResetPush(
+ pctxt, char_data, buffer_len, c_filename, c_encoding)
+ _reset_document_loader(orig_loader)
+ py_buffer_len -= buffer_len
+ char_data += buffer_len
+ if error:
+ raise MemoryError()
+ __GLOBAL_PARSER_CONTEXT.initParserDict(pctxt)
+
+ #print pctxt.charset, 'NONE' if c_encoding is NULL else c_encoding
+
+ fixup_error = 0
+ while py_buffer_len > 0 and (error == 0 or recover):
+ if char_data is NULL:
+ # Unicode parsing by converting chunks to UTF-8
+ buffer_len = 2**19 # len(bytes) <= 4 * (2**19) == 2 MiB
+ bstring = ( data)[ustart : ustart+buffer_len].encode('UTF-8')
+ ustart += buffer_len
+ py_buffer_len -= buffer_len # may end up < 0
+ error, fixup_error = _parse_data_chunk(pctxt, bstring, len(bstring))
+ else:
+ # Direct byte string parsing.
+ buffer_len = py_buffer_len if py_buffer_len <= limits.INT_MAX else limits.INT_MAX
+ error, fixup_error = _parse_data_chunk(pctxt, char_data, buffer_len)
+ py_buffer_len -= buffer_len
+ char_data += buffer_len
+
+ if fixup_error:
+ context.store_exception(MemoryError())
+
+ if context._has_raised():
+ # propagate Python exceptions immediately
+ recover = 0
+ error = 1
+ break
+
+ if error and not pctxt.replaceEntities and not pctxt.validate:
+ # in this mode, we ignore errors about undefined entities
+ for entry in context._error_log.filter_from_errors():
+ if entry.type != ErrorTypes.WAR_UNDECLARED_ENTITY and \
+ entry.type != ErrorTypes.ERR_UNDECLARED_ENTITY:
+ break
+ else:
+ error = 0
+
+ if not pctxt.wellFormed and pctxt.disableSAX and context._has_raised():
+ # propagate Python exceptions immediately
+ recover = 0
+ error = 1
+
+ if fixup_error or not recover and (error or not pctxt.wellFormed):
+ self._feed_parser_running = 0
+ try:
+ context._handleParseResult(self, pctxt.myDoc, None)
+ finally:
+ context.cleanup()
+
+ cpdef close(self):
+ """close(self)
+
+ Terminates feeding data to this parser. This tells the parser to
+ process any remaining data in the feed buffer, and then returns the
+ root Element of the tree that was parsed.
+
+ This method must be called after passing the last chunk of data into
+ the ``feed()`` method. It should only be called when using the feed
+ parser interface, all other usage is undefined.
+ """
+ if not self._feed_parser_running:
+ raise XMLSyntaxError("no element found",
+ xmlerror.XML_ERR_INTERNAL_ERROR, 0, 0,
+ self._filename)
+
+ context = self._getPushParserContext()
+ pctxt = context._c_ctxt
+
+ self._feed_parser_running = 0
+ if self._for_html:
+ htmlparser.htmlParseChunk(pctxt, NULL, 0, 1)
+ else:
+ xmlparser.xmlParseChunk(pctxt, NULL, 0, 1)
+
+ if (pctxt.recovery and not pctxt.disableSAX and
+ isinstance(context, _SaxParserContext)):
+ # apply any left-over 'end' events
+ (<_SaxParserContext>context).flushEvents()
+
+ try:
+ result = context._handleParseResult(self, pctxt.myDoc, None)
+ finally:
+ context.cleanup()
+
+ if isinstance(result, _Document):
+ return (<_Document>result).getroot()
+ else:
+ return result
+
+
+cdef (int, int) _parse_data_chunk(xmlparser.xmlParserCtxt* c_ctxt,
+ const char* char_data, int buffer_len):
+ fixup_error = 0
+ with nogil:
+ if c_ctxt.html:
+ c_node = c_ctxt.node # last node where the parser stopped
+ orig_loader = _register_document_loader()
+ error = htmlparser.htmlParseChunk(c_ctxt, char_data, buffer_len, 0)
+ _reset_document_loader(orig_loader)
+ # and now for the fun part: move node names to the dict
+ if c_ctxt.myDoc:
+ fixup_error = _fixHtmlDictSubtreeNames(
+ c_ctxt.dict, c_ctxt.myDoc, c_node)
+ if c_ctxt.myDoc.dict and c_ctxt.myDoc.dict is not c_ctxt.dict:
+ xmlparser.xmlDictFree(c_ctxt.myDoc.dict)
+ c_ctxt.myDoc.dict = c_ctxt.dict
+ xmlparser.xmlDictReference(c_ctxt.dict)
+ else:
+ orig_loader = _register_document_loader()
+ error = xmlparser.xmlParseChunk(c_ctxt, char_data, buffer_len, 0)
+ _reset_document_loader(orig_loader)
+ return (error, fixup_error)
+
+
+cdef int _htmlCtxtResetPush(xmlparser.xmlParserCtxt* c_ctxt,
+ const_char* c_data, int buffer_len,
+ const_char* c_filename, const_char* c_encoding,
+ int parse_options) except -1:
+ cdef xmlparser.xmlParserInput* c_input_stream
+ # libxml2 lacks an HTML push parser setup function
+ error = xmlparser.xmlCtxtResetPush(
+ c_ctxt, c_data, buffer_len, c_filename, c_encoding)
+ if error:
+ return error
+
+ # fix libxml2 setup for HTML
+ c_ctxt.progressive = 1
+ c_ctxt.html = 1
+ htmlparser.htmlCtxtUseOptions(c_ctxt, parse_options)
+
+ return 0
+
+
+############################################################
+## XML parser
+############################################################
+
+cdef int _XML_DEFAULT_PARSE_OPTIONS
+_XML_DEFAULT_PARSE_OPTIONS = (
+ xmlparser.XML_PARSE_NOENT |
+ xmlparser.XML_PARSE_NOCDATA |
+ xmlparser.XML_PARSE_NONET |
+ xmlparser.XML_PARSE_COMPACT |
+ xmlparser.XML_PARSE_BIG_LINES
+ )
+
+cdef class XMLParser(_FeedParser):
+ """XMLParser(self, encoding=None, attribute_defaults=False, dtd_validation=False, load_dtd=False, no_network=True, ns_clean=False, recover=False, schema: XMLSchema =None, huge_tree=False, remove_blank_text=False, resolve_entities=True, remove_comments=False, remove_pis=False, strip_cdata=True, collect_ids=True, target=None, compact=True)
+
+ The XML parser.
+
+ Parsers can be supplied as additional argument to various parse
+ functions of the lxml API. A default parser is always available
+ and can be replaced by a call to the global function
+ 'set_default_parser'. New parsers can be created at any time
+ without a major run-time overhead.
+
+ The keyword arguments in the constructor are mainly based on the
+ libxml2 parser configuration. A DTD will also be loaded if DTD
+ validation or attribute default values are requested (unless you
+ additionally provide an XMLSchema from which the default
+ attributes can be read).
+
+ Available boolean keyword arguments:
+
+ - attribute_defaults - inject default attributes from DTD or XMLSchema
+ - dtd_validation - validate against a DTD referenced by the document
+ - load_dtd - use DTD for parsing
+ - no_network - prevent network access for related files (default: True)
+ - ns_clean - clean up redundant namespace declarations
+ - recover - try hard to parse through broken XML
+ - remove_blank_text - discard blank text nodes that appear ignorable
+ - remove_comments - discard comments
+ - remove_pis - discard processing instructions
+ - strip_cdata - replace CDATA sections by normal text content (default: True)
+ - compact - save memory for short text content (default: True)
+ - collect_ids - use a hash table of XML IDs for fast access (default: True, always True with DTD validation)
+ - huge_tree - disable security restrictions and support very deep trees
+ and very long text content (only affects libxml2 2.7+)
+
+ Other keyword arguments:
+
+ - resolve_entities - replace entities by their text value: False for keeping the
+ entity references, True for resolving them, and 'internal' for resolving
+ internal definitions only (no external file/URL access).
+ The default used to be True and was changed to 'internal' in lxml 5.0.
+ - encoding - override the document encoding (note: libiconv encoding name)
+ - target - a parser target object that will receive the parse events
+ - schema - an XMLSchema to validate against
+
+ Note that you should avoid sharing parsers between threads. While this is
+ not harmful, it is more efficient to use separate parsers. This does not
+ apply to the default parser.
+ """
+ def __init__(self, *, encoding=None, attribute_defaults=False,
+ dtd_validation=False, load_dtd=False, no_network=True,
+ ns_clean=False, recover=False, XMLSchema schema=None,
+ huge_tree=False, remove_blank_text=False, resolve_entities='internal',
+ remove_comments=False, remove_pis=False, strip_cdata=True,
+ collect_ids=True, target=None, compact=True):
+ cdef int parse_options
+ cdef bint resolve_external = True
+ parse_options = _XML_DEFAULT_PARSE_OPTIONS
+ if load_dtd:
+ parse_options = parse_options | xmlparser.XML_PARSE_DTDLOAD
+ if dtd_validation:
+ parse_options = parse_options | xmlparser.XML_PARSE_DTDVALID | \
+ xmlparser.XML_PARSE_DTDLOAD
+ if attribute_defaults:
+ parse_options = parse_options | xmlparser.XML_PARSE_DTDATTR
+ if schema is None:
+ parse_options = parse_options | xmlparser.XML_PARSE_DTDLOAD
+ if ns_clean:
+ parse_options = parse_options | xmlparser.XML_PARSE_NSCLEAN
+ if recover:
+ parse_options = parse_options | xmlparser.XML_PARSE_RECOVER
+ if remove_blank_text:
+ parse_options = parse_options | xmlparser.XML_PARSE_NOBLANKS
+ if huge_tree:
+ parse_options = parse_options | xmlparser.XML_PARSE_HUGE
+ if not no_network:
+ parse_options = parse_options ^ xmlparser.XML_PARSE_NONET
+ if not compact:
+ parse_options = parse_options ^ xmlparser.XML_PARSE_COMPACT
+ if not resolve_entities:
+ parse_options = parse_options ^ xmlparser.XML_PARSE_NOENT
+ elif resolve_entities == 'internal':
+ resolve_external = False
+ if not strip_cdata:
+ parse_options = parse_options ^ xmlparser.XML_PARSE_NOCDATA
+
+ _BaseParser.__init__(self, parse_options, False, schema,
+ remove_comments, remove_pis, strip_cdata,
+ collect_ids, target, encoding, resolve_external)
+
+
+cdef class XMLPullParser(XMLParser):
+ """XMLPullParser(self, events=None, *, tag=None, **kwargs)
+
+ XML parser that collects parse events in an iterator.
+
+ The collected events are the same as for iterparse(), but the
+ parser itself is non-blocking in the sense that it receives
+ data chunks incrementally through its .feed() method, instead
+ of reading them directly from a file(-like) object all by itself.
+
+ By default, it collects Element end events. To change that,
+ pass any subset of the available events into the ``events``
+ argument: ``'start'``, ``'end'``, ``'start-ns'``,
+ ``'end-ns'``, ``'comment'``, ``'pi'``.
+
+ To support loading external dependencies relative to the input
+ source, you can pass the ``base_url``.
+ """
+ def __init__(self, events=None, *, tag=None, base_url=None, **kwargs):
+ XMLParser.__init__(self, **kwargs)
+ if events is None:
+ events = ('end',)
+ self._setBaseURL(base_url)
+ self._collectEvents(events, tag)
+
+ def read_events(self):
+ return (<_SaxParserContext?>self._getPushParserContext()).events_iterator
+
+
+cdef class ETCompatXMLParser(XMLParser):
+ """ETCompatXMLParser(self, encoding=None, attribute_defaults=False, \
+ dtd_validation=False, load_dtd=False, no_network=True, \
+ ns_clean=False, recover=False, schema=None, \
+ huge_tree=False, remove_blank_text=False, resolve_entities=True, \
+ remove_comments=True, remove_pis=True, strip_cdata=True, \
+ target=None, compact=True)
+
+ An XML parser with an ElementTree compatible default setup.
+
+ See the XMLParser class for details.
+
+ This parser has ``remove_comments`` and ``remove_pis`` enabled by default
+ and thus ignores comments and processing instructions.
+ """
+ def __init__(self, *, encoding=None, attribute_defaults=False,
+ dtd_validation=False, load_dtd=False, no_network=True,
+ ns_clean=False, recover=False, schema=None,
+ huge_tree=False, remove_blank_text=False, resolve_entities=True,
+ remove_comments=True, remove_pis=True, strip_cdata=True,
+ target=None, compact=True):
+ XMLParser.__init__(self,
+ attribute_defaults=attribute_defaults,
+ dtd_validation=dtd_validation,
+ load_dtd=load_dtd,
+ no_network=no_network,
+ ns_clean=ns_clean,
+ recover=recover,
+ remove_blank_text=remove_blank_text,
+ huge_tree=huge_tree,
+ compact=compact,
+ resolve_entities=resolve_entities,
+ remove_comments=remove_comments,
+ remove_pis=remove_pis,
+ strip_cdata=strip_cdata,
+ target=target,
+ encoding=encoding,
+ schema=schema)
+
+# ET 1.2 compatible name
+XMLTreeBuilder = ETCompatXMLParser
+
+
+cdef XMLParser __DEFAULT_XML_PARSER
+__DEFAULT_XML_PARSER = XMLParser()
+
+__GLOBAL_PARSER_CONTEXT.setDefaultParser(__DEFAULT_XML_PARSER)
+
+def set_default_parser(_BaseParser parser=None):
+ """set_default_parser(parser=None)
+
+ Set a default parser for the current thread. This parser is used
+ globally whenever no parser is supplied to the various parse functions of
+ the lxml API. If this function is called without a parser (or if it is
+ None), the default parser is reset to the original configuration.
+
+ Note that the pre-installed default parser is not thread-safe. Avoid the
+ default parser in multi-threaded environments. You can create a separate
+ parser for each thread explicitly or use a parser pool.
+ """
+ if parser is None:
+ parser = __DEFAULT_XML_PARSER
+ __GLOBAL_PARSER_CONTEXT.setDefaultParser(parser)
+
+def get_default_parser():
+ "get_default_parser()"
+ return __GLOBAL_PARSER_CONTEXT.getDefaultParser()
+
+############################################################
+## HTML parser
+############################################################
+
+cdef int _HTML_DEFAULT_PARSE_OPTIONS
+_HTML_DEFAULT_PARSE_OPTIONS = (
+ htmlparser.HTML_PARSE_RECOVER |
+ htmlparser.HTML_PARSE_NONET |
+ htmlparser.HTML_PARSE_COMPACT
+ )
+
+cdef object _UNUSED = object()
+
+cdef class HTMLParser(_FeedParser):
+ """HTMLParser(self, encoding=None, remove_blank_text=False, \
+ remove_comments=False, remove_pis=False, \
+ no_network=True, target=None, schema: XMLSchema =None, \
+ recover=True, compact=True, collect_ids=True, huge_tree=False)
+
+ The HTML parser.
+
+ This parser allows reading HTML into a normal XML tree. By
+ default, it can read broken (non well-formed) HTML, depending on
+ the capabilities of libxml2. Use the 'recover' option to switch
+ this off.
+
+ Available boolean keyword arguments:
+
+ - recover - try hard to parse through broken HTML (default: True)
+ - no_network - prevent network access for related files (default: True)
+ - remove_blank_text - discard empty text nodes that are ignorable (i.e. not actual text content)
+ - remove_comments - discard comments
+ - remove_pis - discard processing instructions
+ - compact - save memory for short text content (default: True)
+ - default_doctype - add a default doctype even if it is not found in the HTML (default: True)
+ - collect_ids - use a hash table of XML IDs for fast access (default: True)
+ - huge_tree - disable security restrictions and support very deep trees
+ and very long text content (only affects libxml2 2.7+)
+
+ Other keyword arguments:
+
+ - encoding - override the document encoding (note: libiconv encoding name)
+ - target - a parser target object that will receive the parse events
+ - schema - an XMLSchema to validate against
+
+ Note that you should avoid sharing parsers between threads for performance
+ reasons.
+ """
+ def __init__(self, *, encoding=None, remove_blank_text=False,
+ remove_comments=False, remove_pis=False, strip_cdata=_UNUSED,
+ no_network=True, target=None, XMLSchema schema=None,
+ recover=True, compact=True, default_doctype=True,
+ collect_ids=True, huge_tree=False):
+ cdef int parse_options
+ parse_options = _HTML_DEFAULT_PARSE_OPTIONS
+ if remove_blank_text:
+ parse_options = parse_options | htmlparser.HTML_PARSE_NOBLANKS
+ if not recover:
+ parse_options = parse_options ^ htmlparser.HTML_PARSE_RECOVER
+ if not no_network:
+ parse_options = parse_options ^ htmlparser.HTML_PARSE_NONET
+ if not compact:
+ parse_options = parse_options ^ htmlparser.HTML_PARSE_COMPACT
+ if not default_doctype:
+ parse_options = parse_options ^ htmlparser.HTML_PARSE_NODEFDTD
+ if huge_tree:
+ parse_options = parse_options | xmlparser.XML_PARSE_HUGE
+
+ if strip_cdata is not _UNUSED:
+ import warnings
+ warnings.warn(
+ "The 'strip_cdata' option of HTMLParser() has never done anything and will eventually be removed.",
+ DeprecationWarning)
+ _BaseParser.__init__(self, parse_options, True, schema,
+ remove_comments, remove_pis, strip_cdata,
+ collect_ids, target, encoding)
+
+
+cdef HTMLParser __DEFAULT_HTML_PARSER
+__DEFAULT_HTML_PARSER = HTMLParser()
+
+
+cdef class HTMLPullParser(HTMLParser):
+ """HTMLPullParser(self, events=None, *, tag=None, base_url=None, **kwargs)
+
+ HTML parser that collects parse events in an iterator.
+
+ The collected events are the same as for iterparse(), but the
+ parser itself is non-blocking in the sense that it receives
+ data chunks incrementally through its .feed() method, instead
+ of reading them directly from a file(-like) object all by itself.
+
+ By default, it collects Element end events. To change that,
+ pass any subset of the available events into the ``events``
+ argument: ``'start'``, ``'end'``, ``'start-ns'``,
+ ``'end-ns'``, ``'comment'``, ``'pi'``.
+
+ To support loading external dependencies relative to the input
+ source, you can pass the ``base_url``.
+ """
+ def __init__(self, events=None, *, tag=None, base_url=None, **kwargs):
+ HTMLParser.__init__(self, **kwargs)
+ if events is None:
+ events = ('end',)
+ self._setBaseURL(base_url)
+ self._collectEvents(events, tag)
+
+ def read_events(self):
+ return (<_SaxParserContext?>self._getPushParserContext()).events_iterator
+
+
+############################################################
+## helper functions for document creation
+############################################################
+
+cdef xmlDoc* _parseDoc(text, filename, _BaseParser parser) except NULL:
+ cdef char* c_filename
+ cdef char* c_text
+ cdef Py_ssize_t c_len
+ if parser is None:
+ parser = __GLOBAL_PARSER_CONTEXT.getDefaultParser()
+ if not filename:
+ c_filename = NULL
+ else:
+ filename_utf = _encodeFilenameUTF8(filename)
+ c_filename = _cstr(filename_utf)
+ if isinstance(text, unicode):
+ if python.PyUnicode_IS_READY(text):
+ # PEP-393 Unicode string
+ c_len = python.PyUnicode_GET_LENGTH(text) * python.PyUnicode_KIND(text)
+ else:
+ # old Py_UNICODE string
+ c_len = python.PyUnicode_GET_DATA_SIZE(text)
+ if c_len > limits.INT_MAX:
+ return (<_BaseParser>parser)._parseDocFromFilelike(
+ StringIO(text), filename, None)
+ return (<_BaseParser>parser)._parseUnicodeDoc(text, c_filename)
+ else:
+ c_len = python.PyBytes_GET_SIZE(text)
+ if c_len > limits.INT_MAX:
+ return (<_BaseParser>parser)._parseDocFromFilelike(
+ BytesIO(text), filename, None)
+ c_text = _cstr(text)
+ return (<_BaseParser>parser)._parseDoc(c_text, c_len, c_filename)
+
+cdef xmlDoc* _parseDocFromFile(filename8, _BaseParser parser) except NULL:
+ if parser is None:
+ parser = __GLOBAL_PARSER_CONTEXT.getDefaultParser()
+ return (<_BaseParser>parser)._parseDocFromFile(_cstr(filename8))
+
+cdef xmlDoc* _parseDocFromFilelike(source, filename,
+ _BaseParser parser) except NULL:
+ if parser is None:
+ parser = __GLOBAL_PARSER_CONTEXT.getDefaultParser()
+ return (<_BaseParser>parser)._parseDocFromFilelike(source, filename, None)
+
+cdef xmlDoc* _newXMLDoc() except NULL:
+ cdef xmlDoc* result
+ result = tree.xmlNewDoc(NULL)
+ if result is NULL:
+ raise MemoryError()
+ if result.encoding is NULL:
+ result.encoding = tree.xmlStrdup("UTF-8")
+ __GLOBAL_PARSER_CONTEXT.initDocDict(result)
+ return result
+
+cdef xmlDoc* _newHTMLDoc() except NULL:
+ cdef xmlDoc* result
+ result = tree.htmlNewDoc(NULL, NULL)
+ if result is NULL:
+ raise MemoryError()
+ __GLOBAL_PARSER_CONTEXT.initDocDict(result)
+ return result
+
+cdef xmlDoc* _copyDoc(xmlDoc* c_doc, int recursive) except NULL:
+ cdef xmlDoc* result
+ if recursive:
+ with nogil:
+ result = tree.xmlCopyDoc(c_doc, recursive)
+ else:
+ result = tree.xmlCopyDoc(c_doc, 0)
+ if result is NULL:
+ raise MemoryError()
+ __GLOBAL_PARSER_CONTEXT.initDocDict(result)
+ return result
+
+cdef xmlDoc* _copyDocRoot(xmlDoc* c_doc, xmlNode* c_new_root) except NULL:
+ "Recursively copy the document and make c_new_root the new root node."
+ cdef xmlDoc* result
+ cdef xmlNode* c_node
+ result = tree.xmlCopyDoc(c_doc, 0) # non recursive
+ __GLOBAL_PARSER_CONTEXT.initDocDict(result)
+ with nogil:
+ c_node = tree.xmlDocCopyNode(c_new_root, result, 1) # recursive
+ if c_node is NULL:
+ raise MemoryError()
+ tree.xmlDocSetRootElement(result, c_node)
+ _copyTail(c_new_root.next, c_node)
+ return result
+
+cdef xmlNode* _copyNodeToDoc(xmlNode* c_node, xmlDoc* c_doc) except NULL:
+ "Recursively copy the element into the document. c_doc is not modified."
+ cdef xmlNode* c_root
+ c_root = tree.xmlDocCopyNode(c_node, c_doc, 1) # recursive
+ if c_root is NULL:
+ raise MemoryError()
+ _copyTail(c_node.next, c_root)
+ return c_root
+
+
+############################################################
+## API level helper functions for _Document creation
+############################################################
+
+cdef _Document _parseDocument(source, _BaseParser parser, base_url):
+ cdef _Document doc
+ source = _getFSPathOrObject(source)
+ if _isString(source):
+ # parse the file directly from the filesystem
+ doc = _parseDocumentFromURL(_encodeFilename(source), parser)
+ # fix base URL if requested
+ if base_url is not None:
+ base_url = _encodeFilenameUTF8(base_url)
+ if doc._c_doc.URL is not NULL:
+ tree.xmlFree(doc._c_doc.URL)
+ doc._c_doc.URL = tree.xmlStrdup(_xcstr(base_url))
+ return doc
+
+ if base_url is not None:
+ url = base_url
+ else:
+ url = _getFilenameForFile(source)
+
+ if hasattr(source, 'getvalue') and hasattr(source, 'tell'):
+ # StringIO - reading from start?
+ if source.tell() == 0:
+ return _parseMemoryDocument(source.getvalue(), url, parser)
+
+ # Support for file-like objects (urlgrabber.urlopen, ...)
+ if hasattr(source, 'read'):
+ return _parseFilelikeDocument(source, url, parser)
+
+ raise TypeError, f"cannot parse from '{python._fqtypename(source).decode('UTF-8')}'"
+
+cdef _Document _parseDocumentFromURL(url, _BaseParser parser):
+ c_doc = _parseDocFromFile(url, parser)
+ return _documentFactory(c_doc, parser)
+
+cdef _Document _parseMemoryDocument(text, url, _BaseParser parser):
+ if isinstance(text, unicode):
+ if _hasEncodingDeclaration(text):
+ raise ValueError(
+ "Unicode strings with encoding declaration are not supported. "
+ "Please use bytes input or XML fragments without declaration.")
+ elif not isinstance(text, bytes):
+ raise ValueError, "can only parse strings"
+ c_doc = _parseDoc(text, url, parser)
+ return _documentFactory(c_doc, parser)
+
+cdef _Document _parseFilelikeDocument(source, url, _BaseParser parser):
+ c_doc = _parseDocFromFilelike(source, url, parser)
+ return _documentFactory(c_doc, parser)
diff --git a/llava_video/lib/python3.10/site-packages/lxml/parsertarget.pxi b/llava_video/lib/python3.10/site-packages/lxml/parsertarget.pxi
new file mode 100644
index 0000000000000000000000000000000000000000..37c29957dd12e7a685a6450c408baa68e2c3de02
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/parsertarget.pxi
@@ -0,0 +1,180 @@
+# Parser target context (ET target interface)
+
+cdef object inspect_getargspec
+try:
+ from inspect import getfullargspec as inspect_getargspec
+except ImportError:
+ from inspect import getargspec as inspect_getargspec
+
+
+class _TargetParserResult(Exception):
+ # Admittedly, this is somewhat ugly, but it's the easiest way
+ # to push the Python level parser result through the parser
+ # machinery towards the API level functions
+ def __init__(self, result):
+ self.result = result
+
+
+@cython.final
+@cython.internal
+cdef class _PythonSaxParserTarget(_SaxParserTarget):
+ cdef object _target_start
+ cdef object _target_end
+ cdef object _target_data
+ cdef object _target_start_ns
+ cdef object _target_end_ns
+ cdef object _target_doctype
+ cdef object _target_pi
+ cdef object _target_comment
+ cdef bint _start_takes_nsmap
+
+ def __cinit__(self, target):
+ cdef int event_filter
+ event_filter = 0
+ self._start_takes_nsmap = 0
+ try:
+ self._target_start = target.start
+ if self._target_start is not None:
+ event_filter |= SAX_EVENT_START
+ except AttributeError:
+ pass
+ else:
+ try:
+ arguments = inspect_getargspec(self._target_start)
+ if len(arguments[0]) > 3 or arguments[1] is not None:
+ self._start_takes_nsmap = 1
+ except TypeError:
+ pass
+ try:
+ self._target_end = target.end
+ if self._target_end is not None:
+ event_filter |= SAX_EVENT_END
+ except AttributeError:
+ pass
+ try:
+ self._target_start_ns = target.start_ns
+ if self._target_start_ns is not None:
+ event_filter |= SAX_EVENT_START_NS
+ except AttributeError:
+ pass
+ try:
+ self._target_end_ns = target.end_ns
+ if self._target_end_ns is not None:
+ event_filter |= SAX_EVENT_END_NS
+ except AttributeError:
+ pass
+ try:
+ self._target_data = target.data
+ if self._target_data is not None:
+ event_filter |= SAX_EVENT_DATA
+ except AttributeError:
+ pass
+ try:
+ self._target_doctype = target.doctype
+ if self._target_doctype is not None:
+ event_filter |= SAX_EVENT_DOCTYPE
+ except AttributeError:
+ pass
+ try:
+ self._target_pi = target.pi
+ if self._target_pi is not None:
+ event_filter |= SAX_EVENT_PI
+ except AttributeError:
+ pass
+ try:
+ self._target_comment = target.comment
+ if self._target_comment is not None:
+ event_filter |= SAX_EVENT_COMMENT
+ except AttributeError:
+ pass
+ self._sax_event_filter = event_filter
+
+ cdef _handleSaxStart(self, tag, attrib, nsmap):
+ if self._start_takes_nsmap:
+ return self._target_start(tag, attrib, nsmap)
+ else:
+ return self._target_start(tag, attrib)
+
+ cdef _handleSaxEnd(self, tag):
+ return self._target_end(tag)
+
+ cdef _handleSaxStartNs(self, prefix, uri):
+ return self._target_start_ns(prefix, uri)
+
+ cdef _handleSaxEndNs(self, prefix):
+ return self._target_end_ns(prefix)
+
+ cdef int _handleSaxData(self, data) except -1:
+ self._target_data(data)
+
+ cdef int _handleSaxDoctype(self, root_tag, public_id, system_id) except -1:
+ self._target_doctype(root_tag, public_id, system_id)
+
+ cdef _handleSaxPi(self, target, data):
+ return self._target_pi(target, data)
+
+ cdef _handleSaxComment(self, comment):
+ return self._target_comment(comment)
+
+
+@cython.final
+@cython.internal
+@cython.no_gc_clear # Required because parent class uses it - Cython bug.
+cdef class _TargetParserContext(_SaxParserContext):
+ """This class maps SAX2 events to the ET parser target interface.
+ """
+ cdef object _python_target
+ cdef int _setTarget(self, target) except -1:
+ self._python_target = target
+ if not isinstance(target, _SaxParserTarget) or \
+ hasattr(target, '__dict__'):
+ target = _PythonSaxParserTarget(target)
+ self._setSaxParserTarget(target)
+ return 0
+
+ cdef _ParserContext _copy(self):
+ cdef _TargetParserContext context
+ context = _ParserContext._copy(self)
+ context._setTarget(self._python_target)
+ return context
+
+ cdef void _cleanupTargetParserContext(self, xmlDoc* result) noexcept:
+ if self._c_ctxt.myDoc is not NULL:
+ if self._c_ctxt.myDoc is not result and \
+ self._c_ctxt.myDoc._private is NULL:
+ # no _Document proxy => orphen
+ tree.xmlFreeDoc(self._c_ctxt.myDoc)
+ self._c_ctxt.myDoc = NULL
+
+ cdef object _handleParseResult(self, _BaseParser parser, xmlDoc* result,
+ filename):
+ cdef bint recover
+ recover = parser._parse_options & xmlparser.XML_PARSE_RECOVER
+ try:
+ if self._has_raised():
+ self._cleanupTargetParserContext(result)
+ self._raise_if_stored()
+ if not self._c_ctxt.wellFormed and not recover:
+ _raiseParseError(self._c_ctxt, filename, self._error_log)
+ except:
+ self._python_target.close()
+ raise
+ return self._python_target.close()
+
+ cdef xmlDoc* _handleParseResultDoc(self, _BaseParser parser,
+ xmlDoc* result, filename) except NULL:
+ cdef bint recover
+ recover = parser._parse_options & xmlparser.XML_PARSE_RECOVER
+ if result is not NULL and result._private is NULL:
+ # no _Document proxy => orphen
+ tree.xmlFreeDoc(result)
+ try:
+ self._cleanupTargetParserContext(result)
+ self._raise_if_stored()
+ if not self._c_ctxt.wellFormed and not recover:
+ _raiseParseError(self._c_ctxt, filename, self._error_log)
+ except:
+ self._python_target.close()
+ raise
+ parse_result = self._python_target.close()
+ raise _TargetParserResult(parse_result)
diff --git a/llava_video/lib/python3.10/site-packages/lxml/proxy.pxi b/llava_video/lib/python3.10/site-packages/lxml/proxy.pxi
new file mode 100644
index 0000000000000000000000000000000000000000..f7b47a73a47d3f0792365796df1b80ffd60f6e34
--- /dev/null
+++ b/llava_video/lib/python3.10/site-packages/lxml/proxy.pxi
@@ -0,0 +1,619 @@
+# Proxy functions and low level node allocation stuff
+
+# Proxies represent elements, their reference is stored in the C
+# structure of the respective node to avoid multiple instantiation of
+# the Python class.
+
+@cython.linetrace(False)
+@cython.profile(False)
+cdef inline _Element getProxy(xmlNode* c_node):
+ """Get a proxy for a given node.
+ """
+ #print "getProxy for:", c_node
+ if c_node is not NULL and c_node._private is not NULL:
+ return <_Element>c_node._private
+ else:
+ return None
+
+
+@cython.linetrace(False)
+@cython.profile(False)
+cdef inline bint hasProxy(xmlNode* c_node):
+ if c_node._private is NULL:
+ return False
+ return True
+
+
+@cython.linetrace(False)
+@cython.profile(False)
+cdef inline int _registerProxy(_Element proxy, _Document doc,
+ xmlNode* c_node) except -1:
+ """Register a proxy and type for the node it's proxying for.
+ """
+ #print "registering for:", proxy._c_node
+ assert not hasProxy(c_node), "double registering proxy!"
+ proxy._doc = doc
+ proxy._c_node = c_node
+ c_node._private = proxy
+ return 0
+
+
+@cython.linetrace(False)
+@cython.profile(False)
+cdef inline int _unregisterProxy(_Element proxy) except -1:
+ """Unregister a proxy for the node it's proxying for.
+ """
+ cdef xmlNode* c_node = proxy._c_node
+ assert c_node._private is proxy, "Tried to unregister unknown proxy"
+ c_node._private = NULL
+ return 0
+
+
+################################################################################
+# temporarily make a node the root node of its document
+
+cdef xmlDoc* _fakeRootDoc(xmlDoc* c_base_doc, xmlNode* c_node) except NULL:
+ return _plainFakeRootDoc(c_base_doc, c_node, 1)
+
+cdef xmlDoc* _plainFakeRootDoc(xmlDoc* c_base_doc, xmlNode* c_node,
+ bint with_siblings) except NULL:
+ # build a temporary document that has the given node as root node
+ # note that copy and original must not be modified during its lifetime!!
+ # always call _destroyFakeDoc() after use!
+ cdef xmlNode* c_child
+ cdef xmlNode* c_root
+ cdef xmlNode* c_new_root
+ cdef xmlDoc* c_doc
+ if with_siblings or (c_node.prev is NULL and c_node.next is NULL):
+ c_root = tree.xmlDocGetRootElement(c_base_doc)
+ if c_root is c_node:
+ # already the root node, no siblings
+ return c_base_doc
+
+ c_doc = _copyDoc(c_base_doc, 0) # non recursive!
+ c_new_root = tree.xmlDocCopyNode(c_node, c_doc, 2) # non recursive!
+ tree.xmlDocSetRootElement(c_doc, c_new_root)
+ _copyParentNamespaces(c_node, c_new_root)
+
+ c_new_root.children = c_node.children
+ c_new_root.last = c_node.last
+ c_new_root.next = c_new_root.prev = NULL
+
+ # store original node
+ c_doc._private = c_node
+
+ # divert parent pointers of children
+ c_child = c_new_root.children
+ while c_child is not NULL:
+ c_child.parent = c_new_root
+ c_child = c_child.next
+
+ c_doc.children = c_new_root
+ return c_doc
+
+cdef void _destroyFakeDoc(xmlDoc* c_base_doc, xmlDoc* c_doc) noexcept:
+ # delete a temporary document
+ cdef xmlNode* c_child
+ cdef xmlNode* c_parent
+ cdef xmlNode* c_root
+ if c_doc is c_base_doc:
+ return
+ c_root = tree.xmlDocGetRootElement(c_doc)
+
+ # restore parent pointers of children
+ c_parent = c_doc._private
+ c_child = c_root.children
+ while c_child is not NULL:
+ c_child.parent = c_parent
+ c_child = c_child.next
+
+ # prevent recursive removal of children
+ c_root.children = c_root.last = NULL
+ tree.xmlFreeDoc(c_doc)
+
+cdef _Element _fakeDocElementFactory(_Document doc, xmlNode* c_element):
+ """Special element factory for cases where we need to create a fake
+ root document, but still need to instantiate arbitrary nodes from
+ it. If we instantiate the fake root node, things will turn bad
+ when it's destroyed.
+
+ Instead, if we are asked to instantiate the fake root node, we
+ instantiate the original node instead.
+ """
+ if c_element.doc is not doc._c_doc:
+ if c_element.doc._private is not NULL:
+ if c_element is c_element.doc.children:
+ c_element = c_element.doc._private
+ #assert c_element.type == tree.XML_ELEMENT_NODE
+ return _elementFactory(doc, c_element)
+
+################################################################################
+# support for freeing tree elements when proxy objects are destroyed
+
+cdef int attemptDeallocation(xmlNode* c_node) noexcept:
+ """Attempt deallocation of c_node (or higher up in tree).
+ """
+ cdef xmlNode* c_top
+ # could be we actually aren't referring to the tree at all
+ if c_node is NULL:
+ #print "not freeing, node is NULL"
+ return 0
+ c_top = getDeallocationTop(c_node)
+ if c_top is not NULL:
+ #print "freeing:", c_top.name
+ _removeText(c_top.next) # tail
+ tree.xmlFreeNode(c_top)
+ return 1
+ return 0
+
+cdef xmlNode* getDeallocationTop(xmlNode* c_node) noexcept:
+ """Return the top of the tree that can be deallocated, or NULL.
+ """
+ cdef xmlNode* c_next
+ #print "trying to do deallocating:", c_node.type
+ if hasProxy(c_node):
+ #print "Not freeing: proxies still exist"
+ return NULL
+ while c_node.parent is not NULL:
+ c_node = c_node.parent
+ #print "checking:", c_current.type
+ if c_node.type == tree.XML_DOCUMENT_NODE or \
+ c_node.type == tree.XML_HTML_DOCUMENT_NODE:
+ #print "not freeing: still in doc"
+ return NULL
+ # if we're still attached to the document, don't deallocate
+ if hasProxy(c_node):
+ #print "Not freeing: proxies still exist"
+ return NULL
+ # see whether we have children to deallocate
+ if not canDeallocateChildNodes(c_node):
+ return NULL
+ # see whether we have siblings to deallocate
+ c_next = c_node.prev
+ while c_next:
+ if _isElement(c_next):
+ if hasProxy(c_next) or not canDeallocateChildNodes(c_next):
+ return NULL
+ c_next = c_next.prev
+ c_next = c_node.next
+ while c_next:
+ if _isElement(c_next):
+ if hasProxy(c_next) or not canDeallocateChildNodes(c_next):
+ return NULL
+ c_next = c_next.next
+ return c_node
+
+cdef int canDeallocateChildNodes(xmlNode* c_parent) noexcept:
+ cdef xmlNode* c_node
+ c_node = c_parent.children
+ tree.BEGIN_FOR_EACH_ELEMENT_FROM(c_parent, c_node, 1)
+ if hasProxy(c_node):
+ return 0
+ tree.END_FOR_EACH_ELEMENT_FROM(c_node)
+ return 1
+
+################################################################################
+# fix _Document references and namespaces when a node changes documents
+
+cdef void _copyParentNamespaces(xmlNode* c_from_node, xmlNode* c_to_node) noexcept nogil:
+ """Copy the namespaces of all ancestors of c_from_node to c_to_node.
+ """
+ cdef xmlNode* c_parent
+ cdef xmlNs* c_ns
+ cdef xmlNs* c_new_ns
+ cdef int prefix_known
+ c_parent = c_from_node.parent
+ while c_parent and (tree._isElementOrXInclude(c_parent) or
+ c_parent.type == tree.XML_DOCUMENT_NODE):
+ c_new_ns = c_parent.nsDef
+ while c_new_ns:
+ # libxml2 will check if the prefix is already defined
+ tree.xmlNewNs(c_to_node, c_new_ns.href, c_new_ns.prefix)
+ c_new_ns = c_new_ns.next
+ c_parent = c_parent.parent
+
+
+ctypedef struct _ns_update_map:
+ xmlNs* old
+ xmlNs* new
+
+
+ctypedef struct _nscache:
+ _ns_update_map* ns_map
+ size_t size
+ size_t last
+
+
+cdef int _growNsCache(_nscache* c_ns_cache) except -1:
+ cdef _ns_update_map* ns_map_ptr
+ if c_ns_cache.size == 0:
+ c_ns_cache.size = 20
+ else:
+ c_ns_cache.size *= 2
+ ns_map_ptr = <_ns_update_map*> python.lxml_realloc(
+ c_ns_cache.ns_map, c_ns_cache.size, sizeof(_ns_update_map))
+ if not ns_map_ptr:
+ python.lxml_free(c_ns_cache.ns_map)
+ c_ns_cache.ns_map = NULL
+ raise MemoryError()
+ c_ns_cache.ns_map = ns_map_ptr
+ return 0
+
+
+cdef inline int _appendToNsCache(_nscache* c_ns_cache,
+ xmlNs* c_old_ns, xmlNs* c_new_ns) except -1:
+ if c_ns_cache.last >= c_ns_cache.size:
+ _growNsCache(c_ns_cache)
+ c_ns_cache.ns_map[c_ns_cache.last] = _ns_update_map(old=c_old_ns, new=c_new_ns)
+ c_ns_cache.last += 1
+
+
+cdef int _stripRedundantNamespaceDeclarations(xmlNode* c_element, _nscache* c_ns_cache,
+ xmlNs** c_del_ns_list) except -1:
+ """Removes namespace declarations from an element that are already
+ defined in its parents. Does not free the xmlNs's, just prepends
+ them to the c_del_ns_list.
+ """
+ cdef xmlNs* c_ns
+ cdef xmlNs* c_ns_next
+ cdef xmlNs** c_nsdef
+ # use a xmlNs** to handle assignments to "c_element.nsDef" correctly
+ c_nsdef = &c_element.nsDef
+ while c_nsdef[0] is not NULL:
+ c_ns = tree.xmlSearchNsByHref(
+ c_element.doc, c_element.parent, c_nsdef[0].href)
+ if c_ns is NULL:
+ # new namespace href => keep and cache the ns declaration
+ _appendToNsCache(c_ns_cache, c_nsdef[0], c_nsdef[0])
+ c_nsdef = &c_nsdef[0].next
+ else:
+ # known namespace href => cache mapping and strip old ns
+ _appendToNsCache(c_ns_cache, c_nsdef[0], c_ns)
+ # cut out c_nsdef.next and prepend it to garbage chain
+ c_ns_next = c_nsdef[0].next
+ c_nsdef[0].next = c_del_ns_list[0]
+ c_del_ns_list[0] = c_nsdef[0]
+ c_nsdef[0] = c_ns_next
+ return 0
+
+
+cdef void _cleanUpFromNamespaceAdaptation(xmlNode* c_start_node,
+ _nscache* c_ns_cache, xmlNs* c_del_ns_list) noexcept:
+ # Try to recover from exceptions with really bad timing. We were in the middle
+ # of ripping out xmlNS-es and likely ran out of memory. Try to fix up the tree
+ # by re-adding the original xmlNs declarations (which might still be used in some
+ # places).
+ if c_ns_cache.ns_map:
+ python.lxml_free(c_ns_cache.ns_map)
+ if c_del_ns_list:
+ if not c_start_node.nsDef:
+ c_start_node.nsDef = c_del_ns_list
+ else:
+ c_ns = c_start_node.nsDef
+ while c_ns.next:
+ c_ns = c_ns.next
+ c_ns.next = c_del_ns_list
+
+
+cdef int moveNodeToDocument(_Document doc, xmlDoc* c_source_doc,
+ xmlNode* c_element) except -1:
+ """Fix the xmlNs pointers of a node and its subtree that were moved.
+
+ Originally copied from libxml2's xmlReconciliateNs(). Expects
+ libxml2 doc pointers of node to be correct already, but fixes
+ _Document references.
+
+ For each node in the subtree, we do this:
+
+ 1) Remove redundant declarations of namespace that are already
+ defined in its parents.
+
+ 2) Replace namespaces that are *not* defined on the node or its
+ parents by the equivalent namespace declarations that *are*
+ defined on the node or its parents (possibly using a different
+ prefix). If a namespace is unknown, declare a new one on the
+ node.
+
+ 3) Reassign the names of tags and attribute from the dict of the
+ target document *iff* it is different from the dict used in the
+ source subtree.
+
+ 4) Set the Document reference to the new Document (if different).
+ This is done on backtracking to keep the original Document
+ alive as long as possible, until all its elements are updated.
+
+ Note that the namespace declarations are removed from the tree in
+ step 1), but freed only after the complete subtree was traversed
+ and all occurrences were replaced by tree-internal pointers.
+ """
+ cdef xmlNode* c_start_node
+ cdef xmlNode* c_node
+ cdef xmlDoc* c_doc = doc._c_doc
+ cdef tree.xmlAttr* c_attr
+ cdef char* c_name
+ cdef _nscache c_ns_cache = [NULL, 0, 0]
+ cdef xmlNs* c_del_ns_list = NULL
+ cdef proxy_count = 0
+
+ if not tree._isElementOrXInclude(c_element):
+ return 0
+
+ c_start_node = c_element
+
+ tree.BEGIN_FOR_EACH_FROM(c_element, c_element, 1)
+ if tree._isElementOrXInclude(c_element):
+ if hasProxy(c_element):
+ proxy_count += 1
+
+ # 1) cut out namespaces defined here that are already known by
+ # the ancestors
+ if c_element.nsDef is not NULL:
+ try:
+ _stripRedundantNamespaceDeclarations(c_element, &c_ns_cache, &c_del_ns_list)
+ except:
+ _cleanUpFromNamespaceAdaptation(c_start_node, &c_ns_cache, c_del_ns_list)
+ raise
+
+ # 2) make sure the namespaces of an element and its attributes
+ # are declared in this document (i.e. on the node or its parents)
+ if c_element.ns is not NULL:
+ _fixCNs(doc, c_start_node, c_element, &c_ns_cache, c_del_ns_list)
+
+ c_node = c_element.properties
+ while c_node is not NULL:
+ if c_node.ns is not NULL:
+ _fixCNs(doc, c_start_node, c_node, &c_ns_cache, c_del_ns_list)
+ c_node = c_node.next
+
+ tree.END_FOR_EACH_FROM(c_element)
+
+ # free now unused namespace declarations
+ if c_del_ns_list is not NULL:
+ tree.xmlFreeNsList(c_del_ns_list)
+
+ # cleanup
+ if c_ns_cache.ns_map is not NULL:
+ python.lxml_free(c_ns_cache.ns_map)
+
+ # 3) fix the names in the tree if we moved it from a different thread
+ if doc._c_doc.dict is not c_source_doc.dict:
+ fixThreadDictNames(c_start_node, c_source_doc.dict, doc._c_doc.dict)
+
+ # 4) fix _Document references
+ # (and potentially deallocate the source document)
+ if proxy_count > 0:
+ if proxy_count == 1 and c_start_node._private is not NULL:
+ proxy = getProxy(c_start_node)
+ if proxy is not None:
+ if proxy._doc is not doc:
+ proxy._doc = doc
+ else:
+ fixElementDocument(c_start_node, doc, proxy_count)
+ else:
+ fixElementDocument(c_start_node, doc, proxy_count)
+
+ return 0
+
+
+cdef void _setTreeDoc(xmlNode* c_node, xmlDoc* c_doc) noexcept:
+ """Adaptation of 'xmlSetTreeDoc()' that deep-fixes the document links iteratively.
+ It avoids https://gitlab.gnome.org/GNOME/libxml2/issues/42
+ """
+ tree.BEGIN_FOR_EACH_FROM(c_node, c_node, 1)
+ if c_node.type == tree.XML_ELEMENT_NODE:
+ c_attr = c_node.properties
+ while c_attr:
+ if c_attr.atype == tree.XML_ATTRIBUTE_ID:
+ tree.xmlRemoveID(c_node.doc, c_attr)
+ c_attr.doc = c_doc
+ _fixDocChildren(c_attr.children, c_doc)
+ c_attr = c_attr.next
+ # Set doc link for all nodes, not only elements.
+ c_node.doc = c_doc
+ tree.END_FOR_EACH_FROM(c_node)
+
+
+cdef inline void _fixDocChildren(xmlNode* c_child, xmlDoc* c_doc) noexcept:
+ while c_child:
+ c_child.doc = c_doc
+ if c_child.children:
+ _fixDocChildren(c_child.children, c_doc)
+ c_child = c_child.next
+
+
+cdef int _fixCNs(_Document doc, xmlNode* c_start_node, xmlNode* c_node,
+ _nscache* c_ns_cache, xmlNs* c_del_ns_list) except -1:
+ cdef xmlNs* c_ns = NULL
+ cdef bint is_prefixed_attr = (c_node.type == tree.XML_ATTRIBUTE_NODE and c_node.ns.prefix)
+
+ for ns_map in c_ns_cache.ns_map[:c_ns_cache.last]:
+ if c_node.ns is ns_map.old:
+ if is_prefixed_attr and not ns_map.new.prefix:
+ # avoid dropping prefix from attributes
+ continue
+ c_ns = ns_map.new
+ break
+
+ if c_ns:
+ c_node.ns = c_ns
+ else:
+ # not in cache or not acceptable
+ # => find a replacement from this document
+ try:
+ c_ns = doc._findOrBuildNodeNs(
+ c_start_node, c_node.ns.href, c_node.ns.prefix,
+ c_node.type == tree.XML_ATTRIBUTE_NODE)
+ c_node.ns = c_ns
+ _appendToNsCache(c_ns_cache, c_node.ns, c_ns)
+ except:
+ _cleanUpFromNamespaceAdaptation(c_start_node, c_ns_cache, c_del_ns_list)
+ raise
+ return 0
+
+
+cdef int fixElementDocument(xmlNode* c_element, _Document doc,
+ size_t proxy_count) except -1:
+ cdef xmlNode* c_node = c_element
+ cdef _Element proxy = None # init-to-None required due to fake-loop below
+ tree.BEGIN_FOR_EACH_FROM(c_element, c_node, 1)
+ if c_node._private is not NULL:
+ proxy = getProxy(c_node)
+ if proxy is not None:
+ if proxy._doc is not doc:
+ proxy._doc = doc
+ proxy_count -= 1
+ if proxy_count == 0:
+ return 0
+ tree.END_FOR_EACH_FROM(c_node)
+
+
+cdef void fixThreadDictNames(xmlNode* c_element,
+ tree.xmlDict* c_src_dict,
+ tree.xmlDict* c_dict) noexcept nogil:
+ # re-assign the names of tags and attributes
+ #
+ # this should only be called when the element is based on a
+ # different libxml2 tag name dictionary
+ if c_element.type == tree.XML_DOCUMENT_NODE or \
+ c_element.type == tree.XML_HTML_DOCUMENT_NODE:
+ # may define "xml" namespace
+ fixThreadDictNsForNode(c_element, c_src_dict, c_dict)
+ if c_element.doc.extSubset:
+ fixThreadDictNamesForDtd(c_element.doc.extSubset, c_src_dict, c_dict)
+ if c_element.doc.intSubset:
+ fixThreadDictNamesForDtd(c_element.doc.intSubset, c_src_dict, c_dict)
+ c_element = c_element.children
+ while c_element is not NULL:
+ fixThreadDictNamesForNode(c_element, c_src_dict, c_dict)
+ c_element = c_element.next
+ elif tree._isElementOrXInclude(c_element):
+ fixThreadDictNamesForNode(c_element, c_src_dict, c_dict)
+
+
+cdef inline void _fixThreadDictPtr(const_xmlChar** c_ptr,
+ tree.xmlDict* c_src_dict,
+ tree.xmlDict* c_dict) noexcept nogil:
+ c_str = c_ptr[0]
+ if c_str and c_src_dict and tree.xmlDictOwns(c_src_dict, c_str):
+ # return value can be NULL on memory error, but we don't handle that here
+ c_str = tree.xmlDictLookup(c_dict, c_str, -1)
+ if c_str:
+ c_ptr[0] = c_str
+
+
+cdef void fixThreadDictNamesForNode(xmlNode* c_element,
+ tree.xmlDict* c_src_dict,
+ tree.xmlDict* c_dict) noexcept nogil:
+ cdef xmlNode* c_node = c_element
+ tree.BEGIN_FOR_EACH_FROM(c_element, c_node, 1)
+ if c_node.type in (tree.XML_ELEMENT_NODE, tree.XML_XINCLUDE_START):
+ fixThreadDictNamesForAttributes(
+ c_node.properties, c_src_dict, c_dict)
+ fixThreadDictNsForNode(c_node, c_src_dict, c_dict)
+ _fixThreadDictPtr(&c_node.name, c_src_dict, c_dict)
+ elif c_node.type == tree.XML_TEXT_NODE:
+ # libxml2's SAX2 parser interns some indentation space
+ fixThreadDictContentForNode(c_node, c_src_dict, c_dict)
+ elif c_node.type == tree.XML_COMMENT_NODE:
+ pass # don't touch c_node.name
+ else:
+ _fixThreadDictPtr(&c_node.name, c_src_dict, c_dict)
+ tree.END_FOR_EACH_FROM(c_node)
+
+
+cdef inline void fixThreadDictNamesForAttributes(tree.xmlAttr* c_attr,
+ tree.xmlDict* c_src_dict,
+ tree.xmlDict* c_dict) noexcept nogil:
+ cdef xmlNode* c_child
+ cdef xmlNode* c_node =