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

pip/__init__.py

@@ -1,9 +1,9 @@
-from typing import List, Optional
+from __future__ import annotations
 
-__version__ = "25.1.1"
+__version__ = "25.3"
 
 
-def main(args: Optional[List[str]] = None) -> int:
+def main(args: list[str] | None = None) -> int:
     """This is an internal API only meant for use by pip's own console scripts.
 
     For additional details, see https://github.com/pypa/pip/issues/7498.

pip/_internal/__init__.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from __future__ import annotations
 
 from pip._internal.utils import _log
 
@@ -7,7 +7,7 @@ from pip._internal.utils import _log
 _log.init_logging()
 
 
-def main(args: Optional[List[str]] = None) -> int:
+def main(args: list[str] | None = None) -> int:
     """This is preserved for old console scripts that may still be referencing
     it.
 

pip/_internal/build_env.py

@@ -1,5 +1,7 @@
 """Build Environment used for isolation during sdist building"""
 
+from __future__ import annotations
+
 import logging
 import os
 import pathlib
@@ -7,8 +9,9 @@ import site
 import sys
 import textwrap
 from collections import OrderedDict
+from collections.abc import Iterable
 from types import TracebackType
-from typing import TYPE_CHECKING, Iterable, List, Optional, Set, Tuple, Type, Union
+from typing import TYPE_CHECKING, Protocol, TypedDict
 
 from pip._vendor.packaging.version import Version
 
@@ -16,6 +19,7 @@ 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.deprecation import deprecated
 from pip._internal.utils.logging import VERBOSE
 from pip._internal.utils.packaging import get_requirement
 from pip._internal.utils.subprocess import call_subprocess
@@ -23,11 +27,16 @@ 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
+
+    class ExtraEnviron(TypedDict, total=False):
+        extra_environ: dict[str, str]
+
 
 logger = logging.getLogger(__name__)
 
 
-def _dedup(a: str, b: str) -> Union[Tuple[str], Tuple[str, str]]:
+def _dedup(a: str, b: str) -> tuple[str] | tuple[str, str]:
     return (a, b) if a != b else (a,)
 
 
@@ -56,7 +65,7 @@ def get_runnable_pip() -> str:
     return os.fsdecode(source / "__pip-runner__.py")
 
 
-def _get_system_sitepackages() -> Set[str]:
+def _get_system_sitepackages() -> set[str]:
     """Get system site packages
 
     Usually from site.getsitepackages,
@@ -76,10 +85,171 @@ def _get_system_sitepackages() -> Set[str]:
     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,
+        build_constraints: list[str] | None = None,
+        build_constraint_feature_enabled: bool = False,
+    ) -> None:
+        self.finder = finder
+        self._build_constraints = build_constraints or []
+        self._build_constraint_feature_enabled = build_constraint_feature_enabled
+
+    def _deprecation_constraint_check(self) -> None:
+        """
+        Check for deprecation warning: PIP_CONSTRAINT affecting build environments.
+
+        This warns when build-constraint feature is NOT enabled and PIP_CONSTRAINT
+        is not empty.
+        """
+        if self._build_constraint_feature_enabled or self._build_constraints:
+            return
+
+        pip_constraint = os.environ.get("PIP_CONSTRAINT")
+        if not pip_constraint or not pip_constraint.strip():
+            return
+
+        deprecated(
+            reason=(
+                "Setting PIP_CONSTRAINT will not affect "
+                "build constraints in the future,"
+            ),
+            replacement=(
+                "to specify build constraints using --build-constraint or "
+                "PIP_BUILD_CONSTRAINT. To disable this warning without "
+                "any build constraints set --use-feature=build-constraint or "
+                'PIP_USE_FEATURE="build-constraint"'
+            ),
+            gone_in="26.2",
+            issue=None,
+        )
+
+    def install(
+        self,
+        requirements: Iterable[str],
+        prefix: _Prefix,
+        *,
+        kind: str,
+        for_req: InstallRequirement | None,
+    ) -> None:
+        self._deprecation_constraint_check()
+
+        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")
+
+        # Handle build constraints
+        if self._build_constraint_feature_enabled:
+            args.extend(["--use-feature", "build-constraint"])
+
+        if self._build_constraints:
+            # Build constraints must be passed as both constraints
+            # and build constraints, so that nested builds receive
+            # build constraints
+            for constraint_file in self._build_constraints:
+                args.extend(["--constraint", constraint_file])
+                args.extend(["--build-constraint", constraint_file])
+
+        extra_environ: ExtraEnviron = {}
+        if self._build_constraint_feature_enabled and not self._build_constraints:
+            # If there are no build constraints but the build constraints
+            # feature is enabled then we must ignore regular constraints
+            # in the isolated build environment
+            extra_environ = {"extra_environ": {"_PIP_IN_BUILD_IGNORE_CONSTRAINTS": "1"}}
+
+        args.append("--")
+        args.extend(requirements)
+
+        identify_requirement = (
+            f" for {for_req.name}" if for_req and for_req.name else ""
+        )
+        with open_spinner(f"Installing {kind}") as spinner:
+            call_subprocess(
+                args,
+                command_desc=f"installing {kind}{identify_requirement}",
+                spinner=spinner,
+                **extra_environ,
+            )
+
+
 class BuildEnvironment:
     """Creates and manages an isolated environment to install build deps"""
 
-    def __init__(self) -> None:
+    def __init__(self, installer: BuildEnvironmentInstaller) -> None:
+        self.installer = installer
         temp_dir = TempDirectory(kind=tempdir_kinds.BUILD_ENV, globally_managed=True)
 
         self._prefixes = OrderedDict(
@@ -87,8 +257,8 @@ class BuildEnvironment:
             for name in ("normal", "overlay")
         )
 
-        self._bin_dirs: List[str] = []
-        self._lib_dirs: List[str] = []
+        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)
@@ -156,9 +326,9 @@ class BuildEnvironment:
 
     def __exit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        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:
@@ -168,7 +338,7 @@ class BuildEnvironment:
 
     def check_requirements(
         self, reqs: Iterable[str]
-    ) -> Tuple[Set[Tuple[str, str]], Set[str]]:
+    ) -> tuple[set[tuple[str, str]], set[str]]:
         """Return 2 sets:
         - conflicting requirements: set of (installed, wanted) reqs tuples
         - missing requirements: set of reqs
