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

venv/Lib/site-packages/pip/_internal/cli/command_context.py

@@ -1,28 +0,0 @@
-from collections.abc import Generator
-from contextlib import AbstractContextManager, ExitStack, contextmanager
-from typing import TypeVar
-
-_T = TypeVar("_T", covariant=True)
-
-
-class CommandContextMixIn:
-    def __init__(self) -> None:
-        super().__init__()
-        self._in_main_context = False
-        self._main_context = ExitStack()
-
-    @contextmanager
-    def main_context(self) -> Generator[None, None, None]:
-        assert not self._in_main_context
-
-        self._in_main_context = True
-        try:
-            with self._main_context:
-                yield
-        finally:
-            self._in_main_context = False
-
-    def enter_context(self, context_provider: AbstractContextManager[_T]) -> _T:
-        assert self._in_main_context
-
-        return self._main_context.enter_context(context_provider)

venv/Lib/site-packages/pip/_internal/cli/index_command.py

@@ -1,175 +0,0 @@
-"""
-Contains command classes which may interact with an index / the network.
-
-Unlike its sister module, req_command, this module still uses lazy imports
-so commands which don't always hit the network (e.g. list w/o --outdated or
---uptodate) don't need waste time importing PipSession and friends.
-"""
-
-from __future__ import annotations
-
-import logging
-import os
-import sys
-from functools import lru_cache
-from optparse import Values
-from typing import TYPE_CHECKING
-
-from pip._vendor import certifi
-
-from pip._internal.cli.base_command import Command
-from pip._internal.cli.command_context import CommandContextMixIn
-
-if TYPE_CHECKING:
-    from ssl import SSLContext
-
-    from pip._internal.network.session import PipSession
-
-logger = logging.getLogger(__name__)
-
-
-@lru_cache
-def _create_truststore_ssl_context() -> SSLContext | None:
-    if sys.version_info < (3, 10):
-        logger.debug("Disabling truststore because Python version isn't 3.10+")
-        return None
-
-    try:
-        import ssl
-    except ImportError:
-        logger.warning("Disabling truststore since ssl support is missing")
-        return None
-
-    try:
-        from pip._vendor import truststore
-    except ImportError:
-        logger.warning("Disabling truststore because platform isn't supported")
-        return None
-
-    ctx = truststore.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
-    ctx.load_verify_locations(certifi.where())
-    return ctx
-
-
-class SessionCommandMixin(CommandContextMixIn):
-    """
-    A class mixin for command classes needing _build_session().
-    """
-
-    def __init__(self) -> None:
-        super().__init__()
-        self._session: PipSession | None = None
-
-    @classmethod
-    def _get_index_urls(cls, options: Values) -> list[str] | None:
-        """Return a list of index urls from user-provided options."""
-        index_urls = []
-        if not getattr(options, "no_index", False):
-            url = getattr(options, "index_url", None)
-            if url:
-                index_urls.append(url)
-        urls = getattr(options, "extra_index_urls", None)
-        if urls:
-            index_urls.extend(urls)
-        # Return None rather than an empty list
-        return index_urls or None
-
-    def get_default_session(self, options: Values) -> PipSession:
-        """Get a default-managed session."""
-        if self._session is None:
-            self._session = self.enter_context(self._build_session(options))
-            # there's no type annotation on requests.Session, so it's
-            # automatically ContextManager[Any] and self._session becomes Any,
-            # then https://github.com/python/mypy/issues/7696 kicks in
-            assert self._session is not None
-        return self._session
-
-    def _build_session(
-        self,
-        options: Values,
-        retries: int | None = None,
-        timeout: int | None = None,
-    ) -> PipSession:
-        from pip._internal.network.session import PipSession
-
-        cache_dir = options.cache_dir
-        assert not cache_dir or os.path.isabs(cache_dir)
-
-        if "legacy-certs" not in options.deprecated_features_enabled:
-            ssl_context = _create_truststore_ssl_context()
-        else:
-            ssl_context = None
-
-        session = PipSession(
-            cache=os.path.join(cache_dir, "http-v2") if cache_dir else None,
-            retries=retries if retries is not None else options.retries,
-            trusted_hosts=options.trusted_hosts,
-            index_urls=self._get_index_urls(options),
-            ssl_context=ssl_context,
-        )
-
-        # Handle custom ca-bundles from the user
-        if options.cert:
-            session.verify = options.cert
-
-        # Handle SSL client certificate
-        if options.client_cert:
-            session.cert = options.client_cert
-
-        # Handle timeouts
-        if options.timeout or timeout:
-            session.timeout = timeout if timeout is not None else options.timeout
-
-        # Handle configured proxies
-        if options.proxy:
-            session.proxies = {
-                "http": options.proxy,
-                "https": options.proxy,
-            }
-            session.trust_env = False
-            session.pip_proxy = options.proxy
-
-        # Determine if we can prompt the user for authentication or not
-        session.auth.prompting = not options.no_input
-        session.auth.keyring_provider = options.keyring_provider
-
-        return session
-
-
-def _pip_self_version_check(session: PipSession, options: Values) -> None:
-    from pip._internal.self_outdated_check import pip_self_version_check as check
-
-    check(session, options)
-
-
-class IndexGroupCommand(Command, SessionCommandMixin):
-    """
-    Abstract base class for commands with the index_group options.
-
-    This also corresponds to the commands that permit the pip version check.
-    """
-
-    def handle_pip_version_check(self, options: Values) -> None:
-        """
-        Do the pip version check if not disabled.
-
-        This overrides the default behavior of not doing the check.
-        """
-        # Make sure the index_group options are present.
-        assert hasattr(options, "no_index")
-
-        if options.disable_pip_version_check or options.no_index:
-            return
-
-        try:
-            # Otherwise, check if we're using the latest version of pip available.
-            session = self._build_session(
-                options,
-                retries=0,
-                timeout=min(5, options.timeout),
-            )
-            with session:
-                _pip_self_version_check(session, options)
-        except Exception:
-            logger.warning("There was an error checking the latest version of pip.")
-            logger.debug("See below for error", exc_info=True)

