cli-ih 0.6.3.1__py3-none-any.whl → 0.7.1__py3-none-any.whl

venv/Lib/site-packages/pip/__pip-runner__.py

@@ -1,50 +0,0 @@
-"""Execute exactly this copy of pip, within a different environment.
-
-This file is named as it is, to ensure that this module can't be imported via
-an import statement.
-"""
-
-# /!\ This version compatibility check section must be Python 2 compatible. /!\
-
-import sys
-
-# Copied from pyproject.toml
-PYTHON_REQUIRES = (3, 9)
-
-
-def version_str(version):  # type: ignore
-    return ".".join(str(v) for v in version)
-
-
-if sys.version_info[:2] < PYTHON_REQUIRES:
-    raise SystemExit(
-        "This version of pip does not support python {} (requires >={}).".format(
-            version_str(sys.version_info[:2]), version_str(PYTHON_REQUIRES)
-        )
-    )
-
-# From here on, we can use Python 3 features, but the syntax must remain
-# Python 2 compatible.
-
-import runpy  # noqa: E402
-from importlib.machinery import PathFinder  # noqa: E402
-from os.path import dirname  # noqa: E402
-
-PIP_SOURCES_ROOT = dirname(dirname(__file__))
-
-
-class PipImportRedirectingFinder:
-    @classmethod
-    def find_spec(self, fullname, path=None, target=None):  # type: ignore
-        if fullname != "pip":
-            return None
-
-        spec = PathFinder.find_spec(fullname, [PIP_SOURCES_ROOT], target)
-        assert spec, (PIP_SOURCES_ROOT, fullname)
-        return spec
-
-
-sys.meta_path.insert(0, PipImportRedirectingFinder())
-
-assert __name__ == "__main__", "Cannot run __pip-runner__.py as a non-main module"
-runpy.run_module("pip", run_name="__main__", alter_sys=True)

venv/Lib/site-packages/pip/_internal/__init__.py

@@ -1,18 +0,0 @@
-from __future__ import annotations
-
-from pip._internal.utils import _log
-
-# init_logging() must be called before any call to logging.getLogger()
-# which happens at import of most modules.
-_log.init_logging()
-
-
-def main(args: list[str] | None = None) -> int:
-    """This is preserved for old console scripts that may still be referencing
-    it.
-
-    For additional details, see https://github.com/pypa/pip/issues/7498.
-    """
-    from pip._internal.utils.entrypoints import _wrapper
-
-    return _wrapper(args)

venv/Lib/site-packages/pip/_internal/build_env.py

