File Manager

X7ROOT File Manager

Current Path: /opt/alt/python313/lib64/python3.13

opt / alt / python313 / lib64 / python3.13 /

?? ..
?? LICENSE.txt(13.49 KB)
?? __future__.py(5.1 KB)
?? __hello__.py(227 B)
?? __pycache__
?? _aix_support.py(3.93 KB)
?? _android_support.py(6.73 KB)
?? _apple_support.py(2.2 KB)
?? _collections_abc.py(31.51 KB)
?? _colorize.py(2.78 KB)
?? _compat_pickle.py(8.53 KB)
?? _compression.py(5.55 KB)
?? _ios_support.py(2.61 KB)
?? _markupbase.py(14.31 KB)
?? _opcode_metadata.py(9.05 KB)
?? _osx_support.py(21.51 KB)
?? _py_abc.py(6.04 KB)
?? _pydatetime.py(89.83 KB)
?? _pydecimal.py(221.96 KB)
?? _pyio.py(91.5 KB)
?? _pylong.py(11.55 KB)
?? _pyrepl
?? _sitebuiltins.py(3.05 KB)
?? _strptime.py(28.69 KB)
?? _sysconfigdata__linux_x86_64-linux-gnu.py(65.73 KB)
?? _sysconfigdata_d_linux_x86_64-linux-gnu.py(65.71 KB)
?? _threading_local.py(4.26 KB)
?? _weakrefset.py(5.75 KB)
?? abc.py(6.38 KB)
?? antigravity.py(500 B)
?? argparse.py(99.28 KB)
?? ast.py(63.81 KB)
?? asyncio
?? base64.py(21.14 KB)
?? bdb.py(34.51 KB)
?? bisect.py(3.34 KB)
?? bz2.py(11.69 KB)
?? cProfile.py(6.48 KB)
?? calendar.py(25.47 KB)
?? cmd.py(14.96 KB)
?? code.py(12.86 KB)
?? codecs.py(36.06 KB)
?? codeop.py(5.69 KB)
?? collections
?? colorsys.py(3.97 KB)
?? compileall.py(20.18 KB)
?? concurrent
?? config-3.13-x86_64-linux-gnu
?? configparser.py(52.57 KB)
?? contextlib.py(27.15 KB)
?? contextvars.py(129 B)
?? copy.py(8.76 KB)
?? copyreg.py(7.44 KB)
?? csv.py(18.73 KB)
?? ctypes
?? curses
?? dataclasses.py(63.03 KB)
?? datetime.py(268 B)
?? dbm
?? decimal.py(2.73 KB)
?? difflib.py(81.41 KB)
?? dis.py(40 KB)
?? doctest.py(106.77 KB)
?? email
?? encodings
?? ensurepip
?? enum.py(83.57 KB)
?? filecmp.py(10.4 KB)
?? fileinput.py(15.35 KB)
?? fnmatch.py(6.04 KB)
?? fractions.py(39.08 KB)
?? ftplib.py(33.92 KB)
?? functools.py(38.21 KB)
?? genericpath.py(6.1 KB)
?? getopt.py(7.31 KB)
?? getpass.py(6.09 KB)
?? gettext.py(21.03 KB)
?? glob.py(19.26 KB)
?? graphlib.py(9.42 KB)
?? gzip.py(24.06 KB)
?? hashlib.py(9.22 KB)
?? heapq.py(22.48 KB)
?? hmac.py(7.54 KB)
?? html
?? http
?? imaplib.py(52.77 KB)
?? importlib
?? inspect.py(125.27 KB)
?? io.py(3.5 KB)
?? ipaddress.py(79.72 KB)
?? json
?? keyword.py(1.05 KB)
?? lib-dynload
?? linecache.py(7.11 KB)
?? locale.py(77.18 KB)
?? logging
?? lzma.py(13.08 KB)
?? mailbox.py(79.73 KB)
?? mimetypes.py(23.29 KB)
?? modulefinder.py(23.23 KB)
?? multiprocessing
?? netrc.py(6.76 KB)
?? ntpath.py(32.04 KB)
?? nturl2path.py(2.32 KB)
?? numbers.py(11.2 KB)
?? opcode.py(2.76 KB)
?? operator.py(10.72 KB)
?? optparse.py(58.95 KB)
?? os.py(40.66 KB)
?? pathlib
?? pdb.py(88.81 KB)
?? pickle.py(65.39 KB)
?? pickletools.py(91.85 KB)
?? pkgutil.py(17.85 KB)
?? platform.py(46.25 KB)
?? plistlib.py(29.1 KB)
?? poplib.py(14.26 KB)
?? posixpath.py(17.93 KB)
?? pprint.py(23.59 KB)
?? profile.py(22.61 KB)
?? pstats.py(28.61 KB)
?? pty.py(5.99 KB)
?? py_compile.py(7.65 KB)
?? pyclbr.py(11.13 KB)
?? pydoc.py(107.5 KB)
?? pydoc_data
?? queue.py(13.17 KB)
?? quopri.py(7.03 KB)
?? random.py(36.14 KB)
?? re
?? reprlib.py(7.02 KB)
?? rlcompleter.py(7.73 KB)
?? runpy.py(12.58 KB)
?? sched.py(6.2 KB)
?? secrets.py(1.94 KB)
?? selectors.py(19 KB)
?? shelve.py(8.6 KB)
?? shlex.py(13.04 KB)
?? shutil.py(56.12 KB)
?? signal.py(2.44 KB)
?? site-packages
?? site.py(24.97 KB)
?? smtplib.py(42.52 KB)
?? socket.py(36.87 KB)
?? socketserver.py(27.41 KB)
?? sqlite3
?? sre_compile.py(231 B)
?? sre_constants.py(232 B)
?? sre_parse.py(229 B)
?? ssl.py(51.47 KB)
?? stat.py(6 KB)
?? statistics.py(60.38 KB)
?? string.py(11.51 KB)
?? stringprep.py(12.61 KB)
?? struct.py(257 B)
?? subprocess.py(87.39 KB)
?? symtable.py(13.87 KB)
?? sysconfig
?? tabnanny.py(11.27 KB)
?? tarfile.py(111.42 KB)
?? tempfile.py(31.61 KB)
?? textwrap.py(19.47 KB)
?? this.py(1003 B)
?? threading.py(53.95 KB)
?? timeit.py(13.16 KB)
?? token.py(2.43 KB)
?? tokenize.py(21.06 KB)
?? tomllib
?? trace.py(29.03 KB)
?? traceback.py(64.96 KB)
?? tracemalloc.py(17.62 KB)
?? tty.py(1.99 KB)
?? types.py(10.94 KB)
?? typing.py(129.61 KB)
?? unittest
?? urllib
?? uuid.py(28.46 KB)
?? venv
?? warnings.py(26.32 KB)
?? wave.py(22.69 KB)
?? weakref.py(21.01 KB)
?? webbrowser.py(23.73 KB)
?? wsgiref
?? xml
?? xmlrpc
?? zipapp.py(8.42 KB)
?? zipfile
?? zipimport.py(32.12 KB)
?? zoneinfo

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.
"""

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

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

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

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

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

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 _getline_from_code(filename, lineno):
    lines = _getlines_from_code(filename)
    if 1 <= lineno <= len(lines):
        return lines[lineno - 1]
    return ''

def _make_key(code):
    return (code.co_filename, code.co_qualname, code.co_firstlineno)

def _getlines_from_code(code):
    code_id = _make_key(code)
    if code_id in _interactive_cache:
        entry = _interactive_cache[code_id]
        if len(entry) != 1:
            return _interactive_cache[code_id][2]
    return []

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

if filename is None:
        # get keys atomically
        filenames = cache.copy().keys()
    else:
        filenames = [filename]

for filename in filenames:
        try:
            entry = cache[filename]
        except KeyError:
            continue

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:
            # This import can fail if the interpreter is shutting down
            import os
        except ImportError:
            return
        try:
            stat = os.stat(fullname)
        except (OSError, ValueError):
            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."""

# These imports are not at top level because linecache is in the critical
    # path of the interpreter startup and importing os and sys take a lot of time
    # and slows down the startup sequence.
    try:
        import os
        import sys
        import tokenize
    except ImportError:
        # These import can fail if the interpreter is shutting down
        return []

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, ValueError):
                pass
        else:
            return []
    except ValueError:  # may be raised by os.stat()
        return []
    try:
        with tokenize.open(fullname) as fp:
            lines = fp.readlines()
    except (OSError, UnicodeDecodeError, SyntaxError):
        return []
    if not lines:
        lines = ['\n']
    elif 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 cacheable
        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 '__name__' in module_globals:
        spec = module_globals.get('__spec__')
        name = getattr(spec, 'name', None) or module_globals['__name__']
        loader = getattr(spec, 'loader', None)
        if loader is None:
            loader = module_globals.get('__loader__')
        get_source = getattr(loader, 'get_source', None)

if name and get_source:
            def get_lines(name=name, *args, **kwargs):
                return get_source(name, *args, **kwargs)
            cache[filename] = (get_lines,)
            return True
    return False

def _register_code(code, string, name):
    entry = (len(string),
             None,
             [line + '\n' for line in string.splitlines()],
             name)
    stack = [code]
    while stack:
        code = stack.pop()
        for const in code.co_consts:
            if isinstance(const, type(code)):
                stack.append(const)
        _interactive_cache[_make_key(code)] = entry

X7ROOT File Manager

Editing: linecache.py

Upload File

Create Folder