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

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

@@ -1,139 +0,0 @@
-"""
-Package containing all pip commands
-"""
-
-from __future__ import annotations
-
-import importlib
-from collections import namedtuple
-from typing import Any
-
-from pip._internal.cli.base_command import Command
-
-CommandInfo = namedtuple("CommandInfo", "module_path, class_name, summary")
-
-# This dictionary does a bunch of heavy lifting for help output:
-# - Enables avoiding additional (costly) imports for presenting `--help`.
-# - The ordering matters for help display.
-#
-# Even though the module path starts with the same "pip._internal.commands"
-# prefix, the full path makes testing easier (specifically when modifying
-# `commands_dict` in test setup / teardown).
-commands_dict: dict[str, CommandInfo] = {
-    "install": CommandInfo(
-        "pip._internal.commands.install",
-        "InstallCommand",
-        "Install packages.",
-    ),
-    "lock": CommandInfo(
-        "pip._internal.commands.lock",
-        "LockCommand",
-        "Generate a lock file.",
-    ),
-    "download": CommandInfo(
-        "pip._internal.commands.download",
-        "DownloadCommand",
-        "Download packages.",
-    ),
-    "uninstall": CommandInfo(
-        "pip._internal.commands.uninstall",
-        "UninstallCommand",
-        "Uninstall packages.",
-    ),
-    "freeze": CommandInfo(
-        "pip._internal.commands.freeze",
-        "FreezeCommand",
-        "Output installed packages in requirements format.",
-    ),
-    "inspect": CommandInfo(
-        "pip._internal.commands.inspect",
-        "InspectCommand",
-        "Inspect the python environment.",
-    ),
-    "list": CommandInfo(
-        "pip._internal.commands.list",
-        "ListCommand",
-        "List installed packages.",
-    ),
-    "show": CommandInfo(
-        "pip._internal.commands.show",
-        "ShowCommand",
-        "Show information about installed packages.",
-    ),
-    "check": CommandInfo(
-        "pip._internal.commands.check",
-        "CheckCommand",
-        "Verify installed packages have compatible dependencies.",
-    ),
-    "config": CommandInfo(
-        "pip._internal.commands.configuration",
-        "ConfigurationCommand",
-        "Manage local and global configuration.",
-    ),
-    "search": CommandInfo(
-        "pip._internal.commands.search",
-        "SearchCommand",
-        "Search PyPI for packages.",
-    ),
-    "cache": CommandInfo(
-        "pip._internal.commands.cache",
-        "CacheCommand",
-        "Inspect and manage pip's wheel cache.",
-    ),
-    "index": CommandInfo(
-        "pip._internal.commands.index",
-        "IndexCommand",
-        "Inspect information available from package indexes.",
-    ),
-    "wheel": CommandInfo(
-        "pip._internal.commands.wheel",
-        "WheelCommand",
-        "Build wheels from your requirements.",
-    ),
-    "hash": CommandInfo(
-        "pip._internal.commands.hash",
-        "HashCommand",
-        "Compute hashes of package archives.",
-    ),
-    "completion": CommandInfo(
-        "pip._internal.commands.completion",
-        "CompletionCommand",
-        "A helper command used for command completion.",
-    ),
-    "debug": CommandInfo(
-        "pip._internal.commands.debug",
-        "DebugCommand",
-        "Show information useful for debugging.",
-    ),
-    "help": CommandInfo(
-        "pip._internal.commands.help",
-        "HelpCommand",
-        "Show help for commands.",
-    ),
-}
-
-
-def create_command(name: str, **kwargs: Any) -> Command:
-    """
-    Create an instance of the Command class with the given name.
-    """
-    module_path, class_name, summary = commands_dict[name]
-    module = importlib.import_module(module_path)
-    command_class = getattr(module, class_name)
-    command = command_class(name=name, summary=summary, **kwargs)
-
-    return command
-
-
-def get_similar_commands(name: str) -> str | None:
-    """Command name auto-correct."""
-    from difflib import get_close_matches
-
-    name = name.lower()
-
-    close_commands = get_close_matches(name, commands_dict.keys())
-
-    if close_commands:
-        return close_commands[0]
-    else:
-        return None

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

