move select_whl function to a separate file

Author: aignas

python/private/pypi/BUILD.bazel

@@ -120,7 +120,6 @@ bzl_library(
         ":whl_config_setting_bzl",
         ":whl_library_bzl",
         ":whl_repo_name_bzl",
-        ":whl_target_platforms_bzl",
         "//python/private:full_version_bzl",
         "//python/private:normalize_name_bzl",
         "//python/private:version_bzl",
@@ -209,7 +208,7 @@ bzl_library(
         ":parse_requirements_txt_bzl",
         ":pypi_repo_utils_bzl",
         ":requirements_files_by_platform_bzl",
-        ":whl_target_platforms_bzl",
+        ":select_whl_bzl",
         "//python/private:normalize_name_bzl",
         "//python/private:repo_utils_bzl",
     ],
@@ -359,6 +358,15 @@ bzl_library(
     ],
 )
 
+bzl_library(
+    name = "select_whl_bzl",
+    srcs = ["select_whl.bzl"],
+    deps = [
+        ":parse_whl_name_bzl",
+        "//python/private:version_bzl",
+    ],
+)
+
 bzl_library(
     name = "simpleapi_download_bzl",
     srcs = ["simpleapi_download.bzl"],
@@ -422,8 +430,4 @@ bzl_library(
 bzl_library(
     name = "whl_target_platforms_bzl",
     srcs = ["whl_target_platforms.bzl"],
-    deps = [
-        ":parse_whl_name_bzl",
-        "//python/private:version_bzl",
-    ],
 )

python/private/pypi/parse_requirements.bzl

@@ -31,7 +31,7 @@ load("//python/private:repo_utils.bzl", "repo_utils")
 load(":index_sources.bzl", "index_sources")
 load(":parse_requirements_txt.bzl", "parse_requirements_txt")
 load(":pep508_requirement.bzl", "requirement")
-load(":whl_target_platforms.bzl", "select_whl")
+load(":select_whl.bzl", "select_whl")
 
 def parse_requirements(
         ctx,

python/private/pypi/select_whl.bzl

@@ -0,0 +1,151 @@
+"Select a single wheel that fits the parameters of a target platform."
+
+load("//python/private:version.bzl", "version")
+load(":parse_whl_name.bzl", "parse_whl_name")
+
+def _get_priority(*, tag, values, allow_wildcard = True):
+    for priority, wp in enumerate(values):
+        # TODO @aignas 2025-06-16: move the matcher validation out of this
+        # TODO @aignas 2025-06-21: test the 'cp*' matching
+        head, sep, tail = wp.partition("*")
+        if "*" in tail:
+            fail("only a single '*' can be present in the matcher")
+        if not allow_wildcard and sep:
+            fail("'*' is not allowed in the matcher")
+
+        for p in tag.split("."):
+            if not sep and p == head:
+                return priority
+            elif sep and p.startswith(head) and p.endswith(tail):
+                return priority
+
+    return None
+
+def select_whl(*, whls, python_version, platforms, want_abis, implementation = "cp", limit = 1, logger = None):
+    """Select a whl that is the most suitable for the given platform.
+
+    Args:
+        whls: {type}`list[struct]` a list of candidates which have a `filename`
+            attribute containing the `whl` filename.
+        python_version: {type}`str` the target python version.
+        platforms: {type}`list[str]` the target platform identifiers that may contain
+            a single `*` character.
+        implementation: {type}`str` TODO
+        want_abis: {type}`str` TODO
+        limit: {type}`int` number of wheels to return. Defaults to 1.
+        logger: {type}`struct` the logger instance.
+
+    Returns:
+        {type}`list[struct] | struct | None`, a single struct from the `whls` input
+            argument or `None` if a match is not found. If the `limit` is greater than
+            one, then we will return a list.
+    """
+    py_version = version.parse(python_version, strict = True)
+
+    # Get the minor version instead
+    # TODO @aignas 2025-06-27: do this more efficiently
+    py_version = version.parse("{0}.{1}".format(*py_version.release), strict = True)
+    candidates = {}
+
+    for whl in whls:
+        parsed = parse_whl_name(whl.filename)
+
+        suffix = ""
+        if parsed.abi_tag.startswith(implementation):
+            v = parsed.abi_tag[2:]
+            min_whl_py_version = version.parse(
+                "{}.{}".format(v[0], v[1:].strip("tmu")),
+                strict = False,
+            )
+            if not min_whl_py_version:
+                if logger:
+                    logger.warn(lambda: "Discarding the wheel ('{}') because we could not parse the version from the abi tag".format(whl.filename))
+                continue
+
+            if parsed.abi_tag.endswith("t"):
+                suffix = "t"
+
+            if not version.is_eq(py_version, min_whl_py_version):
+                if logger:
+                    logger.debug(lambda: "Discarding the wheel ('{}') because the min version supported based on the wheel ABI tag '{}' ({}) is not compatible with the provided target Python version '{}'".format(
+                        whl.filename,
+                        parsed.abi_tag,
+                        min_whl_py_version.string,
+                        py_version.string,
+                    ))
+                continue
+        else:
+            if parsed.python_tag.startswith("py"):
+                pass
+            elif not parsed.python_tag.startswith(implementation):
+                if logger:
+                    logger.debug(lambda: "Discarding the wheel because the implementation '{}' is not compatible with target implementation '{}'".format(
+                        parsed.python_tag,
+                        implementation,
+                    ))
+                continue
+
+            if parsed.python_tag == "py2.py3":
+                min_version = "2"
+            else:
+                min_version = parsed.python_tag[2:]
+
+            if len(min_version) > 1:
+                min_version = "{}.{}".format(min_version[0], min_version[1:])
+
+            min_whl_py_version = version.parse(min_version, strict = True)
+            if not version.is_ge(py_version, min_whl_py_version):
+                if logger:
+                    logger.debug(lambda: "Discarding the wheel because the min version supported based on the wheel ABI tag '{}' ({}) is not compatible with the provided target Python version '{}'".format(
+                        parsed.abi_tag,
+                        min_whl_py_version.string,
+                        py_version.string,
+                    ))
+                continue
+
+        abi_priority = _get_priority(
+            tag = parsed.abi_tag,
+            values = want_abis,
+            allow_wildcard = False,
+        )
+        if abi_priority == None:
+            if logger:
+                logger.debug(lambda: "The abi '{}' does not match given list: {}".format(
+                    parsed.abi_tag,
+                    want_abis,
+                ))
+            continue
+        platform_priority = _get_priority(
+            tag = parsed.platform_tag,
+            values = platforms,
+        )
+        if platform_priority == None:
+            if logger:
+                logger.debug(lambda: "The platform_tag '{}' does not match given list: {}".format(
+                    parsed.platform_tag,
+                    platforms,
+                ))
+            continue
+
+        key = (
+            # Ensure that we chose the highest compatible version
+            parsed.python_tag.startswith(implementation),
+            platform_priority,
+            # prefer abi_tags in this order
+            version.key(min_whl_py_version),
+            abi_priority,
+            suffix,
+        )
+        candidates.setdefault(key, whl)
+
+    if not candidates:
+        return None
+
+    sorted_candidates = [i[1] for i in sorted(candidates.items())]
+    if logger:
+        logger.debug(lambda: "Sorted candidates:\n{}".format(
+            "\n".join([c.filename for c in sorted_candidates]),
+        ))
+    results = sorted_candidates[-limit:] if sorted_candidates else None
+
+    return results[-1] if limit == 1 else results

python/private/pypi/whl_target_platforms.bzl

@@ -16,9 +16,6 @@
 A starlark implementation of the wheel platform tag parsing to get the target platform.
 """
 
-load("//python/private:version.bzl", "version")
-load(":parse_whl_name.bzl", "parse_whl_name")
-
 # The order of the dictionaries is to keep definitions with their aliases next to each
 # other
 _CPU_ALIASES = {
@@ -47,153 +44,6 @@ _OS_PREFIXES = {
     "win": "windows",
 }  # buildifier: disable=unsorted-dict-items
 
-def _get_priority(*, tag, values, allow_wildcard = True):
-    for priority, wp in enumerate(values):
-        # TODO @aignas 2025-06-16: move the matcher validation out of this
-        # TODO @aignas 2025-06-21: test the 'cp*' matching
-        head, sep, tail = wp.partition("*")
-        if "*" in tail:
-            fail("only a single '*' can be present in the matcher")
-        if not allow_wildcard and sep:
-            fail("'*' is not allowed in the matcher")
-
-        for p in tag.split("."):
-            if not sep and p == head:
-                return priority
-            elif sep and p.startswith(head) and p.endswith(tail):
-                return priority
-
-    return None
-
-def select_whl(*, whls, python_version, platforms, want_abis, implementation = "cp", limit = 1, logger = None):
-    """Select a whl that is the most suitable for the given platform.
-
-    Args:
-        whls: {type}`list[struct]` a list of candidates which have a `filename`
-            attribute containing the `whl` filename.
-        python_version: {type}`str` the target python version.
-        platforms: {type}`list[str]` the target platform identifiers that may contain
-            a single `*` character.
-        implementation: {type}`str` TODO
-        want_abis: {type}`str` TODO
-        limit: {type}`int` number of wheels to return. Defaults to 1.
-        logger: {type}`struct` the logger instance.
-
-    Returns:
-        {type}`list[struct] | struct | None`, a single struct from the `whls` input
-            argument or `None` if a match is not found. If the `limit` is greater than
-            one, then we will return a list.
-    """
-    py_version = version.parse(python_version, strict = True)
-
-    # Get the minor version instead
-    # TODO @aignas 2025-06-27: do this more efficiently
-    py_version = version.parse("{0}.{1}".format(*py_version.release), strict = True)
-    candidates = {}
-
-    for whl in whls:
-        parsed = parse_whl_name(whl.filename)
-
-        suffix = ""
-        if parsed.abi_tag.startswith(implementation):
-            v = parsed.abi_tag[2:]
-            min_whl_py_version = version.parse(
-                "{}.{}".format(v[0], v[1:].strip("tmu")),
-                strict = False,
-            )
-            if not min_whl_py_version:
-                if logger:
-                    logger.warn(lambda: "Discarding the wheel ('{}') because we could not parse the version from the abi tag".format(whl.filename))
-                continue
-
-            if parsed.abi_tag.endswith("t"):
-                suffix = "t"
-
-            if not version.is_eq(py_version, min_whl_py_version):
-                if logger:
-                    logger.debug(lambda: "Discarding the wheel ('{}') because the min version supported based on the wheel ABI tag '{}' ({}) is not compatible with the provided target Python version '{}'".format(
-                        whl.filename,
-                        parsed.abi_tag,
-                        min_whl_py_version.string,
-                        py_version.string,
-                    ))
-                continue
-        else:
-            if parsed.python_tag.startswith("py"):
-                pass
-            elif not parsed.python_tag.startswith(implementation):
-                if logger:
-                    logger.debug(lambda: "Discarding the wheel because the implementation '{}' is not compatible with target implementation '{}'".format(
-                        parsed.python_tag,
-                        implementation,
-                    ))
-                continue
-
-            if parsed.python_tag == "py2.py3":
-                min_version = "2"
-            else:
-                min_version = parsed.python_tag[2:]
-
-            if len(min_version) > 1:
-                min_version = "{}.{}".format(min_version[0], min_version[1:])
-
-            min_whl_py_version = version.parse(min_version, strict = True)
-            if not version.is_ge(py_version, min_whl_py_version):
-                if logger:
-                    logger.debug(lambda: "Discarding the wheel because the min version supported based on the wheel ABI tag '{}' ({}) is not compatible with the provided target Python version '{}'".format(
-                        parsed.abi_tag,
-                        min_whl_py_version.string,
-                        py_version.string,
-                    ))
-                continue
-
-        abi_priority = _get_priority(
-            tag = parsed.abi_tag,
-            values = want_abis,
-            allow_wildcard = False,
-        )
-        if abi_priority == None:
-            if logger:
-                logger.debug(lambda: "The abi '{}' does not match given list: {}".format(
-                    parsed.abi_tag,
-                    want_abis,
-                ))
-            continue
-        platform_priority = _get_priority(
-            tag = parsed.platform_tag,
-            values = platforms,
-        )
-        if platform_priority == None:
-            if logger:
-                logger.debug(lambda: "The platform_tag '{}' does not match given list: {}".format(
-                    parsed.platform_tag,
-                    platforms,
-                ))
-            continue
-
-        key = (
-            # Ensure that we chose the highest compatible version
-            parsed.python_tag.startswith(implementation),
-            platform_priority,
-            # prefer abi_tags in this order
-            version.key(min_whl_py_version),
-            abi_priority,
-            suffix,
-        )
-        candidates.setdefault(key, whl)
-
-    if not candidates:
-        return None
-
-    sorted_candidates = [i[1] for i in sorted(candidates.items())]
-    if logger:
-        logger.debug(lambda: "Sorted candidates:\n{}".format(
-            "\n".join([c.filename for c in sorted_candidates]),
-        ))
-    results = sorted_candidates[-limit:] if sorted_candidates else None
-
-    return results[-1] if limit == 1 else results
-
 def whl_target_platforms(platform_tag, abi_tag = ""):
     """Parse the wheel abi and platform tags and return (os, cpu) tuples.
 

tests/pypi/select_whl/BUILD.bazel

@@ -0,0 +1,3 @@
+load(":select_whl_tests.bzl", "select_whl_test_suite")
+
+select_whl_test_suite(name = "select_whl_tests")

tests/pypi/whl_target_platforms/select_whl_tests.bzl renamed to tests/pypi/select_whl/select_whl_tests.bzl

@@ -1,22 +1,8 @@
-# Copyright 2024 The Bazel Authors. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
 ""
 
 load("@rules_testing//lib:test_suite.bzl", "test_suite")
 load("//python/private:repo_utils.bzl", "REPO_DEBUG_ENV_VAR", "REPO_VERBOSITY_ENV_VAR", "repo_utils")  # buildifier: disable=bzl-visibility
-load("//python/private/pypi:whl_target_platforms.bzl", "select_whl")  # buildifier: disable=bzl-visibility
+load("//python/private/pypi:select_whl.bzl", "select_whl")  # buildifier: disable=bzl-visibility
 
 WHL_LIST = [
     "pkg-0.0.1-cp311-cp311-macosx_10_9_universal2.whl",