File Manager

X7ROOT File Manager

Current Path: /opt/alt/python310/lib64/python3.10

opt / alt / python310 / lib64 / python3.10 /

ðŸ“ ..
ðŸ“„ LICENSE.txt(13.61 KB)
ðŸ“„ __future__.py(5.03 KB)
ðŸ“„ __phello__.foo.py(64 B)
ðŸ“ __pycache__
ðŸ“„ _aix_support.py(3.19 KB)
ðŸ“„ _bootsubprocess.py(2.61 KB)
ðŸ“„ _collections_abc.py(31.53 KB)
ðŸ“„ _compat_pickle.py(8.54 KB)
ðŸ“„ _compression.py(5.55 KB)
ðŸ“„ _markupbase.py(14.31 KB)
ðŸ“„ _osx_support.py(21.28 KB)
ðŸ“„ _py_abc.py(6.04 KB)
ðŸ“„ _pydecimal.py(223.32 KB)
ðŸ“„ _pyio.py(92.25 KB)
ðŸ“„ _sitebuiltins.py(3.05 KB)
ðŸ“„ _strptime.py(24.68 KB)
ðŸ“„ _sysconfigdata__linux_x86_64-linux-gnu.py(40.38 KB)
ðŸ“„ _sysconfigdata_d_linux_x86_64-linux-gnu.py(39.81 KB)
ðŸ“„ _threading_local.py(7.05 KB)
ðŸ“„ _weakrefset.py(5.78 KB)
ðŸ“„ abc.py(6.37 KB)
ðŸ“„ aifc.py(31.84 KB)
ðŸ“„ antigravity.py(500 B)
ðŸ“„ argparse.py(96.23 KB)
ðŸ“„ ast.py(58.5 KB)
ðŸ“„ asynchat.py(11.25 KB)
ðŸ“ asyncio
ðŸ“„ asyncore.py(19.79 KB)
ðŸ“„ base64.py(20.37 KB)
ðŸ“„ bdb.py(31.64 KB)
ðŸ“„ binhex.py(14.44 KB)
ðŸ“„ bisect.py(3.06 KB)
ðŸ“„ bz2.py(11.57 KB)
ðŸ“„ cProfile.py(6.21 KB)
ðŸ“„ calendar.py(24 KB)
ðŸ“„ cgi.py(33.31 KB)
ðŸ“„ cgitb.py(11.81 KB)
ðŸ“„ chunk.py(5.31 KB)
ðŸ“„ cmd.py(14.51 KB)
ðŸ“„ code.py(10.37 KB)
ðŸ“„ codecs.py(35.85 KB)
ðŸ“„ codeop.py(5.48 KB)
ðŸ“ collections
ðŸ“„ colorsys.py(3.92 KB)
ðŸ“„ compileall.py(19.78 KB)
ðŸ“ concurrent
ðŸ“ config-3.10-x86_64-linux-gnu
ðŸ“„ configparser.py(53.33 KB)
ðŸ“„ contextlib.py(25.28 KB)
ðŸ“„ contextvars.py(129 B)
ðŸ“„ copy.py(8.48 KB)
ðŸ“„ copyreg.py(7.25 KB)
ðŸ“„ crypt.py(3.76 KB)
ðŸ“„ csv.py(15.65 KB)
ðŸ“ ctypes
ðŸ“ curses
ðŸ“„ dataclasses.py(55.07 KB)
ðŸ“„ datetime.py(86.02 KB)
ðŸ“ dbm
ðŸ“„ decimal.py(320 B)
ðŸ“„ difflib.py(81.36 KB)
ðŸ“„ dis.py(19.55 KB)
ðŸ“ distutils
ðŸ“„ doctest.py(102.68 KB)
ðŸ“ email
ðŸ“ encodings
ðŸ“ ensurepip
ðŸ“„ enum.py(38.9 KB)
ðŸ“„ filecmp.py(9.94 KB)
ðŸ“„ fileinput.py(16.06 KB)
ðŸ“„ fnmatch.py(6.56 KB)
ðŸ“„ fractions.py(27.58 KB)
ðŸ“„ ftplib.py(34.66 KB)
ðŸ“„ functools.py(37.18 KB)
ðŸ“„ genericpath.py(4.86 KB)
ðŸ“„ getopt.py(7.31 KB)
ðŸ“„ getpass.py(5.85 KB)
ðŸ“„ gettext.py(26.63 KB)
ðŸ“„ glob.py(7.7 KB)
ðŸ“„ graphlib.py(9.35 KB)
ðŸ“„ gzip.py(21.34 KB)
ðŸ“„ hashlib.py(9.99 KB)
ðŸ“„ heapq.py(22.34 KB)
ðŸ“„ hmac.py(7.54 KB)
ðŸ“ html
ðŸ“ http
ðŸ“„ imaplib.py(53.92 KB)
ðŸ“„ imghdr.py(3.72 KB)
ðŸ“„ imp.py(10.34 KB)
ðŸ“ importlib
ðŸ“„ inspect.py(121.46 KB)
ðŸ“„ io.py(4.1 KB)
ðŸ“„ ipaddress.py(76.71 KB)
ðŸ“ json
ðŸ“„ keyword.py(1.04 KB)
ðŸ“ lib-dynload
ðŸ“ lib2to3
ðŸ“„ linecache.py(5.56 KB)
ðŸ“„ locale.py(76.29 KB)
ðŸ“ logging
ðŸ“„ lzma.py(12.97 KB)
ðŸ“„ mailbox.py(76.95 KB)
ðŸ“„ mailcap.py(8.9 KB)
ðŸ“„ mimetypes.py(22.01 KB)
ðŸ“„ modulefinder.py(23.83 KB)
ðŸ“ multiprocessing
ðŸ“„ netrc.py(5.61 KB)
ðŸ“„ nntplib.py(40.06 KB)
ðŸ“„ ntpath.py(28.79 KB)
ðŸ“„ nturl2path.py(2.82 KB)
ðŸ“„ numbers.py(10.11 KB)
ðŸ“„ opcode.py(5.76 KB)
ðŸ“„ operator.py(10.5 KB)
ðŸ“„ optparse.py(58.95 KB)
ðŸ“„ os.py(38.63 KB)
ðŸ“„ pathlib.py(48.41 KB)
ðŸ“„ pdb.py(61.76 KB)
ðŸ“„ pickle.py(63.43 KB)
ðŸ“„ pickletools.py(91.29 KB)
ðŸ“„ pipes.py(8.71 KB)
ðŸ“„ pkgutil.py(24 KB)
ðŸ“„ platform.py(41.05 KB)
ðŸ“„ plistlib.py(27.69 KB)
ðŸ“„ poplib.py(14.84 KB)
ðŸ“„ posixpath.py(15.87 KB)
ðŸ“„ pprint.py(23.87 KB)
ðŸ“„ profile.py(22.36 KB)
ðŸ“„ pstats.py(28.64 KB)
ðŸ“„ pty.py(5.09 KB)
ðŸ“„ py_compile.py(7.71 KB)
ðŸ“„ pyclbr.py(11.13 KB)
ðŸ“„ pydoc.py(107.03 KB)
ðŸ“ pydoc_data
ðŸ“„ queue.py(11.23 KB)
ðŸ“„ quopri.py(7.11 KB)
ðŸ“„ random.py(32.44 KB)
ðŸ“„ re.py(15.49 KB)
ðŸ“„ reprlib.py(5.14 KB)
ðŸ“„ rlcompleter.py(7.63 KB)
ðŸ“„ runpy.py(12.8 KB)
ðŸ“„ sched.py(6.2 KB)
ðŸ“„ secrets.py(1.99 KB)
ðŸ“„ selectors.py(19.08 KB)
ðŸ“„ shelve.py(8.36 KB)
ðŸ“„ shlex.py(13.18 KB)
ðŸ“„ shutil.py(53.29 KB)
ðŸ“„ signal.py(2.38 KB)
ðŸ“ site-packages
ðŸ“„ site.py(22.39 KB)
ðŸ“„ smtpd.py(34.35 KB)
ðŸ“„ smtplib.py(44.37 KB)
ðŸ“„ sndhdr.py(6.93 KB)
ðŸ“„ socket.py(36.14 KB)
ðŸ“„ socketserver.py(26.66 KB)
ðŸ“ sqlite3
ðŸ“„ sre_compile.py(27.32 KB)
ðŸ“„ sre_constants.py(7.01 KB)
ðŸ“„ sre_parse.py(39.82 KB)
ðŸ“„ ssl.py(52.63 KB)
ðŸ“„ stat.py(5.36 KB)
ðŸ“„ statistics.py(42.19 KB)
ðŸ“„ string.py(10.32 KB)
ðŸ“„ stringprep.py(12.61 KB)
ðŸ“„ struct.py(257 B)
ðŸ“„ subprocess.py(82.93 KB)
ðŸ“„ sunau.py(17.73 KB)
ðŸ“„ symtable.py(9.98 KB)
ðŸ“„ sysconfig.py(26.96 KB)
ðŸ“„ tabnanny.py(11.05 KB)
ðŸ“„ tarfile.py(105.13 KB)
ðŸ“„ telnetlib.py(22.71 KB)
ðŸ“„ tempfile.py(28.78 KB)
ðŸ“„ textwrap.py(19.31 KB)
ðŸ“„ this.py(1003 B)
ðŸ“„ threading.py(55.41 KB)
ðŸ“„ timeit.py(13.19 KB)
ðŸ“„ token.py(2.33 KB)
ðŸ“„ tokenize.py(25.31 KB)
ðŸ“„ trace.py(28.54 KB)
ðŸ“„ traceback.py(25.61 KB)
ðŸ“„ tracemalloc.py(17.62 KB)
ðŸ“„ tty.py(879 B)
ðŸ“„ types.py(9.88 KB)
ðŸ“„ typing.py(90.39 KB)
ðŸ“ unittest
ðŸ“ urllib
ðŸ“„ uu.py(7.11 KB)
ðŸ“„ uuid.py(26.86 KB)
ðŸ“ venv
ðŸ“„ warnings.py(19.23 KB)
ðŸ“„ wave.py(17.58 KB)
ðŸ“„ weakref.py(21.05 KB)
ðŸ“„ webbrowser.py(23.69 KB)
ðŸ“ wsgiref
ðŸ“„ xdrlib.py(5.77 KB)
ðŸ“ xml
ðŸ“ xmlrpc
ðŸ“„ zipapp.py(7.36 KB)
ðŸ“„ zipfile.py(88.09 KB)
ðŸ“„ zipimport.py(30.17 KB)
ðŸ“ zoneinfo

