ducktools-pythonfinder 0.7.8__tar.gz → 0.8.0__tar.gz

{ducktools_pythonfinder-0.7.8 → ducktools_pythonfinder-0.8.0}/.gitignore

@@ -117,6 +117,7 @@ celerybeat.pid
 # Environments
 .env
 .venv
+.venv_*/
 env/
 venv/
 ENV/

{ducktools_pythonfinder-0.7.8/src/ducktools_pythonfinder.egg-info → ducktools_pythonfinder-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ducktools-pythonfinder
-Version: 0.7.8
+Version: 0.8.0
 Summary: Cross platform tool to find available python installations
 Author: David C Ellis
 Project-URL: Homepage, https://github.com/davidcellis/ducktools-pythonfinder

{ducktools_pythonfinder-0.7.8 → ducktools_pythonfinder-0.8.0}/src/ducktools/pythonfinder/__init__.py

@@ -32,7 +32,7 @@ __all__ = [
 
 import sys
 from ._version import __version__
-from .shared import PythonInstall
+from .shared import PythonInstall, DetailFinder
 
 
 if sys.platform == "win32":
@@ -43,9 +43,10 @@ else:
     from .linux import get_python_installs
 
 
-def list_python_installs(*, query_executables=True):
+def list_python_installs(*, query_executables: bool = True, finder: "DetailFinder | None" = None):
+    finder = DetailFinder() if finder is None else finder
     return sorted(
-        get_python_installs(query_executables=query_executables),
+        get_python_installs(query_executables=query_executables, finder=finder),
         reverse=True,
         key=lambda x: (x.version[3], *x.version[:3], x.version[4])
     )

{ducktools_pythonfinder-0.7.8 → ducktools_pythonfinder-0.8.0}/src/ducktools/pythonfinder/__main__.py

@@ -28,6 +28,7 @@ import os
 
 from ducktools.lazyimporter import LazyImporter, ModuleImport, FromImport
 from ducktools.pythonfinder import list_python_installs, __version__
+from ducktools.pythonfinder.shared import purge_caches
 
 _laz = LazyImporter(
     [
@@ -122,6 +123,11 @@ def get_parser():
 
     subparsers = parser.add_subparsers(dest="command", required=False)
 
+    clear_cache = subparsers.add_parser(
+        "clear-cache",
+        help="Clear the cache of Python install details"
+    )
+
     online = subparsers.add_parser(
         "online",
         help="Get links to binaries from python.org"
@@ -305,7 +311,9 @@ def main():
         parser = get_parser()
         vals = parser.parse_args(sys.argv[1:])
 
-        if vals.command == "online":
+        if vals.command == "clear-cache":
+            purge_caches()
+        elif vals.command == "online":
             system = vals.system if vals.system else _laz.platform.system()
             machine = vals.machine if vals.machine else _laz.platform.machine()
             try:

ducktools_pythonfinder-0.8.0/src/ducktools/pythonfinder/_version.py

@@ -0,0 +1,2 @@
+__version__ = "0.8.0"
+__version_tuple__ = (0, 8, 0)

{ducktools_pythonfinder-0.7.8 → ducktools_pythonfinder-0.8.0}/src/ducktools/pythonfinder/details_script.py

@@ -29,11 +29,13 @@ import sys
 FULL_PY_VER_RE = r"(?P<major>\d+)\.(?P<minor>\d+)\.?(?P<micro>\d*)-?(?P<releaselevel>a|b|c|rc)?(?P<serial>\d*)?"
 
 
-def version_str_to_tuple(version):
+def version_str_to_tuple(version: str):
     # Needed to parse GraalPy versions only available as strings
     import re
 
     parsed_version = re.fullmatch(FULL_PY_VER_RE, version)
+    if parsed_version is None:
+        raise ValueError(f"'version' must be a valid Python version string, not {version!r}")
 
     major, minor, micro, releaselevel, serial = parsed_version.groups()
 
@@ -70,11 +72,11 @@ def get_details():
             # Special case GraalPy as it erroneously reports the CPython target
             # instead of the Graal versiion
             try:
-                ver = __graalpython__.get_graalvm_version()
+                ver = __graalpython__.get_graalvm_version()  # type: ignore
                 metadata = {
                     "graalpy_version": version_str_to_tuple(ver)
                 }
-            except NameError:
+            except (NameError, ValueError):
                 metadata = {"{}_version".format(implementation): sys.implementation.version}
         elif implementation != "cpython":  # pragma: no cover
             metadata = {"{}_version".format(implementation): sys.implementation.version}

{ducktools_pythonfinder-0.7.8 → ducktools_pythonfinder-0.8.0}/src/ducktools/pythonfinder/linux/__init__.py

@@ -27,11 +27,17 @@ import os.path
 import itertools
 from _collections_abc import Iterator
 
-from ..shared import PythonInstall, get_folder_pythons, get_uv_pythons, get_uv_python_path
+from ..shared import (
+    DetailFinder,
+    PythonInstall,
+    get_folder_pythons,
+    get_uv_pythons,
+    get_uv_python_path
+)
 from .pyenv_search import get_pyenv_pythons, get_pyenv_root
 
 
-def get_path_pythons() -> Iterator[PythonInstall]:
+def get_path_pythons(*, finder: DetailFinder | None = None) -> Iterator[PythonInstall]:
     exe_names = set()
 
     path_folders = os.environ.get("PATH", "").split(":")
@@ -40,6 +46,8 @@ def get_path_pythons() -> Iterator[PythonInstall]:
 
     excluded_folders = [pyenv_root, uv_root]
 
+    finder = DetailFinder if finder is None else finder
+
     for fld in path_folders:
         # Don't retrieve pyenv installs
         skip_folder = False
@@ -54,7 +62,7 @@ def get_path_pythons() -> Iterator[PythonInstall]:
         if not os.path.exists(fld):
             continue
 
-        for install in get_folder_pythons(fld):
+        for install in get_folder_pythons(fld, finder=finder):
             name = os.path.basename(install.executable)
             if name in exe_names:
                 install.shadowed = True
@@ -63,17 +71,24 @@ def get_path_pythons() -> Iterator[PythonInstall]:
             yield install
 
 
-def get_python_installs(*, query_executables=True):
+def get_python_installs(
+    *,
+    query_executables: bool = True,
+    finder: DetailFinder | None = None,
+) -> Iterator[PythonInstall]:
     listed_pythons = set()
 
+    finder = DetailFinder() if finder is None else finder
+
     chain_commands = [
-        get_pyenv_pythons(query_executables=query_executables),
-        get_uv_pythons(query_executables=query_executables),
+        get_pyenv_pythons(query_executables=query_executables, finder=finder),
+        get_uv_pythons(query_executables=query_executables, finder=finder),
     ]
     if query_executables:
-        chain_commands.append(get_path_pythons())
+        chain_commands.append(get_path_pythons(finder=finder))
 
-    for py in itertools.chain.from_iterable(chain_commands):
-        if py.executable not in listed_pythons:
-            yield py
-            listed_pythons.add(py.executable)
+    with finder:
+        for py in itertools.chain.from_iterable(chain_commands):
+            if py.executable not in listed_pythons:
+                yield py
+                listed_pythons.add(py.executable)

{ducktools_pythonfinder-0.7.8 → ducktools_pythonfinder-0.8.0}/src/ducktools/pythonfinder/linux/pyenv_search.py

@@ -22,7 +22,6 @@
 # SOFTWARE.
 from __future__ import annotations
 
-
 """
 Discover python installs that have been created with pyenv
 """
@@ -33,10 +32,11 @@ from _collections_abc import Iterator
 
 from ducktools.lazyimporter import LazyImporter, FromImport, ModuleImport
 
-from ..shared import PythonInstall, get_install_details, FULL_PY_VER_RE, version_str_to_tuple
+from ..shared import PythonInstall, DetailFinder, FULL_PY_VER_RE, INSTALLER_CACHE_PATH, version_str_to_tuple
 
 _laz = LazyImporter(
     [
+        ModuleImport("json"),
         ModuleImport("re"),
         FromImport("subprocess", "run"),
     ]
@@ -52,11 +52,24 @@ def get_pyenv_root() -> str | None:
     pyenv_root = os.environ.get("PYENV_ROOT")
     if not pyenv_root:
         try:
-            output = _laz.run(["pyenv", "root"], capture_output=True, text=True)
-        except FileNotFoundError:
-            return None
+            with open(INSTALLER_CACHE_PATH) as f:
+                installer_cache = _laz.json.load(f)
+        except (FileNotFoundError, _laz.json.JSONDecodeError):
+            installer_cache = {}
+
+        pyenv_root = installer_cache.get("pyenv")
+        if pyenv_root is None or not os.path.exists(pyenv_root):
+            try:
+                output = _laz.run(["pyenv", "root"], capture_output=True, text=True)
+            except FileNotFoundError:
+                return None
+
+            pyenv_root = output.stdout.strip()
 
-        pyenv_root = output.stdout.strip()
+            installer_cache["pyenv"] = pyenv_root
+            os.makedirs(os.path.dirname(INSTALLER_CACHE_PATH), exist_ok=True)
+            with open(INSTALLER_CACHE_PATH, 'w') as f:
+                _laz.json.dump(installer_cache, f)
 
     return pyenv_root
 
@@ -65,6 +78,7 @@ def get_pyenv_pythons(
     versions_folder: str | os.PathLike | None = None,
     *,
     query_executables: bool = True,
+    finder: DetailFinder = None,
 ) -> Iterator[PythonInstall]:
     if versions_folder is None:
         if pyenv_root := get_pyenv_root():
@@ -77,26 +91,32 @@ def get_pyenv_pythons(
     # This can lead to much faster returns by potentially yielding
     # the required python version before checking pypy/graalpy/micropython
 
-    for p in sorted(os.scandir(versions_folder), key=lambda x: x.path):
-        executable = os.path.join(p.path, "bin/python")
-
-        if os.path.exists(executable):
-            if p.name.endswith("t"):
-                freethreaded = True
-                version = p.name[:-1]
-            else:
-                freethreaded = False
-                version = p.name
-            if _laz.re.fullmatch(FULL_PY_VER_RE, version):
-                version_tuple = version_str_to_tuple(version)
-                metadata = {}
-                if version_tuple >= (3, 13):
-                    metadata["freethreaded"] = freethreaded
-                yield PythonInstall(
-                    version=version_tuple,
-                    executable=executable,
-                    metadata=metadata,
-                    managed_by="pyenv",
-                )
-            elif query_executables and (install := get_install_details(executable, managed_by="pyenv")):
-                yield install
+    finder = DetailFinder() if finder is None else finder
+
+    with finder:
+        for p in sorted(os.scandir(versions_folder), key=lambda x: x.path):
+            executable = os.path.join(p.path, "bin/python")
+
+            if os.path.exists(executable):
+                if p.name.endswith("t"):
+                    freethreaded = True
+                    version = p.name[:-1]
+                else:
+                    freethreaded = False
+                    version = p.name
+                if _laz.re.fullmatch(FULL_PY_VER_RE, version):
+                    version_tuple = version_str_to_tuple(version)
+                    metadata = {}
+                    if version_tuple >= (3, 13):
+                        metadata["freethreaded"] = freethreaded
+                    yield PythonInstall(
+                        version=version_tuple,
+                        executable=executable,
+                        metadata=metadata,
+                        managed_by="pyenv",
+                    )
+                elif (
+                    query_executables
+                    and (install := finder.get_install_details(executable, managed_by="pyenv"))
+                ):
+                    yield install

{ducktools_pythonfinder-0.7.8 → ducktools_pythonfinder-0.8.0}/src/ducktools/pythonfinder/shared.py

@@ -28,7 +28,7 @@ import os.path
 
 from _collections_abc import Iterator
 
-from ducktools.classbuilder.prefab import Prefab, attribute
+from ducktools.classbuilder.prefab import Prefab, attribute, as_dict
 from ducktools.lazyimporter import LazyImporter, ModuleImport, FromImport
 
 from . import details_script
@@ -39,13 +39,13 @@ _laz = LazyImporter(
         ModuleImport("json"),
         ModuleImport("platform"),
         ModuleImport("re"),
+        ModuleImport("shutil"),
         ModuleImport("subprocess"),
         ModuleImport("tempfile"),
         ModuleImport("zipfile"),
     ]
 )
 
-
 FULL_PY_VER_RE = r"(?P<major>\d+)\.(?P<minor>\d+)\.?(?P<micro>\d*)-?(?P<releaselevel>a|b|c|rc)?(?P<serial>\d*)?"
 
 UV_PYTHON_RE = (
@@ -56,6 +56,38 @@ UV_PYTHON_RE = (
     r"-.*"
 )
 
+# Cache for runtime details
+# Code to work out where to store data
+# Store in LOCALAPPDATA for windows, User folder for other operating systems
+if sys.platform == "win32":
+    # os.path.expandvars will actually import a whole bunch of other modules
+    # Try just using the environment.
+    if _local_app_folder := os.environ.get("LOCALAPPDATA"):
+        if not os.path.isdir(_local_app_folder):
+            raise FileNotFoundError(
+                f"Could not find local app data folder {_local_app_folder}"
+            )
+    else:
+        raise EnvironmentError(
+            "Environment variable %LOCALAPPDATA% "
+            "for local application data folder location "
+            "not found"
+        )
+    USER_FOLDER = _local_app_folder
+    CACHE_FOLDER = os.path.join(USER_FOLDER, "ducktools", "pythonfinder", "cache")
+else:
+    USER_FOLDER = os.path.expanduser("~")
+    CACHE_FOLDER = os.path.join(USER_FOLDER, ".cache", "ducktools", "pythonfinder")
+
+
+CACHE_VERSION = 1
+DETAILS_CACHE_PATH = os.path.join(CACHE_FOLDER, f"runtime_cache_v{CACHE_VERSION}.json")
+INSTALLER_CACHE_PATH = os.path.join(CACHE_FOLDER, "installer_details.json")
+
+
+def purge_caches(cache_folder=CACHE_FOLDER):
+    _laz.shutil.rmtree(cache_folder, ignore_errors=True)
+
 
 def version_str_to_tuple(version):
     parsed_version = _laz.re.fullmatch(FULL_PY_VER_RE, version)
@@ -129,7 +161,141 @@ class DetailsScript(Prefab):
         return self._source_code
 
 
-details = DetailsScript()
+class DetailFinder(Prefab):
+    cache_path: str = DETAILS_CACHE_PATH
+    details_script: DetailsScript = attribute(default_factory=DetailsScript)
+
+    # Stores the dict loaded from the JSON file without processing
+    _raw_cache: dict | None = attribute(default=None, private=True)
+
+    # Indicates if the cache is known to have changed
+    _dirty_cache: bool = attribute(default=False, private=True)
+
+    # Increased each re-entry to the context manager
+    # Decreased on exit
+    # Save should only occur when all contexts exit
+    _context_level: int = attribute(default=0, private=True)
+
+    def __enter__(self):
+        self._context_level += 1
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self._context_level -= 1
+        if (
+            exc_type in {None, GeneratorExit}
+            and self._dirty_cache
+            and self._context_level == 0
+        ):
+            self.save()
+
+    @property
+    def raw_cache(self):
+        if self._raw_cache is None:
+            try:
+                with open(self.cache_path) as f:
+                    self._raw_cache = _laz.json.load(f)
+            except (_laz.json.JSONDecodeError, FileNotFoundError):
+                self._raw_cache = {}
+        return self._raw_cache
+
+    def save(self):
+        os.makedirs(os.path.dirname(self.cache_path), exist_ok=True)
+        with open(self.cache_path, 'w') as f:
+            _laz.json.dump(self.raw_cache, f, indent=4)
+
+        self._dirty_cache = False
+
+    def clear_invalid_runtimes(self):
+        """
+        Remove cache entries where the python.exe no longer exists
+        """
+        removed_runtimes: set[str] = set()
+        for exe_path in self.raw_cache.copy().keys():
+            if not os.path.exists(exe_path):
+                self.raw_cache.pop(exe_path)
+                removed_runtimes.add(exe_path)
+        if removed_runtimes:
+            self._dirty_cache = True
+
+    def clear_cache(self):
+        """
+        Completely empty the cache
+        """
+        self._raw_cache = {}
+        self._dirty_cache = True
+
+    def query_install(self, exe_path: str, managed_by: str | None = None) -> PythonInstall | None:
+        """
+        Query the details of a Python install directly
+
+        :param exe_path: Path to the runtime .exe
+        :param managed_by: Which tool manages this install (if any)
+        :return: a PythonInstall if one exists at the exe Path
+        """
+        try:
+            source = self.details_script.get_source_code()
+        except FileNotFoundError:
+            return None
+
+        try:
+            detail_output = _laz.subprocess.run(
+                [exe_path, "-"],
+                input=source,
+                capture_output=True,
+                text=True,
+                check=True,
+            ).stdout
+        except OSError:
+            # Something else has gone wrong
+            return None
+        except (_laz.subprocess.CalledProcessError, FileNotFoundError):
+            # Potentially this is micropython which does not support
+            # piping from stdin. Try using a file in a temporary folder.
+            # Python 3.12 has delete_on_close that would make TemporaryFile
+            # Usable on windows but for now use a directory
+            with _laz.tempfile.TemporaryDirectory() as tempdir:
+                temp_script = os.path.join(tempdir, "details_script.py")
+                with open(temp_script, "w") as f:
+                    f.write(source)
+                try:
+                    detail_output = _laz.subprocess.run(
+                        [exe_path, temp_script],
+                        capture_output=True,
+                        text=True,
+                        check=True,
+                    ).stdout
+                except (_laz.subprocess.CalledProcessError, FileNotFoundError):
+                    return None
+
+        try:
+            output = _laz.json.loads(detail_output)
+        except _laz.json.JSONDecodeError:
+            return None
+
+        return PythonInstall.from_json(**output, managed_by=managed_by)
+
+    def get_install_details(self, exe_path: str, managed_by=None) -> PythonInstall | None:
+        exe_path = os.path.abspath(exe_path)
+        mtime = os.stat(exe_path).st_mtime
+
+        install = None
+        if cached_details := self.raw_cache.get(exe_path):
+            if cached_details["mtime"] == mtime:
+                install = PythonInstall.from_json(**cached_details["install"])
+            else:
+                self.raw_cache.pop(exe_path)
+
+        if install is None:
+            install = self.query_install(exe_path, managed_by)
+            if install:
+                self.raw_cache[exe_path] = {
+                    "mtime": mtime,
+                    "install": as_dict(install)
+                }
+                self._dirty_cache = True
+
+        return install
 
 
 class PythonInstall(Prefab):
@@ -139,7 +305,7 @@ class PythonInstall(Prefab):
     implementation: str = "cpython"
     managed_by: str | None = None
     metadata: dict = attribute(default_factory=dict)
-    shadowed: bool = False
+    shadowed: bool = attribute(default=False, serialize=False)
     _implementation_version: tuple[int, int, int, str, int] | None = attribute(default=None, private=True)
 
     def __prefab_post_init__(
@@ -197,13 +363,21 @@ class PythonInstall(Prefab):
         )
 
     @classmethod
-    def from_json(cls, version, executable, architecture, implementation, metadata, managed_by=None):
+    def from_json(
+        cls,
+        version,
+        executable,
+        architecture,
+        implementation,
+        metadata,
+        managed_by=None,
+    ):
         if arch_ver := metadata.get(f"{implementation}_version"):
             metadata[f"{implementation}_version"] = tuple(arch_ver)
 
         # noinspection PyArgumentList
         return cls(
-            version=tuple(version),
+            version=tuple(version),  # type: ignore
             executable=executable,
             architecture=architecture,
             implementation=implementation,
@@ -238,63 +412,22 @@ def _python_exe_regex(basename: str = "python"):
         return _laz.re.compile(rf"{basename}\d?\.?\d*")
 
 
-def get_install_details(executable: str, managed_by=None) -> PythonInstall | None:
-    try:
-        source = details.get_source_code()
-    except FileNotFoundError:
-        return None
-
-    try:
-        detail_output = _laz.subprocess.run(
-            [executable, "-"],
-            input=source,
-            capture_output=True,
-            text=True,
-            check=True,
-        ).stdout
-    except OSError:
-        # Something else has gone wrong
-        return None
-    except (_laz.subprocess.CalledProcessError, FileNotFoundError):
-        # Potentially this is micropython which does not support
-        # piping from stdin. Try using a file in a temporary folder.
-        # Python 3.12 has delete_on_close that would make TemporaryFile
-        # Usable on windows but for now use a directory
-        with _laz.tempfile.TemporaryDirectory() as tempdir:
-            temp_script = os.path.join(tempdir, "details_script.py")
-            with open(temp_script, "w") as f:
-                f.write(source)
-            try:
-                detail_output = _laz.subprocess.run(
-                    [executable, temp_script],
-                    capture_output=True,
-                    text=True,
-                    check=True,
-                ).stdout
-            except (_laz.subprocess.CalledProcessError, FileNotFoundError):
-                return None
-
-    try:
-        output = _laz.json.loads(detail_output)
-    except _laz.json.JSONDecodeError as e:
-        return None
-
-    return PythonInstall.from_json(**output, managed_by=managed_by)
-
-
 def get_folder_pythons(
     base_folder: str | os.PathLike,
-    basenames: tuple[str] = ("python", "pypy")
+    basenames: tuple[str] = ("python", "pypy"),
+    finder: DetailFinder | None = None,
 ):
     regexes = [_python_exe_regex(name) for name in basenames]
 
-    with os.scandir(base_folder) as fld:
+    finder = DetailFinder() if finder is None else finder
+
+    with finder, os.scandir(base_folder) as fld:
         for file_path in fld:
             try:
                 is_file = file_path.is_file()
             except PermissionError:
                 continue
-            
+
             if (
                 is_file
                 and any(reg.fullmatch(file_path.name) for reg in regexes)
@@ -307,13 +440,25 @@ def get_folder_pythons(
                         continue
                 else:
                     p = file_path.path
-                install = get_install_details(p)
+                install = finder.get_install_details(p)
                 if install:
                     yield install
 
 
 # UV Specific finder
 def get_uv_python_path() -> str | None:
+    # Attempt to get cache
+    try:
+        with open(INSTALLER_CACHE_PATH) as f:
+            installer_cache = _laz.json.load(f)
+    except (FileNotFoundError, _laz.json.JSONDecodeError):
+        installer_cache = {}
+
+    uv_python_dir = installer_cache.get("uv")
+    if uv_python_dir and os.path.exists(uv_python_dir):
+        return uv_python_dir
+
+    # Cache failed
     try:
         uv_python_find = _laz.subprocess.run(
             ["uv", "python", "dir"],
@@ -327,17 +472,25 @@ def get_uv_python_path() -> str | None:
         # remove newline
         uv_python_dir = uv_python_find.stdout.strip()
 
+    # Fill cache and update the cache file
+    installer_cache["uv"] = uv_python_dir
+    os.makedirs(os.path.dirname(INSTALLER_CACHE_PATH), exist_ok=True)
+    with open(INSTALLER_CACHE_PATH, 'w') as f:
+        _laz.json.dump(installer_cache, f)
+
     return uv_python_dir
 
 
 def _implementation_from_uv_dir(
     direntry: os.DirEntry,
     query_executables: bool = True,
+    finder: DetailFinder | None = None,
 ) -> PythonInstall | None:
     python_exe = "python.exe" if sys.platform == "win32" else "bin/python"
     python_path = os.path.join(direntry, python_exe)
 
     install: PythonInstall | None = None
+    finder = DetailFinder() if finder is None else finder
 
     if os.path.exists(python_path):
         if match := _laz.re.fullmatch(UV_PYTHON_RE, direntry.name):
@@ -354,7 +507,7 @@ def _implementation_from_uv_dir(
                         architecture="32bit" if arch in {"i686", "armv7"} else "64bit",
                         implementation=implementation,
                         metadata=metadata,
-                        managed_by="Astral UV",
+                        managed_by="Astral",
                     )
             except ValueError:
                 pass
@@ -363,21 +516,22 @@ def _implementation_from_uv_dir(
             # Directory name format has changed or this is an alternate implementation
             # Slow backup - ask python itself
             if query_executables:
-                install = get_install_details(python_path)
-                install.managed_by = "Astral UV"
+                install = finder.get_install_details(python_path, managed_by="Astral")
 
     return install
 
 
-def get_uv_pythons(query_executables=True) -> Iterator[PythonInstall]:
+def get_uv_pythons(query_executables=True, finder=None) -> Iterator[PythonInstall]:
     # This takes some shortcuts over the regular pythonfinder
     # As the UV folders give the python version and the implementation
     if uv_python_path := get_uv_python_path():
         if os.path.exists(uv_python_path):
-            with os.scandir(uv_python_path) as fld:
+            finder = DetailFinder() if finder is None else finder
+
+            with finder, os.scandir(uv_python_path) as fld:
                 for f in fld:
                     if (
                         f.is_dir()
-                        and (install := _implementation_from_uv_dir(f, query_executables))
+                        and (install := _implementation_from_uv_dir(f, query_executables, finder=finder))
                     ):
                         yield install