#$@%#$%!

Ngiler SH3LL 360
: / opt / hc_python / lib64 / python3.12 / site-packages / lxml /

Information Server
MySQL : OFF Perl : OFF CURL : ON WGET : OFF PKEXEC : OFF

Directive	Local Value
IP Address	162.0.209.101
System	Linux premium169.web-hosting.com 4.18.0-553.50.1.lve.el8.x86_64 #1 SMP Thu Apr 17 19:10:24 UTC 2025 x86_64
User	luxeelil
PHP Version	8.0.30
Software	LiteSpeed
Doc root	Writable

Edit File : classlookup.pxi \| Size : 21.91 KB
# Configurable Element class lookup ################################################################################ # Custom Element classes cdef public class ElementBase(_Element) [ type LxmlElementBaseType, object LxmlElementBase ]: """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): """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): """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): """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): """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 ]: """ElementClassLookup(self) Superclass of Element class lookups. """ cdef _element_class_lookup_function _lookup_function cdef public class FallbackElementClassLookup(ElementClassLookup) \ [ type LxmlFallbackElementClassLookupType, object LxmlFallbackElementClassLookup ]: """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): """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): """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): """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, "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, "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, "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, "PI class must be subclass of PIBase" cdef object _lookupDefaultElementClass(state, _Document _doc, xmlNode* c_node): "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): """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): """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): """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): "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 = "element" elif c_node.type == tree.XML_COMMENT_NODE: element_type = "comment" elif c_node.type == tree.XML_PI_NODE: element_type = "PI" elif c_node.type == tree.XML_ENTITY_REF_NODE: element_type = "entity" else: element_type = "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): """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): """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): """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) Back

Edit File : classlookup.pxi | Size : 21.91 KB

# Configurable Element class lookup

################################################################################
# Custom Element classes

cdef public class ElementBase(_Element) [ type LxmlElementBaseType,
                                          object LxmlElementBase ]:
    """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):
        """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):
    """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):
    """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):
    """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 ]:
    """ElementClassLookup(self)
    Superclass of Element class lookups.
    """
    cdef _element_class_lookup_function _lookup_function

cdef public class FallbackElementClassLookup(ElementClassLookup) \
         [ type LxmlFallbackElementClassLookupType,
           object LxmlFallbackElementClassLookup ]:
    """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):
        """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):
        """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):
    """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, "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, "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, "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, "PI class must be subclass of PIBase"

cdef object _lookupDefaultElementClass(state, _Document _doc, xmlNode* c_node):
    "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):
    """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):
    """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):
    """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):
        "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 = "element"
    elif c_node.type == tree.XML_COMMENT_NODE:
        element_type = "comment"
    elif c_node.type == tree.XML_PI_NODE:
        element_type = "PI"
    elif c_node.type == tree.XML_ENTITY_REF_NODE:
        element_type = "entity"
    else:
        element_type = "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):
    """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):
        """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):
    """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)

Back