further refactor and use native as a parameter to make it easier to override

Author: aignas

python/private/config_settings.bzl

@@ -182,7 +182,7 @@ def construct_config_settings(name = None):  # buildifier: disable=function-docs
     )
 
     native.config_setting(
-        name = "is_python_default",
+        name = "is_python_version_unset",
         flag_values = {
             Label("//python/config_settings:python_version"): "",
         },

python/private/pip_config_settings.bzl

@@ -82,8 +82,7 @@ def pip_config_settings(
         target_platforms = [],
         name = None,
         visibility = None,
-        alias_rule = None,
-        config_setting_rule = None):
+        native = native):
     """Generate all of the pip config settings.
 
     Args:
@@ -100,10 +99,9 @@ def pip_config_settings(
             constraint values for each condition.
         visibility (list[str], optional): The visibility to be passed to the
             exposed labels. All other labels will be private.
-        alias_rule (rule): The alias rule to use for creating the
-            objects. Can be overridden for unit tests reasons.
-        config_setting_rule (rule): The config setting rule to use for creating the
-            objects. Can be overridden for unit tests reasons.
+        native (struct): The struct containing alias and config_setting rules
+            to use for creating the objects. Can be overridden for unit tests
+            reasons.
     """
 
     glibc_versions = [""] + glibc_versions
@@ -114,38 +112,25 @@ def pip_config_settings(
         for t in target_platforms
     ]
 
