FM / lxml

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

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

Name	Size	Mode	Actions
html/	-	0755	rm
includes/	-	0755	rm
isoschematron/	-	0755	rm
__pycache__/	-	0755	rm
apihelpers.pxi	64452	0644	edit dl rm
builder.cpython-311-x86_64-linux-gnu.so	123624	0755	edit dl rm
builder.py	8147	0644	edit dl rm
classlookup.pxi	22462	0644	edit dl rm
cleanup.pxi	8458	0644	edit dl rm
cssselect.py	3366	0644	edit dl rm
debug.pxi	3283	0644	edit dl rm
docloader.pxi	5783	0644	edit dl rm
doctestcompare.py	18339	0644	edit dl rm
dtd.pxi	15219	0644	edit dl rm
ElementInclude.py	8560	0644	edit dl rm
etree.cpython-311-x86_64-linux-gnu.so	5797240	0755	edit dl rm
etree.h	8575	0644	edit dl rm
etree.pyx	132415	0644	edit dl rm
etree_api.h	17467	0644	edit dl rm
extensions.pxi	33241	0644	edit dl rm
iterparse.pxi	16607	0644	edit dl rm
lxml.etree.h	8575	0644	edit dl rm
lxml.etree_api.h	17472	0644	edit dl rm
nsclasses.pxi	9145	0644	edit dl rm
objectify.cpython-311-x86_64-linux-gnu.so	3351520	0755	edit dl rm
objectify.pyx	77100	0644	edit dl rm
objectpath.pxi	11479	0644	edit dl rm
parser.pxi	78247	0644	edit dl rm
parsertarget.pxi	6859	0644	edit dl rm
proxy.pxi	23562	0644	edit dl rm
public-api.pxi	6660	0644	edit dl rm
pyclasslookup.py	92	0644	edit dl rm
readonlytree.pxi	19048	0644	edit dl rm
relaxng.pxi	6085	0644	edit dl rm
sax.cpython-311-x86_64-linux-gnu.so	201680	0755	edit dl rm
sax.py	9396	0644	edit dl rm
saxparser.pxi	32542	0644	edit dl rm
schematron.pxi	5782	0644	edit dl rm
serializer.pxi	67999	0644	edit dl rm
usedoctest.py	230	0644	edit dl rm
xinclude.pxi	2460	0644	edit dl rm
xmlerror.pxi	49531	0644	edit dl rm
xmlid.pxi	6064	0644	edit dl rm
xmlschema.pxi	8079	0644	edit dl rm
xpath.pxi	19571	0644	edit dl rm
xslt.pxi	36694	0644	edit dl rm
xsltext.pxi	11085	0644	edit dl rm
_elementpath.cpython-311-x86_64-linux-gnu.so	230680	0755	edit dl rm
_elementpath.py	10742	0644	edit dl rm
__init__.py	575	0644	edit dl rm

Edit: /opt/cloudlinux/venv/lib/python3.11/site-packages/lxml/builder.py (8147B)

# cython: language_level=2

#
# Element generator factory by Fredrik Lundh.
#
# Source:
#    http://online.effbot.org/2006_11_01_archive.htm#et-builder
#    http://effbot.python-hosting.com/file/stuff/sandbox/elementlib/builder.py
#
# --------------------------------------------------------------------
# The ElementTree toolkit is
#
# Copyright (c) 1999-2004 by Fredrik Lundh
#
# By obtaining, using, and/or copying this software and/or its
# associated documentation, you agree that you have read, understood,
# and will comply with the following terms and conditions:
#
# Permission to use, copy, modify, and distribute this software and
# its associated documentation for any purpose and without fee is
# hereby granted, provided that the above copyright notice appears in
# all copies, and that both that copyright notice and this permission
# notice appear in supporting documentation, and that the name of
# Secret Labs AB or the author not be used in advertising or publicity
# pertaining to distribution of the software without specific, written
# prior permission.
#
# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
# ABILITY AND FITNESS.  IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
# OF THIS SOFTWARE.
# --------------------------------------------------------------------

"""
The ``E`` Element factory for generating XML documents.
"""

from __future__ import absolute_import

import lxml.etree as ET
_QName = ET.QName

from functools import partial

try:
    basestring
except NameError:
    basestring = str

try:
    unicode
except NameError:
    unicode = str

