Current File : //opt/cloudlinux/venv/lib64/python3.11/site-packages/lxml/classlookup.pxi
# Configurable Element class lookup
################################################################################
# Custom Element classes
cdef public class ElementBase(_Element) [ type LxmlElementBaseType,
object LxmlElementBase ]:
u"""ElementBase(*children, attrib=None, nsmap=None, **_extra)
The public Element class. All custom Element classes must inherit
from this one. To create an Element, use the `Element()` factory.
BIG FAT WARNING: Subclasses *must not* override __init__ or
__new__ as it is absolutely undefined when these objects will be
created or destroyed. All persistent state of Elements must be
stored in the underlying XML. If you really need to initialize
the object after creation, you can implement an ``_init(self)``
method that will be called directly after object creation.
Subclasses of this class can be instantiated to create a new
Element. By default, the tag name will be the class name and the
namespace will be empty. You can modify this with the following
class attributes:
* TAG - the tag name, possibly containing a namespace in Clark
notation
* NAMESPACE - the default namespace URI, unless provided as part
of the TAG attribute.
* HTML - flag if the class is an HTML tag, as opposed to an XML
tag. This only applies to un-namespaced tags and defaults to
false (i.e. XML).
* PARSER - the parser that provides the configuration for the
newly created document. Providing an HTML parser here will
default to creating an HTML element.
In user code, the latter three are commonly inherited in class
hierarchies that implement a common namespace.
"""
def __init__(self, *children, attrib=None, nsmap=None, **_extra):
u"""ElementBase(*children, attrib=None, nsmap=None, **_extra)
"""
cdef bint is_html = 0
cdef _BaseParser parser
cdef _Element last_child
# don't use normal attribute access as it might be overridden
_getattr = object.__getattribute__
try:
namespace = _utf8(_getattr(self, 'NAMESPACE'))
except AttributeError:
namespace = None
try:
ns, tag = _getNsTag(_getattr(self, 'TAG'))
if ns is not None:
namespace = ns
except AttributeError:
tag = _utf8(_getattr(_getattr(self, '__class__'), '__name__'))
if b'.' in tag:
tag = tag.split(b'.')[-1]
try:
parser = _getattr(self, 'PARSER')
except AttributeError:
parser = None
for child in children:
if isinstance(child, _Element):
parser = (<_Element>child)._doc._parser
break
if isinstance(parser, HTMLParser):
is_html = 1
if namespace is None:
try:
is_html = _getattr(self, 'HTML')
except AttributeError:
pass
_initNewElement(self, is_html, tag, namespace, parser,
attrib, nsmap, _extra)
last_child = None
for child in children:
if _isString(child):
if last_child is None:
_setNodeText(self._c_node,
(_collectText(self._c_node.children) or '') + child)
else:
_setTailText(last_child._c_node,
(_collectText(last_child._c_node.next) or '') + child)
elif isinstance(child, _Element):
last_child = child
_appendChild(self, last_child)
elif isinstance(child, type) and issubclass(child, ElementBase):
last_child = child()
_appendChild(self, last_child)
else:
raise TypeError, f"Invalid child type: {type(child)!r}"
cdef class CommentBase(_Comment):
u"""All custom Comment classes must inherit from this one.
To create an XML Comment instance, use the ``Comment()`` factory.
Subclasses *must not* override __init__ or __new__ as it is
absolutely undefined when these objects will be created or
destroyed. All persistent state of Comments must be stored in the
underlying XML. If you really need to initialize the object after
creation, you can implement an ``_init(self)`` method that will be
called after object creation.
"""
def __init__(self, text):
# copied from Comment() factory
cdef _Document doc
cdef xmlDoc* c_doc
if text is None:
text = b''
else:
text = _utf8(text)
c_doc = _newXMLDoc()
doc = _documentFactory(c_doc, None)
self._c_node = _createComment(c_doc, _xcstr(text))
if self._c_node is NULL:
raise MemoryError()
tree.xmlAddChild(<xmlNode*>c_doc, self._c_node)
_registerProxy(self, doc, self._c_node)
self._init()
cdef class PIBase(_ProcessingInstruction):
u"""All custom Processing Instruction classes must inherit from this one.
To create an XML ProcessingInstruction instance, use the ``PI()``
factory.
Subclasses *must not* override __init__ or __new__ as it is
absolutely undefined when these objects will be created or
destroyed. All persistent state of PIs must be stored in the
underlying XML. If you really need to initialize the object after
creation, you can implement an ``_init(self)`` method that will be
called after object creation.
"""
def __init__(self, target, text=None):
# copied from PI() factory
cdef _Document doc
cdef xmlDoc* c_doc
target = _utf8(target)
if text is None:
text = b''
else:
text = _utf8(text)
c_doc = _newXMLDoc()
doc = _documentFactory(c_doc, None)
self._c_node = _createPI(c_doc, _xcstr(target), _xcstr(text))
if self._c_node is NULL:
raise MemoryError()
tree.xmlAddChild(<xmlNode*>c_doc, self._c_node)
_registerProxy(self, doc, self._c_node)
self._init()
cdef class EntityBase(_Entity):
u"""All custom Entity classes must inherit from this one.
To create an XML Entity instance, use the ``Entity()`` factory.
Subclasses *must not* override __init__ or __new__ as it is
absolutely undefined when these objects will be created or
destroyed. All persistent state of Entities must be stored in the
underlying XML. If you really need to initialize the object after
creation, you can implement an ``_init(self)`` method that will be
called after object creation.
"""
def __init__(self, name):
cdef _Document doc
cdef xmlDoc* c_doc
name_utf = _utf8(name)
c_name = _xcstr(name_utf)
if c_name[0] == c'#':
if not _characterReferenceIsValid(c_name + 1):
raise ValueError, f"Invalid character reference: '{name}'"
elif not _xmlNameIsValid(c_name):
raise ValueError, f"Invalid entity reference: '{name}'"
c_doc = _newXMLDoc()
doc = _documentFactory(c_doc, None)
self._c_node = _createEntity(c_doc, c_name)
if self._c_node is NULL:
raise MemoryError()
tree.xmlAddChild(<xmlNode*>c_doc, self._c_node)
_registerProxy(self, doc, self._c_node)
self._init()
cdef int _validateNodeClass(xmlNode* c_node, cls) except -1:
if c_node.type == tree.XML_ELEMENT_NODE:
expected = ElementBase
elif c_node.type == tree.XML_COMMENT_NODE:
expected = CommentBase
elif c_node.type == tree.XML_ENTITY_REF_NODE:
expected = EntityBase
elif c_node.type == tree.XML_PI_NODE:
expected = PIBase
else:
assert False, f"Unknown node type: {c_node.type}"
if not (isinstance(cls, type) and issubclass(cls, expected)):
raise TypeError(
f"result of class lookup must be subclass of {type(expected)}, got {type(cls)}")
return 0
################################################################################
# Element class lookup
ctypedef public object (*_element_class_lookup_function)(object, _Document, xmlNode*)
# class to store element class lookup functions
cdef public class ElementClassLookup [ type LxmlElementClassLookupType,
object LxmlElementClassLookup ]:
u"""ElementClassLookup(self)
Superclass of Element class lookups.
"""
cdef _element_class_lookup_function _lookup_function
cdef public class FallbackElementClassLookup(ElementClassLookup) \
[ type LxmlFallbackElementClassLookupType,
object LxmlFallbackElementClassLookup ]:
u"""FallbackElementClassLookup(self, fallback=None)
Superclass of Element class lookups with additional fallback.
"""
cdef readonly ElementClassLookup fallback
cdef _element_class_lookup_function _fallback_function
def __cinit__(self):
# fall back to default lookup
self._fallback_function = _lookupDefaultElementClass
def __init__(self, ElementClassLookup fallback=None):
if fallback is not None:
self._setFallback(fallback)
else:
self._fallback_function = _lookupDefaultElementClass
cdef void _setFallback(self, ElementClassLookup lookup):
u"""Sets the fallback scheme for this lookup method.
"""
self.fallback = lookup
self._fallback_function = lookup._lookup_function
if self._fallback_function is NULL:
self._fallback_function = _lookupDefaultElementClass
def set_fallback(self, ElementClassLookup lookup not None):
u"""set_fallback(self, lookup)
Sets the fallback scheme for this lookup method.
"""
self._setFallback(lookup)
cdef inline object _callLookupFallback(FallbackElementClassLookup lookup,
_Document doc, xmlNode* c_node):
return lookup._fallback_function(lookup.fallback, doc, c_node)
################################################################################
# default lookup scheme
cdef class ElementDefaultClassLookup(ElementClassLookup):
u"""ElementDefaultClassLookup(self, element=None, comment=None, pi=None, entity=None)
Element class lookup scheme that always returns the default Element
class.
The keyword arguments ``element``, ``comment``, ``pi`` and ``entity``
accept the respective Element classes.
"""
cdef readonly object element_class
cdef readonly object comment_class
cdef readonly object pi_class
cdef readonly object entity_class
def __cinit__(self):
self._lookup_function = _lookupDefaultElementClass
def __init__(self, element=None, comment=None, pi=None, entity=None):
if element is None:
self.element_class = _Element
elif issubclass(element, ElementBase):
self.element_class = element
else:
raise TypeError, u"element class must be subclass of ElementBase"
if comment is None:
self.comment_class = _Comment
elif issubclass(comment, CommentBase):
self.comment_class = comment
else:
raise TypeError, u"comment class must be subclass of CommentBase"
if entity is None:
self.entity_class = _Entity
elif issubclass(entity, EntityBase):
self.entity_class = entity
else:
raise TypeError, u"Entity class must be subclass of EntityBase"
if pi is None:
self.pi_class = None # special case, see below
elif issubclass(pi, PIBase):
self.pi_class = pi
else:
raise TypeError, u"PI class must be subclass of PIBase"
cdef object _lookupDefaultElementClass(state, _Document _doc, xmlNode* c_node):
u"Trivial class lookup function that always returns the default class."
if c_node.type == tree.XML_ELEMENT_NODE:
if state is not None:
return (<ElementDefaultClassLookup>state).element_class
else:
return _Element
elif c_node.type == tree.XML_COMMENT_NODE:
if state is not None:
return (<ElementDefaultClassLookup>state).comment_class
else:
return _Comment
elif c_node.type == tree.XML_ENTITY_REF_NODE:
if state is not None:
return (<ElementDefaultClassLookup>state).entity_class
else:
return _Entity
elif c_node.type == tree.XML_PI_NODE:
if state is None or (<ElementDefaultClassLookup>state).pi_class is None:
# special case XSLT-PI
if c_node.name is not NULL and c_node.content is not NULL:
if tree.xmlStrcmp(c_node.name, <unsigned char*>"xml-stylesheet") == 0:
if tree.xmlStrstr(c_node.content, <unsigned char*>"text/xsl") is not NULL or \
tree.xmlStrstr(c_node.content, <unsigned char*>"text/xml") is not NULL:
return _XSLTProcessingInstruction
return _ProcessingInstruction
else:
return (<ElementDefaultClassLookup>state).pi_class
else:
assert False, f"Unknown node type: {c_node.type}"
################################################################################
# attribute based lookup scheme
cdef class AttributeBasedElementClassLookup(FallbackElementClassLookup):
u"""AttributeBasedElementClassLookup(self, attribute_name, class_mapping, fallback=None)
Checks an attribute of an Element and looks up the value in a
class dictionary.
Arguments:
- attribute name - '{ns}name' style string
- class mapping - Python dict mapping attribute values to Element classes
- fallback - optional fallback lookup mechanism
A None key in the class mapping will be checked if the attribute is
missing.
"""
cdef object _class_mapping
cdef tuple _pytag
cdef const_xmlChar* _c_ns
cdef const_xmlChar* _c_name
def __cinit__(self):
self._lookup_function = _attribute_class_lookup
def __init__(self, attribute_name, class_mapping,
ElementClassLookup fallback=None):
self._pytag = _getNsTag(attribute_name)
ns, name = self._pytag
if ns is None:
self._c_ns = NULL
else:
self._c_ns = _xcstr(ns)
self._c_name = _xcstr(name)
self._class_mapping = dict(class_mapping)
FallbackElementClassLookup.__init__(self, fallback)
cdef object _attribute_class_lookup(state, _Document doc, xmlNode* c_node):
cdef AttributeBasedElementClassLookup lookup
cdef python.PyObject* dict_result
lookup = <AttributeBasedElementClassLookup>state
if c_node.type == tree.XML_ELEMENT_NODE:
value = _attributeValueFromNsName(
c_node, lookup._c_ns, lookup._c_name)
dict_result = python.PyDict_GetItem(lookup._class_mapping, value)
if dict_result is not NULL:
cls = <object>dict_result
_validateNodeClass(c_node, cls)
return cls
return _callLookupFallback(lookup, doc, c_node)
################################################################################
# per-parser lookup scheme
cdef class ParserBasedElementClassLookup(FallbackElementClassLookup):
u"""ParserBasedElementClassLookup(self, fallback=None)
Element class lookup based on the XML parser.
"""
def __cinit__(self):
self._lookup_function = _parser_class_lookup
cdef object _parser_class_lookup(state, _Document doc, xmlNode* c_node):
if doc._parser._class_lookup is not None:
return doc._parser._class_lookup._lookup_function(
doc._parser._class_lookup, doc, c_node)
return _callLookupFallback(<FallbackElementClassLookup>state, doc, c_node)
################################################################################
# custom class lookup based on node type, namespace, name
cdef class CustomElementClassLookup(FallbackElementClassLookup):
u"""CustomElementClassLookup(self, fallback=None)
Element class lookup based on a subclass method.
You can inherit from this class and override the method::
lookup(self, type, doc, namespace, name)
to lookup the element class for a node. Arguments of the method:
* type: one of 'element', 'comment', 'PI', 'entity'
* doc: document that the node is in
* namespace: namespace URI of the node (or None for comments/PIs/entities)
* name: name of the element/entity, None for comments, target for PIs
If you return None from this method, the fallback will be called.
"""
def __cinit__(self):
self._lookup_function = _custom_class_lookup
def lookup(self, type, doc, namespace, name):
u"lookup(self, type, doc, namespace, name)"
return None
cdef object _custom_class_lookup(state, _Document doc, xmlNode* c_node):
cdef CustomElementClassLookup lookup
lookup = <CustomElementClassLookup>state
if c_node.type == tree.XML_ELEMENT_NODE:
element_type = u"element"
elif c_node.type == tree.XML_COMMENT_NODE:
element_type = u"comment"
elif c_node.type == tree.XML_PI_NODE:
element_type = u"PI"
elif c_node.type == tree.XML_ENTITY_REF_NODE:
element_type = u"entity"
else:
element_type = u"element"
if c_node.name is NULL:
name = None
else:
name = funicode(c_node.name)
c_str = tree._getNs(c_node)
ns = funicode(c_str) if c_str is not NULL else None
cls = lookup.lookup(element_type, doc, ns, name)
if cls is not None:
_validateNodeClass(c_node, cls)
return cls
return _callLookupFallback(lookup, doc, c_node)
################################################################################
# read-only tree based class lookup
cdef class PythonElementClassLookup(FallbackElementClassLookup):
u"""PythonElementClassLookup(self, fallback=None)
Element class lookup based on a subclass method.
This class lookup scheme allows access to the entire XML tree in
read-only mode. To use it, re-implement the ``lookup(self, doc,
root)`` method in a subclass::
from lxml import etree, pyclasslookup
class MyElementClass(etree.ElementBase):
honkey = True
class MyLookup(pyclasslookup.PythonElementClassLookup):
def lookup(self, doc, root):
if root.tag == "sometag":
return MyElementClass
else:
for child in root:
if child.tag == "someothertag":
return MyElementClass
# delegate to default
return None
If you return None from this method, the fallback will be called.
The first argument is the opaque document instance that contains
the Element. The second argument is a lightweight Element proxy
implementation that is only valid during the lookup. Do not try
to keep a reference to it. Once the lookup is done, the proxy
will be invalid.
Also, you cannot wrap such a read-only Element in an ElementTree,
and you must take care not to keep a reference to them outside of
the `lookup()` method.
Note that the API of the Element objects is not complete. It is
purely read-only and does not support all features of the normal
`lxml.etree` API (such as XPath, extended slicing or some
iteration methods).
See https://lxml.de/element_classes.html
"""
def __cinit__(self):
self._lookup_function = _python_class_lookup
def lookup(self, doc, element):
u"""lookup(self, doc, element)
Override this method to implement your own lookup scheme.
"""
return None
cdef object _python_class_lookup(state, _Document doc, tree.xmlNode* c_node):
cdef PythonElementClassLookup lookup
cdef _ReadOnlyProxy proxy
lookup = <PythonElementClassLookup>state
proxy = _newReadOnlyProxy(None, c_node)
cls = lookup.lookup(doc, proxy)
_freeReadOnlyProxies(proxy)
if cls is not None:
_validateNodeClass(c_node, cls)
return cls
return _callLookupFallback(lookup, doc, c_node)
################################################################################
# Global setup
cdef _element_class_lookup_function LOOKUP_ELEMENT_CLASS
cdef object ELEMENT_CLASS_LOOKUP_STATE
cdef void _setElementClassLookupFunction(
_element_class_lookup_function function, object state):
global LOOKUP_ELEMENT_CLASS, ELEMENT_CLASS_LOOKUP_STATE
if function is NULL:
state = DEFAULT_ELEMENT_CLASS_LOOKUP
function = DEFAULT_ELEMENT_CLASS_LOOKUP._lookup_function
ELEMENT_CLASS_LOOKUP_STATE = state
LOOKUP_ELEMENT_CLASS = function
def set_element_class_lookup(ElementClassLookup lookup = None):
u"""set_element_class_lookup(lookup = None)
Set the global element class lookup method.
This defines the main entry point for looking up element implementations.
The standard implementation uses the :class:`ParserBasedElementClassLookup`
to delegate to different lookup schemes for each parser.
.. warning::
This should only be changed by applications, not by library packages.
In most cases, parser specific lookups should be preferred,
which can be configured via
:meth:`~lxml.etree.XMLParser.set_element_class_lookup`
(and the same for HTML parsers).
Globally replacing the element class lookup by something other than a
:class:`ParserBasedElementClassLookup` will prevent parser specific lookup
schemes from working. Several tools rely on parser specific lookups,
including :mod:`lxml.html` and :mod:`lxml.objectify`.
"""
if lookup is None or lookup._lookup_function is NULL:
_setElementClassLookupFunction(NULL, None)
else:
_setElementClassLookupFunction(lookup._lookup_function, lookup)
# default setup: parser delegation
cdef ParserBasedElementClassLookup DEFAULT_ELEMENT_CLASS_LOOKUP
DEFAULT_ELEMENT_CLASS_LOOKUP = ParserBasedElementClassLookup()
set_element_class_lookup(DEFAULT_ELEMENT_CLASS_LOOKUP)
Mini Shell