File Manager

X7ROOT File Manager

Current Path: /opt/cloudlinux/venv/lib/python3.11/site-packages/lxml

opt / cloudlinux / venv / lib / python3.11 / site-packages / lxml /

ðŸ“ ..
ðŸ“„ ElementInclude.py(8.36 KB)
ðŸ“„ __init__.py(575 B)
ðŸ“ __pycache__
ðŸ“„ _elementpath.cpython-311-x86_64-linux-gnu.so(225.27 KB)
ðŸ“„ _elementpath.py(10.49 KB)
ðŸ“„ apihelpers.pxi(62.94 KB)
ðŸ“„ builder.cpython-311-x86_64-linux-gnu.so(120.73 KB)
ðŸ“„ builder.py(7.96 KB)
ðŸ“„ classlookup.pxi(21.94 KB)
ðŸ“„ cleanup.pxi(8.26 KB)
ðŸ“„ cssselect.py(3.29 KB)
ðŸ“„ debug.pxi(3.21 KB)
ðŸ“„ docloader.pxi(5.65 KB)
ðŸ“„ doctestcompare.py(17.91 KB)
ðŸ“„ dtd.pxi(14.86 KB)
ðŸ“„ etree.cpython-311-x86_64-linux-gnu.so(5.53 MB)
ðŸ“„ etree.h(8.37 KB)
ðŸ“„ etree.pyx(129.31 KB)
ðŸ“„ etree_api.h(17.06 KB)
ðŸ“„ extensions.pxi(32.46 KB)
ðŸ“ html
ðŸ“ includes
ðŸ“ isoschematron
ðŸ“„ iterparse.pxi(16.22 KB)
ðŸ“„ lxml.etree.h(8.37 KB)
ðŸ“„ lxml.etree_api.h(17.06 KB)
ðŸ“„ nsclasses.pxi(8.93 KB)
ðŸ“„ objectify.cpython-311-x86_64-linux-gnu.so(3.2 MB)
ðŸ“„ objectify.pyx(75.29 KB)
ðŸ“„ objectpath.pxi(11.21 KB)
ðŸ“„ parser.pxi(76.41 KB)
ðŸ“„ parsertarget.pxi(6.7 KB)
ðŸ“„ proxy.pxi(23.01 KB)
ðŸ“„ public-api.pxi(6.5 KB)
ðŸ“„ pyclasslookup.py(92 B)
ðŸ“„ readonlytree.pxi(18.6 KB)
ðŸ“„ relaxng.pxi(5.94 KB)
ðŸ“„ sax.cpython-311-x86_64-linux-gnu.so(196.95 KB)
ðŸ“„ sax.py(9.18 KB)
ðŸ“„ saxparser.pxi(31.78 KB)
ðŸ“„ schematron.pxi(5.65 KB)
ðŸ“„ serializer.pxi(66.41 KB)
ðŸ“„ usedoctest.py(230 B)
ðŸ“„ xinclude.pxi(2.4 KB)
ðŸ“„ xmlerror.pxi(48.37 KB)
ðŸ“„ xmlid.pxi(5.92 KB)
ðŸ“„ xmlschema.pxi(7.89 KB)
ðŸ“„ xpath.pxi(19.11 KB)
ðŸ“„ xslt.pxi(35.83 KB)
ðŸ“„ xsltext.pxi(10.83 KB)

Editing: parsertarget.pxi

# Parser target context (ET target interface)

cdef object inspect_getargspec
try:
    from inspect import getfullargspec as inspect_getargspec
except ImportError:
    from inspect import getargspec as inspect_getargspec

class _TargetParserResult(Exception):
    # Admittedly, this is somewhat ugly, but it's the easiest way
    # to push the Python level parser result through the parser
    # machinery towards the API level functions
    def __init__(self, result):
        self.result = result

@cython.final
@cython.internal
cdef class _PythonSaxParserTarget(_SaxParserTarget):
    cdef object _target_start
    cdef object _target_end
    cdef object _target_data
    cdef object _target_start_ns
    cdef object _target_end_ns
    cdef object _target_doctype
    cdef object _target_pi
    cdef object _target_comment
    cdef bint _start_takes_nsmap

