feat(uv): parse the dist-manifest.json to not hardcode sha256 in rules_python (#2578)

Finalize the `uv` extension interface employing a builder pattern so
that the users can specify the exact version that needs to be
registered.
This also moves the registration of the actual toolchain to
`rules_python`
itself and ensures that an incompatible noop toolchain is registered if
nothing is configured. This ensures that the
`register_toolchains("@uv//:all")`
never fails.

If the `url/sha256` values are not specified, this is falling back to
using the `dist-manifest.json` on the GH releases page so that
we can get the expected `sha256` value of each available file and
download all of the usable archives. This means that `rules_python` no
longer needs to be updated for `uv` version bumps.

The remaining bits for closing the ticket:
- [ ] Finalize the `lock` interface.
- [ ] Add the locking target to the `pip.parse` hub repo if
`pyproject.toml`
    is passed in.
- [ ] Add a rule/target for `venv` creation.

Work towards #1975.

Author: aignas

CHANGELOG.md

@@ -80,6 +80,11 @@ Unreleased changes template.
 * {obj}`//python/bin:python`: convenience target for directly running an
   interpreter. {obj}`--//python/bin:python_src` can be used to specify a
   binary whose interpreter to use.
+* (uv) Now the extension can be fully configured via `bzlmod` APIs without the
+  need to patch `rules_python`. The documentation has been added to `rules_python`
+  docs but usage of the extension may result in your setup breaking without any
+  notice. What is more, the URLs and SHA256 values will be retrieved from the
+  GitHub releases page metadata published by the `uv` project.
 * (pypi) An extra argument to add the interpreter lib dir to `LDFLAGS` when
   building wheels from `sdist`.
 

MODULE.bazel

@@ -174,16 +174,83 @@ use_repo(
     "build_bazel_bazel_self",
 )
 
-# EXPERIMENTAL: This is experimental and may be removed without notice
-uv = use_extension(
+# TODO @aignas 2025-01-27: should this be moved to `//python/extensions:uv.bzl` or should
+# it stay as it is? I think I may prefer to move it.
+uv = use_extension("//python/uv:uv.bzl", "uv")
+
+# Here is how we can define platforms for the `uv` binaries - this will affect
+# all of the downstream callers because we are using the extension without
+# `dev_dependency = True`.
+uv.default(
+    base_url = "https://github.com/astral-sh/uv/releases/download",
+    manifest_filename = "dist-manifest.json",
+    version = "0.6.3",
+)
+uv.default(
+    compatible_with = [
+        "@platforms//os:macos",
+        "@platforms//cpu:aarch64",
+    ],
+    platform = "aarch64-apple-darwin",
+)
+uv.default(
+    compatible_with = [
+        "@platforms//os:linux",
+        "@platforms//cpu:aarch64",
+    ],
+    platform = "aarch64-unknown-linux-gnu",
+)
+uv.default(
+    compatible_with = [
+        "@platforms//os:linux",
+        "@platforms//cpu:ppc",
+    ],
+    platform = "powerpc64-unknown-linux-gnu",
+)
+uv.default(
+    compatible_with = [
+        "@platforms//os:linux",
+        "@platforms//cpu:ppc64le",
+    ],
+    platform = "powerpc64le-unknown-linux-gnu",
+)
+uv.default(
+    compatible_with = [
+        "@platforms//os:linux",
+        "@platforms//cpu:s390x",
+    ],
+    platform = "s390x-unknown-linux-gnu",
+)
+uv.default(
+    compatible_with = [
+        "@platforms//os:macos",
+        "@platforms//cpu:x86_64",
+    ],
+    platform = "x86_64-apple-darwin",
+)
+uv.default(
+    compatible_with = [
+        "@platforms//os:windows",
+        "@platforms//cpu:x86_64",
+    ],
+    platform = "x86_64-pc-windows-msvc",
+)
+uv.default(
+    compatible_with = [
+        "@platforms//os:linux",
+        "@platforms//cpu:x86_64",
+    ],
+    platform = "x86_64-unknown-linux-gnu",
+)
+use_repo(uv, "uv")
+
+register_toolchains("@uv//:all")
+
+uv_dev = use_extension(
     "//python/uv:uv.bzl",
     "uv",
     dev_dependency = True,
 )
-uv.toolchain(uv_version = "0.4.25")
-use_repo(uv, "uv_toolchains")
-
-register_toolchains(
-    "@uv_toolchains//:all",
-    dev_dependency = True,
+uv_dev.configure(
+    version = "0.6.2",
 )

examples/bzlmod/MODULE.bazel

@@ -101,12 +101,15 @@ python.single_version_platform_override(
 # rules based on the `python_version` arg values.
 use_repo(python, "python_3_10", "python_3_9", "python_versions", "pythons_hub")
 
-# EXPERIMENTAL: This is experimental and may be removed without notice
-uv = use_extension("@rules_python//python/uv:uv.bzl", "uv")
-uv.toolchain(uv_version = "0.4.25")
-use_repo(uv, "uv_toolchains")
-
-register_toolchains("@uv_toolchains//:all")
+# EXPERIMENTAL: This is experimental and may be changed or removed without notice
+uv = use_extension(
+    "@rules_python//python/uv:uv.bzl",
+    "uv",
+    # Use `dev_dependency` so that the toolchains are not defined pulled when your
+    # module is used elsewhere.
+    dev_dependency = True,
+)
+uv.configure(version = "0.6.2")
 
 # This extension allows a user to create modifications to how rules_python
 # creates different wheel repositories.  Different attributes allow the user

python/uv/private/BUILD.bazel

@@ -47,20 +47,19 @@ bzl_library(
     name = "uv_bzl",
     srcs = ["uv.bzl"],
     visibility = ["//python/uv:__subpackages__"],
-    deps = [":uv_repositories_bzl"],
-)
-
-bzl_library(
-    name = "uv_repositories_bzl",
-    srcs = ["uv_repositories.bzl"],
-    visibility = ["//python/uv:__subpackages__"],
     deps = [
         ":toolchain_types_bzl",
+        ":uv_repository_bzl",
         ":uv_toolchains_repo_bzl",
-        ":versions_bzl",
     ],
 )
 
+bzl_library(
+    name = "uv_repository_bzl",
+    srcs = ["uv_repository.bzl"],
+    visibility = ["//python/uv:__subpackages__"],
+)
+
 bzl_library(
     name = "uv_toolchain_bzl",
     srcs = ["uv_toolchain.bzl"],
@@ -82,9 +81,3 @@ bzl_library(
         "//python/private:text_util_bzl",
     ],
 )
-
-bzl_library(
-    name = "versions_bzl",
-    srcs = ["versions.bzl"],
-    visibility = ["//python/uv:__subpackages__"],
-)

python/uv/private/lock.bzl

@@ -30,9 +30,11 @@ def lock(*, name, srcs, out, upgrade = False, universal = True, args = [], **kwa
     """Pin the requirements based on the src files.
 
     Differences with the current {obj}`compile_pip_requirements` rule:
-    - This is implemented in shell and uv.
+    - This is implemented in shell and `uv`.
     - This does not error out if the output file does not exist yet.
     - Supports transitions out of the box.
+    - The execution of the lock file generation is happening inside of a build
+      action in a `genrule`.
 
     Args:
         name: The name of the target to run for updating the requirements.
@@ -41,8 +43,8 @@ def lock(*, name, srcs, out, upgrade = False, universal = True, args = [], **kwa
         upgrade: Tell `uv` to always upgrade the dependencies instead of
             keeping them as they are.
         universal: Tell `uv` to generate a universal lock file.
-        args: Extra args to pass to `uv`.
-        **kwargs: Extra kwargs passed to the {obj}`py_binary` rule.
+        args: Extra args to pass to the rule.
+        **kwargs: Extra kwargs passed to the binary rule.
     """
     pkg = native.package_name()
     update_target = name + ".update"

python/uv/private/toolchains_hub.bzl

@@ -0,0 +1,65 @@
+# Copyright 2025 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.
+
+"""A macro used from the uv_toolchain hub repo."""
+
+load(":toolchain_types.bzl", "UV_TOOLCHAIN_TYPE")
+
+def toolchains_hub(
+        *,
+        name,
+        toolchains,
+        implementations,
+        target_compatible_with,
+        target_settings):
+    """Define the toolchains so that the lexicographical order registration is deterministic.
+
+    TODO @aignas 2025-03-09: see if this can be reused in the python toolchains.
+
+    Args:
+        name: The prefix to all of the targets, which goes after a numeric prefix.
+        toolchains: The toolchain names for the targets defined by this macro.
+            The earlier occurring items take precedence over the later items if
+            they match the target platform and target settings.
+        implementations: The name to label mapping.
+        target_compatible_with: The name to target_compatible_with list mapping.
+        target_settings: The name to target_settings list mapping.
+    """
+    if len(toolchains) != len(implementations):
+        fail("Each name must have an implementation")
+
+    # We are defining the toolchains so that the order of toolchain matching is
+    # the same as the order of the toolchains, because:
+    # * the toolchains are matched by target settings and target_compatible_with
+    # * the first toolchain satisfying the above wins
+    #
+    # this means we need to register the toolchains prefixed with a number of
+    # format 00xy, where x and y are some digits and the leading zeros to
+    # ensure lexicographical sorting.
+    #
+    # Add 1 so that there is always a leading zero
+    prefix_len = len(str(len(toolchains))) + 1
+    prefix = "0" * (prefix_len - 1)
+
+    for i, toolchain in enumerate(toolchains):
+        # prefix with a prefix and then truncate the string.
+        number_prefix = "{}{}".format(prefix, i)[-prefix_len:]
+
+        native.toolchain(
+            name = "{}_{}_{}".format(number_prefix, name, toolchain),
+            target_compatible_with = target_compatible_with.get(toolchain, []),
+            target_settings = target_settings.get(toolchain, []),
+            toolchain = implementations[toolchain],
+            toolchain_type = UV_TOOLCHAIN_TYPE,
+        )