__docformat__ = "restructuredtext en"

__all__ = [

]

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

cimport cpython.mem

cimport cpython.ref

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

iterkeys = itervalues = iteritems = __iter__

cdef object IMMUTABLE_EMPTY_MAPPING = _ImmutableMapping()

del _ImmutableMapping

DEF __DEBUG = 1

DEF __MAX_LOG_SIZE = 100

DEBUG = __DEBUG

cdef struct qname:

const_xmlChar* c_name

python.PyObject* href

xmlparser.xmlInitParser()

tree.xmlThrDefIndentTreeOutput(1)

tree.xmlThrDefLineNumbersDefaultValue(1)

_initThreadLogging()

cdef bytes _FILENAME_ENCODING = (sys.getfilesystemencoding() or sys.getdefaultencoding() or 'ascii').encode("UTF-8")

cdef const char* _C_FILENAME_ENCODING = _cstr(_FILENAME_ENCODING)

cdef dict _DEFAULT_NAMESPACE_PREFIXES = {

}

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

_update_default_namespace_prefixes_items()

class Error(Exception):

pass

class LxmlError(Error):

self.error_log = error_log.copy()

cdef object _Error = Error

class LxmlSyntaxError(LxmlError, SyntaxError):

"""Base class for all syntax errors.

class C14NError(LxmlError):

"""Error during C14N serialisation.

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)

__version__ = tree.LXML_VERSION_STRING.decode("ascii")

cdef extern from *:

"""

# zlib isn't included automatically by libxml2's headers

#long ZLIB_HEX_VERSION "__lxml_zlib_version"

long LIBICONV_HEX_VERSION "__lxml_iconv_version"

ICONV_COMPILED_VERSION = __unpackIntVersion(LIBICONV_HEX_VERSION, base=0x100)[:2]

cdef extern from "libxml/xmlversion.h":

"""

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 = {

}

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

cdef class _TempStore:

return 0

cdef int clear(self) except –1:

del self._storage[:]

return 0

cdef class _ExceptionContext:

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

ctypedef public xmlNode* (*_node_to_node_function)(xmlNode*)

include "proxy.pxi" # Proxy handling (element backpointers/memory/etc.)

include "apihelpers.pxi" # Private helper functions

include "xmlerror.pxi" # Error and log handling

@cython.freelist(8)

cdef public class _Document [ type LxmlDocumentType, object LxmlDocument ]:

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

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

return result

cdef object _find_invalid_public_id_characters = re.compile(

ur"[^\x20\x0D\x0Aa-zA-Z0-9'()+,./:=?;!*#@$_%-]+").search

cdef class DocInfo:

return _dtdFactory(self._doc._c_doc.extSubset)

cdef public class _Element [ type LxmlElementType, object LxmlElement ]: