morel-theme-pack 0.1.31 → 0.1.321

data/assets/env/lib/python3.10/site-packages/pip/_internal/utils/temp_dir.py

@@ -1,246 +0,0 @@
-import errno
-import itertools
-import logging
-import os.path
-import tempfile
-from contextlib import ExitStack, contextmanager
-from typing import Any, Dict, Generator, Optional, TypeVar, Union
-
-from pip._internal.utils.misc import enum, rmtree
-
-logger = logging.getLogger(__name__)
-
-_T = TypeVar("_T", bound="TempDirectory")
-
-
-# Kinds of temporary directories. Only needed for ones that are
-# globally-managed.
-tempdir_kinds = enum(
-    BUILD_ENV="build-env",
-    EPHEM_WHEEL_CACHE="ephem-wheel-cache",
-    REQ_BUILD="req-build",
-)
-
-
-_tempdir_manager: Optional[ExitStack] = None
-
-
-@contextmanager
-def global_tempdir_manager() -> Generator[None, None, None]:
-    global _tempdir_manager
-    with ExitStack() as stack:
-        old_tempdir_manager, _tempdir_manager = _tempdir_manager, stack
-        try:
-            yield
-        finally:
-            _tempdir_manager = old_tempdir_manager
-
-
-class TempDirectoryTypeRegistry:
-    """Manages temp directory behavior"""
-
-    def __init__(self) -> None:
-        self._should_delete: Dict[str, bool] = {}
-
-    def set_delete(self, kind: str, value: bool) -> None:
-        """Indicate whether a TempDirectory of the given kind should be
-        auto-deleted.
-        """
-        self._should_delete[kind] = value
-
-    def get_delete(self, kind: str) -> bool:
-        """Get configured auto-delete flag for a given TempDirectory type,
-        default True.
-        """
-        return self._should_delete.get(kind, True)
-
-
-_tempdir_registry: Optional[TempDirectoryTypeRegistry] = None
-
-
-@contextmanager
-def tempdir_registry() -> Generator[TempDirectoryTypeRegistry, None, None]:
-    """Provides a scoped global tempdir registry that can be used to dictate
-    whether directories should be deleted.
-    """
-    global _tempdir_registry
-    old_tempdir_registry = _tempdir_registry
-    _tempdir_registry = TempDirectoryTypeRegistry()
-    try:
-        yield _tempdir_registry
-    finally:
-        _tempdir_registry = old_tempdir_registry
-
-
-class _Default:
-    pass
-
-
-_default = _Default()
-
-
-class TempDirectory:
-    """Helper class that owns and cleans up a temporary directory.
-
-    This class can be used as a context manager or as an OO representation of a
-    temporary directory.
-
-    Attributes:
-        path
-            Location to the created temporary directory
-        delete
-            Whether the directory should be deleted when exiting
-            (when used as a contextmanager)
-
-    Methods:
-        cleanup()
-            Deletes the temporary directory
-
-    When used as a context manager, if the delete attribute is True, on
-    exiting the context the temporary directory is deleted.
-    """
-
-    def __init__(
-        self,
-        path: Optional[str] = None,
-        delete: Union[bool, None, _Default] = _default,
-        kind: str = "temp",
-        globally_managed: bool = False,
-    ):
-        super().__init__()
-
-        if delete is _default:
-            if path is not None:
-                # If we were given an explicit directory, resolve delete option
-                # now.
-                delete = False
-            else:
-                # Otherwise, we wait until cleanup and see what
-                # tempdir_registry says.
-                delete = None
-
-        # The only time we specify path is in for editables where it
-        # is the value of the --src option.
-        if path is None:
-            path = self._create(kind)
-
-        self._path = path
-        self._deleted = False
-        self.delete = delete
-        self.kind = kind
-
-        if globally_managed:
-            assert _tempdir_manager is not None
-            _tempdir_manager.enter_context(self)
-
-    @property
-    def path(self) -> str:
-        assert not self._deleted, f"Attempted to access deleted path: {self._path}"
-        return self._path
-
-    def __repr__(self) -> str:
-        return f"<{self.__class__.__name__} {self.path!r}>"
-
-    def __enter__(self: _T) -> _T:
-        return self
-
-    def __exit__(self, exc: Any, value: Any, tb: Any) -> None:
-        if self.delete is not None:
-            delete = self.delete
-        elif _tempdir_registry:
-            delete = _tempdir_registry.get_delete(self.kind)
-        else:
-            delete = True
-
-        if delete:
-            self.cleanup()
-
-    def _create(self, kind: str) -> str:
-        """Create a temporary directory and store its path in self.path"""
-        # We realpath here because some systems have their default tmpdir
-        # symlinked to another directory.  This tends to confuse build
-        # scripts, so we canonicalize the path by traversing potential
-        # symlinks here.
-        path = os.path.realpath(tempfile.mkdtemp(prefix=f"pip-{kind}-"))
-        logger.debug("Created temporary directory: %s", path)
-        return path
-
-    def cleanup(self) -> None:
-        """Remove the temporary directory created and reset state"""
-        self._deleted = True
-        if not os.path.exists(self._path):
-            return
-        rmtree(self._path)
-
-
-class AdjacentTempDirectory(TempDirectory):
-    """Helper class that creates a temporary directory adjacent to a real one.
-
-    Attributes:
-        original
-            The original directory to create a temp directory for.
-        path
-            After calling create() or entering, contains the full
-            path to the temporary directory.
-        delete
-            Whether the directory should be deleted when exiting
-            (when used as a contextmanager)
-
-    """
-
-    # The characters that may be used to name the temp directory
-    # We always prepend a ~ and then rotate through these until
-    # a usable name is found.
-    # pkg_resources raises a different error for .dist-info folder
-    # with leading '-' and invalid metadata
-    LEADING_CHARS = "-~.=%0123456789"
-
-    def __init__(self, original: str, delete: Optional[bool] = None) -> None:
-        self.original = original.rstrip("/\\")
-        super().__init__(delete=delete)
-
-    @classmethod
-    def _generate_names(cls, name: str) -> Generator[str, None, None]:
-        """Generates a series of temporary names.
-
-        The algorithm replaces the leading characters in the name
-        with ones that are valid filesystem characters, but are not
-        valid package names (for both Python and pip definitions of
-        package).
-        """
-        for i in range(1, len(name)):
-            for candidate in itertools.combinations_with_replacement(
-                cls.LEADING_CHARS, i - 1
-            ):
-                new_name = "~" + "".join(candidate) + name[i:]
-                if new_name != name:
-                    yield new_name
-
-        # If we make it this far, we will have to make a longer name
-        for i in range(len(cls.LEADING_CHARS)):
-            for candidate in itertools.combinations_with_replacement(
-                cls.LEADING_CHARS, i
-            ):
-                new_name = "~" + "".join(candidate) + name
-                if new_name != name:
-                    yield new_name
-
-    def _create(self, kind: str) -> str:
-        root, name = os.path.split(self.original)
-        for candidate in self._generate_names(name):
-            path = os.path.join(root, candidate)
-            try:
-                os.mkdir(path)
-            except OSError as ex:
-                # Continue if the name exists already
-                if ex.errno != errno.EEXIST:
-                    raise
-            else:
-                path = os.path.realpath(path)
-                break
-        else:
-            # Final fallback on the default behavior.
-            path = os.path.realpath(tempfile.mkdtemp(prefix=f"pip-{kind}-"))
-
-        logger.debug("Created temporary directory: %s", path)
-        return path