Editing: zipapp.py

import contextlib
import os
import pathlib
import shutil
import stat
import sys
import zipfile

__all__ = ['ZipAppError', 'create_archive', 'get_interpreter']

# The __main__.py used if the users specifies "-m module:fn".
# Note that this will always be written as UTF-8 (module and
# function names can be non-ASCII in Python 3).
# We add a coding cookie even though UTF-8 is the default in Python 3
# because the resulting archive may be intended to be run under Python 2.
MAIN_TEMPLATE = """\
# -*- coding: utf-8 -*-
import {module}
{module}.{fn}()
"""

# The Windows launcher defaults to UTF-8 when parsing shebang lines if the
# file has no BOM. So use UTF-8 on Windows.
# On Unix, use the filesystem encoding.
if sys.platform.startswith('win'):
    shebang_encoding = 'utf-8'
else:
    shebang_encoding = sys.getfilesystemencoding()

class ZipAppError(ValueError):
    pass

@contextlib.contextmanager
def _maybe_open(archive, mode):
    if isinstance(archive, (str, os.PathLike)):
        with open(archive, mode) as f:
            yield f
    else:
        yield archive

def _write_file_prefix(f, interpreter):
    """Write a shebang line."""
    if interpreter:
        shebang = b'#!' + interpreter.encode(shebang_encoding) + b'\n'
        f.write(shebang)

