Store : Webshell.Store

Linux lhcp3406.webapps.net 3.10.0-962.3.2.lve1.5.82.el7.x86_64 #1 SMP Tue Oct 31 10:15:24 UTC 2023 x86_64

Apache

81.88.53.156 | Your IP: 216.73.216.101

Cant read [ /etc/named.conf ]

[ drwxr-xr-x ]

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

Home Upload Info Server

Server Info

Operating System	:	Linux lhcp3406.webapps.net 3.10.0-962.3.2.lve1.5.82.el7.x86_64 #1 SMP Tue Oct 31 10:15:24 UTC 2023 x86_64
User / Group	:	1190[c43ut3hs] / 1192[c43ut3hs]
PHP Version	:	5.6.40
IP Server	:	81.88.53.156
Your IP	:	216.73.216.101
Storage	:	Total = 1.05 TB, Free = 302.15 GB [28%]
Domains	:	Cant read [ /etc/named.conf ]
Software	:	Apache
Disable Functions	:	All function is accessible
Useful Functions	:	gcc, lcc, cc, ld, make, php, perl, python, ruby, tar, gzip, bzip, bzialfa2, nc, locate, suidperl, git, docker, ssh
Downloader	:	wget, fetch, lynx, links, curl, get, lwp-mirror
CURL : ON \| SSH2 : OFF \| Magic Quotes : ON \| MySQL : ON \| MSSQL : OFF \| PostgreSQL : OFF \| Oracle : OFF
Safe Mode : OFF \| Open Basedir : NONE \| Safe Mode Exec Dir : NONE \| Safe Mode Include Dir : NONE

html5parser.py

"""
An interface to html5lib that mimics the lxml.html interface.
"""
import sys
import string

from html5lib import HTMLParser as _HTMLParser
from html5lib.treebuilders.etree_lxml import TreeBuilder
from lxml import etree
from lxml.html import Element, XHTML_NAMESPACE, _contains_block_level_tag

# python3 compatibility
try:
    _strings = basestring
except NameError:
    _strings = (bytes, str)
try:
    from urllib2 import urlopen
except ImportError:
    from urllib.request import urlopen
try:
    from urlparse import urlparse
except ImportError:
    from urllib.parse import urlparse

class HTMLParser(_HTMLParser):
    """An html5lib HTML parser with lxml as tree."""

def __init__(self, strict=False, **kwargs):
        _HTMLParser.__init__(self, strict=strict, tree=TreeBuilder, **kwargs)

try:
    from html5lib import XHTMLParser as _XHTMLParser
except ImportError:
    pass
else:
    class XHTMLParser(_XHTMLParser):
        """An html5lib XHTML Parser with lxml as tree."""

def __init__(self, strict=False, **kwargs):
            _XHTMLParser.__init__(self, strict=strict, tree=TreeBuilder, **kwargs)

xhtml_parser = XHTMLParser()

def _find_tag(tree, tag):
    elem = tree.find(tag)
    if elem is not None:
        return elem
    return tree.find('{%s}%s' % (XHTML_NAMESPACE, tag))

def document_fromstring(html, guess_charset=None, parser=None):
    """
    Parse a whole document into a string.

if parser is None:
        parser = html_parser

def fragments_fromstring(html, no_leading_text=False,
                         guess_charset=None, parser=None):
    """Parses several HTML elements, returning a list of elements.

The first item in the list may be a string.  If no_leading_text is true,
    then it will be an error if there is leading text, and it will always be
    a list of only elements.

If `guess_charset` is true, the `chardet` library will perform charset
    guessing on the string.
    """
    if not isinstance(html, _strings):
        raise TypeError('string required')

if parser is None:
        parser = html_parser

options = {}
    if guess_charset is None and isinstance(html, bytes):
        # html5lib does not accept useChardet as an argument, if it
        # detected the html argument would produce unicode objects.
        guess_charset = False
    if guess_charset is not None:
        options['useChardet'] = guess_charset
    children = parser.parseFragment(html, 'div', **options)
    if children and isinstance(children[0], _strings):
        if no_leading_text:
            if children[0].strip():
                raise etree.ParserError('There is leading text: %r' %
                                        children[0])
            del children[0]
    return children

def fragment_fromstring(html, create_parent=False,
                        guess_charset=None, parser=None):
    """Parses a single HTML element; it is an error if there is more than
    one element, or if anything but whitespace precedes or follows the
    element.

If 'create_parent' is true (or is a tag name) then a parent node
    will be created to encapsulate the HTML in a single element.  In
    this case, leading or trailing text is allowed.

If `guess_charset` is true, the `chardet` library will perform charset
    guessing on the string.
    """
    if not isinstance(html, _strings):
        raise TypeError('string required')

accept_leading_text = bool(create_parent)

elements = fragments_fromstring(
        html, guess_charset=guess_charset, parser=parser,
        no_leading_text=not accept_leading_text)

if create_parent:
        if not isinstance(create_parent, _strings):
            create_parent = 'div'
        new_root = Element(create_parent)
        if elements:
            if isinstance(elements[0], _strings):
                new_root.text = elements[0]
                del elements[0]
            new_root.extend(elements)
        return new_root

if not elements:
        raise etree.ParserError('No elements found')
    if len(elements) > 1:
        raise etree.ParserError('Multiple elements found')
    result = elements[0]
    if result.tail and result.tail.strip():
        raise etree.ParserError('Element followed by text: %r' % result.tail)
    result.tail = None
    return result

def fromstring(html, guess_charset=None, parser=None):
    """Parse the html, returning a single element/document.

