# 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

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

# 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

# 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(str s):

return s, s.encode('utf8')

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"

"""

if attribute_tag is None:

namespace, namespace_utf = _unicodeAndUtf8("http://codespeak.net/lxml/objectify/pytype")

attribute_name, attribute_name_utf = _unicodeAndUtf8("pytype")

else:

namespace_utf, attribute_name_utf = cetree.getNsTag(attribute_tag)

namespace = namespace_utf.decode('utf8')

attribute_name = attribute_name_utf.decode('utf8')

cdef const_xmlChar *c_namespace = namespace_utf

cdef const_xmlChar *c_attribute = attribute_name_utf

global PYTYPE_ATTRIBUTE, _PYTYPE_NAMESPACE, _PYTYPE_ATTRIBUTE_NAME

global PYTYPE_NAMESPACE, PYTYPE_NAMESPACE_UTF8

global PYTYPE_ATTRIBUTE_NAME, PYTYPE_ATTRIBUTE_NAME_UTF8

with cython.critical_section(TREE_PYTYPE_NAME): # anything global and immutable, really

# First overwrite the C string pointers, then replace their old Python bytes targets.

_PYTYPE_NAMESPACE = c_namespace

_PYTYPE_ATTRIBUTE_NAME = c_attribute

PYTYPE_NAMESPACE, PYTYPE_NAMESPACE_UTF8 = namespace, namespace_utf

PYTYPE_ATTRIBUTE_NAME, PYTYPE_ATTRIBUTE_NAME_UTF8 = attribute_name, attribute_name_utf

PYTYPE_ATTRIBUTE = cetree.namespacedNameFromNsName(c_namespace, c_attribute)

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("<root><c1><c2>0</c2><c2>1</c2></c1></root>")

>>> second_c2 = root.c1.c2[1]

>>> print(second_c2.text)

1

Note that you cannot (and must not) instantiate this class or its

subclasses.

"""

def __iter__(self):

"""Iterate over self and all siblings with the same tag.

"""

parent = self.getparent()

if parent is None:

return iter([self])

return etree.ElementChildIterator(parent, tag=self.tag)

def __str__(self):

if __RECURSIVE_STR:

return _dump(self, 0)

else:

return _lockedTextOf(self) or ''

# pickle support for objectified Element

def __reduce__(self):

return fromstring, (etree.tostring(self),)

@property

def text(self):

return _lockedTextOf(self)

@property

def __dict__(self):

"""A fake implementation for __dict__ to support dir() etc.

Note that this only considers the first child with a given name.

"""

cdef _Element child

cdef dict children

doc = self._doc

cetree.lock_read(doc)

try:

c_ns = tree._getNs(self._c_node)

tag = "{%s}*" % pyunicode(c_ns) if c_ns is not NULL else None

children = {}

for child in etree.ElementChildIterator(self, tag=tag):

if c_ns is NULL and tree._getNs(child._c_node) is not NULL:

continue

name = pyunicode(child._c_node.name)

if name not in children:

children[name] = child

finally:

cetree.unlock_read(doc)

return children

def __len__(self):

"""Count self and siblings with the same tag.

"""

return _countSiblings(self._c_node)

def countchildren(self):

"""countchildren(self)

Return the number of children of this element, regardless of their

name.

"""

# copied from etree

cdef Py_ssize_t count

cdef tree.xmlNode* c_node

count = 0

doc = self._doc

cetree.lock_read(doc)

try:

c_node = self._c_node.children

while c_node is not NULL:

count += tree._isElement(c_node)

c_node = c_node.next

finally:

cetree.unlock_read(doc)

return count

def getchildren(self):

"""getchildren(self)

Returns a sequence of all direct children. The elements are

returned in document order.

"""

cdef tree.xmlNode* c_node

result = []

doc = self._doc

cetree.lock_read(doc)

try:

c_node = self._c_node.children

while c_node is not NULL:

if tree._isElement(c_node):