def _copy_archive(archive, new_archive, interpreter=None):
    """Copy an application archive, modifying the shebang line."""
    with _maybe_open(archive, 'rb') as src:
        # Skip the shebang line from the source.
        # Read 2 bytes of the source and check if they are #!.
        first_2 = src.read(2)
        if first_2 == b'#!':
            # Discard the initial 2 bytes and the rest of the shebang line.
            first_2 = b''
            src.readline()

with _maybe_open(new_archive, 'wb') as dst:
            _write_file_prefix(dst, interpreter)
            # If there was no shebang, "first_2" contains the first 2 bytes
            # of the source file, so write them before copying the rest
            # of the file.
            dst.write(first_2)
            shutil.copyfileobj(src, dst)

if interpreter and isinstance(new_archive, str):
        os.chmod(new_archive, os.stat(new_archive).st_mode | stat.S_IEXEC)

def create_archive(source, target=None, interpreter=None, main=None,
                   filter=None, compressed=False):
    """Create an application archive from SOURCE.

The SOURCE can be the name of a directory, or a filename or a file-like
    object referring to an existing archive.

The content of SOURCE is packed into an application archive in TARGET,
    which can be a filename or a file-like object.  If SOURCE is a directory,
    TARGET can be omitted and will default to the name of SOURCE with .pyz
    appended.

The created application archive will have a shebang line specifying
    that it should run with INTERPRETER (there will be no shebang line if
    INTERPRETER is None), and a __main__.py which runs MAIN (if MAIN is
    not specified, an existing __main__.py will be used).  It is an error
    to specify MAIN for anything other than a directory source with no
    __main__.py, and it is an error to omit MAIN if the directory has no
    __main__.py.
    """
    # Are we copying an existing archive?
    source_is_file = False
    if hasattr(source, 'read') and hasattr(source, 'readline'):
        source_is_file = True
    else:
        source = pathlib.Path(source)
        if source.is_file():
            source_is_file = True