@@ -1,231 +0,0 @@
-import os
-import textwrap
-from optparse import Values
-from typing import Callable
-
-from pip._internal.cli.base_command import Command
-from pip._internal.cli.status_codes import ERROR, SUCCESS
-from pip._internal.exceptions import CommandError, PipError
-from pip._internal.utils import filesystem
-from pip._internal.utils.logging import getLogger
-from pip._internal.utils.misc import format_size
-
-logger = getLogger(__name__)
-
-
-class CacheCommand(Command):
-    """
-    Inspect and manage pip's wheel cache.
-
-    Subcommands:
-
-    - dir: Show the cache directory.
-    - info: Show information about the cache.
-    - list: List filenames of packages stored in the cache.
-    - remove: Remove one or more package from the cache.
-    - purge: Remove all items from the cache.
-
-    ``<pattern>`` can be a glob expression or a package name.
-    """
-
-    ignore_require_venv = True
-    usage = """
-        %prog dir
-        %prog info
-        %prog list [<pattern>] [--format=[human, abspath]]
-        %prog remove <pattern>
-        %prog purge
-    """
-
-    def add_options(self) -> None:
-        self.cmd_opts.add_option(
-            "--format",
-            action="store",
-            dest="list_format",
-            default="human",
-            choices=("human", "abspath"),
-            help="Select the output format among: human (default) or abspath",
-        )
-
-        self.parser.insert_option_group(0, self.cmd_opts)
-
-    def handler_map(self) -> dict[str, Callable[[Values, list[str]], None]]:
-        return {
-            "dir": self.get_cache_dir,
-            "info": self.get_cache_info,
-            "list": self.list_cache_items,
-            "remove": self.remove_cache_items,
-            "purge": self.purge_cache,
-        }
-
-    def run(self, options: Values, args: list[str]) -> int:
-        handler_map = self.handler_map()
-
-        if not options.cache_dir:
-            logger.error("pip cache commands can not function since cache is disabled.")
-            return ERROR
-
-        # Determine action
-        if not args or args[0] not in handler_map:
-            logger.error(
-                "Need an action (%s) to perform.",
-                ", ".join(sorted(handler_map)),
-            )
-            return ERROR
-
-        action = args[0]
-
-        # Error handling happens here, not in the action-handlers.
-        try:
-            handler_map[action](options, args[1:])
-        except PipError as e:
-            logger.error(e.args[0])
-            return ERROR
-
-        return SUCCESS
-
-    def get_cache_dir(self, options: Values, args: list[str]) -> None:
-        if args:
-            raise CommandError("Too many arguments")
-
-        logger.info(options.cache_dir)
-
-    def get_cache_info(self, options: Values, args: list[str]) -> None:
-        if args:
-            raise CommandError("Too many arguments")
-
-        num_http_files = len(self._find_http_files(options))
-        num_packages = len(self._find_wheels(options, "*"))
-
-        http_cache_location = self._cache_dir(options, "http-v2")
-        old_http_cache_location = self._cache_dir(options, "http")
-        wheels_cache_location = self._cache_dir(options, "wheels")
-        http_cache_size = filesystem.format_size(
-            filesystem.directory_size(http_cache_location)
-            + filesystem.directory_size(old_http_cache_location)
-        )
-        wheels_cache_size = filesystem.format_directory_size(wheels_cache_location)
-
-        message = (
-            textwrap.dedent(
-                """
-                    Package index page cache location (pip v23.3+): {http_cache_location}
-                    Package index page cache location (older pips): {old_http_cache_location}
-                    Package index page cache size: {http_cache_size}
-                    Number of HTTP files: {num_http_files}
-                    Locally built wheels location: {wheels_cache_location}
-                    Locally built wheels size: {wheels_cache_size}
-                    Number of locally built wheels: {package_count}
-                """  # noqa: E501
-            )
-            .format(
-                http_cache_location=http_cache_location,
-                old_http_cache_location=old_http_cache_location,
-                http_cache_size=http_cache_size,
-                num_http_files=num_http_files,
-                wheels_cache_location=wheels_cache_location,
-                package_count=num_packages,
-                wheels_cache_size=wheels_cache_size,
-            )
-            .strip()
-        )
-
-        logger.info(message)
-
-    def list_cache_items(self, options: Values, args: list[str]) -> None:
-        if len(args) > 1:
-            raise CommandError("Too many arguments")
-
-        if args:
-            pattern = args[0]
-        else:
-            pattern = "*"
-
-        files = self._find_wheels(options, pattern)
-        if options.list_format == "human":
-            self.format_for_human(files)
-        else:
-            self.format_for_abspath(files)
-
-    def format_for_human(self, files: list[str]) -> None:
-        if not files:
-            logger.info("No locally built wheels cached.")
-            return
-
-        results = []
-        for filename in files:
-            wheel = os.path.basename(filename)
-            size = filesystem.format_file_size(filename)
-            results.append(f" - {wheel} ({size})")
-        logger.info("Cache contents:\n")
-        logger.info("\n".join(sorted(results)))
-
-    def format_for_abspath(self, files: list[str]) -> None:
-        if files:
-            logger.info("\n".join(sorted(files)))
-
-    def remove_cache_items(self, options: Values, args: list[str]) -> None:
-        if len(args) > 1:
-            raise CommandError("Too many arguments")
-
-        if not args:
-            raise CommandError("Please provide a pattern")
-
-        files = self._find_wheels(options, args[0])
-
-        no_matching_msg = "No matching packages"
-        if args[0] == "*":
-            # Only fetch http files if no specific pattern given
-            files += self._find_http_files(options)
-        else:
-            # Add the pattern to the log message
-            no_matching_msg += f' for pattern "{args[0]}"'
-
-        if not files:
-            logger.warning(no_matching_msg)
-
-        bytes_removed = 0
-        for filename in files:
-            bytes_removed += os.stat(filename).st_size
-            os.unlink(filename)
-            logger.verbose("Removed %s", filename)
-        logger.info("Files removed: %s (%s)", len(files), format_size(bytes_removed))
-
-    def purge_cache(self, options: Values, args: list[str]) -> None:
-        if args:
-            raise CommandError("Too many arguments")
-
-        return self.remove_cache_items(options, ["*"])
-
-    def _cache_dir(self, options: Values, subdir: str) -> str:
-        return os.path.join(options.cache_dir, subdir)
-
-    def _find_http_files(self, options: Values) -> list[str]:
-        old_http_dir = self._cache_dir(options, "http")
-        new_http_dir = self._cache_dir(options, "http-v2")
-        return filesystem.find_files(old_http_dir, "*") + filesystem.find_files(
-            new_http_dir, "*"
-        )
-
-    def _find_wheels(self, options: Values, pattern: str) -> list[str]:
-        wheel_dir = self._cache_dir(options, "wheels")
-
-        # The wheel filename format, as specified in PEP 427, is:
-        #     {distribution}-{version}(-{build})?-{python}-{abi}-{platform}.whl
-        #
-        # Additionally, non-alphanumeric values in the distribution are
-        # normalized to underscores (_), meaning hyphens can never occur
-        # before `-{version}`.
-        #
-        # Given that information:
-        # - If the pattern we're given contains a hyphen (-), the user is
-        #   providing at least the version. Thus, we can just append `*.whl`
-        #   to match the rest of it.
-        # - If the pattern we're given doesn't contain a hyphen (-), the
-        #   user is only providing the name. Thus, we append `-*.whl` to
-        #   match the hyphen before the version, followed by anything else.
-        #
-        # PEP 427: https://www.python.org/dev/peps/pep-0427/
-        pattern = pattern + ("*.whl" if "-" in pattern else "-*.whl")
-
-        return filesystem.find_files(wheel_dir, pattern)