venv/Lib/site-packages/pip/_internal/cli/main.py

@@ -1,80 +0,0 @@
-"""Primary application entrypoint."""
-
-from __future__ import annotations
-
-import locale
-import logging
-import os
-import sys
-import warnings
-
-from pip._internal.cli.autocompletion import autocomplete
-from pip._internal.cli.main_parser import parse_command
-from pip._internal.commands import create_command
-from pip._internal.exceptions import PipError
-from pip._internal.utils import deprecation
-
-logger = logging.getLogger(__name__)
-
-
-# Do not import and use main() directly! Using it directly is actively
-# discouraged by pip's maintainers. The name, location and behavior of
-# this function is subject to change, so calling it directly is not
-# portable across different pip versions.
-
-# In addition, running pip in-process is unsupported and unsafe. This is
-# elaborated in detail at
-# https://pip.pypa.io/en/stable/user_guide/#using-pip-from-your-program.
-# That document also provides suggestions that should work for nearly
-# all users that are considering importing and using main() directly.
-
-# However, we know that certain users will still want to invoke pip
-# in-process. If you understand and accept the implications of using pip
-# in an unsupported manner, the best approach is to use runpy to avoid
-# depending on the exact location of this entry point.
-
-# The following example shows how to use runpy to invoke pip in that
-# case:
-#
-#     sys.argv = ["pip", your, args, here]
-#     runpy.run_module("pip", run_name="__main__")
-#
-# Note that this will exit the process after running, unlike a direct
-# call to main. As it is not safe to do any processing after calling
-# main, this should not be an issue in practice.
-
-
-def main(args: list[str] | None = None) -> int:
-    if args is None:
-        args = sys.argv[1:]
-
-    # Suppress the pkg_resources deprecation warning
-    # Note - we use a module of .*pkg_resources to cover
-    # the normal case (pip._vendor.pkg_resources) and the
-    # devendored case (a bare pkg_resources)
-    warnings.filterwarnings(
-        action="ignore", category=DeprecationWarning, module=".*pkg_resources"
-    )
-
-    # Configure our deprecation warnings to be sent through loggers
-    deprecation.install_warning_logger()
-
-    autocomplete()
-
-    try:
-        cmd_name, cmd_args = parse_command(args)
-    except PipError as exc:
-        sys.stderr.write(f"ERROR: {exc}")
-        sys.stderr.write(os.linesep)
-        sys.exit(1)
-
-    # Needed for locale.getpreferredencoding(False) to work
-    # in pip._internal.utils.encoding.auto_decode
-    try:
-        locale.setlocale(locale.LC_ALL, "")
-    except locale.Error as e:
-        # setlocale can apparently crash if locale are uninitialized
-        logger.debug("Ignoring error %s when setting locale", e)
-    command = create_command(cmd_name, isolated=("--isolated" in cmd_args))
-
-    return command.main(cmd_args)

