pip 25.1__py3-none-any.whl → 25.2__py3-none-any.whl

pip/_internal/cli/index_command.py

@@ -6,12 +6,14 @@ 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, List, Optional
+from typing import TYPE_CHECKING
 
 from pip._vendor import certifi
 
@@ -27,7 +29,7 @@ logger = logging.getLogger(__name__)
 
 
 @lru_cache
-def _create_truststore_ssl_context() -> Optional["SSLContext"]:
+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
@@ -56,10 +58,10 @@ class SessionCommandMixin(CommandContextMixIn):
 
     def __init__(self) -> None:
         super().__init__()
-        self._session: Optional[PipSession] = None
+        self._session: PipSession | None = None
 
     @classmethod
-    def _get_index_urls(cls, options: Values) -> Optional[List[str]]:
+    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):
@@ -72,7 +74,7 @@ class SessionCommandMixin(CommandContextMixIn):
         # Return None rather than an empty list
         return index_urls or None
 
-    def get_default_session(self, options: Values) -> "PipSession":
+    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))
@@ -85,9 +87,9 @@ class SessionCommandMixin(CommandContextMixIn):
     def _build_session(
         self,
         options: Values,
-        retries: Optional[int] = None,
-        timeout: Optional[int] = None,
-    ) -> "PipSession":
+        retries: int | None = None,
+        timeout: int | None = None,
+    ) -> PipSession:
         from pip._internal.network.session import PipSession
 
         cache_dir = options.cache_dir
@@ -134,7 +136,7 @@ class SessionCommandMixin(CommandContextMixIn):
         return session
 
 
-def _pip_self_version_check(session: "PipSession", options: Values) -> None:
+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)

pip/_internal/cli/main.py

@@ -1,11 +1,12 @@
 """Primary application entrypoint."""
 
+from __future__ import annotations
+
 import locale
 import logging
 import os
 import sys
 import warnings
-from typing import List, Optional
 
 from pip._internal.cli.autocompletion import autocomplete
 from pip._internal.cli.main_parser import parse_command
@@ -43,7 +44,7 @@ logger = logging.getLogger(__name__)
 # main, this should not be an issue in practice.
 
 
-def main(args: Optional[List[str]] = None) -> int:
+def main(args: list[str] | None = None) -> int:
     if args is None:
         args = sys.argv[1:]
 

pip/_internal/cli/main_parser.py

@@ -1,9 +1,10 @@
 """A single place for constructing and exposing the main parser"""
 
+from __future__ import annotations
+
 import os
 import subprocess
 import sys
-from typing import List, Optional, Tuple
 
 from pip._internal.build_env import get_runnable_pip
 from pip._internal.cli import cmdoptions
@@ -46,7 +47,7 @@ def create_main_parser() -> ConfigOptionParser:
     return parser
 
 
-def identify_python_interpreter(python: str) -> Optional[str]:
+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.
@@ -65,7 +66,7 @@ def identify_python_interpreter(python: str) -> Optional[str]:
     return None
 
 
-def parse_command(args: List[str]) -> Tuple[str, List[str]]:
+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

pip/_internal/cli/parser.py

@@ -1,12 +1,15 @@
 """Base option parser setup"""
 
+from __future__ import annotations
+
 import logging
 import optparse
 import shutil
 import sys
 import textwrap
+from collections.abc import Generator
 from contextlib import suppress
-from typing import Any, Dict, Generator, List, NoReturn, Optional, Tuple
+from typing import Any, NoReturn
 
 from pip._internal.cli.status_codes import UNKNOWN_ERROR
 from pip._internal.configuration import Configuration, ConfigurationError
@@ -67,7 +70,7 @@ class PrettyHelpFormatter(optparse.IndentedHelpFormatter):
         msg = "\nUsage: {}\n".format(self.indent_lines(textwrap.dedent(usage), "  "))
         return msg
 
-    def format_description(self, description: Optional[str]) -> str:
+    def format_description(self, description: str | None) -> str:
         # leave full control over description to us
         if description:
             if hasattr(self.parser, "main"):
@@ -85,7 +88,7 @@ class PrettyHelpFormatter(optparse.IndentedHelpFormatter):
         else:
             return ""
 
