asaf.use_new_resolver

src/piprules/pipcompat.py

@@ -12,7 +12,7 @@
 from pip._internal.req import parse_requirements, InstallRequirement
 from pip._internal.req.constructors import install_req_from_req_string, install_req_from_parsed_requirement
 from pip._internal.req.req_tracker import get_requirement_tracker
-from pip._internal.resolution.legacy.resolver import Resolver
+from pip._internal.resolution.resolvelib.resolver import Resolver
 from pip._internal.wheel_builder import build, should_build_for_wheel_command
 from pip._internal.models.wheel import Wheel
 from pip._internal.cache import WheelCache

src/piprules/requirements.py

@@ -81,7 +81,7 @@ def add_from_requirements_file(self, path, pip_session):
 
     def condense(self):
         LOG.debug("Condensing requirement collection into a set")
-        return [requirement for requirement in self._generate_condensed_requirements()]
+        return {requirement.name: requirement for requirement in self._generate_condensed_requirements()}
 
     def _generate_condensed_requirements(self):
         for name, group in self._iterate_grouped_requirements():

src/piprules/resolve.py

@@ -137,23 +137,28 @@ def __init__(self, session, pip_resolver, work_dirs, wheel_dir):
         self._work_dirs = work_dirs
         self._wheel_dir = wheel_dir
 
-    def resolve(self, requirement_list):
+    def resolve(self, requirement_map):
         requirement_set = self._pip_resolver.resolve(
-            requirement_list,
+            list(requirement_map.values()),
             check_supported_wheels=True,
         )
 
         requirements = requirement_set.requirements.values()
 
         built_wheels = self._build_wheels_if_necessary(requirements)
+        res_list = []
+
+        for requirement in requirements:
+            is_direct = False
+            if requirement.name in requirement_map and hasattr(requirement_map[requirement.name], "rules_pip_is_direct"):
+                is_direct = requirement_map[requirement.name].rules_pip_is_direct
+
+            use_local_wheels = requirement in built_wheels
+            res_list.append(self._create_resolved_requirement(requirement, use_local_wheels, is_direct))
+
+        return res_list
+
 
-        return [
-            self._create_resolved_requirement(requirement, False)
-            for requirement in requirements if requirements not in built_wheels
-        ] + [
-            self._create_resolved_requirement(requirement, True)
-            for requirement in built_wheels
-        ]
 
     def _build_wheels_if_necessary(self, requirements):
         build_successes, build_failures = pipcompat.build(
@@ -167,7 +172,7 @@ def _build_wheels_if_necessary(self, requirements):
         return build_successes
 
 
-    def _create_resolved_requirement(self, requirement, use_local_wheel_source):
+    def _create_resolved_requirement(self, requirement, use_local_wheel_source, is_direct):
         LOG.debug("Creating resolved requirement for %s", requirement.name)
 
         abstract_dist = pipcompat.make_distribution_for_install_requirement(requirement)
@@ -191,10 +196,6 @@ def _create_resolved_requirement(self, requirement, use_local_wheel_source):
             else self._compute_sha256_sum(requirement)
         )
 
-        is_direct = False
-        if hasattr(requirement, "rules_pip_is_direct"):
-            is_direct = requirement.rules_pip_is_direct
-
         return ResolvedRequirement(
             pipcompat.canonicalize_name(requirement.name),
             version,