|
|
|
|
|
|
|
|
|
|
|
|
|
|
""" |
|
|
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 |
|
|
from libc.string cimport const_char |
|
|
|
|
|
__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 _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) |
|
|
|
|
|
|
|
|
|
|
|
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) |
|
|
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("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): |
|
|
"""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 textOf(self._c_node) or '' |
|
|
|
|
|
|
|
|
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 = "{%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): |
|
|
"""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. |
|
|
""" |
|
|
|
|
|
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): |
|
|
"""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): |
|
|
"""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. |
|
|
""" |
|
|
return _lookupChildOrRaise(self, tag) |
|
|
|
|
|
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 |
|
|
|
|
|
if tag == 'text' or tag == 'pyval': |
|
|
|
|
|
raise TypeError, f"attribute '{tag}' of '{_typename(self)}' objects is not writable" |
|
|
elif tag == 'tail': |
|
|
cetree.setTailText(self._c_node, value) |
|
|
return |
|
|
elif tag == 'tag': |
|
|
ElementBase.tag.__set__(self, value) |
|
|
return |
|
|
elif tag == '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): |
|
|
"""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): |
|
|
"""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] |
|
|
|
|
|
c_index = key |
|
|
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): |
|
|
"""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: |
|
|
|
|
|
raise TypeError, "assignment to root element is invalid" |
|
|
|
|
|
if isinstance(key, slice): |
|
|
|
|
|
_setSlice(key, self, value) |
|
|
else: |
|
|
|
|
|
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, "deleting items not supported by root element" |
|
|
if isinstance(key, slice): |
|
|
|
|
|
del_items = list(self)[key] |
|
|
remove = parent.remove |
|
|
for el in del_items: |
|
|
remove(el) |
|
|
else: |
|
|
|
|
|
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) |
|
|
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 |
|
|
if ns is None: |
|
|
|
|
|
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): |
|
|
|
|
|
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): |
|
|
|
|
|
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 = _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 |
|
|
|
|
|
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] |
|
|
|
|
|
|
|
|
new_items = [] |
|
|
tag = target.tag |
|
|
for item in items: |
|
|
if isinstance(item, _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) |
|
|
|
|
|
|
|
|
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)}" |
|
|
|
|
|
|
|
|
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 |
|
|
|
|
|
if pos < len(del_items): |
|
|
remove = parent.remove |
|
|
while pos < len(del_items): |
|
|
remove(del_items[pos]) |
|
|
pos += 1 |
|
|
|
|
|
if pos < len(new_items): |
|
|
|
|
|
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): |
|
|
"""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 textOf(self._c_node) or '' |
|
|
|
|
|
def _setText(self, s): |
|
|
"""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): |
|
|
"""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 textOf(self._c_node) or '' |
|
|
|
|
|
def __repr__(self): |
|
|
return repr(textOf(self._c_node) or '') |
|
|
|
|
|
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 '') |
|
|
|
|
|
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 __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 "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 |
|
|
|
|
|
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 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 |
|
|
|
|
|
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': |
|
|
|
|
|
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 |
|
|
|
|
|
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): |
|
|
return _checkNumber(<unicode>s, allow_float=False) |
|
|
|
|
|
|
|
|
cdef _checkFloat(s): |
|
|
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 '' |
|
|
if obj is None: |
|
|
return '' |
|
|
return unicode(obj) |
|
|
|
|
|
|
|
|
cdef object _numericValueOf(obj): |
|
|
if isinstance(obj, NumberElement): |
|
|
return _parseNumber(<NumberElement>obj) |
|
|
try: |
|
|
|
|
|
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) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cdef class PyType: |
|
|
"""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, "Type name must be a string" |
|
|
if type_check is not None and not callable(type_check): |
|
|
raise TypeError, "Type check function must be callable (or None)" |
|
|
if name != TREE_PYTYPE_NAME and \ |
|
|
not issubclass(type_class, ObjectifiedDataElement): |
|
|
raise TypeError, \ |
|
|
"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): |
|
|
"""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, "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, "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): |
|
|
"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: |
|
|
"""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 "true" if value else "false" |
|
|
|
|
|
cdef unicode _xml_float(value): |
|
|
if _float_is_inf(value): |
|
|
if value > 0: |
|
|
return "INF" |
|
|
return "-INF" |
|
|
if _float_is_nan(value): |
|
|
return "NaN" |
|
|
return unicode(repr(value)) |
|
|
|
|
|
cdef _pytypename(obj): |
|
|
return "str" if python._isString(obj) else _typename(obj) |
|
|
|
|
|
def pytypename(obj): |
|
|
"""pytypename(obj) |
|
|
|
|
|
Find the name of the corresponding PyType for a Python object. |
|
|
""" |
|
|
return _pytypename(obj) |
|
|
|
|
|
cdef _registerPyTypes(): |
|
|
pytype = PyType('int', _checkInt, IntElement) |
|
|
pytype.xmlSchemaTypes = ("integer", "int", "short", "byte", "unsignedShort", |
|
|
"unsignedByte", "nonPositiveInteger", |
|
|
"negativeInteger", "long", "nonNegativeInteger", |
|
|
"unsignedLong", "unsignedInt", "positiveInteger",) |
|
|
pytype.register() |
|
|
|
|
|
|
|
|
pytype = PyType('long', None, IntElement) |
|
|
pytype.register() |
|
|
|
|
|
pytype = PyType('float', _checkFloat, FloatElement, _xml_float) |
|
|
pytype.xmlSchemaTypes = ("double", "float") |
|
|
pytype.register() |
|
|
|
|
|
pytype = PyType('bool', _checkBool, BoolElement, _xml_bool) |
|
|
pytype.xmlSchemaTypes = ("boolean",) |
|
|
pytype.register() |
|
|
|
|
|
pytype = PyType('str', None, StringElement) |
|
|
pytype.xmlSchemaTypes = ("string", "normalizedString", "token", "language", |
|
|
"Name", "NCName", "ID", "IDREF", "ENTITY", |
|
|
"NMTOKEN", ) |
|
|
pytype.register() |
|
|
|
|
|
|
|
|
pytype = PyType('NoneType', None, NoneElement) |
|
|
pytype.register() |
|
|
|
|
|
|
|
|
pytype = PyType('none', None, NoneElement) |
|
|
pytype.register() |
|
|
|
|
|
|
|
|
cdef PyType TREE_PYTYPE = PyType(TREE_PYTYPE_NAME, None, ObjectifiedElement) |
|
|
|
|
|
_registerPyTypes() |
|
|
|
|
|
def getRegisteredTypes(): |
|
|
"""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: |
|
|
|
|
|
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 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@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): |
|
|
"__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, "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(): |
|
|
|
|
|
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: |
|
|
|
|
|
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, "str") |
|
|
elif pytype_name is not None: |
|
|
cetree.setAttributeValue(element, PYTYPE_ATTRIBUTE, pytype_name) |
|
|
|
|
|
return element |
|
|
|
|
|
cdef _add_text(_Element elem, text): |
|
|
|
|
|
|
|
|
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: |
|
|
"""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 "{%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] != "{": |
|
|
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: |
|
|
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) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cdef bint __RECURSIVE_STR = 0 |
|
|
|
|
|
def enable_recursive_str(on=True): |
|
|
"""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): |
|
|
"""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 = " " * 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 = "{%s}" % XML_SCHEMA_INSTANCE_NS |
|
|
pytype_ns = "{%s}" % PYTYPE_NAMESPACE |
|
|
for name, value in sorted(cetree.iterattributes(element, 3)): |
|
|
if '{' in name: |
|
|
if name == PYTYPE_ATTRIBUTE: |
|
|
if value == TREE_PYTYPE_NAME: |
|
|
continue |
|
|
else: |
|
|
name = name.replace(pytype_ns, 'py:') |
|
|
name = name.replace(xsi_ns, '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] |
|
|
else: |
|
|
return result |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def __unpickleElementTree(data): |
|
|
return etree.ElementTree(fromstring(data)) |
|
|
|
|
|
cdef _setupPickle(elementTreeReduceFunction): |
|
|
import copyreg |
|
|
copyreg.pickle(etree._ElementTree, |
|
|
elementTreeReduceFunction, __unpickleElementTree) |
|
|
|
|
|
def pickleReduceElementTree(obj): |
|
|
return __unpickleElementTree, (etree.tostring(obj),) |
|
|
|
|
|
_setupPickle(pickleReduceElementTree) |
|
|
del pickleReduceElementTree |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cdef class ObjectifyElementClassLookup(ElementClassLookup): |
|
|
"""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): |
|
|
"""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 cetree.hasChild(c_node): |
|
|
return lookup.tree_class |
|
|
|
|
|
|
|
|
if "true" == cetree.attributeValueFromNsName( |
|
|
c_node, _XML_SCHEMA_INSTANCE_NS, <unsigned char*>"nil"): |
|
|
return NoneElement |
|
|
|
|
|
|
|
|
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 |
|
|
|
|
|
|
|
|
|
|
|
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 ':' in value: |
|
|
prefix, value = value.split(':', 1) |
|
|
schema_type = <PyType>_SCHEMA_TYPE_DICT.get(value) |
|
|
if schema_type is not None: |
|
|
return schema_type._type |
|
|
|
|
|
|
|
|
el_class = _guessElementClass(c_node) |
|
|
if el_class is not None: |
|
|
return el_class |
|
|
|
|
|
|
|
|
if c_node.parent is NULL or not tree._isElement(c_node.parent): |
|
|
return lookup.tree_class |
|
|
|
|
|
return lookup.empty_data_class |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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: |
|
|
|
|
|
pass |
|
|
return None |
|
|
|
|
|
def pyannotate(element_or_tree, *, ignore_old=False, ignore_xsi=False, |
|
|
empty_pytype=None): |
|
|
"""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): |
|
|
"""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): |
|
|
"""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('str') |
|
|
NoneType = <PyType>_PYTYPE_DICT.get('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 cetree.attributeValueFromNsName( |
|
|
c_node, _XML_SCHEMA_INSTANCE_NS, <unsigned char*>"nil") == "true": |
|
|
pytype = NoneType |
|
|
|
|
|
if pytype is None and not ignore_xsi: |
|
|
|
|
|
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 ':' in typename: |
|
|
prefix, typename = typename.split(':', 1) |
|
|
pytype = <PyType>_SCHEMA_TYPE_DICT.get(typename) |
|
|
if pytype is not None and pytype is not StrType: |
|
|
|
|
|
|
|
|
|
|
|
pytype = _check_type(c_node, pytype) |
|
|
if pytype is None: |
|
|
typename = None |
|
|
|
|
|
if pytype is None and not ignore_pytype: |
|
|
|
|
|
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): |
|
|
|
|
|
|
|
|
pytype = TREE_PYTYPE |
|
|
else: |
|
|
if old_pytypename == 'none': |
|
|
|
|
|
old_pytypename = "NoneType" |
|
|
pytype = <PyType>_PYTYPE_DICT.get(old_pytypename) |
|
|
if pytype is not None and pytype is not StrType: |
|
|
|
|
|
|
|
|
|
|
|
pytype = _check_type(c_node, pytype) |
|
|
|
|
|
if pytype is None: |
|
|
|
|
|
if not cetree.hasChild(c_node): |
|
|
|
|
|
pytype = _guessPyType(textOf(c_node), StrType) |
|
|
else: |
|
|
istree = 1 |
|
|
|
|
|
if pytype is None: |
|
|
|
|
|
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: |
|
|
|
|
|
|
|
|
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: |
|
|
|
|
|
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: |
|
|
|
|
|
cetree.delAttributeFromNsName( |
|
|
c_node, _PYTYPE_NAMESPACE, _PYTYPE_ATTRIBUTE_NAME) |
|
|
else: |
|
|
|
|
|
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): |
|
|
"""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) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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): |
|
|
"""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, "parser must inherit from lxml.etree.XMLParser" |
|
|
|
|
|
def makeparser(**kw): |
|
|
"""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) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cdef object _fromstring |
|
|
_fromstring = etree.fromstring |
|
|
|
|
|
SubElement = etree.SubElement |
|
|
|
|
|
def fromstring(xml, parser=None, *, base_url=None): |
|
|
"""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): |
|
|
"""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): |
|
|
"""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): |
|
|
"""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): |
|
|
"""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: |
|
|
|
|
|
return _value.__copy__() |
|
|
if isinstance(_value, ObjectifiedDataElement): |
|
|
|
|
|
temp = _value.nsmap |
|
|
if temp is not None and temp: |
|
|
temp = dict(temp) |
|
|
temp.update(nsmap) |
|
|
nsmap = temp |
|
|
|
|
|
temp = _value.attrib |
|
|
if temp is not None and temp: |
|
|
temp = dict(temp) |
|
|
temp.update(_attributes) |
|
|
_attributes = temp |
|
|
|
|
|
|
|
|
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 ':' in _xsi: |
|
|
prefix, name = _xsi.split(':', 1) |
|
|
ns = nsmap.get(prefix) |
|
|
if ns != XML_SCHEMA_NS: |
|
|
raise ValueError, "XSD types require the XSD namespace" |
|
|
elif nsmap is _DEFAULT_NSMAP: |
|
|
name = _xsi |
|
|
_xsi = '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 + ':' + _xsi |
|
|
break |
|
|
else: |
|
|
raise ValueError, "XSD types require the XSD namespace" |
|
|
_attributes[XML_SCHEMA_INSTANCE_TYPE_ATTR] = _xsi |
|
|
if _pytype is None: |
|
|
|
|
|
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 != "str": |
|
|
_pytype = _pytype or "NoneType" |
|
|
strval = None |
|
|
elif python._isString(_value): |
|
|
strval = _value |
|
|
elif isinstance(_value, bool): |
|
|
if _value: |
|
|
strval = "true" |
|
|
else: |
|
|
strval = "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 == "NoneType" or _pytype == "none": |
|
|
strval = None |
|
|
_attributes[XML_SCHEMA_INSTANCE_NIL_ATTR] = "true" |
|
|
else: |
|
|
|
|
|
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("value", strval, _attributes, nsmap) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
include "objectpath.pxi" |
|
|
|
