pip 25.3__py3-none-any.whl → 26.0__py3-none-any.whl

pip/_internal/cli/parser.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 import logging
 import optparse
+import os
+import re
 import shutil
 import sys
 import textwrap
@@ -11,8 +13,12 @@ from collections.abc import Generator
 from contextlib import suppress
 from typing import Any, NoReturn
 
+from pip._vendor.rich.markup import escape
+from pip._vendor.rich.theme import Theme
+
 from pip._internal.cli.status_codes import UNKNOWN_ERROR
 from pip._internal.configuration import Configuration, ConfigurationError
+from pip._internal.utils.logging import PipConsole
 from pip._internal.utils.misc import redact_auth_from_url, strtobool
 
 logger = logging.getLogger(__name__)
@@ -21,6 +27,17 @@ logger = logging.getLogger(__name__)
 class PrettyHelpFormatter(optparse.IndentedHelpFormatter):
     """A prettier/less verbose help formatter for optparse."""
 
+    styles = {
+        "optparse.shortargs": "green",
+        "optparse.longargs": "cyan",
+        "optparse.groups": "bold blue",
+        "optparse.metavar": "yellow",
+    }
+    highlights = {
+        r"\s(-{1}[\w]+[\w-]*)": "shortargs",  # highlight -letter as short args
+        r"\s(-{2}[\w]+[\w-]*)": "longargs",  # highlight --words as long args
+    }
+
     def __init__(self, *args: Any, **kwargs: Any) -> None:
         # help position must be aligned with __init__.parseopts.description
         kwargs["max_help_position"] = 30
@@ -29,61 +46,82 @@ class PrettyHelpFormatter(optparse.IndentedHelpFormatter):
         super().__init__(*args, **kwargs)
 
     def format_option_strings(self, option: optparse.Option) -> str:
-        return self._format_option_strings(option)
-
-    def _format_option_strings(
-        self, option: optparse.Option, mvarfmt: str = " <{}>", optsep: str = ", "
-    ) -> str:
-        """
-        Return a comma-separated list of option strings and metavars.
-
-        :param option:  tuple of (short opt, long opt), e.g: ('-f', '--format')
-        :param mvarfmt: metavar format string
-        :param optsep:  separator
-        """
+        """Return a comma-separated list of option strings and metavars."""
         opts = []
 
         if option._short_opts:
-            opts.append(option._short_opts[0])
+            opts.append(f"[optparse.shortargs]{option._short_opts[0]}[/]")
         if option._long_opts:
-            opts.append(option._long_opts[0])
+            opts.append(f"[optparse.longargs]{option._long_opts[0]}[/]")
         if len(opts) > 1:
-            opts.insert(1, optsep)
+            opts.insert(1, ", ")
 
         if option.takes_value():
             assert option.dest is not None
             metavar = option.metavar or option.dest.lower()
-            opts.append(mvarfmt.format(metavar.lower()))
+            opts.append(f" [optparse.metavar]<{escape(metavar.lower())}>[/]")
 
         return "".join(opts)
 
+    def format_option(self, option: optparse.Option) -> str:
+        """Overridden method with Rich support."""
+        # fmt: off
+        result = []
+        opts = self.option_strings[option]
+        opt_width = self.help_position - self.current_indent - 2
+        # Remove the rich style tags before calculating width during
+        # text wrap calculations. Also store the length removed to adjust
+        # the padding in the else branch.
+        stripped = re.sub(r"(\[[a-z.]+\])|(\[\/\])", "", opts)
+        style_tag_length = len(opts) - len(stripped)
+        if len(stripped) > opt_width:
+            opts = "%*s%s\n" % (self.current_indent, "", opts)  # noqa: UP031
+            indent_first = self.help_position
+        else:                       # start help on same line as opts
+            opts = "%*s%-*s  " % (self.current_indent, "",      # noqa: UP031
+                                  opt_width + style_tag_length, opts)
+            indent_first = 0
+        result.append(opts)
+        if option.help:
+            help_text = self.expand_default(option)
+            help_lines = textwrap.wrap(help_text, self.help_width)
+            result.append("%*s%s\n" % (indent_first, "", help_lines[0]))  # noqa: UP031
+            result.extend(["%*s%s\n" % (self.help_position, "", line)     # noqa: UP031
+                           for line in help_lines[1:]])
+        elif opts[-1] != "\n":
+            result.append("\n")
+        return "".join(result)
+        # fmt: on
+
     def format_heading(self, heading: str) -> str:
         if heading == "Options":
             return ""