venv/Lib/site-packages/pip/_internal/commands/check.py

@@ -1,66 +0,0 @@
-import logging
-from optparse import Values
-
-from pip._internal.cli.base_command import Command
-from pip._internal.cli.status_codes import ERROR, SUCCESS
-from pip._internal.metadata import get_default_environment
-from pip._internal.operations.check import (
-    check_package_set,
-    check_unsupported,
-    create_package_set_from_installed,
-)
-from pip._internal.utils.compatibility_tags import get_supported
-from pip._internal.utils.misc import write_output
-
-logger = logging.getLogger(__name__)
-
-
-class CheckCommand(Command):
-    """Verify installed packages have compatible dependencies."""
-
-    ignore_require_venv = True
-    usage = """
-      %prog [options]"""
-
-    def run(self, options: Values, args: list[str]) -> int:
-        package_set, parsing_probs = create_package_set_from_installed()
-        missing, conflicting = check_package_set(package_set)
-        unsupported = list(
-            check_unsupported(
-                get_default_environment().iter_installed_distributions(),
-                get_supported(),
-            )
-        )
-
-        for project_name in missing:
-            version = package_set[project_name].version
-            for dependency in missing[project_name]:
-                write_output(
-                    "%s %s requires %s, which is not installed.",
-                    project_name,
-                    version,
-                    dependency[0],
-                )
-
-        for project_name in conflicting:
-            version = package_set[project_name].version
-            for dep_name, dep_version, req in conflicting[project_name]:
-                write_output(
-                    "%s %s has requirement %s, but you have %s %s.",
-                    project_name,
-                    version,
-                    req,
-                    dep_name,
-                    dep_version,
-                )
-        for package in unsupported:
-            write_output(
-                "%s %s is not supported on this platform",
-                package.raw_name,
-                package.version,
-            )
-        if missing or conflicting or parsing_probs or unsupported:
-            return ERROR
-        else:
-            write_output("No broken requirements found.")
-            return SUCCESS

venv/Lib/site-packages/pip/_internal/commands/completion.py

