refactor: own the interpreter runtime toolchain rules instead of rules_python's

Generated interpreter repos now instantiate a rules_py py_runtime_toolchain
(py/private/interpreter/runtime.bzl, with a rules_py PyRuntimeInfo) instead of
rules_python's py_runtime + py_runtime_pair + py_exec_tools_toolchain. One
:runtime target per repo backs both toolchain registrations. Toolchain types
are unchanged (@bazel_tools python type; rules_python's exec_tools type, with
its exec_tools.exec_runtime/precompiler payload shape preserved), so
rules_python-provisioned interpreters still satisfy whl_install/site-merge and
rules_py still consumes user-registered rules_python py_runtime toolchains.

This shrinks each interpreter repo's rules_python loads from 31 .bzl files to
the 12 of the deliberately kept py_cc_toolchain chain, insulating provisioned
toolchains from rules_python implementation churn, and leaves the runtime
layer pinning no rules_python minimum version.

New coverage: e2e/rules-python-interop (isolated module) pins that a module
mixing both rulesets shares one rules_python-provisioned interpreter,
including a $(PYTHON3) location diff_test; e2e/cases/rules-python-consumers
pins that rules_python's own toolchain consumers (current_py_toolchain,
exec-tools readers) work against rules_py-backed toolchains.

Narrow breaks:
- Generated interpreter repo targets are renamed: @python_X//:py3_runtime,
  :runtime_pair, and :exec_tools_toolchain are now a single @python_X//:runtime.
  Only direct label references need updating; toolchain resolution is unaffected.
- rules_py-provisioned runtimes carry rules_py's PyRuntimeInfo, not
  rules_python's. Provider-indexed access (target[PyRuntimeInfo] with
  rules_python's symbol) on these targets or resolved toolchains breaks;
  duck-typed field access keeps working. As a consequence, rules_python's
  py_binary/py_test cannot execute on rules_py-provisioned toolchains (they
  read provider fields rules_py does not carry) — the same one-way interop
  direction #1231 establishes for PyInfo.
- The exec-tools toolchain rules_py registers provides precompiler = None;
  enabling rules_python precompiling while @python_interpreters toolchains are
  registered first is unsupported.

Author: jbedard

docs/interpreter.md

@@ -273,8 +273,23 @@ This interpreter provisioning is designed to coexist with `rules_python`:
   registration, so these interpreters work with all existing Python rules.
 - The `@rules_python//python/config_settings:python_version` flag is kept in
   sync with our own version flag via build transitions.
-- `py_runtime` and `py_runtime_pair` from `rules_python` are used to create
-  the runtime providers.
+- Runtimes registered with `rules_python`'s `py_runtime` / `py_runtime_pair`
+  (for example a system interpreter) remain usable by rules_py rules, which
+  read the runtime fields structurally.
+- Build actions that run an interpreter (wheel installation, site-packages
+  merging) resolve `@aspect_rules_py//py/private/toolchain:exec_tools_toolchain_type`,
+  which `interpreters.toolchain()` registers. Interpreters provisioned solely
+  through `rules_python`'s `python.toolchain()` do not satisfy it; register a
+  toolchain providing `ToolchainInfo(exec_runtime = <runtime>)` under that
+  type to bridge one. rules_py registers nothing under `rules_python`'s
+  exec-tools type, leaving it — including precompiling — entirely to
+  `rules_python`.
+
+Note that runtimes provisioned by `interpreters.toolchain()` carry rules_py's
+own `PyRuntimeInfo` (exported from `@aspect_rules_py//py:defs.bzl`), not
+`rules_python`'s provider. `rules_python`-defined executables analyze and run
+on them, but no coverage tool is bundled, and Starlark indexing the runtime
+with `rules_python`'s provider symbol must switch to rules_py's.
 
 You can migrate incrementally: replace `python.toolchain()` calls with
 `interpreters.toolchain()` and remove the `rules_python` interpreter

e2e/cases/rules-python-consumers/consumers_test.py

@@ -22,11 +22,13 @@ def read(rel):
 python3 = read("python3_var.txt")
 assert "python_interpreters+python_3_13" in python3, python3
 