-        return heading + ":\n"
+        return "[optparse.groups]" + escape(heading) + ":[/]\n"
 
     def format_usage(self, usage: str) -> str:
         """
         Ensure there is only one newline between usage and the first heading
         if there is no description.
         """
-        msg = "\nUsage: {}\n".format(self.indent_lines(textwrap.dedent(usage), "  "))
+        contents = self.indent_lines(textwrap.dedent(usage), "  ")
+        msg = f"\n[optparse.groups]Usage:[/] {escape(contents)}\n"
         return msg
 
     def format_description(self, description: str | None) -> str:
         # leave full control over description to us
         if description:
             if hasattr(self.parser, "main"):
-                label = "Commands"
+                label = "[optparse.groups]Commands:[/]"
             else:
-                label = "Description"
+                label = "[optparse.groups]Description:[/]"
+
             # some doc strings have initial newlines, some don't
             description = description.lstrip("\n")
             # some doc strings have final newlines and spaces, some don't
             description = description.rstrip()
             # dedent, then reindent
             description = self.indent_lines(textwrap.dedent(description), "  ")
-            description = f"{label}:\n{description}\n"
+            description = f"{label}\n{description}\n"
             return description
         else:
             return ""
@@ -91,10 +129,17 @@ class PrettyHelpFormatter(optparse.IndentedHelpFormatter):
     def format_epilog(self, epilog: str | None) -> str:
         # leave full control over epilog to us
         if epilog:
-            return epilog
+            return escape(epilog)
         else:
             return ""
 
+    def expand_default(self, option: optparse.Option) -> str:
+        """Overridden HelpFormatter.expand_default() which colorizes flags."""
+        help = escape(super().expand_default(option))
+        for regex, style in self.highlights.items():
+            help = re.sub(regex, rf"[optparse.{style}] \1[/]", help)
+        return help
+
     def indent_lines(self, text: str, indent: str) -> str:
         new_lines = [indent + line for line in text.split("\n")]
         return "\n".join(new_lines)
@@ -185,23 +230,25 @@ class ConfigOptionParser(CustomOptionParser):
         override_order = ["global", self.name, ":env:"]
 
         # Pool the options into different groups
-        section_items: dict[str, list[tuple[str, Any]]] = {
-            name: [] for name in override_order
+        # Use a dict because we need to implement the fallthrough logic after PR 12201
+        # was merged which removed the fallthrough logic for options
+        section_items_dict: dict[str, dict[str, Any]] = {
+            name: {} for name in override_order
         }
 
-        for _, value in self.config.items():  # noqa: PERF102
+        for _, value in self.config.items():
             for section_key, val in value.items():
-                # ignore empty values
-                if not val:
-                    logger.debug(
-                        "Ignoring configuration key '%s' as its value is empty.",
-                        section_key,
-                    )
-                    continue
 
                 section, key = section_key.split(".", 1)
                 if section in override_order:
-                    section_items[section].append((key, val))
+                    section_items_dict[section][key] = val
+
+        # Now that we a dict of items per section, convert to list of tuples
+        # Make sure we completely remove empty values again
+        section_items = {
+            name: [(k, v) for k, v in section_items_dict[name].items() if v]
+            for name in override_order
+        }
 
         # Yield each group in their override order
         for section in override_order:
@@ -296,3 +343,16 @@ class ConfigOptionParser(CustomOptionParser):
     def error(self, msg: str) -> NoReturn:
         self.print_usage(sys.stderr)
         self.exit(UNKNOWN_ERROR, f"{msg}\n")
+
+    def print_help(self, file: Any = None) -> None:
+        # This is unfortunate but necessary since arguments may have not been
+        # parsed yet at this point, so detect --no-color manually.
+        no_color = (
+            "--no-color" in sys.argv
+            or bool(strtobool(os.environ.get("PIP_NO_COLOR", "no") or "no"))
+            or "NO_COLOR" in os.environ
+        )
+        console = PipConsole(
+            theme=Theme(PrettyHelpFormatter.styles), no_color=no_color, file=file
+        )
+        console.print(self.format_help().rstrip(), highlight=False)

pip/_internal/cli/progress_bars.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import functools
 import sys
 from collections.abc import Generator, Iterable, Iterator
-from typing import Callable, Literal, TypeVar
+from typing import TYPE_CHECKING, Callable, Literal, TypeVar
 
 from pip._vendor.rich.progress import (
     BarColumn,
@@ -20,9 +20,11 @@ from pip._vendor.rich.progress import (
 )
 
 from pip._internal.cli.spinners import RateLimiter
-from pip._internal.req.req_install import InstallRequirement
 from pip._internal.utils.logging import get_console, get_indentation
 
+if TYPE_CHECKING:
+    from pip._internal.req.req_install import InstallRequirement
+
 T = TypeVar("T")
 ProgressRenderer = Callable[[Iterable[T]], Iterator[T]]
 BarType = Literal["on", "off", "raw"]

pip/_internal/cli/req_command.py

@@ -13,12 +13,21 @@ from functools import partial
 from optparse import Values
 from typing import Any, Callable, TypeVar
 
-from pip._internal.build_env import SubprocessBuildEnvironmentInstaller
+from pip._internal.build_env import (
+    BuildEnvironmentInstaller,
+    InprocessBuildEnvironmentInstaller,
+    SubprocessBuildEnvironmentInstaller,
+)
 from pip._internal.cache import WheelCache
 from pip._internal.cli import cmdoptions
+from pip._internal.cli.cmdoptions import make_target_python
 from pip._internal.cli.index_command import IndexGroupCommand
 from pip._internal.cli.index_command import SessionCommandMixin as SessionCommandMixin
-from pip._internal.exceptions import CommandError, PreviousBuildDirError
+from pip._internal.exceptions import (
+    CommandError,
+    PreviousBuildDirError,
+    UnsupportedPythonVersion,
+)
 from pip._internal.index.collector import LinkCollector
 from pip._internal.index.package_finder import PackageFinder
 from pip._internal.models.selection_prefs import SelectionPreferences
@@ -32,10 +41,12 @@ from pip._internal.req.constructors import (
     install_req_from_parsed_requirement,
     install_req_from_req_string,
 )
+from pip._internal.req.pep723 import PEP723Exception, pep723_metadata
 from pip._internal.req.req_dependency_group import parse_dependency_groups
 from pip._internal.req.req_file import parse_requirements
 from pip._internal.req.req_install import InstallRequirement
 from pip._internal.resolution.base import BaseResolver
+from pip._internal.utils.packaging import check_requires_python
 from pip._internal.utils.temp_dir import (
     TempDirectory,
     TempDirectoryTypeRegistry,
@@ -93,6 +104,31 @@ def with_cleanup(
     return wrapper
 
 
+def parse_constraint_files(
+    constraint_files: list[str],
+    finder: PackageFinder,
+    options: Values,
+    session: PipSession,
+) -> list[InstallRequirement]:
+    requirements = []
+    for filename in constraint_files:
+        for parsed_req in parse_requirements(
+            filename,
+            constraint=True,
+            finder=finder,
+            options=options,
+            session=session,
+        ):
+            req_to_add = install_req_from_parsed_requirement(
+                parsed_req,
+                isolated=options.isolated_mode,
+                user_supplied=False,
+            )
+            requirements.append(req_to_add)
+
+    return requirements
+
+
 class RequirementCommand(IndexGroupCommand):
     def __init__(self, *args: Any, **kw: Any) -> None:
         super().__init__(*args, **kw)
@@ -152,16 +188,31 @@ class RequirementCommand(IndexGroupCommand):
             "build-constraint" in options.features_enabled
         )
 
+        env_installer: BuildEnvironmentInstaller
+        if "inprocess-build-deps" in options.features_enabled:
+            build_constraint_reqs = parse_constraint_files(
+                build_constraints, finder, options, session
+            )
+            env_installer = InprocessBuildEnvironmentInstaller(
+                finder=finder,
+                build_tracker=build_tracker,
+                build_constraints=build_constraint_reqs,
+                verbosity=verbosity,
+                wheel_cache=WheelCache(options.cache_dir),
+            )
+        else:
+            env_installer = SubprocessBuildEnvironmentInstaller(
+                finder,
+                build_constraints=build_constraints,
+                build_constraint_feature_enabled=build_constraint_feature_enabled,
+            )
+
         return RequirementPreparer(
             build_dir=temp_build_dir_path,
             src_dir=options.src_dir,
             download_dir=download_dir,
             build_isolation=options.build_isolation,
-            build_isolation_installer=SubprocessBuildEnvironmentInstaller(
-                finder,
-                build_constraints=build_constraints,
-                build_constraint_feature_enabled=build_constraint_feature_enabled,
-            ),
+            build_isolation_installer=env_installer,
             check_build_deps=options.check_build_deps,
             build_tracker=build_tracker,
             session=session,
@@ -172,7 +223,6 @@ class RequirementCommand(IndexGroupCommand):
             lazy_wheel=lazy_wheel,
             verbosity=verbosity,
             legacy_resolver=legacy_resolver,
-            resume_retries=options.resume_retries,
         )
 
     @classmethod
@@ -245,22 +295,14 @@ class RequirementCommand(IndexGroupCommand):
         requirements: list[InstallRequirement] = []
 
         if not should_ignore_regular_constraints(options):
-            for filename in options.constraints:
-                for parsed_req in parse_requirements(
-                    filename,
-                    constraint=True,
-                    finder=finder,
-                    options=options,
-                    session=session,
-                ):
-                    req_to_add = install_req_from_parsed_requirement(
-                        parsed_req,
-                        isolated=options.isolated_mode,
-                        user_supplied=False,
-                    )
-                    requirements.append(req_to_add)
+            constraints = parse_constraint_files(
+                options.constraints, finder, options, session
+            )
+            requirements.extend(constraints)
 
         for req in args:
+            if not req.strip():
+                continue
             req_to_add = install_req_from_line(
                 req,
                 comes_from=None,
@@ -305,6 +347,38 @@ class RequirementCommand(IndexGroupCommand):
                 )
                 requirements.append(req_to_add)
 
+        if options.requirements_from_scripts:
+            if len(options.requirements_from_scripts) > 1:
+                raise CommandError("--requirements-from-script can only be given once")
+
+            script = options.requirements_from_scripts[0]
+            try:
+                script_metadata = pep723_metadata(script)
+            except PEP723Exception as exc:
+                raise CommandError(exc.msg)
+
+            script_requires_python = script_metadata.get("requires-python", "")
+
+            if script_requires_python and not options.ignore_requires_python:
+                target_python = make_target_python(options)
+
+                if not check_requires_python(
+                    requires_python=script_requires_python,
+                    version_info=target_python.py_version_info,
+                ):
+                    raise UnsupportedPythonVersion(
+                        f"Script {script!r} requires a different Python: "
+                        f"{target_python.py_version} not in {script_requires_python!r}"
+                    )
+
+            for req in script_metadata.get("dependencies", []):
+                req_to_add = install_req_from_req_string(
+                    req,
+                    isolated=options.isolated_mode,
+                    user_supplied=True,
+                )
+                requirements.append(req_to_add)
+
         # If any requirement has hash options, enable hash checking.
         if any(req.has_hash_options for req in requirements):
             options.require_hashes = True
@@ -314,6 +388,7 @@ class RequirementCommand(IndexGroupCommand):
             or options.editables
             or options.requirements
             or options.dependency_groups
+            or options.requirements_from_scripts
         ):
             opts = {"name": self.name}
             if options.find_links:
@@ -359,7 +434,7 @@ class RequirementCommand(IndexGroupCommand):
         selection_prefs = SelectionPreferences(
             allow_yanked=True,
             format_control=options.format_control,
-            allow_all_prereleases=options.pre,
+            release_control=options.release_control,
             prefer_binary=options.prefer_binary,
             ignore_requires_python=ignore_requires_python,
         )
@@ -368,4 +443,5 @@ class RequirementCommand(IndexGroupCommand):
             link_collector=link_collector,
             selection_prefs=selection_prefs,
             target_python=target_python,
+            uploaded_prior_to=options.uploaded_prior_to,
         )

pip/_internal/commands/cache.py

@@ -189,7 +189,31 @@ class CacheCommand(Command):
             bytes_removed += os.stat(filename).st_size
             os.unlink(filename)
             logger.verbose("Removed %s", filename)
+
+        http_dirs = filesystem.subdirs_without_files(self._cache_dir(options, "http"))
+        wheel_dirs = filesystem.subdirs_without_wheels(
+            self._cache_dir(options, "wheels")
+        )
+        dirs = [*http_dirs, *wheel_dirs]
+
+        for subdir in dirs:
+            try:
+                for file in subdir.iterdir():
+                    file.unlink(missing_ok=True)
+                subdir.rmdir()
+            except FileNotFoundError:
+                # If the directory is already gone, that's fine.
+                pass
+            logger.verbose("Removed %s", subdir)
+
+        # selfcheck.json is no longer used by pip.
+        selfcheck_json = self._cache_dir(options, "selfcheck.json")
+        if os.path.isfile(selfcheck_json):
+            os.remove(selfcheck_json)
+            logger.verbose("Removed legacy selfcheck.json file")
+
         logger.info("Files removed: %s (%s)", len(files), format_size(bytes_removed))
+        logger.info("Directories removed: %s", len(dirs))
 
     def purge_cache(self, options: Values, args: list[str]) -> None:
         if args:

pip/_internal/commands/completion.py

@@ -14,9 +14,10 @@ COMPLETION_SCRIPTS = {
     "bash": """
         _pip_completion()
         {{
+            local IFS=$' \\t\\n'
             COMPREPLY=( $( COMP_WORDS="${{COMP_WORDS[*]}}" \\
                            COMP_CWORD=$COMP_CWORD \\
-                           PIP_AUTO_COMPLETE=1 $1 2>/dev/null ) )
+                           PIP_AUTO_COMPLETE=1 "$1" 2>/dev/null ) )
         }}
         complete -o default -F _pip_completion {prog}
     """,

pip/_internal/commands/download.py

@@ -37,12 +37,9 @@ class DownloadCommand(RequirementCommand):
         self.cmd_opts.add_option(cmdoptions.constraints())
         self.cmd_opts.add_option(cmdoptions.build_constraints())
         self.cmd_opts.add_option(cmdoptions.requirements())
+        self.cmd_opts.add_option(cmdoptions.requirements_from_scripts())
         self.cmd_opts.add_option(cmdoptions.no_deps())
-        self.cmd_opts.add_option(cmdoptions.no_binary())
-        self.cmd_opts.add_option(cmdoptions.only_binary())
-        self.cmd_opts.add_option(cmdoptions.prefer_binary())
         self.cmd_opts.add_option(cmdoptions.src())
-        self.cmd_opts.add_option(cmdoptions.pre())
         self.cmd_opts.add_option(cmdoptions.require_hashes())
         self.cmd_opts.add_option(cmdoptions.progress_bar())
         self.cmd_opts.add_option(cmdoptions.no_build_isolation())
@@ -68,7 +65,13 @@ class DownloadCommand(RequirementCommand):
             self.parser,
         )
 
+        selection_opts = cmdoptions.make_option_group(
+            cmdoptions.package_selection_group,
+            self.parser,
+        )
+
         self.parser.insert_option_group(0, index_opts)
+        self.parser.insert_option_group(0, selection_opts)
         self.parser.insert_option_group(0, self.cmd_opts)
 
     @with_cleanup
@@ -80,6 +83,7 @@ class DownloadCommand(RequirementCommand):
 
         cmdoptions.check_dist_restriction(options)
         cmdoptions.check_build_constraints(options)
+        cmdoptions.check_release_control_exclusive(options)
 
         options.download_dir = normalize_path(options.download_dir)
         ensure_dir(options.download_dir)

pip/_internal/commands/index.py

@@ -6,6 +6,7 @@ from collections.abc import Iterable
 from optparse import Values
 from typing import Any, Callable
 
+from pip._vendor.packaging.utils import canonicalize_name
 from pip._vendor.packaging.version import Version
 
 from pip._internal.cli import cmdoptions
@@ -40,17 +41,20 @@ class IndexCommand(IndexGroupCommand):
         cmdoptions.add_target_python_options(self.cmd_opts)
 
         self.cmd_opts.add_option(cmdoptions.ignore_requires_python())
-        self.cmd_opts.add_option(cmdoptions.pre())
         self.cmd_opts.add_option(cmdoptions.json())
-        self.cmd_opts.add_option(cmdoptions.no_binary())
-        self.cmd_opts.add_option(cmdoptions.only_binary())
 
         index_opts = cmdoptions.make_option_group(
             cmdoptions.index_group,
             self.parser,
         )
 
+        selection_opts = cmdoptions.make_option_group(
+            cmdoptions.package_selection_group,
+            self.parser,
+        )
+
         self.parser.insert_option_group(0, index_opts)
+        self.parser.insert_option_group(0, selection_opts)
         self.parser.insert_option_group(0, self.cmd_opts)
 
     def handler_map(self) -> dict[str, Callable[[Values, list[str]], None]]:
@@ -59,6 +63,8 @@ class IndexCommand(IndexGroupCommand):
         }
 
     def run(self, options: Values, args: list[str]) -> int:
+        cmdoptions.check_release_control_exclusive(options)
+
         handler_map = self.handler_map()
 
         # Determine action
@@ -95,7 +101,8 @@ class IndexCommand(IndexGroupCommand):
         # Pass allow_yanked=False to ignore yanked versions.
         selection_prefs = SelectionPreferences(
             allow_yanked=False,
-            allow_all_prereleases=options.pre,
+            release_control=options.release_control,
+            format_control=options.format_control,
             ignore_requires_python=ignore_requires_python,
         )
 
@@ -103,6 +110,7 @@ class IndexCommand(IndexGroupCommand):
             link_collector=link_collector,
             selection_prefs=selection_prefs,
             target_python=target_python,
+            uploaded_prior_to=options.uploaded_prior_to,
         )
 
     def get_available_package_versions(self, options: Values, args: list[Any]) -> None:
@@ -124,8 +132,7 @@ class IndexCommand(IndexGroupCommand):
                 candidate.version for candidate in finder.find_all_candidates(query)
             )
 
-            if not options.pre:
-                # Remove prereleases
+            if self.should_exclude_prerelease(options, canonicalize_name(query)):
                 versions = (
                     version for version in versions if not version.is_prerelease
                 )