LocalPackageResolver: Resolve packages using _first_ match in sys.path

When LocalPackageResolver is used to look up packages in the _current_
Python environment, it should take care to use the same package that
Python itself would end up using when importing a package of that name.

Until now, the way we have used importlib_metadata (specifically the way
we iterate over MetadataPathFinder().find_distributions()), if a
packages occurs multiple times in sys.path, we would end up using the
_last_ instance, whereas Python would use the _first_. Fix our iteration
to be in line with Python.

Author: jherland

fawltydeps/packages.py

@@ -261,15 +261,24 @@ def packages(self) -> Dict[str, Package]:
         # that map to zero import names.
         context = DistributionFinder.Context(path=paths)  # type: ignore
         for dist in MetadataPathFinder().find_distributions(context):  # type: ignore
+            normalized_name = Package.normalize_name(dist.name)
             parent_dir = dist.locate_file("")
+            if normalized_name in ret:
+                # We already found another instance of this package earlier in
+                # the given paths. Assume that the earlier package is what
+                # Python's import machinery will choose, and that this later
+                # package is not interesting
+                logger.debug(f"Skip {dist.name} {dist.version} under {parent_dir}")
+                continue
+
             logger.debug(f"Found {dist.name} {dist.version} under {parent_dir}")
             imports = set(
                 _top_level_declared(dist)  # type: ignore
                 or _top_level_inferred(dist)  # type: ignore
             )
             description = self.description_template.format(path=parent_dir)
             package = Package(dist.name, {description: imports})
-            ret[Package.normalize_name(dist.name)] = package
+            ret[normalized_name] = package
 
         return ret
 

tests/test_local_env.py

@@ -121,6 +121,21 @@ def test_local_env__current_venv__contains_prepared_packages(isolate_default_res
         assert package_name in lpl.packages
 
 
+def test_local_env__prefers_first_package_found_in_sys_path(isolate_default_resolver):
+    # Add the same package twice, The one that ends up _first_ in sys.path is
+    # the one that Python would end up importing, and it is therefore also the
+    # one that we should resolve to.
+
+    site_dir1 = isolate_default_resolver({"other": {"other"}})
+    site_dir2 = isolate_default_resolver({"other": {"other"}})
+    assert site_dir1 != site_dir2
+    assert sys.path[0] == str(site_dir2)
+    actual = LocalPackageResolver().lookup_packages({"other"})
+    assert actual == {
+        "other": Package("other", {f"Python env at {site_dir2}": {"other"}}),
+    }
+
+
 def test_resolve_dependencies__in_empty_venv__reverts_to_id_mapping(tmp_path):
     venv.create(tmp_path, with_pip=False)
     id_mapping = IdentityMapping()