def __cinit__(self, target):
        cdef int event_filter
        event_filter = 0
        self._start_takes_nsmap = 0
        try:
            self._target_start = target.start
            if self._target_start is not None:
                event_filter |= SAX_EVENT_START
        except AttributeError:
            pass
        else:
            try:
                arguments = inspect_getargspec(self._target_start)
                if len(arguments[0]) > 3 or arguments[1] is not None:
                    self._start_takes_nsmap = 1
            except TypeError:
                pass
        try:
            self._target_end = target.end
            if self._target_end is not None:
                event_filter |= SAX_EVENT_END
        except AttributeError:
            pass
        try:
            self._target_start_ns = target.start_ns
            if self._target_start_ns is not None:
                event_filter |= SAX_EVENT_START_NS
        except AttributeError:
            pass
        try:
            self._target_end_ns = target.end_ns
            if self._target_end_ns is not None:
                event_filter |= SAX_EVENT_END_NS
        except AttributeError:
            pass
        try:
            self._target_data = target.data
            if self._target_data is not None:
                event_filter |= SAX_EVENT_DATA
        except AttributeError:
            pass
        try:
            self._target_doctype = target.doctype
            if self._target_doctype is not None:
                event_filter |= SAX_EVENT_DOCTYPE
        except AttributeError:
            pass
        try:
            self._target_pi = target.pi
            if self._target_pi is not None:
                event_filter |= SAX_EVENT_PI
        except AttributeError:
            pass
        try:
            self._target_comment = target.comment
            if self._target_comment is not None:
                event_filter |= SAX_EVENT_COMMENT
        except AttributeError:
            pass
        self._sax_event_filter = event_filter

cdef _handleSaxStart(self, tag, attrib, nsmap):
        if self._start_takes_nsmap:
            return self._target_start(tag, attrib, nsmap)
        else:
            return self._target_start(tag, attrib)

cdef _handleSaxEnd(self, tag):
        return self._target_end(tag)

cdef _handleSaxStartNs(self, prefix, uri):
        return self._target_start_ns(prefix, uri)

cdef _handleSaxEndNs(self, prefix):
        return self._target_end_ns(prefix)

cdef int _handleSaxData(self, data) except -1:
        self._target_data(data)

cdef int _handleSaxDoctype(self, root_tag, public_id, system_id) except -1:
        self._target_doctype(root_tag, public_id, system_id)

cdef _handleSaxPi(self, target, data):
        return self._target_pi(target, data)

cdef _handleSaxComment(self, comment):
        return self._target_comment(comment)

@cython.final
@cython.internal
@cython.no_gc_clear  # Required because parent class uses it - Cython bug.
cdef class _TargetParserContext(_SaxParserContext):
    u"""This class maps SAX2 events to the ET parser target interface.
    """
    cdef object _python_target
    cdef int _setTarget(self, target) except -1:
        self._python_target = target
        if not isinstance(target, _SaxParserTarget) or \
                hasattr(target, u'__dict__'):
            target = _PythonSaxParserTarget(target)
        self._setSaxParserTarget(target)
        return 0

cdef _ParserContext _copy(self):
        cdef _TargetParserContext context
        context = _ParserContext._copy(self)
        context._setTarget(self._python_target)
        return context

cdef void _cleanupTargetParserContext(self, xmlDoc* result):
        if self._c_ctxt.myDoc is not NULL:
            if self._c_ctxt.myDoc is not result and \
                    self._c_ctxt.myDoc._private is NULL:
                # no _Document proxy => orphen
                tree.xmlFreeDoc(self._c_ctxt.myDoc)
            self._c_ctxt.myDoc = NULL

cdef object _handleParseResult(self, _BaseParser parser, xmlDoc* result,
                                   filename):
        cdef bint recover
        recover = parser._parse_options & xmlparser.XML_PARSE_RECOVER
        try:
            if self._has_raised():
                self._cleanupTargetParserContext(result)
                self._raise_if_stored()
            if not self._c_ctxt.wellFormed and not recover:
                _raiseParseError(self._c_ctxt, filename, self._error_log)
        except:
            if python.IS_PYTHON2:
                exc = sys.exc_info()
                # Python 2 can't chain exceptions
                try: self._python_target.close()
                except: pass
                raise exc[0], exc[1], exc[2]
            else:
                self._python_target.close()
                raise
        return self._python_target.close()

cdef xmlDoc* _handleParseResultDoc(self, _BaseParser parser,
                                       xmlDoc* result, filename) except NULL:
        cdef bint recover
        recover = parser._parse_options & xmlparser.XML_PARSE_RECOVER
        if result is not NULL and result._private is NULL:
            # no _Document proxy => orphen
            tree.xmlFreeDoc(result)
        try:
            self._cleanupTargetParserContext(result)
            self._raise_if_stored()
            if not self._c_ctxt.wellFormed and not recover:
                _raiseParseError(self._c_ctxt, filename, self._error_log)
        except:
            if python.IS_PYTHON2:
                exc = sys.exc_info()
                # Python 2 can't chain exceptions
                try: self._python_target.close()
                except: pass
                raise exc[0], exc[1], exc[2]
            else:
                self._python_target.close()
                raise
        parse_result = self._python_target.close()
        raise _TargetParserResult(parse_result)

X7ROOT File Manager

Editing: parsertarget.pxi

Upload File

Create Folder