# 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',

'LIBXML_FEATURES',

'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

cimport cpython.object

from cpython.buffer cimport PyBUF_SIMPLE, PyBUF_READ, PyBUF_FORMAT, PyBUF_ND, PyBUF_STRIDES

from libc cimport limits, stdio, stdlib, stdint

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, BufferedWriter

from io import BytesIO, StringIO, BufferedWriter

cdef object OrderedDict

from collections import OrderedDict

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 const 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 = list({

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")

with cython.critical_section(_DEFAULT_NAMESPACE_PREFIXES):

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

class Error(Exception):

pass

# module level superclass for all exceptions

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.

"""

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]+', (<unsigned char*>tree.xmlParserVersion).decode("ascii")).group(0))

except Exception:

print("Unknown libxml2 version: " + (<unsigned char*>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)

cdef bint _get_freethreading_enabled():

import lxml.etree as etree

pymoduledef = python.PyModule_GetDef(etree)

if pymoduledef is NULL:

return False

slot = pymoduledef.m_slots

while slot is not NULL and slot[0].slot != 0:

if slot[0].slot == python.Py_mod_gil:

return slot[0].value == python.Py_MOD_GIL_NOT_USED

slot += 1

return False

_freethreading_enabled = _get_freethreading_enabled()

__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]

cdef extern from "libxml/xmlversion.h":

"""

static const char* const _lxml_lib_features[] = {

#ifdef LIBXML_HTML_ENABLED

"html",

#endif

#ifdef LIBXML_FTP_ENABLED

"ftp",

#endif

#ifdef LIBXML_HTTP_ENABLED

"http",

#endif

#ifdef LIBXML_CATALOG_ENABLED

"catalog",

#endif

#ifdef LIBXML_XPATH_ENABLED

"xpath",

#endif

#ifdef LIBXML_ICONV_ENABLED

"iconv",

#endif

#ifdef LIBXML_ICU_ENABLED

"icu",

#endif

#ifdef LIBXML_REGEXP_ENABLED

"regexp",

#endif

#ifdef LIBXML_SCHEMAS_ENABLED

"xmlschema",

#endif

#ifdef LIBXML_SCHEMATRON_ENABLED

"schematron",

#endif

#ifdef LIBXML_ZLIB_ENABLED

"zlib",

#endif

#ifdef LIBXML_LZMA_ENABLED

"lzma",

#endif

0

};

"""

const char* const* _LXML_LIB_FEATURES "_lxml_lib_features"

cdef set _copy_lib_features():

features = set()

feature = _LXML_LIB_FEATURES

while feature[0]:

features.add(feature[0].decode('ASCII'))

feature += 1

return features

LIBXML_COMPILED_FEATURES = _copy_lib_features()

LIBXML_FEATURES = {

feature_name for feature_id, feature_name in [

#XML_WITH_THREAD = 1

#XML_WITH_TREE = 2

#XML_WITH_OUTPUT = 3

#XML_WITH_PUSH = 4

#XML_WITH_READER = 5

#XML_WITH_PATTERN = 6

#XML_WITH_WRITER = 7

#XML_WITH_SAX1 = 8

(xmlparser.XML_WITH_FTP, "ftp"), # XML_WITH_FTP = 9

(xmlparser.XML_WITH_HTTP, "http"), # XML_WITH_HTTP = 10

#XML_WITH_VALID = 11

(xmlparser.XML_WITH_HTML, "html"), # XML_WITH_HTML = 12

#XML_WITH_LEGACY = 13

#XML_WITH_C14N = 14

(xmlparser.XML_WITH_CATALOG, "catalog"), # XML_WITH_CATALOG = 15

(xmlparser.XML_WITH_XPATH, "xpath"), # XML_WITH_XPATH = 16

#XML_WITH_XPTR = 17

#XML_WITH_XINCLUDE = 18

(xmlparser.XML_WITH_ICONV, "iconv"), # XML_WITH_ICONV = 19

#XML_WITH_ISO8859X = 20

#XML_WITH_UNICODE = 21

(xmlparser.XML_WITH_REGEXP, "regexp"), # XML_WITH_REGEXP = 22

#XML_WITH_AUTOMATA = 23

#XML_WITH_EXPR = 24

(xmlparser.XML_WITH_SCHEMAS, "xmlschema"), # XML_WITH_SCHEMAS = 25

(xmlparser.XML_WITH_SCHEMATRON, "schematron"), # XML_WITH_SCHEMATRON = 26

#XML_WITH_MODULES = 27

#XML_WITH_DEBUG = 28

#XML_WITH_DEBUG_MEM = 29

#XML_WITH_DEBUG_RUN = 30 # unused

(xmlparser.XML_WITH_ZLIB, "zlib"), # XML_WITH_ZLIB = 31

(xmlparser.XML_WITH_ICU, "icu"), # XML_WITH_ICU = 32

(xmlparser.XML_WITH_LZMA, "lzma"), # XML_WITH_LZMA = 33

] if xmlparser.xmlHasFeature(feature_id)

}

cdef bint HAS_ZLIB_COMPRESSION = xmlparser.xmlHasFeature(xmlparser.XML_WITH_ZLIB)

# 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

@cython.final

cdef void _store_raised(self) noexcept:

context = None

try:

if self._exc_info is not None:

context = self._exc_info[0]

self._exc_info = sys.exc_info()

if context is not None:

self._store_context(context)

except BaseException as e:

self._store_exception(e)

finally:

return # and swallow any further exceptions

@cython.final

cdef int _store_exception(self, exception) except -1:

context = None if self._exc_info is None else self._exc_info[0]

self._exc_info = (exception, None, None)

if context is not None:

self._store_context(context)

return 0

@cython.final

cdef void _store_context(self, context) noexcept:

try:

if self._exc_info is None:

# remember at least the context exception

self._store_exception(context)

else:

exc = self._exc_info[0]

if python.PyException_GetContext(exc) is NULL:

python.PyException_SetContext(exc, context)

finally:

return # and swallow any further exceptions

@cython.final

cdef bint _has_raised(self) except -1:

return self._exc_info is not None

@cython.final

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 "rwlock.pxi" # A read-write lock

include "apihelpers.pxi" # Private helper functions

include "xmlerror.pxi" # Error and log handling

################################################################################

# Public Python API

@cython.final

@cython.no_gc_clear

@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

# -- End of public part, '_c_doc' is the only publicly exposed struct field.

cdef _BaseParser _parser

cdef RWLock _lock

# Short-lived lock to guard proxy link changes.

cdef cython.pymutex _proxy_lock

def __dealloc__(self):

# If there are no more references to the document, it is safe

# to clean the whole thing up, as all nodes hold a reference to

# the _Document. No locking is needed.

tree.xmlFreeDoc(self._c_doc)

# Allow locking and working with the names dict to be done per document

# to avoid letting code know that it currently isn't document specific.

cdef void initDict(self) noexcept:

self._parser.initDocDict(self._c_doc)

cdef void lock_proxies(self) noexcept:

self._proxy_lock.acquire()

cdef void unlock_proxies(self) noexcept:

self._proxy_lock.release()

cdef void lock_read(self) noexcept:

self._lock.lock_read()

cdef void unlock_read(self) noexcept:

self._lock.unlock_read()

cdef void lock_write(self) noexcept:

self._lock.lock_write()

cdef void unlock_write(self) noexcept:

self._lock.unlock_write()

cdef void lock_fakedoc(self) noexcept:

# Explicit alias for locking when we create a 'fake root doc'.

self._lock.lock_read()

cdef void unlock_fakedoc(self) noexcept:

# Explicit alias for locking when we create a 'fake root doc'.

self._lock.unlock_read()

cdef void lock_write_with(self, _Document second_doc) noexcept:

"""Lock two documents for writing at the same time.

"""

if second_doc is None or self._lock is second_doc._lock:

self._lock.lock_write()

else:

self._lock.lock_write_with(second_doc._lock)

cdef void unlock_write_with(self, _Document second_doc) noexcept:

"""Unlock two documents for writing after locking them at the same time.

"""

if second_doc is None or self._lock is second_doc._lock:

self._lock.unlock_write()

else:

self._lock.unlock_write_with(second_doc._lock)

def get_lock_perf_counters(self) -> dict:

"""Return the current performance counters of this document's concurrency lock in a dict.

lxml needs to be compiled with '-DLXML_LOCK_PERFORMANCE=1' to make this useful.

"""

return self._lock.get_perf_counters()

# Internal accessors, not locked.

@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 tuple 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

with cython.critical_section(self._lock):

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 tuple 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 <bint>(self._c_doc.standalone == 1)

@cython.final

cdef bint ishtml(self):

return self._c_doc.type == tree.XML_HTML_DOCUMENT_NODE

@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:

with cython.critical_section(_DEFAULT_NAMESPACE_PREFIXES):

dict_result = python.PyDict_GetItem(

_DEFAULT_NAMESPACE_PREFIXES, <unsigned char*>c_href)

if dict_result is not NULL:

prefix = <object>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(26) ])

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

result._lock = parser._lock

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) noexcept:

""""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

cdef tree.xmlNode* c_dtd

with cython.critical_section(self._doc._lock):

c_doc = self._doc._c_doc

c_dtd = <xmlNode*>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()

with cython.critical_section(self._doc._lock):

c_dtd = self._get_c_dtd()

if not c_dtd:

tree.xmlFree(c_value)

raise MemoryError()

old_id = c_dtd.ExternalID

c_dtd.ExternalID = c_value

if old_id:

tree.xmlFree(<void*> old_id)

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()

with cython.critical_section(self._doc._lock):

c_dtd = self._get_c_dtd()

if not c_dtd:

tree.xmlFree(c_value)

raise MemoryError()

old_id = c_dtd.SystemID

c_dtd.SystemID = c_value

if old_id:

tree.xmlFree(<void*> old_id)

@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

def is_html(self):

return self._doc.ishtml()

property URL:

"The source URL of the document (or None if unknown)."

def __get__(self):

return _get_docURL(self._doc)

def __set__(self, url):

url = _encodeFilename(url)

c_new_url = tree.xmlStrdup(_xcstr(url)) if url is not None else NULL

with cython.critical_section(self._doc._lock):

c_oldurl = self._doc._c_doc.URL

self._doc._c_doc.URL = c_new_url

if c_oldurl is not NULL:

tree.xmlFree(<void*>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'<!DOCTYPE {root_name} PUBLIC "{public_id}" {quoted_system_url}>'

else:

return f'<!DOCTYPE {root_name} PUBLIC "{public_id}">'

elif system_url:

return f'<!DOCTYPE {root_name} SYSTEM {quoted_system_url}>'

elif self._doc.hasdoctype():

return f'<!DOCTYPE {root_name}>'

else:

return ''

@property

def internalDTD(self):

"""Returns a DTD validator based on the internal subset of the document."""

with cython.critical_section(self._doc._lock):

dtd = _dtdFactory(self._doc._c_doc.intSubset)

return dtd

@property

def externalDTD(self):

"""Returns a DTD validator based on the external subset of the document."""

with cython.critical_section(self._doc._lock):

dtd = _dtdFactory(self._doc._c_doc.extSubset)

return dtd

cdef _get_docURL(doc: _Document):

with cython.critical_section(doc._lock):

c_url = doc._c_doc.URL

return _decodeFilename(c_url) if c_url is not NULL else None

@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 __del__(self):

#print("trying to free node:", <int>self._c_node)

#displayNode(self._c_node, 0)

c_node = self._c_node

if c_node is NULL:

#stdio.printf("DEAD1(** 1 **) ")

return

#assert c_node._private is not NULL

#assert cpython.ref._Py_REFCNT(<cpython.object.PyObject*> c_node._private) > 0, \

# cpython.ref._Py_REFCNT(<cpython.object.PyObject*> c_node._private)

doc = self._doc

#stdio.printf("DEALLOC " if type(doc) is _Document else "DEALLOC [**NO DOC!**] ")

# None probably means that the unregistration has happened concurrently.

if doc is not None:

doc.lock_proxies()

try:

# Now, owning the lock, make sure there is still something to deallocate.

c_node = self._c_node

if c_node is NULL:

#stdio.printf("DEAD(** 2 **) ")

return

#if c_node._private is NULL:

# self._c_node = NULL