@@ -202,96 +372,18 @@ class BuildEnvironment:
 
     def install_requirements(
         self,
-        finder: "PackageFinder",
         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._install_requirements(
-            get_runnable_pip(),
-            finder,
-            requirements,
-            prefix,
-            kind=kind,
-        )
-
-    @staticmethod
-    def _install_requirements(
-        pip_runnable: str,
-        finder: "PackageFinder",
-        requirements: Iterable[str],
-        prefix: _Prefix,
-        *,
-        kind: str,
-    ) -> None:
-        args: List[str] = [
-            sys.executable,
-            pip_runnable,
-            "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,
-            )
+        self.installer.install(requirements, prefix, kind=kind, for_req=for_req)
 
 
 class NoOpBuildEnvironment(BuildEnvironment):
@@ -305,9 +397,9 @@ class NoOpBuildEnvironment(BuildEnvironment):
 
     def __exit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         pass
 
@@ -316,10 +408,10 @@ class NoOpBuildEnvironment(BuildEnvironment):
 
     def install_requirements(
         self,
-        finder: "PackageFinder",
         requirements: Iterable[str],
         prefix_as_string: str,
         *,
         kind: str,
+        for_req: InstallRequirement | None = None,
     ) -> None:
         raise NotImplementedError()

pip/_internal/cache.py

@@ -1,11 +1,13 @@
 """Cache Management"""
 
+from __future__ import annotations
+
 import hashlib
 import json
 import logging
 import os
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from pip._vendor.packaging.tags import Tag, interpreter_name, interpreter_version
 from pip._vendor.packaging.utils import canonicalize_name
@@ -22,7 +24,7 @@ logger = logging.getLogger(__name__)
 ORIGIN_JSON_NAME = "origin.json"
 
 
-def _hash_dict(d: Dict[str, str]) -> str:
+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()
@@ -39,7 +41,7 @@ class Cache:
         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]:
+    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
@@ -72,7 +74,7 @@ class Cache:
 
         return parts
 
-    def _get_candidates(self, link: Link, canonical_package_name: str) -> List[Any]:
+    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 []
@@ -89,8 +91,8 @@ class Cache:
     def get(
         self,
         link: Link,
-        package_name: Optional[str],
-        supported_tags: List[Tag],
+        package_name: str | None,
+        supported_tags: list[Tag],
     ) -> Link:
         """Returns a link to a cached item if it exists, otherwise returns the
         passed link.
@@ -127,8 +129,8 @@ class SimpleWheelCache(Cache):
     def get(
         self,
         link: Link,
-        package_name: Optional[str],
-        supported_tags: List[Tag],
+        package_name: str | None,
+        supported_tags: list[Tag],
     ) -> Link:
         candidates = []
 
@@ -141,7 +143,7 @@ class SimpleWheelCache(Cache):
                 wheel = Wheel(wheel_name)
             except InvalidWheelFilename:
                 continue
-            if canonicalize_name(wheel.name) != canonical_package_name:
+            if wheel.name != canonical_package_name:
                 logger.debug(
                     "Ignoring cached wheel %s for %s as it "
                     "does not match the expected distribution name %s.",
@@ -188,7 +190,7 @@ class CacheEntry:
     ):
         self.link = link
         self.persistent = persistent
-        self.origin: Optional[DirectUrl] = None
+        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:
@@ -225,8 +227,8 @@ class WheelCache(Cache):
     def get(
         self,
         link: Link,
-        package_name: Optional[str],
-        supported_tags: List[Tag],
+        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:
@@ -236,9 +238,9 @@ class WheelCache(Cache):
     def get_cache_entry(
         self,
         link: Link,
-        package_name: Optional[str],
-        supported_tags: List[Tag],
-    ) -> Optional[CacheEntry]:
+        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.

pip/_internal/cli/autocompletion.py

@@ -1,10 +1,13 @@
 """Logic that powers autocompletion installed by ``pip completion``."""
 
+from __future__ import annotations
+
 import optparse
 import os
 import sys
+from collections.abc import Iterable
 from itertools import chain
-from typing import Any, Iterable, List, Optional
+from typing import Any
 
 from pip._internal.cli.main_parser import create_main_parser
 from pip._internal.commands import commands_dict, create_command
@@ -32,7 +35,7 @@ def autocomplete() -> None:
     options = []
 
     # subcommand
-    subcommand_name: Optional[str] = None
+    subcommand_name: str | None = None
     for word in cwords:
         if word in subcommands:
             subcommand_name = word
@@ -100,6 +103,12 @@ def autocomplete() -> None:
             if option[1] and option[0][:2] == "--":
                 opt_label += "="
             print(opt_label)
+
+        # Complete sub-commands (unless one is already given).
+        if not any(name in cwords for name in subcommand.handler_map()):
+            for handler_name in subcommand.handler_map():
+                if handler_name.startswith(current):
+                    print(handler_name)
     else:
         # show main parser options only when necessary
 
@@ -121,8 +130,8 @@ def autocomplete() -> None:
 
 
 def get_path_completion_type(
-    cwords: List[str], cword: int, opts: Iterable[Any]
-) -> Optional[str]:
+    cwords: list[str], cword: int, opts: Iterable[Any]
+) -> str | None:
     """Get the type of path completion (``file``, ``dir``, ``path`` or None)
 
     :param cwords: same as the environmental variable ``COMP_WORDS``

pip/_internal/cli/base_command.py

@@ -1,5 +1,7 @@
 """Base Command class, and related routines"""
 
+from __future__ import annotations
+
 import logging
 import logging.config
 import optparse
@@ -7,7 +9,7 @@ import os
 import sys
 import traceback
 from optparse import Values
-from typing import List, Optional, Tuple
+from typing import Callable
 
 from pip._vendor.rich import reconfigure
 from pip._vendor.rich import traceback as rich_traceback
@@ -60,7 +62,7 @@ class Command(CommandContextMixIn):
             isolated=isolated,
         )
 
-        self.tempdir_registry: Optional[TempDirRegistry] = None
+        self.tempdir_registry: TempDirRegistry | None = None
 
         # Commands should add options to this option group
         optgroup_name = f"{self.name.capitalize()} Options"
@@ -87,10 +89,10 @@ class Command(CommandContextMixIn):
         # are present.
         assert not hasattr(options, "no_index")
 
-    def run(self, options: Values, args: List[str]) -> int:
+    def run(self, options: Values, args: list[str]) -> int:
         raise NotImplementedError
 
-    def _run_wrapper(self, level_number: int, options: Values, args: List[str]) -> int:
+    def _run_wrapper(self, level_number: int, options: Values, args: list[str]) -> int:
         def _inner_run() -> int:
             try:
                 return self.run(options, args)
@@ -147,18 +149,18 @@ class Command(CommandContextMixIn):
 
             return UNKNOWN_ERROR
 
-    def parse_args(self, args: List[str]) -> Tuple[Values, List[str]]:
+    def parse_args(self, args: list[str]) -> tuple[Values, list[str]]:
         # factored out for testability
         return self.parser.parse_args(args)
 
-    def main(self, args: List[str]) -> int:
+    def main(self, args: list[str]) -> int:
         try:
             with self.main_context():
                 return self._main(args)
         finally:
             logging.shutdown()
 
-    def _main(self, args: List[str]) -> int:
+    def _main(self, args: list[str]) -> int:
         # We must initialize this before the tempdir manager, otherwise the
         # configuration would not be accessible by the time we clean up the
         # tempdir manager.
@@ -174,6 +176,9 @@ class Command(CommandContextMixIn):
         if options.debug_mode:
             self.verbosity = 2
 
+        if hasattr(options, "progress_bar") and options.progress_bar == "auto":
+            options.progress_bar = "on" if self.verbosity >= 0 else "off"
+
         reconfigure(no_color=options.no_color)
         level_number = setup_logging(
             verbosity=self.verbosity,
@@ -231,3 +236,9 @@ class Command(CommandContextMixIn):
                 options.cache_dir = None
 
         return self._run_wrapper(level_number, options, args)
+
+    def handler_map(self) -> dict[str, Callable[[Values, list[str]], None]]:
+        """
+        map of names to handler actions for commands with sub-actions
+        """
+        return {}