seemed to have found a reasonable workaround

Author: rickeylev

python/private/py_executable.bzl

@@ -539,11 +539,14 @@ def _create_venv(ctx, output_prefix, imports, runtime_details):
     ctx.actions.write(pyvenv_cfg, "")
 
     runtime = runtime_details.effective_runtime
+
     venvs_use_declare_symlink_enabled = (
         VenvsUseDeclareSymlinkFlag.get_value(ctx) == VenvsUseDeclareSymlinkFlag.YES
     )
+    recreate_venv_at_runtime = False
 
-    if not venvs_use_declare_symlink_enabled:
+    if not venvs_use_declare_symlink_enabled or not runtime.supports_build_time_venv:
+        recreate_venv_at_runtime = True
         if runtime.interpreter:
             interpreter_actual_path = runfiles_root_path(ctx, runtime.interpreter.short_path)
         else:
@@ -618,13 +621,17 @@ def _create_venv(ctx, output_prefix, imports, runtime_details):
     )
     site_packages_symlinks = _create_site_packages_symlinks(ctx, site_packages)
 
+    ##ctx.actions.write(site_customize,
+    ##                  "import site\nsite.addsitedir('{}')\n".format(
+
     return struct(
         interpreter = interpreter,
-        recreate_venv_at_runtime = not venvs_use_declare_symlink_enabled,
+        recreate_venv_at_runtime = recreate_venv_at_runtime,
         # Runfiles root relative path or absolute path
         interpreter_actual_path = interpreter_actual_path,
         files_without_interpreter = [pyvenv_cfg, pth, site_init] + site_packages_symlinks,
         venv_site_packages = venv_site_packages,
+        ##runtime_symlinks = runtime_symlinks,
     )
 
 def _create_site_packages_symlinks(ctx, site_packages):
@@ -784,6 +791,8 @@ def _create_stage1_bootstrap(
         "%recreate_venv_at_runtime%": str(int(venv.recreate_venv_at_runtime)) if venv else "0",
         "%target%": str(ctx.label),
         "%workspace_name%": ctx.workspace_name,
+        "%venv_rel_site_packages%": venv.venv_site_packages if venv else "",
+        "%resolve_python_binary_at_runtime%": "0" if runtime.supports_build_time_venv else "1",
     }
 
     if stage2_bootstrap:

python/private/py_runtime_info.bzl

@@ -67,7 +67,8 @@ def _PyRuntimeInfo_init(
         stage2_bootstrap_template = None,
         zip_main_template = None,
         abi_flags = "",
-        site_init_template = None):
+        site_init_template = None,
+        supports_build_time_venv = True):
     if (interpreter_path and interpreter) or (not interpreter_path and not interpreter):
         fail("exactly one of interpreter or interpreter_path must be specified")
 
@@ -117,6 +118,7 @@ def _PyRuntimeInfo_init(
         "pyc_tag": pyc_tag,
         "python_version": python_version,
         "site_init_template": site_init_template,
+        "supports_build_time_venv": supports_build_time_venv,
         "stage2_bootstrap_template": stage2_bootstrap_template,
         "stub_shebang": stub_shebang,
         "zip_main_template": zip_main_template,
@@ -333,6 +335,26 @@ The following substitutions are made during template expansion:
 
 :::{versionadded} 0.33.0
 :::
+""",
+        "supports_build_time_venv": """
+:type: bool
+
+True if this toolchain supports creating a virtual env at runtime. False if not
+or unknown. If build-time venv creation isn't supported, then binaries may
+fallback to non-venv solutions or creating a venv at runtime.
+
+In order to have a functionalal virtualenv created at build time, two criteria
+must be met:
+1. Specifying that the invoked interpreter (`$venv/bin/python3`, as reported by
+   `sys.executable`) isn't the real interpreter (e.g. `/usr/bin/python3`). This
+   typically requires relative symlinks or support for the `PYTHONEXECUTABLE`
+   environment variable.
+2. Creating a site-packages directory (`sys.prefix`) that the runtime
+   interpreter will recognize (e.g. `$venv/lib/python{version}/site-packages`).
+   This typically requires knowing the Python version at build time.
+
+:::{versionadded} VERSION_NEXT_FEATURE
+:::
 """,
     },
 )

python/private/py_runtime_rule.bzl

@@ -130,6 +130,7 @@ def _py_runtime_impl(ctx):
         zip_main_template = ctx.file.zip_main_template,
         abi_flags = abi_flags,
         site_init_template = ctx.file.site_init_template,
+        supports_build_time_venv = ctx.attr.supports_build_time_venv,
     ))
 
     if not IS_BAZEL_7_OR_HIGHER:
@@ -307,6 +308,17 @@ from `implementation_name` and `interpreter_version_info`. If no pyc_tag is
 available, then only source-less pyc generation will function correctly.
 """,
             ),