-# The exec-tools payload carries rules_python's expected shape: an exec
-# runtime from a rules_py-provisioned repo, and a precompiler field (None).
+# rules_py's exec-tools type serves a rules_py-provisioned runtime. rules_py
+# registers nothing under rules_python's own exec-tools type, but it must
+# still resolve — rules_python's toolchain wraps the ambient standard-type
+# runtime through its own exec-interpreter indirection.
 facts = read("exec_tools_facts.txt").splitlines()
 assert "python_interpreters+" in facts[0], facts
-assert facts[1] == "None", facts
+assert facts[1] != "None", facts
 
 assert read("python_launcher.txt") == "3.11"
 

e2e/cases/rules-python-consumers/exec_tools_facts.bzl

@@ -1,24 +1,32 @@
-"""Materialises the resolved exec-tools toolchain payload for assertion.
+"""Materialises the resolved exec-tools toolchain payloads for assertion.
 
-Reads the fields rules_python's consumers access — `exec_tools.exec_runtime`
-and `exec_tools.precompiler` — so the test pins that rules_py's registration
-under rules_python's toolchain type keeps their expected shape.
+Line 1: the rules_py exec-tools type's runtime — must be a rules_py-provisioned
+interpreter. Line 2: rules_python's own exec-tools type — rules_py registers
+nothing there, but it must still resolve: rules_python's toolchain wraps
+whatever the standard Python toolchain provides (here, a rules_py runtime,
+reached through their own exec-interpreter indirection).
 """
 
-EXEC_TOOLS_TOOLCHAIN = "@rules_python//python:exec_tools_toolchain_type"
+EXEC_TOOLS_TOOLCHAIN = "@aspect_rules_py//py/private/toolchain:exec_tools_toolchain_type"
+RPY_EXEC_TOOLS_TOOLCHAIN = "@rules_python//python:exec_tools_toolchain_type"
 
 def _exec_tools_facts_impl(ctx):
-    exec_tools = ctx.toolchains[EXEC_TOOLS_TOOLCHAIN].exec_tools
+    exec_runtime = ctx.toolchains[EXEC_TOOLS_TOOLCHAIN].exec_runtime
+    rpy_info = ctx.toolchains[RPY_EXEC_TOOLS_TOOLCHAIN]
+    rpy_runtime = rpy_info.exec_tools.exec_runtime if rpy_info else None
     out = ctx.actions.declare_file(ctx.label.name + ".txt")
     ctx.actions.write(out, "{}\n{}\n".format(
-        exec_tools.exec_runtime.interpreter.path,
-        exec_tools.precompiler,
+        exec_runtime.interpreter.path,
+        rpy_runtime.interpreter.path if rpy_runtime else None,
     ))
     return [DefaultInfo(files = depset([out]))]
 
 exec_tools_facts = rule(
     implementation = _exec_tools_facts_impl,
-    toolchains = [EXEC_TOOLS_TOOLCHAIN],
+    toolchains = [
+        EXEC_TOOLS_TOOLCHAIN,
+        config_common.toolchain_type(RPY_EXEC_TOOLS_TOOLCHAIN, mandatory = False),
+    ],
 )
 
 def _set_python_version_impl(settings, attr):

e2e/cases/rules-python-consumers/report_exec_version.bzl

@@ -1,14 +1,14 @@
 """Runnable that prints the resolved exec-tools runtime version.
 
-Resolves rules_python's exec-tools toolchain directly (no py_* version
+Resolves rules_py's exec-tools toolchain directly (no py_* version
 transition), so the reported version reflects the version flag only if the flag
 is authoritative in the interpreter hub. `bazel run` it and assert on stdout.
 """
 
-_EXEC_TOOLS_TOOLCHAIN = "@rules_python//python:exec_tools_toolchain_type"
+_EXEC_TOOLS_TOOLCHAIN = "@aspect_rules_py//py/private/toolchain:exec_tools_toolchain_type"
 
 def _report_exec_version_impl(ctx):
-    version_info = ctx.toolchains[_EXEC_TOOLS_TOOLCHAIN].exec_tools.exec_runtime.interpreter_version_info
+    version_info = ctx.toolchains[_EXEC_TOOLS_TOOLCHAIN].exec_runtime.interpreter_version_info
     launcher = ctx.actions.declare_file(ctx.label.name + ".sh")
     ctx.actions.write(
         output = launcher,

e2e/cases/rules-python-consumers/test.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 #
-# report_exec_version resolves rules_python's exec-tools toolchain without the
+# report_exec_version resolves rules_py's exec-tools toolchain without the
 # py_* version transition, so it prints the requested version only if the
 # version flag is authoritative in the interpreter hub. Both the native flag
 # and @rules_python's fallback must select the requested version.

e2e/cases/uv-deps-650/crossbuild/toolchain_test.bzl

@@ -5,10 +5,10 @@ path into a file, so sh_test scripts can verify which interpreter was selected
 under cross-compilation (target platform ≠ exec platform).
 """
 
