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

pip/_internal/resolution/resolvelib/factory.py

@@ -1,21 +1,14 @@
+from __future__ import annotations
+
 import contextlib
 import functools
 import logging
+from collections.abc import Iterable, Iterator, Mapping, Sequence
 from typing import (
     TYPE_CHECKING,
     Callable,
-    Dict,
-    FrozenSet,
-    Iterable,
-    Iterator,
-    List,
-    Mapping,
     NamedTuple,
-    Optional,
     Protocol,
-    Sequence,
-    Set,
-    Tuple,
     TypeVar,
     cast,
 )
@@ -84,13 +77,13 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 C = TypeVar("C")
-Cache = Dict[Link, C]
+Cache = dict[Link, C]
 
 
 class CollectedRootRequirements(NamedTuple):
-    requirements: List[Requirement]
-    constraints: Dict[str, Constraint]
-    user_requested: Dict[str, int]
+    requirements: list[Requirement]
+    constraints: dict[str, Constraint]
+    user_requested: dict[str, int]
 
 
 class Factory:
@@ -99,12 +92,12 @@ class Factory:
         finder: PackageFinder,
         preparer: RequirementPreparer,
         make_install_req: InstallRequirementProvider,
-        wheel_cache: Optional[WheelCache],
+        wheel_cache: WheelCache | None,
         use_user_site: bool,
         force_reinstall: bool,
         ignore_installed: bool,
         ignore_requires_python: bool,
-        py_version_info: Optional[Tuple[int, ...]] = None,
+        py_version_info: tuple[int, ...] | None = None,
     ) -> None:
         self._finder = finder
         self.preparer = preparer
@@ -118,9 +111,9 @@ class Factory:
         self._build_failures: Cache[InstallationError] = {}
         self._link_candidate_cache: Cache[LinkCandidate] = {}
         self._editable_candidate_cache: Cache[EditableCandidate] = {}
-        self._installed_candidate_cache: Dict[str, AlreadyInstalledCandidate] = {}
-        self._extras_candidate_cache: Dict[
-            Tuple[int, FrozenSet[NormalizedName]], ExtrasCandidate
+        self._installed_candidate_cache: dict[str, AlreadyInstalledCandidate] = {}
+        self._extras_candidate_cache: dict[
+            tuple[int, frozenset[NormalizedName]], ExtrasCandidate
         ] = {}
         self._supported_tags_cache = get_supported()
 
@@ -149,9 +142,9 @@ class Factory:
     def _make_extras_candidate(
         self,
         base: BaseCandidate,
-        extras: FrozenSet[str],
+        extras: frozenset[str],
         *,
-        comes_from: Optional[InstallRequirement] = None,
+        comes_from: InstallRequirement | None = None,
     ) -> ExtrasCandidate:
         cache_key = (id(base), frozenset(canonicalize_name(e) for e in extras))
         try:
@@ -164,7 +157,7 @@ class Factory:
     def _make_candidate_from_dist(
         self,
         dist: BaseDistribution,
-        extras: FrozenSet[str],
+        extras: frozenset[str],
         template: InstallRequirement,
     ) -> Candidate:
         try:
@@ -179,12 +172,12 @@ class Factory:
     def _make_candidate_from_link(
         self,
         link: Link,
-        extras: FrozenSet[str],
+        extras: frozenset[str],
         template: InstallRequirement,
-        name: Optional[NormalizedName],
-        version: Optional[Version],
-    ) -> Optional[Candidate]:
-        base: Optional[BaseCandidate] = self._make_base_candidate_from_link(
+        name: NormalizedName | None,
+        version: Version | None,
+    ) -> Candidate | None:
+        base: BaseCandidate | None = self._make_base_candidate_from_link(
             link, template, name, version
         )
         if not extras or base is None:
@@ -195,9 +188,9 @@ class Factory:
         self,
         link: Link,
         template: InstallRequirement,
-        name: Optional[NormalizedName],
-        version: Optional[Version],
-    ) -> Optional[BaseCandidate]:
+        name: NormalizedName | None,
+        version: Version | None,
+    ) -> BaseCandidate | None:
         # TODO: Check already installed candidate, and use it if the link and
         # editable flag match.
 
@@ -254,7 +247,7 @@ class Factory:
         specifier: SpecifierSet,
         hashes: Hashes,
         prefers_installed: bool,
-        incompatible_ids: Set[int],
+        incompatible_ids: set[int],
     ) -> Iterable[Candidate]:
         if not ireqs:
             return ()
@@ -267,14 +260,14 @@ class Factory:
         assert template.req, "Candidates found on index must be PEP 508"
         name = canonicalize_name(template.req.name)
 
-        extras: FrozenSet[str] = frozenset()
+        extras: frozenset[str] = frozenset()
         for ireq in ireqs:
             assert ireq.req, "Candidates found on index must be PEP 508"
             specifier &= ireq.req.specifier
             hashes &= ireq.hashes(trust_internet=False)
             extras |= frozenset(ireq.extras)
 
-        def _get_installed_candidate() -> Optional[Candidate]:
+        def _get_installed_candidate() -> Candidate | None:
             """Get the candidate for the currently-installed version."""
             # If --force-reinstall is set, we want the version from the index
             # instead, so we "pretend" there is nothing installed.
@@ -353,7 +346,7 @@ class Factory:
     def _iter_explicit_candidates_from_base(
         self,
         base_requirements: Iterable[Requirement],
-        extras: FrozenSet[str],
+        extras: frozenset[str],
     ) -> Iterator[Candidate]:
         """Produce explicit candidates from the base given an extra-ed package.
 
@@ -404,8 +397,8 @@ class Factory:
         is_satisfied_by: Callable[[Requirement, Candidate], bool],
     ) -> Iterable[Candidate]:
         # Collect basic lookup information from the requirements.
-        explicit_candidates: Set[Candidate] = set()
-        ireqs: List[InstallRequirement] = []
+        explicit_candidates: set[Candidate] = set()
+        ireqs: list[InstallRequirement] = []
         for req in requirements[identifier]:
             cand, ireq = req.get_candidate_lookup()
             if cand is not None:
@@ -524,7 +517,7 @@ class Factory:
                     )
 
     def collect_root_requirements(
-        self, root_ireqs: List[InstallRequirement]
+        self, root_ireqs: list[InstallRequirement]
     ) -> CollectedRootRequirements:
         collected = CollectedRootRequirements([], {}, {})
         for i, ireq in enumerate(root_ireqs):
@@ -573,7 +566,7 @@ class Factory:
     def make_requirements_from_spec(
         self,
         specifier: str,
-        comes_from: Optional[InstallRequirement],
+        comes_from: InstallRequirement | None,
         requested_extras: Iterable[str] = (),
     ) -> Iterator[Requirement]:
         """
@@ -591,7 +584,7 @@ class Factory:
     def make_requires_python_requirement(
         self,
         specifier: SpecifierSet,
-    ) -> Optional[Requirement]:
+    ) -> Requirement | None:
         if self._ignore_requires_python:
             return None
         # Don't bother creating a dependency for an empty Requires-Python.
@@ -599,9 +592,7 @@ class Factory:
             return None
         return RequiresPythonRequirement(specifier, self._python_candidate)
 
-    def get_wheel_cache_entry(
-        self, link: Link, name: Optional[str]
-    ) -> Optional[CacheEntry]:
+    def get_wheel_cache_entry(self, link: Link, name: str | None) -> CacheEntry | None:
         """Look up the link in the wheel cache.
 
         If ``preparer.require_hashes`` is True, don't use the wheel cache,
@@ -618,7 +609,7 @@ class Factory:
             supported_tags=self._supported_tags_cache,
         )
 
-    def get_dist_to_uninstall(self, candidate: Candidate) -> Optional[BaseDistribution]:
+    def get_dist_to_uninstall(self, candidate: Candidate) -> BaseDistribution | None:
         # TODO: Are there more cases this needs to return True? Editable?
         dist = self._installed_dists.get(candidate.project_name)
         if dist is None:  # Not installed, no uninstallation required.
@@ -647,7 +638,7 @@ class Factory:
         return None
 
     def _report_requires_python_error(
-        self, causes: Sequence["ConflictCause"]
+        self, causes: Sequence[ConflictCause]
     ) -> UnsupportedPythonVersion:
         assert causes, "Requires-Python error reported with no cause"
 
@@ -669,7 +660,7 @@ class Factory:
         return UnsupportedPythonVersion(message)
 
     def _report_single_requirement_conflict(
-        self, req: Requirement, parent: Optional[Candidate]
+        self, req: Requirement, parent: Candidate | None
     ) -> DistributionNotFound:
         if parent is None:
             req_disp = str(req)
@@ -679,8 +670,8 @@ class Factory:
         cands = self._finder.find_all_candidates(req.project_name)
         skipped_by_requires_python = self._finder.requires_python_skipped_reasons()
 
-        versions_set: Set[Version] = set()
-        yanked_versions_set: Set[Version] = set()
+        versions_set: set[Version] = set()
+        yanked_versions_set: set[Version] = set()
         for c in cands:
             is_yanked = c.link.is_yanked if c.link else False
             if is_yanked:
@@ -720,10 +711,25 @@ class Factory:
 
         return DistributionNotFound(f"No matching distribution found for {req}")
 
+    def _has_any_candidates(self, project_name: str) -> bool:
+        """
+        Check if there are any candidates available for the project name.
+        """
+        return any(
+            self.find_candidates(
+                project_name,
+                requirements={project_name: []},
+                incompatibilities={},
+                constraint=Constraint.empty(),
+                prefers_installed=True,
+                is_satisfied_by=lambda r, c: True,
+            )
+        )
+
     def get_installation_error(
         self,
-        e: "ResolutionImpossible[Requirement, Candidate]",
-        constraints: Dict[str, Constraint],
+        e: ResolutionImpossible[Requirement, Candidate],
+        constraints: dict[str, Constraint],
     ) -> InstallationError:
         assert e.causes, "Installation error reported with no cause"
 
@@ -756,7 +762,7 @@ class Factory:
         # satisfied at once.
 
         # A couple of formatting helpers
-        def text_join(parts: List[str]) -> str:
+        def text_join(parts: list[str]) -> str:
             if len(parts) == 1:
                 return parts[0]
 
@@ -805,6 +811,22 @@ class Factory:
             spec = constraints[key].specifier
             msg += f"\n    The user requested (constraint) {key}{spec}"
 
+        # Check for causes that had no candidates
+        causes = set()
+        for req, _ in e.causes:
+            causes.add(req.name)
+
+        no_candidates = {c for c in causes if not self._has_any_candidates(c)}
+        if no_candidates:
+            msg = (
+                msg
+                + "\n\n"
+                + "Additionally, some packages in these conflicts have no "
+                + "matching distributions available for your environment:"
+                + "\n    "
+                + "\n    ".join(sorted(no_candidates))
+            )
+
         msg = (
             msg
             + "\n\n"

pip/_internal/resolution/resolvelib/found_candidates.py

@@ -8,9 +8,11 @@ absolutely need, and not "download the world" when we only need one version of
 something.
 """
 
+from __future__ import annotations
+
 import logging
-from collections.abc import Sequence
-from typing import Any, Callable, Iterator, Optional, Set, Tuple
+from collections.abc import Iterator, Sequence
+from typing import Any, Callable, Optional
 
 from pip._vendor.packaging.version import _BaseVersion
 
@@ -20,7 +22,7 @@ from .base import Candidate
 
 logger = logging.getLogger(__name__)
 
-IndexCandidateInfo = Tuple[_BaseVersion, Callable[[], Optional[Candidate]]]
+IndexCandidateInfo = tuple[_BaseVersion, Callable[[], Optional[Candidate]]]
 
 
 def _iter_built(infos: Iterator[IndexCandidateInfo]) -> Iterator[Candidate]:
@@ -29,7 +31,7 @@ def _iter_built(infos: Iterator[IndexCandidateInfo]) -> Iterator[Candidate]:
     This iterator is used when the package is not already installed. Candidates
     from index come later in their normal ordering.
     """
-    versions_found: Set[_BaseVersion] = set()
+    versions_found: set[_BaseVersion] = set()
     for version, func in infos:
         if version in versions_found:
             continue
@@ -65,7 +67,7 @@ def _iter_built_with_prepended(
     normal ordering, except skipped when the version is already installed.
     """
     yield installed
-    versions_found: Set[_BaseVersion] = {installed.version}
+    versions_found: set[_BaseVersion] = {installed.version}
     for version, func in infos:
         if version in versions_found:
             continue
@@ -89,7 +91,7 @@ def _iter_built_with_inserted(
     the installed candidate exactly once before we start yielding older or
     equivalent candidates, or after all other candidates if they are all newer.
     """
-    versions_found: Set[_BaseVersion] = set()
+    versions_found: set[_BaseVersion] = set()
     for version, func in infos:
         if version in versions_found:
             continue
@@ -120,15 +122,15 @@ class FoundCandidates(Sequence[Candidate]):
     def __init__(
         self,
         get_infos: Callable[[], Iterator[IndexCandidateInfo]],
-        installed: Optional[Candidate],
+        installed: Candidate | None,
         prefers_installed: bool,
-        incompatible_ids: Set[int],
+        incompatible_ids: set[int],
     ):
         self._get_infos = get_infos
         self._installed = installed
         self._prefers_installed = prefers_installed
         self._incompatible_ids = incompatible_ids
-        self._bool: Optional[bool] = None
+        self._bool: bool | None = None
 
     def __getitem__(self, index: Any) -> Any:
         # Implemented to satisfy the ABC check. This is not needed by the

pip/_internal/resolution/resolvelib/provider.py

@@ -1,16 +1,11 @@
+from __future__ import annotations
+
 import math
-from functools import lru_cache
+from collections.abc import Iterable, Iterator, Mapping, Sequence
+from functools import cache
 from typing import (
     TYPE_CHECKING,
-    Dict,
-    Iterable,
-    Iterator,
-    Mapping,
-    Optional,
-    Sequence,
-    Tuple,
     TypeVar,
-    Union,
 )
 
 from pip._vendor.resolvelib.providers import AbstractProvider
@@ -59,7 +54,7 @@ def _get_with_identifier(
     mapping: Mapping[str, V],
     identifier: str,
     default: D,
-) -> Union[D, V]:
+) -> D | V:
     """Get item from a package name lookup mapping with a resolver identifier.
 
     This extra logic is needed when the target mapping is keyed by package
@@ -94,10 +89,10 @@ class PipProvider(_ProviderBase):
     def __init__(
         self,
         factory: Factory,
-        constraints: Dict[str, Constraint],
+        constraints: dict[str, Constraint],
         ignore_dependencies: bool,
         upgrade_strategy: str,
-        user_requested: Dict[str, int],
+        user_requested: dict[str, int],
     ) -> None:
         self._factory = factory
         self._constraints = constraints
@@ -105,7 +100,16 @@ class PipProvider(_ProviderBase):
         self._upgrade_strategy = upgrade_strategy
         self._user_requested = user_requested
 
-    def identify(self, requirement_or_candidate: Union[Requirement, Candidate]) -> str:
+    @property
+    def constraints(self) -> dict[str, Constraint]:
+        """Public view of user-specified constraints.
+
+        Exposes the provider's constraints mapping without encouraging
+        external callers to reach into private attributes.
+        """
+        return self._constraints
+
+    def identify(self, requirement_or_candidate: Requirement | Candidate) -> str:
         return requirement_or_candidate.name
 
     def narrow_requirement_selection(
@@ -113,8 +117,8 @@ class PipProvider(_ProviderBase):
         identifiers: Iterable[str],
         resolutions: Mapping[str, Candidate],
         candidates: Mapping[str, Iterator[Candidate]],
-        information: Mapping[str, Iterator["PreferenceInformation"]],
-        backtrack_causes: Sequence["PreferenceInformation"],
+        information: Mapping[str, Iterator[PreferenceInformation]],
+        backtrack_causes: Sequence[PreferenceInformation],
     ) -> Iterable[str]:
         """Produce a subset of identifiers that should be considered before others.
 
@@ -156,9 +160,9 @@ class PipProvider(_ProviderBase):
         identifier: str,
         resolutions: Mapping[str, Candidate],
         candidates: Mapping[str, Iterator[Candidate]],
-        information: Mapping[str, Iterable["PreferenceInformation"]],
-        backtrack_causes: Sequence["PreferenceInformation"],
-    ) -> "Preference":
+        information: Mapping[str, Iterable[PreferenceInformation]],
+        backtrack_causes: Sequence[PreferenceInformation],
+    ) -> Preference:
         """Produce a sort key for given requirement based on preference.
 
         The lower the return value is, the more preferred this group of
@@ -192,7 +196,7 @@ class PipProvider(_ProviderBase):
 
         if not has_information:
             direct = False
-            ireqs: Tuple[Optional[InstallRequirement], ...] = ()
+            ireqs: tuple[InstallRequirement | None, ...] = ()
         else:
             # Go through the information and for each requirement,
             # check if it's explicit (e.g., a direct link) and get the
@@ -271,7 +275,7 @@ class PipProvider(_ProviderBase):
         )
 
     @staticmethod
-    @lru_cache(maxsize=None)
+    @cache
     def is_satisfied_by(requirement: Requirement, candidate: Candidate) -> bool:
         return requirement.is_satisfied_by(candidate)
 

pip/_internal/resolution/resolvelib/reporter.py

@@ -1,17 +1,21 @@
+from __future__ import annotations
+
 from collections import defaultdict
+from collections.abc import Mapping
 from logging import getLogger
-from typing import Any, DefaultDict, Optional
+from typing import Any
 
 from pip._vendor.resolvelib.reporters import BaseReporter
 
-from .base import Candidate, Requirement
+from .base import Candidate, Constraint, Requirement
 
 logger = getLogger(__name__)
 
 
 class PipReporter(BaseReporter[Requirement, Candidate, str]):
-    def __init__(self) -> None:
-        self.reject_count_by_package: DefaultDict[str, int] = defaultdict(int)
+    def __init__(self, constraints: Mapping[str, Constraint] | None = None) -> None:
+        self.reject_count_by_package: defaultdict[str, int] = defaultdict(int)
+        self._constraints = constraints or {}
 
         self._messages_at_reject_count = {
             1: (
@@ -33,25 +37,36 @@ class PipReporter(BaseReporter[Requirement, Candidate, str]):
         }
 
     def rejecting_candidate(self, criterion: Any, candidate: Candidate) -> None:
+        """Report a candidate being rejected.
+
+        Logs both the rejection count message (if applicable) and details about
+        the requirements and constraints that caused the rejection.
+        """
         self.reject_count_by_package[candidate.name] += 1
 
         count = self.reject_count_by_package[candidate.name]
-        if count not in self._messages_at_reject_count:
-            return
-
-        message = self._messages_at_reject_count[count]
-        logger.info("INFO: %s", message.format(package_name=candidate.name))
+        if count in self._messages_at_reject_count:
+            message = self._messages_at_reject_count[count]
+            logger.info("INFO: %s", message.format(package_name=candidate.name))
 
         msg = "Will try a different candidate, due to conflict:"
         for req_info in criterion.information:
             req, parent = req_info.requirement, req_info.parent
-            # Inspired by Factory.get_installation_error
             msg += "\n    "
             if parent:
                 msg += f"{parent.name} {parent.version} depends on "
             else:
                 msg += "The user requested "
             msg += req.format_for_error()
+
+        # Add any relevant constraints
+        if self._constraints:
+            name = candidate.name
+            constraint = self._constraints.get(name)
+            if constraint and constraint.specifier:
+                constraint_text = f"{name}{constraint.specifier}"
+                msg += f"\n    The user requested (constraint) {constraint_text}"
+
         logger.debug(msg)
 
 
@@ -72,7 +87,7 @@ class PipDebuggingReporter(BaseReporter[Requirement, Candidate, str]):
         logger.info("Reporter.ending(%r)", state)
 
     def adding_requirement(
-        self, requirement: Requirement, parent: Optional[Candidate]
+        self, requirement: Requirement, parent: Candidate | None
     ) -> None:
         logger.info("Reporter.adding_requirement(%r, %r)", requirement, parent)
 

pip/_internal/resolution/resolvelib/requirements.py

@@ -1,4 +1,6 @@
-from typing import Any, Optional
+from __future__ import annotations
+
+from typing import Any
 
 from pip._vendor.packaging.specifiers import SpecifierSet
 from pip._vendor.packaging.utils import NormalizedName, canonicalize_name
@@ -51,8 +53,8 @@ class SpecifierRequirement(Requirement):
     def __init__(self, ireq: InstallRequirement) -> None:
         assert ireq.link is None, "This is a link, not a specifier"
         self._ireq = ireq
-        self._equal_cache: Optional[str] = None
-        self._hash: Optional[int] = None
+        self._equal_cache: str | None = None
+        self._hash: int | None = None
         self._extras = frozenset(canonicalize_name(e) for e in self._ireq.extras)
 
     @property
@@ -128,8 +130,8 @@ class SpecifierWithoutExtrasRequirement(SpecifierRequirement):
     def __init__(self, ireq: InstallRequirement) -> None:
         assert ireq.link is None, "This is a link, not a specifier"
         self._ireq = install_req_drop_extras(ireq)
-        self._equal_cache: Optional[str] = None
-        self._hash: Optional[int] = None
+        self._equal_cache: str | None = None
+        self._hash: int | None = None
         self._extras = frozenset(canonicalize_name(e) for e in self._ireq.extras)
 
     @property
@@ -159,7 +161,7 @@ class RequiresPythonRequirement(Requirement):
     def __init__(self, specifier: SpecifierSet, match: Candidate) -> None:
         self.specifier = specifier
         self._specifier_string = str(specifier)  # for faster __eq__
-        self._hash: Optional[int] = None
+        self._hash: int | None = None
         self._candidate = match
 
     def __str__(self) -> str: