Graybyt3 Was Here

Linux server6.maghost.ro 4.18.0-477.21.1.lve.1.el8.x86_64 #1 SMP Tue Sep 5 23:08:35 UTC 2023 x86_64
Apache
91.213.11.6

File Name : sax.py

# cython: language_level=2

"""
SAX-based adapter to copy trees from/to the Python standard library.

Use the `ElementTreeContentHandler` class to build an ElementTree from
SAX events.

Use the `ElementTreeProducer` class or the `saxify()` function to fire
the SAX events of an ElementTree against a SAX ContentHandler.

See https://lxml.de/sax.html
"""

from __future__ import absolute_import

from xml.sax.handler import ContentHandler
from lxml import etree
from lxml.etree import ElementTree, SubElement
from lxml.etree import Comment, ProcessingInstruction

class SaxError(etree.LxmlError):
    """General SAX error.
    """

def _getNsTag(tag):
    if tag[0] == '{':
        return tuple(tag[1:].split('}', 1))
    else:
        return None, tag

class ElementTreeContentHandler(ContentHandler):
    """Build an lxml ElementTree from SAX events.
    """
    def __init__(self, makeelement=None):
        ContentHandler.__init__(self)
        self._root = None
        self._root_siblings = []
        self._element_stack = []
        self._default_ns = None
        self._ns_mapping = { None : [None] }
        self._new_mappings = {}
        if makeelement is None:
            makeelement = etree.Element
        self._makeelement = makeelement

def _get_etree(self):
        "Contains the generated ElementTree after parsing is finished."
        return ElementTree(self._root)

etree = property(_get_etree, doc=_get_etree.__doc__)

def setDocumentLocator(self, locator):
        pass

def startDocument(self):
        pass

def endDocument(self):
        pass

def startPrefixMapping(self, prefix, uri):
        self._new_mappings[prefix] = uri
        try:
            self._ns_mapping[prefix].append(uri)
        except KeyError:
            self._ns_mapping[prefix] = [uri]
        if prefix is None:
            self._default_ns = uri

def endPrefixMapping(self, prefix):
        ns_uri_list = self._ns_mapping[prefix]
        ns_uri_list.pop()
        if prefix is None:
            self._default_ns = ns_uri_list[-1]

def _buildTag(self, ns_name_tuple):
        ns_uri, local_name = ns_name_tuple
        if ns_uri:
            el_tag = "{%s}%s" % ns_name_tuple
        elif self._default_ns:
            el_tag = "{%s}%s" % (self._default_ns, local_name)
        else:
            el_tag = local_name
        return el_tag

def startElementNS(self, ns_name, qname, attributes=None):
        el_name = self._buildTag(ns_name)
        if attributes:
            attrs = {}
            try:
                iter_attributes = attributes.iteritems()
            except AttributeError:
                iter_attributes = attributes.items()

for name_tuple, value in iter_attributes:
                if name_tuple[0]:
                    attr_name = "{%s}%s" % name_tuple
                else:
                    attr_name = name_tuple[1]
                attrs[attr_name] = value
        else:
            attrs = None

element_stack = self._element_stack
        if self._root is None:
            element = self._root = \
                      self._makeelement(el_name, attrs, self._new_mappings)
            if self._root_siblings and hasattr(element, 'addprevious'):
                for sibling in self._root_siblings:
                    element.addprevious(sibling)
            del self._root_siblings[:]
        else:
            element = SubElement(element_stack[-1], el_name,
                                 attrs, self._new_mappings)
        element_stack.append(element)

self._new_mappings.clear()

def processingInstruction(self, target, data):
        pi = ProcessingInstruction(target, data)
        if self._root is None:
            self._root_siblings.append(pi)
        else:
            self._element_stack[-1].append(pi)

def endElementNS(self, ns_name, qname):
        element = self._element_stack.pop()
        el_tag = self._buildTag(ns_name)
        if el_tag != element.tag:
            raise SaxError("Unexpected element closed: " + el_tag)

def startElement(self, name, attributes=None):
        if attributes:
            attributes = dict(
                    [((None, k), v) for k, v in attributes.items()]
                )
        self.startElementNS((None, name), name, attributes)

def endElement(self, name):
        self.endElementNS((None, name), name)

def characters(self, data):
        last_element = self._element_stack[-1]
        try:
            # if there already is a child element, we must append to its tail
            last_element = last_element[-1]
            last_element.tail = (last_element.tail or '') + data
        except IndexError:
            # otherwise: append to the text
            last_element.text = (last_element.text or '') + data

ignorableWhitespace = characters