data/assets/env/lib/python3.10/site-packages/pip/_internal/utils/unpacking.py

@@ -1,257 +0,0 @@
-"""Utilities related archives.
-"""
-
-import logging
-import os
-import shutil
-import stat
-import tarfile
-import zipfile
-from typing import Iterable, List, Optional
-from zipfile import ZipInfo
-
-from pip._internal.exceptions import InstallationError
-from pip._internal.utils.filetypes import (
-    BZ2_EXTENSIONS,
-    TAR_EXTENSIONS,
-    XZ_EXTENSIONS,
-    ZIP_EXTENSIONS,
-)
-from pip._internal.utils.misc import ensure_dir
-
-logger = logging.getLogger(__name__)
-
-
-SUPPORTED_EXTENSIONS = ZIP_EXTENSIONS + TAR_EXTENSIONS
-
-try:
-    import bz2  # noqa
-
-    SUPPORTED_EXTENSIONS += BZ2_EXTENSIONS
-except ImportError:
-    logger.debug("bz2 module is not available")
-
-try:
-    # Only for Python 3.3+
-    import lzma  # noqa
-
-    SUPPORTED_EXTENSIONS += XZ_EXTENSIONS
-except ImportError:
-    logger.debug("lzma module is not available")
-
-
-def current_umask() -> int:
-    """Get the current umask which involves having to set it temporarily."""
-    mask = os.umask(0)
-    os.umask(mask)
-    return mask
-
-
-def split_leading_dir(path: str) -> List[str]:
-    path = path.lstrip("/").lstrip("\\")
-    if "/" in path and (
-        ("\\" in path and path.find("/") < path.find("\\")) or "\\" not in path
-    ):
-        return path.split("/", 1)
-    elif "\\" in path:
-        return path.split("\\", 1)
-    else:
-        return [path, ""]
-
-
-def has_leading_dir(paths: Iterable[str]) -> bool:
-    """Returns true if all the paths have the same leading path name
-    (i.e., everything is in one subdirectory in an archive)"""
-    common_prefix = None
-    for path in paths:
-        prefix, rest = split_leading_dir(path)
-        if not prefix:
-            return False
-        elif common_prefix is None:
-            common_prefix = prefix
-        elif prefix != common_prefix:
-            return False
-    return True
-
-
-def is_within_directory(directory: str, target: str) -> bool:
-    """
-    Return true if the absolute path of target is within the directory
-    """
-    abs_directory = os.path.abspath(directory)
-    abs_target = os.path.abspath(target)
-
-    prefix = os.path.commonprefix([abs_directory, abs_target])
-    return prefix == abs_directory
-
-
-def set_extracted_file_to_default_mode_plus_executable(path: str) -> None:
-    """
-    Make file present at path have execute for user/group/world
-    (chmod +x) is no-op on windows per python docs
-    """
-    os.chmod(path, (0o777 & ~current_umask() | 0o111))
-
-
-def zip_item_is_executable(info: ZipInfo) -> bool:
-    mode = info.external_attr >> 16
-    # if mode and regular file and any execute permissions for
-    # user/group/world?
-    return bool(mode and stat.S_ISREG(mode) and mode & 0o111)
-
-
-def unzip_file(filename: str, location: str, flatten: bool = True) -> None:
-    """
-    Unzip the file (with path `filename`) to the destination `location`.  All
-    files are written based on system defaults and umask (i.e. permissions are
-    not preserved), except that regular file members with any execute
-    permissions (user, group, or world) have "chmod +x" applied after being
-    written. Note that for windows, any execute changes using os.chmod are
-    no-ops per the python docs.
-    """
-    ensure_dir(location)
-    zipfp = open(filename, "rb")
-    try:
-        zip = zipfile.ZipFile(zipfp, allowZip64=True)
-        leading = has_leading_dir(zip.namelist()) and flatten
-        for info in zip.infolist():
-            name = info.filename
-            fn = name
-            if leading:
-                fn = split_leading_dir(name)[1]
-            fn = os.path.join(location, fn)
-            dir = os.path.dirname(fn)
-            if not is_within_directory(location, fn):
-                message = (
-                    "The zip file ({}) has a file ({}) trying to install "
-                    "outside target directory ({})"
-                )
-                raise InstallationError(message.format(filename, fn, location))
-            if fn.endswith("/") or fn.endswith("\\"):
-                # A directory
-                ensure_dir(fn)
-            else:
-                ensure_dir(dir)
-                # Don't use read() to avoid allocating an arbitrarily large
-                # chunk of memory for the file's content
-                fp = zip.open(name)
-                try:
-                    with open(fn, "wb") as destfp:
-                        shutil.copyfileobj(fp, destfp)
-                finally:
-                    fp.close()
-                    if zip_item_is_executable(info):
-                        set_extracted_file_to_default_mode_plus_executable(fn)
-    finally:
-        zipfp.close()
-
-
-def untar_file(filename: str, location: str) -> None:
-    """
-    Untar the file (with path `filename`) to the destination `location`.
-    All files are written based on system defaults and umask (i.e. permissions
-    are not preserved), except that regular file members with any execute
-    permissions (user, group, or world) have "chmod +x" applied after being
-    written.  Note that for windows, any execute changes using os.chmod are
-    no-ops per the python docs.
-    """
-    ensure_dir(location)
-    if filename.lower().endswith(".gz") or filename.lower().endswith(".tgz"):
-        mode = "r:gz"
-    elif filename.lower().endswith(BZ2_EXTENSIONS):
-        mode = "r:bz2"
-    elif filename.lower().endswith(XZ_EXTENSIONS):
-        mode = "r:xz"
-    elif filename.lower().endswith(".tar"):
-        mode = "r"
-    else:
-        logger.warning(
-            "Cannot determine compression type for file %s",
-            filename,
-        )
-        mode = "r:*"
-    tar = tarfile.open(filename, mode, encoding="utf-8")
-    try:
-        leading = has_leading_dir([member.name for member in tar.getmembers()])
-        for member in tar.getmembers():
-            fn = member.name
-            if leading:
-                fn = split_leading_dir(fn)[1]
-            path = os.path.join(location, fn)
-            if not is_within_directory(location, path):
-                message = (
-                    "The tar file ({}) has a file ({}) trying to install "
-                    "outside target directory ({})"
-                )
-                raise InstallationError(message.format(filename, path, location))
-            if member.isdir():
-                ensure_dir(path)
-            elif member.issym():
-                try:
-                    tar._extract_member(member, path)
-                except Exception as exc:
-                    # Some corrupt tar files seem to produce this
-                    # (specifically bad symlinks)
-                    logger.warning(
-                        "In the tar file %s the member %s is invalid: %s",
-                        filename,
-                        member.name,
-                        exc,
-                    )
-                    continue
-            else:
-                try:
-                    fp = tar.extractfile(member)
-                except (KeyError, AttributeError) as exc:
-                    # Some corrupt tar files seem to produce this
-                    # (specifically bad symlinks)
-                    logger.warning(
-                        "In the tar file %s the member %s is invalid: %s",
-                        filename,
-                        member.name,
-                        exc,
-                    )
-                    continue
-                ensure_dir(os.path.dirname(path))
-                assert fp is not None
-                with open(path, "wb") as destfp:
-                    shutil.copyfileobj(fp, destfp)
-                fp.close()
-                # Update the timestamp (useful for cython compiled files)
-                tar.utime(member, path)
-                # member have any execute permissions for user/group/world?
-                if member.mode & 0o111:
-                    set_extracted_file_to_default_mode_plus_executable(path)
-    finally:
-        tar.close()
-
-
-def unpack_file(
-    filename: str,
-    location: str,
-    content_type: Optional[str] = None,
-) -> None:
-    filename = os.path.realpath(filename)
-    if (
-        content_type == "application/zip"
-        or filename.lower().endswith(ZIP_EXTENSIONS)
-        or zipfile.is_zipfile(filename)
-    ):
-        unzip_file(filename, location, flatten=not filename.endswith(".whl"))
-    elif (
-        content_type == "application/x-gzip"
-        or tarfile.is_tarfile(filename)
-        or filename.lower().endswith(TAR_EXTENSIONS + BZ2_EXTENSIONS + XZ_EXTENSIONS)
-    ):
-        untar_file(filename, location)
-    else:
-        # FIXME: handle?
-        # FIXME: magic signatures?
-        logger.critical(
-            "Cannot unpack file %s (downloaded from %s, content-type: %s); "
-            "cannot detect archive format",
-            filename,
-            location,
-            content_type,
-        )
-        raise InstallationError(f"Cannot determine archive format of {location}")

