python-discovery 1.4.4__py3-none-any.whl → 1.5.1__py3-none-any.whl

python_discovery/_cache.py

@@ -104,7 +104,7 @@ class DiskContentStore:
 
     @contextmanager
     def locked(self) -> Generator[None]:
-        from filelock import FileLock  # noqa: PLC0415
+        from filelock import FileLock  # ruff:ignore[import-outside-top-level]
 
         lock_path = self._folder / f"{self._key}.lock"
         lock_path.parent.mkdir(parents=True, exist_ok=True)
@@ -148,10 +148,10 @@ class DiskCache:
 class NoOpContentStore(ContentStore):
     """Content store that does nothing -- implements ContentStore protocol."""
 
-    def exists(self) -> bool:  # noqa: PLR6301
+    def exists(self) -> bool:  # ruff:ignore[no-self-use]
         return False
 
-    def read(self) -> dict | None:  # noqa: PLR6301
+    def read(self) -> dict | None:  # ruff:ignore[no-self-use]
         return None
 
     def write(self, content: dict) -> None:
@@ -161,14 +161,14 @@ class NoOpContentStore(ContentStore):
         pass
 
     @contextmanager
-    def locked(self) -> Generator[None]:  # noqa: PLR6301
+    def locked(self) -> Generator[None]:  # ruff:ignore[no-self-use]
         yield
 
 
 class NoOpCache(PyInfoCache):
     """Cache that does nothing -- implements PyInfoCache protocol."""
 
-    def py_info(self, path: Path) -> NoOpContentStore:  # noqa: ARG002, PLR6301
+    def py_info(self, path: Path) -> NoOpContentStore:  # ruff:ignore[unused-method-argument, no-self-use]
         return NoOpContentStore()
 
     def py_info_clear(self) -> None:

python_discovery/_cached_py_info.py

@@ -8,14 +8,14 @@ import logging
 import os
 import pkgutil
 import secrets
-import subprocess  # noqa: S404
+import subprocess  # ruff:ignore[suspicious-subprocess-import]
 import sys
 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 subprocess import Popen, TimeoutExpired  # ruff:ignore[suspicious-subprocess-import]
 from typing import TYPE_CHECKING, Final
 
 from ._cache import NoOpCache
@@ -32,7 +32,7 @@ _CACHE[Path(sys.executable)] = PythonInfo()
 _LOGGER: Final[logging.Logger] = logging.getLogger(__name__)
 
 