class ElementTreeProducer(object):
    """Produces SAX events for an element and children.
    """
    def __init__(self, element_or_tree, content_handler):
        try:
            element = element_or_tree.getroot()
        except AttributeError:
            element = element_or_tree
        self._element = element
        self._content_handler = content_handler
        from xml.sax.xmlreader import AttributesNSImpl as attr_class
        self._attr_class = attr_class
        self._empty_attributes = attr_class({}, {})

def saxify(self):
        self._content_handler.startDocument()

element = self._element
        if hasattr(element, 'getprevious'):
            siblings = []
            sibling = element.getprevious()
            while getattr(sibling, 'tag', None) is ProcessingInstruction:
                siblings.append(sibling)
                sibling = sibling.getprevious()
            for sibling in siblings[::-1]:
                self._recursive_saxify(sibling, {})

self._recursive_saxify(element, {})

if hasattr(element, 'getnext'):
            sibling = element.getnext()
            while getattr(sibling, 'tag', None) is ProcessingInstruction:
                self._recursive_saxify(sibling, {})
                sibling = sibling.getnext()

self._content_handler.endDocument()

def _recursive_saxify(self, element, parent_nsmap):
        content_handler = self._content_handler
        tag = element.tag
        if tag is Comment or tag is ProcessingInstruction:
            if tag is ProcessingInstruction:
                content_handler.processingInstruction(
                    element.target, element.text)
            tail = element.tail
            if tail:
                content_handler.characters(tail)
            return

element_nsmap = element.nsmap
        new_prefixes = []
        if element_nsmap != parent_nsmap:
            # There have been updates to the namespace
            for prefix, ns_uri in element_nsmap.items():
                if parent_nsmap.get(prefix) != ns_uri:
                    new_prefixes.append( (prefix, ns_uri) )

attribs = element.items()
        if attribs:
            attr_values = {}
            attr_qnames = {}
            for attr_ns_name, value in attribs:
                attr_ns_tuple = _getNsTag(attr_ns_name)
                attr_values[attr_ns_tuple] = value
                attr_qnames[attr_ns_tuple] = self._build_qname(
                    attr_ns_tuple[0], attr_ns_tuple[1], element_nsmap,
                    preferred_prefix=None, is_attribute=True)
            sax_attributes = self._attr_class(attr_values, attr_qnames)
        else:
            sax_attributes = self._empty_attributes

ns_uri, local_name = _getNsTag(tag)
        qname = self._build_qname(
            ns_uri, local_name, element_nsmap, element.prefix, is_attribute=False)

for prefix, uri in new_prefixes:
            content_handler.startPrefixMapping(prefix, uri)
        content_handler.startElementNS(
            (ns_uri, local_name), qname, sax_attributes)
        text = element.text
        if text:
            content_handler.characters(text)
        for child in element:
            self._recursive_saxify(child, element_nsmap)
        content_handler.endElementNS((ns_uri, local_name), qname)
        for prefix, uri in new_prefixes:
            content_handler.endPrefixMapping(prefix)
        tail = element.tail
        if tail:
            content_handler.characters(tail)

def _build_qname(self, ns_uri, local_name, nsmap, preferred_prefix, is_attribute):
        if ns_uri is None:
            return local_name

if not is_attribute and nsmap.get(preferred_prefix) == ns_uri:
            prefix = preferred_prefix
        else:
            # Pick the first matching prefix, in alphabetical order.
            candidates = [
                pfx for (pfx, uri) in nsmap.items()
                if pfx is not None and uri == ns_uri
            ]
            prefix = (
                candidates[0] if len(candidates) == 1
                else min(candidates) if candidates
                else None
            )

if prefix is None:
            # Default namespace
            return local_name
        return prefix + ':' + local_name

def saxify(element_or_tree, content_handler):
    """One-shot helper to generate SAX events from an XML tree and fire
    them against a SAX ContentHandler.
    """
    return ElementTreeProducer(element_or_tree, content_handler).saxify()