data/assets/env/lib/python3.10/site-packages/pip/_internal/utils/urls.py

@@ -1,62 +0,0 @@
-import os
-import string
-import urllib.parse
-import urllib.request
-from typing import Optional
-
-from .compat import WINDOWS
-
-
-def get_url_scheme(url: str) -> Optional[str]:
-    if ":" not in url:
-        return None
-    return url.split(":", 1)[0].lower()
-
-
-def path_to_url(path: str) -> str:
-    """
-    Convert a path to a file: URL.  The path will be made absolute and have
-    quoted path parts.
-    """
-    path = os.path.normpath(os.path.abspath(path))
-    url = urllib.parse.urljoin("file:", urllib.request.pathname2url(path))
-    return url
-
-
-def url_to_path(url: str) -> str:
-    """
-    Convert a file: URL to a path.
-    """
-    assert url.startswith(
-        "file:"
-    ), f"You can only turn file: urls into filenames (not {url!r})"
-
-    _, netloc, path, _, _ = urllib.parse.urlsplit(url)
-
-    if not netloc or netloc == "localhost":
-        # According to RFC 8089, same as empty authority.
-        netloc = ""
-    elif WINDOWS:
-        # If we have a UNC path, prepend UNC share notation.
-        netloc = "\\\\" + netloc
-    else:
-        raise ValueError(
-            f"non-local file URIs are not supported on this platform: {url!r}"
-        )
-
-    path = urllib.request.url2pathname(netloc + path)
-
-    # On Windows, urlsplit parses the path as something like "/C:/Users/foo".
-    # This creates issues for path-related functions like io.open(), so we try
-    # to detect and strip the leading slash.
-    if (
-        WINDOWS
-        and not netloc  # Not UNC.
-        and len(path) >= 3
-        and path[0] == "/"  # Leading slash to strip.
-        and path[1] in string.ascii_letters  # Drive letter.
-        and path[2:4] in (":", ":/")  # Colon + end of string, or colon + absolute path.
-    ):
-        path = path[1:]
-
-    return path

