Merge remote-tracking branch 'upstream/main' into support_python_3.13.1

okin · okin · commit 779f0856ddec · 2024-12-23T15:37:59.000+01:00
diff --git a/.bazelignore b/.bazelignore
@@ -18,6 +18,7 @@ examples/bzlmod/other_module/bazel-bin
 examples/bzlmod/other_module/bazel-other_module
 examples/bzlmod/other_module/bazel-out
 examples/bzlmod/other_module/bazel-testlogs
+examples/bzlmod/py_proto_library/foo_external
 examples/bzlmod_build_file_generation/bazel-bzlmod_build_file_generation
 examples/multi_python_versions/bazel-multi_python_versions
 examples/pip_parse/bazel-pip_parse
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -71,6 +71,10 @@ Unreleased changes template.
 * (pypi) Using {bzl:obj}`pip_parse.experimental_requirement_cycles` and
   {bzl:obj}`pip_parse.use_hub_alias_dependencies` together now works when
   using WORKSPACE files.
+* (pypi) The error messages when the wheel distributions do not match anything
+  are now printing more details and include the currently active flag
+  values. Fixes [#2466](https://github.com/bazelbuild/rules_python/issues/2466).
+* (py_proto_library) Fix import paths in Bazel 8.
 
 [pep-695]: https://peps.python.org/pep-0695/
 
diff --git a/docs/api/rules_python/python/config_settings/index.md b/docs/api/rules_python/python/config_settings/index.md
@@ -240,3 +240,21 @@ instead.
 :::
 
 ::::
+
+::::{bzl:flag} current_config
+Fail the build if the current build configuration does not match the
+{obj}`pip.parse` defined wheels.
+
+Values:
+* `fail`: Will fail in the build action ensuring that we get the error
+  message no matter the action cache.
+* ``: (empty string) The default value, that will just print a warning.
+
+:::{seealso}
+{obj}`pip.parse`
+:::
+
+:::{versionadded} 1.1.0
+:::
+
+::::
diff --git a/examples/bzlmod/.bazelignore b/examples/bzlmod/.bazelignore
@@ -1 +1,2 @@
 other_module
+py_proto_library/foo_external
diff --git a/examples/bzlmod/MODULE.bazel b/examples/bzlmod/MODULE.bazel
@@ -5,6 +5,7 @@ module(
 )
 
 bazel_dep(name = "bazel_skylib", version = "1.7.1")
+bazel_dep(name = "platforms", version = "0.0.4")
 bazel_dep(name = "rules_python", version = "0.0.0")
 local_path_override(
     module_name = "rules_python",
@@ -272,5 +273,11 @@ local_path_override(
     path = "other_module",
 )
 
+bazel_dep(name = "foo_external", version = "")
+local_path_override(
+    module_name = "foo_external",
+    path = "py_proto_library/foo_external",
+)
+
 # example test dependencies
 bazel_dep(name = "rules_shell", version = "0.3.0", dev_dependency = True)
diff --git a/examples/bzlmod/py_proto_library/BUILD.bazel b/examples/bzlmod/py_proto_library/BUILD.bazel
@@ -1,3 +1,4 @@
+load("@bazel_skylib//rules:native_binary.bzl", "native_test")
 load("@rules_python//python:py_test.bzl", "py_test")
 
 py_test(
@@ -16,3 +17,18 @@ py_test(
         "//py_proto_library/example.com/another_proto:message_proto_py_pb2",
     ],
 )
+
+# Regression test for https://github.com/bazelbuild/rules_python/issues/2515
+#
+# This test failed before https://github.com/bazelbuild/rules_python/pull/2516
+# when ran with --legacy_external_runfiles=False (default in Bazel 8.0.0).
+native_test(
+    name = "external_import_test",
+    src = "@foo_external//:py_binary_with_proto",
+    # Incompatible with Windows: native_test wrapping a py_binary doesn't work
+    # on Windows.
+    target_compatible_with = select({
+        "@platforms//os:windows": ["@platforms//:incompatible"],
+        "//conditions:default": [],
+    }),
+)
diff --git a/examples/bzlmod/py_proto_library/foo_external/BUILD.bazel b/examples/bzlmod/py_proto_library/foo_external/BUILD.bazel
@@ -0,0 +1,22 @@
+load("@rules_proto//proto:defs.bzl", "proto_library")
+load("@rules_python//python:proto.bzl", "py_proto_library")
+load("@rules_python//python:py_binary.bzl", "py_binary")
+
+package(default_visibility = ["//visibility:public"])
+
+proto_library(
+    name = "proto_lib",
+    srcs = ["nested/foo/my_proto.proto"],
+    strip_import_prefix = "/nested/foo",
+)
+
+py_proto_library(
+    name = "a_proto",
+    deps = [":proto_lib"],
+)
+
+py_binary(
+    name = "py_binary_with_proto",
+    srcs = ["py_binary_with_proto.py"],
+    deps = [":a_proto"],
+)
diff --git a/examples/bzlmod/py_proto_library/foo_external/MODULE.bazel b/examples/bzlmod/py_proto_library/foo_external/MODULE.bazel
@@ -0,0 +1,8 @@
+module(
+    name = "foo_external",
+    version = "0.0.1",
+)
+
+bazel_dep(name = "rules_python", version = "1.0.0")
+bazel_dep(name = "protobuf", version = "28.2", repo_name = "com_google_protobuf")
+bazel_dep(name = "rules_proto", version = "7.0.2")
diff --git a/examples/bzlmod/py_proto_library/foo_external/WORKSPACE b/examples/bzlmod/py_proto_library/foo_external/WORKSPACE
diff --git a/examples/bzlmod/py_proto_library/foo_external/nested/foo/my_proto.proto b/examples/bzlmod/py_proto_library/foo_external/nested/foo/my_proto.proto
@@ -0,0 +1,6 @@
+syntax = "proto3";
+
+package my_proto;
+
+message MyMessage {
+}
diff --git a/examples/bzlmod/py_proto_library/foo_external/py_binary_with_proto.py b/examples/bzlmod/py_proto_library/foo_external/py_binary_with_proto.py
@@ -0,0 +1,5 @@
+import sys
+
+if __name__ == "__main__":
+    import my_proto_pb2
+    sys.exit(0)
diff --git a/python/config_settings/BUILD.bazel b/python/config_settings/BUILD.bazel
@@ -29,6 +29,15 @@ filegroup(
 construct_config_settings(
     name = "construct_config_settings",
     default_version = DEFAULT_PYTHON_VERSION,
+    documented_flags = [
+        ":pip_whl",
+        ":pip_whl_glibc_version",
+        ":pip_whl_muslc_version",
+        ":pip_whl_osx_arch",
+        ":pip_whl_osx_version",
+        ":py_freethreaded",
+        ":py_linux_libc",
+    ],
     minor_mapping = MINOR_MAPPING,
     versions = PYTHON_VERSIONS,
 )
diff --git a/python/private/config_settings.bzl b/python/private/config_settings.bzl
@@ -17,12 +17,21 @@
 
 load("@bazel_skylib//lib:selects.bzl", "selects")
 load("@bazel_skylib//rules:common_settings.bzl", "BuildSettingInfo")
+load("//python/private:text_util.bzl", "render")
 load(":semver.bzl", "semver")
 
 _PYTHON_VERSION_FLAG = Label("//python/config_settings:python_version")
 _PYTHON_VERSION_MAJOR_MINOR_FLAG = Label("//python/config_settings:python_version_major_minor")
 
-def construct_config_settings(*, name, default_version, versions, minor_mapping):  # buildifier: disable=function-docstring
+_DEBUG_ENV_MESSAGE_TEMPLATE = """\
+The current configuration rules_python config flags is:
+    {flags}
+
+If the value is missing, then the default value is being used, see documentation:
+{docs_url}/python/config_settings
+"""
+
+def construct_config_settings(*, name, default_version, versions, minor_mapping, documented_flags):  # buildifier: disable=function-docstring
     """Create a 'python_version' config flag and construct all config settings used in rules_python.
 
     This mainly includes the targets that are used in the toolchain and pip hub
@@ -33,6 +42,8 @@ def construct_config_settings(*, name, default_version, versions, minor_mapping)
         default_version: {type}`str` the default value for the `python_version` flag.
         versions: {type}`list[str]` A list of versions to build constraint settings for.
         minor_mapping: {type}`dict[str, str]` A mapping from `X.Y` to `X.Y.Z` python versions.
+        documented_flags: {type}`list[str]` The labels of the documented settings
+            that affect build configuration.
     """
     _ = name  # @unused
     _python_version_flag(
@@ -101,6 +112,25 @@ def construct_config_settings(*, name, default_version, versions, minor_mapping)
             visibility = ["//visibility:public"],
         )
 
+    _current_config(
+        name = "current_config",
+        build_setting_default = "",
+        settings = documented_flags + [_PYTHON_VERSION_FLAG.name],
+        visibility = ["//visibility:private"],
+    )
+    native.config_setting(
+        name = "is_not_matching_current_config",
+        # We use the rule above instead of @platforms//:incompatible so that the
+        # printing of the current env always happens when the _current_config rule
+        # is executed.
+        #
+        # NOTE: This should in practise only happen if there is a missing compatible
+        # `whl_library` in the hub repo created by `pip.parse`.
+        flag_values = {"current_config": "will-never-match"},
+        # Only public so that PyPI hub repo can access it
+        visibility = ["//visibility:public"],
+    )
+
 def _python_version_flag_impl(ctx):
     value = ctx.build_setting_value
     return [
@@ -122,7 +152,7 @@ _python_version_flag = rule(
 )
 
 def _python_version_major_minor_flag_impl(ctx):
-    input = ctx.attr._python_version_flag[config_common.FeatureFlagInfo].value
+    input = _flag_value(ctx.attr._python_version_flag)
     if input:
         version = semver(input)
         value = "{}.{}".format(version.major, version.minor)
@@ -140,3 +170,42 @@ _python_version_major_minor_flag = rule(
         ),
     },
 )
+
+def _flag_value(s):
+    if config_common.FeatureFlagInfo in s:
+        return s[config_common.FeatureFlagInfo].value
+    else:
+        return s[BuildSettingInfo].value
+
+def _print_current_config_impl(ctx):
+    flags = "\n".join([
+        "{}: \"{}\"".format(k, v)
+        for k, v in sorted({
+            str(setting.label): _flag_value(setting)
+            for setting in ctx.attr.settings
+        }.items())
+    ])
+
+    msg = ctx.attr._template.format(
+        docs_url = "https://rules-python.readthedocs.io/en/latest/api/rules_python",
+        flags = render.indent(flags).lstrip(),
+    )
+    if ctx.build_setting_value and ctx.build_setting_value != "fail":
+        fail("Only 'fail' and empty build setting values are allowed for {}".format(
+            str(ctx.label),
+        ))
+    elif ctx.build_setting_value:
+        fail(msg)
+    else:
+        print(msg)  # buildifier: disable=print
+
+    return [config_common.FeatureFlagInfo(value = "")]
+
+_current_config = rule(
+    implementation = _print_current_config_impl,
+    build_setting = config.string(flag = True),
+    attrs = {
+        "settings": attr.label_list(mandatory = True),
+        "_template": attr.string(default = _DEBUG_ENV_MESSAGE_TEMPLATE),
+    },
+)
diff --git a/python/private/proto/py_proto_library.bzl b/python/private/proto/py_proto_library.bzl
@@ -98,7 +98,12 @@ def _py_proto_aspect_impl(target, ctx):
             proto_root = proto_root[len(ctx.bin_dir.path) + 1:]
 
         plugin_output = ctx.bin_dir.path + "/" + proto_root
-        proto_root = ctx.workspace_name + "/" + proto_root
+
+        # Import path within the runfiles tree
+        if proto_root.startswith("external/"):
+            proto_root = proto_root[len("external") + 1:]
+        else:
+            proto_root = ctx.workspace_name + "/" + proto_root
 
         proto_common.compile(
             actions = ctx.actions,
diff --git a/python/private/pypi/pkg_aliases.bzl b/python/private/pypi/pkg_aliases.bzl
@@ -36,8 +36,6 @@ load(":whl_target_platforms.bzl", "whl_target_platforms")
 # it. It is more of an internal consistency check.
 _VERSION_NONE = (0, 0)
 
-_CONFIG_SETTINGS_PKG = str(Label("//python/config_settings:BUILD.bazel")).partition(":")[0]
-
 _NO_MATCH_ERROR_TEMPLATE = """\
 No matching wheel for current configuration's Python version.
 
@@ -49,37 +47,18 @@ configuration settings:
 To determine the current configuration's Python version, run:
     `bazel config <config id>` (shown further below)
 
-and look for one of:
-    {settings_pkg}:python_version
-    {settings_pkg}:pip_whl
-    {settings_pkg}:pip_whl_glibc_version
-    {settings_pkg}:pip_whl_muslc_version
-    {settings_pkg}:pip_whl_osx_arch
-    {settings_pkg}:pip_whl_osx_version
-    {settings_pkg}:py_freethreaded
-    {settings_pkg}:py_linux_libc
-
-If the value is missing, then the default value is being used, see documentation:
-{docs_url}/python/config_settings"""
-
-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([
-                value
-                for key in actual
-                for value in (key if type(key) == "tuple" else [key])
-            ])),
-        ).lstrip(),
-        settings_pkg = _CONFIG_SETTINGS_PKG,
-        docs_url = "https://rules-python.readthedocs.io/en/latest/api/rules_python",
-    )
+For the current configuration value see the debug message above that is
+printing the current flag values. If you can't see the message, then re-run the
+build to make it a failure instead by running the build with:
+    --{current_flags}=fail
+
+However, the command above will hide the `bazel config <config id>` message.
+"""
+
+_LABEL_NONE = Label("//python:none")
+_LABEL_CURRENT_CONFIG = Label("//python/config_settings:current_config")
+_LABEL_CURRENT_CONFIG_NO_MATCH = Label("//python/config_settings:is_not_matching_current_config")
+_INCOMPATIBLE = "_no_matching_repository"
 
 def pkg_aliases(
         *,
@@ -120,7 +99,26 @@ def pkg_aliases(
     }
 
     actual = multiplatform_whl_aliases(aliases = actual, **kwargs)
-    no_match_error = _no_match_error(actual)
+    if type(actual) == type({}) and "//conditions:default" not in actual:
+        native.alias(
+            name = _INCOMPATIBLE,
+            actual = select(
+                {_LABEL_CURRENT_CONFIG_NO_MATCH: _LABEL_NONE},
+                no_match_error = _NO_MATCH_ERROR_TEMPLATE.format(
+                    config_settings = render.indent(
+                        "\n".join(sorted([
+                            value
+                            for key in actual
+                            for value in (key if type(key) == "tuple" else [key])
+                        ])),
+                    ).lstrip(),
+                    current_flags = str(_LABEL_CURRENT_CONFIG),
+                ),
+            ),
+            visibility = ["//visibility:private"],
+            tags = ["manual"],
+        )
+        actual["//conditions:default"] = _INCOMPATIBLE
 
     for name, target_name in target_names.items():
         if type(actual) == type(""):
@@ -134,10 +132,9 @@ def pkg_aliases(
                     v: "@{repo}//:{target_name}".format(
                         repo = repo,
                         target_name = name,
-                    )
+                    ) if repo != _INCOMPATIBLE else repo
                     for v, repo in actual.items()
                 },
-                no_match_error = no_match_error,
             )
         else:
             fail("The `actual` arg must be a dictionary or a string")
diff --git a/tests/pypi/pkg_aliases/pkg_aliases_test.bzl b/tests/pypi/pkg_aliases/pkg_aliases_test.bzl

Original file line number	Diff line number	Diff line change
`@@ -1 +1,2 @@`
`1`	`1`	`other_module`
	`2`	`+py_proto_library/foo_external`