🔧 chore: switch to ty and fix CI failures

CI was failing due to shim tests assuming from_exe is called exactly once
(UV_PYTHON_INSTALL_DIR adds extra binaries in CI) and pyright type errors
across the codebase.

Switched to ty (Astral's type checker) to match the pytest-env pattern,
fixed all type errors, applied walrus operators where they simplify code,
and ensured 100% coverage holds.

Author: gaborbernat

pyproject.toml

@@ -129,6 +129,10 @@ lint.isort = { known-first-party = [
 ] }
 lint.preview = true
 
+[tool.ty]
+environment.python-version = "3.14"
+src.exclude = ["tests/windows/winreg_mock_values.py"]
+
 [tool.codespell]
 builtin = "clear,usage,en-GB_to_en-US"
 write-changes = true

src/py_discovery/_builtin.py

@@ -59,6 +59,8 @@ def get_interpreter(
     proposed_paths = 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
         key = interpreter.system_executable, impl_must_match
         if key in proposed_paths:
             continue
@@ -75,7 +77,7 @@ def propose_interpreters(
     try_first_with: Iterable[str],
     cache: PyInfoCache | None = None,
     env: Mapping[str, str] | None = None,
-) -> Generator[tuple[PythonInfo, bool], None, None]:
+) -> Generator[tuple[PythonInfo | None, bool], None, None]:
     env = os.environ if env is None else env
     tested_exes: set[str] = set()
     if spec.is_abs and spec.path is not None:

src/py_discovery/_py_info.py

@@ -48,7 +48,7 @@ def abs_path(v):
         self.platform = sys.platform
         self.implementation = platform.python_implementation()
         if self.implementation == "PyPy":
-            self.pypy_version_info = tuple(sys.pypy_version_info)  # ty: ignore[unresolved-attribute]
+            self.pypy_version_info = tuple(sys.pypy_version_info)  # ty: ignore[unresolved-attribute] # pypy only
 
         # this is a tuple in earlier, struct later, unify to our own named tuple
         self.version_info = VersionInfo(*sys.version_info)
@@ -281,7 +281,7 @@ def _distutils_install():
         with warnings.catch_warnings():  # disable warning for PEP-632
             warnings.simplefilter("ignore")
             try:
-                from distutils import (  # ty: ignore[unresolved-import] - setuptools provides distutils on 3.12+
+                from distutils import (  # ty: ignore[unresolved-import]
                     dist,
                 )
                 from distutils.command.install import (  # ty: ignore[unresolved-import]
@@ -298,7 +298,7 @@ def _distutils_install():
             warnings.simplefilter("ignore")
             i = d.get_command_obj("install", create=True)
 
-        i.prefix = os.sep  # paths generated are relative to prefix that contains the path sep, this makes it relative
+        i.prefix = os.sep  # paths generated are relative to prefix that contains the path sep
         i.finalize_options()
         return {key: (getattr(i, f"install_{key}")[1:]).lstrip(os.sep) for key in SCHEME_KEYS}
 

src/py_discovery/_py_spec.py

@@ -68,8 +68,7 @@ def from_string_spec(cls, string_spec: str) -> PythonSpec:
             path = string_spec
         else:
             ok = False
-            match = re.match(PATTERN, string_spec)
-            if match:
+            if match := re.match(PATTERN, string_spec):
 
                 def _int_or_none(val):
                     return None if val is None else int(val)
@@ -103,8 +102,7 @@ def _int_or_none(val):
                         machine = normalize_isa(machine)
 
             if not ok:
-                specifier_match = SPECIFIER_PATTERN.match(string_spec.strip())
-                if specifier_match and SpecifierSet is not None:
+                if (specifier_match := SPECIFIER_PATTERN.match(string_spec.strip())) and SpecifierSet is not None:
                     impl = specifier_match.group("impl")
                     spec_text = specifier_match.group("spec").strip()
                     try:

src/py_discovery/_specifier.py

@@ -18,11 +18,12 @@ def __init__(self, version_str: str) -> None:
         self.version_str = version_str
         # Parse version string into components
         # Support formats like: "3.11", "3.11.0", "3.11.0a1", "3.11.0b2", "3.11.0rc1"
-        match = re.match(
-            r"^(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:(a|b|rc)(\d+))?$",
-            version_str.strip(),
-        )
-        if not match:
+        if not (
+            match := re.match(
+                r"^(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:(a|b|rc)(\d+))?$",
+                version_str.strip(),
+            )
+        ):
             msg = f"Invalid version: {version_str}"
             raise ValueError(msg)
 
@@ -98,8 +99,7 @@ class SimpleSpecifier:
     def __init__(self, spec_str: str) -> None:
         self.spec_str = spec_str.strip()
         # Parse operator and version
-        match = re.match(r"^(===|==|~=|!=|<=|>=|<|>)\s*(.+)$", self.spec_str)
-        if not match:
+        if not (match := re.match(r"^(===|==|~=|!=|<=|>=|<|>)\s*(.+)$", self.spec_str)):
             msg = f"Invalid specifier: {spec_str}"
             raise ValueError(msg)
 

src/py_discovery/_windows/_pep514.py

@@ -117,8 +117,7 @@ def load_arch_data(hive_name: str, company: str, tag: str, tag_key: Any, default
 
 def parse_arch(arch_str: Any) -> int:
     if isinstance(arch_str, str):
-        match = re.match(r"^(\d+)bit$", arch_str)
-        if match:
+        if match := re.match(r"^(\d+)bit$", arch_str):
             return int(next(iter(match.groups())))
         error = f"invalid format {arch_str}"
     else:
@@ -143,8 +142,7 @@ def load_version_data(
 
 def parse_version(version_str: Any) -> tuple[int | None, int | None, int | None]:
     if isinstance(version_str, str):
-        match = re.match(r"^(\d+)(?:\.(\d+))?(?:\.(\d+))?$", version_str)
-        if match:
+        if match := re.match(r"^(\d+)(?:\.(\d+))?(?:\.(\d+))?$", version_str):
             g1, g2, g3 = match.groups()
             return (
                 int(g1) if g1 is not None else None,

tests/conftest.py

@@ -1,17 +1,22 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 import pytest
 
 from py_discovery import DiskCache, PythonInfo
 
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
 
 @pytest.fixture(scope="session")
 def session_cache(tmp_path_factory: pytest.TempPathFactory) -> DiskCache:
     return DiskCache(tmp_path_factory.mktemp("py-discovery-cache"))
 
 
 @pytest.fixture(autouse=True)
-def _ensure_py_info_cache_empty(session_cache: DiskCache) -> None:
+def _ensure_py_info_cache_empty(session_cache: DiskCache) -> Generator[None]:
     PythonInfo.clear_cache(session_cache)
     yield
     PythonInfo.clear_cache(session_cache)

tests/py_info/test_py_info.py

@@ -108,12 +108,12 @@ def test_satisfy_not_threaded() -> None:
 
 
 def _generate_not_match_current_interpreter_version() -> list[str]:
-    result = []
+    result: list[str] = []
     for i in range(3):
-        ver = sys.version_info[0 : i + 1]
+        ver: list[int] = [int(v) for v in sys.version_info[0 : i + 1]]
         for a in range(len(ver)):
             for o in [-1, 1]:
-                temp = list(ver)
+                temp = ver.copy()
                 temp[a] += o
                 result.append(".".join(str(i) for i in temp))
     return result
@@ -215,7 +215,7 @@ def _make_py_info(of: PyInfoMock) -> PythonInfo:
         py_info = _make_py_info(i)
         py_info.system_executable = CURRENT.system_executable
         py_info.executable = CURRENT.system_executable
-        py_info.base_executable = str(path)
+        py_info.base_executable = str(path)  # ty: ignore[unresolved-attribute]
         if pos == position:
             selected = py_info
         discovered_with_path[str(path)] = py_info
@@ -261,6 +261,7 @@ def test_py_info_ignores_distutils_config(monkeypatch: pytest.MonkeyPatch, tmp_p
     (tmp_path / "setup.cfg").write_text(dedent(raw), encoding="utf-8")
     monkeypatch.chdir(tmp_path)
     py_info = PythonInfo.from_exe(sys.executable)
+    assert py_info is not None
     distutils = py_info.distutils_install
     for key, value in distutils.items():  # pragma: no cover # distutils_install is empty with "venv" scheme
         assert not value.startswith(str(tmp_path)), f"{key}={value}"

tests/test_builtin.py

@@ -300,8 +300,7 @@ def test_shim_resolved_to_real_binary(
     with patch("py_discovery._builtin.PathPythonInfo.from_exe") as mock_from_exe:
         mock_from_exe.return_value = None
         get_interpreter("python2.7", [])
-        mock_from_exe.assert_called_once()
-        assert mock_from_exe.call_args[0][0] == str(real_binary)
+        assert mock_from_exe.call_args_list[0][0][0] == str(real_binary)
 
 
 def test_shim_not_resolved_without_version_manager_env(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
@@ -318,8 +317,7 @@ def test_shim_not_resolved_without_version_manager_env(tmp_path: Path, monkeypat
     with patch("py_discovery._builtin.PathPythonInfo.from_exe") as mock_from_exe:
         mock_from_exe.return_value = None
         get_interpreter("python2.7", [])
-        mock_from_exe.assert_called_once()
-        assert mock_from_exe.call_args[0][0] == str(shim)
+        assert mock_from_exe.call_args_list[0][0][0] == str(shim)
 
 
 def test_shim_falls_through_when_binary_missing(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
@@ -334,8 +332,7 @@ def test_shim_falls_through_when_binary_missing(tmp_path: Path, monkeypatch: pyt
     with patch("py_discovery._builtin.PathPythonInfo.from_exe") as mock_from_exe:
         mock_from_exe.return_value = None
         get_interpreter("python2.7", [])
-        mock_from_exe.assert_called_once()
-        assert mock_from_exe.call_args[0][0] == str(shim)
+        assert mock_from_exe.call_args_list[0][0][0] == str(shim)
 
 
 def test_shim_uses_python_version_file(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
@@ -353,8 +350,7 @@ def test_shim_uses_python_version_file(tmp_path: Path, monkeypatch: pytest.Monke
     with patch("py_discovery._builtin.PathPythonInfo.from_exe") as mock_from_exe:
         mock_from_exe.return_value = None
         get_interpreter("python2.7", [])
-        mock_from_exe.assert_called_once()
-        assert mock_from_exe.call_args[0][0] == str(real_binary)
+        assert mock_from_exe.call_args_list[0][0][0] == str(real_binary)
 
 
 def test_shim_pyenv_version_env_takes_priority_over_file(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
@@ -373,8 +369,7 @@ def test_shim_pyenv_version_env_takes_priority_over_file(tmp_path: Path, monkeyp
     with patch("py_discovery._builtin.PathPythonInfo.from_exe") as mock_from_exe:
         mock_from_exe.return_value = None
         get_interpreter("python2.7", [])
-        mock_from_exe.assert_called_once()
-        assert mock_from_exe.call_args[0][0] == str(env_binary)
+        assert mock_from_exe.call_args_list[0][0][0] == str(env_binary)
 
 
 def test_shim_uses_global_version_file(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
@@ -394,8 +389,7 @@ def test_shim_uses_global_version_file(tmp_path: Path, monkeypatch: pytest.Monke
     with patch("py_discovery._builtin.PathPythonInfo.from_exe") as mock_from_exe:
         mock_from_exe.return_value = None
         get_interpreter("python2.7", [])
-        mock_from_exe.assert_called_once()
-        assert mock_from_exe.call_args[0][0] == str(real_binary)
+        assert mock_from_exe.call_args_list[0][0][0] == str(real_binary)
 
 
 def test_shim_colon_separated_pyenv_version_picks_first_match(
@@ -415,5 +409,4 @@ def test_shim_colon_separated_pyenv_version_picks_first_match(
     with patch("py_discovery._builtin.PathPythonInfo.from_exe") as mock_from_exe:
         mock_from_exe.return_value = None
         get_interpreter("python2.7", [])
-        mock_from_exe.assert_called_once()
-        assert mock_from_exe.call_args[0][0] == str(second_binary)
+        assert mock_from_exe.call_args_list[0][0][0] == str(second_binary)

tests/test_py_spec.py

@@ -1,14 +1,17 @@
 from __future__ import annotations
 
 import sys
-from copy import copy
+from typing import TYPE_CHECKING
 
 import pytest
 
 from py_discovery import PythonSpec
 from py_discovery._py_info import normalize_isa
 from py_discovery._specifier import SimpleSpecifierSet as SpecifierSet
 
+if TYPE_CHECKING:
+    from pathlib import Path
+
 
 def test_bad_py_spec() -> None:
     text = "python2.3.4.5"
@@ -107,10 +110,10 @@ def _version_not_satisfies_pairs() -> list[tuple[str, str]]:
     for major in range(len(version)):
         req = ".".join(version[0 : major + 1])
         for minor in range(major + 1):
-            sat_ver = list(sys.version_info[0 : minor + 1])
+            sat_ver: list[int] = [int(v) for v in sys.version_info[0 : minor + 1]]
             for patch in range(minor + 1):
                 for o in [1, -1]:
-                    temp = copy(sat_ver)
+                    temp = sat_ver.copy()
                     temp[patch] += o
                     if temp[patch] < 0:
                         continue  # pragma: no cover
@@ -126,7 +129,7 @@ def test_version_satisfies_nok(req: str, spec: str) -> None:
     assert sat_spec.satisfies(req_spec) is False
 
 
-def test_relative_spec(tmp_path: pytest.TempPathFactory, monkeypatch: pytest.MonkeyPatch) -> None:
+def test_relative_spec(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.chdir(tmp_path)
     a_relative_path = str((tmp_path / "a" / "b").relative_to(tmp_path))
     spec = PythonSpec.from_string_spec(a_relative_path)