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

.github/workflows/ci-workflows.yaml

@@ -45,6 +45,7 @@ jobs:
                 - { path: "e2e/interpreter-runtime-metadata", slug: "e2e-interpreter-runtime-metadata", runner: "ubuntu-latest" }
                 - { path: "e2e/interpreter-toolchain-settings", slug: "e2e-interpreter-toolchain-settings", runner: "ubuntu-latest" }
                 - { path: "e2e/interpreter-input-validation", slug: "e2e-interpreter-input-validation", runner: "ubuntu-latest" }
+                - { path: "e2e/rules-python-interop", slug: "e2e-rules-python-interop", runner: "ubuntu-latest" }
                 - { path: "e2e/rules-proto-grpc-python", slug: "e2e-rules-proto-grpc-python", runner: "ubuntu-22.04-32core" }
                 - { path: "examples/debugger", slug: "examples-debugger", runner: "ubuntu-latest" }
                 - { path: "examples/dev_deps", slug: "examples-dev_deps", runner: "ubuntu-latest" }

docs/interpreter.md

@@ -231,8 +231,17 @@ 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 `@rules_python//python:exec_tools_toolchain_type`, so
+  interpreters provisioned through either `interpreters.toolchain()` or
+  `rules_python`'s `python.toolchain()` satisfy them.
+
+Note that runtimes provisioned by `interpreters.toolchain()` carry rules_py's
+own runtime provider, not `rules_python`'s `PyRuntimeInfo` — `rules_python`'s
+rules cannot run on them.
 
 You can migrate incrementally: replace `python.toolchain()` calls with
 `interpreters.toolchain()` and remove the `rules_python` interpreter

e2e/cases/rules-python-consumers/BUILD.bazel

@@ -0,0 +1,37 @@
+load("@aspect_rules_py//py:defs.bzl", "py_test")
+load(":exec_tools_facts.bzl", "exec_tools_facts", "with_python_version")
+
+# rules_python reaches rules_py-provisioned interpreters only through
+# toolchain types, never through labels inside the generated repos — so the
+# repos' internal target names are private wiring. Pin that by running
+# rules_python's own consumer code against rules_py-backed toolchains.
+
+# rules_python's current_py_toolchain field-reads the resolved standard
+# toolchain payload to expand $(PYTHON3). Pinned to 3.13 via the wrapper
+# below (data edges reset Python flags), it resolves the rules_py-provisioned
+# interpreter.
+genrule(
+    name = "python3_var",
+    outs = ["python3_var.txt"],
+    cmd = "echo '$(PYTHON3)' > $@",
+    toolchains = ["@rules_python//python:current_py_toolchain"],
+)
+
+with_python_version(
+    name = "python3_var_313",
+    python_version = "3.13",
+    deps = [":python3_var"],
+)
+
+exec_tools_facts(
+    name = "exec_tools_facts",
+)
+
+py_test(
+    name = "consumers_test",
+    srcs = ["consumers_test.py"],
+    data = [
+        ":exec_tools_facts",
+        ":python3_var_313",
+    ],
+)

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

@@ -0,0 +1,31 @@
+"""Asserts rules_python's toolchain consumers work against rules_py-provisioned
+toolchains, which they reach only via toolchain types — never via labels inside
+the generated interpreter repos.
+"""
+
+import os
+
+
+def read(rel):
+    path = os.path.join(
+        os.environ["TEST_SRCDIR"],
+        os.environ["TEST_WORKSPACE"],
+        "rules-python-consumers",
+        rel,
+    )
+    with open(path) as f:
+        return f.read().strip()
+
+
+# rules_python's current_py_toolchain expanded $(PYTHON3) from the resolved
+# standard toolchain — backed by rules_py's provisioned 3.13 runtime.
+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).
+facts = read("exec_tools_facts.txt").splitlines()
+assert "python_interpreters+" in facts[0], facts
+assert facts[1] == "None", facts
+
+print("OK")

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

@@ -0,0 +1,61 @@
+"""Materialises the resolved exec-tools toolchain payload 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.
+"""
+
+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
+    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,
+    ))
+    return [DefaultInfo(files = depset([out]))]
+
+exec_tools_facts = rule(
+    implementation = _exec_tools_facts_impl,
+    toolchains = [EXEC_TOOLS_TOOLCHAIN],
+)
+
+def _set_python_version_impl(settings, attr):
+    # Both flags together so the uv constraints mismatch guard stays satisfied.
+    return {
+        "@aspect_rules_py//py/private/interpreter:python_version": attr.python_version,
+        "@rules_python//python/config_settings:python_version": attr.python_version,
+    }
+
+_set_python_version = transition(
+    implementation = _set_python_version_impl,
+    inputs = [],
+    outputs = [
+        "@aspect_rules_py//py/private/interpreter:python_version",
+        "@rules_python//python/config_settings:python_version",
+    ],
+)
+
+def _with_python_version_impl(ctx):
+    return [DefaultInfo(files = depset(transitive = [
+        dep[DefaultInfo].files
+        for dep in ctx.attr.deps
+    ]))]
+
+with_python_version = rule(
+    doc = """Forwards deps analyzed under an explicit Python version.
+
+py_* data edges reset the Python flags to the caller baseline (#1294), so a
+data file that must be produced under a specific version pins it here rather
+than inheriting the consuming terminal's transition.""",
+    implementation = _with_python_version_impl,
+    attrs = {
+        "deps": attr.label_list(mandatory = True),
+        "python_version": attr.string(mandatory = True),
+        "_allowlist_function_transition": attr.label(
+            default = "@bazel_tools//tools/allowlists/function_transition_allowlist",
+        ),
+    },
+    cfg = _set_python_version,
+)

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:

e2e/rules-python-interop/BUILD.bazel

@@ -0,0 +1,56 @@
+load("@aspect_rules_py//py:defs.bzl", "current_py_toolchain", rules_py_test = "py_test")
+load("@bazel_skylib//rules:diff_test.bzl", "diff_test")
+load("@rules_python//python:py_test.bzl", rules_python_test = "py_test")
+
+# The only interpreter in this module comes from rules_python (see
+# MODULE.bazel); each test asserts the resolved binary's repo path.
+
+# Default toolchain resolution: no python_version set.
+rules_py_test(
+    name = "rules_py_default_test",
+    srcs = ["shared_interpreter_test.py"],
+    main = "shared_interpreter_test.py",
+)
+
+# Versioned resolution: the python_version transition also sets the
+# rules_python version flag, selecting rules_python's 3.12 toolchain.
+rules_py_test(
+    name = "rules_py_versioned_test",
+    srcs = ["shared_interpreter_test.py"],
+    main = "shared_interpreter_test.py",
+    python_version = "3.12",
+)
+
+rules_python_test(
+    name = "rules_python_test",
+    srcs = ["shared_interpreter_test.py"],
+    main = "shared_interpreter_test.py",
+)
+
+# Build-time identity check: each ruleset's current_py_toolchain expands
+# $(PYTHON3) to its resolved toolchain's interpreter File.path; the diff
+# proves both toolchain resolutions yield the same artifact.
+
+current_py_toolchain(
+    name = "rules_py_current_toolchain",
+)
+
+genrule(
+    name = "rules_py_interpreter_path",
+    outs = ["rules_py_interpreter_path.txt"],
+    cmd = "echo '$(PYTHON3)' > $@",
+    toolchains = [":rules_py_current_toolchain"],
+)
+
+genrule(
+    name = "rules_python_interpreter_path",
+    outs = ["rules_python_interpreter_path.txt"],
+    cmd = "echo '$(PYTHON3)' > $@",
+    toolchains = ["@rules_python//python:current_py_toolchain"],
+)
+
+diff_test(
+    name = "same_interpreter_location_test",
+    file1 = ":rules_py_interpreter_path",
+    file2 = ":rules_python_interpreter_path",
+)

e2e/rules-python-interop/MODULE.bazel

@@ -0,0 +1,20 @@
+"""Interop: rules_py rules share the interpreter provisioned by rules_python.
+
+This module deliberately provisions its only interpreter through rules_python's
+`python.toolchain()` — no `python_interpreters` — so rules_py and rules_python
+targets must both resolve, and run on, that single runtime.
+"""
+
+module(name = "rules_python_interop")
+
+bazel_dep(name = "aspect_rules_py")
+bazel_dep(name = "bazel_skylib", version = "1.4.2")
+bazel_dep(name = "rules_python", version = "1.9.0")
+
+local_path_override(
+    module_name = "aspect_rules_py",
+    path = "../..",
+)
+
+python = use_extension("@rules_python//python/extensions:python.bzl", "python")
+python.toolchain(python_version = "3.12")