Interpreter lookup can report Python 3.15 as 3.11 #186

#!/usr/bin/env python3
import json
import pathlib
import subprocess
import tempfile

PYTHON = "/opt/venv/bin/python"  # the image installs python-discovery from /src here

# set up: <root>/prefix holds python3.11 and python3.15; venv311 and venv315 are venvs of each
root = pathlib.Path(tempfile.mkdtemp())
subprocess.run([PYTHON, "/tmp/repro.d/make_two_venvs_on_one_prefix.py", root], check=True)
prefix = root / "prefix"

# the one artificial step, standing in for a CPython <= 3.10 venv: `home` without an interpreter in it.
# CPython still finds base_prefix = prefix by walking up from `home`, but sys._base_executable names
# nothing, so python-discovery gets system_executable=None and searches the prefix for the base.
for venv in ("venv311", "venv315"):
    pyvenv_cfg = root / venv / "pyvenv.cfg"
    recorded_home = f"home = {prefix}/bin\n"
    assert recorded_home in pyvenv_cfg.read_text()
    pyvenv_cfg.write_text(pyvenv_cfg.read_text().replace(recorded_home, f"home = {prefix}/no-python-here\n"))

resolve_with_only_venv315_on_path = [PYTHON, "/tmp/repro.d/resolve_specs.py", str(root / "venv315" / "bin")]

# control: a fresh process asks for "3.11" with only the 3.15 venv on PATH
control = subprocess.run([*resolve_with_only_venv315_on_path, "3.11"], check=True, capture_output=True, text=True)
print("process 1:")
print(control.stdout)
(alone,) = json.loads(control.stdout.splitlines()[-1])

# trigger: the same request, in a process that resolved the 3.11 venv first
trigger = subprocess.run(
    [*resolve_with_only_venv315_on_path, str(root / "venv311" / "bin" / "python"), "3.11"],
    check=True,
    capture_output=True,
    text=True,
)
print("process 2:")
print(trigger.stdout)
_, after_venv311 = json.loads(trigger.stdout.splitlines()[-1])

# check: "3.11" must not be answered with the 3.15 venv; run what was returned and ask its version
print('"3.11" alone                  ->', alone)
print('"3.11" after resolving venv311 ->', after_venv311)
really_runs = None
if after_venv311 is not None:
    ask_version = [after_venv311["executable"], "-c", "import platform; print(platform.python_version())"]
    really_runs = subprocess.check_output(ask_version, text=True).strip()
    print(after_venv311["executable"], "is reported as", after_venv311["version"], "and really runs", really_runs)
print("BUG" if alone is None and after_venv311 is not None and after_venv311["version"] != really_runs else "OK")

#!/usr/bin/env python3
# usage: make_two_venvs_on_one_prefix.py <root>
# Creates <root>/prefix (bin/python3.11 and bin/python3.15, like a distribution's /usr)
# and a plain `python -m venv` of each: <root>/venv311, <root>/venv315.
import pathlib
import shutil
import subprocess
import sys

root = pathlib.Path(sys.argv[1])
prefix = root / "prefix"
(prefix / "bin").mkdir(parents=True)
(prefix / "lib").mkdir()

# copies, not symlinks: CPython derives sys.prefix from the real path of its binary
shutil.copy2("/usr/bin/python3.11", prefix / "bin" / "python3.11")
shutil.copy2("/usr/local/bin/python3.15", prefix / "bin" / "python3.15")
(prefix / "lib" / "python3.11").symlink_to("/usr/lib/python3.11")
(prefix / "lib" / "python3.15").symlink_to("/usr/local/lib/python3.15")

# --copies: a symlinked venv python would find its base executable through realpath()
subprocess.run([prefix / "bin" / "python3.11", "-m", "venv", "--copies", "--without-pip", root / "venv311"], check=True)
subprocess.run([prefix / "bin" / "python3.15", "-m", "venv", "--copies", "--without-pip", root / "venv315"], check=True)

#!/usr/bin/env python3
# A tool that resolves several interpreter requests in one process, as tox or virtualenv do.
# usage: resolve_specs.py <PATH to search> <spec> [<spec> ...]
# Last line of stdout: a JSON list with one entry per spec (null when nothing was found).
import json
import pathlib
import sys
import tempfile

from python_discovery import DiskCache, get_interpreter


def print_spawned_interpreter(event, args):
    if event == "subprocess.Popen":
        print("    spawned:", *args[1][:2])


sys.addaudithook(print_spawned_interpreter)

search_path, specs = sys.argv[1], sys.argv[2:]
cache = DiskCache(pathlib.Path(tempfile.mkdtemp()))

results = []
for spec in specs:
    print(f"  get_interpreter({spec!r}, env={{'PATH': {search_path!r}}})")
    found = get_interpreter(spec, cache=cache, env={"PATH": search_path})
    if found is None:
        results.append(None)
    else:
        results.append({
            "executable": found.executable,
            "version": found.version_str,
            "system_executable": found.system_executable,
        })
print(json.dumps(results))