venv/Lib/site-packages/pip/_internal/cli/main_parser.py

@@ -1,134 +0,0 @@
-"""A single place for constructing and exposing the main parser"""
-
-from __future__ import annotations
-
-import os
-import subprocess
-import sys
-
-from pip._internal.build_env import get_runnable_pip
-from pip._internal.cli import cmdoptions
-from pip._internal.cli.parser import ConfigOptionParser, UpdatingDefaultsHelpFormatter
-from pip._internal.commands import commands_dict, get_similar_commands
-from pip._internal.exceptions import CommandError
-from pip._internal.utils.misc import get_pip_version, get_prog
-
-__all__ = ["create_main_parser", "parse_command"]
-
-
-def create_main_parser() -> ConfigOptionParser:
-    """Creates and returns the main parser for pip's CLI"""
-
-    parser = ConfigOptionParser(
-        usage="\n%prog <command> [options]",
-        add_help_option=False,
-        formatter=UpdatingDefaultsHelpFormatter(),
-        name="global",
-        prog=get_prog(),
-    )
-    parser.disable_interspersed_args()
-
-    parser.version = get_pip_version()
-
-    # add the general options
-    gen_opts = cmdoptions.make_option_group(cmdoptions.general_group, parser)
-    parser.add_option_group(gen_opts)
-
-    # so the help formatter knows
-    parser.main = True  # type: ignore
-
-    # create command listing for description
-    description = [""] + [
-        f"{name:27} {command_info.summary}"
-        for name, command_info in commands_dict.items()
-    ]
-    parser.description = "\n".join(description)
-
-    return parser
-
-
-def identify_python_interpreter(python: str) -> str | None:
-    # If the named file exists, use it.
-    # If it's a directory, assume it's a virtual environment and
-    # look for the environment's Python executable.
-    if os.path.exists(python):
-        if os.path.isdir(python):
-            # bin/python for Unix, Scripts/python.exe for Windows
-            # Try both in case of odd cases like cygwin.
-            for exe in ("bin/python", "Scripts/python.exe"):
-                py = os.path.join(python, exe)
-                if os.path.exists(py):
-                    return py
-        else:
-            return python
-
-    # Could not find the interpreter specified
-    return None
-
-
-def parse_command(args: list[str]) -> tuple[str, list[str]]:
-    parser = create_main_parser()
-
-    # Note: parser calls disable_interspersed_args(), so the result of this
-    # call is to split the initial args into the general options before the
-    # subcommand and everything else.
-    # For example:
-    #  args: ['--timeout=5', 'install', '--user', 'INITools']
-    #  general_options: ['--timeout==5']
-    #  args_else: ['install', '--user', 'INITools']
-    general_options, args_else = parser.parse_args(args)
-
-    # --python
-    if general_options.python and "_PIP_RUNNING_IN_SUBPROCESS" not in os.environ:
-        # Re-invoke pip using the specified Python interpreter
-        interpreter = identify_python_interpreter(general_options.python)
-        if interpreter is None:
-            raise CommandError(
-                f"Could not locate Python interpreter {general_options.python}"
-            )
-
-        pip_cmd = [
-            interpreter,
-            get_runnable_pip(),
-        ]
-        pip_cmd.extend(args)
-
-        # Set a flag so the child doesn't re-invoke itself, causing
-        # an infinite loop.
-        os.environ["_PIP_RUNNING_IN_SUBPROCESS"] = "1"
-        returncode = 0
-        try:
-            proc = subprocess.run(pip_cmd)
-            returncode = proc.returncode
-        except (subprocess.SubprocessError, OSError) as exc:
-            raise CommandError(f"Failed to run pip under {interpreter}: {exc}")
-        sys.exit(returncode)
-
-    # --version
-    if general_options.version:
-        sys.stdout.write(parser.version)
-        sys.stdout.write(os.linesep)
-        sys.exit()
-
-    # pip || pip help -> print_help()
-    if not args_else or (args_else[0] == "help" and len(args_else) == 1):
-        parser.print_help()
-        sys.exit()
-
-    # the subcommand name
-    cmd_name = args_else[0]
-
-    if cmd_name not in commands_dict:
-        guess = get_similar_commands(cmd_name)
-
-        msg = [f'unknown command "{cmd_name}"']
-        if guess:
-            msg.append(f'maybe you meant "{guess}"')
-
-        raise CommandError(" - ".join(msg))
-
-    # all the args without the subcommand
-    cmd_args = args[:]
-    cmd_args.remove(cmd_name)
-
-    return cmd_name, cmd_args