if source_is_file:
        _copy_archive(source, target, interpreter)
        return

# We are creating a new archive from a directory.
    if not source.exists():
        raise ZipAppError("Source does not exist")
    has_main = (source / '__main__.py').is_file()
    if main and has_main:
        raise ZipAppError(
            "Cannot specify entry point if the source has __main__.py")
    if not (main or has_main):
        raise ZipAppError("Archive has no entry point")

main_py = None
    if main:
        # Check that main has the right format.
        mod, sep, fn = main.partition(':')
        mod_ok = all(part.isidentifier() for part in mod.split('.'))
        fn_ok = all(part.isidentifier() for part in fn.split('.'))
        if not (sep == ':' and mod_ok and fn_ok):
            raise ZipAppError("Invalid entry point: " + main)
        main_py = MAIN_TEMPLATE.format(module=mod, fn=fn)

if target is None:
        target = source.with_suffix('.pyz')
    elif not hasattr(target, 'write'):
        target = pathlib.Path(target)

with _maybe_open(target, 'wb') as fd:
        _write_file_prefix(fd, interpreter)
        compression = (zipfile.ZIP_DEFLATED if compressed else
                       zipfile.ZIP_STORED)
        with zipfile.ZipFile(fd, 'w', compression=compression) as z:
            for child in source.rglob('*'):
                arcname = child.relative_to(source)
                if filter is None or filter(arcname):
                    z.write(child, arcname.as_posix())
            if main_py:
                z.writestr('__main__.py', main_py.encode('utf-8'))

if interpreter and not hasattr(target, 'write'):
        target.chmod(target.stat().st_mode | stat.S_IEXEC)

def get_interpreter(archive):
    with _maybe_open(archive, 'rb') as f:
        if f.read(2) == b'#!':
            return f.readline().strip().decode(shebang_encoding)

def main(args=None):
    """Run the zipapp command line interface.

The ARGS parameter lets you specify the argument list directly.
    Omitting ARGS (or setting it to None) works as for argparse, using
    sys.argv[1:] as the argument list.
    """
    import argparse

parser = argparse.ArgumentParser()
    parser.add_argument('--output', '-o', default=None,
            help="The name of the output archive. "
                 "Required if SOURCE is an archive.")
    parser.add_argument('--python', '-p', default=None,
            help="The name of the Python interpreter to use "
                 "(default: no shebang line).")
    parser.add_argument('--main', '-m', default=None,
            help="The main function of the application "
                 "(default: use an existing __main__.py).")
    parser.add_argument('--compress', '-c', action='store_true',
            help="Compress files with the deflate method. "
                 "Files are stored uncompressed by default.")
    parser.add_argument('--info', default=False, action='store_true',
            help="Display the interpreter from the archive.")
    parser.add_argument('source',
            help="Source directory (or existing archive).")

args = parser.parse_args(args)

# Handle `python -m zipapp archive.pyz --info`.
    if args.info:
        if not os.path.isfile(args.source):
            raise SystemExit("Can only get info for an archive file")
        interpreter = get_interpreter(args.source)
        print("Interpreter: {}".format(interpreter or "<none>"))
        sys.exit(0)

if os.path.isfile(args.source):
        if args.output is None or (os.path.exists(args.output) and
                                   os.path.samefile(args.source, args.output)):
            raise SystemExit("In-place editing of archives is not supported")
        if args.main:
            raise SystemExit("Cannot change the main function when copying")

create_archive(args.source, args.output,
                   interpreter=args.python, main=args.main,
                   compressed=args.compress)

if __name__ == '__main__':
    main()

X7ROOT File Manager

Editing: zipapp.py

Upload File

Create Folder