refactor: create group aliases

Author: aignas

examples/bzlmod/MODULE.bazel.lock

@@ -16,28 +16,66 @@
 
 This is used in bzlmod and non-bzlmod setups."""
 
+load("//python/private:text_util.bzl", "render")
 load(
     ":labels.bzl",
     "DATA_LABEL",
     "DIST_INFO_LABEL",
-    #"PY_LIBRARY_IMPL_LABEL",
+    "PY_LIBRARY_IMPL_LABEL",
     "PY_LIBRARY_PUBLIC_LABEL",
-    #"WHEEL_FILE_IMPL_LABEL",
+    "WHEEL_FILE_IMPL_LABEL",
     "WHEEL_FILE_PUBLIC_LABEL",
 )
 
+_NO_MATCH_ERROR_TEMPLATE = """\
+No matching wheel for current configuration's Python version.
+
+The current build configuration's Python version doesn't match any of the Python
+wheels available for this wheel. This wheel supports the following Python
+configuration settings:
+    {config_settings}
+
+To determine the current configuration's Python version, run:
+    `bazel config <config id>` (shown further below)
+and look for
+    {rules_python}//python/config_settings:python_version
+
+If the value is missing, then the "default" Python version is being used,
+which has a "null" version value and will not match version constraints.
+"""
+
+def _no_match_error(actual):
+    if type(actual) != type({}):
+        return None
+
+    if "//conditions:default" in actual:
+        return None
+
+    return _NO_MATCH_ERROR_TEMPLATE.format(
+        config_settings = render.indent(
+            "\n".join(sorted(actual.keys())),
+        ).lstrip(),
+        rules_python = "rules_python",
+    )
+
 def pkg_aliases(
         *,
         name,
         actual,
-        native = native):
+        group_name = None,
+        extra_aliases = None,
+        native = native,
+        select = select):
     """Create aliases for an actual package.
 
     Args:
         name: {type}`str` The name of the package.
-        actual: {type}`dict[Label, str]` The config settings for the package
+        actual: {type}`dict[Label, str] | str` The config settings for the package
             mapping to repositories.
-        native: {type}`struct` used in unit tests
+        group_name: {type}`str` The group name that the pkg belongs to.
+        extra_aliases: {type}`list[str]` The extra aliases to be created.
+        native: {type}`struct` used in unit tests.
+        select: {type}`select` used in unit tests.
     """
     _ = actual  # buildifier: @unused
     native.alias(
@@ -46,25 +84,52 @@ def pkg_aliases(
     )
 
     target_names = {
+        PY_LIBRARY_PUBLIC_LABEL: PY_LIBRARY_IMPL_LABEL if group_name else PY_LIBRARY_PUBLIC_LABEL,
+        WHEEL_FILE_PUBLIC_LABEL: WHEEL_FILE_IMPL_LABEL if group_name else WHEEL_FILE_PUBLIC_LABEL,
+        DATA_LABEL: DATA_LABEL,
+        DIST_INFO_LABEL: DIST_INFO_LABEL,
+    } | {
         x: x
-        for x in [
-            PY_LIBRARY_PUBLIC_LABEL,
-            WHEEL_FILE_PUBLIC_LABEL,
-            DATA_LABEL,
-            DIST_INFO_LABEL,
-        ]
+        for x in extra_aliases or []
     }
+    no_match_error = _no_match_error(actual)
 
-    if type(actual) == type({}):
-        fail("TODO")
+    for name, target_name in target_names.items():
+        if type(actual) == type(""):
+            _actual = "@{repo}//:{target_name}".format(
+                repo = actual,
+                target_name = name,
+            )
+        elif type(actual) == type({}):
+            _actual = select(
+                {
+                    config_setting: "@{repo}//:{target_name}".format(
+                        repo = repo,
+                        target_name = name,
+                    )
+                    for config_setting, repo in actual.items()
+                },
+                no_match_error = no_match_error,
+            )
+        else:
+            fail("BUG: should have a dictionary or a string")
 
-    repo = actual
+        kwargs = {}
+        if target_name.startswith("_"):
+            kwargs["visibility"] = ["//_groups:__subpackages__"]
 
-    for name, target_name in target_names.items():
         native.alias(
-            name = name,
-            actual = "@{repo}//:{target_name}".format(
-                repo = repo,
-                target_name = target_name,
-            ),
+            name = target_name,
+            actual = _actual,
+            **kwargs
+        )
+
+    if group_name:
+        native.alias(
+            name = PY_LIBRARY_PUBLIC_LABEL,
+            actual = "//_groups:{}_pkg".format(group_name),
+        )
+        native.alias(
+            name = WHEEL_FILE_PUBLIC_LABEL,
+            actual = "//_groups:{}_whl".format(group_name),
         )

python/private/pypi/pkg_aliases.bzl

@@ -22,15 +22,6 @@ load(
     ":generate_group_library_build_bazel.bzl",
     "generate_group_library_build_bazel",
 )  # buildifier: disable=bzl-visibility
-load(
-    ":labels.bzl",
-    "DATA_LABEL",
-    "DIST_INFO_LABEL",
-    "PY_LIBRARY_IMPL_LABEL",
-    "PY_LIBRARY_PUBLIC_LABEL",
-    "WHEEL_FILE_IMPL_LABEL",
-    "WHEEL_FILE_PUBLIC_LABEL",
-)
 load(":parse_whl_name.bzl", "parse_whl_name")
 load(":whl_target_platforms.bzl", "whl_target_platforms")
 
@@ -70,124 +61,38 @@ If the value is missing, then the "default" Python version is being used,
 which has a "null" version value and will not match version constraints.
 """
 