This tries to minimally parse the chunk of text, without knowing if it
    is a fragment or a document.

'base_url' will set the document's base_url attribute (and the tree's
    docinfo.URL)

If `guess_charset` is true, or if the input is not Unicode but a
    byte string, the `chardet` library will perform charset guessing
    on the string.
    """
    if not isinstance(html, _strings):
        raise TypeError('string required')
    doc = document_fromstring(html, parser=parser,
                              guess_charset=guess_charset)

# document starts with doctype or <html>, full document!
    start = html[:50]
    if isinstance(start, bytes):
        # Allow text comparison in python3.
        # Decode as ascii, that also covers latin-1 and utf-8 for the
        # characters we need.
        start = start.decode('ascii', 'replace')

start = start.lstrip().lower()
    if start.startswith('<html') or start.startswith('<!doctype'):
        return doc

head = _find_tag(doc, 'head')

# if the head is not empty we have a full document
    if len(head):
        return doc

body = _find_tag(doc, 'body')

# The body has just one element, so it was probably a single
    # element passed in
    if (len(body) == 1 and (not body.text or not body.text.strip())
        and (not body[-1].tail or not body[-1].tail.strip())):
        return body[0]

# Now we have a body which represents a bunch of tags which have the
    # content that was passed in.  We will create a fake container, which
    # is the body tag, except <body> implies too much structure.
    if _contains_block_level_tag(body):
        body.tag = 'div'
    else:
        body.tag = 'span'
    return body

def parse(filename_url_or_file, guess_charset=None, parser=None):
    """Parse a filename, URL, or file-like object into an HTML document
    tree.  Note: this returns a tree, not an element.  Use
    ``parse(...).getroot()`` to get the document root.

If ``guess_charset`` is true, the ``useChardet`` option is passed into
    html5lib to enable character detection.  This option is on by default
    when parsing from URLs, off by default when parsing from file(-like)
    objects (which tend to return Unicode more often than not), and on by
    default when parsing from a file path (which is read in binary mode).
    """
    if parser is None:
        parser = html_parser
    if not isinstance(filename_url_or_file, _strings):
        fp = filename_url_or_file
        if guess_charset is None:
            # assume that file-like objects return Unicode more often than bytes
            guess_charset = False
    elif _looks_like_url(filename_url_or_file):
        fp = urlopen(filename_url_or_file)
        if guess_charset is None:
            # assume that URLs return bytes
            guess_charset = True
    else:
        fp = open(filename_url_or_file, 'rb')
        if guess_charset is None:
            guess_charset = True

options = {}
    # html5lib does not accept useChardet as an argument, if it
    # detected the html argument would produce unicode objects.
    if guess_charset:
        options['useChardet'] = guess_charset
    return parser.parse(fp, **options)

def _looks_like_url(str):
    scheme = urlparse(str)[0]
    if not scheme:
        return False
    elif (sys.platform == 'win32' and
            scheme in string.ascii_letters
            and len(scheme) == 1):
        # looks like a 'normal' absolute path
        return False
    else:
        return True

html_parser = HTMLParser()

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/root	drwxr-xr-x	2023-11-27 12:53:32
..	dir	-	root/root	drwxr-xr-x	2023-11-27 12:53:33
__pycache__	dir	-	root/root	drwxr-xr-x	2023-11-27 12:53:32
ElementSoup.py	file	320 B	root/root	-rw-r--r--	2023-09-05 09:10:01
__init__.py	file	63.42 KB	root/root	-rw-r--r--	2023-09-05 09:10:01
_diffcommand.py	file	2.07 KB	root/root	-rw-r--r--	2023-09-05 09:10:01
_html5builder.py	file	3.17 KB	root/root	-rw-r--r--	2023-09-05 09:10:01
_setmixin.py	file	1.16 KB	root/root	-rw-r--r--	2023-09-05 09:10:01
builder.py	file	4.39 KB	root/root	-rw-r--r--	2023-09-05 09:10:01
clean.cpython-311-x86_64-linux-gnu.so	file	573.05 KB	root/root	-rwxr-xr-x	2023-09-05 09:10:01
clean.py	file	27.65 KB	root/root	-rw-r--r--	2023-09-05 09:10:01
defs.py	file	4.14 KB	root/root	-rw-r--r--	2023-09-05 09:10:01
diff.cpython-311-x86_64-linux-gnu.so	file	792.63 KB	root/root	-rwxr-xr-x	2023-09-05 09:10:01
diff.py	file	29.84 KB	root/root	-rw-r--r--	2023-09-05 09:10:01
formfill.py	file	9.46 KB	root/root	-rw-r--r--	2023-09-05 09:10:01
html5parser.py	file	8.43 KB	root/root	-rw-r--r--	2023-09-05 09:10:01
soupparser.py	file	9.96 KB	root/root	-rw-r--r--	2023-09-05 09:10:01
usedoctest.py	file	249 B	root/root	-rw-r--r--	2023-09-05 09:10:01