-EXEC_TOOLS_TOOLCHAIN = "@rules_python//python:exec_tools_toolchain_type"
+EXEC_TOOLS_TOOLCHAIN = "@aspect_rules_py//py/private/toolchain:exec_tools_toolchain_type"
 
 def _exec_python_path_impl(ctx):
-    exec_runtime = ctx.toolchains[EXEC_TOOLS_TOOLCHAIN].exec_tools.exec_runtime
+    exec_runtime = ctx.toolchains[EXEC_TOOLS_TOOLCHAIN].exec_runtime
     out = ctx.actions.declare_file(ctx.label.name + ".txt")
     ctx.actions.write(out, exec_runtime.interpreter.path)
     return [DefaultInfo(files = depset([out]))]

e2e/interpreter-runtime-metadata/BUILD.bazel

@@ -3,11 +3,11 @@ load(":runtime_metadata_test.bzl", "runtime_metadata_test")
 runtime_metadata_test(
     name = "regular",
     abi_flags = "",
-    runtime = "@python_3_15_x86_64_unknown_linux_gnu//:py3_runtime",
+    runtime = "@python_3_15_x86_64_unknown_linux_gnu//:runtime",
 )
 
 runtime_metadata_test(
     name = "freethreaded",
     abi_flags = "t",
-    runtime = "@python_3_15_x86_64_unknown_linux_gnu_freethreaded//:py3_runtime",
+    runtime = "@python_3_15_x86_64_unknown_linux_gnu_freethreaded//:runtime",
 )

e2e/interpreter-runtime-metadata/runtime_metadata_test.bzl

@@ -1,6 +1,6 @@
 """Checks metadata on a provisioned PBS Python runtime."""
 
-load("@rules_python//python:py_runtime_info.bzl", "PyRuntimeInfo")
+load("@aspect_rules_py//py:defs.bzl", "PyRuntimeInfo")
 
 def _assert_equal(description, expected, actual):
     if actual != expected:

examples/debugger/.bazelrc

@@ -1,3 +1,6 @@
+# Default Python version for targets without an explicit python_version.
+common --@aspect_rules_py//py:python_version=3.11
+
 # Default to debug venv — includes debugpy
 common --@pypi//dep_group=debug
 

examples/debugger/MODULE.bazel

@@ -3,7 +3,6 @@
 bazel_dep(name = "aspect_rules_py")
 bazel_dep(name = "bazel_skylib", version = "1.4.2")
 bazel_dep(name = "rules_cc", version = "0.2.16")
-bazel_dep(name = "rules_python", version = "1.9.0")
 bazel_dep(name = "platforms", version = "1.0.0")
 bazel_dep(name = "llvm", version = "0.7.1")
 
@@ -12,11 +11,11 @@ local_path_override(
     path = "../..",
 )
 
-python = use_extension("@rules_python//python/extensions:python.bzl", "python")
-python.toolchain(
-    is_default = True,
-    python_version = "3.11",
-)
+interpreters = use_extension("@aspect_rules_py//py:extensions.bzl", "python_interpreters")
+interpreters.toolchain(python_version = "3.11")
+use_repo(interpreters, "python_interpreters")
+
+register_toolchains("@python_interpreters//:all")
 
 uv = use_extension("@aspect_rules_py//uv:extensions.bzl", "uv")
 uv.declare_hub(hub_name = "pypi")