File Manager

X7ROOT File Manager

Current Path: /opt/alt/python37/lib64/python3.7

opt / alt / python37 / lib64 / python3.7 /

ðŸ“ ..
ðŸ“„ __future__.py(4.98 KB)
ðŸ“„ __phello__.foo.py(64 B)
ðŸ“ __pycache__
ðŸ“„ _bootlocale.py(1.76 KB)
ðŸ“„ _collections_abc.py(25.8 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(19.14 KB)
ðŸ“„ _py_abc.py(6.04 KB)
ðŸ“„ _pydecimal.py(223.33 KB)
ðŸ“„ _pyio.py(89.47 KB)
ðŸ“„ _sitebuiltins.py(3.04 KB)
ðŸ“„ _strptime.py(24.91 KB)
ðŸ“„ _sysconfigdata_dm_linux_x86_64-linux-gnu.py(30.59 KB)
ðŸ“„ _sysconfigdata_m_linux_x86_64-linux-gnu.py(27.93 KB)
ðŸ“„ _threading_local.py(7.04 KB)
ðŸ“„ _weakrefset.py(5.55 KB)
ðŸ“„ abc.py(5.45 KB)
ðŸ“„ aifc.py(32.04 KB)
ðŸ“„ antigravity.py(477 B)
ðŸ“„ argparse.py(93.14 KB)
ðŸ“„ ast.py(12.54 KB)
ðŸ“„ asynchat.py(11.06 KB)
ðŸ“ asyncio
ðŸ“„ asyncore.py(19.65 KB)
ðŸ“„ base64.py(19.92 KB)
ðŸ“„ bdb.py(30.99 KB)
ðŸ“„ binhex.py(13.63 KB)
ðŸ“„ bisect.py(2.5 KB)
ðŸ“„ bz2.py(12.12 KB)
ðŸ“„ cProfile.py(6.11 KB)
ðŸ“„ calendar.py(24.24 KB)
ðŸ“„ cgi.py(34.23 KB)
ðŸ“„ cgitb.py(11.74 KB)
ðŸ“„ chunk.py(5.31 KB)
ðŸ“„ cmd.py(14.51 KB)
ðŸ“„ code.py(10.37 KB)
ðŸ“„ codecs.py(35.76 KB)
ðŸ“„ codeop.py(6.13 KB)
ðŸ“ collections
ðŸ“„ colorsys.py(3.97 KB)
ðŸ“„ compileall.py(13.46 KB)
ðŸ“ concurrent
ðŸ“ config-3.7m
ðŸ“„ configparser.py(53.01 KB)
ðŸ“„ contextlib.py(24.18 KB)
ðŸ“„ contextvars.py(129 B)
ðŸ“„ copy.py(8.65 KB)
ðŸ“„ copyreg.py(6.85 KB)
ðŸ“„ crypt.py(3.27 KB)
ðŸ“„ csv.py(15.8 KB)
ðŸ“ ctypes
ðŸ“ curses
ðŸ“„ dataclasses.py(48.36 KB)
ðŸ“„ datetime.py(84.52 KB)
ðŸ“ dbm
ðŸ“„ decimal.py(320 B)
ðŸ“„ difflib.py(82.42 KB)
ðŸ“„ dis.py(19.42 KB)
ðŸ“ distutils
ðŸ“„ doctest.py(102.11 KB)
ðŸ“„ dummy_threading.py(2.75 KB)
ðŸ“ email
ðŸ“ encodings
ðŸ“ ensurepip
ðŸ“„ enum.py(34.22 KB)
ðŸ“„ filecmp.py(9.6 KB)
ðŸ“„ fileinput.py(14.28 KB)
ðŸ“„ fnmatch.py(3.96 KB)
ðŸ“„ formatter.py(14.79 KB)
ðŸ“„ fractions.py(23.2 KB)
ðŸ“„ ftplib.py(34.78 KB)
ðŸ“„ functools.py(32.16 KB)
ðŸ“„ genericpath.py(4.8 KB)
ðŸ“„ getopt.py(7.31 KB)
ðŸ“„ getpass.py(5.85 KB)
ðŸ“„ gettext.py(21.45 KB)
ðŸ“„ glob.py(5.51 KB)
ðŸ“„ gzip.py(20.15 KB)
ðŸ“„ hashlib.py(9.31 KB)
ðŸ“„ heapq.py(22.48 KB)
ðŸ“„ hmac.py(6.36 KB)
ðŸ“ html
ðŸ“ http
ðŸ“ idlelib
ðŸ“„ imaplib.py(52.04 KB)
ðŸ“„ imghdr.py(3.71 KB)
ðŸ“„ imp.py(10.29 KB)
ðŸ“ importlib
ðŸ“„ inspect.py(114.88 KB)
ðŸ“„ io.py(3.43 KB)
ðŸ“„ ipaddress.py(71.85 KB)
ðŸ“ json
ðŸ“„ keyword.py(2.2 KB)
ðŸ“ lib-dynload
ðŸ“ lib2to3
ðŸ“„ linecache.py(5.21 KB)
ðŸ“„ locale.py(76.36 KB)
ðŸ“ logging
ðŸ“„ lzma.py(12.68 KB)
ðŸ“„ macpath.py(5.98 KB)
ðŸ“„ mailbox.py(76.81 KB)
ðŸ“„ mailcap.py(8.85 KB)
ðŸ“„ mimetypes.py(20.99 KB)
ðŸ“„ modulefinder.py(22.5 KB)
ðŸ“ multiprocessing
ðŸ“„ netrc.py(5.44 KB)
ðŸ“„ nntplib.py(42.08 KB)
ðŸ“„ ntpath.py(21.82 KB)
ðŸ“„ nturl2path.py(2.52 KB)
ðŸ“„ numbers.py(10 KB)
ðŸ“„ opcode.py(5.69 KB)
ðŸ“„ operator.py(10.61 KB)
ðŸ“„ optparse.py(58.96 KB)
ðŸ“„ os.py(37.01 KB)
ðŸ“„ pathlib.py(49.15 KB)
ðŸ“„ pdb.py(61.04 KB)
ðŸ“„ pickle.py(56.63 KB)
ðŸ“„ pickletools.py(89.08 KB)
ðŸ“„ pipes.py(8.71 KB)
ðŸ“„ pkgutil.py(20.96 KB)
ðŸ“„ platform.py(45.89 KB)
ðŸ“„ plistlib.py(29.99 KB)
ðŸ“„ poplib.py(14.61 KB)
ðŸ“„ posixpath.py(15.4 KB)
ðŸ“„ pprint.py(20.39 KB)
ðŸ“„ profile.py(21.97 KB)
ðŸ“„ pstats.py(26.67 KB)
ðŸ“„ pty.py(4.65 KB)
ðŸ“„ py_compile.py(7.81 KB)
ðŸ“„ pyclbr.py(14.78 KB)
ðŸ“„ pydoc.py(103.39 KB)
ðŸ“ pydoc_data
ðŸ“„ queue.py(11.09 KB)
ðŸ“„ quopri.py(7.09 KB)
ðŸ“„ random.py(26.91 KB)
ðŸ“„ re.py(14.95 KB)
ðŸ“„ reprlib.py(5.14 KB)
ðŸ“„ rlcompleter.py(6.93 KB)
ðŸ“„ runpy.py(11.68 KB)
ðŸ“„ sched.py(6.29 KB)
ðŸ“„ secrets.py(1.99 KB)
ðŸ“„ selectors.py(18.13 KB)
ðŸ“„ shelve.py(8.33 KB)
ðŸ“„ shlex.py(12.79 KB)
ðŸ“„ shutil.py(40.97 KB)
ðŸ“„ signal.py(2.07 KB)
ðŸ“ site-packages
ðŸ“„ site.py(21.07 KB)
ðŸ“„ smtpd.py(33.91 KB)
ðŸ“„ smtplib.py(43.4 KB)
ðŸ“„ sndhdr.py(6.92 KB)
ðŸ“„ socket.py(26.83 KB)
ðŸ“„ socketserver.py(26.29 KB)
ðŸ“ sqlite3
ðŸ“„ sre_compile.py(26.24 KB)
ðŸ“„ sre_constants.py(7.01 KB)
ðŸ“„ sre_parse.py(38.24 KB)
ðŸ“„ ssl.py(44.43 KB)
ðŸ“„ stat.py(5.26 KB)
ðŸ“„ statistics.py(20.17 KB)
ðŸ“„ string.py(11.29 KB)
ðŸ“„ stringprep.py(12.61 KB)
ðŸ“„ struct.py(257 B)
ðŸ“„ subprocess.py(70.95 KB)
ðŸ“„ sunau.py(17.94 KB)
ðŸ“„ symbol.py(2.09 KB)
ðŸ“„ symtable.py(7.11 KB)
ðŸ“„ sysconfig.py(23.87 KB)
ðŸ“„ tabnanny.py(11.15 KB)
ðŸ“„ tarfile.py(90.5 KB)
ðŸ“„ telnetlib.py(22.59 KB)
ðŸ“„ tempfile.py(26.1 KB)
ðŸ“ test
ðŸ“„ textwrap.py(18.95 KB)
ðŸ“„ this.py(1003 B)
ðŸ“„ threading.py(48.13 KB)
ðŸ“„ timeit.py(13.18 KB)
ðŸ“„ token.py(3.67 KB)
ðŸ“„ tokenize.py(26.4 KB)
ðŸ“„ trace.py(28.23 KB)
ðŸ“„ traceback.py(22.89 KB)
ðŸ“„ tracemalloc.py(16.68 KB)
ðŸ“„ tty.py(879 B)
ðŸ“„ types.py(9.67 KB)
ðŸ“„ typing.py(55.12 KB)
ðŸ“ unittest
ðŸ“ urllib
ðŸ“„ uu.py(7.11 KB)
ðŸ“„ uuid.py(28.83 KB)
ðŸ“ venv
ðŸ“„ warnings.py(19.61 KB)
ðŸ“„ wave.py(17.8 KB)
ðŸ“„ weakref.py(21 KB)
ðŸ“„ webbrowser.py(23.16 KB)
ðŸ“ wsgiref
ðŸ“„ xdrlib.py(5.77 KB)
ðŸ“ xml
ðŸ“ xmlrpc
ðŸ“„ zipapp.py(7.36 KB)
ðŸ“„ zipfile.py(79.19 KB)

Editing: compileall.py

"""Module/script to byte-compile all .py files to .pyc files.

When called as a script with arguments, this compiles the directories
given as arguments recursively; the -l option prevents it from
recursing into directories.

Without arguments, if compiles all modules on sys.path, without
recursing into subdirectories.  (Even though it should do so for
packages -- for now, you'll have to deal with packages separately.)

See module py_compile for details of the actual byte-compilation.
"""
import os
import sys
import importlib.util
import py_compile
import struct

from functools import partial

__all__ = ["compile_dir","compile_file","compile_path"]

def _walk_dir(dir, ddir=None, maxlevels=10, quiet=0):
    if quiet < 2 and isinstance(dir, os.PathLike):
        dir = os.fspath(dir)
    if not quiet:
        print('Listing {!r}...'.format(dir))
    try:
        names = os.listdir(dir)
    except OSError:
        if quiet < 2:
            print("Can't list {!r}".format(dir))
        names = []
    names.sort()
    for name in names:
        if name == '__pycache__':
            continue
        fullname = os.path.join(dir, name)
        if ddir is not None:
            dfile = os.path.join(ddir, name)
        else:
            dfile = None
        if not os.path.isdir(fullname):
            yield fullname, ddir
        elif (maxlevels > 0 and name != os.curdir and name != os.pardir and
              os.path.isdir(fullname) and not os.path.islink(fullname)):
            yield from _walk_dir(fullname, ddir=dfile,
                                 maxlevels=maxlevels - 1, quiet=quiet)

def compile_dir(dir, maxlevels=10, ddir=None, force=False, rx=None,
                quiet=0, legacy=False, optimize=-1, workers=1,
                invalidation_mode=None):
    """Byte-compile all modules in the given directory tree.

Arguments (only dir is required):

dir:       the directory to byte-compile
    maxlevels: maximum recursion level (default 10)
    ddir:      the directory that will be prepended to the path to the
               file as it is compiled into each byte-code file.
    force:     if True, force compilation, even if timestamps are up-to-date
    quiet:     full output with False or 0, errors only with 1,
               no output with 2
    legacy:    if True, produce legacy pyc paths instead of PEP 3147 paths
    optimize:  optimization level or -1 for level of the interpreter
    workers:   maximum number of parallel workers
    invalidation_mode: how the up-to-dateness of the pyc will be checked
    """
    ProcessPoolExecutor = None
    if workers is not None:
        if workers < 0:
            raise ValueError('workers must be greater or equal to 0')
        elif workers != 1:
            try:
                # Only import when needed, as low resource platforms may
                # fail to import it
                from concurrent.futures import ProcessPoolExecutor
            except ImportError:
                workers = 1
    files_and_ddirs = _walk_dir(dir, quiet=quiet, maxlevels=maxlevels,
                                ddir=ddir)
    success = True
    if workers is not None and workers != 1 and ProcessPoolExecutor is not None:
        workers = workers or None
        with ProcessPoolExecutor(max_workers=workers) as executor:
            results = executor.map(
                    partial(_compile_file_tuple,
                            force=force, rx=rx, quiet=quiet,
                            legacy=legacy, optimize=optimize,
                            invalidation_mode=invalidation_mode,
                        ),
                    files_and_ddirs)
            success = min(results, default=True)
    else:
        for file, dfile in files_and_ddirs:
            if not compile_file(file, dfile, force, rx, quiet,
                                legacy, optimize, invalidation_mode):
                success = False
    return success

def _compile_file_tuple(file_and_dfile, **kwargs):
    """Needs to be toplevel for ProcessPoolExecutor."""
    file, dfile = file_and_dfile
    return compile_file(file, dfile, **kwargs)

def compile_file(fullname, ddir=None, force=False, rx=None, quiet=0,
                 legacy=False, optimize=-1,
                 invalidation_mode=None):
    """Byte-compile one file.

Arguments (only fullname is required):

fullname:  the file to byte-compile
    ddir:      if given, the directory name compiled in to the
               byte-code file.
    force:     if True, force compilation, even if timestamps are up-to-date
    quiet:     full output with False or 0, errors only with 1,
               no output with 2
    legacy:    if True, produce legacy pyc paths instead of PEP 3147 paths
    optimize:  optimization level or -1 for level of the interpreter
    invalidation_mode: how the up-to-dateness of the pyc will be checked
    """
    success = True
    if quiet < 2 and isinstance(fullname, os.PathLike):
        fullname = os.fspath(fullname)
    name = os.path.basename(fullname)
    if ddir is not None:
        dfile = os.path.join(ddir, name)
    else:
        dfile = None
    if rx is not None:
        mo = rx.search(fullname)
        if mo:
            return success
    if os.path.isfile(fullname):
        if legacy:
            cfile = fullname + 'c'
        else:
            if optimize >= 0:
                opt = optimize if optimize >= 1 else ''
                cfile = importlib.util.cache_from_source(
                                fullname, optimization=opt)
            else:
                cfile = importlib.util.cache_from_source(fullname)
            cache_dir = os.path.dirname(cfile)
        head, tail = name[:-3], name[-3:]
        if tail == '.py':
            if not force:
                try:
                    mtime = int(os.stat(fullname).st_mtime)
                    expect = struct.pack('<4sll', importlib.util.MAGIC_NUMBER,
                                         0, mtime)
                    with open(cfile, 'rb') as chandle:
                        actual = chandle.read(12)
                    if expect == actual:
                        return success
                except OSError:
                    pass
            if not quiet:
                print('Compiling {!r}...'.format(fullname))
            try:
                ok = py_compile.compile(fullname, cfile, dfile, True,
                                        optimize=optimize,
                                        invalidation_mode=invalidation_mode)
            except py_compile.PyCompileError as err:
                success = False
                if quiet >= 2:
                    return success
                elif quiet:
                    print('*** Error compiling {!r}...'.format(fullname))
                else:
                    print('*** ', end='')
                # escape non-printable characters in msg
                msg = err.msg.encode(sys.stdout.encoding,
                                     errors='backslashreplace')
                msg = msg.decode(sys.stdout.encoding)
                print(msg)
            except (SyntaxError, UnicodeError, OSError) as e:
                success = False
                if quiet >= 2:
                    return success
                elif quiet:
                    print('*** Error compiling {!r}...'.format(fullname))
                else:
                    print('*** ', end='')
                print(e.__class__.__name__ + ':', e)
            else:
                if ok == 0:
                    success = False
    return success

def compile_path(skip_curdir=1, maxlevels=0, force=False, quiet=0,
                 legacy=False, optimize=-1,
                 invalidation_mode=None):
    """Byte-compile all module on sys.path.

Arguments (all optional):

skip_curdir: if true, skip current directory (default True)
    maxlevels:   max recursion level (default 0)
    force: as for compile_dir() (default False)
    quiet: as for compile_dir() (default 0)
    legacy: as for compile_dir() (default False)
    optimize: as for compile_dir() (default -1)
    invalidation_mode: as for compiler_dir()
    """
    success = True
    for dir in sys.path:
        if (not dir or dir == os.curdir) and skip_curdir:
            if quiet < 2:
                print('Skipping current directory')
        else:
            success = success and compile_dir(
                dir,
                maxlevels,
                None,
                force,
                quiet=quiet,
                legacy=legacy,
                optimize=optimize,
                invalidation_mode=invalidation_mode,
            )
    return success

def main():
    """Script main program."""
    import argparse

parser = argparse.ArgumentParser(
        description='Utilities to support installing Python libraries.')
    parser.add_argument('-l', action='store_const', const=0,
                        default=10, dest='maxlevels',
                        help="don't recurse into subdirectories")
    parser.add_argument('-r', type=int, dest='recursion',
                        help=('control the maximum recursion level. '
                              'if `-l` and `-r` options are specified, '
                              'then `-r` takes precedence.'))
    parser.add_argument('-f', action='store_true', dest='force',
                        help='force rebuild even if timestamps are up to date')
    parser.add_argument('-q', action='count', dest='quiet', default=0,
                        help='output only error messages; -qq will suppress '
                             'the error messages as well.')
    parser.add_argument('-b', action='store_true', dest='legacy',
                        help='use legacy (pre-PEP3147) compiled file locations')
    parser.add_argument('-d', metavar='DESTDIR',  dest='ddir', default=None,
                        help=('directory to prepend to file paths for use in '
                              'compile-time tracebacks and in runtime '
                              'tracebacks in cases where the source file is '
                              'unavailable'))
    parser.add_argument('-x', metavar='REGEXP', dest='rx', default=None,
                        help=('skip files matching the regular expression; '
                              'the regexp is searched for in the full path '
                              'of each file considered for compilation'))
    parser.add_argument('-i', metavar='FILE', dest='flist',
                        help=('add all the files and directories listed in '
                              'FILE to the list considered for compilation; '
                              'if "-", names are read from stdin'))
    parser.add_argument('compile_dest', metavar='FILE|DIR', nargs='*',
                        help=('zero or more file and directory names '
                              'to compile; if no arguments given, defaults '
                              'to the equivalent of -l sys.path'))
    parser.add_argument('-j', '--workers', default=1,
                        type=int, help='Run compileall concurrently')
    invalidation_modes = [mode.name.lower().replace('_', '-')
                          for mode in py_compile.PycInvalidationMode]
    parser.add_argument('--invalidation-mode',
                        choices=sorted(invalidation_modes),
                        help=('set .pyc invalidation mode; defaults to '
                              '"checked-hash" if the SOURCE_DATE_EPOCH '
                              'environment variable is set, and '
                              '"timestamp" otherwise.'))

args = parser.parse_args()
    compile_dests = args.compile_dest

if args.rx:
        import re
        args.rx = re.compile(args.rx)

if args.recursion is not None:
        maxlevels = args.recursion
    else:
        maxlevels = args.maxlevels

# if flist is provided then load it
    if args.flist:
        try:
            with (sys.stdin if args.flist=='-' else open(args.flist)) as f:
                for line in f:
                    compile_dests.append(line.strip())
        except OSError:
            if args.quiet < 2:
                print("Error reading file list {}".format(args.flist))
            return False

if args.workers is not None:
        args.workers = args.workers or None

if args.invalidation_mode:
        ivl_mode = args.invalidation_mode.replace('-', '_').upper()
        invalidation_mode = py_compile.PycInvalidationMode[ivl_mode]
    else:
        invalidation_mode = None

success = True
    try:
        if compile_dests:
            for dest in compile_dests:
                if os.path.isfile(dest):
                    if not compile_file(dest, args.ddir, args.force, args.rx,
                                        args.quiet, args.legacy,
                                        invalidation_mode=invalidation_mode):
                        success = False
                else:
                    if not compile_dir(dest, maxlevels, args.ddir,
                                       args.force, args.rx, args.quiet,
                                       args.legacy, workers=args.workers,
                                       invalidation_mode=invalidation_mode):
                        success = False
            return success
        else:
            return compile_path(legacy=args.legacy, force=args.force,
                                quiet=args.quiet,
                                invalidation_mode=invalidation_mode)
    except KeyboardInterrupt:
        if args.quiet < 2:
            print("\n[interrupted]")
        return False
    return True

if __name__ == '__main__':
    exit_status = int(not main())
    sys.exit(exit_status)

X7ROOT File Manager

Editing: compileall.py

Upload File

Create Folder