-    alias_rule = alias_rule or native.alias
-    config_setting_rule = config_setting_rule or _dist_config_setting
-
-    for version in ["default"] + python_versions:
-        is_python = "is_python_{}".format(version)
-        alias_rule(
+    for python_version in [""] + python_versions:
+        is_python = "is_python_{}".format(python_version or "version_unset")
+        native.alias(
             name = is_python,
             actual = Label("//python/config_settings:" + is_python),
             visibility = visibility,
         )
 
-    for os, cpu in target_platforms:
-        constraint_values = []
-        suffix = ""
-        if os:
-            constraint_values.append("@platforms//os:" + os)
-            suffix += "_" + os
-        if cpu:
-            constraint_values.append("@platforms//cpu:" + cpu)
-            suffix += "_" + cpu
-
-        for python_version in [""] + python_versions:
-            sdist = "cp{}_sdist".format(python_version) if python_version else "sdist"
-            config_setting_rule(
-                name = "is_{}{}".format(sdist, suffix),
-                python_version = python_version,
-                flag_values = {_flags.dist: ""},
-                is_pip_whl = FLAGS.is_pip_whl_no,
-                constraint_values = constraint_values,
-                visibility = visibility,
-            )
-            _whl_config_settings(
+        for os, cpu in target_platforms:
+            constraint_values = []
+            suffix = ""
+            if os:
+                constraint_values.append("@platforms//os:" + os)
+                suffix += "_" + os
+            if cpu:
+                constraint_values.append("@platforms//cpu:" + cpu)
+                suffix += "_" + cpu
+
+            _dist_config_settings(
                 suffix = suffix,
                 plat_flag_values = _plat_flag_values(
                     os = os,
@@ -156,39 +141,45 @@ def pip_config_settings(
                 ),
                 constraint_values = constraint_values,
                 python_version = python_version,
-                is_pip_whl = FLAGS.is_pip_whl_only,
+                is_python = is_python,
                 visibility = visibility,
-                config_setting_rule = config_setting_rule,
+                native = native,
             )
 
-def _whl_config_settings(*, suffix, plat_flag_values, config_setting_rule, **kwargs):
-    # With the following three we cover different per-version wheels
-    python_version = kwargs.get("python_version")
-    py = "cp{}_py".format(python_version) if python_version else "py"
-    pycp = "cp{}_cp3x".format(python_version) if python_version else "cp3x"
-
-    flag_values = {
-        _flags.dist: "",
-    }
+def _dist_config_settings(*, suffix, plat_flag_values, **kwargs):
+    flag_values = {_flags.dist: ""}
+
+    # First create an sdist, we will be building upon the flag values, which
+    # will ensure that each sdist config setting is the least specialized of
+    # all. However, we need at least one flag value to cover the case where we
+    # have `sdist` for any platform, hence we have a non-empty `flag_values`
+    # here.
+    _dist_config_setting(
+        name = "sdist{}".format(suffix),
+        flag_values = flag_values,
+        is_pip_whl = FLAGS.is_pip_whl_no,
+        **kwargs
+    )
 
-    for name, f in {
-        "is_{}_none_any{}".format(py, suffix): _flags.whl_py2_py3,
-        "is_{}3_none_any{}".format(py, suffix): _flags.whl_py3,
-        "is_{}3_abi3_any{}".format(py, suffix): _flags.whl_py3_abi3,
-        "is_{}_none_any{}".format(pycp, suffix): _flags.whl_pycp3x,
-        "is_{}_abi3_any{}".format(pycp, suffix): _flags.whl_pycp3x_abi3,
-        "is_{}_cp_any{}".format(pycp, suffix): _flags.whl_pycp3x_abicp,
-    }.items():
+    for name, f in [
+        ("py_none", _flags.whl_py2_py3),
+        ("py3_none", _flags.whl_py3),
+        ("py3_abi3", _flags.whl_py3_abi3),
+        ("cp3x_none", _flags.whl_pycp3x),
+        ("cp3x_abi3", _flags.whl_pycp3x_abi3),
+        ("cp3x_cp", _flags.whl_pycp3x_abicp),
+    ]:
         if f in flag_values:
             # This should never happen as all of the different whls should have
             # unique flag values.
             fail("BUG: the flag {} is attempted to be added twice to the list".format(f))
         else:
             flag_values[f] = ""
 
-        config_setting_rule(
-            name = name,
+        _dist_config_setting(
+            name = "{}_any{}".format(name, suffix),
             flag_values = flag_values,
+            is_pip_whl = FLAGS.is_pip_whl_only,
             **kwargs
         )
 
@@ -197,24 +188,25 @@ def _whl_config_settings(*, suffix, plat_flag_values, config_setting_rule, **kwa
     for (suffix, flag_values) in plat_flag_values:
         flag_values = flag_values | generic_flag_values
 
-        for name, f in {
-            "is_{}_none_{}".format(py, suffix): _flags.whl_plat,
-            "is_{}3_none_{}".format(py, suffix): _flags.whl_plat_py3,
-            "is_{}3_abi3_{}".format(py, suffix): _flags.whl_plat_py3_abi3,
-            "is_{}_none_{}".format(pycp, suffix): _flags.whl_plat_pycp3x,
-            "is_{}_abi3_{}".format(pycp, suffix): _flags.whl_plat_pycp3x_abi3,
-            "is_{}_cp_{}".format(pycp, suffix): _flags.whl_plat_pycp3x_abicp,
-        }.items():
+        for name, f in [
+            ("py_none", _flags.whl_plat),
+            ("py3_none", _flags.whl_plat_py3),
+            ("py3_abi3", _flags.whl_plat_py3_abi3),
+            ("cp3x_none", _flags.whl_plat_pycp3x),
+            ("cp3x_abi3", _flags.whl_plat_pycp3x_abi3),
+            ("cp3x_cp", _flags.whl_plat_pycp3x_abicp),
+        ]:
             if f in flag_values:
                 # This should never happen as all of the different whls should have
                 # unique flag values.
                 fail("BUG: the flag {} is attempted to be added twice to the list".format(f))
             else:
                 flag_values[f] = ""
 
-            config_setting_rule(
-                name = name,
+            _dist_config_setting(
+                name = "{}_{}".format(name, suffix),
                 flag_values = flag_values,
+                is_pip_whl = FLAGS.is_pip_whl_only,
                 **kwargs
             )
 
@@ -284,24 +276,28 @@ def _plat_flag_values(os, cpu, osx_versions, glibc_versions, muslc_versions):
 
     return ret
 
-def _dist_config_setting(*, name, is_pip_whl, python_version = "", **kwargs):
+def _dist_config_setting(*, name, is_pip_whl, is_python, python_version, native = native, **kwargs):
     """A macro to create a target that matches is_pip_whl_auto and one more value.
 
     Args:
         name: The name of the public target.
         is_pip_whl: The config setting to match in addition to
             `is_pip_whl_auto` when evaluating the config setting.
-        python_version: The python version to match.
+        is_python: The python version config_setting to match.
+        python_version: The python version name.
+        native (struct): The struct containing alias and config_setting rules
+            to use for creating the objects. Can be overridden for unit tests
+            reasons.
         **kwargs: The kwargs passed to the config_setting rule. Visibility of
             the main alias target is also taken from the kwargs.
     """
+    name = "is_cp{}_{}".format(python_version, name) if python_version else "is_{}".format(name)
     if python_version:
         _name = name.replace("is_cp{}".format(python_version), "_is")
     else:
         _name = "_" + name
 
     # First match by the python version
-    is_python = ":is_python_" + (python_version or "default")
     visibility = kwargs.get("visibility")
     native.alias(
         name = name,

tests/pip_hub_repository/render_pkg_aliases/render_pkg_aliases_test.bzl

@@ -926,8 +926,10 @@ def _test_config_settings_exist(env):
                 mock_rule = lambda name, **kwargs: available_config_settings.append(name)
                 pip_config_settings(
                     python_versions = ["3.11"],
-                    alias_rule = mock_rule,
-                    config_setting_rule = mock_rule,
+                    native = struct(
+                        alias = mock_rule,
+                        config_setting = mock_rule,
+                    ),
                     **kwargs
                 )