wip

Author: aignas

python/private/python.bzl

@@ -248,8 +248,10 @@ def parse_modules(*, module_ctx, _fail = fail):
     # "3.X"` transitions work as expected.
     minor_version_toolchains = []
     other_toolchains = []
+    minor_mapping = config.minor_mapping
     for t in toolchains:
-        if t.python_version in config.minor_mapping:
+        # TODO @aignas 2025-04-04: I am getting lost here when unit testing
+        if t.python_version == minor_mapping.get(t.python_version):
             minor_version_toolchains.append(t)
         else:
             other_toolchains.append(t)
@@ -258,7 +260,7 @@ def parse_modules(*, module_ctx, _fail = fail):
     return struct(
         config = config,
         debug_info = debug_info,
-        default_python_version = toolchains[-1].python_version,
+        default_python_version = default_toolchain.python_version,
         toolchains = [
             struct(
                 python_version = t.python_version,

python/uv/private/lock.bzl

@@ -106,6 +106,7 @@ def _lock_impl(ctx):
 
     exec_tools = ctx.toolchains[EXEC_TOOLS_TOOLCHAIN_TYPE].exec_tools
     runtime = exec_tools.exec_interpreter[platform_common.ToolchainInfo].py3_runtime
+    fail(runtime.interpreter_version_info)
     python = runtime.interpreter or runtime.interpreter_path
     python_files = runtime.files
     args.add("--python", python)

tests/config_settings/transition/multi_version_tests.bzl

@@ -13,6 +13,7 @@
 # limitations under the License.
 """Tests for py_test."""
 
+load("@pythons_hub//:versions.bzl", "DEFAULT_PYTHON_VERSION")
 load("@rules_testing//lib:analysis_test.bzl", "analysis_test")
 load("@rules_testing//lib:test_suite.bzl", "test_suite")
 load("@rules_testing//lib:util.bzl", "TestingAspectInfo", rt_util = "util")
@@ -29,7 +30,7 @@ load("//tests/support:support.bzl", "CC_TOOLCHAIN")
 # If the toolchain is not resolved then you will have a weird message telling
 # you that your transition target does not have a PyRuntime provider, which is
 # caused by there not being a toolchain detected for the target.
-_PYTHON_VERSION = "3.11"
+_PYTHON_VERSION = DEFAULT_PYTHON_VERSION
 
 _tests = []
 

tests/python/python_tests.bzl

@@ -284,6 +284,54 @@ def _test_default_non_rules_python_ignore_root_user_error_non_root_module(env):
 
 _tests.append(_test_default_non_rules_python_ignore_root_user_error_non_root_module)
 
+def _test_toolchain_ordering(env):
+    py = parse_modules(
+        module_ctx = _mock_mctx(
+            _mod(
+              name = "my_module", 
+              toolchain = [
+                _toolchain("3.10"),
+                _toolchain("3.10.15"),
+                _toolchain("3.10.16"),
+                _toolchain("3.10.11"),
+                _toolchain("3.11.1"),
+                _toolchain("3.11.10"),
+                _toolchain("3.11.11", is_default = True),
+              ],
+            ),
+            _mod(name = "rules_python", toolchain = [_toolchain("3.11")]),
+        ),
+    )
+    got_versions = [
+        t.python_version
+        for t in py.toolchains
+    ]
+
+    env.expect.that_str(py.default_python_version).equals("3.11")
+    env.expect.that_dict(py.config.minor_mapping).contains_exactly({
+      "3.10": "3.10.16",
+      "3.11": "3.11.11",
+      "3.12": "3.12.9",
+      "3.13": "3.13.2",
+      "3.8": "3.8.20",
+      "3.9": "3.9.21",
+    })
+    env.expect.that_collection(got_versions).contains_exactly([
+      # First the full-version toolchains that are in minor_mapping
+      # so that they get matched first if only the `python_version` is in MINOR_MAPPING
+      "3.10.16",
+      # Next, the rest, where we will match things based on the `python_version` being
+      # the same
+      "3.10",
+      "3.10.15",
+      "3.10.11",
+      "3.11.1",
+      "3.11.10",
+      "3.11.11",
+    ]).in_order()
+
+_tests.append(_test_toolchain_ordering)
+
 def _test_default_from_defaults(env):
     py = parse_modules(
         module_ctx = _mock_mctx(

tests/toolchains/defs.bzl

@@ -14,7 +14,9 @@
 
 ""
 
+load("@pythons_hub//:versions.bzl", "MINOR_MAPPING", "DEFAULT_PYTHON_VERSION")
 load("//python:versions.bzl", "PLATFORMS", "TOOL_VERSIONS")
+load("//python/private:full_version.bzl", "full_version")
 load("//tests/support:sh_py_run_test.bzl", "py_reconfig_test")
 
 def define_toolchain_tests(name):
@@ -30,7 +32,41 @@ def define_toolchain_tests(name):
             constraint_values = platform_info.compatible_with,
         )
 
-    for python_version, meta in TOOL_VERSIONS.items():
+    # First we expect the transitions with a specific version to always
+    # give us that specific version
+    exact_version_tests = {
+        (v, v): "python_{}_test".format(v)
+        for v in TOOL_VERSIONS
+    }
+    native.test_suite(
+        name = "exact_version_tests",
+        tests = exact_version_tests.values(),
+    )
+
+    # Then we expect to get the version in the MINOR_MAPPING if we provide
+    # the version from the MINOR_MAPPING
+    minor_mapping_tests = {
+        (minor, full): "python_{}_test".format(minor)
+        for minor, full in MINOR_MAPPING.items()
+    }
+    native.test_suite(
+        name = "minor_mapping_tests",
+        tests = minor_mapping_tests.values(),
+    )
+
+    # Lastly, if we don't provide any version to the transition, we should
+    # get the default version
+    default_version = full_version(
+        version = DEFAULT_PYTHON_VERSION,
+        minor_mapping = MINOR_MAPPING,
+    )
+    default_version_tests = {
+        (None, default_version): "default_version_test"
+    }
+    tests = exact_version_tests | minor_mapping_tests | default_version_tests
+
+    for (input_python_version, expect_python_version), test_name in tests.items():
+        meta = TOOL_VERSIONS[expect_python_version]
         target_compatible_with = {
             "//conditions:default": ["@platforms//:incompatible"],
         }
@@ -39,12 +75,12 @@ def define_toolchain_tests(name):
             target_compatible_with[is_platform] = []
 
         py_reconfig_test(
-            name = "python_{}_test".format(python_version),
+            name = test_name,
             srcs = ["python_toolchain_test.py"],
             main = "python_toolchain_test.py",
-            python_version = python_version,
+            python_version = input_python_version,
             env = {
-                "EXPECT_PYTHON_VERSION": python_version,
+                "EXPECT_PYTHON_VERSION": expect_python_version,
             },
             deps = ["//python/runfiles"],
             data = ["//tests/support:current_build_settings"],