-def _render_whl_library_alias(
-        *,
-        name,
-        aliases,
-        target_name,
-        **kwargs):
-    """Render an alias for common targets."""
-    if len(aliases) == 1 and not aliases[0].version:
-        return ""
-
-    # Create the alias repositories which contains different select
-    # statements  These select statements point to the different pip
-    # whls that are based on a specific version of Python.
-    selects = {}
-    no_match_error = "_NO_MATCH_ERROR"
-    for alias in sorted(aliases, key = lambda x: x.version):
-        actual = "@{repo}//:{name}".format(repo = alias.repo, name = target_name)
-        selects.setdefault(actual, []).append(alias.config_setting)
-
-    return render.alias(
-        name = name,
-        actual = render.select(
-            {
-                tuple(sorted(
-                    conditions,
-                    # Group `is_python` and other conditions for easier reading
-                    # when looking at the generated files.
-                    key = lambda condition: ("is_python" not in condition, condition),
-                )): target
-                for target, conditions in sorted(selects.items())
-            },
-            no_match_error = no_match_error,
-            # This key_repr is used to render selects.with_or keys
-            key_repr = lambda x: repr(x[0]) if len(x) == 1 else render.tuple(x),
-            name = "selects.with_or",
-        ),
-        **kwargs
-    )
+def _render_pkg_aliases(name, actual, group_name, extra_aliases):
+    if len(actual) == 1 and None in actual:
+        actual = repr(actual.values()[0])
+    else:
+        actual = render.indent(render.dict(actual)).lstrip()
 
-def _render_pkg_aliases(name, actual):
-    actual = actual.values()[0] if len(actual) == 1 and None in actual else ":pkg"
     return """\
 pkg_aliases(
     name = "{name}",
     actual = {actual},
-)""".format(name = name, actual = repr(actual))
+    group_name = {group_name},
+    extra_aliases = {extra_aliases},
+)""".format(name = name, actual = actual, group_name = repr(group_name), extra_aliases = repr(extra_aliases))
 
 def _render_common_aliases(*, name, aliases, extra_aliases = [], group_name = None):
     lines = [
         """\
-load("@bazel_skylib//lib:selects.bzl", "selects")
 load("@rules_python//python/private/pypi:pkg_aliases.bzl", "pkg_aliases")""",
         """package(default_visibility = ["//visibility:public"])""",
     ]
 
-    config_settings = None
-    if aliases:
-        config_settings = sorted([v.config_setting for v in aliases if v.config_setting])
-
-    if config_settings:
-        error_msg = NO_MATCH_ERROR_MESSAGE_TEMPLATE_V2.format(
-            config_settings = render.indent(
-                "\n".join(config_settings),
-            ).lstrip(),
-            rules_python = "rules_python",
-        )
-
-        lines.append("_NO_MATCH_ERROR = \"\"\"\\\n{error_msg}\"\"\"".format(
-            error_msg = error_msg,
-        ))
-
     lines.append(
         _render_pkg_aliases(
             name = name,
             actual = {
                 a.config_setting: a.repo
                 for a in aliases
             },
+            group_name = group_name,
+            extra_aliases = extra_aliases,
         ),
     )
-    lines.extend(
-        [
-            line
-            for line in [
-                _render_whl_library_alias(
-                    name = name,
-                    aliases = aliases,
-                    target_name = target_name,
-                    visibility = ["//_groups:__subpackages__"] if name.startswith("_") else None,
-                )
-                for target_name, name in (
-                    {
-                        PY_LIBRARY_PUBLIC_LABEL: PY_LIBRARY_IMPL_LABEL if group_name else PY_LIBRARY_PUBLIC_LABEL,
-                        WHEEL_FILE_PUBLIC_LABEL: WHEEL_FILE_IMPL_LABEL if group_name else WHEEL_FILE_PUBLIC_LABEL,
-                        DATA_LABEL: DATA_LABEL,
-                        DIST_INFO_LABEL: DIST_INFO_LABEL,
-                    } | {
-                        x: x
-                        for x in extra_aliases
-                    }
-                ).items()
-            ]
-            if line
-        ],
-    )
-    if group_name:
-        lines.extend(
-            [
-                render.alias(
-                    name = "pkg",
-                    actual = repr("//_groups:{}_pkg".format(group_name)),
-                ),
-                render.alias(
-                    name = "whl",
-                    actual = repr("//_groups:{}_whl".format(group_name)),
-                ),
-            ],
-        )
 
     return "\n\n".join(lines)