data/assets/env/lib/python3.10/site-packages/pip/_internal/utils/virtualenv.py

@@ -1,104 +0,0 @@
-import logging
-import os
-import re
-import site
-import sys
-from typing import List, Optional
-
-logger = logging.getLogger(__name__)
-_INCLUDE_SYSTEM_SITE_PACKAGES_REGEX = re.compile(
-    r"include-system-site-packages\s*=\s*(?P<value>true|false)"
-)
-
-
-def _running_under_venv() -> bool:
-    """Checks if sys.base_prefix and sys.prefix match.
-
-    This handles PEP 405 compliant virtual environments.
-    """
-    return sys.prefix != getattr(sys, "base_prefix", sys.prefix)
-
-
-def _running_under_regular_virtualenv() -> bool:
-    """Checks if sys.real_prefix is set.
-
-    This handles virtual environments created with pypa's virtualenv.
-    """
-    # pypa/virtualenv case
-    return hasattr(sys, "real_prefix")
-
-
-def running_under_virtualenv() -> bool:
-    """Return True if we're running inside a virtualenv, False otherwise."""
-    return _running_under_venv() or _running_under_regular_virtualenv()
-
-
-def _get_pyvenv_cfg_lines() -> Optional[List[str]]:
-    """Reads {sys.prefix}/pyvenv.cfg and returns its contents as list of lines
-
-    Returns None, if it could not read/access the file.
-    """
-    pyvenv_cfg_file = os.path.join(sys.prefix, "pyvenv.cfg")
-    try:
-        # Although PEP 405 does not specify, the built-in venv module always
-        # writes with UTF-8. (pypa/pip#8717)
-        with open(pyvenv_cfg_file, encoding="utf-8") as f:
-            return f.read().splitlines()  # avoids trailing newlines
-    except OSError:
-        return None
-
-
-def _no_global_under_venv() -> bool:
-    """Check `{sys.prefix}/pyvenv.cfg` for system site-packages inclusion
-
-    PEP 405 specifies that when system site-packages are not supposed to be
-    visible from a virtual environment, `pyvenv.cfg` must contain the following
-    line:
-
-        include-system-site-packages = false
-
-    Additionally, log a warning if accessing the file fails.
-    """
-    cfg_lines = _get_pyvenv_cfg_lines()
-    if cfg_lines is None:
-        # We're not in a "sane" venv, so assume there is no system
-        # site-packages access (since that's PEP 405's default state).
-        logger.warning(
-            "Could not access 'pyvenv.cfg' despite a virtual environment "
-            "being active. Assuming global site-packages is not accessible "
-            "in this environment."
-        )
-        return True
-
-    for line in cfg_lines:
-        match = _INCLUDE_SYSTEM_SITE_PACKAGES_REGEX.match(line)
-        if match is not None and match.group("value") == "false":
-            return True
-    return False
-
-
-def _no_global_under_regular_virtualenv() -> bool:
-    """Check if "no-global-site-packages.txt" exists beside site.py
-
-    This mirrors logic in pypa/virtualenv for determining whether system
-    site-packages are visible in the virtual environment.
-    """
-    site_mod_dir = os.path.dirname(os.path.abspath(site.__file__))
-    no_global_site_packages_file = os.path.join(
-        site_mod_dir,
-        "no-global-site-packages.txt",
-    )
-    return os.path.exists(no_global_site_packages_file)
-
-
-def virtualenv_no_global() -> bool:
-    """Returns a boolean, whether running in venv with no system site-packages."""
-    # PEP 405 compliance needs to be checked first since virtualenv >=20 would
-    # return True for both checks, but is only able to use the PEP 405 config.
-    if _running_under_venv():
-        return _no_global_under_venv()
-
-    if _running_under_regular_virtualenv():
-        return _no_global_under_regular_virtualenv()
-
-    return False