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

pip/_internal/req/req_set.py

@@ -1,6 +1,5 @@
 import logging
 from collections import OrderedDict
-from typing import Dict, List
 
 from pip._vendor.packaging.utils import canonicalize_name
 
@@ -13,10 +12,10 @@ class RequirementSet:
     def __init__(self, check_supported_wheels: bool = True) -> None:
         """Create a RequirementSet."""
 
-        self.requirements: Dict[str, InstallRequirement] = OrderedDict()
+        self.requirements: dict[str, InstallRequirement] = OrderedDict()
         self.check_supported_wheels = check_supported_wheels
 
-        self.unnamed_requirements: List[InstallRequirement] = []
+        self.unnamed_requirements: list[InstallRequirement] = []
 
     def __str__(self) -> str:
         requirements = sorted(
@@ -65,11 +64,11 @@ class RequirementSet:
         raise KeyError(f"No project with the name {name!r}")
 
     @property
-    def all_requirements(self) -> List[InstallRequirement]:
+    def all_requirements(self) -> list[InstallRequirement]:
         return self.unnamed_requirements + list(self.requirements.values())
 
     @property
-    def requirements_to_install(self) -> List[InstallRequirement]:
+    def requirements_to_install(self) -> list[InstallRequirement]:
         """Return the list of requirements that need to be installed.
 
         TODO remove this property together with the legacy resolver, since the new

pip/_internal/req/req_uninstall.py

@@ -1,9 +1,12 @@
+from __future__ import annotations
+
 import functools
 import os
 import sys
 import sysconfig
+from collections.abc import Generator, Iterable
 from importlib.util import cache_from_source
-from typing import Any, Callable, Dict, Generator, Iterable, List, Optional, Set, Tuple
+from typing import Any, Callable
 
 from pip._internal.exceptions import LegacyDistutilsInstall, UninstallMissingRecord
 from pip._internal.locations import get_bin_prefix, get_bin_user
@@ -42,7 +45,7 @@ def _unique(
 ) -> Callable[..., Generator[Any, None, None]]:
     @functools.wraps(fn)
     def unique(*args: Any, **kw: Any) -> Generator[Any, None, None]:
-        seen: Set[Any] = set()
+        seen: set[Any] = set()
         for item in fn(*args, **kw):
             if item not in seen:
                 seen.add(item)
@@ -85,14 +88,14 @@ def uninstallation_paths(dist: BaseDistribution) -> Generator[str, None, None]:
             yield path
 
 
-def compact(paths: Iterable[str]) -> Set[str]:
+def compact(paths: Iterable[str]) -> set[str]:
     """Compact a path set to contain the minimal number of paths
     necessary to contain all paths in the set. If /a/path/ and
     /a/path/to/a/file.txt are both in the set, leave only the
     shorter path."""
 
     sep = os.path.sep
-    short_paths: Set[str] = set()
+    short_paths: set[str] = set()
     for path in sorted(paths, key=len):
         should_skip = any(
             path.startswith(shortpath.rstrip("*"))
@@ -104,7 +107,7 @@ def compact(paths: Iterable[str]) -> Set[str]:
     return short_paths
 
 
-def compress_for_rename(paths: Iterable[str]) -> Set[str]:
+def compress_for_rename(paths: Iterable[str]) -> set[str]:
     """Returns a set containing the paths that need to be renamed.
 
     This set may include directories when the original sequence of paths
@@ -113,7 +116,7 @@ def compress_for_rename(paths: Iterable[str]) -> Set[str]:
     case_map = {os.path.normcase(p): p for p in paths}
     remaining = set(case_map)
     unchecked = sorted({os.path.split(p)[0] for p in case_map.values()}, key=len)
-    wildcards: Set[str] = set()
+    wildcards: set[str] = set()
 
     def norm_join(*a: str) -> str:
         return os.path.normcase(os.path.join(*a))
@@ -123,8 +126,8 @@ def compress_for_rename(paths: Iterable[str]) -> Set[str]:
             # This directory has already been handled.
             continue
 
-        all_files: Set[str] = set()
-        all_subdirs: Set[str] = set()
+        all_files: set[str] = set()
+        all_subdirs: set[str] = set()
         for dirname, subdirs, files in os.walk(root):
             all_subdirs.update(norm_join(root, dirname, d) for d in subdirs)
             all_files.update(norm_join(root, dirname, f) for f in files)
@@ -138,7 +141,7 @@ def compress_for_rename(paths: Iterable[str]) -> Set[str]:
     return set(map(case_map.__getitem__, remaining)) | wildcards
 
 
-def compress_for_output_listing(paths: Iterable[str]) -> Tuple[Set[str], Set[str]]:
+def compress_for_output_listing(paths: Iterable[str]) -> tuple[set[str], set[str]]:
     """Returns a tuple of 2 sets of which paths to display to user
 
     The first set contains paths that would be deleted. Files of a package
@@ -194,10 +197,10 @@ class StashedUninstallPathSet:
     def __init__(self) -> None:
         # Mapping from source file root to [Adjacent]TempDirectory
         # for files under that directory.
-        self._save_dirs: Dict[str, TempDirectory] = {}
+        self._save_dirs: dict[str, TempDirectory] = {}
         # (old path, new path) tuples for each move that may need
         # to be undone.
-        self._moves: List[Tuple[str, str]] = []
+        self._moves: list[tuple[str, str]] = []
 
     def _get_directory_stash(self, path: str) -> str:
         """Stashes a directory.
@@ -297,9 +300,9 @@ class UninstallPathSet:
     requirement."""
 
     def __init__(self, dist: BaseDistribution) -> None:
-        self._paths: Set[str] = set()
-        self._refuse: Set[str] = set()
-        self._pth: Dict[str, UninstallPthEntries] = {}
+        self._paths: set[str] = set()
+        self._refuse: set[str] = set()
+        self._pth: dict[str, UninstallPthEntries] = {}
         self._dist = dist
         self._moved_paths = StashedUninstallPathSet()
         # Create local cache of normalize_path results. Creating an UninstallPathSet
@@ -421,7 +424,7 @@ class UninstallPathSet:
         self._moved_paths.commit()
 
     @classmethod
-    def from_dist(cls, dist: BaseDistribution) -> "UninstallPathSet":
+    def from_dist(cls, dist: BaseDistribution) -> UninstallPathSet:
         dist_location = dist.location
         info_location = dist.info_location
         if dist_location is None:
@@ -581,8 +584,8 @@ class UninstallPathSet:
 class UninstallPthEntries:
     def __init__(self, pth_file: str) -> None:
         self.file = pth_file
-        self.entries: Set[str] = set()
-        self._saved_lines: Optional[List[bytes]] = None
+        self.entries: set[str] = set()
+        self._saved_lines: list[bytes] | None = None
 
     def add(self, entry: str) -> None:
         entry = os.path.normcase(entry)

pip/_internal/resolution/base.py

@@ -1,4 +1,4 @@
-from typing import Callable, List, Optional
+from typing import Callable, Optional
 
 from pip._internal.req.req_install import InstallRequirement
 from pip._internal.req.req_set import RequirementSet
@@ -10,11 +10,11 @@ InstallRequirementProvider = Callable[
 
 class BaseResolver:
     def resolve(
-        self, root_reqs: List[InstallRequirement], check_supported_wheels: bool
+        self, root_reqs: list[InstallRequirement], check_supported_wheels: bool
     ) -> RequirementSet:
         raise NotImplementedError()
 
     def get_installation_order(
         self, req_set: RequirementSet
-    ) -> List[InstallRequirement]:
+    ) -> list[InstallRequirement]:
         raise NotImplementedError()

pip/_internal/resolution/legacy/resolver.py

@@ -10,11 +10,14 @@ for sub-dependencies
     a. "first found, wins" (where the order is breadth first)
 """
 
+from __future__ import annotations
+
 import logging
 import sys
 from collections import defaultdict
+from collections.abc import Iterable
 from itertools import chain
-from typing import DefaultDict, Iterable, List, Optional, Set, Tuple
+from typing import Optional
 
 from pip._vendor.packaging import specifiers
 from pip._vendor.packaging.requirements import Requirement
@@ -49,12 +52,12 @@ from pip._internal.utils.packaging import check_requires_python
 
 logger = logging.getLogger(__name__)
 
-DiscoveredDependencies = DefaultDict[Optional[str], List[InstallRequirement]]
+DiscoveredDependencies = defaultdict[Optional[str], list[InstallRequirement]]
 
 
 def _check_dist_requires_python(
     dist: BaseDistribution,
-    version_info: Tuple[int, int, int],
+    version_info: tuple[int, int, int],
     ignore_requires_python: bool = False,
 ) -> None:
     """
@@ -117,7 +120,7 @@ class Resolver(BaseResolver):
         self,
         preparer: RequirementPreparer,
         finder: PackageFinder,
-        wheel_cache: Optional[WheelCache],
+        wheel_cache: WheelCache | None,
         make_install_req: InstallRequirementProvider,
         use_user_site: bool,
         ignore_dependencies: bool,
@@ -125,7 +128,7 @@ class Resolver(BaseResolver):
         ignore_requires_python: bool,
         force_reinstall: bool,
         upgrade_strategy: str,
-        py_version_info: Optional[Tuple[int, ...]] = None,
+        py_version_info: tuple[int, ...] | None = None,
     ) -> None:
         super().__init__()
         assert upgrade_strategy in self._allowed_strategies
@@ -152,7 +155,7 @@ class Resolver(BaseResolver):
         self._discovered_dependencies: DiscoveredDependencies = defaultdict(list)
 
     def resolve(
-        self, root_reqs: List[InstallRequirement], check_supported_wheels: bool
+        self, root_reqs: list[InstallRequirement], check_supported_wheels: bool
     ) -> RequirementSet:
         """Resolve what operations need to be done
 
@@ -174,7 +177,7 @@ class Resolver(BaseResolver):
         # exceptions cannot be checked ahead of time, because
         # _populate_link() needs to be called before we can make decisions
         # based on link type.
-        discovered_reqs: List[InstallRequirement] = []
+        discovered_reqs: list[InstallRequirement] = []
         hash_errors = HashErrors()
         for req in chain(requirement_set.all_requirements, discovered_reqs):
             try:
@@ -192,9 +195,9 @@ class Resolver(BaseResolver):
         self,
         requirement_set: RequirementSet,
         install_req: InstallRequirement,
-        parent_req_name: Optional[str] = None,
-        extras_requested: Optional[Iterable[str]] = None,
-    ) -> Tuple[List[InstallRequirement], Optional[InstallRequirement]]:
+        parent_req_name: str | None = None,
+        extras_requested: Iterable[str] | None = None,
+    ) -> tuple[list[InstallRequirement], InstallRequirement | None]:
         """Add install_req as a requirement to install.
 
         :param parent_req_name: The name of the requirement that needed this
@@ -242,8 +245,8 @@ class Resolver(BaseResolver):
             return [install_req], None
 
         try:
-            existing_req: Optional[InstallRequirement] = (
-                requirement_set.get_requirement(install_req.name)
+            existing_req: InstallRequirement | None = requirement_set.get_requirement(
+                install_req.name
             )
         except KeyError:
             existing_req = None
@@ -323,9 +326,7 @@ class Resolver(BaseResolver):
             req.should_reinstall = True
         req.satisfied_by = None
 
-    def _check_skip_installed(
-        self, req_to_install: InstallRequirement
-    ) -> Optional[str]:
+    def _check_skip_installed(self, req_to_install: InstallRequirement) -> str | None:
         """Check if req_to_install should be skipped.
 
         This will check if the req is installed, and whether we should upgrade
