File Manager

X7ROOT File Manager

Current Path: /opt/alt/python38/lib64/python3.8

opt / alt / python38 / lib64 / python3.8 /

ðŸ“ ..
ðŸ“„ LICENSE.txt(13.61 KB)
ðŸ“„ __future__.py(5.03 KB)
ðŸ“„ __phello__.foo.py(64 B)
ðŸ“ __pycache__
ðŸ“„ _bootlocale.py(1.76 KB)
ðŸ“„ _collections_abc.py(25.49 KB)
ðŸ“„ _compat_pickle.py(8.54 KB)
ðŸ“„ _compression.py(5.21 KB)
ðŸ“„ _dummy_thread.py(5.89 KB)
ðŸ“„ _markupbase.py(14.26 KB)
ðŸ“„ _osx_support.py(21.26 KB)
ðŸ“„ _py_abc.py(6.04 KB)
ðŸ“„ _pydecimal.py(223.31 KB)
ðŸ“„ _pyio.py(90.99 KB)
ðŸ“„ _sitebuiltins.py(3.04 KB)
ðŸ“„ _strptime.py(24.68 KB)
ðŸ“„ _sysconfigdata__linux_x86_64-linux-gnu.py(40.7 KB)
ðŸ“„ _sysconfigdata_d_linux_x86_64-linux-gnu.py(40.47 KB)
ðŸ“„ _threading_local.py(7.05 KB)
ðŸ“„ _weakrefset.py(5.6 KB)
ðŸ“„ abc.py(4.38 KB)
ðŸ“„ aifc.py(32.04 KB)
ðŸ“„ antigravity.py(477 B)
ðŸ“„ argparse.py(93.76 KB)
ðŸ“„ ast.py(18.78 KB)
ðŸ“„ asynchat.py(11.06 KB)
ðŸ“ asyncio
ðŸ“„ asyncore.py(19.62 KB)
ðŸ“„ base64.py(19.92 KB)
ðŸ“„ bdb.py(31.3 KB)
ðŸ“„ binhex.py(13.63 KB)
ðŸ“„ bisect.py(2.16 KB)
ðŸ“„ bz2.py(12.26 KB)
ðŸ“„ cProfile.py(6.86 KB)
ðŸ“„ calendar.py(24.25 KB)
ðŸ“„ cgi.py(33.15 KB)
ðŸ“„ cgitb.py(11.81 KB)
ðŸ“„ chunk.py(5.31 KB)
ðŸ“„ cmd.py(14.51 KB)
ðŸ“„ code.py(10.37 KB)
ðŸ“„ codecs.py(35.81 KB)
ðŸ“„ codeop.py(6.18 KB)
ðŸ“ collections
ðŸ“„ colorsys.py(3.97 KB)
ðŸ“„ compileall.py(13.36 KB)
ðŸ“ concurrent
ðŸ“ config-3.8-x86_64-linux-gnu
ðŸ“„ configparser.py(53.1 KB)
ðŸ“„ contextlib.py(24.41 KB)
ðŸ“„ contextvars.py(129 B)
ðŸ“„ copy.py(8.46 KB)
ðŸ“„ copyreg.py(6.97 KB)
ðŸ“„ crypt.py(3.53 KB)
ðŸ“„ csv.py(15.77 KB)
ðŸ“ ctypes
ðŸ“ curses
ðŸ“„ dataclasses.py(48.8 KB)
ðŸ“„ datetime.py(86.22 KB)
ðŸ“ dbm
ðŸ“„ decimal.py(320 B)
ðŸ“„ difflib.py(82.09 KB)
ðŸ“„ dis.py(20.09 KB)
ðŸ“ distutils
ðŸ“„ doctest.py(102.09 KB)
ðŸ“„ dummy_threading.py(2.75 KB)
ðŸ“ email
ðŸ“ encodings
ðŸ“ ensurepip
ðŸ“„ enum.py(37.24 KB)
ðŸ“„ filecmp.py(9.6 KB)
ðŸ“„ fileinput.py(14.36 KB)
ðŸ“„ fnmatch.py(3.98 KB)
ðŸ“„ formatter.py(14.79 KB)
ðŸ“„ fractions.py(23.76 KB)
ðŸ“„ ftplib.py(34.31 KB)
ðŸ“„ functools.py(36.53 KB)
ðŸ“„ genericpath.py(4.86 KB)
ðŸ“„ getopt.py(7.31 KB)
ðŸ“„ getpass.py(5.85 KB)
ðŸ“„ gettext.py(26.5 KB)
ðŸ“„ glob.py(5.56 KB)
ðŸ“„ gzip.py(20.91 KB)
ðŸ“„ hashlib.py(9.5 KB)
ðŸ“„ heapq.py(22.34 KB)
ðŸ“„ hmac.py(6.47 KB)
ðŸ“ html
ðŸ“ http
ðŸ“„ imaplib.py(52.35 KB)
ðŸ“„ imghdr.py(3.72 KB)
ðŸ“„ imp.py(10.29 KB)
ðŸ“ importlib
ðŸ“„ inspect.py(115.77 KB)
ðŸ“„ io.py(3.46 KB)
ðŸ“„ ipaddress.py(73.14 KB)
ðŸ“ json
ðŸ“„ keyword.py(945 B)
ðŸ“ lib-dynload
ðŸ“ lib2to3
ðŸ“„ linecache.py(5.21 KB)
ðŸ“„ locale.py(76.36 KB)
ðŸ“ logging
ðŸ“„ lzma.py(12.68 KB)
ðŸ“„ mailbox.py(76.82 KB)
ðŸ“„ mailcap.py(8.85 KB)
ðŸ“„ mimetypes.py(21.16 KB)
ðŸ“„ modulefinder.py(23.86 KB)
ðŸ“ multiprocessing
ðŸ“„ netrc.py(5.44 KB)
ðŸ“„ nntplib.py(42.25 KB)
ðŸ“„ ntpath.py(27.08 KB)
ðŸ“„ nturl2path.py(2.82 KB)
ðŸ“„ numbers.py(10 KB)
ðŸ“„ opcode.py(5.67 KB)
ðŸ“„ operator.py(10.46 KB)
ðŸ“„ optparse.py(58.95 KB)
ðŸ“„ os.py(38.08 KB)
ðŸ“„ pathlib.py(51.38 KB)
ðŸ“„ pdb.py(61.28 KB)
ðŸ“„ pickle.py(62.96 KB)
ðŸ“„ pickletools.py(91.29 KB)
ðŸ“„ pipes.py(8.71 KB)
ðŸ“„ pkgutil.py(21 KB)
ðŸ“„ platform.py(39.49 KB)
ðŸ“„ plistlib.py(31.46 KB)
ðŸ“„ poplib.py(14.72 KB)
ðŸ“„ posixpath.py(15.26 KB)
ðŸ“„ pprint.py(20.98 KB)
ðŸ“„ profile.py(23.01 KB)
ðŸ“„ pstats.py(26.7 KB)
ðŸ“„ pty.py(4.69 KB)
ðŸ“„ py_compile.py(8.01 KB)
ðŸ“„ pyclbr.py(14.9 KB)
ðŸ“„ pydoc.py(104.2 KB)
ðŸ“ pydoc_data
ðŸ“„ queue.py(11.09 KB)
ðŸ“„ quopri.py(7.09 KB)
ðŸ“„ random.py(28.13 KB)
ðŸ“„ re.py(15.49 KB)
ðŸ“„ reprlib.py(5.14 KB)
ðŸ“„ rlcompleter.py(6.93 KB)
ðŸ“„ runpy.py(11.77 KB)
ðŸ“„ sched.py(6.29 KB)
ðŸ“„ secrets.py(1.99 KB)
ðŸ“„ selectors.py(18.13 KB)
ðŸ“„ shelve.py(8.33 KB)
ðŸ“„ shlex.py(13.01 KB)
ðŸ“„ shutil.py(50.55 KB)
ðŸ“„ signal.py(2.22 KB)
ðŸ“ site-packages
ðŸ“„ site.py(21.36 KB)
ðŸ“„ smtpd.py(33.91 KB)
ðŸ“„ smtplib.py(43.96 KB)
ðŸ“„ sndhdr.py(6.93 KB)
ðŸ“„ socket.py(34.63 KB)
ðŸ“„ socketserver.py(26.66 KB)
ðŸ“ sqlite3
ðŸ“„ sre_compile.py(26.07 KB)
ðŸ“„ sre_constants.py(6.99 KB)
ðŸ“„ sre_parse.py(39.29 KB)
ðŸ“„ ssl.py(51.3 KB)
ðŸ“„ stat.py(5.36 KB)
ðŸ“„ statistics.py(38.76 KB)
ðŸ“„ string.py(10.29 KB)
ðŸ“„ stringprep.py(12.61 KB)
ðŸ“„ struct.py(257 B)
ðŸ“„ subprocess.py(76.42 KB)
ðŸ“„ sunau.py(17.94 KB)
ðŸ“„ symbol.py(2.06 KB)
ðŸ“„ symtable.py(7.83 KB)
ðŸ“„ sysconfig.py(24.31 KB)
ðŸ“„ tabnanny.py(11.15 KB)
ðŸ“„ tarfile.py(103.55 KB)
ðŸ“„ telnetlib.py(22.71 KB)
ðŸ“„ tempfile.py(27.17 KB)
ðŸ“„ textwrap.py(18.95 KB)
ðŸ“„ this.py(1003 B)
ðŸ“„ threading.py(49.63 KB)
ðŸ“„ timeit.py(13.18 KB)
ðŸ“„ token.py(2.31 KB)
ðŸ“„ tokenize.py(25.24 KB)
ðŸ“„ trace.py(29.18 KB)
ðŸ“„ traceback.py(23.06 KB)
ðŸ“„ tracemalloc.py(16.68 KB)
ðŸ“„ tty.py(879 B)
ðŸ“„ types.py(9.49 KB)
ðŸ“„ typing.py(67.35 KB)
ðŸ“ unittest
ðŸ“ urllib
ðŸ“„ uu.py(7.11 KB)
ðŸ“„ uuid.py(29.75 KB)
ðŸ“ venv
ðŸ“„ warnings.py(19.23 KB)
ðŸ“„ wave.py(17.8 KB)
ðŸ“„ weakref.py(20.89 KB)
ðŸ“„ webbrowser.py(23.53 KB)
ðŸ“ wsgiref
ðŸ“„ xdrlib.py(5.77 KB)
ðŸ“ xml
ðŸ“ xmlrpc
ðŸ“„ zipapp.py(7.36 KB)
ðŸ“„ zipfile.py(86.4 KB)
ðŸ“„ zipimport.py(30.04 KB)

