Edit File: objectify.pyx
# cython: binding=True # cython: auto_pickle=False # cython: language_level=2 """ The ``lxml.objectify`` module implements a Python object API for XML. It is based on `lxml.etree`. """ from __future__ import absolute_import 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__ = [u'BoolElement', u'DataElement', u'E', u'Element', u'ElementMaker', u'FloatElement', u'IntElement', u'LongElement', u'NoneElement', u'NumberElement', u'ObjectPath', u'ObjectifiedDataElement', u'ObjectifiedElement', u'ObjectifyElementClassLookup', u'PYTYPE_ATTRIBUTE', u'PyType', u'StringElement', u'SubElement', u'XML', u'annotate', u'deannotate', u'dump', u'enable_recursive_str', u'fromstring', u'getRegisteredTypes', u'makeparser', u'parse', u'pyannotate', u'pytypename', u'set_default_parser', u'set_pytype_attribute_tag', u'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(u'__.*__$').match # Duplicated from apihelpers.pxi, since dependencies obstruct # including apihelpers.pxi. cdef strrepr(s): """Build a representation of strings which we can use in __repr__ methods, e.g. _Element.__repr__(). """ return s.encode('unicode-escape') if python.IS_PYTHON2 else s 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(<const_xmlChar*>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 = u"TREE" cdef tuple _unicodeAndUtf8(s): return s, python.PyUnicode_AsUTF8String(s) def set_pytype_attribute_tag(attribute_tag=None): u"""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(u"http://codespeak.net/lxml/objectify/pytype") PYTYPE_ATTRIBUTE_NAME, PYTYPE_ATTRIBUTE_NAME_UTF8 = \ _unicodeAndUtf8(u"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(u"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(u"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 = u"{%s}nil" % XML_SCHEMA_INSTANCE_NS cdef object XML_SCHEMA_INSTANCE_TYPE_ATTR = u"{%s}type" % XML_SCHEMA_INSTANCE_NS ################################################################################ # Element class for the main API cdef class ObjectifiedElement(ElementBase): u"""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): u"""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 textOf(self._c_node) or u'' # pickle support for objectified Element def __reduce__(self): return fromstring, (etree.tostring(self),) @property def text(self): return textOf(self._c_node) @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 c_ns = tree._getNs(self._c_node) tag = u"{%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 return children def __len__(self): u"""Count self and siblings with the same tag. """ return _countSiblings(self._c_node) def countchildren(self): u"""countchildren(self) Return the number of children of this element, regardless of their name. """ # copied from etree cdef Py_ssize_t c cdef tree.xmlNode* c_node c = 0 c_node = self._c_node.children while c_node is not NULL: if tree._isElement(c_node): c += 1 c_node = c_node.next return c def getchildren(self): u"""getchildren(self) Returns a sequence of all direct children. The elements are returned in document order. """ cdef tree.xmlNode* c_node result = [] c_node = self._c_node.children while c_node is not NULL: if tree._isElement(c_node): result.append(cetree.elementFactory(self._doc, c_node)) c_node = c_node.next return result def __getattr__(self, tag): u"""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. """ if is_special_method(tag): return object.__getattr__(self, tag) return _lookupChildOrRaise(self, tag) def __setattr__(self, tag, value): u"""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 == u'text' or tag == u'pyval': # read-only ! raise TypeError, f"attribute '{tag}' of '{_typename(self)}' objects is not writable" elif tag == u'tail': cetree.setTailText(self._c_node, value) return elif tag == u'tag': ElementBase.tag.__set__(self, value) return elif tag == u'base': ElementBase.base.__set__(self, value) return tag = _buildChildTag(self, tag) element = _lookupChild(self, tag) if element is None: _appendValue(self, tag, value) else: _replaceElement(element, value) def __delattr__(self, tag): child = _lookupChildOrRaise(self, tag) self.remove(child) def addattr(self, tag, value): u"""addattr(self, tag, value) Add a child value to the element. As opposed to append(), it sets a data value, not an element. """ _appendValue(self, _buildChildTag(self, tag), value) def __getitem__(self, key): u"""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 if python._isString(key): return _lookupChildOrRaise(self, key) elif isinstance(key, slice): return list(self)[key] # normal item access 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, unicode(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, unicode(key) return elementFactory(self._doc, c_node) def __setitem__(self, key, value): u"""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): key = _buildChildTag(self, key) element = _lookupChild(self, key) if element is None: _appendValue(self, key, value) else: _replaceElement(element, value) return if self._c_node.parent is NULL: # the 'root[i] = ...' case raise TypeError, u"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(self._doc, c_node) _replaceElement(element, value) def __delitem__(self, key): parent = self.getparent() if parent is None: raise TypeError, u"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): u"""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 = u'.'.join(prefix) 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 = tree.xmlDictExists( c_node.doc.dict, _xcstr(tag), python.PyBytes_GET_SIZE(tag)) 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, u"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, u"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 = u"str" py_type = <PyType>_PYTYPE_DICT.get(pytype_name) else: pytype_name = _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, u"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): u"""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 strrepr(textOf(self._c_node) or '') def _setText(self, s): u"""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): u"""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 __long__(self): return long(_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 LongElement(NumberElement): def _init(self): self._parse_value = long def __index__(self): return int(_parseNumber(self)) cdef class FloatElement(NumberElement): def _init(self): self._parse_value = float cdef class StringElement(ObjectifiedDataElement): u"""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 u'' def __repr__(self): return repr(textOf(self._c_node) or u'') 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 u'') 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((<StringElement>self)._c_node) or '') * _numericValueOf(other) elif isinstance(other, StringElement): return _numericValueOf(self) * (textOf((<StringElement>other)._c_node) or '') else: return NotImplemented def __rmul__(self, other): return _numericValueOf(other) * (textOf((<StringElement>self)._c_node) or '') def __mod__(self, other): return (_strValueOf(self) or '') % other def __int__(self): return int(textOf(self._c_node)) def __long__(self): return long(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 u"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): u"""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.isdigit() if (bytes_unicode is unicode) else c in b'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 == u'.': 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 u'-+': if state == NPS_SPACE_PRE: state = NPS_SIGN elif state == NPS_EXP: state = NPS_EXP_SIGN else: state = NPS_ERROR elif c == u'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 u'iI': state = NPS_INF1 if allow_float and state in (NPS_SPACE_PRE, NPS_SIGN) else NPS_ERROR elif c in u'fF': state = NPS_INF3 if state == NPS_INF2 else NPS_ERROR elif c in u'aA': state = NPS_NAN2 if state == NPS_NAN1 else NPS_ERROR elif c in u'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): if python.IS_PYTHON2 and type(s) is bytes: return _checkNumber(<bytes>s, allow_float=False) else: return _checkNumber(<unicode>s, allow_float=False) cdef _checkFloat(s): if python.IS_PYTHON2 and type(s) is bytes: return _checkNumber(<bytes>s, allow_float=True) else: return _checkNumber(<unicode>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 u'' if obj is None: return u'' return unicode(obj) cdef object _numericValueOf(obj): if isinstance(obj, NumberElement): return _parseNumber(<NumberElement>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: u"""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 = (<bytes>name).decode('ascii') elif not isinstance(name, unicode): raise TypeError, u"Type name must be a string" if type_check is not None and not callable(type_check): raise TypeError, u"Type check function must be callable (or None)" if name != TREE_PYTYPE_NAME and \ not issubclass(type_class, ObjectifiedDataElement): raise TypeError, \ u"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): u"""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, u"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, u"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): u"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: u"""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 u"true" if value else u"false" cdef unicode _xml_float(value): if _float_is_inf(value): if value > 0: return u"INF" return u"-INF" if _float_is_nan(value): return u"NaN" return unicode(repr(value)) cdef _pytypename(obj): return u"str" if python._isString(obj) else _typename(obj) def pytypename(obj): u"""pytypename(obj) Find the name of the corresponding PyType for a Python object. """ return _pytypename(obj) cdef _registerPyTypes(): pytype = PyType(u'int', _checkInt, IntElement) # wraps functions for Python pytype.xmlSchemaTypes = (u"integer", u"int", u"short", u"byte", u"unsignedShort", u"unsignedByte", u"nonPositiveInteger", u"negativeInteger", u"long", u"nonNegativeInteger", u"unsignedLong", u"unsignedInt", u"positiveInteger",) pytype.register() # 'long' type just for backwards compatibility pytype = PyType(u'long', None, IntElement) pytype.register() pytype = PyType(u'float', _checkFloat, FloatElement, _xml_float) # wraps functions for Python pytype.xmlSchemaTypes = (u"double", u"float") pytype.register() pytype = PyType(u'bool', _checkBool, BoolElement, _xml_bool) # wraps functions for Python pytype.xmlSchemaTypes = (u"boolean",) pytype.register() pytype = PyType(u'str', None, StringElement) pytype.xmlSchemaTypes = (u"string", u"normalizedString", u"token", u"language", u"Name", u"NCName", u"ID", u"IDREF", u"ENTITY", u"NMTOKEN", ) pytype.register() # since lxml 2.0 pytype = PyType(u'NoneType', None, NoneElement) pytype.register() # backwards compatibility pytype = PyType(u'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(): u"""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 <PyType>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>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): u"__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, u"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>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>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, u"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: u"""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')) <html><body><p style="font-weight: bold" class="par">hello<br>objectify</p></body></html> 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 u"{%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] != u"{": 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: if is_special_method(tag): return object.__getattr__(self, tag) 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): u"""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): u"""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 = u" " * 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 = u"{%s}" % XML_SCHEMA_INSTANCE_NS pytype_ns = u"{%s}" % PYTYPE_NAMESPACE for name, value in sorted(cetree.iterattributes(element, 3)): if u'{' in name: if name == PYTYPE_ATTRIBUTE: if value == TREE_PYTYPE_NAME: continue else: name = name.replace(pytype_ns, u'py:') name = name.replace(xsi_ns, u'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): if python.IS_PYTHON2: import copy_reg as copyreg else: 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): u"""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): u"""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 = <ObjectifyElementClassLookup>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 u"true" == cetree.attributeValueFromNsName( c_node, _XML_SCHEMA_INSTANCE_NS, <unsigned char*>"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>_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, <unsigned char*>"type") if value is not None: schema_type = <PyType>_SCHEMA_TYPE_DICT.get(value) if schema_type is None and u':' in value: prefix, value = value.split(u':', 1) schema_type = <PyType>_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): u"""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): u"""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): u"""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 = (<bytes>empty_type_name).decode("ascii") empty_pytype = <PyType>_SCHEMA_TYPE_DICT.get(empty_type_name) elif empty_pytype_name is not None: if isinstance(empty_pytype_name, bytes): empty_pytype_name = (<bytes>empty_pytype_name).decode("ascii") empty_pytype = <PyType>_PYTYPE_DICT.get(empty_pytype_name) else: empty_pytype = None StrType = <PyType>_PYTYPE_DICT.get(u'str') NoneType = <PyType>_PYTYPE_DICT.get(u'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, <unsigned char*>"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, <unsigned char*>"type") if typename is not None: pytype = <PyType>_SCHEMA_TYPE_DICT.get(typename) if pytype is None and u':' in typename: prefix, typename = typename.split(u':', 1) pytype = <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>_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, <unsigned char*>"type") else: # update or create attribute typename_utf8 = cetree.utf8(typename) c_ns = cetree.findOrBuildNodeNsPrefix( doc, c_node, _XML_SCHEMA_NS, <unsigned char*>'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 = (<unsigned char*>c_ns.prefix) + b':' + name elif c_ns.prefix is not NULL and c_ns.prefix[0] != c'\0': typename_utf8 = (<unsigned char*>c_ns.prefix) + b':' + typename_utf8 c_ns = cetree.findOrBuildNodeNsPrefix( doc, c_node, _XML_SCHEMA_INSTANCE_NS, <unsigned char*>'xsi') tree.xmlSetNsProp(c_node, c_ns, <unsigned char*>"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, <unsigned char*>'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, <unsigned char*>'xsi') tree.xmlSetNsProp(c_node, c_ns, <unsigned char*>"nil", <unsigned char*>"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): u"""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): u"""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, u"parser must inherit from lxml.etree.XMLParser" def makeparser(**kw): u"""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): u"""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): u"""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): u"""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): u"""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): u"""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 u':' in _xsi: prefix, name = _xsi.split(u':', 1) ns = nsmap.get(prefix) if ns != XML_SCHEMA_NS: raise ValueError, u"XSD types require the XSD namespace" elif nsmap is _DEFAULT_NSMAP: name = _xsi _xsi = u'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 + u':' + _xsi break else: raise ValueError, u"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 = <PyType>_SCHEMA_TYPE_DICT.get(_xsi) if py_type is None: py_type = <PyType>_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 != u"str": _pytype = _pytype or u"NoneType" strval = None elif python._isString(_value): strval = _value elif isinstance(_value, bool): if _value: strval = u"true" else: strval = u"false" else: py_type = <PyType>_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 == u"NoneType" or _pytype == u"none": strval = None _attributes[XML_SCHEMA_INSTANCE_NIL_ATTR] = u"true" else: # check if type information from arguments is valid py_type = <PyType>_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(u"value", strval, _attributes, nsmap) ################################################################################ # ObjectPath include "objectpath.pxi"
Back to File Manager