@@ -377,7 +378,7 @@ class Resolver(BaseResolver):
         self._set_req_to_reinstall(req_to_install)
         return None
 
-    def _find_requirement_link(self, req: InstallRequirement) -> Optional[Link]:
+    def _find_requirement_link(self, req: InstallRequirement) -> Link | None:
         upgrade = self._is_upgrade_allowed(req)
         best_candidate = self.finder.find_requirement(req, upgrade)
         if not best_candidate:
@@ -488,7 +489,7 @@ class Resolver(BaseResolver):
         self,
         requirement_set: RequirementSet,
         req_to_install: InstallRequirement,
-    ) -> List[InstallRequirement]:
+    ) -> list[InstallRequirement]:
         """Prepare a single requirements file.
 
         :return: A list of additional InstallRequirements to also install.
@@ -511,7 +512,7 @@ class Resolver(BaseResolver):
             ignore_requires_python=self.ignore_requires_python,
         )
 
-        more_reqs: List[InstallRequirement] = []
+        more_reqs: list[InstallRequirement] = []
 
         def add_req(subreq: Requirement, extras_requested: Iterable[str]) -> None:
             # This idiosyncratically converts the Requirement to str and let
@@ -569,7 +570,7 @@ class Resolver(BaseResolver):
 
     def get_installation_order(
         self, req_set: RequirementSet
-    ) -> List[InstallRequirement]:
+    ) -> list[InstallRequirement]:
         """Create the installation order.
 
         The installation order is topological - requirements are installed
@@ -580,7 +581,7 @@ class Resolver(BaseResolver):
         # installs the user specified things in the order given, except when
         # dependencies must come earlier to achieve topological order.
         order = []
-        ordered_reqs: Set[InstallRequirement] = set()
+        ordered_reqs: set[InstallRequirement] = set()
 
         def schedule(req: InstallRequirement) -> None:
             if req.satisfied_by or req in ordered_reqs:

pip/_internal/resolution/resolvelib/base.py

@@ -1,5 +1,8 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
 from dataclasses import dataclass
-from typing import FrozenSet, Iterable, Optional, Tuple
+from typing import Optional
 
 from pip._vendor.packaging.specifiers import SpecifierSet
 from pip._vendor.packaging.utils import NormalizedName
@@ -9,10 +12,10 @@ from pip._internal.models.link import Link, links_equivalent
 from pip._internal.req.req_install import InstallRequirement
 from pip._internal.utils.hashes import Hashes
 
-CandidateLookup = Tuple[Optional["Candidate"], Optional[InstallRequirement]]
+CandidateLookup = tuple[Optional["Candidate"], Optional[InstallRequirement]]
 
 
-def format_name(project: NormalizedName, extras: FrozenSet[NormalizedName]) -> str:
+def format_name(project: NormalizedName, extras: frozenset[NormalizedName]) -> str:
     if not extras:
         return project
     extras_expr = ",".join(sorted(extras))
@@ -23,21 +26,21 @@ def format_name(project: NormalizedName, extras: FrozenSet[NormalizedName]) -> s
 class Constraint:
     specifier: SpecifierSet
     hashes: Hashes
-    links: FrozenSet[Link]
+    links: frozenset[Link]
 
     @classmethod
-    def empty(cls) -> "Constraint":
+    def empty(cls) -> Constraint:
         return Constraint(SpecifierSet(), Hashes(), frozenset())
 
     @classmethod
-    def from_ireq(cls, ireq: InstallRequirement) -> "Constraint":
+    def from_ireq(cls, ireq: InstallRequirement) -> Constraint:
         links = frozenset([ireq.link]) if ireq.link else frozenset()
         return Constraint(ireq.specifier, ireq.hashes(trust_internet=False), links)
 
     def __bool__(self) -> bool:
         return bool(self.specifier) or bool(self.hashes) or bool(self.links)
 
-    def __and__(self, other: InstallRequirement) -> "Constraint":
+    def __and__(self, other: InstallRequirement) -> Constraint:
         if not isinstance(other, InstallRequirement):
             return NotImplemented
         specifier = self.specifier & other.specifier
@@ -47,7 +50,7 @@ class Constraint:
             links = links.union([other.link])
         return Constraint(specifier, hashes, links)
 
-    def is_satisfied_by(self, candidate: "Candidate") -> bool:
+    def is_satisfied_by(self, candidate: Candidate) -> bool:
         # Reject if there are any mismatched URL constraints on this package.
         if self.links and not all(_match_link(link, candidate) for link in self.links):
             return False
@@ -77,7 +80,7 @@ class Requirement:
         """
         raise NotImplementedError("Subclass should override")
 
-    def is_satisfied_by(self, candidate: "Candidate") -> bool:
+    def is_satisfied_by(self, candidate: Candidate) -> bool:
         return False
 
     def get_candidate_lookup(self) -> CandidateLookup:
@@ -87,7 +90,7 @@ class Requirement:
         raise NotImplementedError("Subclass should override")
 
 
-def _match_link(link: Link, candidate: "Candidate") -> bool:
+def _match_link(link: Link, candidate: Candidate) -> bool:
     if candidate.source_link:
         return links_equivalent(link, candidate.source_link)
     return False
@@ -126,13 +129,13 @@ class Candidate:
         raise NotImplementedError("Override in subclass")
 
     @property
-    def source_link(self) -> Optional[Link]:
+    def source_link(self) -> Link | None:
         raise NotImplementedError("Override in subclass")
 
-    def iter_dependencies(self, with_requires: bool) -> Iterable[Optional[Requirement]]:
+    def iter_dependencies(self, with_requires: bool) -> Iterable[Requirement | None]:
         raise NotImplementedError("Override in subclass")
 
-    def get_install_requirement(self) -> Optional[InstallRequirement]:
+    def get_install_requirement(self) -> InstallRequirement | None:
         raise NotImplementedError("Override in subclass")
 
     def format_for_error(self) -> str:

pip/_internal/resolution/resolvelib/candidates.py

@@ -1,6 +1,9 @@
+from __future__ import annotations
+
 import logging
 import sys
-from typing import TYPE_CHECKING, Any, FrozenSet, Iterable, Optional, Tuple, Union, cast
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Any, Union, cast
 
 from pip._vendor.packaging.requirements import InvalidRequirement
 from pip._vendor.packaging.utils import NormalizedName, canonicalize_name
@@ -41,7 +44,7 @@ BaseCandidate = Union[
 REQUIRES_PYTHON_IDENTIFIER = cast(NormalizedName, "<Python from Requires-Python>")
 
 
-def as_base_candidate(candidate: Candidate) -> Optional[BaseCandidate]:
+def as_base_candidate(candidate: Candidate) -> BaseCandidate | None:
     """The runtime version of BaseCandidate."""
     base_candidate_classes = (
         AlreadyInstalledCandidate,
@@ -146,9 +149,9 @@ class _InstallRequirementBackedCandidate(Candidate):
         link: Link,
         source_link: Link,
         ireq: InstallRequirement,
-        factory: "Factory",
-        name: Optional[NormalizedName] = None,
-        version: Optional[Version] = None,
+        factory: Factory,
+        name: NormalizedName | None = None,
+        version: Version | None = None,
     ) -> None:
         self._link = link
         self._source_link = source_link
@@ -157,7 +160,7 @@ class _InstallRequirementBackedCandidate(Candidate):
         self._name = name
         self._version = version
         self.dist = self._prepare()
-        self._hash: Optional[int] = None
+        self._hash: int | None = None
 
     def __str__(self) -> str:
         return f"{self.name} {self.version}"
@@ -178,7 +181,7 @@ class _InstallRequirementBackedCandidate(Candidate):
         return False
 
     @property
-    def source_link(self) -> Optional[Link]:
+    def source_link(self) -> Link | None:
         return self._source_link
 
     @property
@@ -248,7 +251,7 @@ class _InstallRequirementBackedCandidate(Candidate):
         self._check_metadata_consistency(dist)
         return dist
 
-    def iter_dependencies(self, with_requires: bool) -> Iterable[Optional[Requirement]]:
+    def iter_dependencies(self, with_requires: bool) -> Iterable[Requirement | None]:
         # Emit the Requires-Python requirement first to fail fast on
         # unsupported candidates and avoid pointless downloads/preparation.
         yield self._factory.make_requires_python_requirement(self.dist.requires_python)
@@ -256,7 +259,7 @@ class _InstallRequirementBackedCandidate(Candidate):
         for r in requires:
             yield from self._factory.make_requirements_from_spec(str(r), self._ireq)
 
-    def get_install_requirement(self) -> Optional[InstallRequirement]:
+    def get_install_requirement(self) -> InstallRequirement | None:
         return self._ireq
 
 
@@ -267,9 +270,9 @@ class LinkCandidate(_InstallRequirementBackedCandidate):
         self,
         link: Link,
         template: InstallRequirement,
-        factory: "Factory",
-        name: Optional[NormalizedName] = None,
-        version: Optional[Version] = None,
+        factory: Factory,
+        name: NormalizedName | None = None,
+        version: Version | None = None,
     ) -> None:
         source_link = link
         cache_entry = factory.get_wheel_cache_entry(source_link, name)
@@ -324,9 +327,9 @@ class EditableCandidate(_InstallRequirementBackedCandidate):
         self,
         link: Link,
         template: InstallRequirement,
-        factory: "Factory",
-        name: Optional[NormalizedName] = None,
-        version: Optional[Version] = None,
+        factory: Factory,
+        name: NormalizedName | None = None,
+        version: Version | None = None,
     ) -> None:
         super().__init__(
             link=link,
@@ -349,7 +352,7 @@ class AlreadyInstalledCandidate(Candidate):
         self,
         dist: BaseDistribution,
         template: InstallRequirement,
-        factory: "Factory",
+        factory: Factory,
     ) -> None:
         self.dist = dist
         self._ireq = _make_install_req_from_dist(dist, template)
@@ -398,7 +401,7 @@ class AlreadyInstalledCandidate(Candidate):
     def format_for_error(self) -> str:
         return f"{self.name} {self.version} (Installed)"
 
-    def iter_dependencies(self, with_requires: bool) -> Iterable[Optional[Requirement]]:
+    def iter_dependencies(self, with_requires: bool) -> Iterable[Requirement | None]:
         if not with_requires:
             return
 
@@ -408,7 +411,7 @@ class AlreadyInstalledCandidate(Candidate):
         except InvalidRequirement as exc:
             raise InvalidInstalledPackage(dist=self.dist, invalid_exc=exc) from None
 
-    def get_install_requirement(self) -> Optional[InstallRequirement]:
+    def get_install_requirement(self) -> InstallRequirement | None:
         return None
 
 
@@ -440,9 +443,9 @@ class ExtrasCandidate(Candidate):
     def __init__(
         self,
         base: BaseCandidate,
-        extras: FrozenSet[str],
+        extras: frozenset[str],
         *,
-        comes_from: Optional[InstallRequirement] = None,
+        comes_from: InstallRequirement | None = None,
     ) -> None:
         """
         :param comes_from: the InstallRequirement that led to this candidate if it
