trying to fix local toolchains

Author: rickeylev

python/private/local_runtime_repo.bzl

@@ -84,9 +84,18 @@ def _local_runtime_repo_impl(rctx):
     info = json.decode(exec_result.stdout)
     logger.info(lambda: _format_get_info_result(info))
 
-    # The base executable is the final, actual, underlying interpreter.
-    # If an intermediate wrapper is used, then it can cause venvs to not
-    # be recognized as active.
+    # We use base_executable because we want the path within a Python
+    # installation directory ("PYTHONHOME"). The problems with sys.executable
+    # are:
+    # * If we're in an activated venv, then we don't want the venv's
+    #   `bin/python3` path to be used -- it isn't an actual Python installation.
+    # * If sys.executable is a wrapper (e.g. pyenv), then (1) it may not be
+    #   located within an actual Python installation directory, and (2) it
+    #   can interfer with Python recognizing when it's within a venv.
+    #
+    # In some cases, it may be a symlink (usually e.g. `python3->python3.12`),
+    # but we don't realpath() it to respect what it has decided is the
+    # appropriate path.
     interpreter_path = info["base_executable"]
 
     # NOTE: Keep in sync with recursive glob in define_local_runtime_toolchain_impl

tests/integration/local_toolchains/test.py

@@ -2,26 +2,59 @@
 import subprocess
 import sys
 import unittest
-
+import tempfile
+import os.path
 
 class LocalToolchainTest(unittest.TestCase):
     maxDiff = None
 
     def test_python_from_path_used(self):
+        # NOTE: This is a bit brittle. It assumes the environment during the
+        # repo-phase and when the test is run are roughly the same. It's
+        # easy to violate this condition if there are shell-local changes
+        # that wouldn't be reflected when sub-shells are run later.
         shell_path = shutil.which("python3")
 
         # We call the interpreter and print its executable because of
         # things like pyenv: they install a shim that re-execs python.
         # The shim is e.g. /home/user/.pyenv/shims/python3, which then
         # runs e.g. /usr/bin/python3
-        expected = subprocess.check_output(
-            [shell_path, "-c", "import os, sys; print(sys._base_executable)"],
-            text=True,
-        )
-        expected = expected.strip().lower()
+        with tempfile.NamedTemporaryFile(suffix="_info.py", mode="w+") as f:
+            f.write("""
+import sys
+print(sys.executable)
+print(sys._base_executable)
+"""
+                    )
+            f.flush()
+            output_lines = subprocess.check_output(
+                [shell_path, f.name],
+                text=True,
+            ).strip().splitlines()
+        shell_exe, shell_base_exe = output_lines
+
+        # Call realpath() to help normalize away differences from symlinks.
+        # Use base executable to ignore a venv the test may be running within.
+        expected = os.path.realpath(shell_base_exe.strip().lower())
+        actual = os.path.realpath(sys._base_executable.lower())
+
+        msg = f"""
+details of executables:
+test's runtime:
+{sys.executable=}
+{sys._base_executable=}
+realpath exe     : {os.path.realpath(sys.executable)}
+realpath base_exe: {os.path.realpath(sys._base_executable)}
+
+from shell resolution:
+{shell_exe=}
+{shell_base_exe=}
+realpath exe     : {os.path.realpath(shell_exe)}
+realpath base_exe: {os.path.realpath(shell_base_exe)}
+""".strip()
 
         # Normalize case: Windows may have case differences
-        self.assertEqual(expected.lower(), sys._base_executable.lower())
+        self.assertEqual(expected.lower(), actual.lower(), msg=msg)
 
 
 if __name__ == "__main__":