@@ -1,135 +0,0 @@
-import sys
-import textwrap
-from optparse import Values
-
-from pip._internal.cli.base_command import Command
-from pip._internal.cli.status_codes import SUCCESS
-from pip._internal.utils.misc import get_prog
-
-BASE_COMPLETION = """
-# pip {shell} completion start{script}# pip {shell} completion end
-"""
-
-COMPLETION_SCRIPTS = {
-    "bash": """
-        _pip_completion()
-        {{
-            COMPREPLY=( $( COMP_WORDS="${{COMP_WORDS[*]}}" \\
-                           COMP_CWORD=$COMP_CWORD \\
-                           PIP_AUTO_COMPLETE=1 $1 2>/dev/null ) )
-        }}
-        complete -o default -F _pip_completion {prog}
-    """,
-    "zsh": """
-        #compdef -P pip[0-9.]#
-        __pip() {{
-          compadd $( COMP_WORDS="$words[*]" \\
-                     COMP_CWORD=$((CURRENT-1)) \\
-                     PIP_AUTO_COMPLETE=1 $words[1] 2>/dev/null )
-        }}
-        if [[ $zsh_eval_context[-1] == loadautofunc ]]; then
-          # autoload from fpath, call function directly
-          __pip "$@"
-        else
-          # eval/source/. command, register function for later
-          compdef __pip -P 'pip[0-9.]#'
-        fi
-    """,
-    "fish": """
-        function __fish_complete_pip
-            set -lx COMP_WORDS \\
-                (commandline --current-process --tokenize --cut-at-cursor) \\
-                (commandline --current-token --cut-at-cursor)
-            set -lx COMP_CWORD (math (count $COMP_WORDS) - 1)
-            set -lx PIP_AUTO_COMPLETE 1
-            set -l completions
-            if string match -q '2.*' $version
-                set completions (eval $COMP_WORDS[1])
-            else
-                set completions ($COMP_WORDS[1])
-            end
-            string split \\  -- $completions
-        end
-        complete -fa "(__fish_complete_pip)" -c {prog}
-    """,
-    "powershell": """
-        if ((Test-Path Function:\\TabExpansion) -and -not `
-            (Test-Path Function:\\_pip_completeBackup)) {{
-            Rename-Item Function:\\TabExpansion _pip_completeBackup
-        }}
-        function TabExpansion($line, $lastWord) {{
-            $lastBlock = [regex]::Split($line, '[|;]')[-1].TrimStart()
-            if ($lastBlock.StartsWith("{prog} ")) {{
-                $Env:COMP_WORDS=$lastBlock
-                $Env:COMP_CWORD=$lastBlock.Split().Length - 1
-                $Env:PIP_AUTO_COMPLETE=1
-                (& {prog}).Split()
-                Remove-Item Env:COMP_WORDS
-                Remove-Item Env:COMP_CWORD
-                Remove-Item Env:PIP_AUTO_COMPLETE
-            }}
-            elseif (Test-Path Function:\\_pip_completeBackup) {{
-                # Fall back on existing tab expansion
-                _pip_completeBackup $line $lastWord
-            }}
-        }}
-    """,
-}
-
-
-class CompletionCommand(Command):
-    """A helper command to be used for command completion."""
-
-    ignore_require_venv = True
-
-    def add_options(self) -> None:
-        self.cmd_opts.add_option(
-            "--bash",
-            "-b",
-            action="store_const",
-            const="bash",
-            dest="shell",
-            help="Emit completion code for bash",
-        )
-        self.cmd_opts.add_option(
-            "--zsh",
-            "-z",
-            action="store_const",
-            const="zsh",
-            dest="shell",
-            help="Emit completion code for zsh",
-        )
-        self.cmd_opts.add_option(
-            "--fish",
-            "-f",
-            action="store_const",
-            const="fish",
-            dest="shell",
-            help="Emit completion code for fish",
-        )
-        self.cmd_opts.add_option(
-            "--powershell",
-            "-p",
-            action="store_const",
-            const="powershell",
-            dest="shell",
-            help="Emit completion code for powershell",
-        )
-
-        self.parser.insert_option_group(0, self.cmd_opts)
-
-    def run(self, options: Values, args: list[str]) -> int:
-        """Prints the completion code of the given shell"""
-        shells = COMPLETION_SCRIPTS.keys()
-        shell_options = ["--" + shell for shell in sorted(shells)]
-        if options.shell in shells:
-            script = textwrap.dedent(
-                COMPLETION_SCRIPTS.get(options.shell, "").format(prog=get_prog())
-            )
-            print(BASE_COMPLETION.format(script=script, shell=options.shell))
-            return SUCCESS
-        else:
-            sys.stderr.write(
-                "ERROR: You must pass {}\n".format(" or ".join(shell_options))
-            )
-            return SUCCESS