@@ -498,10 +501,10 @@ class ExtrasCandidate(Candidate):
         return self.base.is_editable
 
     @property
-    def source_link(self) -> Optional[Link]:
+    def source_link(self) -> Link | None:
         return self.base.source_link
 
-    def iter_dependencies(self, with_requires: bool) -> Iterable[Optional[Requirement]]:
+    def iter_dependencies(self, with_requires: bool) -> Iterable[Requirement | None]:
         factory = self.base._factory
 
         # Add a dependency on the exact base
@@ -529,7 +532,7 @@ class ExtrasCandidate(Candidate):
                 valid_extras,
             )
 
-    def get_install_requirement(self) -> Optional[InstallRequirement]:
+    def get_install_requirement(self) -> InstallRequirement | None:
         # We don't return anything here, because we always
         # depend on the base candidate, and we'll get the
         # install requirement from that.
@@ -540,7 +543,7 @@ class RequiresPythonCandidate(Candidate):
     is_installed = False
     source_link = None
 
-    def __init__(self, py_version_info: Optional[Tuple[int, ...]]) -> None:
+    def __init__(self, py_version_info: tuple[int, ...] | None) -> None:
         if py_version_info is not None:
             version_info = normalize_version_info(py_version_info)
         else:
@@ -572,8 +575,8 @@ class RequiresPythonCandidate(Candidate):
     def format_for_error(self) -> str:
         return f"Python {self.version}"
 
-    def iter_dependencies(self, with_requires: bool) -> Iterable[Optional[Requirement]]:
+    def iter_dependencies(self, with_requires: bool) -> Iterable[Requirement | None]:
         return ()
 
-    def get_install_requirement(self) -> Optional[InstallRequirement]:
+    def get_install_requirement(self) -> InstallRequirement | None:
         return None