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

venv/Lib/site-packages/pip/_internal/utils/virtualenv.py

@@ -1,105 +0,0 @@
-from __future__ import annotations
-
-import logging
-import os
-import re
-import site
-import sys
-
-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_legacy_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:
-    """True if we're running inside a virtual environment, False otherwise."""
-    return _running_under_venv() or _running_under_legacy_virtualenv()
-
-
-def _get_pyvenv_cfg_lines() -> list[str] | None:
-    """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_legacy_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_legacy_virtualenv():
-        return _no_global_under_legacy_virtualenv()
-
-    return False

venv/Lib/site-packages/pip/_internal/utils/wheel.py

@@ -1,132 +0,0 @@
-"""Support functions for working with wheel files."""
-
-import logging
-from email.message import Message
-from email.parser import Parser
-from zipfile import BadZipFile, ZipFile
-
-from pip._vendor.packaging.utils import canonicalize_name
-
-from pip._internal.exceptions import UnsupportedWheel
-
-VERSION_COMPATIBLE = (1, 0)
-
-
-logger = logging.getLogger(__name__)
-
-
-def parse_wheel(wheel_zip: ZipFile, name: str) -> tuple[str, Message]:
-    """Extract information from the provided wheel, ensuring it meets basic
-    standards.
-
-    Returns the name of the .dist-info directory and the parsed WHEEL metadata.
-    """
-    try:
-        info_dir = wheel_dist_info_dir(wheel_zip, name)
-        metadata = wheel_metadata(wheel_zip, info_dir)
-        version = wheel_version(metadata)
-    except UnsupportedWheel as e:
-        raise UnsupportedWheel(f"{name} has an invalid wheel, {e}")
-
-    check_compatibility(version, name)
-
-    return info_dir, metadata
-
-
-def wheel_dist_info_dir(source: ZipFile, name: str) -> str:
-    """Returns the name of the contained .dist-info directory.
-
-    Raises AssertionError or UnsupportedWheel if not found, >1 found, or
-    it doesn't match the provided name.
-    """
-    # Zip file path separators must be /
-    subdirs = {p.split("/", 1)[0] for p in source.namelist()}
-
-    info_dirs = [s for s in subdirs if s.endswith(".dist-info")]
-
-    if not info_dirs:
-        raise UnsupportedWheel(".dist-info directory not found")
-
-    if len(info_dirs) > 1:
-        raise UnsupportedWheel(
-            "multiple .dist-info directories found: {}".format(", ".join(info_dirs))
-        )
-
-    info_dir = info_dirs[0]
-
-    info_dir_name = canonicalize_name(info_dir)
-    canonical_name = canonicalize_name(name)
-    if not info_dir_name.startswith(canonical_name):
-        raise UnsupportedWheel(
-            f".dist-info directory {info_dir!r} does not start with {canonical_name!r}"
-        )
-
-    return info_dir
-
-
-def read_wheel_metadata_file(source: ZipFile, path: str) -> bytes:
-    try:
-        return source.read(path)
-        # BadZipFile for general corruption, KeyError for missing entry,
-        # and RuntimeError for password-protected files
-    except (BadZipFile, KeyError, RuntimeError) as e:
-        raise UnsupportedWheel(f"could not read {path!r} file: {e!r}")
-
-
-def wheel_metadata(source: ZipFile, dist_info_dir: str) -> Message:
-    """Return the WHEEL metadata of an extracted wheel, if possible.
-    Otherwise, raise UnsupportedWheel.
-    """
-    path = f"{dist_info_dir}/WHEEL"
-    # Zip file path separators must be /
-    wheel_contents = read_wheel_metadata_file(source, path)
-
-    try:
-        wheel_text = wheel_contents.decode()
-    except UnicodeDecodeError as e:
-        raise UnsupportedWheel(f"error decoding {path!r}: {e!r}")
-
-    # FeedParser (used by Parser) does not raise any exceptions. The returned
-    # message may have .defects populated, but for backwards-compatibility we
-    # currently ignore them.
-    return Parser().parsestr(wheel_text)
-
-
-def wheel_version(wheel_data: Message) -> tuple[int, ...]:
-    """Given WHEEL metadata, return the parsed Wheel-Version.
-    Otherwise, raise UnsupportedWheel.
-    """
-    version_text = wheel_data["Wheel-Version"]
-    if version_text is None:
-        raise UnsupportedWheel("WHEEL is missing Wheel-Version")
-
-    version = version_text.strip()
-
-    try:
-        return tuple(map(int, version.split(".")))
-    except ValueError:
-        raise UnsupportedWheel(f"invalid Wheel-Version: {version!r}")
-
-
-def check_compatibility(version: tuple[int, ...], name: str) -> None:
-    """Raises errors or warns if called with an incompatible Wheel-Version.
-
-    pip should refuse to install a Wheel-Version that's a major series
-    ahead of what it's compatible with (e.g 2.0 > 1.1); and warn when
-    installing a version only minor version ahead (e.g 1.2 > 1.1).
-
-    version: a 2-tuple representing a Wheel-Version (Major, Minor)
-    name: name of wheel or package to raise exception about
-
-    :raises UnsupportedWheel: when an incompatible Wheel-Version is given
-    """
-    if version[0] > VERSION_COMPATIBLE[0]:
-        raise UnsupportedWheel(
-            "{}'s Wheel-Version ({}) is not compatible with this version "
-            "of pip".format(name, ".".join(map(str, version)))
-        )
-    elif version > VERSION_COMPATIBLE:
-        logger.warning(
-            "Installing from a newer Wheel-Version (%s)",
-            ".".join(map(str, version)),
-        )

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

@@ -1,15 +0,0 @@
-# Expose a limited set of classes and functions so callers outside of
-# the vcs package don't need to import deeper than `pip._internal.vcs`.
-# (The test directory may still need to import from a vcs sub-package.)
-# Import all vcs modules to register each VCS in the VcsSupport object.
-import pip._internal.vcs.bazaar
-import pip._internal.vcs.git
-import pip._internal.vcs.mercurial
-import pip._internal.vcs.subversion  # noqa: F401
-from pip._internal.vcs.versioncontrol import (  # noqa: F401
-    RemoteNotFoundError,
-    RemoteNotValidError,
-    is_url,
-    make_vcs_requirement_url,
-    vcs,
-)

venv/Lib/site-packages/pip/_internal/vcs/bazaar.py

@@ -1,130 +0,0 @@
-from __future__ import annotations
-
-import logging
-
-from pip._internal.utils.misc import HiddenText, display_path
-from pip._internal.utils.subprocess import make_command
-from pip._internal.utils.urls import path_to_url
-from pip._internal.vcs.versioncontrol import (
-    AuthInfo,
-    RemoteNotFoundError,
-    RevOptions,
-    VersionControl,
-    vcs,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class Bazaar(VersionControl):
-    name = "bzr"
-    dirname = ".bzr"
-    repo_name = "branch"
-    schemes = (
-        "bzr+http",
-        "bzr+https",
-        "bzr+ssh",
-        "bzr+sftp",
-        "bzr+ftp",
-        "bzr+lp",
-        "bzr+file",
-    )
-
-    @staticmethod
-    def get_base_rev_args(rev: str) -> list[str]:
-        return ["-r", rev]
-
-    def fetch_new(
-        self, dest: str, url: HiddenText, rev_options: RevOptions, verbosity: int
-    ) -> None:
-        rev_display = rev_options.to_display()
-        logger.info(
-            "Checking out %s%s to %s",
-            url,
-            rev_display,
-            display_path(dest),
-        )
-        if verbosity <= 0:
-            flags = ["--quiet"]
-        elif verbosity == 1:
-            flags = []
-        else:
-            flags = [f"-{'v'*verbosity}"]
-        cmd_args = make_command(
-            "checkout", "--lightweight", *flags, rev_options.to_args(), url, dest
-        )
-        self.run_command(cmd_args)
-
-    def switch(
-        self,
-        dest: str,
-        url: HiddenText,
-        rev_options: RevOptions,
-        verbosity: int = 0,
-    ) -> None:
-        self.run_command(make_command("switch", url), cwd=dest)
-
-    def update(
-        self,
-        dest: str,
-        url: HiddenText,
-        rev_options: RevOptions,
-        verbosity: int = 0,
-    ) -> None:
-        flags = []
-
-        if verbosity <= 0:
-            flags.append("-q")
-
-        output = self.run_command(
-            make_command("info"), show_stdout=False, stdout_only=True, cwd=dest
-        )
-        if output.startswith("Standalone "):
-            # Older versions of pip used to create standalone branches.
-            # Convert the standalone branch to a checkout by calling "bzr bind".
-            cmd_args = make_command("bind", *flags, url)
-            self.run_command(cmd_args, cwd=dest)
-
-        cmd_args = make_command("update", *flags, rev_options.to_args())
-        self.run_command(cmd_args, cwd=dest)
-
-    @classmethod
-    def get_url_rev_and_auth(cls, url: str) -> tuple[str, str | None, AuthInfo]:
-        # hotfix the URL scheme after removing bzr+ from bzr+ssh:// re-add it
-        url, rev, user_pass = super().get_url_rev_and_auth(url)
-        if url.startswith("ssh://"):
-            url = "bzr+" + url
-        return url, rev, user_pass
-
-    @classmethod
-    def get_remote_url(cls, location: str) -> str:
-        urls = cls.run_command(
-            ["info"], show_stdout=False, stdout_only=True, cwd=location
-        )
-        for line in urls.splitlines():
-            line = line.strip()
-            for x in ("checkout of branch: ", "parent branch: "):
-                if line.startswith(x):
-                    repo = line.split(x)[1]
-                    if cls._is_local_repository(repo):
-                        return path_to_url(repo)
-                    return repo
-        raise RemoteNotFoundError
-
-    @classmethod
-    def get_revision(cls, location: str) -> str:
-        revision = cls.run_command(
-            ["revno"],
-            show_stdout=False,
-            stdout_only=True,
-            cwd=location,
-        )
-        return revision.splitlines()[-1]
-
-    @classmethod
-    def is_commit_id_equal(cls, dest: str, name: str | None) -> bool:
-        """Always assume the versions don't match"""
-        return False
-
-
-vcs.register(Bazaar)