python-discovery 1.0.0__py3-none-any.whl

python_discovery/_windows/_pep514.py

@@ -0,0 +1,222 @@
+"""Implement https://www.python.org/dev/peps/pep-0514/ to discover interpreters - Windows only."""
+
+from __future__ import annotations
+
+import logging
+import os
+import re
+import sys
+import winreg
+from logging import basicConfig, getLogger
+from typing import TYPE_CHECKING, Any, Final
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+    _RegistrySpec = tuple[str, int | None, int | None, int, bool, str, str | None]
+
+_LOGGER: Final[logging.Logger] = getLogger(__name__)
+_ARCH_RE: Final[re.Pattern[str]] = re.compile(
+    r"""
+    ^
+    (\d+)   # bitness number
+    bit     # literal suffix
+    $
+    """,
+    re.VERBOSE,
+)
+_VERSION_RE: Final[re.Pattern[str]] = re.compile(
+    r"""
+    ^
+    (\d+)            # major
+    (?:\.(\d+))?     # optional minor
+    (?:\.(\d+))?     # optional micro
+    $
+    """,
+    re.VERBOSE,
+)
+_THREADED_TAG_RE: Final[re.Pattern[str]] = re.compile(
+    r"""
+    ^
+    \d+              # major
+    (\.\d+){0,2}     # optional minor/micro
+    t                # free-threaded flag
+    $
+    """,
+    re.VERBOSE | re.IGNORECASE,
+)
+
+
+def enum_keys(key: Any) -> Generator[str, None, None]:  # noqa: ANN401
+    at = 0
+    while True:
+        try:
+            yield winreg.EnumKey(key, at)  # ty: ignore[unresolved-attribute]
+        except OSError:
+            break
+        at += 1
+
+
+def get_value(key: Any, value_name: str | None) -> Any:  # noqa: ANN401
+    try:
+        return winreg.QueryValueEx(key, value_name)[0]  # ty: ignore[unresolved-attribute]
+    except OSError:
+        return None
+
+
+def discover_pythons() -> Generator[_RegistrySpec, None, None]:
+    for hive, hive_name, key, flags, default_arch in [
+        (winreg.HKEY_CURRENT_USER, "HKEY_CURRENT_USER", r"Software\Python", 0, 64),  # ty: ignore[unresolved-attribute]
+        (winreg.HKEY_LOCAL_MACHINE, "HKEY_LOCAL_MACHINE", r"Software\Python", winreg.KEY_WOW64_64KEY, 64),  # ty: ignore[unresolved-attribute]
+        (winreg.HKEY_LOCAL_MACHINE, "HKEY_LOCAL_MACHINE", r"Software\Python", winreg.KEY_WOW64_32KEY, 32),  # ty: ignore[unresolved-attribute]
+    ]:
+        yield from process_set(hive, hive_name, key, flags, default_arch)
+
+
+def process_set(
+    hive: int,
+    hive_name: str,
+    key: str,
+    flags: int,
+    default_arch: int,
+) -> Generator[_RegistrySpec, None, None]:
+    try:
+        with winreg.OpenKeyEx(hive, key, 0, winreg.KEY_READ | flags) as root_key:  # ty: ignore[unresolved-attribute]
+            for company in enum_keys(root_key):
+                if company == "PyLauncher":  # reserved
+                    continue
+                yield from process_company(hive_name, company, root_key, default_arch)
+    except OSError:
+        pass
+
+
+def process_company(
+    hive_name: str,
+    company: str,
+    root_key: Any,  # noqa: ANN401
+    default_arch: int,
+) -> Generator[_RegistrySpec, None, None]:
+    with winreg.OpenKeyEx(root_key, company) as company_key:  # ty: ignore[unresolved-attribute]
+        for tag in enum_keys(company_key):
+            spec = process_tag(hive_name, company, company_key, tag, default_arch)
+            if spec is not None:
+                yield spec
+
+
+def process_tag(hive_name: str, company: str, company_key: Any, tag: str, default_arch: int) -> _RegistrySpec | None:  # noqa: ANN401
+    with winreg.OpenKeyEx(company_key, tag) as tag_key:  # ty: ignore[unresolved-attribute]
+        version = load_version_data(hive_name, company, tag, tag_key)
+        if version is not None:  # if failed to get version bail
+            major, minor, _ = version
+            arch = load_arch_data(hive_name, company, tag, tag_key, default_arch)
+            if arch is not None:
+                exe_data = load_exe(hive_name, company, company_key, tag)
+                if exe_data is not None:
+                    exe, args = exe_data
+                    threaded = load_threaded(hive_name, company, tag, tag_key)
+                    return company, major, minor, arch, threaded, exe, args
+                return None
+            return None
+        return None
+
+
+def load_exe(hive_name: str, company: str, company_key: Any, tag: str) -> tuple[str, str | None] | None:  # noqa: ANN401
+    key_path = f"{hive_name}/{company}/{tag}"
+    try:
+        with winreg.OpenKeyEx(company_key, rf"{tag}\InstallPath") as ip_key, ip_key:  # ty: ignore[unresolved-attribute]
+            exe = get_value(ip_key, "ExecutablePath")
+            if exe is None:
+                ip = get_value(ip_key, None)
+                if ip is None:
+                    msg(key_path, "no ExecutablePath or default for it")
+
+                else:
+                    exe = os.path.join(ip, "python.exe")
+            if exe is not None and os.path.exists(exe):
+                args = get_value(ip_key, "ExecutableArguments")
+                return exe, args
+            msg(key_path, f"could not load exe with value {exe}")
+    except OSError:
+        msg(f"{key_path}/InstallPath", "missing")
+    return None
+
+
+def load_arch_data(hive_name: str, company: str, tag: str, tag_key: Any, default_arch: int) -> int | None:  # noqa: ANN401
+    arch_str = get_value(tag_key, "SysArchitecture")
+    if arch_str is not None:
+        key_path = f"{hive_name}/{company}/{tag}/SysArchitecture"
+        try:
+            return parse_arch(arch_str)
+        except ValueError as sys_arch:
+            msg(key_path, sys_arch)
+    return default_arch
+
+
+def parse_arch(arch_str: Any) -> int:  # noqa: ANN401
+    if isinstance(arch_str, str):
+        if match := _ARCH_RE.match(arch_str):
+            return int(next(iter(match.groups())))
+        error = f"invalid format {arch_str}"
+    else:
+        error = f"arch is not string: {arch_str!r}"
+    raise ValueError(error)
+
+
+def load_version_data(
+    hive_name: str,
+    company: str,
+    tag: str,
+    tag_key: Any,  # noqa: ANN401
+) -> tuple[int | None, int | None, int | None] | None:
+    for candidate, key_path in [
+        (get_value(tag_key, "SysVersion"), f"{hive_name}/{company}/{tag}/SysVersion"),
+        (tag, f"{hive_name}/{company}/{tag}"),
+    ]:
+        if candidate is not None:
+            try:
+                return parse_version(candidate)
+            except ValueError as sys_version:
+                msg(key_path, sys_version)
+    return None
+
+
+def parse_version(version_str: Any) -> tuple[int | None, int | None, int | None]:  # noqa: ANN401
+    if isinstance(version_str, str):
+        if match := _VERSION_RE.match(version_str):
+            g1, g2, g3 = match.groups()
+            return (
+                int(g1) if g1 is not None else None,
+                int(g2) if g2 is not None else None,
+                int(g3) if g3 is not None else None,
+            )
+        error = f"invalid format {version_str}"
+    else:
+        error = f"version is not string: {version_str!r}"
+    raise ValueError(error)
+
+
+def load_threaded(hive_name: str, company: str, tag: str, tag_key: Any) -> bool:  # noqa: ANN401
+    display_name = get_value(tag_key, "DisplayName")
+    if display_name is not None:
+        if isinstance(display_name, str):
+            if "freethreaded" in display_name.lower():
+                return True
+        else:
+            key_path = f"{hive_name}/{company}/{tag}/DisplayName"
+            msg(key_path, f"display name is not string: {display_name!r}")
+    return bool(_THREADED_TAG_RE.match(tag))
+
+
+def msg(path: str, what: object) -> None:
+    _LOGGER.warning("PEP-514 violation in Windows Registry at %s error: %s", path, what)
+
+
+def _run() -> None:
+    basicConfig()
+    interpreters = [repr(spec) for spec in discover_pythons()]
+    sys.stdout.write("\n".join(sorted(interpreters)))
+    sys.stdout.write("\n")
+
+
+if __name__ == "__main__":
+    _run()

python_discovery/_windows/_propose.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from python_discovery._py_info import PythonInfo
+from python_discovery._py_spec import PythonSpec
+
+from ._pep514 import discover_pythons
+
+if TYPE_CHECKING:
+    from collections.abc import Generator, Mapping
+
+    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,
+        ),
+        reverse=True,
+    )
+
+    for name, major, minor, arch, threaded, exe, _ in existing:
+        implementation = _IMPLEMENTATION_BY_ORG.get(name, name)
+
+        skip_pre_filter = implementation.lower() != "cpython"
+        registry_spec = PythonSpec("", implementation, major, minor, None, arch, exe, free_threaded=threaded)
+        if skip_pre_filter or registry_spec.satisfies(spec):
+            interpreter = Pep514PythonInfo.from_exe(exe, cache, env=env, raise_on_error=False)
+            if interpreter is not None and interpreter.satisfies(spec, impl_must_match=True):
+                yield interpreter
+
+
+__all__ = [
+    "Pep514PythonInfo",
+    "propose_interpreters",
+]

python_discovery-1.0.0.dist-info/METADATA

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: python-discovery
+Version: 1.0.0
+Summary: Python interpreter discovery
+Project-URL: Changelog, https://github.com/tox-dev/python-discovery/releases
+Project-URL: Documentation, https://python-discovery.readthedocs.io
+Project-URL: Homepage, https://github.com/tox-dev/python-discovery
+Project-URL: Source, https://github.com/tox-dev/python-discovery
+Project-URL: Tracker, https://github.com/tox-dev/python-discovery/issues
+Maintainer-email: Bernát Gábor <gaborjbernat@gmail.com>
+License: Permission is hereby granted, free of charge, to any person obtaining a
+        copy of this software and associated documentation files (the
+        "Software"), to deal in the Software without restriction, including
+        without limitation the rights to use, copy, modify, merge, publish,
+        distribute, sublicense, and/or sell copies of the Software, and to
+        permit persons to whom the Software is furnished to do so, subject to
+        the following conditions:
+        
+        The above copyright notice and this permission notice shall be included
+        in all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+        OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+        MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+        IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+        CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+        TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+        SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+License-File: LICENSE
+Keywords: discovery,interpreter,python
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Requires-Dist: filelock>=3.15.4
+Requires-Dist: platformdirs<5,>=4.3.6
+Provides-Extra: docs
+Requires-Dist: furo>=2025.12.19; extra == 'docs'
+Requires-Dist: sphinx-autodoc-typehints>=3.6.3; extra == 'docs'
+Requires-Dist: sphinx>=9.1; extra == 'docs'
+Requires-Dist: sphinxcontrib-mermaid>=2; extra == 'docs'
+Provides-Extra: testing
+Requires-Dist: covdefaults>=2.3; extra == 'testing'
+Requires-Dist: coverage>=7.5.4; extra == 'testing'
+Requires-Dist: pytest-mock>=3.14; extra == 'testing'
+Requires-Dist: pytest>=8.3.5; extra == 'testing'
+Requires-Dist: setuptools>=75.1; extra == 'testing'
+Description-Content-Type: text/markdown
+
+# [`python-discovery`](https://python-discovery.readthedocs.io/en/latest/)
+
+[![PyPI](https://img.shields.io/pypi/v/python-discovery?style=flat-square)](https://pypi.org/project/python-discovery/)
+[![Supported Python
+versions](https://img.shields.io/pypi/pyversions/python-discovery.svg)](https://pypi.org/project/python-discovery/)
+[![Downloads](https://static.pepy.tech/badge/python-discovery/month)](https://pepy.tech/project/python-discovery)
+[![check](https://github.com/tox-dev/python-discovery/actions/workflows/check.yml/badge.svg)](https://github.com/tox-dev/python-discovery/actions/workflows/check.yml)
+[![Documentation Status](https://readthedocs.org/projects/python-discovery/badge/?version=latest)](https://python-discovery.readthedocs.io/en/latest/?badge=latest)

python_discovery-1.0.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+python_discovery/__init__.py,sha256=0uFXdlOPCzMeqnwpyYglvqxs64P_PpidbwIzdWJEroc,483
+python_discovery/_cache.py,sha256=gQT6iqLj0-JF_lVDYsi0n05t9RekM7RWbUb0SfFCN5s,4159
+python_discovery/_cached_py_info.py,sha256=1u90GMe9uSfFh5jFFKMy3M0PXee89217mAjPE2wlJSA,8309
+python_discovery/_compat.py,sha256=iqxGuhK9rPaiui80G1H1KrweoMJ16gyLYEmUrSXrp5c,709
+python_discovery/_discovery.py,sha256=z4nVspl0L0_5NiRVut_us9kbWDtXnkzsLBSM7RaL-mU,11236
+python_discovery/_py_info.py,sha256=T6RJEewEi2aVC6MJOMv2e3Xor4d55M5YUAXY6Idi2sA,30807
+python_discovery/_py_spec.py,sha256=VsHl6k_SwiZlviUk3KcSn9D83_ersKqs8OBiRcztucc,8385
+python_discovery/_specifier.py,sha256=gLaqTrZhp2woUSYHpZayLqfpgTn9914ZM3WPXC8AKMM,8744
+python_discovery/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_discovery/_windows/__init__.py,sha256=qthcyGh36b3WkeSbZ4ECRRYLbCOCaQu5X_DRZ98tXfk,315
+python_discovery/_windows/_pep514.py,sha256=JYSQ5tOYbSMOKtVVfOEkyYskBhEoTsImNr3DJcv7XNE,7658
+python_discovery/_windows/_propose.py,sha256=iMJf6l0TU4SvuV8UsCHHINAe9L5dUT949xyeyMVdong,1565
+python_discovery-1.0.0.dist-info/METADATA,sha256=JqrmW6S_Jxb0qUk--KSpfwaYTuiBOEIdGbTdyN87F50,4022
+python_discovery-1.0.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+python_discovery-1.0.0.dist-info/licenses/LICENSE,sha256=kOJeH68qSq6o2V7o5_VziwUqGswMnFgGgQH5Mahr1Yg,1023
+python_discovery-1.0.0.dist-info/RECORD,,

python_discovery-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

python_discovery-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,18 @@
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.