Na}{

Path: ~//proc/thread-self/root/proc/thread-self/root/opt/alt/python37/lib/python3.7/site-packages/

File Content: `zipp.py`

import io
import posixpath
import zipfile
import itertools
import contextlib
import sys
import pathlib

if sys.version_info < (3, 7):
    from collections import OrderedDict
else:
    OrderedDict = dict


__all__ = ['Path']


def _parents(path):
    """
    Given a path with elements separated by
    posixpath.sep, generate all parents of that path.

    >>> list(_parents('b/d'))
    ['b']
    >>> list(_parents('/b/d/'))
    ['/b']
    >>> list(_parents('b/d/f/'))
    ['b/d', 'b']
    >>> list(_parents('b'))
    []
    >>> list(_parents(''))
    []
    """
    return itertools.islice(_ancestry(path), 1, None)


def _ancestry(path):
    """
    Given a path with elements separated by
    posixpath.sep, generate all elements of that path

    >>> list(_ancestry('b/d'))
    ['b/d', 'b']
    >>> list(_ancestry('/b/d/'))
    ['/b/d', '/b']
    >>> list(_ancestry('b/d/f/'))
    ['b/d/f', 'b/d', 'b']
    >>> list(_ancestry('b'))
    ['b']
    >>> list(_ancestry(''))
    []
    """
    path = path.rstrip(posixpath.sep)
    while path and path != posixpath.sep:
        yield path
        path, tail = posixpath.split(path)


_dedupe = OrderedDict.fromkeys
"""Deduplicate an iterable in original order"""


def _difference(minuend, subtrahend):
    """
    Return items in minuend not in subtrahend, retaining order
    with O(1) lookup.
    """
    return itertools.filterfalse(set(subtrahend).__contains__, minuend)


class CompleteDirs(zipfile.ZipFile):
    """
    A ZipFile subclass that ensures that implied directories
    are always included in the namelist.
    """

    @staticmethod
    def _implied_dirs(names):
        parents = itertools.chain.from_iterable(map(_parents, names))
        as_dirs = (p + posixpath.sep for p in parents)
        return _dedupe(_difference(as_dirs, names))

    def namelist(self):
        names = super(CompleteDirs, self).namelist()
        return names + list(self._implied_dirs(names))

    def _name_set(self):
        return set(self.namelist())

    def resolve_dir(self, name):
        """
        If the name represents a directory, return that name
        as a directory (with the trailing slash).
        """
        names = self._name_set()
        dirname = name + '/'
        dir_match = name not in names and dirname in names
        return dirname if dir_match else name

    @classmethod
    def make(cls, source):
        """
        Given a source (filename or zipfile), return an
        appropriate CompleteDirs subclass.
        """
        if isinstance(source, CompleteDirs):
            return source

        if not isinstance(source, zipfile.ZipFile):
            return cls(_pathlib_compat(source))

        # Only allow for FastLookup when supplied zipfile is read-only
        if 'r' not in source.mode:
            cls = CompleteDirs

        source.__class__ = cls
        return source


class FastLookup(CompleteDirs):
    """
    ZipFile subclass to ensure implicit
    dirs exist and are resolved rapidly.
    """

    def namelist(self):
        with contextlib.suppress(AttributeError):
            return self.__names
        self.__names = super(FastLookup, self).namelist()
        return self.__names

    def _name_set(self):
        with contextlib.suppress(AttributeError):
            return self.__lookup
        self.__lookup = super(FastLookup, self)._name_set()
        return self.__lookup


def _pathlib_compat(path):
    """
    For path-like objects, convert to a filename for compatibility
    on Python 3.6.1 and earlier.
    """
    try:
        return path.__fspath__()
    except AttributeError:
        return str(path)


class Path:
    """
    A pathlib-compatible interface for zip files.

    Consider a zip file with this structure::

        .
        ├── a.txt
        └── b
            ├── c.txt
            └── d
                └── e.txt

    >>> data = io.BytesIO()
    >>> zf = zipfile.ZipFile(data, 'w')
    >>> zf.writestr('a.txt', 'content of a')
    >>> zf.writestr('b/c.txt', 'content of c')
    >>> zf.writestr('b/d/e.txt', 'content of e')
    >>> zf.filename = 'mem/abcde.zip'

    Path accepts the zipfile object itself or a filename

    >>> root = Path(zf)

    From there, several path operations are available.

    Directory iteration (including the zip file itself):

    >>> a, b = root.iterdir()
    >>> a
    Path('mem/abcde.zip', 'a.txt')
    >>> b
    Path('mem/abcde.zip', 'b/')

    name property:

    >>> b.name
    'b'

    join with divide operator:

    >>> c = b / 'c.txt'
    >>> c
    Path('mem/abcde.zip', 'b/c.txt')
    >>> c.name
    'c.txt'

    Read text:

    >>> c.read_text()
    'content of c'

    existence:

    >>> c.exists()
    True
    >>> (b / 'missing.txt').exists()
    False

    Coercion to string:

    >>> import os
    >>> str(c).replace(os.sep, posixpath.sep)
    'mem/abcde.zip/b/c.txt'

    At the root, ``name``, ``filename``, and ``parent``
    resolve to the zipfile. Note these attributes are not
    valid and will raise a ``ValueError`` if the zipfile
    has no filename.

    >>> root.name
    'abcde.zip'
    >>> str(root.filename).replace(os.sep, posixpath.sep)
    'mem/abcde.zip'
    >>> str(root.parent)
    'mem'
    """

    __repr = "{self.__class__.__name__}({self.root.filename!r}, {self.at!r})"

    def __init__(self, root, at=""):
        """
        Construct a Path from a ZipFile or filename.

        Note: When the source is an existing ZipFile object,
        its type (__class__) will be mutated to a
        specialized type. If the caller wishes to retain the
        original type, the caller should either create a
        separate ZipFile object or pass a filename.
        """
        self.root = FastLookup.make(root)
        self.at = at

    def open(self, mode='r', *args, pwd=None, **kwargs):
        """
        Open this entry as text or binary following the semantics
        of ``pathlib.Path.open()`` by passing arguments through
        to io.TextIOWrapper().
        """
        if self.is_dir():
            raise IsADirectoryError(self)
        zip_mode = mode[0]
        if not self.exists() and zip_mode == 'r':
            raise FileNotFoundError(self)
        stream = self.root.open(self.at, zip_mode, pwd=pwd)
        if 'b' in mode:
            if args or kwargs:
                raise ValueError("encoding args invalid for binary operation")
            return stream
        return io.TextIOWrapper(stream, *args, **kwargs)

    @property
    def name(self):
        return pathlib.Path(self.at).name or self.filename.name

    @property
    def suffix(self):
        return pathlib.Path(self.at).suffix or self.filename.suffix

    @property
    def suffixes(self):
        return pathlib.Path(self.at).suffixes or self.filename.suffixes

    @property
    def stem(self):
        return pathlib.Path(self.at).stem or self.filename.stem

    @property
    def filename(self):
        return pathlib.Path(self.root.filename).joinpath(self.at)

    def read_text(self, *args, **kwargs):
        with self.open('r', *args, **kwargs) as strm:
            return strm.read()

    def read_bytes(self):
        with self.open('rb') as strm:
            return strm.read()

    def _is_child(self, path):
        return posixpath.dirname(path.at.rstrip("/")) == self.at.rstrip("/")

    def _next(self, at):
        return self.__class__(self.root, at)

    def is_dir(self):
        return not self.at or self.at.endswith("/")

    def is_file(self):
        return self.exists() and not self.is_dir()

    def exists(self):
        return self.at in self.root._name_set()

    def iterdir(self):
        if not self.is_dir():
            raise ValueError("Can't listdir a file")
        subs = map(self._next, self.root.namelist())
        return filter(self._is_child, subs)

    def __str__(self):
        return posixpath.join(self.root.filename, self.at)

    def __repr__(self):
        return self.__repr.format(self=self)

    def joinpath(self, *other):
        next = posixpath.join(self.at, *map(_pathlib_compat, other))
        return self._next(self.root.resolve_dir(next))

    __truediv__ = joinpath

    @property
    def parent(self):
        if not self.at:
            return self.filename.parent
        parent_at = posixpath.dirname(self.at.rstrip('/'))
        if parent_at:
            parent_at += '/'
        return self._next(parent_at)

Edit Rename Chmod Delete

FILE FOLDER

Name	Size	Permission
Babel-2.9.1-py3.7.egg-info	---	0755
Beaker-1.11.0-py3.7.egg-info	---	0755
Jinja2-3.0.3-py3.7.egg-info	---	0755
Mako-1.1.0-py3.7.egg-info	---	0755
OpenSSL	---	0755
Paste-1.7.5.1-py3.7.egg-info	---	0755
PyJWT-1.7.1-py3.7.egg-info	---	0755
Tempita-0.5.1-py3.7.egg-info	---	0755
__pycache__	---	0755
_distutils_hack	---	0755
aiosignal	---	0755
aiosignal-1.2.0a0-py3.7.egg-info	---	0755
alembic	---	0755
alembic-0.8.3-py3.7.egg-info	---	0755
asn1crypto	---	0755
asn1crypto-0.22.0-py3.7.egg-info	---	0755
async_timeout	---	0755
async_timeout-4.0.2-py3.7.egg-info	---	0755
attr	---	0755
attrs-21.2.0-py3.7.egg-info	---	0755
babel	---	0755
beaker	---	0755
beautifulsoup4-4.5.1-py3.7.egg-info	---	0755
bs4	---	0755
certifi	---	0755
certifi-2018.4.16-py3.7.egg-info	---	0755
chardet	---	0755
chardet-3.0.4-py3.7.egg-info	---	0755
charset_normalizer	---	0755
charset_normalizer-2.0.12-py3.7.egg-info	---	0755
cl_dom_collector	---	0755
clcommon	---	0755
clconfig	---	0755
clconfigure	---	0755
cldashboard	---	0755
clevents	---	0755
cllimits_validator	---	0755
cllimitslib_v2	---	0755
clquota	---	0755
clselect	---	0755
clselector	---	0755
clsentry	---	0755
clsummary	---	0755
clveconfig	---	0755
clwizard	---	0755
cssselect	---	0755
cssselect-0.9.2-py3.7.egg-info	---	0755
distlib	---	0755
docopt-0.6.2-py3.7.egg-info	---	0755
filelock	---	0755
filelock-0.0.0-py3.7.egg-info	---	0755
future	---	0755
future-0.17.0-py3.7.egg-info	---	0755
html5lib	---	0755
html5lib-1.0.1-py3.7.egg-info	---	0755
idna	---	0755
idna-2.5-py3.7.egg-info	---	0755
importlib_metadata	---	0755
importlib_metadata-0.0.0-py3.7.egg-info	---	0755
jinja2	---	0755
jsonschema	---	0755
jsonschema-3.2.0-py3.7.egg-info	---	0755
jwt	---	0755
libfuturize	---	0755
libpasteurize	---	0755
lve_utils	---	0755
lvemanager	---	0755
lvestats	---	0755
mako	---	0755
nose	---	0755
nose-1.3.7-py3.7.egg-info	---	0755
packaging	---	0755
packaging-16.8-py3.7.egg-info	---	0755
past	---	0755
paste	---	0755
pip	---	0755
pip-20.2.4.dist-info	---	0755
pkg_resources	---	0755
platformdirs	---	0755
platformdirs-0.0.0-py3.7.egg-info	---	0755
ply	---	0755
ply-3.8-py3.7.egg-info	---	0755
prettytable-0.7.2-py3.7.egg-info	---	0755
pyOpenSSL-17.3.0-py3.7.egg-info	---	0755
pycparser	---	0755
pycparser-2.14-py3.7.egg-info	---	0755
pyparsing	---	0755
pyparsing-3.0.9.dist-info	---	0755
python_editor-0.4-py3.7.egg-info	---	0755
pytz	---	0755
pytz-2017.2-py3.7.egg-info	---	0755
raven	---	0755
raven-6.3.0-py3.7.egg-info	---	0755
requests	---	0755
requests-2.26.0-py3.7.egg-info	---	0755
schema-0.7.1-py3.7.egg-info	---	0755
sentry_sdk	---	0755
sentry_sdk-0.19.4-py3.7.egg-info	---	0755
setuptools	---	0755
setuptools-58.3.0.dist-info	---	0755
six-1.15.0-py3.7.egg-info	---	0755
ssa	---	0755
svgwrite	---	0755
svgwrite-1.3.0-py3.7.egg-info	---	0755
tempita	---	0755
typing_extensions-3.7.4.3-py3.7.egg-info	---	0755
urllib3	---	0755
urllib3-1.26.6-py3.7.egg-info	---	0755
vendors_api	---	0755
virtualenv	---	0755
virtualenv-20.13.0-py3.7.egg-info	---	0755
webencodings	---	0755
webencodings-0.5.1-py3.7.egg-info	---	0755
zipp-0.0.0-py3.7.egg-info	---	0755
Paste-1.7.5.1-py3.7-nspkg.pth	534 bytes	0644
PySocks-1.5.7-py3.7.egg-info	322 bytes	0644
distlib-0.3.4-py3.7.egg-info	1162 bytes	0644
distutils-precedence.pth	152 bytes	0644
docopt.py	19946 bytes	0644
editor.py	2550 bytes	0755
prettytable.py	54204 bytes	0644
schema.py	29198 bytes	0644
six.py	34159 bytes	0644
socks.py	29952 bytes	0644
sockshandler.py	2913 bytes	0644
typing-3.5.3.0-py3.7.egg-info	1484 bytes	0644
typing.py	70677 bytes	0644
typing_extensions.py	83727 bytes	0644
zipp.py	8425 bytes	0644

File Content: zipp.py

File Content: `zipp.py`