class ElementMaker(object):
    """Element generator factory.

Unlike the ordinary Element factory, the E factory allows you to pass in
    more than just a tag and some optional attributes; you can also pass in
    text and other elements.  The text is added as either text or tail
    attributes, and elements are inserted at the right spot.  Some small
    examples::

>>> from lxml import etree as ET
        >>> from lxml.builder import E

>>> ET.tostring(E("tag"))
 '<tag/>'
 >>> ET.tostring(E("tag", "text"))
 '<tag>text</tag>'
 >>> ET.tostring(E("tag", "text", key="value"))
 '<tag key="value">text</tag>'
 >>> ET.tostring(E("tag", E("subtag", "text"), "tail"))
 '<tag><subtag>text</subtag>tail</tag>'

For simple tags, the factory also allows you to write ``E.tag(...)`` instead
    of ``E('tag', ...)``::

>>> ET.tostring(E.tag())
 '<tag/>'
 >>> ET.tostring(E.tag("text"))
 '<tag>text</tag>'
 >>> ET.tostring(E.tag(E.subtag("text"), "tail"))
 '<tag><subtag>text</subtag>tail</tag>'

Here's a somewhat larger example; this shows how to generate HTML
    documents, using a mix of prepared factory functions for inline elements,
    nested ``E.tag`` calls, and embedded XHTML fragments::

# some common inline elements
        A = E.a
        I = E.i
        B = E.b

def CLASS(v):
            # helper function, 'class' is a reserved word
            return {'class': v}

page = (
 E.html(
 E.head(
 E.title("This is a sample document")
 ),
 E.body(
 E.h1("Hello!", CLASS("title")),
 E.p("This is a paragraph with ", B("bold"), " text in it!"),
 E.p("This is another paragraph, with a ",
 A("link", href="http://www.python.org"), "."),
 E.p("Here are some reserved characters: <spam&egg>."),
 ET.XML("And finally, here is an embedded XHTML fragment."),
 )
 )
 )

print ET.tostring(page)

Here's a prettyprinted version of the output from the above script::

<html>
 <head>
 <title>This is a sample document</title>
 </head>
 <body>
 <h1 class="title">Hello!</h1>
 This is a paragraph with bold text in it!
 This is another paragraph, with <a href="http://www.python.org">link</a>.
 Here are some reserved characters: &lt;spam&amp;egg&gt;.
 And finally, here is an embedded XHTML fragment.
 </body>
 </html>

For namespace support, you can pass a namespace map (``nsmap``)
    and/or a specific target ``namespace`` to the ElementMaker class::

>>> E = ElementMaker(namespace="http://my.ns/")
 >>> print(ET.tostring( E.test ))
 <test xmlns="http://my.ns/"/>

>>> E = ElementMaker(namespace="http://my.ns/", nsmap={'p':'http://my.ns/'})
 >>> print(ET.tostring( E.test ))
 <p:test xmlns:p="http://my.ns/"/>
 """

def __init__(self, typemap=None,
                 namespace=None, nsmap=None, makeelement=None):
        self._namespace = '{' + namespace + '}' if namespace is not None else None
        self._nsmap = dict(nsmap) if nsmap else None

assert makeelement is None or callable(makeelement)
        self._makeelement = makeelement if makeelement is not None else ET.Element

# initialize the default type map functions for this element factory
        typemap = dict(typemap) if typemap else {}

def add_text(elem, item):
            try:
                last_child = elem[-1]
            except IndexError:
                elem.text = (elem.text or "") + item
            else:
                last_child.tail = (last_child.tail or "") + item

def add_cdata(elem, cdata):
            if elem.text:
                raise ValueError("Can't add a CDATA section. Element already has some text: %r" % elem.text)
            elem.text = cdata

if str not in typemap:
            typemap[str] = add_text
        if unicode not in typemap:
            typemap[unicode] = add_text
        if ET.CDATA not in typemap:
            typemap[ET.CDATA] = add_cdata

def add_dict(elem, item):
            attrib = elem.attrib
            for k, v in item.items():
                if isinstance(v, basestring):
                    attrib[k] = v
                else:
                    attrib[k] = typemap[type(v)](None, v)

if dict not in typemap:
            typemap[dict] = add_dict

self._typemap = typemap

def __call__(self, tag, *children, **attrib):
        typemap = self._typemap

# We'll usually get a 'str', and the compiled type check is very fast.
        if not isinstance(tag, str) and isinstance(tag, _QName):
            # A QName is explicitly qualified, do not look at self._namespace.
            tag = tag.text
        elif self._namespace is not None and tag[0] != '{':
            tag = self._namespace + tag
        elem = self._makeelement(tag, nsmap=self._nsmap)
        if attrib:
            typemap[dict](elem, attrib)

for item in children:
            if callable(item):
                item = item()
            t = typemap.get(type(item))
            if t is None:
                if ET.iselement(item):
                    elem.append(item)
                    continue
                for basetype in type(item).__mro__:
                    # See if the typemap knows of any of this type's bases.
                    t = typemap.get(basetype)
                    if t is not None:
                        break
                else:
                    raise TypeError("bad argument type: %s(%r)" %
                                    (type(item).__name__, item))
            v = t(elem, item)
            if v:
                typemap.get(type(v))(elem, v)

return elem

def __getattr__(self, tag):
        return partial(self, tag)

# create factory object
E = ElementMaker()

cmd: