tox-dev-python-discovery-79-85

-rw-r--r-- 1 root root 2238 Nov  4 15:51 README.md
drwxr-xr-x 1 root root 4096 Nov  4 15:51 docs
-rw-r--r-- 1 root root 6764 Nov  4 15:51 pyproject.toml
drwxr-xr-x 1 root root 4096 Nov  4 15:51 src
drwxr-xr-x 1 root root 4096 Nov  4 15:51 tasks
drwxr-xr-x 1 root root 4096 Nov  4 15:51 tests
-rw-r--r-- 1 root root 2565 Nov  4 15:51 tox.toml
./.git/COMMIT_E
…[273 chars omitted]…
DME.md
./docs/changelog.rst
./docs/conf.py
./docs/explanation.rst
./docs/index.rst
./pyproject.toml
./tasks/release.py
./tests/conftest.py
./tests/test_cache.py
./tests/test_cached_py_info.py
./tests/test_discovery.py
./tests/test_discovery_extra.py
./tests/test_iter_interpreters.py
./tests/test_py_info_extra.py
./tests/test_py_spec.py
./tests/test_py_spec_extra.py
./tests/test_specifier.py
./tox.toml

grep: src/virtualenv: No such file or directory

import warnings
from collections import OrderedDict
from string import digits
from typing import TYPE_CHECKING, ClassVar, Final, NamedTuple

if TYPE_CHECKING:
    import tkinter as tk
    from collections.abc import Generator, Mapping

    from ._cache import PyInfoCache
    from ._py_spec import PythonSpec


class VersionInfo(NamedTuple):
    major: int
    minor: int
    micro: int
    releaselevel: str
    serial: int


_LOGGER: Final[logging.Logger] = logging.getLogger(__name__)


def _get_path_extensions() -> list[str]:
    return list(OrderedDict.fromkeys(["", *os.environ.get("PATHEXT", "").lower().split(os.pathsep)]))


EXTENSIONS: F
…[8630 chars omitted]…
:165:def load_version_data(
src/python_discovery/_windows/_propose.py:5:from python_discovery._py_info import PythonInfo
src/python_discovery/_windows/_propose.py:6:from python_discovery._py_spec import PythonSpec
src/python_discovery/_windows/_propose.py:13:    from python_discovery._cache import PyInfoCache
src/python_discovery/__init__.py:8:from ._discovery import get_interpreter, iter_interpreters

    13	import warnings
    14	from collections import OrderedDict
    15	from string import digits
    16	from typing import TYPE_CHECKING, ClassVar, Final, NamedTuple
    17	
    18	if TYPE_CHECKING:
    19	    import tkinter as tk
    20	    from collections.abc import Generator, Mapping
    21	
    22	    from ._cache import PyInfoCache
    23	    from ._py_spec import PythonSpec
    24	
    25	
    26	class VersionInfo(NamedTuple):
    27	    major: int
    28	    minor: int
    29	    micro: int
    30	    releaselevel: str
    31	    serial: int
    32
…[8630 chars omitted]…
e": "ppc64le",
   806	        "sparcv9": "sparc64",
   807	    }.get(low, low)
   808	
   809	
   810	def _main() -> None:  # pragma: no cover
   811	    argv = sys.argv[1:]
   812	
   813	    if len(argv) >= 1:
   814	        start_cookie = argv[0]
   815	        argv = argv[1:]
   816	    else:
   817	        start_cookie = ""
   818	
   819	    if len(argv) >= 1:
   820	        end_cookie = argv[0]

                return tk_lib
        except tk.TclError:
            pass
        return None

    @staticmethod
    def _resolve_tk_lib(tcl: tk.Tk, tcl_lib: str) -> str | None:  # pragma: no cover
        """Resolve the TK library path by direct query or path construction."""
        if (tk_lib := PythonInfo._query_tk_library(tcl)) is not None:
            return tk_lib
        tk_version = tcl.eval("package require Tk")
        tcl_parent = os.path.dirname(tcl_lib)
        for version in (tk_version, ".".jo
…[8630 chars omitted]…
t find the file specified"),
tests/windows/winreg_mock_values.py:134:        "ExecutableArguments": OSError(2, "The system cannot find the file specified"),
tests/windows/winreg_mock_values.py:138:        "ExecutableArguments": OSError(2, "The system cannot find the file specified"),
tests/windows/winreg_mock_values.py:143:        "DisplayName": OSError(2, "The system cannot find the file specified"),

ier.py:115:    assert spec.is_wildcard is False
tests/test_specifier.py:118:def test_specifier_parse_wildcard() -> None:
tests/test_specifier.py:119:    spec = SimpleSpecifier.from_string("==3.11.*")
tests/test_specifier.py:120:    assert spec.is_wildcard is True
tests/test_specifier.py:121:    assert spec.wildcard_precision == 2
tests/test_specifier.py:125:    ("spec_str", "version_str", "expected"),

    def sysconfig_path(self, key: str, config_var: dict[str, str] | None = None, sep: str = os.sep) -> str:
        """
        Return the sysconfig install path for a scheme *key*, optionally substituting config variables.

        :param key: sysconfig path key (e.g. ``"purelib"``, ``"include"``).
        :param config_var: replacement mapping for sysconfig variables; when ``None`` uses the interpreter's own values.
        :param sep: pat
…[8630 chars omitted]…
fo.satisfies(spec, impl_must_match=True) is True


def test_py_info_to_dict_includes_sysconfig_platform() -> None:
    data = CURRENT.to_dict()
    assert "sysconfig_platform" in data
    assert data["sysconfig_platform"] == sysconfig.get_platform()


def test_py_info_json_round_trip() -> None:
    json_str = CURRENT.to_json()
    parsed = json.loads(json_str)
    assert "sysconfig_platform" in parsed

            self.machine,
        )

    @classmethod
    def clear_cache(cls, cache: PyInfoCache) -> None:
        """
        Clear all cached interpreter information from *cache*.

        :param cache: the cache store to clear.
        """
        from ._cached_py_info import clear  # noqa: PLC0415

        clear(cache)
        cls._cache_exe_discovery.clear()

    def satisfies(self, spec: PythonSpec, *, impl_must_match: bool) -
…[8630 chars omitted]…
win32 cover
        found = found.lower()
        dest_str = dest_str.lower()
    assert found == dest_str
    assert len(caplog.messages) >= 1, caplog.text
    assert "get interpreter info via cmd: " in caplog.text

    dest.rename(dest.parent / (dest.name + "-1"))
    CURRENT._cache_exe_discovery.clear()
    with pytest.raises(RuntimeError):
        CURRENT.discover_exe(session_cache, inside_folder)

   462	
   463	    def _satisfies_implementation(self, spec: PythonSpec) -> bool:
   464	        return spec.implementation is None or spec.implementation.lower() == self.implementation.lower()
   465	
   466	    def _satisfies_version_specifier(self, spec: PythonSpec) -> bool:
   467	        if
…[8630 chars omitted]…
ig_platform == sysconfig.get_platform()
   352	
   353	
   354	@pytest.mark.parametrize(
   355	    ("platform", "expected"),
   356	    [
   357	        pytest.param("win32", "x86", id="win32"),
   358	        pytest.param("win-amd64", "x86_64", id="win-amd64"),
   359	        pytest.param("win-arm64", "arm64", id="win-arm64"),
   360	        pytest.param("linux-x86_64", "x86_64", id="linux-x86_64"),

import warnings
from collections import OrderedDict
from string import digits
from typing import TYPE_CHECKING, ClassVar, Final, NamedTuple

if TYPE_CHECKING:
    import tkinter as tk
    from collections.abc import Generator, Mapping

    from ._cache import PyInfoCache
    from ._py_spec import PythonSpec


class VersionInfo(NamedTuple):
    major: int
    minor: int
    micro: int
    releaselevel: str
    serial: int


_LOGGER: Final[logging.Logger] = logging.getLogger(__name__)


def _get_path_extensions() -> list[str]:
    return list(OrderedDict.fromkeys(["", *os.environ.get("PATHEXT", "").lower().split(os.pathsep)]))


EXTENSIONS: F
…[8630 chars omitted]…
d is selected

    assert caplog.records[0].msg == "discover exe for %s in %s"
    for record in caplog.records[1:-1]:
        assert record.message.startswith("refused interpreter ")
        assert record.levelno == logging.DEBUG

    warn_similar = caplog.records[-1]
    assert warn_similar.levelno == logging.DEBUG
    assert warn_similar.msg.startswith("no exact match found, chosen most similar")

    def from_exe(  # noqa: PLR0913
        cls,
        exe: str,
        cache: PyInfoCache | None = None,
        *,
        raise_on_error: bool = True,
        ignore_cache: bool = False,
        resolve_to_host: bool = True,
        env: Mapping[str, str] | None = None,
    ) -> PythonInfo | None:
        """
        Get the python
…[8629 chars omitted]…
 = base.lower()
            yield lower
            from ._compat import fs_is_case_sensitive  # noqa: PLC0415

            if fs_is_case_sensitive():  # pragma: no branch
                if base != lower:
                    yield base
                upper = base.upper()
                if upper != base:
                    yield upper


KNOWN_ARCHITECTURES: frozenset[str] = frozenset({
    "arm64",

  { directory = "contrib", name = "Contributor-facing changes", showcontent = true },
  { directory = "misc", name = "Miscellaneous internal changes", showcontent = true },
]

import tempfile
from collections import OrderedDict
from contextlib import contextmanager
from pathlib import Path
from shlex import quote
from subprocess import Popen, TimeoutExpired  # noqa: S404
from typing import TYPE_CHECKING, Final

from ._cache import NoOpCache
from ._py_info import PythonInfo

if TYPE_CHECKING:
    from collections.abc import Generator, Mapping

    from ._cache import ContentStore, PyInfoCache


_CACHE: OrderedDict[Path, PythonInfo | Exception] = OrderedDict()
_CACHE[Path(sys.executable)] = PythonInfo()
_LOGGER: Final[logging.Logger] = logging.getLogger(__name__)


def from_exe(  # noqa: PLR0913
    cls: type[Pyth
…[8630 chars omitted]…
rt result.system_executable is not None
tests/test_py_info_extra.py:503:    target.system_executable = "/some/system/python"
tests/test_py_info_extra.py:507:    resolved.system_executable = "/some/system/python"
tests/test_py_info_extra.py:517:    target.system_executable = "/some/system/python"
tests/windows/conftest.py:131:    info.executable = info.original_executable = info.system_executable = exe

    proposed_paths: set[tuple[str | None, bool]] = set()
    env = os.environ if env is None else env
    for interpreter, impl_must_match in propose_interpreters(spec, try_first_with, cache, env):
        if interpreter is None:  # pragma: no cover
            continue
        proposed_key = interpreter.system_executable, impl_must_match
        if proposed_key in proposed_paths:
            continue
        _LOGGER.info("proposed %s", interpreter)
        if interpreter.satisfies(spec, impl_must_match=impl_must_match) and (
   
…[8629 chars omitted]…
g_spec: an interpreter spec — an absolute path, a version string, an implementation prefix,
            or a `version specifier <https://packaging.python.org/en/latest/specifications/version-specifiers/>`_.
        """
        if pathlib.Path(string_spec).is_absolute():
            return cls(string_spec, None, None, None, None, None, string_spec)
        if result := _parse_spec_pattern(string_spec):

        architecture: int | None,
        path: str | None,
        *,
        free_threaded: bool | None = None,
        machine: str | None = None,
        version_specifier: SpecifierSet | None = None,
    ) -> None:
        self.str_spec = str_spec
        self.implementation = implementation
        self.major = major
        self.minor = minor
        self.micro = micro
        self.free_threaded = free_threaded
        self.architecture = architecture
        self.machine = machine
        self.path = path
  
…[3588 chars omitted]…
ible with the given *spec* (e.g. PEP-514 on Windows).

        :param spec: the requirement to check against.
        """
        if spec.is_abs and self.is_abs and self.path != spec.path:
            return False
        if (
            spec.implementation is not None
            and self.implementation is not None
            and spec.implementation.lower() != self.implementation.lower()
        ):

commands = [
  ["coverage", "erase"],
  [
    "coverage",
    "run",
    "-m",
    "pytest",
    { replace = "posargs", extend = true, default = [
      "--junitxml",
      "{work_dir}{/}junit.{env_name}.xml",
      "tests",
    ] },
  ],
  ["coverage", "combine"],
  ["coverage", "report"],
  ["coverage", "html", "-d", "{env_tmp_dir}{/}htmlcov"],
]

[env.fix]
description = "run static analysis and style check using flake8"
skip_install = true
deps =
…[2101 chars omitted]…
ifier, SimpleSpecifierSet, SimpleVersion

__version__ = version("python-discovery")

__all__ = [
    "KNOWN_ARCHITECTURES",
    "KNOWN_IMPLEMENTATIONS",
    "ContentStore",
    "DiskCache",
    "PyInfoCache",
    "PythonInfo",
    "PythonSpec",
    "SimpleSpecifier",
    "SimpleSpecifierSet",
    "SimpleVersion",
    "__version__",
    "get_interpreter",
    "iter_interpreters",
    "normalize_isa",
]

grep: src/python_discovery/__pycache__/_cached_py_info.cpython-312.pyc: binary file matches
grep: src/python_discovery/__pycache__/_py_info.cpython-312.pyc: binary file matches

    result = str(CURRENT)
    assert "PythonInfo" in result
    assert "spec=" in result


def test_machine_none_platform() -> None:
    info = copy.deepcopy(CURRENT)
    info.sysconfig_platform = None
    assert info.machine == "unknown"


def test_from_json_round_trip() -> None:
    json_str = CURRENT.to_json()
    restored = PythonInfo.from_json(json_str)
    assert restored.version_info == CURRENT.version_info
    assert restored.implementation == CURRENT.implementation


def test_from_dict() -> None:
    data = CURRENT.to_dict()
    restored = PythonInfo.from_dict(data)
    assert resto
…[6829 chars omitted]…
ests/test_discovery_extra.py:90:def test_lazy_path_dump_debug_non_executable(tmp_path: Path) -> None:
tests/test_discovery_extra.py:99:def test_lazy_path_dump_debug_oserror(tmp_path: Path, mocker: MockerFixture) -> None:
grep: tests/__pycache__/test_discovery.cpython-312-pytest-9.2.0.pyc: binary file matches
grep: tests/__pycache__/test_discovery_extra.cpython-312-pytest-9.2.0.pyc: binary file matches

PATTERN = re.compile(
    r"""
    ^
    (?P<impl>[a-zA-Z]+)?            # implementation (e.g. cpython, pypy)
    (?P<version>[0-9.]+)?           # version (e.g. 3.12, 3.12.1)
    (?P<threaded>t)?                # free-threaded flag
    (?:-(?P<arch>32|64))?           # architecture bitness
    (?:-(?P<machine>[a-zA-Z0-9_.]+))?  # ISA (e.g. arm64, x86_64, i86pc.64bit)
    $
    """,
    re.VERBOSE,
)
SPECIFIER_PATTERN = re.compile(
    r"""
    ^
    (?:(?P<impl>[A-Za-z]+)\s*)?     # optional implementation prefix
    (?P<spec>(?:===|==|~=|!=|<=|>=|<|>).+)  # PEP 440 version specifier

…[2165 chars omitted]…
spec_text = specifier_match.group("spec").strip()
    try:
        version_specifier = SpecifierSet.from_string(spec_text)
    except InvalidSpecifier:  # pragma: no cover
        return None
    if impl in {"py", "python"}:
        impl = None
    if impl == "graalvm":
        impl = "graalpy"
    return PythonSpec(string_spec, impl, None, None, None, None, None, version_specifier=version_specifier)

@@ -73,6 +74,7 @@ class PythonInfo:  # noqa: PLR0904
         self.version = sys.version
         self.os = os.name
         self.free_threaded = sysconfig.get_config_var("Py_GIL_DISABLED") == 1
+        self.debug_build = sysconfig.get_config_var("Py_DEBUG") == 1
 
     def _init_prefixes(self) -> None:
         def abs_path(value: str | None) -> str | None:
@@ -197,12 +199,50 @@ class PythonInfo:  # noqa: PLR0904
                 return tk_lib_path
         return None
 
+    @stati
…[4889 chars omitted]…
     if basename.lower().endswith("_d"):
+            basename = basename[:-2]
+        elif basename.lower().endswith("d"):
+            basename = basename[:-1]
+        basename = basename.rstrip(digits)
         possible_base[basename] = None
         possible_base[self.implementation] = None
         # python is always the final option as in practice is used by multiple implementation as exe name

___________________ test_fast_get_system_executable_not_venv ___________________

    def test_fast_get_system_executable_not_venv() -> None:
        info = PythonInfo()
        info.real_prefix = None
        info.base_prefix 
…[233 chars omitted]…
+ /usr/local/bin/python3.12
E         ?                      ++++

tests/test_py_info_extra.py:74: AssertionError
=========================== short test summary info ============================
FAILED tests/test_py_info_extra.py::test_fast_get_system_executable_not_venv
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
1 failed, 101 passed, 2 skipped, 1 warning in 4.49s

@@ -73,6 +74,7 @@ class PythonInfo:  # noqa: PLR0904
         self.version = sys.version
         self.os = os.name
         self.free_threaded = sysconfig.get_config_var("Py_GIL_DISABLED") == 1
+        self.debug_build = sysconfig.get_config_var("Py_DEBUG") == 1
 
     def _init_prefixes(self) -> None:
         def abs_path(value: str | None) -> str | None:
@@ -86,7 +88,10 @@ class PythonInfo:  # noqa: PLR0904
 
         self.executable = abs_path(sys.executable)
         self.origi
…[5049 chars omitted]…
name.lower().endswith("_d"):
+                basename = basename[:-2]
+            elif basename.lower().endswith("d"):
+                basename = basename[:-1]
+        basename = basename.rstrip(digits)
         possible_base[basename] = None
         possible_base[self.implementation] = None
         # python is always the final option as in practice is used by multiple implementation as exe name

    @property
    def spec(self) -> str:
        """A specification string identifying this interpreter (e.g. ``CPython3.13.2d-64-arm64``)."""
        modifiers = ("t" if self.free_threaded else "") + ("d" if self.debug_build else "")
        return "{}{}{}-{}-{}".format(
            self.implementation,
            ".".join(str(i) for i in self.version_info[:3]),
            modifiers,
            self.architecture,
            self.machine,
     
…[1310 chars omitted]…
  raise RuntimeError(msg)
            prefixes[prefix] = target
            target = target.discover_exe(cache, prefix=prefix, exact=False)
        if target.executable != target.system_executable:
            resolved = cls.from_exe(target.system_executable, cache)
            if resolved is not None:
                target = resolved
        target.executable = start_executable
        return target

    if IS_WIN:  # pragma: win32 cover
        from ._windows import propose_interpreters as win_propose  # noqa: PLC0415

        for interpreter in win_propose(spec, cache, env):
            if _is_new_exe(str(interpreter.executable), tested_exes):
                yield interpreter, True


def _propose_from_path(
    spec: PythonSpec,
    cache: PyInfoCache | None,
    env: Mapping[str, str],
    tested_exes: set[str],
    *,
    all_implementations: boo
…[7380 chars omitted]…

    "InvalidVersion",
    "PythonSpec",
    "SpecifierSet",
    "Version",
]
src/python_discovery/_windows/_propose.py:43:        registry_spec = PythonSpec("", implementation, major, minor, None, arch, exe, free_threaded=threaded)
tests/windows/conftest.py:135:    info.free_threaded = threaded
tests/windows/conftest.py:144:        if spec.free_threaded is not None and spec.free_threaded != threaded:

    def path_exes(path: Path) -> Generator[tuple[Path, bool], None, None]:
        direct_path = path / direct
        if direct_path.exists():
            yield direct_path, False

        for exe in path.iterdir():
            match = pat.fullmatch(exe.name)
            if match:
         
…[1730 chars omitted]…
ec_2.free_threaded is False
tests/test_py_spec_extra.py:77:def test_generate_re_no_threaded() -> None:
tests/test_py_spec_extra.py:79:    pat = spec.generate_re(windows=False)
tests/test_py_spec_extra.py:83:def test_generate_re_with_threaded() -> None:
tests/test_py_spec_extra.py:85:    pat = spec.generate_re(windows=False)
tests/test_discovery.py:38:    threaded = "t" if current.free_threaded else ""

        possible_base["python"] = None
        for base in possible_base:
            lower = base.lower()
            yield lower
            from ._compat import fs_is_case_sensitive  # noqa: PLC0415

            if fs_is_case_sensitive():  # pragma: no branch
                if base != lower:
                    yield base
                upper = base.upper()
                if upper != base:
                    yield upper


KNOWN_ARCHITECTURES: frozenset[str] = frozenset({
    "arm64",
    "loongarch64",
    "ppc",
    "ppc64",

    ) -> PythonInfo:
        """
        Discover a matching Python executable under a given *prefix* directory.

        :param cache: interpreter metadata cache.
        :param prefix: directory prefix to search under.
        :param exact: when ``True``, require an exact version match.
        :param env: environment mapping; defaults to :data:`os.environ`.
        """
        key = prefix, exact
        if key in self._cache_exe_discovery and prefix:
            _LOGGER.debug("discover exe from cache %s - exact %s: %r", prefix, exact, self._cache_exe_discovery[key])
     
…[8629 chars omitted]…
ult, (PythonInfo, Exception))


def test_from_exe_retry_on_first_failure(
    tmp_path: Path, mocker: MockerFixture, caplog: pytest.LogCaptureFixture
) -> None:
    caplog.set_level(logging.DEBUG)
    cache = DiskCache(tmp_path)
    error = RuntimeError("fail")
    mocker.patch(
        "python_discovery._cached_py_info._run_subprocess",
        side_effect=[(error, None), (None, PythonInfo())],
    )

        resolve_to_host: bool = True,
        env: Mapping[str, str] | None = None,
    ) -> PythonInfo | None:
        """
        Get the python information for a given executable path.

        :param exe: path to the Python executable.
        :param cache: interpreter metadata cache; when ``None`` results are not cached.
        :param raise_on_error: raise on failure instead of returning ``None``.
        :param ignore_cache: bypass the cache and re-query the interpreter.
        :param resolve_to_host: 
…[1990 chars omitted]…

        possible_base[basename] = None
        possible_base[self.implementation] = None
        # python is always the final option as in practice is used by multiple implementation as exe name
        if "python" in possible_base:
            del possible_base["python"]
        possible_base["python"] = None
        for base in possible_base:
            lower = base.lower()
            yield lower

        data["version_info"] = VersionInfo(**data["version_info"])  # restore this to a named tuple structure
        data.setdefault("debug_build", False)  # data written by older versions did not include this field
        result = cls()
        result.__dict__ = data.copy()
        return result

    @classmethod
    def resolve_to_system(cls, cache: PyInfoCache | None, target: PythonInfo) -> PythonInfo:
        """
        Walk virtualenv/venv prefix chains to find the underlying system interpreter.

        
…[294 chars omitted]…
et.real_prefix or target.base_prefix or target.prefix
            if prefix in prefixes:
                if len(prefixes) == 1:
                    _LOGGER.info("%r links back to itself via prefixes", target)
                    target.system_executable = cls._resolve_executable_symlink(target.executable)
                    break
                for at, (p, t) in enumerate(prefixes.items(), start=1):

    :param version: the parsed version, or ``None`` if parsing failed.
    """

    spec_str: str
    operator: str
    version_str: str
    is_wildcard: bool
    wildcard_precision: int | None
    version: SimpleVersion | None

    @classmethod
    def from_string(cls, spec_str: str) -> SimpleSpecifier:
        """

    
        def reject_first(info: PythonInfo) -> bool:
            nonlocal accepted_exe
            if accepted_exe is None:
                accepted_exe = str(info.executable)
                return False
    
…[656 chars omitted]…
l/lib/python3.12', 'max_size': 9223372036854775807}).executable

tests/test_discovery.py:446: AssertionError
=========================== short test summary info ============================
FAILED tests/test_discovery.py::test_predicate_with_fallback_specs - Assertio...
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
1 failed, 169 passed, 1 skipped, 1 warning in 10.94s

def test_predicate_filters_interpreters(session_cache: DiskCache) -> None:
    result = get_interpreter(sys.executable, [], session_cache, predicate=lambda _: False)
    assert result is None


def test_predicate_accepts_interpreter(session_cache: DiskCache) -> None:
    result = get_interpreter(sys.e
…[3339 chars omitted]…
e ``None``."""
    try:
        os.lstat(path)
    except OSError:
        return None
    resolved = str(Path(path).resolve())
    exe_id = fs_path_id(resolved)
    if exe_id in tested_exes:
        return None
    tested_exes.add(exe_id)
/usr/local/bin/python True /usr/local/bin/python3.12
/usr/local/bin/python3 True /usr/local/bin/python3.12
/usr/local/bin/python3.12 False /usr/local/bin/python3.12

from ._compat import fs_path_id
from ._py_info import PythonInfo
from ._py_spec import PythonSpec

if TYPE_CHECKING:
    from collections.abc import Callable, Generator, Iterable, Iterator, Mapping, Sequence

    from ._cache import PyInfoCache

_LOGGER: Final[logging.Logger] = logging.getLogger(__name__)
IS_WIN: Final[bool] = sys.platform == "win32"


def get_interpreter(
    key: str | Sequence[str],
    try_first_with: Iterable[str] | None = None,
    cache: PyInfoCache | None = None,
    env: Mapping[str, str] | None = None,
    predicate: Callable[[PythonInfo], bool] | None = None,
) -> PythonInfo | N
…[5367 chars omitted]…
    return None


def _check_exe(path: str, tested_exes: set[str]) -> str | None:
    """Resolve *path* to an absolute path and return it if not yet tested, otherwise ``None``."""
    try:
        os.lstat(path)
    except OSError:
        return None
    resolved = str(Path(path).resolve())
    exe_id = fs_path_id(resolved)
    if exe_id in tested_exes:
        return None
    tested_exes.add(exe_id)

__all__ = [
    "LazyPathDump",
    "PathPythonInfo",
    "get_interpreter",
    "get_paths",
    "iter_interpreters",
    "propose_interpreters",
]
.pytest_cache/v/cache/lastfailed:2:  "tests/test_discovery.py::test_predicate_with_fallback_specs": true
.pytest_cache/v/cache/nodeids:160:  "tests/test_discovery.py::test_predicate_with_fallback_specs",
tests/test_discovery.py:431:def test_predicate_with_fallback_specs(session_cache: DiskCache) -> None:
grep: tests/__pycache__/test_discovery.cpython-312-pytest-9.2.0.pyc: binary file matches

    from python_discovery._py_info import VersionInfo

    info = MagicMock()
    info.base_prefix = str(Path(exe).parent)
    info.executable = info.original_executable = info.system_executable = exe
    info.implementation = "CPython"
    info.architecture = arch
    info.version_info = VersionInfo(major, minor, 0, "final", 0)
    info.free_threaded = threaded
    info.sysconfig_platform = "win-amd64" if arch == 64 else "win32"
 
…[568 chars omitted]…
nd spec.minor != minor)

    info.satisfies = satisfies
    return info


@pytest.fixture
def _populate_pyinfo_cache(monkeypatch: pytest.MonkeyPatch) -> None:
    from python_discovery._cached_py_info import _CACHE

    python_core_path = "C:\\Users\\user\\AppData\\Local\\Programs\\Python"
    interpreters = [
        ("ContinuumAnalytics", 3, 10, 32, False, "C:\\Users\\user\\Miniconda3\\python.exe"),

        possible_base = OrderedDict()
        basename = os.path.splitext(os.path.basename(self.executable))[0]
        lower_basename = basename.lower()
        if lower_basename.endswith("_d"):
            basename = basename[:-2]
        elif lower_basename.endswith("d") and len(basenam
…[1878 chars omitted]…
ebug("discover exe from cache %s - exact %s: %r", prefix, exact, self._cache_exe_discovery[key])
            return self._cache_exe_discovery[key]
        _LOGGER.debug("discover exe for %s in %s", self, prefix)
        possible_names = self._find_possible_exe_names()
        possible_folders = self._find_possible_folders(prefix)
        discovered = []
        env = os.environ if env is None else env

            nonlocal accepted_exe
            if accepted_exe is None:
                accepted_exe = str(info.executable)
                return False
            return True
    
        result = get_interpreter([f"{major}.{minor}", sys.executable], [], session_cache, predicate=reject_first)
        assert accepted_exe is not None
       
…[435 chars omitted]…
system_stdlib_platform': '/usr/local/lib/python3.12', 'max_size': 9223372036854775807}).executable

tests/test_discovery.py:446: AssertionError
=========================== short test summary info ============================
FAILED tests/test_discovery.py::test_predicate_with_fallback_specs - Assertio...
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
1 failed in 0.45s

         if interpreter is None:  # pragma: no cover
             continue
-        proposed_key = interpreter.system_executable, impl_must_match
+        proposed_key = interpreter.system_executable, interpreter.executable, impl_must_match
         if propo
…[8173 chars omitted]…
       basename = basename[:-2]
+        elif lower_basename.endswith("d") and len(basename) > 1 and basename[-2].isdigit():
+            basename = basename[:-1]
+        basename = basename.rstrip(digits)
         possible_base[basename] = None
         possible_base[self.implementation] = None
         # python is always the final option as in practice is used by multiple implementation as exe name

    from python_discovery._cache import PyInfoCache

_IMPLEMENTATION_BY_ORG: dict[str, str] = {
    "ContinuumAnalytics": "CPython",
    "PythonCore": "CPython",
}


class Pep514PythonInfo(PythonInfo):
    """A Python information acquired from PEP-514."""


def propose_interpreters(
    spec: PythonSpec,
    cache: PyInfoCache | None,
    env: Mapping[str, str],
) -> Generator[PythonInfo, None, None]:
    existing = list(discover_pythons())
    existing.sort(
        key=lambda i: (
            *tuple(-1 if j is None else j for j in i[1:4]),
            1 if i[0] == "PythonCore" else 0,
        ),
        revers
…[8629 chars omitted]…
 result.value if isinstance(result, _Key) else result
        if isinstance(value, OSError):
            raise value
        yield result

    return _open_key_ex


@pytest.fixture
def _mock_registry(monkeypatch: pytest.MonkeyPatch) -> None:
    if sys.platform != "win32":
        winreg = _create_winreg_mock()
        monkeypatch.setitem(sys.modules, "winreg", winreg)
    else:
        import winreg

    def _init_sysconfig(self) -> None:
        makefile = getattr(sysconfig, "get_makefile_filenam
…[1494 chars omitted]…
etect the tcl and tk libraries using tkinter."""
        tcl_lib, tk_lib = None, None
        try:
            import tkinter as tk  # noqa: PLC0415
        except ImportError:
            pass
        else:
            try:
                tcl = tk.Tcl()
                tcl_lib = tcl.eval("info library")
                tk_lib = PythonInfo._resolve_tk_lib(tcl, tcl_lib)
            except tk.TclError:

@functools.lru_cache(maxsize=1)
def fs_is_case_sensitive() -> bool:
    with tempfile.NamedTemporaryFile(prefix="TmP") as tmp_file:
        result = not pathlib.Path(tmp_file.name.lower()).exists()
    _LOGGER.debug("filesystem is %scase-sensitive", "" if result else "not ")
    return result


def fs_path_id(path: str) -> str:
    return path.casefold() if not fs_is_case_sensitive() else path


__all__ = [
    "fs_is_case_sensitive",
    "fs_path_id",
]
106:    for interpreter, impl_must_match in propose_interpreters(
134:    for interpreter, impl_must_match in propose_interpreters(spec, try_first_with, cache, env):
173:def propose_interpreters(
205:def _propose_explicit(
234:        from ._windows import propose_interpreters as win_propose  # noqa: PLC0415
424:    "propose_interpreters",

        # Make the path absolute while preserving symlinked parent directories. Normalizing ``..`` can
        # change which directory a path traverses when one of its parents is itself a symlink, so only
        # use the normalized path when it still names the same file.
        absolute = path if os.path.isabs(path) else os.path.join(os.getcwd(), path)
        normalized = os.path.normp
…[1097 chars omitted]…
y just looking at properties."""
        # if we're not in a virtual environment, this is already a system python, so return the original executable
        # note we must choose the original and not the pure executable as shim scripts might throw us off
        if not (self.real_prefix or (self.base_prefix is not None and self.base_prefix != self.prefix)):
            return self.original_executable

        while os.path.islink(resolved):
            try:
                target = os.readlink(resolved)
                if not os.path.isabs(target):
                    target = os.path.join(os.path.dirname(resolved), target)
                normalized_target = os.path.normpath(target)
                if normalized_target != target:
                    if not os.path.samefile(target, normalized_target):
                        break
                    target = normalized_target
                if target in seen or not os.path.samefile(resolved, target):
                    break
            except (OSError, ValueError):
                break
            resolved = target
            seen.add(resolved)
        return resolved

    def _fast_get_system_executable(self) -> str | None:

            basename = basename[:-2]
        elif lower_basename.endswith("d") and len(basename) > 1 and basename[-2].isdigit():
            basename = basename[:-1]
        basename = basename.rstrip(digits)
        possible_base[basename] = None
        possible_base[self.
…[713 chars omitted]…
ename = basename[:-1]
803-        basename = basename.rstrip(digits)
804-        possible_base[basename] = None
805-        possible_base[self.implementation] = None
806-        # python is always the final option as in practice is used by multiple implementation as exe name
807-        if "python" in possible_base:
808-            del possible_base["python"]
809-        possible_base["python"] = None

 2 files changed, 70 insertions(+), 16 deletions(-)

269:def test_check_exe_none_path(tmp_path: Path) -> None:
270-    info = copy.deepcopy(CURRENT)
271-    result = info._check_exe(MagicMock(), str(tmp_path), "nonexistent", [], dict(os.environ), exact=True)
272-    assert result is None
273-
274-
275-def test_satisfies_version_specifier() -> None:
276-    spec = PythonSpec.from_string_spec(f">={sys.version_info.major}.{sys.version_info.minor}")
277-    assert CURRENT.satisfies(spec, impl_must_match=False) is T
…[7357 chars omitted]…
honInfo, "from_exe", return_value=resolved)
511-    result = PythonInfo.resolve_to_system(None, target)
512-    assert result.executable == "/some/venv/python"
513-
514-
515-def test_resolve_to_system_from_exe_returns_none(mocker: MockerFixture) -> None:
516-    target = copy.deepcopy(CURRENT)
517-    target.system_executable = "/some/system/python"
518-    target.executable = "/some/venv/python"
519-

tests/test_py_spec_extra.py:51:    spec = PythonSpec("", None, None, None, None, None, None)
tests/test_py_spec_extra.py:52:    candidate = PythonSpec("", "CPython", 3, 12, 0, None, None)

    $
    """,
    re.VERBOSE,
)
SPECIFIER_PATTERN = re.compile(
    r"""
    ^
    (?:(?P<impl>[A-Za-z]+)\s*)?     # optional implementation prefix
    (?P<spec>(?:===|==|~=|!=|<=|>=|<|>).+)  # PEP 440 version specifier
    $
    """,
    re.VERBOSE,
)

_MAX_VERSION_PARTS: Final[int] = 3
_SINGLE_DIGIT_MAX: Final[int] = 9

KNOWN_IMPLEMENTATIONS: Final[tupl
…[8628 chars omitted]…
ring identifying this interpreter (e.g. ``CPython3.13.2d-64-arm64``)."""
        modifiers = ("t" if self.free_threaded else "") + ("d" if self.debug_build else "")
        return "{}{}{}-{}-{}".format(
            self.implementation,
            ".".join(str(i) for i in self.version_info[:3]),
            modifiers,
            self.architecture,
            self.machine,
        )

    @classmethod

from ._py_info import normalize_isa
from ._specifier import SimpleSpecifier, SimpleSpecifierSet, SimpleVersion

PATTERN = re.compile(
    r"""
    ^
    (?P<impl>[a-zA-Z]+)?            # implementation (e.g. cpython, pypy)
    (?P<version>[0-9.]+)?           # version (e.g. 3.12, 3.12.1)
    (?P<threaded>t)?                # free-threaded flag
    (?P<debug>d)?                   # debug-build flag
    (?:-(?P<arch>32|64))?           # architecture bitness
    (?:-(?P<machine>[a-zA-Z0-9_.]+))?  # ISA (e.g. arm64, x86_64, i86pc.64bit)
    $
    """,
    re.VERBOSE,
)
SPECIFIER_PATTERN = re.compile(
    r"""
   
…[8026 chars omitted]…
ure",
            "machine",
            "path",
            "free_threaded",
            "debug_build",
            "version_specifier",
        )
        return f"{name}({', '.join(f'{k}={getattr(self, k)}' for k in params if getattr(self, k) is not None)})"


__all__ = [
    "KNOWN_IMPLEMENTATIONS",
    "InvalidSpecifier",
    "InvalidVersion",
    "PythonSpec",
    "SpecifierSet",
    "Version",
]

    13	PATTERN = re.compile(
    14	    r"""
    15	    ^
    16	    (?P<impl>[a-zA-Z]+)?            # implementation (e.g. cpython, pypy)
    17	    (?P<version>[0-9.]+)?           # version (e.g. 3.12, 3.12.1)
    18	    (?P<threaded>t)?                # free-threaded flag
    19	    (?P<debug>d)?                   # debug-build flag
    20	    (?:-(?P<arch>32|64))?           # architecture bitness
    21	    (?:-(?P<machine>[a-zA-Z0-9_.]+))?  # ISA (e.g. arm64, x86_64, i86pc.64bit)
    22	    $
    23
…[8629 chars omitted]…
 is not None and not self._check_version_specifier(spec):
             return False
         return all(
@@ -263,6 +282,7 @@ class PythonSpec:
             "machine",
             "path",
             "free_threaded",
+            "debug_build",
             "version_specifier",
         )
         return f"{name}({', '.join(f'{k}={getattr(self, k)}' for k in params if getattr(self, k) is not None)})"

    if not (match := re.match(PATTERN, string_spec)):
        return None
    groups = match.groupdict()
    version = groups["version"]
    major, minor, micro, threaded = None, None, None, None
    if version is not None:
        try:
            major, minor, micro = _parse_version_parts(version)
        except ValueError:
            return None
        threaded = bool(groups["threaded"])
    debug = None if version is Non
…[5012 chars omitted]…
ation into a :class:`PythonSpec`.

        :param string_spec: an interpreter spec — an absolute path, a version string, an implementation prefix,
            or a `version specifier <https://packaging.python.org/en/latest/specifications/version-specifiers/>`_.
        """
        if pathlib.Path(string_spec).is_absolute():
            return cls(string_spec, None, None, None, None, None, string_spec)

-    proposed_paths: set[tuple[str | None, bool]] = set()
+    proposed_paths: set[tuple[str | None, str | None, bool]] = set()
     env = os.environ if env is None else env
     for interpreter, impl_must_match in propose_interpreters(spec, try_first_with, cache, env):
         if interpreter is
…[8629 chars omitted]…
 is not None and not self._check_version_specifier(spec):
             return False
         return all(
@@ -263,6 +287,7 @@ class PythonSpec:
             "machine",
             "path",
             "free_threaded",
+            "debug_build",
             "version_specifier",
         )
         return f"{name}({', '.join(f'{k}={getattr(self, k)}' for k in params if getattr(self, k) is not None)})"

            return False
        if (
            spec.debug_build is not None
            and self.debug_build is not None
            and spec.debug_build != self.debug_build
        ):
            return False
        if spec.version_specifier is not None and not self._check_version_specifier(spec):
            return False
     
…[375 chars omitted]…
................................. [ 42%]
.....s.................................................................. [ 57%]
........................................................................ [ 71%]
........................................................................ [ 85%]
........................................................ssssssssssss..ss [100%]
488 passed, 16 skipped, 1 warning in 16.47s

    debug = None if version is None else bool(groups["debug"])
    impl = groups["impl"]
    if impl in {"py", "python"}:
        impl = None
    if impl == "graalvm":
        impl = "graalpy"
    arch = _int_or_none(groups["arch"])
    machine = groups.get("machine")
    if machine is not None:
        machine = normalize_isa(machine)
    return PythonSpec(
        string_spec,
        impl,
        major,
        minor,
        mi
…[8629 chars omitted]…
i) for i in found), ".".join(str(i) for i in searched)
                executable = info.executable
                _LOGGER.debug("refused interpreter %s because %s differs %s != %s", executable, item, found, searched)
                if exact is False and item != "debug_build":
                    discovered.append(info)
                break
        else:
            return info
        return None

         if interpreter is None:  # pragma: no cover
             continue
-        proposed_key = interpreter.system_executable, impl_must_match
+        proposed_key = interpreter.system_executable, interpreter.executable, impl_must_match
         if propo
…[8629 chars omitted]…
 is not None and not self._check_version_specifier(spec):
             return False
         return all(
@@ -263,6 +291,7 @@ class PythonSpec:
             "machine",
             "path",
             "free_threaded",
+            "debug_build",
             "version_specifier",
         )
         return f"{name}({', '.join(f'{k}={getattr(self, k)}' for k in params if getattr(self, k) is not None)})"