System Information
*ReClick For Close
File : BlackDragon /about/function.php

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/root	0755	2023-09-24 06:25:58
..	dir	-	root/root	0755	2024-03-18 03:02:40
__pycache__	dir	-	root/root	0755	2023-09-24 06:27:58
html	dir	-	root/root	0755	2023-09-24 06:25:58
includes	dir	-	root/root	0755	2023-09-24 06:25:58
isoschematron	dir	-	root/root	0755	2023-09-24 06:25:58
ElementInclude.py	text/x-python	8.36 KB	root/root	0644	2023-09-05 09:10:13
__init__.py	text/x-python	575 B	root/root	0644	2023-09-05 09:10:13
_elementpath.cpython-311-x86_64-linux-gnu.so	application/x-pie-executable	225.27 KB	root/root	0755	2023-09-05 09:10:35
_elementpath.py	text/x-python	10.49 KB	root/root	0644	2023-09-05 09:10:13
apihelpers.pxi	text/x-python	62.94 KB	root/root	0644	2023-09-05 09:10:13
builder.cpython-311-x86_64-linux-gnu.so	application/x-pie-executable	120.73 KB	root/root	0755	2023-09-05 09:10:35
builder.py	text/x-python	7.96 KB	root/root	0644	2023-09-05 09:10:13
classlookup.pxi	text/x-python	21.94 KB	root/root	0644	2023-09-05 09:10:13
cleanup.pxi	text/x-python	8.26 KB	root/root	0644	2023-09-05 09:10:13
cssselect.py	text/plain	3.29 KB	root/root	0644	2023-09-05 09:10:13
debug.pxi	text/x-python	3.21 KB	root/root	0644	2023-09-05 09:10:13
docloader.pxi	text/x-python	5.65 KB	root/root	0644	2023-09-05 09:10:13
doctestcompare.py	text/plain	17.91 KB	root/root	0644	2023-09-05 09:10:13
dtd.pxi	text/x-python	14.86 KB	root/root	0644	2023-09-05 09:10:13
etree.cpython-311-x86_64-linux-gnu.so	application/x-pie-executable	5.53 MB	root/root	0755	2023-09-05 09:10:35
etree.h	text/x-c	8.37 KB	root/root	0644	2023-09-05 09:10:13
etree.pyx	text/x-python	129.31 KB	root/root	0644	2023-09-05 09:10:13
etree_api.h	text/x-c	17.06 KB	root/root	0644	2023-09-05 09:10:13
extensions.pxi	text/x-python	32.46 KB	root/root	0644	2023-09-05 09:10:13
iterparse.pxi	text/x-python	16.22 KB	root/root	0644	2023-09-05 09:10:13
lxml.etree.h	text/x-c	8.37 KB	root/root	0644	2023-09-05 09:10:13
lxml.etree_api.h	text/x-c	17.06 KB	root/root	0644	2023-09-05 09:10:13
nsclasses.pxi	text/x-python	8.93 KB	root/root	0644	2023-09-05 09:10:13
objectify.cpython-311-x86_64-linux-gnu.so	application/x-pie-executable	3.2 MB	root/root	0755	2023-09-05 09:10:35
objectify.pyx	text/x-python	75.29 KB	root/root	0644	2023-09-05 09:10:13
objectpath.pxi	text/x-python	11.21 KB	root/root	0644	2023-09-05 09:10:13
parser.pxi	text/x-python	76.41 KB	root/root	0644	2023-09-05 09:10:13
parsertarget.pxi	text/x-python	6.7 KB	root/root	0644	2023-09-05 09:10:13
proxy.pxi	text/plain	23.01 KB	root/root	0644	2023-09-05 09:10:13
public-api.pxi	text/plain	6.5 KB	root/root	0644	2023-09-05 09:10:13
pyclasslookup.py	text/x-python	92 B	root/root	0644	2023-09-05 09:10:13
readonlytree.pxi	text/x-python	18.6 KB	root/root	0644	2023-09-05 09:10:13
relaxng.pxi	text/x-python	5.94 KB	root/root	0644	2023-09-05 09:10:13
sax.cpython-311-x86_64-linux-gnu.so	application/x-pie-executable	196.95 KB	root/root	0755	2023-09-05 09:10:35
sax.py	text/x-python	9.18 KB	root/root	0644	2023-09-05 09:10:13
saxparser.pxi	text/x-python	31.78 KB	root/root	0644	2023-09-05 09:10:13
schematron.pxi	text/x-python	5.65 KB	root/root	0644	2023-09-05 09:10:13
serializer.pxi	text/x-python	66.41 KB	root/root	0644	2023-09-05 09:10:13
usedoctest.py	text/plain	230 B	root/root	0644	2023-09-05 09:10:13
xinclude.pxi	text/x-python	2.4 KB	root/root	0644	2023-09-05 09:10:13
xmlerror.pxi	text/x-python	48.37 KB	root/root	0644	2023-09-05 09:10:13
xmlid.pxi	text/x-python	5.92 KB	root/root	0644	2023-09-05 09:10:13
xmlschema.pxi	text/x-python	7.89 KB	root/root	0644	2023-09-05 09:10:13
xpath.pxi	text/x-python	19.11 KB	root/root	0644	2023-09-05 09:10:13
xslt.pxi	text/x-python	35.83 KB	root/root	0644	2023-09-05 09:10:13
xsltext.pxi	text/x-python	10.83 KB	root/root	0644	2023-09-05 09:10:13