Editing: linecache.py

"""Cache lines from Python source files.

This is intended to read lines from modules imported -- hence if a filename
is not found, it will look down the module search path for a file by
that name.
"""

import functools
import sys
import os
import tokenize

__all__ = ["getline", "clearcache", "checkcache"]

def getline(filename, lineno, module_globals=None):
    lines = getlines(filename, module_globals)
    if 1 <= lineno <= len(lines):
        return lines[lineno-1]
    else:
        return ''

# The cache

# The cache. Maps filenames to either a thunk which will provide source code,
# or a tuple (size, mtime, lines, fullname) once loaded.
cache = {}

def clearcache():
    """Clear the cache entirely."""

global cache
    cache = {}

def getlines(filename, module_globals=None):
    """Get the lines for a Python source file from the cache.
    Update the cache if it doesn't contain an entry for this file already."""

if filename in cache:
        entry = cache[filename]
        if len(entry) != 1:
            return cache[filename][2]

try:
        return updatecache(filename, module_globals)
    except MemoryError:
        clearcache()
        return []

def checkcache(filename=None):
    """Discard cache entries that are out of date.
    (This is not checked upon each call!)"""

if filename is None:
        filenames = list(cache.keys())
    else:
        if filename in cache:
            filenames = [filename]
        else:
            return