result.append(cetree.elementFactory(doc, c_node))

c_node = c_node.next

finally:

cetree.unlock_read(doc)

return result

def __getattr__(self, tag):

"""Return the (first) child with the given tag name. If no namespace

is provided, the child will be looked up in the same one as self.

"""

doc = self._doc

cetree.lock_read(doc)

try:

return _lookupChildOrRaise(self, tag)

finally:

cetree.unlock_read(doc)

def __setattr__(self, tag, value):

"""Set the value of the (first) child with the given tag name. If no

namespace is provided, the child will be looked up in the same one as

self.

"""

cdef _Element element

# properties are looked up /after/ __setattr__, so we must emulate them

if tag == 'text' or tag == 'pyval':

# read-only !

raise TypeError, f"attribute '{tag}' of '{python._typename(self)}' objects is not writable"

elif tag == 'tail':

doc = self._doc

cetree.lock_write(doc)

try:

cetree.setTailText(self._c_node, value)

finally:

cetree.unlock_write(doc)

return

elif tag == 'tag':

ElementBase.tag.__set__(self, value)

return

elif tag == 'base':

ElementBase.base.__set__(self, value)

return

doc = self._doc

cetree.lock_write(doc)

try:

tag = _buildChildTag(self, tag)

element = _lookupChild(self, tag)

if element is None:

_appendValue(self, tag, value)

else:

_replaceElement(element, value)

finally:

cetree.unlock_write(doc)

def __delattr__(self, tag):

child = _lookupChildOrRaise(self, tag)

self.remove(child)

def addattr(self, tag, value):

"""addattr(self, tag, value)

Add a child value to the element.

As opposed to append(), it sets a data value, not an element.

"""

doc = self._doc

cetree.lock_write(doc)

try:

_appendValue(self, _buildChildTag(self, tag), value)

finally:

cetree.unlock_write(doc)

def __getitem__(self, key):

"""Return a sibling, counting from the first child of the parent. The

method behaves like both a dict and a sequence.

* If argument is an integer, returns the sibling at that position.

* If argument is a string, does the same as getattr(). This can be

used to provide namespaces for element lookup, or to look up

children with special names (``text`` etc.).

* If argument is a slice object, returns the matching slice.

"""

cdef tree.xmlNode* c_self_node

cdef tree.xmlNode* c_parent

cdef tree.xmlNode* c_node

cdef Py_ssize_t c_index

doc = self._doc

if python._isString(key):

cetree.lock_read(doc)

try:

return _lookupChildOrRaise(self, key)

finally:

cetree.unlock_read(doc)

elif isinstance(key, slice):

return list(self)[key]

# normal item access

cetree.lock_read(doc)

try:

c_index = key # raises TypeError if necessary

c_self_node = self._c_node

c_parent = c_self_node.parent

if c_parent is NULL:

if c_index == 0 or c_index == -1:

return self

raise IndexError, str(key)

if c_index < 0:

c_node = c_parent.last

else:

c_node = c_parent.children

c_node = _findFollowingSibling(

c_node, tree._getNs(c_self_node), c_self_node.name, c_index)

if c_node is NULL:

raise IndexError, str(key)

return elementFactory(doc, c_node)

finally:

cetree.unlock_read(doc)

def __setitem__(self, key, value):

"""Set the value of a sibling, counting from the first child of the

parent. Implements key assignment, item assignment and slice

assignment.

* If argument is an integer, sets the sibling at that position.

* If argument is a string, does the same as setattr(). This is used

to provide namespaces for element lookup.

* If argument is a sequence (list, tuple, etc.), assign the contained

items to the siblings.

"""

cdef _Element element

cdef tree.xmlNode* c_node

if python._isString(key):

doc = self._doc

cetree.lock_write(doc)

try:

key = _buildChildTag(self, key)

element = _lookupChild(self, key)

if element is None:

_appendValue(self, key, value)

else:

_replaceElement(element, value)

finally:

cetree.unlock_write(doc)

return

doc = self._doc

cetree.lock_write(doc)

try:

if self._c_node.parent is NULL:

# the 'root[i] = ...' case

raise TypeError, "assignment to root element is invalid"

if isinstance(key, slice):

# slice assignment

_setSlice(key, self, value)

else:

# normal index assignment

if key < 0:

c_node = self._c_node.parent.last

else:

c_node = self._c_node.parent.children

c_node = _findFollowingSibling(

c_node, tree._getNs(self._c_node), self._c_node.name, key)

if c_node is NULL:

raise IndexError, unicode(key)

element = elementFactory(doc, c_node)

_replaceElement(element, value)

finally:

cetree.unlock_write(doc)

def __delitem__(self, key):

parent = self.getparent()

if parent is None:

raise TypeError, "deleting items not supported by root element"

if isinstance(key, slice):

# slice deletion

del_items = list(self)[key]

remove = parent.remove

for el in del_items:

remove(el)

else:

# normal index deletion

sibling = self.__getitem__(key)

parent.remove(sibling)

def descendantpaths(self, prefix=None):

"""descendantpaths(self, prefix=None)

Returns a list of object path expressions for all descendants.

"""

if prefix is not None and not python._isString(prefix):

prefix = '.'.join(prefix)

doc = self._doc

cetree.lock_read(doc)

try:

return _build_descendant_paths(self._c_node, prefix)

finally:

cetree.unlock_read(doc)

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

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.xmlStrEqual(c_node_href, c_href)

cdef Py_ssize_t _countSiblings(tree.xmlNode* c_start_node) noexcept:

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

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

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

# 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 _lockedTextOf(self)

def __str__(self):

return _lockedTextOf(self) or ''

def __repr__(self):

return _lockedTextOf(self) or ''

def _setText(self, s):

"""For use in subclasses only. Don't use unless you know what you are

doing.

"""

doc = self._doc

cetree.lock_write(doc)

try:

cetree.setNodeText(self._c_node, s)

finally:

cetree.unlock_write(doc)

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 _lockedTextOf(self) or ''

def __repr__(self):

return repr(_lockedTextOf(self) or '')

def strlen(self):

text = _lockedTextOf(self)

return len(text) if text is not None else 0

def __bool__(self):

return bool(_lockedTextOf(self))

def __richcmp__(self, other, int op):

return _richcmpPyvals(self, other, op)

def __hash__(self):

return hash(_lockedTextOf(self) or '')

def __add__(self, other):

text = _lockedTextOf(self) or ''

other = _strValueOf(other)

return text + other

def __radd__(self, other):

text = _lockedTextOf(self) or ''

other = _strValueOf(other)

return other + text

def __mul__(self, other):

if isinstance(self, StringElement):

return (_lockedTextOf(<StringElement> self) or '') * _numericValueOf(other)

elif isinstance(other, StringElement):

return _numericValueOf(self) * (_lockedTextOf(<StringElement> other) or '')

else:

return NotImplemented

def __rmul__(self, other):

return _numericValueOf(other) * (_lockedTextOf(<StringElement> self) or '')

def __mod__(self, other):

return (_lockedTextOf(self) or '') % other

def __int__(self):

return int(_lockedTextOf(self))

def __float__(self):

return float(_lockedTextOf(self))

def __complex__(self):

return complex(_lockedTextOf(self))

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

def __int__(self):

return 0 + _parseBool(_lockedTextOf(self))

def __float__(self):

return 0.0 + _parseBool(_lockedTextOf(self))

def __richcmp__(self, other, int op):

return _richcmpPyvals(self, other, op)

def __hash__(self):

return hash(_parseBool(_lockedTextOf(self)))

def __str__(self):

return unicode(_parseBool(_lockedTextOf(self)))

def __repr__(self):

return repr(_parseBool(_lockedTextOf(self)))

@property

def pyval(self):

return _parseBool(_lockedTextOf(self))

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