Refactor root requirement collection into factory

Author: uranusjr

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

@@ -9,6 +9,7 @@
     Iterator,
     List,
     Mapping,
+    NamedTuple,
     Optional,
     Sequence,
     Set,
@@ -38,7 +39,10 @@
 from pip._internal.models.wheel import Wheel
 from pip._internal.operations.prepare import RequirementPreparer
 from pip._internal.req.constructors import install_req_from_link_and_ireq
-from pip._internal.req.req_install import InstallRequirement
+from pip._internal.req.req_install import (
+    InstallRequirement,
+    check_invalid_constraint_type,
+)
 from pip._internal.resolution.base import InstallRequirementProvider
 from pip._internal.utils.compatibility_tags import get_supported
 from pip._internal.utils.hashes import Hashes
@@ -81,6 +85,12 @@ class ConflictCause(Protocol):
 Cache = Dict[Link, C]
 
 
+class CollectedRootRequirements(NamedTuple):
+    requirements: List[Requirement]
+    constraints: Dict[str, Constraint]
+    user_requested: Dict[str, int]
+
+
 class Factory:
     def __init__(
         self,
@@ -414,7 +424,7 @@ def find_candidates(
             and all(req.is_satisfied_by(c) for req in requirements[identifier])
         )
 
-    def make_requirement_from_install_req(self, ireq, requested_extras):
+    def _make_requirement_from_install_req(self, ireq, requested_extras):
         # type: (InstallRequirement, Iterable[str]) -> Optional[Requirement]
         if not ireq.match_markers(requested_extras):
             logger.info(
@@ -445,6 +455,36 @@ def make_requirement_from_install_req(self, ireq, requested_extras):
             return UnsatisfiableRequirement(canonicalize_name(ireq.name))
         return self.make_requirement_from_candidate(cand)
 
+    def collect_root_requirements(self, root_ireqs):
+        # type: (List[InstallRequirement]) -> CollectedRootRequirements
+        collected = CollectedRootRequirements([], {}, {})
+        for i, ireq in enumerate(root_ireqs):
+            if ireq.constraint:
+                # Ensure we only accept valid constraints
+                problem = check_invalid_constraint_type(ireq)
+                if problem:
+                    raise InstallationError(problem)
+                if not ireq.match_markers():
+                    continue
+                assert ireq.name, "Constraint must be named"
+                name = canonicalize_name(ireq.name)
+                if name in collected.constraints:
+                    collected.constraints[name] &= ireq
+                else:
+                    collected.constraints[name] = Constraint.from_ireq(ireq)
+            else:
+                if ireq.user_supplied and ireq.name:
+                    canonical_name = canonicalize_name(ireq.name)
+                    if canonical_name not in collected.user_requested:
+                        collected.user_requested[canonical_name] = i
+                req = self._make_requirement_from_install_req(
+                    ireq,
+                    requested_extras=(),
+                )
+                if req is not None:
+                    collected.requirements.append(req)
+        return collected
+
     def make_requirement_from_candidate(self, candidate):
         # type: (Candidate) -> ExplicitRequirement
         return ExplicitRequirement(candidate)
@@ -457,7 +497,7 @@ def make_requirement_from_spec(
     ):
         # type: (...) -> Optional[Requirement]
         ireq = self._make_install_req_from_spec(specifier, comes_from)
-        return self.make_requirement_from_install_req(ireq, requested_extras)
+        return self._make_requirement_from_install_req(ireq, requested_extras)
 
     def make_requires_python_requirement(self, specifier):
         # type: (Optional[SpecifierSet]) -> Optional[Requirement]

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

@@ -10,13 +10,9 @@
 from pip._vendor.resolvelib.structs import DirectedGraph
 
 from pip._internal.cache import WheelCache
-from pip._internal.exceptions import InstallationError
 from pip._internal.index.package_finder import PackageFinder
 from pip._internal.operations.prepare import RequirementPreparer
-from pip._internal.req.req_install import (
-    InstallRequirement,
-    check_invalid_constraint_type,
-)
+from pip._internal.req.req_install import InstallRequirement
 from pip._internal.req.req_set import RequirementSet
 from pip._internal.resolution.base import BaseResolver, InstallRequirementProvider
 from pip._internal.resolution.resolvelib.provider import PipProvider
@@ -28,7 +24,7 @@
 from pip._internal.utils.filetypes import is_archive_file
 from pip._internal.utils.misc import dist_is_editable
 
-from .base import Candidate, Constraint, Requirement
+from .base import Candidate, Requirement
 from .factory import Factory
 
 if TYPE_CHECKING:
@@ -77,41 +73,13 @@ def __init__(
 
     def resolve(self, root_reqs, check_supported_wheels):
         # type: (List[InstallRequirement], bool) -> RequirementSet
-
-        constraints = {}  # type: Dict[str, Constraint]
-        user_requested = {}  # type: Dict[str, int]
-        requirements = []
-        for i, req in enumerate(root_reqs):
-            if req.constraint:
-                # Ensure we only accept valid constraints
-                problem = check_invalid_constraint_type(req)
-                if problem:
-                    raise InstallationError(problem)
-                if not req.match_markers():
-                    continue
-                assert req.name, "Constraint must be named"
-                name = canonicalize_name(req.name)
-                if name in constraints:
-                    constraints[name] &= req
-                else:
-                    constraints[name] = Constraint.from_ireq(req)
-            else:
-                if req.user_supplied and req.name:
-                    canonical_name = canonicalize_name(req.name)
-                    if canonical_name not in user_requested:
-                        user_requested[canonical_name] = i
-                r = self.factory.make_requirement_from_install_req(
-                    req, requested_extras=()
-                )
-                if r is not None:
-                    requirements.append(r)
-
+        collected = self.factory.collect_root_requirements(root_reqs)
         provider = PipProvider(
             factory=self.factory,
-            constraints=constraints,
+            constraints=collected.constraints,
             ignore_dependencies=self.ignore_dependencies,
             upgrade_strategy=self.upgrade_strategy,
-            user_requested=user_requested,
+            user_requested=collected.user_requested,
         )
         if "PIP_RESOLVER_DEBUG" in os.environ:
             reporter = PipDebuggingReporter()  # type: BaseReporter
@@ -125,13 +93,13 @@ def resolve(self, root_reqs, check_supported_wheels):
         try:
             try_to_avoid_resolution_too_deep = 2000000
             result = self._result = resolver.resolve(
-                requirements, max_rounds=try_to_avoid_resolution_too_deep
+                collected.requirements, max_rounds=try_to_avoid_resolution_too_deep
             )
 
         except ResolutionImpossible as e:
             error = self.factory.get_installation_error(
                 cast("ResolutionImpossible[Requirement, Candidate]", e),
-                constraints,
+                collected.constraints,
             )
             raise error from e