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

from libc cimport limits

__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

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

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

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

cdef class ObjectifiedElement(ElementBase):

return _build_descendant_paths(self._c_node, prefix)

cdef inline bint _tagMatches(tree.xmlNode* c_node, const_xmlChar* c_href, const_xmlChar* c_name):

if c_node.name != c_name:

return 0

if c_href == NULL:

return 1

c_node_href = tree._getNs(c_node)

if c_node_href == NULL:

return c_href[0] == c'\0'

return tree.xmlStrcmp(c_node_href, c_href) == 0

cdef Py_ssize_t _countSiblings(tree.xmlNode* c_start_node):

cdef tree.xmlNode* c_node

cdef Py_ssize_t count

c_tag = c_start_node.name

c_href = tree._getNs(c_start_node)

count = 1

c_node = c_start_node.next

while c_node is not NULL:

if c_node.type == tree.XML_ELEMENT_NODE and \

_tagMatches(c_node, c_href, c_tag):

count += 1

c_node = c_node.next

c_node = c_start_node.prev

while c_node is not NULL:

if c_node.type == tree.XML_ELEMENT_NODE and \

_tagMatches(c_node, c_href, c_tag):

count += 1

c_node = c_node.prev

return count

cdef tree.xmlNode* _findFollowingSibling(tree.xmlNode* c_node,

const_xmlChar* href, const_xmlChar* name,

Py_ssize_t index):

cdef tree.xmlNode* (*next)(tree.xmlNode*)

if index >= 0:

next = cetree.nextElement

else:

index = –1 – index

next = cetree.previousElement

while c_node is not NULL:

if c_node.type == tree.XML_ELEMENT_NODE and \

_tagMatches(c_node, href, name):

index = index – 1

if index < 0:

return c_node

c_node = next(c_node)

return NULL

cdef object _lookupChild(_Element parent, tag):

cdef tree.xmlNode* c_result

cdef tree.xmlNode* c_node

c_node = parent._c_node

ns, tag = cetree.getNsTagWithEmptyNs(tag)

c_tag_len = len(<bytes> tag)

if c_tag_len > limits.INT_MAX:

return None

c_tag = tree.xmlDictExists(

c_node.doc.dict, _xcstr(tag), <int> c_tag_len)

if c_tag is NULL:

return None # not in the hash map => not in the tree

if ns is None:

# either inherit ns from parent or use empty (i.e. no) namespace

c_href = tree._getNs(c_node) or <const_xmlChar*>''

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, <unsigned char*>"nil")

if python._isString(value):

pytype_name = "str"

py_type = <PyType>_PYTYPE_DICT.get(pytype_name)

else:

pytype_name = python._typename(value)

py_type = <PyType>_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 (<slice>sliceobject).step is None:

c_step = 1

else:

c_step = (<slice>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 (<slice>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,

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

cdef class ObjectifiedDataElement(ObjectifiedElement):

cetree.setNodeText(self._c_node, s)

cdef class NumberElement(ObjectifiedDataElement):

return _numericValueOf(other) ^ _numericValueOf(self)

cdef class IntElement(NumberElement):

return int(_parseNumber(self))

cdef class FloatElement(NumberElement):

def _init(self):

self._parse_value = float

cdef class StringElement(ObjectifiedDataElement):

return complex(textOf(self._c_node))

cdef class NoneElement(ObjectifiedDataElement):

return None

cdef class BoolElement(IntElement):

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: