Move backtrack cause preference to narrow_requirement_selection

Author: notatallshaw

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

@@ -114,15 +114,36 @@ def narrow_requirement_selection(
         """Produce a subset of identifiers that should be considered before others.
 
         Currently pip narrows the following selection:
-            * Requires-Python is always considered first.
+            * Requires-Python, if present is always returned by itself
+            * Backtrack causes are considered next because they can be identified
+              in linear time here, whereas because get_preference() is called
+              for each identifier, it would be quadratic to check for them there.
+              Further, the current backtrack causes likely need to be resolved
+              before other requirements as a resolution can't be found while
+              there is a conflict.
         """
+        backtrack_idenifiers= set()
+        for info in backtrack_causes:
+            backtrack_idenifiers.add(info.requirement.name)
+            if info.parent is not None:
+                backtrack_idenifiers.add(info.parent.name)
+
+        current_backtrack_causes = []
         for identifier in identifiers:
             # Requires-Python has only one candidate and the check is basically
             # free, so we always do it first to avoid needless work if it fails.
             # This skips calling get_preference() for all other identifiers.
             if identifier == REQUIRES_PYTHON_IDENTIFIER:
                 return [identifier]
 
+            # Check if this identifier is a backtrack cause
+            if identifier in backtrack_idenifiers:
+                current_backtrack_causes.append(identifier)
+                continue
+
+        if current_backtrack_causes:
+            return current_backtrack_causes
+
         return identifiers
 
     def get_preference(
@@ -175,15 +196,9 @@ def get_preference(
         unfree = bool(operators)
         requested_order = self._user_requested.get(identifier, math.inf)
 
-        # Prefer the causes of backtracking on the assumption that the problem
-        # resolving the dependency tree is related to the failures that caused
-        # the backtracking
-        backtrack_cause = self.is_backtrack_cause(identifier, backtrack_causes)
-
         return (
             not direct,
             not pinned,
-            not backtrack_cause,
             requested_order,
             not unfree,
             identifier,
@@ -238,14 +253,3 @@ def is_satisfied_by(self, requirement: Requirement, candidate: Candidate) -> boo
     def get_dependencies(self, candidate: Candidate) -> Sequence[Requirement]:
         with_requires = not self._ignore_dependencies
         return [r for r in candidate.iter_dependencies(with_requires) if r is not None]
-
-    @staticmethod
-    def is_backtrack_cause(
-        identifier: str, backtrack_causes: Sequence["PreferenceInformation"]
-    ) -> bool:
-        for backtrack_cause in backtrack_causes:
-            if identifier == backtrack_cause.requirement.name:
-                return True
-            if backtrack_cause.parent and identifier == backtrack_cause.parent.name:
-                return True
-        return False

tests/unit/resolution_resolvelib/test_provider.py

@@ -42,39 +42,31 @@ def build_req_info(
             {"pinned-package": [build_req_info("pinned-package==1.0")]},
             [],
             {},
-            (False, False, True, math.inf, False, "pinned-package"),
-        ),
-        # Package that caused backtracking
-        (
-            "backtrack-package",
-            {"backtrack-package": [build_req_info("backtrack-package")]},
-            [build_req_info("backtrack-package")],
-            {},
-            (False, True, False, math.inf, True, "backtrack-package"),
+            (False, False, math.inf, False, "pinned-package"),
         ),
         # Root package requested by user
         (
             "root-package",
             {"root-package": [build_req_info("root-package")]},
             [],
             {"root-package": 1},
-            (False, True, True, 1, True, "root-package"),
+            (False, True, 1, True, "root-package"),
         ),
         # Unfree package (with specifier operator)
         (
             "unfree-package",
             {"unfree-package": [build_req_info("unfree-package<1")]},
             [],
             {},
-            (False, True, True, math.inf, False, "unfree-package"),
+            (False, True, math.inf, False, "unfree-package"),
         ),
         # Free package (no operator)
         (
             "free-package",
             {"free-package": [build_req_info("free-package")]},
             [],
             {},
-            (False, True, True, math.inf, True, "free-package"),
+            (False, True, math.inf, True, "free-package"),
         ),
     ],
 )
@@ -102,37 +94,56 @@ def test_get_preference(
 
 
 @pytest.mark.parametrize(
-    "identifiers, expected",
+    "identifiers, backtrack_causes, expected",
     [
-        # Case 1: REQUIRES_PYTHON_IDENTIFIER is present at the beginning
+        # REQUIRES_PYTHON_IDENTIFIER is present
         (
-            [REQUIRES_PYTHON_IDENTIFIER, "package1", "package2"],
+            [REQUIRES_PYTHON_IDENTIFIER, "package1", "package2", "backtrack-package"],
+            [build_req_info("backtrack-package")],
             [REQUIRES_PYTHON_IDENTIFIER],
         ),
-        # Case 2: REQUIRES_PYTHON_IDENTIFIER is present in the middle
+        # REQUIRES_PYTHON_IDENTIFIER is present after backtrack causes
         (
-            ["package1", REQUIRES_PYTHON_IDENTIFIER, "package2"],
+            ["package1", "package2", "backtrack-package", REQUIRES_PYTHON_IDENTIFIER],
+            [build_req_info("backtrack-package")],
             [REQUIRES_PYTHON_IDENTIFIER],
         ),
-        # Case 3: REQUIRES_PYTHON_IDENTIFIER is not present
+        # Backtrack causes present (direct requirement)
+        (
+            ["package1", "package2", "backtrack-package"],
+            [build_req_info("backtrack-package")],
+            ["backtrack-package"],
+        ),
+        # Multiple backtrack causes
+        (
+            ["package1", "backtrack1", "backtrack2", "package2"],
+            [build_req_info("backtrack1"), build_req_info("backtrack2")],
+            ["backtrack1", "backtrack2"],
+        ),
+        # No special identifiers - return all
         (
             ["package1", "package2"],
+            [],
             ["package1", "package2"],
         ),
-        # Case 4: Empty list of identifiers
+        # Empty list of identifiers
         (
             [],
             [],
+            [],
         ),
     ],
 )
 def test_narrow_requirement_selection(
     identifiers: List[str],
+    backtrack_causes: Sequence["PreferenceInformation"],
     expected: List[str],
     factory: Factory,
 ) -> None:
-    """Test that narrow_requirement_selection correctly prioritizes
-    REQUIRES_PYTHON_IDENTIFIER when present in the list of identifiers.
+    """Test that narrow_requirement_selection correctly prioritizes identifiers:
+    1. REQUIRES_PYTHON_IDENTIFIER (if present)
+    2. Backtrack causes (if present)
+    3. All other identifiers (as-is)
     """
     provider = PipProvider(
         factory=factory,
@@ -142,6 +153,8 @@ def test_narrow_requirement_selection(
         user_requested={},
     )
 
-    result = provider.narrow_requirement_selection(identifiers, {}, {}, {}, [])
+    result = provider.narrow_requirement_selection(
+        identifiers, {}, {}, {}, backtrack_causes
+    )
 
     assert list(result) == expected, f"Expected {expected}, got {list(result)}"