Fix calculation of PipProvider._known_depths

news/10482.bugfix.rst

@@ -0,0 +1 @@
+New resolver: Fixes depth ordering of packages during resolution, e.g. a package 2 levels of dependency down will be ordered before a package 3 levels of dependecy down.

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

@@ -112,9 +112,9 @@ def get_preference(
                 for _, parent in information[identifier]
             )
             inferred_depth = min(d for d in parent_depths) + 1.0
-            self._known_depths[identifier] = inferred_depth
         else:
             inferred_depth = 1.0
+        self._known_depths[identifier] = inferred_depth
 
         requested_order = self._user_requested.get(identifier, math.inf)
 

tests/unit/resolution_resolvelib/test_provider.py

@@ -0,0 +1,84 @@
+import operator
+
+from pip._vendor.packaging.requirements import Requirement
+from pip._vendor.resolvelib.resolvers import Criterion, RequirementInformation
+from pip._vendor.resolvelib.structs import IteratorMapping
+
+from pip._internal.models.candidate import InstallationCandidate
+from pip._internal.models.link import Link
+from pip._internal.req.req_install import InstallRequirement
+from pip._internal.resolution.resolvelib.provider import PipProvider
+from pip._internal.resolution.resolvelib.requirements import SpecifierRequirement
+
+
+def build_package_criterion(provider, name, parent):
+    install_requirement = InstallRequirement(
+        Requirement(name), "-r requirements.txt (line 1)"
+    )
+    matches = provider.find_matches(
+        identifier=name,
+        requirements={name: iter([SpecifierRequirement(install_requirement)])},
+        incompatibilities={name: iter([])},
+    )
+    requirement_information = RequirementInformation(
+        requirement=SpecifierRequirement(install_requirement), parent=parent
+    )
+    return Criterion(iter(matches), [requirement_information], [])
+
+
+def test_provider_known_depths(factory):
+    # Root requirement is specified by the user
+    # therefore has an infered depth of 1
+    root_requirement_name = "my-package"
+    provider = PipProvider(
+        factory=factory,
+        constraints={},
+        ignore_dependencies=False,
+        upgrade_strategy="to-satisfy-only",
+        user_requested={root_requirement_name: 0},
+    )
+
+    root_requirement_criteron = build_package_criterion(
+        provider=provider, name=root_requirement_name, parent=None
+    )
+    provider.get_preference(
+        identifier=root_requirement_name,
+        resolutions={},
+        candidates={},
+        information=IteratorMapping(
+            {root_requirement_name: root_requirement_criteron},
+            operator.attrgetter("information"),
+        ),
+    )
+    assert provider._known_depths == {root_requirement_name: 1.0}
+
+    # Transative requirement is a dependency of root requirement
+    # theforefore has an infered depth of 2
+    root_package_candidate = InstallationCandidate(
+        root_requirement_name,
+        "1.0",
+        Link("https://{root_requirement_name}.com"),
+    )
+    transative_requirement_name = "my-transitive-package"
+
+    transative_package_criterion = build_package_criterion(
+        provider=provider,
+        name=transative_requirement_name,
+        parent=root_package_candidate,
+    )
+    provider.get_preference(
+        identifier=transative_requirement_name,
+        resolutions={},
+        candidates={},
+        information=IteratorMapping(
+            {
+                root_requirement_name: root_requirement_criteron,
+                transative_requirement_name: transative_package_criterion,
+            },
+            operator.attrgetter("information"),
+        ),
+    )
+    assert provider._known_depths == {
+        transative_requirement_name: 2.0,
+        root_requirement_name: 1.0,
+    }