cleanup

aignas · aignas · commit a53c1e8cac3f · 2025-07-13T22:07:32.000+09:00
diff --git a/python/private/pypi/select_whl.bzl b/python/private/pypi/select_whl.bzl
@@ -4,7 +4,7 @@ load("//python/private:version.bzl", "version")
 load(":parse_whl_name.bzl", "parse_whl_name")
 load(":python_tag.bzl", "PY_TAG_GENERIC", "python_tag")
 
-def _get_priority(*, tag, values, allow_wildcard = True):
+def _priority_by_values(*, tag, values, allow_wildcard = True):
     keys = []
     for priority, wp in enumerate(values):
         head, sep, tail = wp.partition("*")
@@ -18,12 +18,9 @@ def _get_priority(*, tag, values, allow_wildcard = True):
         elif sep and tag.startswith(head) and tag.endswith(tail):
             keys.append(priority)
 
-    if not keys:
-        return None
-
-    return max(keys)
+    return max(keys) if keys else None
 
-def _get_py_priority(*, tag, implementation, py_version):
+def _priority_by_version(*, tag, implementation, py_version):
     if tag.startswith(PY_TAG_GENERIC):
         ver_str = tag[len(PY_TAG_GENERIC):]
     elif tag.startswith(implementation):
@@ -43,39 +40,83 @@ def _get_py_priority(*, tag, implementation, py_version):
         version.key(ver),
     )
 
-def _tag_sets(*, whls, implementation, py_version, whl_abi_tags, platforms):
+def _candidates_by_priority(*, whls, implementation, py_version, whl_abi_tags, platforms, logger):
+    """Calculate the priority of each wheel
+
+    Args:
+        whls: {type}`list[struct]` The whls to select from.
+        implementation: {type}`str` The target Python implementation.
+        py_version: {type}`struct` The target python version.
+        whl_abi_tags: {type}`list[str]` The whl abi tags to select from.
+        platforms: {type}`list[str]` The whl platform tags to select from.
+        logger: The logger to use for debugging info
+
+    Returns:
+        A dictionary where keys are priority tuples which allows us to sort and pick the
+        last item.
+    """
+
     ret = {}
     for whl in whls:
         parsed = parse_whl_name(whl.filename)
+        priority = None
 
         # See https://packaging.python.org/en/latest/specifications/platform-compatibility-tags/#compressed-tag-sets
-        for py in parsed.python_tag.split("."):
-            py = _get_py_priority(
-                tag = py,
-                implementation = implementation,
-                py_version = py_version,
-            )
-            if py == None:
-                ret[struct(py = py)] = whl
+        for platform in parsed.platform_tag.split("."):
+            platform = _priority_by_values(tag = platform, values = platforms)
+            if platform == None:
+                if logger:
+                    logger.debug(lambda: "The platform_tag in '{}' does not match given list: {}".format(
+                        whl.filename,
+                        platforms,
+                    ))
                 continue
 