for filename in filenames:
        entry = cache[filename]
        if len(entry) == 1:
            # lazy cache entry, leave it lazy.
            continue
        size, mtime, lines, fullname = entry
        if mtime is None:
            continue   # no-op for files loaded via a __loader__
        try:
            stat = os.stat(fullname)
        except OSError:
            cache.pop(filename, None)
            continue
        if size != stat.st_size or mtime != stat.st_mtime:
            cache.pop(filename, None)

def updatecache(filename, module_globals=None):
    """Update a cache entry and return its list of lines.
    If something's wrong, print a message, discard the cache entry,
    and return an empty list."""

if filename in cache:
        if len(cache[filename]) != 1:
            cache.pop(filename, None)
    if not filename or (filename.startswith('<') and filename.endswith('>')):
        return []

fullname = filename
    try:
        stat = os.stat(fullname)
    except OSError:
        basename = filename

# Realise a lazy loader based lookup if there is one
        # otherwise try to lookup right now.
        if lazycache(filename, module_globals):
            try:
                data = cache[filename][0]()
            except (ImportError, OSError):
                pass
            else:
                if data is None:
                    # No luck, the PEP302 loader cannot find the source
                    # for this module.
                    return []
                cache[filename] = (
                    len(data), None,
                    [line+'\n' for line in data.splitlines()], fullname
                )
                return cache[filename][2]

# Try looking through the module search path, which is only useful
        # when handling a relative filename.
        if os.path.isabs(filename):
            return []

for dirname in sys.path:
            try:
                fullname = os.path.join(dirname, basename)
            except (TypeError, AttributeError):
                # Not sufficiently string-like to do anything useful with.
                continue
            try:
                stat = os.stat(fullname)
                break
            except OSError:
                pass
        else:
            return []
    try:
        with tokenize.open(fullname) as fp:
            lines = fp.readlines()
    except OSError:
        return []
    if lines and not lines[-1].endswith('\n'):
        lines[-1] += '\n'
    size, mtime = stat.st_size, stat.st_mtime
    cache[filename] = size, mtime, lines, fullname
    return lines

def lazycache(filename, module_globals):
    """Seed the cache for filename with module_globals.

The module loader will be asked for the source only when getlines is
    called, not immediately.

If there is an entry in the cache already, it is not altered.

:return: True if a lazy load is registered in the cache,
        otherwise False. To register such a load a module loader with a
        get_source method must be found, the filename must be a cachable
        filename, and the filename must not be already cached.
    """
    if filename in cache:
        if len(cache[filename]) == 1:
            return True
        else:
            return False
    if not filename or (filename.startswith('<') and filename.endswith('>')):
        return False
    # Try for a __loader__, if available
    if module_globals and '__loader__' in module_globals:
        name = module_globals.get('__name__')
        loader = module_globals['__loader__']
        get_source = getattr(loader, 'get_source', None)

if name and get_source:
            get_lines = functools.partial(get_source, name)
            cache[filename] = (get_lines,)
            return True
    return False

X7ROOT File Manager

Editing: linecache.py

Upload File

Create Folder