Merge pull request #9699 from uranusjr/resolvelib-types

Author: uranusjr

news/resolvelib.vendor.rst

@@ -0,0 +1 @@
+Upgrade vendored resolvelib to 0.5.5.

src/pip/_internal/resolution/resolvelib/factory.py

@@ -12,6 +12,7 @@
     Set,
     Tuple,
     TypeVar,
+    cast,
 )
 
 from pip._vendor.packaging.specifiers import SpecifierSet
@@ -419,7 +420,7 @@ def _report_requires_python_error(self, causes):
         return UnsupportedPythonVersion(message)
 
     def _report_single_requirement_conflict(self, req, parent):
-        # type: (Requirement, Candidate) -> DistributionNotFound
+        # type: (Requirement, Optional[Candidate]) -> DistributionNotFound
         if parent is None:
             req_disp = str(req)
         else:
@@ -439,7 +440,7 @@ def _report_single_requirement_conflict(self, req, parent):
 
     def get_installation_error(
         self,
-        e,  # type: ResolutionImpossible
+        e,  # type: ResolutionImpossible[Requirement, Candidate]
         constraints,  # type: Dict[str, Constraint]
     ):
         # type: (...) -> InstallationError
@@ -455,7 +456,11 @@ def get_installation_error(
             and not cause.requirement.is_satisfied_by(self._python_candidate)
         ]
         if requires_python_causes:
-            return self._report_requires_python_error(requires_python_causes)
+            # The comprehension above makes sure all Requirement instances are
+            # RequiresPythonRequirement, so let's cast for convinience.
+            return self._report_requires_python_error(
+                cast("Sequence[ConflictCause]", requires_python_causes),
+            )
 
         # Otherwise, we have a set of causes which can't all be satisfied
         # at once.

src/pip/_internal/resolution/resolvelib/provider.py

@@ -1,10 +1,20 @@
-from typing import Any, Dict, Iterable, Optional, Sequence, Tuple, Union
+from typing import TYPE_CHECKING, Dict, Iterable, Optional, Sequence, Union
 
 from pip._vendor.resolvelib.providers import AbstractProvider
 
 from .base import Candidate, Constraint, Requirement
 from .factory import Factory
 
+if TYPE_CHECKING:
+    from pip._vendor.resolvelib.providers import Preference
+    from pip._vendor.resolvelib.resolvers import RequirementInformation
+
+    PreferenceInformation = RequirementInformation[Requirement, Candidate]
+
+    _ProviderBase = AbstractProvider[Requirement, Candidate, str]
+else:
+    _ProviderBase = AbstractProvider
+
 # Notes on the relationship between the provider, the factory, and the
 # candidate and requirement classes.
 #
@@ -24,7 +34,7 @@
 # services to those objects (access to pip's finder and preparer).
 
 
-class PipProvider(AbstractProvider):
+class PipProvider(_ProviderBase):
     """Pip's provider implementation for resolvelib.
 
     :params constraints: A mapping of constraints specified by the user. Keys
@@ -50,17 +60,17 @@ def __init__(
         self._upgrade_strategy = upgrade_strategy
         self._user_requested = user_requested
 
-    def identify(self, dependency):
+    def identify(self, requirement_or_candidate):
         # type: (Union[Requirement, Candidate]) -> str
-        return dependency.name
+        return requirement_or_candidate.name
 
     def get_preference(
         self,
         resolution,  # type: Optional[Candidate]
-        candidates,  # type: Sequence[Candidate]
-        information,  # type: Sequence[Tuple[Requirement, Candidate]]
+        candidates,  # type: Iterable[Candidate]
+        information,  # type: Iterable[PreferenceInformation]
     ):
-        # type: (...) -> Any
+        # type: (...) -> Preference
         """Produce a sort key for given requirement based on preference.
 
         The lower the return value is, the more preferred this group of

src/pip/_internal/resolution/resolvelib/resolver.py

@@ -1,13 +1,13 @@
 import functools
 import logging
 import os
-from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple
+from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple, cast
 
 from pip._vendor.packaging.utils import canonicalize_name
 from pip._vendor.packaging.version import parse as parse_version
 from pip._vendor.resolvelib import BaseReporter, ResolutionImpossible
 from pip._vendor.resolvelib import Resolver as RLResolver
-from pip._vendor.resolvelib.resolvers import Result
+from pip._vendor.resolvelib.structs import DirectedGraph
 
 from pip._internal.cache import WheelCache
 from pip._internal.exceptions import InstallationError
@@ -28,11 +28,14 @@
 from pip._internal.utils.filetypes import is_archive_file
 from pip._internal.utils.misc import dist_is_editable
 
-from .base import Constraint
+from .base import Candidate, Constraint, Requirement
 from .factory import Factory
 
 if TYPE_CHECKING:
-    from pip._vendor.resolvelib.structs import DirectedGraph
+    from pip._vendor.resolvelib.resolvers import Result as RLResult
+
+    Result = RLResult[Requirement, Candidate, str]
+
 
 logger = logging.getLogger(__name__)
 
@@ -114,7 +117,10 @@ def resolve(self, root_reqs, check_supported_wheels):
             reporter = PipDebuggingReporter()  # type: BaseReporter
         else:
             reporter = PipReporter()
-        resolver = RLResolver(provider, reporter)
+        resolver = RLResolver(
+            provider,
+            reporter,
+        )  # type: RLResolver[Requirement, Candidate, str]
 
         try:
             try_to_avoid_resolution_too_deep = 2000000
@@ -123,7 +129,10 @@ def resolve(self, root_reqs, check_supported_wheels):
             )
 
         except ResolutionImpossible as e:
-            error = self.factory.get_installation_error(e, constraints)
+            error = self.factory.get_installation_error(
+                cast("ResolutionImpossible[Requirement, Candidate]", e),
+                constraints,
+            )
             raise error from e
 
         req_set = RequirementSet(check_supported_wheels=check_supported_wheels)
@@ -148,7 +157,7 @@ def resolve(self, root_reqs, check_supported_wheels):
                 # The incoming distribution is editable, or different in
                 # editable-ness to installation -- reinstall.
                 ireq.should_reinstall = True
-            elif candidate.source_link.is_file:
+            elif candidate.source_link and candidate.source_link.is_file:
                 # The incoming distribution is under file://
                 if candidate.source_link.is_wheel:
                     # is a local wheel -- do nothing.
@@ -236,7 +245,7 @@ def get_installation_order(self, req_set):
 
 
 def get_topological_weights(graph, expected_node_count):
-    # type: (DirectedGraph, int) -> Dict[Optional[str], int]
+    # type: (DirectedGraph[Optional[str]], int) -> Dict[Optional[str], int]
     """Assign weights to each node based on how "deep" they are.
 
     This implementation may change at any point in the future without prior

src/pip/_vendor/resolvelib.pyi

@@ -11,7 +11,7 @@
     "ResolutionTooDeep",
 ]
 
-__version__ = "0.5.4"
+__version__ = "0.5.5"
 
 
 from .providers import AbstractProvider, AbstractResolver

src/pip/_vendor/resolvelib/__init__.py

@@ -0,0 +1,15 @@
+__version__: str
+
+from .providers import (
+    AbstractResolver as AbstractResolver,
+    AbstractProvider as AbstractProvider,
+)
+from .reporters import BaseReporter as BaseReporter
+from .resolvers import (
+    InconsistentCandidate as InconsistentCandidate,
+    RequirementsConflicted as RequirementsConflicted,
+    Resolver as Resolver,
+    ResolutionError as ResolutionError,
+    ResolutionImpossible as ResolutionImpossible,
+    ResolutionTooDeep as ResolutionTooDeep,
+)

src/pip/_vendor/resolvelib/__init__.pyi

@@ -2,12 +2,10 @@ class AbstractProvider(object):
     """Delegate class to provide requirement interface for the resolver."""
 
     def identify(self, requirement_or_candidate):
-        """Given a requirement or candidate, return an identifier for it.
+        """Given a requirement, return an identifier for it.
 
-        This is used in many places to identify a requirement or candidate,
-        e.g. whether two requirements should have their specifier parts merged,
-        whether two candidates would conflict with each other (because they
-        have same name but different versions).
+        This is used to identify a requirement, e.g. whether two requirements
+        should have their specifier parts merged.
         """
         raise NotImplementedError
 

src/pip/_vendor/resolvelib/providers.py

@@ -0,0 +1,44 @@
+from typing import (
+    Any,
+    Collection,
+    Generic,
+    Iterable,
+    Mapping,
+    Optional,
+    Protocol,
+    Sequence,
+    Union,
+)
+
+from .reporters import BaseReporter
+from .resolvers import RequirementInformation
+from .structs import (
+    KT,
+    RT,
+    CT,
+    IterableView,
+    Matches,
+)
+
+class Preference(Protocol):
+    def __lt__(self, __other: Any) -> bool: ...
+
+class AbstractProvider(Generic[RT, CT, KT]):
+    def identify(self, requirement_or_candidate: Union[RT, CT]) -> KT: ...
+    def get_preference(
+        self,
+        resolution: Optional[CT],
+        candidates: IterableView[CT],
+        information: Collection[RequirementInformation[RT, CT]],
+    ) -> Preference: ...
+    def find_matches(self, requirements: Sequence[RT]) -> Matches: ...
+    def is_satisfied_by(self, requirement: RT, candidate: CT) -> bool: ...
+    def get_dependencies(self, candidate: CT) -> Iterable[RT]: ...
+
+class AbstractResolver(Generic[RT, CT, KT]):
+    base_exception = Exception
+    provider: AbstractProvider[RT, CT, KT]
+    reporter: BaseReporter
+    def __init__(
+        self, provider: AbstractProvider[RT, CT, KT], reporter: BaseReporter
+    ): ...