-            for abi in parsed.abi_tag.split("."):
-                abi = _get_priority(
-                    tag = abi,
-                    values = whl_abi_tags,
-                    allow_wildcard = False,
+            for py in parsed.python_tag.split("."):
+                py = _priority_by_version(
+                    tag = py,
+                    implementation = implementation,
+                    py_version = py_version,
                 )
                 if py == None:
-                    ret[struct(py = py, abi = abi)] = whl
+                    if logger:
+                        logger.debug(lambda: "The python_tag in '{}' does not match implementation or version: {} {}".format(
+                            whl.filename,
+                            implementation,
+                            py_version.string,
+                        ))
                     continue
 
-                for p in parsed.platform_tag.split("."):
-                    platform = _get_priority(
-                        tag = p,
-                        values = platforms,
+                for abi in parsed.abi_tag.split("."):
+                    abi = _priority_by_values(
+                        tag = abi,
+                        values = whl_abi_tags,
+                        allow_wildcard = False,
                     )
+                    if abi == None:
+                        if logger:
+                            logger.debug(lambda: "The abi_tag in '{}' does not match given list: {}".format(
+                                whl.filename,
+                                whl_abi_tags,
+                            ))
+                        continue
+
+                    # 1. Prefer platform wheels
+                    # 2. Then prefer implementation/python version
+                    # 3. Then prefer more specific ABI wheels
+                    candidate = (platform, py, abi)
+                    priority = priority or candidate
+                    if candidate > priority:
+                        priority = candidate
+
+        if priority == None:
+            if logger:
+                logger.debug(lambda: "The whl '{}' is incompatible".format(
+                    whl.filename,
+                ))
+            continue
 
-                    ret[struct(py = py, abi = abi, platform = platform)] = whl
+        ret[priority] = whl
 
     return ret
 
@@ -102,41 +143,14 @@ def select_whl(*, whls, python_version, platforms, whl_abi_tags, implementation_
     candidates = {}
     implementation = python_tag(implementation_name)
 
-    for priority, whl in _tag_sets(
+    candidates = _candidates_by_priority(
         whls = whls,
         implementation = implementation,
         py_version = py_version,
         whl_abi_tags = whl_abi_tags,
         platforms = platforms,
-    ).items():
-        if priority.py == None:
-            if logger:
-                logger.debug(lambda: "The python_tag in '{}' does not match implementation or version: {} {}".format(
-                    whl.filename,
-                    implementation,
-                    py_version.string,
-                ))
-            continue
-        elif priority.abi == None:
-            if logger:
-                logger.debug(lambda: "The abi_tag in '{}' does not match given list: {}".format(
-                    whl.filename,
-                    whl_abi_tags,
-                ))
-            continue
-        elif priority.platform == None:
-            if logger:
-                logger.debug(lambda: "The platform_tag in '{}' does not match given list: {}".format(
-                    whl.filename,
-                    platforms,
-                ))
-            continue
-
-        candidates.setdefault((
-            priority.platform,  # Prefer platform wheels
-            priority.py,  # Then prefer implementation/python version
-            priority.abi,  # Then prefer more specific ABI wheels
-        ), whl)
+        logger = logger,
+    )
 
     if not candidates:
         return None
diff --git a/tests/pypi/select_whl/select_whl_tests.bzl b/tests/pypi/select_whl/select_whl_tests.bzl
@@ -118,6 +118,29 @@ def _test_not_select_py2(env):
 
 _tests.append(_test_not_select_py2)
 
+def _test_not_select_abi3(env):
+    # Check we prefer platform specific wheels
+    got = _select_whl(
+        whls = [
+            "pkg-0.0.1-py3-none-any.whl",
+            # the following should be ignored
+            "pkg-0.0.1-py3-abi3-any.whl",
+            "pkg-0.0.1-py3-abi3-p1.p2.p2.whl",
+        ],
+        platforms = ["any", "p1"],
+        whl_abi_tags = ["none"],
+        python_version = "3.13",
+        limit = 2,
+        debug = True,
+    )
+    _match(
+        env,
+        got,
+        "pkg-0.0.1-py3-none-any.whl",
+    )
+
+_tests.append(_test_not_select_abi3)
+
 def _test_select_cp312(env):
     # Check we prefer platform specific wheels
     got = _select_whl(
@@ -347,6 +370,28 @@ def _test_pytags_all_possible(env):
 
 _tests.append(_test_pytags_all_possible)
 
+def _test_manylinx_musllinux_pref(env):
+    got = _select_whl(
+        whls = [
+            "pkg-0.0.1-py3-none-manylinux_2_31_x86_64.musllinux_1_1_x86_64.whl",
+        ],
+        platforms = [
+            "manylinux_*_x86_64",
+            "musllinux_*_x86_64",
+        ],
+        whl_abi_tags = ["none"],
+        python_version = "3.12",
+        limit = 2,
+    )
+    _match(
+        env,
+        got,
+        # there is only wheel, just select that
+        "pkg-0.0.1-py3-none-manylinux_2_31_x86_64.musllinux_1_1_x86_64.whl",
+    )
+
+_tests.append(_test_manylinx_musllinux_pref)
+
 def select_whl_test_suite(name):
     """Create the test suite.
 