@@ -1,349 +0,0 @@
-"""Build Environment used for isolation during sdist building"""
-
-from __future__ import annotations
-
-import logging
-import os
-import pathlib
-import site
-import sys
-import textwrap
-from collections import OrderedDict
-from collections.abc import Iterable
-from types import TracebackType
-from typing import TYPE_CHECKING, Protocol
-
-from pip._vendor.packaging.version import Version
-
-from pip import __file__ as pip_location
-from pip._internal.cli.spinners import open_spinner
-from pip._internal.locations import get_platlib, get_purelib, get_scheme
-from pip._internal.metadata import get_default_environment, get_environment
-from pip._internal.utils.logging import VERBOSE
-from pip._internal.utils.packaging import get_requirement
-from pip._internal.utils.subprocess import call_subprocess
-from pip._internal.utils.temp_dir import TempDirectory, tempdir_kinds
-
-if TYPE_CHECKING:
-    from pip._internal.index.package_finder import PackageFinder
-    from pip._internal.req.req_install import InstallRequirement
-
-logger = logging.getLogger(__name__)
-
-
-def _dedup(a: str, b: str) -> tuple[str] | tuple[str, str]:
-    return (a, b) if a != b else (a,)
-
-
-class _Prefix:
-    def __init__(self, path: str) -> None:
-        self.path = path
-        self.setup = False
-        scheme = get_scheme("", prefix=path)
-        self.bin_dir = scheme.scripts
-        self.lib_dirs = _dedup(scheme.purelib, scheme.platlib)
-
-
-def get_runnable_pip() -> str:
-    """Get a file to pass to a Python executable, to run the currently-running pip.
-
-    This is used to run a pip subprocess, for installing requirements into the build
-    environment.
-    """
-    source = pathlib.Path(pip_location).resolve().parent
-
-    if not source.is_dir():
-        # This would happen if someone is using pip from inside a zip file. In that
-        # case, we can use that directly.
-        return str(source)
-
-    return os.fsdecode(source / "__pip-runner__.py")
-
-
-def _get_system_sitepackages() -> set[str]:
-    """Get system site packages
-
-    Usually from site.getsitepackages,
-    but fallback on `get_purelib()/get_platlib()` if unavailable
-    (e.g. in a virtualenv created by virtualenv<20)
-
-    Returns normalized set of strings.
-    """
-    if hasattr(site, "getsitepackages"):
-        system_sites = site.getsitepackages()
-    else:
-        # virtualenv < 20 overwrites site.py without getsitepackages
-        # fallback on get_purelib/get_platlib.
-        # this is known to miss things, but shouldn't in the cases
-        # where getsitepackages() has been removed (inside a virtualenv)
-        system_sites = [get_purelib(), get_platlib()]
-    return {os.path.normcase(path) for path in system_sites}
-
-
-class BuildEnvironmentInstaller(Protocol):
-    """
-    Interface for installing build dependencies into an isolated build
-    environment.
-    """
-
-    def install(
-        self,
-        requirements: Iterable[str],
-        prefix: _Prefix,
-        *,
-        kind: str,
-        for_req: InstallRequirement | None,
-    ) -> None: ...
-
-
-class SubprocessBuildEnvironmentInstaller:
-    """
-    Install build dependencies by calling pip in a subprocess.
-    """
-
-    def __init__(self, finder: PackageFinder) -> None:
-        self.finder = finder
-
-    def install(
-        self,
-        requirements: Iterable[str],
-        prefix: _Prefix,
-        *,
-        kind: str,
-        for_req: InstallRequirement | None,
-    ) -> None:
-        finder = self.finder
-        args: list[str] = [
-            sys.executable,
-            get_runnable_pip(),
-            "install",
-            "--ignore-installed",
-            "--no-user",
-            "--prefix",
-            prefix.path,
-            "--no-warn-script-location",
-            "--disable-pip-version-check",
-            # As the build environment is ephemeral, it's wasteful to
-            # pre-compile everything, especially as not every Python
-            # module will be used/compiled in most cases.
-            "--no-compile",
-            # The prefix specified two lines above, thus
-            # target from config file or env var should be ignored
-            "--target",
-            "",
-        ]
-        if logger.getEffectiveLevel() <= logging.DEBUG:
-            args.append("-vv")
-        elif logger.getEffectiveLevel() <= VERBOSE:
-            args.append("-v")
-        for format_control in ("no_binary", "only_binary"):
-            formats = getattr(finder.format_control, format_control)
-            args.extend(
-                (
-                    "--" + format_control.replace("_", "-"),
-                    ",".join(sorted(formats or {":none:"})),
-                )
-            )
-
-        index_urls = finder.index_urls
-        if index_urls:
-            args.extend(["-i", index_urls[0]])
-            for extra_index in index_urls[1:]:
-                args.extend(["--extra-index-url", extra_index])
-        else:
-            args.append("--no-index")
-        for link in finder.find_links:
-            args.extend(["--find-links", link])
-
-        if finder.proxy:
-            args.extend(["--proxy", finder.proxy])
-        for host in finder.trusted_hosts:
-            args.extend(["--trusted-host", host])
-        if finder.custom_cert:
-            args.extend(["--cert", finder.custom_cert])
-        if finder.client_cert:
-            args.extend(["--client-cert", finder.client_cert])
-        if finder.allow_all_prereleases:
-            args.append("--pre")
-        if finder.prefer_binary:
-            args.append("--prefer-binary")
-        args.append("--")
-        args.extend(requirements)
-        with open_spinner(f"Installing {kind}") as spinner:
-            call_subprocess(
-                args,
-                command_desc=f"pip subprocess to install {kind}",
-                spinner=spinner,
-            )
-
-
-class BuildEnvironment:
-    """Creates and manages an isolated environment to install build deps"""
-
-    def __init__(self, installer: BuildEnvironmentInstaller) -> None:
-        self.installer = installer
-        temp_dir = TempDirectory(kind=tempdir_kinds.BUILD_ENV, globally_managed=True)
-
-        self._prefixes = OrderedDict(
-            (name, _Prefix(os.path.join(temp_dir.path, name)))
-            for name in ("normal", "overlay")
-        )
-
-        self._bin_dirs: list[str] = []
-        self._lib_dirs: list[str] = []
-        for prefix in reversed(list(self._prefixes.values())):
-            self._bin_dirs.append(prefix.bin_dir)
-            self._lib_dirs.extend(prefix.lib_dirs)
-
-        # Customize site to:
-        # - ensure .pth files are honored
-        # - prevent access to system site packages
-        system_sites = _get_system_sitepackages()
-
-        self._site_dir = os.path.join(temp_dir.path, "site")
-        if not os.path.exists(self._site_dir):
-            os.mkdir(self._site_dir)
-        with open(
-            os.path.join(self._site_dir, "sitecustomize.py"), "w", encoding="utf-8"
-        ) as fp:
-            fp.write(
-                textwrap.dedent(
-                    """
-                import os, site, sys
-
-                # First, drop system-sites related paths.
-                original_sys_path = sys.path[:]
-                known_paths = set()
-                for path in {system_sites!r}:
-                    site.addsitedir(path, known_paths=known_paths)
-                system_paths = set(
-                    os.path.normcase(path)
-                    for path in sys.path[len(original_sys_path):]
-                )
-                original_sys_path = [
-                    path for path in original_sys_path
-                    if os.path.normcase(path) not in system_paths
-                ]
-                sys.path = original_sys_path
-
-                # Second, add lib directories.
-                # ensuring .pth file are processed.
-                for path in {lib_dirs!r}:
-                    assert not path in sys.path
-                    site.addsitedir(path)
-                """
-                ).format(system_sites=system_sites, lib_dirs=self._lib_dirs)
-            )
-
-    def __enter__(self) -> None:
-        self._save_env = {
-            name: os.environ.get(name, None)
-            for name in ("PATH", "PYTHONNOUSERSITE", "PYTHONPATH")
-        }
-
-        path = self._bin_dirs[:]
-        old_path = self._save_env["PATH"]
-        if old_path:
-            path.extend(old_path.split(os.pathsep))
-
-        pythonpath = [self._site_dir]
-
-        os.environ.update(
-            {
-                "PATH": os.pathsep.join(path),
-                "PYTHONNOUSERSITE": "1",
-                "PYTHONPATH": os.pathsep.join(pythonpath),
-            }
-        )
-
-    def __exit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: TracebackType | None,
-    ) -> None:
-        for varname, old_value in self._save_env.items():
-            if old_value is None:
-                os.environ.pop(varname, None)
-            else:
-                os.environ[varname] = old_value
-
-    def check_requirements(
-        self, reqs: Iterable[str]
-    ) -> tuple[set[tuple[str, str]], set[str]]:
-        """Return 2 sets:
-        - conflicting requirements: set of (installed, wanted) reqs tuples
-        - missing requirements: set of reqs
-        """
-        missing = set()
-        conflicting = set()
-        if reqs:
-            env = (
-                get_environment(self._lib_dirs)
-                if hasattr(self, "_lib_dirs")
-                else get_default_environment()
-            )
-            for req_str in reqs:
-                req = get_requirement(req_str)
-                # We're explicitly evaluating with an empty extra value, since build
-                # environments are not provided any mechanism to select specific extras.
-                if req.marker is not None and not req.marker.evaluate({"extra": ""}):
-                    continue
-                dist = env.get_distribution(req.name)
-                if not dist:
-                    missing.add(req_str)
-                    continue
-                if isinstance(dist.version, Version):
-                    installed_req_str = f"{req.name}=={dist.version}"
-                else:
-                    installed_req_str = f"{req.name}==={dist.version}"
-                if not req.specifier.contains(dist.version, prereleases=True):
-                    conflicting.add((installed_req_str, req_str))
-                # FIXME: Consider direct URL?
-        return conflicting, missing
-
-    def install_requirements(
-        self,
-        requirements: Iterable[str],
-        prefix_as_string: str,
-        *,
-        kind: str,
-        for_req: InstallRequirement | None = None,
-    ) -> None:
-        prefix = self._prefixes[prefix_as_string]
-        assert not prefix.setup
-        prefix.setup = True
-        if not requirements:
-            return
-        self.installer.install(requirements, prefix, kind=kind, for_req=for_req)
-
-
-class NoOpBuildEnvironment(BuildEnvironment):
-    """A no-op drop-in replacement for BuildEnvironment"""
-
-    def __init__(self) -> None:
-        pass
-
-    def __enter__(self) -> None:
-        pass
-
-    def __exit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: TracebackType | None,
-    ) -> None:
-        pass
-
-    def cleanup(self) -> None:
-        pass
-
-    def install_requirements(
-        self,
-        requirements: Iterable[str],
-        prefix_as_string: str,
-        *,
-        kind: str,
-        for_req: InstallRequirement | None = None,
-    ) -> None:
-        raise NotImplementedError()

venv/Lib/site-packages/pip/_internal/cache.py

@@ -1,291 +0,0 @@
-"""Cache Management"""
-
-from __future__ import annotations
-
-import hashlib
-import json
-import logging
-import os
-from pathlib import Path
-from typing import Any
-
-from pip._vendor.packaging.tags import Tag, interpreter_name, interpreter_version
-from pip._vendor.packaging.utils import canonicalize_name
-
-from pip._internal.exceptions import InvalidWheelFilename
-from pip._internal.models.direct_url import DirectUrl
-from pip._internal.models.link import Link
-from pip._internal.models.wheel import Wheel
-from pip._internal.utils.temp_dir import TempDirectory, tempdir_kinds
-from pip._internal.utils.urls import path_to_url
-
-logger = logging.getLogger(__name__)
-
-ORIGIN_JSON_NAME = "origin.json"
-
-
-def _hash_dict(d: dict[str, str]) -> str:
-    """Return a stable sha224 of a dictionary."""
-    s = json.dumps(d, sort_keys=True, separators=(",", ":"), ensure_ascii=True)
-    return hashlib.sha224(s.encode("ascii")).hexdigest()
-
-
-class Cache:
-    """An abstract class - provides cache directories for data from links
-
-    :param cache_dir: The root of the cache.
-    """
-
-    def __init__(self, cache_dir: str) -> None:
-        super().__init__()
-        assert not cache_dir or os.path.isabs(cache_dir)
-        self.cache_dir = cache_dir or None
-
-    def _get_cache_path_parts(self, link: Link) -> list[str]:
-        """Get parts of part that must be os.path.joined with cache_dir"""
-
-        # We want to generate an url to use as our cache key, we don't want to
-        # just reuse the URL because it might have other items in the fragment
-        # and we don't care about those.
-        key_parts = {"url": link.url_without_fragment}
-        if link.hash_name is not None and link.hash is not None:
-            key_parts[link.hash_name] = link.hash
-        if link.subdirectory_fragment:
-            key_parts["subdirectory"] = link.subdirectory_fragment
-
-        # Include interpreter name, major and minor version in cache key
-        # to cope with ill-behaved sdists that build a different wheel
-        # depending on the python version their setup.py is being run on,
-        # and don't encode the difference in compatibility tags.
-        # https://github.com/pypa/pip/issues/7296
-        key_parts["interpreter_name"] = interpreter_name()
-        key_parts["interpreter_version"] = interpreter_version()
-
-        # Encode our key url with sha224, we'll use this because it has similar
-        # security properties to sha256, but with a shorter total output (and
-        # thus less secure). However the differences don't make a lot of
-        # difference for our use case here.
-        hashed = _hash_dict(key_parts)
-
-        # We want to nest the directories some to prevent having a ton of top
-        # level directories where we might run out of sub directories on some
-        # FS.
-        parts = [hashed[:2], hashed[2:4], hashed[4:6], hashed[6:]]
-
-        return parts
-
-    def _get_candidates(self, link: Link, canonical_package_name: str) -> list[Any]:
-        can_not_cache = not self.cache_dir or not canonical_package_name or not link
-        if can_not_cache:
-            return []
-
-        path = self.get_path_for_link(link)
-        if os.path.isdir(path):
-            return [(candidate, path) for candidate in os.listdir(path)]
-        return []
-
-    def get_path_for_link(self, link: Link) -> str:
-        """Return a directory to store cached items in for link."""
-        raise NotImplementedError()
-
-    def get(
-        self,
-        link: Link,
-        package_name: str | None,
-        supported_tags: list[Tag],
-    ) -> Link:
-        """Returns a link to a cached item if it exists, otherwise returns the
-        passed link.
-        """
-        raise NotImplementedError()
-
-
-class SimpleWheelCache(Cache):
-    """A cache of wheels for future installs."""
-
-    def __init__(self, cache_dir: str) -> None:
-        super().__init__(cache_dir)
-
-    def get_path_for_link(self, link: Link) -> str:
-        """Return a directory to store cached wheels for link
-
-        Because there are M wheels for any one sdist, we provide a directory
-        to cache them in, and then consult that directory when looking up
-        cache hits.
-
-        We only insert things into the cache if they have plausible version
-        numbers, so that we don't contaminate the cache with things that were
-        not unique. E.g. ./package might have dozens of installs done for it
-        and build a version of 0.0...and if we built and cached a wheel, we'd
-        end up using the same wheel even if the source has been edited.
-
-        :param link: The link of the sdist for which this will cache wheels.
-        """
-        parts = self._get_cache_path_parts(link)
-        assert self.cache_dir
-        # Store wheels within the root cache_dir
-        return os.path.join(self.cache_dir, "wheels", *parts)
-
-    def get(
-        self,
-        link: Link,
-        package_name: str | None,
-        supported_tags: list[Tag],
-    ) -> Link:
-        candidates = []
-
-        if not package_name:
-            return link
-
-        canonical_package_name = canonicalize_name(package_name)
-        for wheel_name, wheel_dir in self._get_candidates(link, canonical_package_name):
-            try:
-                wheel = Wheel(wheel_name)
-            except InvalidWheelFilename:
-                continue
-            if canonicalize_name(wheel.name) != canonical_package_name:
-                logger.debug(
-                    "Ignoring cached wheel %s for %s as it "
-                    "does not match the expected distribution name %s.",
-                    wheel_name,
-                    link,
-                    package_name,
-                )
-                continue
-            if not wheel.supported(supported_tags):
-                # Built for a different python/arch/etc
-                continue
-            candidates.append(
-                (
-                    wheel.support_index_min(supported_tags),
-                    wheel_name,
-                    wheel_dir,
-                )
-            )
-
-        if not candidates:
-            return link
-
-        _, wheel_name, wheel_dir = min(candidates)
-        return Link(path_to_url(os.path.join(wheel_dir, wheel_name)))
-
-
-class EphemWheelCache(SimpleWheelCache):
-    """A SimpleWheelCache that creates it's own temporary cache directory"""
-
-    def __init__(self) -> None:
-        self._temp_dir = TempDirectory(
-            kind=tempdir_kinds.EPHEM_WHEEL_CACHE,
-            globally_managed=True,
-        )
-
-        super().__init__(self._temp_dir.path)
-
-
-class CacheEntry:
-    def __init__(
-        self,
-        link: Link,
-        persistent: bool,
-    ):
-        self.link = link
-        self.persistent = persistent
-        self.origin: DirectUrl | None = None
-        origin_direct_url_path = Path(self.link.file_path).parent / ORIGIN_JSON_NAME
-        if origin_direct_url_path.exists():
-            try:
-                self.origin = DirectUrl.from_json(
-                    origin_direct_url_path.read_text(encoding="utf-8")
-                )
-            except Exception as e:
-                logger.warning(
-                    "Ignoring invalid cache entry origin file %s for %s (%s)",
-                    origin_direct_url_path,
-                    link.filename,
-                    e,
-                )
-
-
-class WheelCache(Cache):
-    """Wraps EphemWheelCache and SimpleWheelCache into a single Cache
-
-    This Cache allows for gracefully degradation, using the ephem wheel cache
-    when a certain link is not found in the simple wheel cache first.
-    """
-
-    def __init__(self, cache_dir: str) -> None:
-        super().__init__(cache_dir)
-        self._wheel_cache = SimpleWheelCache(cache_dir)
-        self._ephem_cache = EphemWheelCache()
-
-    def get_path_for_link(self, link: Link) -> str:
-        return self._wheel_cache.get_path_for_link(link)
-
-    def get_ephem_path_for_link(self, link: Link) -> str:
-        return self._ephem_cache.get_path_for_link(link)
-
-    def get(
-        self,
-        link: Link,
-        package_name: str | None,
-        supported_tags: list[Tag],
-    ) -> Link:
-        cache_entry = self.get_cache_entry(link, package_name, supported_tags)
-        if cache_entry is None:
-            return link
-        return cache_entry.link
-
-    def get_cache_entry(
-        self,
-        link: Link,
-        package_name: str | None,
-        supported_tags: list[Tag],
-    ) -> CacheEntry | None:
-        """Returns a CacheEntry with a link to a cached item if it exists or
-        None. The cache entry indicates if the item was found in the persistent
-        or ephemeral cache.
-        """
-        retval = self._wheel_cache.get(
-            link=link,
-            package_name=package_name,
-            supported_tags=supported_tags,
-        )
-        if retval is not link:
-            return CacheEntry(retval, persistent=True)
-
-        retval = self._ephem_cache.get(
-            link=link,
-            package_name=package_name,
-            supported_tags=supported_tags,
-        )
-        if retval is not link:
-            return CacheEntry(retval, persistent=False)
-
-        return None
-
-    @staticmethod
-    def record_download_origin(cache_dir: str, download_info: DirectUrl) -> None:
-        origin_path = Path(cache_dir) / ORIGIN_JSON_NAME
-        if origin_path.exists():
-            try:
-                origin = DirectUrl.from_json(origin_path.read_text(encoding="utf-8"))
-            except Exception as e:
-                logger.warning(
-                    "Could not read origin file %s in cache entry (%s). "
-                    "Will attempt to overwrite it.",
-                    origin_path,
-                    e,
-                )
-            else:
-                # TODO: use DirectUrl.equivalent when
-                # https://github.com/pypa/pip/pull/10564 is merged.
-                if origin.url != download_info.url:
-                    logger.warning(
-                        "Origin URL %s in cache entry %s does not match download URL "
-                        "%s. This is likely a pip bug or a cache corruption issue. "
-                        "Will overwrite it with the new value.",
-                        origin.url,
-                        cache_dir,
-                        download_info.url,
-                    )
-        origin_path.write_text(download_info.to_json(), encoding="utf-8")