which_package to yield unique collection of package records

conda_build/inspect_pkg.py

@@ -73,9 +73,8 @@ def which_package(
     path = prefix / path
 
     for prec in PrefixData(str(prefix)).iter_records():
-        for file in prec["files"]:
-            if samefile(prefix / file, path):
-                yield prec
+        if any(samefile(prefix / file, path) for file in prec["files"]):
+            yield prec
 
 
 def print_object_info(info, key):

conda_build/post.py

@@ -1187,9 +1187,7 @@ def _lookup_in_prefix_packages(
     if len(precs_in_reqs) == 1:
         _print_msg(
             errors,
-            "{}: {} found in {}{}".format(
-                info_prelude, n_dso_p, precs_in_reqs[0], and_also
-            ),
+            f"{info_prelude}: {n_dso_p} found in {precs_in_reqs[0]}{and_also}",
             verbose=verbose,
         )
     elif in_whitelist:
@@ -1201,25 +1199,20 @@ def _lookup_in_prefix_packages(
     elif len(precs_in_reqs) == 0 and len(precs) > 0:
         _print_msg(
             errors,
-            "{}: {} found in {}{}".format(
-                msg_prelude, n_dso_p, [prec.name for prec in precs], and_also
-            ),
+            f"{msg_prelude}: {n_dso_p} found in {[str(prec) for prec in precs]}{and_also}",
             verbose=verbose,
         )
         _print_msg(
             errors,
-            "{}: .. but {} not in reqs/run, (i.e. it is overlinking)"
-            " (likely) or a missing dependency (less likely)".format(
-                msg_prelude, [prec.name for prec in precs]
-            ),
+            f"{msg_prelude}: .. but {[str(prec) for prec in precs]} not in reqs/run, "
+            "(i.e. it is overlinking) (likely) or a missing dependency (less likely)",
             verbose=verbose,
         )
     elif len(precs_in_reqs) > 1:
         _print_msg(
             errors,
-            "{}: {} found in multiple packages in run/reqs: {}{}".format(
-                warn_prelude, in_prefix_dso, precs_in_reqs, and_also
-            ),
+            f"{warn_prelude}: {in_prefix_dso} found in multiple packages in run/reqs: "
+            f"{[str(prec) for prec in precs_in_reqs]}{and_also}",
             verbose=verbose,
         )
     else:

news/5108-fix-which_package

@@ -0,0 +1,20 @@
+### Enhancements
+
+* <news item>
+
+### Bug fixes
+
+* Fix `conda_build.inspect_pkg.which_package` so it does not return duplicate package records. (#5108)
+* Fix `conda_build.post._lookup_in_prefix_packages` to display `str(PackageRecord)` instead of `repr(PackageRecord)`. (#5108)
+
+### Deprecations
+
+* <news item>
+
+### Docs
+
+* <news item>
+
+### Other
+
+* <news item>

tests/test_inspect_pkg.py

@@ -0,0 +1,119 @@
+# Copyright (C) 2014 Anaconda, Inc
+# SPDX-License-Identifier: BSD-3-Clause
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from conda.core.prefix_data import PrefixData
+
+from conda_build.inspect_pkg import which_package
+
+
+def test_which_package(tmp_path: Path):
+    # create a dummy environment
+    (tmp_path / "conda-meta").mkdir()
+    (tmp_path / "conda-meta" / "history").touch()
+
+    # dummy files
+    (tmp_path / "hardlinkA").touch()  # packageA
+    (tmp_path / "shared").touch()  # packageA & packageB
+    (tmp_path / "internal").symlink_to(tmp_path / "hardlinkA")  # packageA
+    (tmp_path / "external").symlink_to(tmp_path / "hardlinkB")  # packageA
+    (tmp_path / "hardlinkB").touch()  # packageB
+
+    # a dummy package with a hardlink file, shared file, internal softlink, and external softlink
+    (tmp_path / "conda-meta" / "packageA-1-0.json").write_text(
+        json.dumps(
+            {
+                "build": "0",
+                "build_number": 0,
+                "channel": "packageA-channel",
+                "files": ["hardlinkA", "shared", "internal", "external"],
+                "name": "packageA",
+                "paths_data": {
+                    "paths": [
+                        {
+                            "_path": "hardlinkA",
+                            "path_type": "hardlink",
+                            "size_in_bytes": 0,
+                        },
+                        {
+                            "_path": "shared",
+                            "path_type": "hardlink",
+                            "size_in_bytes": 0,
+                        },
+                        {
+                            "_path": "internal",
+                            "path_type": "softlink",
+                            "size_in_bytes": 0,
+                        },
+                        {
+                            "_path": "external",
+                            "path_type": "softlink",
+                            "size_in_bytes": 0,
+                        },
+                    ],
+                    "paths_version": 1,
+                },
+                "version": "1",
+            }
+        )
+    )
+    # a dummy package with a hardlink file and shared file
+    (tmp_path / "conda-meta" / "packageB-1-0.json").write_text(
+        json.dumps(
+            {
+                "build": "0",
+                "build_number": 0,
+                "channel": "packageB-channel",
+                "files": ["hardlinkB", "shared"],
+                "name": "packageB",
+                "paths_data": {
+                    "paths": [
+                        {
+                            "_path": "hardlinkB",
+                            "path_type": "hardlink",
+                            "size_in_bytes": 0,
+                        },
+                        {
+                            "_path": "shared",
+                            "path_type": "hardlink",
+                            "size_in_bytes": 0,
+                        },
+                    ],
+                    "paths_version": 1,
+                },
+                "version": "1",
+            }
+        )
+    )
+
+    # fetch package records
+    pd = PrefixData(tmp_path)
+    precA = pd.get("packageA")
+    precB = pd.get("packageB")
+
+    # test returned package records given a path
+    precs_missing = list(which_package(tmp_path / "missing", tmp_path))
+    assert not precs_missing
+
+    precs_hardlinkA = list(which_package(tmp_path / "hardlinkA", tmp_path))
+    assert len(precs_hardlinkA) == 1
+    assert precs_hardlinkA[0] == precA
+
+    precs_shared = list(which_package(tmp_path / "shared", tmp_path))
+    assert len(precs_shared) == 2
+    assert set(precs_shared) == {precA, precB}
+
+    precs_internal = list(which_package(tmp_path / "internal", tmp_path))
+    assert len(precs_internal) == 1
+    assert precs_internal[0] == precA
+
+    precs_external = list(which_package(tmp_path / "external", tmp_path))
+    assert len(precs_external) == 2
+    assert set(precs_external) == {precA, precB}
+
+    precs_hardlinkB = list(which_package(tmp_path / "hardlinkB", tmp_path))
+    assert len(precs_hardlinkB) == 2
+    assert set(precs_hardlinkB) == {precA, precB}