-    def format_epilog(self, epilog: Optional[str]) -> str:
+    def format_epilog(self, epilog: str | None) -> str:
         # leave full control over epilog to us
         if epilog:
             return epilog
@@ -142,7 +145,7 @@ class CustomOptionParser(optparse.OptionParser):
         return group
 
     @property
-    def option_list_all(self) -> List[optparse.Option]:
+    def option_list_all(self) -> list[optparse.Option]:
         """Get a list of all options, including those in option groups."""
         res = self.option_list[:]
         for i in self.option_groups:
@@ -177,33 +180,34 @@ class ConfigOptionParser(CustomOptionParser):
 
     def _get_ordered_configuration_items(
         self,
-    ) -> Generator[Tuple[str, Any], None, None]:
+    ) -> Generator[tuple[str, Any], None, None]:
         # Configuration gives keys in an unordered manner. Order them.
         override_order = ["global", self.name, ":env:"]
 
         # Pool the options into different groups
-        section_items: Dict[str, List[Tuple[str, Any]]] = {
+        section_items: dict[str, list[tuple[str, Any]]] = {
             name: [] for name in override_order
         }
-        for section_key, val in self.config.items():
-            # ignore empty values
-            if not val:
-                logger.debug(
-                    "Ignoring configuration key '%s' as it's value is empty.",
-                    section_key,
-                )
-                continue
 
-            section, key = section_key.split(".", 1)
-            if section in override_order:
-                section_items[section].append((key, val))
+        for _, value in self.config.items():  # noqa: PERF102
+            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))
 
-        # Yield each group in their override order
-        for section in override_order:
-            for key, val in section_items[section]:
-                yield key, val
+            # Yield each group in their override order
+            for section in override_order:
+                yield from section_items[section]
 
-    def _update_defaults(self, defaults: Dict[str, Any]) -> Dict[str, Any]:
+    def _update_defaults(self, defaults: dict[str, Any]) -> dict[str, Any]:
         """Updates the given defaults with values from the config files and
         the environ. Does a little special handling for certain types of
         options (lists)."""

pip/_internal/cli/progress_bars.py

@@ -1,6 +1,9 @@
+from __future__ import annotations
+
 import functools
 import sys
-from typing import Callable, Generator, Iterable, Iterator, Optional, Tuple, TypeVar
+from collections.abc import Generator, Iterable, Iterator
+from typing import Callable, Literal, TypeVar
 
 from pip._vendor.rich.progress import (
     BarColumn,
@@ -22,20 +25,21 @@ from pip._internal.utils.logging import get_console, get_indentation
 
 T = TypeVar("T")
 ProgressRenderer = Callable[[Iterable[T]], Iterator[T]]
+BarType = Literal["on", "off", "raw"]
 
 
 def _rich_download_progress_bar(
     iterable: Iterable[bytes],
     *,
-    bar_type: str,
-    size: Optional[int],
-    initial_progress: Optional[int] = None,
+    bar_type: BarType,
+    size: int | None,
+    initial_progress: int | None = None,
 ) -> Generator[bytes, None, None]:
     assert bar_type == "on", "This should only be used in the default mode."
 
     if not size:
         total = float("inf")
-        columns: Tuple[ProgressColumn, ...] = (
+        columns: tuple[ProgressColumn, ...] = (
             TextColumn("[progress.description]{task.description}"),
             SpinnerColumn("line", speed=1.5),
             FileSizeColumn(),
@@ -49,18 +53,21 @@ def _rich_download_progress_bar(
             BarColumn(),
             DownloadColumn(),
             TransferSpeedColumn(),
-            TextColumn("eta"),
-            TimeRemainingColumn(),
+            TextColumn("{task.fields[time_description]}"),
+            TimeRemainingColumn(elapsed_when_finished=True),
         )
 
     progress = Progress(*columns, refresh_per_second=5)
-    task_id = progress.add_task(" " * (get_indentation() + 2), total=total)
+    task_id = progress.add_task(
+        " " * (get_indentation() + 2), total=total, time_description="eta"
+    )
     if initial_progress is not None:
         progress.update(task_id, advance=initial_progress)
     with progress:
         for chunk in iterable:
             yield chunk
             progress.update(task_id, advance=len(chunk))
+        progress.update(task_id, time_description="")
 
 
 def _rich_install_progress_bar(
@@ -88,8 +95,8 @@ def _rich_install_progress_bar(
 def _raw_progress_bar(
     iterable: Iterable[bytes],
     *,
-    size: Optional[int],
-    initial_progress: Optional[int] = None,
+    size: int | None,
+    initial_progress: int | None = None,
 ) -> Generator[bytes, None, None]:
     def write_progress(current: int, total: int) -> None:
         sys.stdout.write(f"Progress {current} of {total}\n")
@@ -109,7 +116,7 @@ def _raw_progress_bar(
 
 
 def get_download_progress_renderer(
-    *, bar_type: str, size: Optional[int] = None, initial_progress: Optional[int] = None
+    *, bar_type: BarType, size: int | None = None, initial_progress: int | None = None
 ) -> ProgressRenderer[bytes]:
     """Get an object that can be used to render the download progress.
 
@@ -133,7 +140,7 @@ def get_download_progress_renderer(
 
 
 def get_install_progress_renderer(
-    *, bar_type: str, total: int
+    *, bar_type: BarType, total: int
 ) -> ProgressRenderer[InstallRequirement]:
     """Get an object that can be used to render the install progress.
     Returns a callable, that takes an iterable to "wrap".

pip/_internal/cli/req_command.py

@@ -5,11 +5,14 @@ need PackageFinder capability don't unnecessarily import the
 PackageFinder machinery and all its vendored dependencies, etc.
 """
 
+from __future__ import annotations
+
 import logging
 from functools import partial
 from optparse import Values
-from typing import Any, List, Optional, Tuple
+from typing import Any
 
+from pip._internal.build_env import SubprocessBuildEnvironmentInstaller
 from pip._internal.cache import WheelCache
 from pip._internal.cli import cmdoptions
 from pip._internal.cli.index_command import IndexGroupCommand
@@ -58,8 +61,8 @@ def with_cleanup(func: Any) -> Any:
             registry.set_delete(t, False)
 
     def wrapper(
-        self: RequirementCommand, options: Values, args: List[Any]
-    ) -> Optional[int]:
+        self: RequirementCommand, options: Values, args: list[Any]
+    ) -> int | None:
         assert self.tempdir_registry is not None
         if options.no_clean:
             configure_tempdir_registry(self.tempdir_registry)
@@ -100,7 +103,7 @@ class RequirementCommand(IndexGroupCommand):
         session: PipSession,
         finder: PackageFinder,
         use_user_site: bool,
-        download_dir: Optional[str] = None,
+        download_dir: str | None = None,
         verbosity: int = 0,
     ) -> RequirementPreparer:
         """
@@ -134,6 +137,7 @@ class RequirementCommand(IndexGroupCommand):
             src_dir=options.src_dir,
             download_dir=download_dir,
             build_isolation=options.build_isolation,
+            build_isolation_installer=SubprocessBuildEnvironmentInstaller(finder),
             check_build_deps=options.check_build_deps,
             build_tracker=build_tracker,
             session=session,
@@ -153,14 +157,14 @@ class RequirementCommand(IndexGroupCommand):
         preparer: RequirementPreparer,
         finder: PackageFinder,
         options: Values,
-        wheel_cache: Optional[WheelCache] = None,
+        wheel_cache: WheelCache | None = None,
         use_user_site: bool = False,
         ignore_installed: bool = True,
         ignore_requires_python: bool = False,
         force_reinstall: bool = False,
         upgrade_strategy: str = "to-satisfy-only",
-        use_pep517: Optional[bool] = None,
-        py_version_info: Optional[Tuple[int, ...]] = None,
+        use_pep517: bool | None = None,
+        py_version_info: tuple[int, ...] | None = None,
     ) -> BaseResolver:
         """
         Create a Resolver instance for the given parameters.
@@ -208,15 +212,15 @@ class RequirementCommand(IndexGroupCommand):
 
     def get_requirements(
         self,
-        args: List[str],
+        args: list[str],
         options: Values,
         finder: PackageFinder,
         session: PipSession,
-    ) -> List[InstallRequirement]:
+    ) -> list[InstallRequirement]:
         """
         Parse command-line arguments into the corresponding requirements.
         """
-        requirements: List[InstallRequirement] = []
+        requirements: list[InstallRequirement] = []
         for filename in options.constraints:
             for parsed_req in parse_requirements(
                 filename,
@@ -322,8 +326,8 @@ class RequirementCommand(IndexGroupCommand):
         self,
         options: Values,
         session: PipSession,
-        target_python: Optional[TargetPython] = None,
-        ignore_requires_python: Optional[bool] = None,
+        target_python: TargetPython | None = None,
+        ignore_requires_python: bool | None = None,
     ) -> PackageFinder:
         """
         Create a package finder appropriate to this requirement command.

pip/_internal/cli/spinners.py

@@ -1,15 +1,31 @@
+from __future__ import annotations
+
 import contextlib
 import itertools
 import logging
 import sys
 import time
-from typing import IO, Generator, Optional
+from collections.abc import Generator
+from typing import IO, Final
+
+from pip._vendor.rich.console import (
+    Console,
+    ConsoleOptions,
+    RenderableType,
+    RenderResult,
+)
+from pip._vendor.rich.live import Live
+from pip._vendor.rich.measure import Measurement
+from pip._vendor.rich.text import Text
 
 from pip._internal.utils.compat import WINDOWS
-from pip._internal.utils.logging import get_indentation
+from pip._internal.utils.logging import get_console, get_indentation
 
 logger = logging.getLogger(__name__)
 
+SPINNER_CHARS: Final = r"-\|/"
+SPINS_PER_SECOND: Final = 8
+
 
 class SpinnerInterface:
     def spin(self) -> None:
@@ -23,10 +39,10 @@ class InteractiveSpinner(SpinnerInterface):
     def __init__(
         self,
         message: str,
-        file: Optional[IO[str]] = None,
-        spin_chars: str = "-\\|/",
+        file: IO[str] | None = None,
+        spin_chars: str = SPINNER_CHARS,
         # Empirically, 8 updates/second looks nice
-        min_update_interval_seconds: float = 0.125,
+        min_update_interval_seconds: float = 1 / SPINS_PER_SECOND,
     ):
         self._message = message
         if file is None:
@@ -136,6 +152,66 @@ def open_spinner(message: str) -> Generator[SpinnerInterface, None, None]:
         spinner.finish("done")
 
 
+class _PipRichSpinner:
+    """
+    Custom rich spinner that matches the style of the legacy spinners.
+
+    (*) Updates will be handled in a background thread by a rich live panel
+        which will call render() automatically at the appropriate time.
+    """
+
+    def __init__(self, label: str) -> None:
+        self.label = label
+        self._spin_cycle = itertools.cycle(SPINNER_CHARS)
+        self._spinner_text = ""
+        self._finished = False
+        self._indent = get_indentation() * " "
+
+    def __rich_console__(
+        self, console: Console, options: ConsoleOptions
+    ) -> RenderResult:
+        yield self.render()
+
+    def __rich_measure__(
+        self, console: Console, options: ConsoleOptions
+    ) -> Measurement:
+        text = self.render()
+        return Measurement.get(console, options, text)
+
+    def render(self) -> RenderableType:
+        if not self._finished:
+            self._spinner_text = next(self._spin_cycle)
+
+        return Text.assemble(self._indent, self.label, " ... ", self._spinner_text)
+
+    def finish(self, status: str) -> None:
+        """Stop spinning and set a final status message."""
+        self._spinner_text = status
+        self._finished = True
+
+
+@contextlib.contextmanager
+def open_rich_spinner(label: str, console: Console | None = None) -> Generator[None]:
+    if not logger.isEnabledFor(logging.INFO):
+        # Don't show spinner if --quiet is given.
+        yield
+        return
+
+    console = console or get_console()
+    spinner = _PipRichSpinner(label)
+    with Live(spinner, refresh_per_second=SPINS_PER_SECOND, console=console):
+        try:
+            yield
+        except KeyboardInterrupt:
+            spinner.finish("canceled")
+            raise
+        except Exception:
+            spinner.finish("error")
+            raise
+        else:
+            spinner.finish("done")
+
+
 HIDE_CURSOR = "\x1b[?25l"
 SHOW_CURSOR = "\x1b[?25h"
 

pip/_internal/commands/__init__.py

@@ -2,9 +2,11 @@
 Package containing all pip commands
 """
 
+from __future__ import annotations
+
 import importlib
 from collections import namedtuple
-from typing import Any, Dict, Optional
+from typing import Any
 
 from pip._internal.cli.base_command import Command
 
@@ -17,7 +19,7 @@ CommandInfo = namedtuple("CommandInfo", "module_path, class_name, summary")
 # 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] = {
+commands_dict: dict[str, CommandInfo] = {
     "install": CommandInfo(
         "pip._internal.commands.install",
         "InstallCommand",
@@ -123,7 +125,7 @@ def create_command(name: str, **kwargs: Any) -> Command:
     return command
 
 
-def get_similar_commands(name: str) -> Optional[str]:
+def get_similar_commands(name: str) -> str | None:
     """Command name auto-correct."""
     from difflib import get_close_matches
 

pip/_internal/commands/cache.py

@@ -1,7 +1,7 @@
 import os
 import textwrap
 from optparse import Values
-from typing import Any, List
+from typing import Callable
 
 from pip._internal.cli.base_command import Command
 from pip._internal.cli.status_codes import ERROR, SUCCESS
@@ -49,8 +49,8 @@ class CacheCommand(Command):
 
         self.parser.insert_option_group(0, self.cmd_opts)
 
-    def run(self, options: Values, args: List[str]) -> int:
-        handlers = {
+    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,
@@ -58,15 +58,18 @@ class CacheCommand(Command):
             "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 handlers:
+        if not args or args[0] not in handler_map:
             logger.error(
                 "Need an action (%s) to perform.",
-                ", ".join(sorted(handlers)),
+                ", ".join(sorted(handler_map)),
             )
             return ERROR
 
@@ -74,20 +77,20 @@ class CacheCommand(Command):
 
         # Error handling happens here, not in the action-handlers.
         try:
-            handlers[action](options, args[1:])
+            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[Any]) -> None:
+    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[Any]) -> None:
+    def get_cache_info(self, options: Values, args: list[str]) -> None:
         if args:
             raise CommandError("Too many arguments")
 
@@ -129,7 +132,7 @@ class CacheCommand(Command):
 
         logger.info(message)
 
-    def list_cache_items(self, options: Values, args: List[Any]) -> None:
+    def list_cache_items(self, options: Values, args: list[str]) -> None:
         if len(args) > 1:
             raise CommandError("Too many arguments")
 
@@ -144,7 +147,7 @@ class CacheCommand(Command):
         else:
             self.format_for_abspath(files)
 
-    def format_for_human(self, files: List[str]) -> None:
+    def format_for_human(self, files: list[str]) -> None:
         if not files:
             logger.info("No locally built wheels cached.")
             return
@@ -157,11 +160,11 @@ class CacheCommand(Command):
         logger.info("Cache contents:\n")
         logger.info("\n".join(sorted(results)))
 
-    def format_for_abspath(self, files: List[str]) -> None:
+    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[Any]) -> None:
+    def remove_cache_items(self, options: Values, args: list[str]) -> None:
         if len(args) > 1:
             raise CommandError("Too many arguments")
 
@@ -188,7 +191,7 @@ class CacheCommand(Command):
             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[Any]) -> None:
+    def purge_cache(self, options: Values, args: list[str]) -> None:
         if args:
             raise CommandError("Too many arguments")
 
@@ -197,14 +200,14 @@ class CacheCommand(Command):
     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]:
+    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]:
+    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:

pip/_internal/commands/check.py

@@ -1,6 +1,5 @@
 import logging
 from optparse import Values
-from typing import List
 
 from pip._internal.cli.base_command import Command
 from pip._internal.cli.status_codes import ERROR, SUCCESS
@@ -23,7 +22,7 @@ class CheckCommand(Command):
     usage = """
       %prog [options]"""
 
-    def run(self, options: Values, args: List[str]) -> int:
+    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(