+            "supports_build_time_venv": attr.bool(
+                doc = """
+Whether this runtime supports virtualenvs created at build time.
+
+See {obj}`PyRuntimeInfo.supports_build_time_venv` for docs.
+
+:::{versionadded} VERSION_NEXT_FEATURE
+:::
+""",
+                default = True,
+            ),
             "python_version": attr.string(
                 default = "PY3",
                 values = ["PY2", "PY3"],

python/private/runtime_env_toolchain.bzl

@@ -45,6 +45,7 @@ def define_runtime_env_toolchain(name):
         stub_shebang = "#!/usr/bin/env python3",
         visibility = ["//visibility:private"],
         tags = ["manual"],
+        supports_build_time_venv = False,
     )
 
     # This is a dummy runtime whose interpreter_path triggers the native rule
@@ -56,6 +57,7 @@ def define_runtime_env_toolchain(name):
         python_version = "PY3",
         visibility = ["//visibility:private"],
         tags = ["manual"],
+        supports_build_time_venv = False,
     )
 
     py_runtime_pair(

python/private/runtime_env_toolchain_interpreter.sh

@@ -67,10 +67,8 @@ if [[ -e "$self_dir/pyvenv.cfg" || -e "$self_dir/../pyvenv.cfg" ]]; then
 
   # PYTHONEXECUTABLE is also used because `exec -a` doesn't fully trick the
   # pyenv wrappers.
-  # NOTE: The PYTHONEXECUTABLE envvar docs say it's only for Mac, however,
-  # emperically it also works on e.g. Linux
+  # NOTE: The PYTHONEXECUTABLE only works for non-Mac starting in Python 3.11
   export PYTHONEXECUTABLE="$venv_bin"
-  # Python uses to det
   # Use exec -a so that Python looks at the venv's binary, not the
   # actual one invoked.
   exec -a "$venv_bin" "$PYTHON_BIN" "$@"

python/private/stage1_bootstrap_template.sh

@@ -5,11 +5,13 @@ set -e
 if [[ -n "${RULES_PYTHON_BOOTSTRAP_VERBOSE:-}" ]]; then
   set -x
 fi
+  set -x
 
 # runfiles-relative path
 STAGE2_BOOTSTRAP="%stage2_bootstrap%"
 
-# runfiles-relative path to python interpreter to use
+# runfiles-relative path to python interpreter to use.
+# This is the `bin/python3` file in the binary's venv.
 PYTHON_BINARY='%python_binary%'
 # The path that PYTHON_BINARY should symlink to.
 # runfiles-relative path, absolute path, or single word.
@@ -18,8 +20,17 @@ PYTHON_BINARY_ACTUAL="%python_binary_actual%"
 
 # 0 or 1
 IS_ZIPFILE="%is_zipfile%"
-# 0 or 1
+# 0 or 1.
+# If 1, then a venv will be created at runtime that replicates what would have
+# been the build-time structure.
 RECREATE_VENV_AT_RUNTIME="%recreate_venv_at_runtime%"
+# 0 or 1
+# If 1, then the path to python will be resolved by running
+# PYTHON_BINARY_ACTUAL to determine the actual underlying interpreter.
+RESOLVE_PYTHON_BINARY_AT_RUNTIME="%resolve_python_binary_at_runtime%"
+# venv-relative path to the site-packages
+# e.g. lib/python3.12t/site-packages
+VENV_REL_SITE_PACKAGES="%venv_rel_site_packages%"
 
 # array of strings
 declare -a INTERPRETER_ARGS_FROM_TARGET=(
@@ -136,6 +147,7 @@ if [[ "$IS_ZIPFILE" == "1" ]]; then
   mkdir -p "$(dirname $python_exe)"
   ln -s "$symlink_to" "$python_exe"
 elif [[ "$RECREATE_VENV_AT_RUNTIME" == "1" ]]; then
+
   if [[ -n "$RULES_PYTHON_EXTRACT_ROOT" ]]; then
     use_exec=1
     # Use our runfiles path as a unique, reusable, location for the
@@ -167,19 +179,50 @@ elif [[ "$RECREATE_VENV_AT_RUNTIME" == "1" ]]; then
       exit 1
     fi
   fi
-  mkdir -p "$venv/bin"
+
+  runfiles_venv="$RUNFILES_DIR/$(dirname $(dirname $PYTHON_BINARY))"
+
+  # If the interpreter is a wrapper script that invokes Python, and
+  # is prior to Python 3.11 (PYTHONEXECUTABLE environment variable), then
+  # we can only trigger venv behavior by symlinking to the actual underlying
+  # interpreter.
+  # Additionally, if the build-time lib/pythonX.Y/site-packages path doesn't
+  # match what the runtime interpreter is looking for (i.e. version mismatch
+  # between build vs runtime), then pretend the version mismatch is OK :D,
+  # and create the desired path in the temporary venv.
+  if [[ "$RESOLVE_PYTHON_BINARY_AT_RUNTIME" == "1" ]]; then
+    {
+      read -r resolved_py_exe
+      read -r resolved_site_packages
+    } < <("$symlink_to" -I <<EOF
+import sys, site, os
+print(sys.executable)
+print(site.getsitepackages(["$venv"])[-1])
+EOF
+)
+    symlink_to="$resolved_py_exe"
+    runfiles_venv_site_packages=$runfiles_venv/$VENV_REL_SITE_PACKAGES
+    venv_site_packages="$resolved_site_packages"
+  else
+    # For simplicity, just symlink to the whole lib directory.
+    runfiles_venv_site_packages=$runfiles_venv/lib
+    venv_site_packages=$venv/lib
+  fi
+
   # Match the basename; some tools, e.g. pyvenv key off the executable name
   python_exe="$venv/bin/$(basename $PYTHON_BINARY_ACTUAL)"
   if [[ ! -e "$python_exe" ]]; then
+    mkdir -p "$venv/bin"
     ln -s "$symlink_to" "$python_exe"
   fi
-  runfiles_venv="$RUNFILES_DIR/$(dirname $(dirname $PYTHON_BINARY))"
   if [[ ! -e "$venv/pyvenv.cfg" ]]; then
     ln -s "$runfiles_venv/pyvenv.cfg" "$venv/pyvenv.cfg"
   fi
-  if [[ ! -e "$venv/lib" ]]; then
-    ln -s "$runfiles_venv/lib" "$venv/lib"
+  if [[ ! -e "$venv_site_packages" ]]; then
+    mkdir -p $(dirname $venv_site_packages)
+    ln -s "$runfiles_venv_site_packages" "$venv_site_packages"
   fi
+
 else
   use_exec=1
 fi

python/private/stage2_bootstrap_template.py

@@ -370,7 +370,7 @@ def main():
     print_verbose("initial sys.path:", values=sys.path)
 
     site_packages = os.path.join(sys.prefix, VENV_SITE_PACKAGES)
-    if site_packages not in sys.path:
+    if site_packages not in sys.path and os.path.exists(site_packages):
         # NOTE: if this happens, it likely means we're running with a different
         # Python version than was built with. Things may or may not work.
         # Such a situation is likely due to the runtime_env toolchain, or some

tests/runtime_env_toolchain/toolchain_runs_test.py

@@ -3,16 +3,34 @@
 import platform
 import unittest
 
-from python.runfiles import runfiles
-
 
 class RunTest(unittest.TestCase):
     def test_ran(self):
+        import os
+        ##os.system("which python3")
+        ##for x, y in sorted(os.environ.items()):
+        ##    print(f"{x}={y}")
+        import sys
+        print(f"{sys.executable=}")
+        print(f"{sys.prefix=}")
+        print(f"{sys.base_prefix=}")
+        for i, x in enumerate(sys.path):
+            print(i, x)
+
+        breakpoint()
+
+        ##todo trying to get bazel to use py 3.9
+        ## Use pyenv global to change the version used when shell isn't
+        ## inherited
+        ##print(sys.base_executable)
+        print(sys.version)
+        from python.runfiles import runfiles
         rf = runfiles.Create()
         settings_path = rf.Rlocation(
             "rules_python/tests/support/current_build_settings.json"
         )
         settings = json.loads(pathlib.Path(settings_path).read_text())
+        print(settings)
         if platform.system() == "Windows":
             self.assertEqual(
                 "/_magic_pyruntime_sentinel_do_not_use", settings["interpreter_path"]