-def from_exe(  # noqa: PLR0913
+def from_exe(  # ruff:ignore[too-many-arguments]
     cls: type[PythonInfo],
     cache: PyInfoCache | None,
     exe: str,
@@ -197,7 +197,7 @@ def _run_subprocess(
         env["PYTHONUTF8"] = "1"
         _LOGGER.debug("get interpreter info via cmd: %s", LogCmd(cmd))
         try:
-            process = Popen(  # noqa: S603
+            process = Popen(  # ruff:ignore[subprocess-without-shell-equals-true]
                 cmd,
                 universal_newlines=True,
                 stdin=subprocess.PIPE,

python_discovery/_discovery.py

@@ -4,14 +4,14 @@ import logging
 import os
 import sys
 from contextlib import suppress
+from dataclasses import dataclass
 from pathlib import Path
 from typing import TYPE_CHECKING, Final
 
-from platformdirs import user_data_path
-
 from ._compat import fs_path_id
 from ._py_info import PythonInfo
 from ._py_spec import PythonSpec
+from ._specifier import DC_KW, SimpleVersion
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Generator, Iterable, Iterator, Mapping, Sequence
@@ -89,7 +89,7 @@ def iter_interpreters(
         yield from _iter_for_spec(spec_str, first_with, cache, env_map, predicate, seen)
 
 
-def _iter_for_spec(  # noqa: PLR0913, PLR0917
+def _iter_for_spec(  # ruff:ignore[too-many-arguments, too-many-positional-arguments]
     spec_str: str | None,
     try_first_with: tuple[str, ...],
     cache: PyInfoCache | None,
@@ -199,7 +199,7 @@ def propose_interpreters(
     if spec.path is not None and spec.is_abs:  # pragma: no cover # relative spec.path is never abs
         return
     yield from _propose_from_path(spec, cache, env, tested_exes, all_implementations=all_implementations)
-    yield from _propose_from_uv(cache, env, all_implementations=all_implementations)
+    yield from _propose_from_uv(spec, cache, env, all_implementations=all_implementations)
 
 
 def _propose_explicit(
@@ -231,7 +231,7 @@ def _propose_current_and_windows(
         yield current_python, True
 
     if IS_WIN:  # pragma: win32 cover
-        from ._windows import propose_interpreters as win_propose  # noqa: PLC0415
+        from ._windows import propose_interpreters as win_propose  # ruff:ignore[import-outside-top-level]
 
         for interpreter in win_propose(spec, cache, env):
             if _is_new_exe(str(interpreter.executable), tested_exes):
@@ -262,30 +262,157 @@ def _propose_from_path(
 
 
 def _propose_from_uv(
+    spec: PythonSpec,
     cache: PyInfoCache | None,
     env: Mapping[str, str],
     *,
     all_implementations: bool = False,
 ) -> Generator[tuple[PythonInfo | None, bool], None, None]:
-    if uv_python_dir := os.getenv("UV_PYTHON_INSTALL_DIR"):
-        uv_python_path = Path(uv_python_dir).expanduser()
-    elif xdg_data_home := os.getenv("XDG_DATA_HOME"):
-        uv_python_path = Path(xdg_data_home).expanduser() / "uv" / "python"
+    seen_uv_paths: set[str] = set()
+    for root in _uv_python_roots(env):
+        for install in _uv_installs(root, spec, all_implementations=all_implementations):
+            for exe_path in _uv_executables(install):
+                if (resolved := str(exe_path.resolve())) in seen_uv_paths:
+                    continue
+                seen_uv_paths.add(resolved)
+                if interpreter := PathPythonInfo.from_exe(str(exe_path), cache, raise_on_error=False, env=env):
+                    yield interpreter, True
+                    break  # one install directory holds one interpreter
+
+
+def _uv_python_roots(env: Mapping[str, str]) -> Generator[Path, None, None]:
+    """Yield uv's store roots, legacy first; searching both keeps a stale legacy directory from hiding the live one."""
+    if install_dir := env.get("UV_PYTHON_INSTALL_DIR"):
+        yield Path(install_dir).expanduser()
+        return
+    for state_dir in _uv_state_dirs(env):
+        yield state_dir / "python"
+
+
+def _uv_state_dirs(env: Mapping[str, str]) -> Generator[Path, None, None]:
+    """Yield uv's legacy state directory then its current one, the order uv prefers them in."""
+    windows = sys.platform == "win32"
+    home = Path(env.get("USERPROFILE" if windows else "HOME") or "~").expanduser()
+    if windows:
+        app_data = Path(env["APPDATA"]) if "APPDATA" in env else home / "AppData" / "Roaming"
+        yield app_data / "uv" / "data"
+        yield app_data / "uv"
+        return
+    if sys.platform == "darwin":
+        yield home / "Library" / "Application Support" / "uv"
+    # uv ignores a relative XDG_DATA_HOME, as the XDG specification requires
+    if (xdg_data_home := env.get("XDG_DATA_HOME")) and (xdg := Path(xdg_data_home)).is_absolute():
+        yield xdg / "uv"
     else:
-        uv_python_path = user_data_path("uv") / "python"
+        yield home / ".local" / "share" / "uv"
 
-    patterns: list[str] = ["*/bin/python", "*/python.exe"]
-    if all_implementations:
-        patterns.extend(("*/bin/pypy*", "*/bin/graalpy", "*/pypy*.exe", "*/bin/graalpy.exe"))
-    seen_uv_paths: set[str] = set()
-    for pattern in patterns:
-        for exe_path in uv_python_path.glob(pattern):
-            resolved = str(Path(exe_path).resolve())
-            if resolved in seen_uv_paths:
-                continue
-            seen_uv_paths.add(resolved)
-            if interpreter := PathPythonInfo.from_exe(str(exe_path), cache, raise_on_error=False, env=env):
-                yield interpreter, True
+
+def _uv_installs(root: Path, spec: PythonSpec, *, all_implementations: bool) -> list[_UvInstall]:
+    try:
+        matching = [
+            install
+            for entry in sorted(root.iterdir())
+            if not entry.name.startswith(".")
+            and entry.is_dir()
+            and _uv_install_matches(install := _parse_uv_install(entry), spec, all_implementations=all_implementations)
+        ]
+    except OSError:
+        return []
+    matching.sort(key=_uv_sort_key)  # stable, so equally ranked installs stay in directory name order
+    return matching
+
+
+def _parse_uv_install(path: Path) -> _UvInstall:
+    implementation, _, remainder = path.name.partition("-")
+    version_str, _, variant = remainder.partition("-")[0].partition("+")
+    try:
+        version = SimpleVersion.from_string(version_str)
+    except ValueError:  # not a uv key, but the directory may still hold an interpreter worth probing
+        return _UvInstall(path=path, key=None)
+    variants = variant.split("+")
+    key = _UvKey(
+        implementation=implementation.lower(),
+        version=version,
+        free_threaded="freethreaded" in variants,
+        debug="debug" in variants,
+    )
+    return _UvInstall(path=path, key=key)
+
+
+@dataclass(**DC_KW)
+class _UvKey:
+    """The ``<implementation>-<version>[+<variant>]-<os>-<arch>-<libc>`` name uv gives an install directory."""
+
+    implementation: str
+    version: SimpleVersion
+    free_threaded: bool
+    debug: bool
+
+
+@dataclass(**DC_KW)
+class _UvInstall:
+    path: Path
+    key: _UvKey | None
+
+
+def _uv_install_matches(install: _UvInstall, spec: PythonSpec, *, all_implementations: bool) -> bool:
+    if (key := install.key) is None:
+        return True
+    if spec.implementation is not None:
+        if spec.implementation.lower() != key.implementation:
+            return False
+    elif not all_implementations and key.implementation != "cpython":
+        # uv resolves a bare `3.8` to `cpython-3.8`; on PATH the equivalent probe finds CPython too
+        return False
+    if spec.free_threaded is not None and spec.free_threaded != key.free_threaded:
+        return False
+    if spec.debug is not None and spec.debug != key.debug:
+        return False
+    return _uv_version_matches(key, spec)
+
+
+def _uv_version_matches(key: _UvKey, spec: PythonSpec) -> bool:
+    # GraalPy keys carry the GraalVM version in older uv releases, so only CPython and PyPy state a Python version
+    if key.implementation not in {"cpython", "pypy"}:
+        return True
+    if spec.version_specifier is not None and not spec.version_specifier.contains(str(key.version)):
+        return False
+    return all(req is None or our == req for our, req in zip(key.version.release, (spec.major, spec.minor, spec.micro)))
+
+
+def _uv_sort_key(install: _UvInstall) -> tuple[int, ...]:
+    """Rank like uv does: CPython first, newest version first, default build ahead of free-threaded and debug."""
+    impl_order: Final[tuple[str, ...]] = ("cpython", "pypy", "graalpy", "pyodide")
+    if (key := install.key) is None:
+        return (len(impl_order) + 1,)
+    version = key.version
+    return (
+        impl_order.index(key.implementation) if key.implementation in impl_order else len(impl_order),
+        # uv's minor version links point at a concrete install that moves on upgrade, so report the target instead
+        int(install.path.is_symlink()),
+        -version.major,
+        -version.minor,
+        -version.micro,
+        -{"a": 0, "b": 1, "rc": 2, None: 3}[version.pre_type],
+        -(version.pre_num or 0),
+        int(key.free_threaded),
+        int(key.debug),
+    )
+
+
+def _uv_executables(install: _UvInstall) -> Generator[Path, None, None]:
+    # some distributions unpack into an `install` subdirectory, which uv resolves the same way
+    base = nested if (nested := install.path / "install").is_dir() else install.path
+    for pattern in (
+        "bin/python",
+        "python.exe",
+        "bin/pypy*",
+        "pypy*.exe",
+        "bin/graalpy",
+        "bin/graalpy.exe",
+        "python*t.exe",  # free-threaded Windows builds that ship no python.exe (astral-sh/uv#8298)
+    ):
+        yield from sorted(base.glob(pattern))
 
 
 def get_paths(env: Mapping[str, str]) -> Generator[Path, None, None]:

python_discovery/_py_info.py

@@ -49,7 +49,7 @@ _CONF_VAR_RE: Final[re.Pattern[str]] = re.compile(
 )
 
 
-class PythonInfo:  # noqa: PLR0904
+class PythonInfo:  # ruff:ignore[too-many-public-methods]
     """Contains information for a Python interpreter."""
 
     def __init__(self) -> None:
@@ -161,7 +161,7 @@ class PythonInfo:  # noqa: PLR0904
         """Detect the tcl and tk libraries using tkinter."""
         tcl_lib, tk_lib = None, None
         try:
-            import tkinter as tk  # noqa: PLC0415
+            import tkinter as tk  # ruff:ignore[import-outside-top-level]
         except ImportError:
             pass
         else:
@@ -177,7 +177,7 @@ class PythonInfo:  # noqa: PLR0904
     @staticmethod
     def _query_tk_library(tcl: tk.Tk) -> str | None:  # pragma: no cover
         """Try to get the TK library path directly from Tcl."""
-        import tkinter as tk  # noqa: PLC0415
+        import tkinter as tk  # ruff:ignore[import-outside-top-level]
 
         try:
             if (tk_lib := tcl.eval("set tk_library")) and os.path.isdir(tk_lib):
@@ -303,8 +303,11 @@ class PythonInfo:  # noqa: PLR0904
         with warnings.catch_warnings():  # disable warning for PEP-632
             warnings.simplefilter("ignore")
             try:
-                from distutils import dist  # noqa: PLC0415  # ty: ignore[unresolved-import]
-                from distutils.command.install import SCHEME_KEYS  # noqa: PLC0415  # ty: ignore[unresolved-import]
+                # ruff:ignore[import-outside-top-level]
+                from distutils import dist  # ty: ignore[unresolved-import]
+
+                # ruff:ignore[import-outside-top-level]
+                from distutils.command.install import SCHEME_KEYS  # ty: ignore[unresolved-import]
             except ImportError:  # pragma: no cover # if removed or not installed ignore
                 return {}
 
@@ -312,7 +315,7 @@ class PythonInfo:  # noqa: PLR0904
             "script_args": "--no-user-cfg",
         })  # conf files not parsed so they do not hijack paths
         if hasattr(sys, "_framework"):  # pragma: no cover # macOS framework builds only
-            sys._framework = None  # noqa: SLF001  # disable macOS static paths for framework
+            sys._framework = None  # ruff:ignore[private-member-access]  # disable macOS static paths for framework
 
         with warnings.catch_warnings():  # disable warning for PEP-632
             warnings.simplefilter("ignore")
@@ -459,12 +462,12 @@ class PythonInfo:  # noqa: PLR0904
 
         :param cache: the cache store to clear.
         """
-        from ._cached_py_info import clear  # noqa: PLC0415
+        from ._cached_py_info import clear  # ruff:ignore[import-outside-top-level]
 
         clear(cache)
         cls._cache_exe_discovery.clear()
 
-    def satisfies(self, spec: PythonSpec, *, impl_must_match: bool) -> bool:  # noqa: PLR0911
+    def satisfies(self, spec: PythonSpec, *, impl_must_match: bool) -> bool:  # ruff:ignore[too-many-return-statements]
         """
         Check if a given specification can be satisfied by this python interpreter instance.
 
@@ -510,7 +513,7 @@ class PythonInfo:  # noqa: PLR0904
             return True
         version_info = self.version_info
         for specifier in spec.version_specifier:
-            assert specifier.version is not None  # noqa: S101
+            assert specifier.version is not None  # ruff:ignore[assert]
             numeric_version = specifier.version_str
             for prefix in ("rc", "b", "a"):
                 if prefix in numeric_version:
@@ -520,7 +523,7 @@ class PythonInfo:  # noqa: PLR0904
             release = ".".join(str(c) for c in [version_info.major, version_info.minor, version_info.micro][:precision])
             if (
                 version_info.releaselevel != "final"
-                and (precision == 3 or specifier.version.pre_type is not None)  # noqa: PLR2004
+                and (precision == 3 or specifier.version.pre_type is not None)  # ruff:ignore[magic-value-comparison]
                 and (suffix := {"alpha": "a", "beta": "b", "candidate": "rc"}.get(version_info.releaselevel))
             ):
                 release = f"{release}{suffix}{version_info.serial}"
@@ -573,7 +576,7 @@ class PythonInfo:  # noqa: PLR0904
         return data
 
     @classmethod
-    def from_exe(  # noqa: PLR0913
+    def from_exe(  # ruff:ignore[too-many-arguments]
         cls,
         exe: str,
         cache: PyInfoCache | None = None,
@@ -593,7 +596,7 @@ class PythonInfo:  # noqa: PLR0904
         :param resolve_to_host: resolve through virtualenv layers to the system interpreter.
         :param env: environment mapping; defaults to :data:`os.environ`.
         """
-        from ._cached_py_info import from_exe  # noqa: PLC0415
+        from ._cached_py_info import from_exe  # ruff:ignore[import-outside-top-level]
 
         env = os.environ if env is None else env
         proposed = from_exe(cls, cache, exe, env=env, raise_on_error=raise_on_error, ignore_cache=ignore_cache)
@@ -703,7 +706,7 @@ class PythonInfo:  # noqa: PLR0904
         msg = "failed to detect {} in {}".format("|".join(possible_names), os.pathsep.join(possible_folders))
         raise RuntimeError(msg)
 
-    def _check_exe(  # noqa: PLR0913
+    def _check_exe(  # ruff:ignore[too-many-arguments]
         self,
         cache: PyInfoCache | None,
         folder: str,
@@ -797,7 +800,7 @@ class PythonInfo:  # noqa: PLR0904
         for base in possible_base:
             lower = base.lower()
             yield lower
-            from ._compat import fs_is_case_sensitive  # noqa: PLC0415
+            from ._compat import fs_is_case_sensitive  # ruff:ignore[import-outside-top-level]
 
             if fs_is_case_sensitive():  # pragma: no branch
                 if base != lower:

python_discovery/_py_spec.py

@@ -55,7 +55,7 @@ def _parse_version_parts(version: str) -> tuple[int | None, int | None, int | No
         raise ValueError(msg)
     if len(versions) == _MAX_VERSION_PARTS:
         return versions[0], versions[1], versions[2]
-    if len(versions) == 2:  # noqa: PLR2004
+    if len(versions) == 2:  # ruff:ignore[magic-value-comparison]
         return versions[0], versions[1], None
     version_data = versions[0]
     major = int(str(version_data)[0])
@@ -127,7 +127,7 @@ class PythonSpec:
         constraints, or ``None``.
     """
 
-    def __init__(  # noqa: PLR0913, PLR0917
+    def __init__(  # ruff:ignore[too-many-arguments, too-many-positional-arguments]
         self,
         str_spec: str,
         implementation: str | None,
@@ -233,7 +233,7 @@ class PythonSpec:
             return len(item.version.release)
         return None
 
-    def satisfies(self, spec: PythonSpec) -> bool:  # noqa: PLR0911
+    def satisfies(self, spec: PythonSpec) -> bool:  # ruff:ignore[too-many-return-statements]
         """
         Check if this spec is compatible with the given *spec* (e.g. PEP-514 on Windows).
 

python_discovery/_specifier.py

@@ -9,7 +9,9 @@ import sys
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Final
 
-_DC_KW = {"frozen": True, "kw_only": True, "slots": True} if sys.version_info >= (3, 10) else {"frozen": True}
+DC_KW: Final[dict[str, bool]] = (
+    {"frozen": True, "kw_only": True, "slots": True} if sys.version_info >= (3, 10) else {"frozen": True}
+)
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -38,7 +40,7 @@ _SPECIFIER_RE: Final[re.Pattern[str]] = re.compile(
 _PRE_ORDER: Final[dict[str, int]] = {"a": 1, "b": 2, "rc": 3}
 
 
-@dataclass(**_DC_KW)
+@dataclass(**DC_KW)
 class SimpleVersion:
     """
     Simple PEP 440-like version parser using only standard library.
@@ -92,7 +94,7 @@ class SimpleVersion:
     def __hash__(self) -> int:
         return hash((self.release, self.pre_type, self.pre_num))
 
-    def __lt__(self, other: object) -> bool:  # noqa: PLR0911
+    def __lt__(self, other: object) -> bool:  # ruff:ignore[too-many-return-statements]
         if not isinstance(other, SimpleVersion):
             return NotImplemented
         if self.release != other.release:
@@ -125,7 +127,7 @@ class SimpleVersion:
         return f"SimpleVersion('{self.version_str}')"
 
 
-@dataclass(**_DC_KW)
+@dataclass(**DC_KW)
 class SimpleSpecifier:
     """
     Simple PEP 440-like version specifier using only standard library.
@@ -225,7 +227,7 @@ class SimpleSpecifier:
             return False
         if candidate < self.version:
             return False
-        if len(self.version.release) >= 2:  # noqa: PLR2004  # pragma: no branch # SimpleVersion always has 3-part release
+        if len(self.version.release) >= 2:  # ruff:ignore[magic-value-comparison]  # pragma: no branch # SimpleVersion always has 3-part release
             upper_parts = list(self.version.release[:-1])
             upper_parts[-1] += 1
             upper = SimpleVersion.from_string(".".join(str(p) for p in upper_parts))
@@ -247,7 +249,7 @@ class SimpleSpecifier:
         return f"SimpleSpecifier('{self.spec_str}')"
 
 
-@dataclass(**_DC_KW)
+@dataclass(**DC_KW)
 class SimpleSpecifierSet:
     """
     Simple PEP 440-like specifier set using only standard library.
@@ -305,6 +307,7 @@ class SimpleSpecifierSet:
 
 
 __all__ = [
+    "DC_KW",
     "SimpleSpecifier",
     "SimpleSpecifierSet",
     "SimpleVersion",

python_discovery/_windows/_pep514.py

@@ -47,7 +47,7 @@ _THREADED_TAG_RE: Final[re.Pattern[str]] = re.compile(
 )
 
 
-def enum_keys(key: Any) -> Generator[str, None, None]:  # noqa: ANN401
+def enum_keys(key: Any) -> Generator[str, None, None]:  # ruff:ignore[any-type]
     at = 0
     while True:
         try:
@@ -57,7 +57,7 @@ def enum_keys(key: Any) -> Generator[str, None, None]:  # noqa: ANN401
         at += 1
 
 
-def get_value(key: Any, value_name: str | None) -> Any:  # noqa: ANN401
+def get_value(key: Any, value_name: str | None) -> Any:  # ruff:ignore[any-type]
     try:
         return winreg.QueryValueEx(key, value_name)[0]  # ty: ignore[unresolved-attribute]
     except OSError:
@@ -93,7 +93,7 @@ def process_set(
 def process_company(
     hive_name: str,
     company: str,
-    root_key: Any,  # noqa: ANN401
+    root_key: Any,  # ruff:ignore[any-type]
     default_arch: int,
 ) -> Generator[_RegistrySpec, None, None]:
     with winreg.OpenKeyEx(root_key, company) as company_key:  # ty: ignore[unresolved-attribute]
@@ -103,7 +103,7 @@ def process_company(
                 yield spec
 
 
-def process_tag(hive_name: str, company: str, company_key: Any, tag: str, default_arch: int) -> _RegistrySpec | None:  # noqa: ANN401
+def process_tag(hive_name: str, company: str, company_key: Any, tag: str, default_arch: int) -> _RegistrySpec | None:  # ruff:ignore[any-type]
     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
@@ -120,7 +120,7 @@ def process_tag(hive_name: str, company: str, company_key: Any, tag: str, defaul
         return None
 
 
-def load_exe(hive_name: str, company: str, company_key: Any, tag: str) -> tuple[str, str | None] | None:  # noqa: ANN401
+def load_exe(hive_name: str, company: str, company_key: Any, tag: str) -> tuple[str, str | None] | None:  # ruff:ignore[any-type]
     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]
@@ -132,7 +132,7 @@ def load_exe(hive_name: str, company: str, company_key: Any, tag: str) -> tuple[
     return None
 
 
-def _resolve_exe(ip_key: Any, key_path: str) -> str | None:  # noqa: ANN401
+def _resolve_exe(ip_key: Any, key_path: str) -> str | None:  # ruff:ignore[any-type]
     if (exe := get_value(ip_key, "ExecutablePath")) is not None:
         return exe
     if (ip := get_value(ip_key, None)) is None:
@@ -141,7 +141,7 @@ def _resolve_exe(ip_key: Any, key_path: str) -> str | None:  # noqa: ANN401
     return os.path.join(ip, "python.exe")
 
 
-def load_arch_data(hive_name: str, company: str, tag: str, tag_key: Any, default_arch: int) -> int | None:  # noqa: ANN401
+def load_arch_data(hive_name: str, company: str, tag: str, tag_key: Any, default_arch: int) -> int | None:  # ruff:ignore[any-type]
     arch_str = get_value(tag_key, "SysArchitecture")
     if arch_str is not None:
         key_path = f"{hive_name}/{company}/{tag}/SysArchitecture"
@@ -152,7 +152,7 @@ def load_arch_data(hive_name: str, company: str, tag: str, tag_key: Any, default
     return default_arch
 
 
-def parse_arch(arch_str: Any) -> int:  # noqa: ANN401
+def parse_arch(arch_str: Any) -> int:  # ruff:ignore[any-type]
     if isinstance(arch_str, str):
         if match := _ARCH_RE.match(arch_str):
             return int(next(iter(match.groups())))
@@ -166,7 +166,7 @@ def load_version_data(
     hive_name: str,
     company: str,
     tag: str,
-    tag_key: Any,  # noqa: ANN401
+    tag_key: Any,  # ruff:ignore[any-type]
 ) -> tuple[int | None, int | None, int | None] | None:
     for candidate, key_path in [
         (get_value(tag_key, "SysVersion"), f"{hive_name}/{company}/{tag}/SysVersion"),
@@ -180,7 +180,7 @@ def load_version_data(
     return None
 
 
-def parse_version(version_str: Any) -> tuple[int | None, int | None, int | None]:  # noqa: ANN401
+def parse_version(version_str: Any) -> tuple[int | None, int | None, int | None]:  # ruff:ignore[any-type]
     if isinstance(version_str, str):
         if match := _VERSION_RE.match(version_str):
             g1, g2, g3 = match.groups()
@@ -195,7 +195,7 @@ def parse_version(version_str: Any) -> tuple[int | None, int | None, int | None]
     raise ValueError(error)
 
 
-def load_threaded(hive_name: str, company: str, tag: str, tag_key: Any) -> bool:  # noqa: ANN401
+def load_threaded(hive_name: str, company: str, tag: str, tag_key: Any) -> bool:  # ruff:ignore[any-type]
     display_name = get_value(tag_key, "DisplayName")
     if display_name is not None:
         if isinstance(display_name, str):

{python_discovery-1.4.4.dist-info → python_discovery-1.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-discovery
-Version: 1.4.4
+Version: 1.5.1
 Summary: Python interpreter discovery
 Project-URL: Changelog, https://github.com/tox-dev/python-discovery/releases
 Project-URL: Documentation, https://python-discovery.readthedocs.io
@@ -42,25 +42,12 @@ 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 :: 3.15
 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'
-Requires-Dist: sphinxcontrib-towncrier>=0.4; extra == 'docs'
-Requires-Dist: towncrier>=25.8; 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/)

python_discovery-1.5.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+python_discovery/__init__.py,sha256=Hi4j3pMvC8Fo8KoNL-wOHsPSCUHwY4c0qvv5sjnFzME,808
+python_discovery/_cache.py,sha256=svmG2GzUQzd2xTjAbm2eX1CKxxGAglfv4kxaPuxwPIA,5147
+python_discovery/_cached_py_info.py,sha256=l9Y9UJGjKjp4M7iR9HfXYzW3hWdQ3KyNOD5IbSEphLw,8659
+python_discovery/_compat.py,sha256=iqxGuhK9rPaiui80G1H1KrweoMJ16gyLYEmUrSXrp5c,709
+python_discovery/_discovery.py,sha256=ABPD8MRweUO6B7cG3U3ZBfUIYs08rh6dYPA225EURyY,22032
+python_discovery/_py_info.py,sha256=sXsOX4epGDRhrLvEcpDThh3r1yKMf5KZVaF2ZegoSOA,37311
+python_discovery/_py_spec.py,sha256=O1RMC9JQ7m5SRzF6cEELxnIWZpadXYWO4bWDD7TemUs,10965
+python_discovery/_specifier.py,sha256=o7MHb0z_mFSLz9gXqMwJoNkHYjgi2biq3Ibvd0_slvc,10457
+python_discovery/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_discovery/_windows/__init__.py,sha256=qthcyGh36b3WkeSbZ4ECRRYLbCOCaQu5X_DRZ98tXfk,315
+python_discovery/_windows/_pep514.py,sha256=1TqLTdofSCPu3VFE7D4u2fXweyaqhKJR7b48VmJ9AQQ,7787
+python_discovery/_windows/_propose.py,sha256=iMJf6l0TU4SvuV8UsCHHINAe9L5dUT949xyeyMVdong,1565
+python_discovery-1.5.1.dist-info/METADATA,sha256=DWitu_0XNhVQusKTT4aIXioAlImTpg-XH4Yp5ZhHbRc,4980
+python_discovery-1.5.1.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+python_discovery-1.5.1.dist-info/licenses/LICENSE,sha256=kOJeH68qSq6o2V7o5_VziwUqGswMnFgGgQH5Mahr1Yg,1023
+python_discovery-1.5.1.dist-info/RECORD,,

python_discovery-1.4.4.dist-info/RECORD

@@ -1,16 +0,0 @@
-python_discovery/__init__.py,sha256=Hi4j3pMvC8Fo8KoNL-wOHsPSCUHwY4c0qvv5sjnFzME,808
-python_discovery/_cache.py,sha256=bG4fD-h2pdPmb4v9BldbXmJ5Tlt1boiH1Qrz8kp9Dds,5063
-python_discovery/_cached_py_info.py,sha256=1AFEoc_-OaCi1PXmaFz9Iy_bEuqOhJdFSDFHljzD-EE,8540
-python_discovery/_compat.py,sha256=iqxGuhK9rPaiui80G1H1KrweoMJ16gyLYEmUrSXrp5c,709
-python_discovery/_discovery.py,sha256=cdo6xlktNMEwsQn2R8pn4T1VDE4LD2EJPUyCT7vlHnM,16830
-python_discovery/_py_info.py,sha256=fFhS-gZoYIJYscqM56h1RwFknJou8bgf3h8VXrqm5g8,36974
-python_discovery/_py_spec.py,sha256=FN7nsWOkxdFpmd5st5hz5e2f7egbLzzbRiNiBndAYZc,10877
-python_discovery/_specifier.py,sha256=PTh6suNTC0hMnFSxFYF_vggdciFLnwxoh1YflSbgCXA,10368
-python_discovery/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_discovery/_windows/__init__.py,sha256=qthcyGh36b3WkeSbZ4ECRRYLbCOCaQu5X_DRZ98tXfk,315
-python_discovery/_windows/_pep514.py,sha256=zXxje07QIXfrCB3eYbZHOBgXcvAQQpZ-ZWun3_zrapA,7688
-python_discovery/_windows/_propose.py,sha256=iMJf6l0TU4SvuV8UsCHHINAe9L5dUT949xyeyMVdong,1565
-python_discovery-1.4.4.dist-info/METADATA,sha256=15xJaaopcuujqLtLazKC4ZadMMCtHPWntqISeeYMFCQ,5592
-python_discovery-1.4.4.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-python_discovery-1.4.4.dist-info/licenses/LICENSE,sha256=kOJeH68qSq6o2V7o5_VziwUqGswMnFgGgQH5Mahr1Yg,1023
-python_discovery-1.4.4.dist-info/RECORD,,