ducktools-pythonfinder 0.5.3__tar.gz → 0.5.5__tar.gz

{ducktools_pythonfinder-0.5.3/src/ducktools_pythonfinder.egg-info → ducktools_pythonfinder-0.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ducktools-pythonfinder
-Version: 0.5.3
+Version: 0.5.5
 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.5.3 → ducktools_pythonfinder-0.5.5}/src/ducktools/pythonfinder/__init__.py

@@ -24,6 +24,7 @@
 # Find platform python versions
 
 __all__ = [
+    "__version__",
     "get_python_installs",
     "list_python_installs",
     "PythonInstall",
@@ -42,9 +43,9 @@ else:
     from .linux import get_python_installs
 
 
-def list_python_installs():
+def list_python_installs(*, query_executables=True):
     return sorted(
-        get_python_installs(),
+        get_python_installs(query_executables=query_executables),
         reverse=True,
         key=lambda x: (x.version[3], *x.version[:3], x.version[4])
     )

{ducktools_pythonfinder-0.5.3 → ducktools_pythonfinder-0.5.5}/src/ducktools/pythonfinder/__main__.py

@@ -20,6 +20,7 @@
 # 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.
+from __future__ import annotations
 
 
 import sys
@@ -79,6 +80,11 @@ def parse_args(args):
         description="Discover base Python installs",
     )
     parser.add_argument("-V", "--version", action="version", version=__version__)
+    parser.add_argument(
+        "--fast",
+        action="store_true",
+        help="Skip Python installs that need to be launched to obtain metadata"
+    )
 
     subparsers = parser.add_subparsers(dest="command", required=False)
 
@@ -121,7 +127,12 @@ def parse_args(args):
     return vals
 
 
-def display_local_installs(min_ver=None, max_ver=None, compatible=None):
+def display_local_installs(
+    min_ver=None,
+    max_ver=None,
+    compatible=None,
+    query_executables=True,
+):
     if min_ver:
         min_ver = tuple(int(i) for i in min_ver.split("."))
     if max_ver:
@@ -129,24 +140,17 @@ def display_local_installs(min_ver=None, max_ver=None, compatible=None):
     if compatible:
         compatible = tuple(int(i) for i in compatible.split("."))
 
-    installs = list_python_installs()
-    headings = ["Python Version", "Executable Location"]
-    max_executable_len = max(
-        len(headings[1]), max(len(inst.executable) for inst in installs)
-    )
-    headings_str = f"| {headings[0]} | {headings[1]:<{max_executable_len}s} |"
+    installs = list_python_installs(query_executables=query_executables)
 
-    print("Discoverable Python Installs")
-    if sys.platform == "win32":
-        print("+ - Listed in the Windows Registry ")
-        print("^ - This is a 32-bit Python install")
-    if sys.platform != "win32":
-        print("[] - This Python install is shadowed by another on Path")
-    print("* - This is the active Python executable used to call this module")
-    print("** - This is the parent Python executable of the venv used to call this module")
-    print()
-    print(headings_str)
-    print(f"| {'-' * len(headings[0])} | {'-' * max_executable_len} |")
+    headings = ["Version", "Executable Location"]
+
+    install_collection: list[tuple[str, str]] = []
+    max_version_len = len(headings[0])
+    max_executable_len = len(headings[1])
+
+    alternate_implementations = False
+
+    # First collect the strings
     for install in installs:
         if min_ver and install.version < min_ver:
             continue
@@ -180,17 +184,45 @@ def display_local_installs(min_ver=None, max_ver=None, compatible=None):
         if install.shadowed:
             version_str = f"[{version_str}]"
 
-        print(f"| {version_str:>14s} | {install.executable:<{max_executable_len}s} |")
+        if install.implementation != "cpython":
+            alternate_implementations = True
+            version_str = f"({install.implementation_version_str}) {version_str}"
+
+        max_version_len = max(max_version_len, len(version_str))
+        max_executable_len = max(max_executable_len, len(install.executable))
+
+        install_collection.append((version_str, install.executable))
+
+    print("Discoverable Python Installs")
+    print()
+    if alternate_implementations:
+        print("Alternate implementation versions are listed in parentheses")
+
+    if sys.platform == "win32":
+        print("+ - Listed in the Windows Registry ")
+        print("^ - This is a 32-bit Python install")
+    if sys.platform != "win32":
+        print("[] - This Python install is shadowed by another on Path")
+    print("* - This is the active Python executable used to call this module")
+    print("** - This is the parent Python executable of the venv used to call this module")
+    print()
+
+    headings_str = f"| {headings[0]:<{max_version_len}s} | {headings[1]:<{max_executable_len}s} |"
+    print(headings_str)
+    print(f"| {'-' * max_version_len} | {'-' * max_executable_len} |")
+
+    for version_str, executable in install_collection:
+        print(f"| {version_str:>{max_version_len}s} | {executable:<{max_executable_len}s} |")
 
 
 def display_remote_binaries(
-        min_ver,
-        max_ver,
-        compatible,
-        all_binaries,
-        system,
-        machine,
-        prerelease
+    min_ver,
+    max_ver,
+    compatible,
+    all_binaries,
+    system,
+    machine,
+    prerelease
 ):
     specs = []
     if min_ver:
@@ -252,7 +284,12 @@ def main():
             except _laz.URLError:
                 print("Could not connect to python.org")
         else:
-            display_local_installs(vals.min, vals.max, vals.compatible)
+            display_local_installs(
+                min_ver=vals.min,
+                max_ver=vals.max,
+                compatible=vals.compatible,
+                query_executables=not vals.fast,
+            )
     else:
         # No arguments to parse
         display_local_installs()

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

@@ -0,0 +1,2 @@
+__version__ = "0.5.5"
+__version_tuple__ = (0, 5, 5)

{ducktools_pythonfinder-0.5.3 → ducktools_pythonfinder-0.5.5}/src/ducktools/pythonfinder/details_script.py

@@ -26,6 +26,35 @@ Get the details from a python install as JSON
 """
 import sys
 
+FULL_PY_VER_RE = r"(?P<major>\d+)\.(?P<minor>\d+)\.?(?P<micro>\d*)-?(?P<releaselevel>[a-zA-Z]*)(?P<serial>\d*)"
+
+
+def version_str_to_tuple(version):
+    # Needed to parse GraalPy versions only available as strings
+    import re
+
+    parsed_version = re.fullmatch(FULL_PY_VER_RE, version)
+
+    major, minor, micro, releaselevel, serial = parsed_version.groups()
+
+    if releaselevel in {"a", "dev"}:
+        releaselevel = "alpha"
+    elif releaselevel == "b":
+        releaselevel = "beta"
+    elif releaselevel == "rc":
+        releaselevel = "candidate"
+    else:
+        releaselevel = "final"
+
+    version_tuple = (
+        int(major),
+        int(minor),
+        int(micro) if micro else 0,
+        releaselevel,
+        int(serial if serial != "" else 0),
+    )
+    return version_tuple
+
 
 def get_details():
     try:
@@ -37,7 +66,17 @@ def get_details():
         implementation = platform.python_implementation().lower()
         metadata = {}
     else:
-        if implementation != "cpython":  # pragma: no cover
+        if implementation == "graalpy":
+            # Special case GraalPy as it erroneously reports the CPython target
+            # instead of the Graal versiion
+            try:
+                ver = __graalpython__.get_graalvm_version()
+                metadata = {
+                    "graalpy_version": version_str_to_tuple(ver)
+                }
+            except NameError:
+                metadata = {"{}_version".format(implementation): sys.implementation.version}
+        elif implementation != "cpython":  # pragma: no cover
             metadata = {"{}_version".format(implementation): sys.implementation.version}
         else:
             metadata = {}

{ducktools_pythonfinder-0.5.3 → ducktools_pythonfinder-0.5.5}/src/ducktools/pythonfinder/linux/__init__.py

@@ -63,14 +63,17 @@ def get_path_pythons() -> Iterator[PythonInstall]:
             yield install
 
 
-def get_python_installs():
+def get_python_installs(*, query_executables=True):
     listed_pythons = set()
 
-    for py in itertools.chain(
-        get_pyenv_pythons(),
-        get_uv_pythons(),
-        get_path_pythons(),
-    ):
+    chain_commands = [
+        get_pyenv_pythons(query_executables=query_executables),
+        get_uv_pythons(query_executables=query_executables),
+    ]
+    if query_executables:
+        chain_commands.append(get_path_pythons())
+
+    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.5.3 → ducktools_pythonfinder-0.5.5}/src/ducktools/pythonfinder/linux/pyenv_search.py

@@ -45,24 +45,20 @@ _laz = LazyImporter(
 PYTHON_VER_RE = r"\d{1,2}\.\d{1,2}\.\d+[a-z]*\d*"
 PYPY_VER_RE = r"^pypy(?P<pyversion>\d{1,2}\.\d+)-(?P<pypyversion>[\d\.]*)$"
 
-# 'pypy -V' output matcher
-PYPY_V_OUTPUT = (
-    r"(?is)python (?P<python_version>\d+\.\d+\.\d+[a-z]*\d*).*?"
-    r"pypy (?P<pypy_version>\d+\.\d+\.\d+[a-z]*\d*).*"
-)
-
 PYENV_VERSIONS_FOLDER = os.path.join(os.environ.get("PYENV_ROOT", ""), "versions")
 
 
 def get_pyenv_pythons(
     versions_folder: str | os.PathLike = PYENV_VERSIONS_FOLDER,
+    *,
+    query_executables: bool = True,
 ) -> Iterator[PythonInstall]:
     if not os.path.exists(versions_folder):
         return
 
-    # Sorting puts standard python versions before pypy
+    # Sorting puts standard python versions before alternate implementations
     # This can lead to much faster returns by potentially yielding
-    # the required python version before checking pypy
+    # 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")
@@ -70,6 +66,5 @@ def get_pyenv_pythons(
         if os.path.exists(executable):
             if _laz.re.fullmatch(PYTHON_VER_RE, p.name):
                 yield PythonInstall.from_str(p.name, executable)
-            elif _laz.re.fullmatch(PYPY_VER_RE, p.name):
-                if install := get_install_details(executable):
-                    yield install
+            elif query_executables and (install := get_install_details(executable)):
+                yield install

{ducktools_pythonfinder-0.5.3 → ducktools_pythonfinder-0.5.5}/src/ducktools/pythonfinder/shared.py

@@ -28,24 +28,25 @@ import os.path
 
 from _collections_abc import Iterator
 
-from ducktools.classbuilder import slotclass, Field, SlotFields
+from ducktools.classbuilder.prefab import Prefab, attribute
 from ducktools.lazyimporter import LazyImporter, ModuleImport, FromImport
 
 from . import details_script
 
 _laz = LazyImporter(
     [
-        ModuleImport("re"),
-        ModuleImport("subprocess"),
-        ModuleImport("platform"),
         FromImport("glob", "glob"),
         ModuleImport("json"),
+        ModuleImport("platform"),
+        ModuleImport("re"),
+        ModuleImport("subprocess"),
+        ModuleImport("tempfile"),
         ModuleImport("zipfile"),
     ]
 )
 
 
-FULL_PY_VER_RE = r"(?P<major>\d+)\.(?P<minor>\d+)\.?(?P<micro>\d*)(?P<releaselevel>[a-zA-Z]*)(?P<serial>\d*)"
+FULL_PY_VER_RE = r"(?P<major>\d+)\.(?P<minor>\d+)\.?(?P<micro>\d*)-?(?P<releaselevel>[a-zA-Z]*)(?P<serial>\d*)"
 
 
 def version_str_to_tuple(version):
@@ -56,7 +57,7 @@ def version_str_to_tuple(version):
 
     major, minor, micro, releaselevel, serial = parsed_version.groups()
 
-    if releaselevel == "a":
+    if releaselevel in {"a", "dev"}:
         releaselevel = "alpha"
     elif releaselevel == "b":
         releaselevel = "beta"
@@ -95,17 +96,12 @@ def version_tuple_to_str(version_tuple):
     return f"{major}.{minor}.{micro}{releaselevel}{serial}"
 
 
-@slotclass
-class DetailsScript:
+class DetailsScript(Prefab):
     """
     Class to obtain and cache the source code of details_script.py
     to use on external Pythons.
     """
-    __slots__ = SlotFields(
-        _source_code=Field(default=None)
-    )
-
-    _source_code: str | None
+    _source_code: str | None = attribute(default=None, private=True)
 
     def get_source_code(self):
         if self._source_code is None:
@@ -128,27 +124,46 @@ class DetailsScript:
 details = DetailsScript()
 
 
-@slotclass
-class PythonInstall:
-    __slots__ = SlotFields(
-        version=Field(),
-        executable=Field(),
-        architecture="64bit",
-        implementation="cpython",
-        metadata=Field(default_factory=dict),
-        shadowed=False,
-    )
+class PythonInstall(Prefab):
     version: tuple[int, int, int, str, int]
     executable: str
-    architecture: str
-    implementation: str
-    metadata: dict
-    shadowed: bool
+    architecture: str = "64bit"
+    implementation: str = "cpython"
+    metadata: dict = attribute(default_factory=dict)
+    shadowed: bool = False
+    _implementation_version: tuple[int, int, int, str, int] | None = attribute(default=None, private=True)
+
+    def __prefab_post_init__(
+        self,
+        version: tuple[int, int, int] | tuple[int, int, int, str, int]
+    ):
+        if len(version) == 3:
+            # Micropython gives an invalid 3 part version here
+            # Add the extras to avoid breaking
+            self.version = tuple([*version, "final", 0])  # type: ignore
+        else:
+            self.version = version
 
     @property
     def version_str(self) -> str:
         return version_tuple_to_str(self.version)
 
+    @property
+    def implementation_version(self) -> tuple[int, int, int, str, int] | None:
+        if self._implementation_version is None:
+            if self.implementation == "cpython":
+                self._implementation_version = self.version
+            elif implementation_ver := self.metadata.get(f"{self.implementation}_version"):
+                if len(implementation_ver) == 3:
+                    self._implementation_version = tuple([*implementation_ver, "final", 0])  # type: ignore
+                else:
+                    self._implementation_version = implementation_ver
+        return self._implementation_version
+
+    @property
+    def implementation_version_str(self) -> str:
+        return version_tuple_to_str(self.implementation_version)
+
     @classmethod
     def from_str(
         cls,
@@ -219,12 +234,31 @@ def get_install_details(executable: str) -> PythonInstall | None:
             text=True,
             check=True,
         ).stdout
-    except (_laz.subprocess.CalledProcessError, FileNotFoundError):
+    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:
+    except _laz.json.JSONDecodeError as e:
         return None
 
     return PythonInstall.from_json(**output)
@@ -266,7 +300,10 @@ def get_uv_python_path() -> str | None:
     return uv_python_dir
 
 
-def _implementation_from_uv_dir(direntry: os.DirEntry) -> PythonInstall | None:
+def _implementation_from_uv_dir(
+    direntry: os.DirEntry,
+    query_executables: bool = True,
+) -> PythonInstall | None:
     python_exe = "python.exe" if sys.platform == "win32" else "bin/python"
     python_path = os.path.join(direntry, python_exe)
 
@@ -278,9 +315,10 @@ def _implementation_from_uv_dir(direntry: os.DirEntry) -> PythonInstall | None:
         except ValueError:
             # Directory name format has changed
             # Slow backup - ask python itself
-            install = get_install_details(python_path)
+            if query_executables:
+                install = get_install_details(python_path)
         else:
-            if implementation == "cpython":
+            if implementation in {"cpython"}:
                 install = PythonInstall.from_str(
                     version=version,
                     executable=python_path,
@@ -289,16 +327,20 @@ def _implementation_from_uv_dir(direntry: os.DirEntry) -> PythonInstall | None:
                 )
             else:
                 # Get additional alternate implementation details
-                install = get_install_details(python_path)
+                if query_executables:
+                    install = get_install_details(python_path)
 
     return install
 
 
-def get_uv_pythons() -> Iterator[PythonInstall]:
+def get_uv_pythons(query_executables=True) -> 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():
         with os.scandir(uv_python_path) as fld:
             for f in fld:
-                if f.is_dir() and (install := _implementation_from_uv_dir(f)):
+                if (
+                    f.is_dir()
+                    and (install := _implementation_from_uv_dir(f, query_executables))
+                ):
                     yield install

{ducktools_pythonfinder-0.5.3 → ducktools_pythonfinder-0.5.5}/src/ducktools/pythonfinder/win32/__init__.py

@@ -30,12 +30,12 @@ from .pyenv_search import get_pyenv_pythons
 from .registry_search import get_registered_pythons
 
 
-def get_python_installs() -> Iterator[PythonInstall]:
+def get_python_installs(*, query_executables: bool = True) -> Iterator[PythonInstall]:
     listed_installs = set()
     for py in itertools.chain(
         get_registered_pythons(),
-        get_pyenv_pythons(),
-        get_uv_pythons(),
+        get_pyenv_pythons(query_executables=query_executables),
+        get_uv_pythons(query_executables=query_executables),
     ):
         if py.executable not in listed_installs:
             yield py

ducktools_pythonfinder-0.5.5/src/ducktools/pythonfinder/win32/pyenv_search.py

@@ -0,0 +1,87 @@
+# ducktools-pythonfinder
+# MIT License
+#
+# Copyright (c) 2023-2024 David C Ellis
+#
+# 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.
+from __future__ import annotations
+
+import os
+import os.path
+from _collections_abc import Iterator
+
+from ..shared import PythonInstall, get_install_details
+
+
+PYENV_VERSIONS_FOLDER = os.path.join(os.environ.get("PYENV_ROOT", ""), "versions")
+
+
+def get_pyenv_pythons(
+    versions_folder: str | os.PathLike = PYENV_VERSIONS_FOLDER,
+    *,
+    query_executables: bool = True,
+) -> Iterator[PythonInstall]:
+    if not os.path.exists(versions_folder):
+        return
+
+    for p in os.scandir(versions_folder):
+        path_base = os.path.basename(p.path)
+
+        if query_executables:
+            # Check for pypy/graalpy
+            if path_base.startswith("pypy"):
+                executable = os.path.join(p.path, "pypy.exe")
+                if os.path.exists(executable):
+                    yield get_install_details(executable)
+                    continue
+            elif path_base.startswith("graalpy"):
+                # Graalpy exe in bin subfolder
+                executable = os.path.join(p.path, "bin", "graalpy.exe")
+                if os.path.exists(executable):
+                    yield get_install_details(executable)
+                    continue
+
+        # Regular CPython
+        executable = os.path.join(p.path, "python.exe")
+
+        if os.path.exists(executable):
+            split_version = p.name.split("-")
+
+            # If there are 1 or 2 arguments this is a recognised version
+            # Otherwise it is unrecognised
+            if len(split_version) == 2:
+                version, arch = split_version
+
+                # win32 in pyenv name means 32 bit python install
+                # 'arm' is the only alternative which will be 64bit
+                arch = "32bit" if arch == "win32" else "64bit"
+                try:
+                    yield PythonInstall.from_str(
+                        version, executable, architecture=arch
+                    )
+                except ValueError:
+                    pass
+            elif len(split_version) == 1:
+                version = split_version[0]
+                try:
+                    yield PythonInstall.from_str(
+                        version, executable, architecture="64bit"
+                    )
+                except ValueError:
+                    pass

{ducktools_pythonfinder-0.5.3 → ducktools_pythonfinder-0.5.5/src/ducktools_pythonfinder.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ducktools-pythonfinder
-Version: 0.5.3
+Version: 0.5.5
 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.5.3 → ducktools_pythonfinder-0.5.5}/tests/conftest.py

@@ -24,7 +24,14 @@ from pathlib import Path
 
 import pytest
 
+from ducktools.pythonfinder import details_script
+
 
 @pytest.fixture(scope="session")
 def sources_folder():
     return Path(__file__).parent / "sources"
+
+
+@pytest.fixture
+def uses_details_script(fs):
+    fs.add_real_file(details_script.__file__)

{ducktools_pythonfinder-0.5.3 → ducktools_pythonfinder-0.5.5}/tests/test_foldersearch.py

@@ -89,7 +89,7 @@ def test_get_install_details_error():
     ) as run_mock:
         details = get_install_details(fake_details_out.executable)
 
-        run_mock.assert_called_with(
+        run_mock.assert_any_call(
             [fake_details_out.executable, "-"],
             input=details_text,
             capture_output=True,

{ducktools_pythonfinder-0.5.3 → ducktools_pythonfinder-0.5.5}/tests/test_pyenv.py

@@ -110,30 +110,32 @@ def test_32bit_version(fs):
 
 
 @pytest.mark.skipif(sys.platform != "win32", reason="Test for Windows only")
-def test_invalid_ver_win(fs):
+def test_invalid_ver_win(fs, uses_details_script):
     # Ignore non-standard versions
 
-    tmpdir = "c:\\fake_folder"
+    pyenv_fld = "C:\\Fake_Folder"
 
-    py_folder = os.path.join(tmpdir, "external-python3.12.1")
+    py_folder = os.path.join(pyenv_fld, "external-python3.12.1")
     py_exe = os.path.join(py_folder, "python.exe")
 
     fs.create_dir(py_folder)
     fs.create_file(py_exe)
 
-    py2_folder = os.path.join(tmpdir, "ext3.13.0")
+    py2_folder = os.path.join(pyenv_fld, "ext3.13.0")
     py2_exe = os.path.join(py2_folder, "python.exe")
 
     fs.create_dir(py2_folder)
     fs.create_file(py2_exe)
 
-    py3_folder = os.path.join(tmpdir, "invalid-version-3.12.1")
+    py3_folder = os.path.join(pyenv_fld, "invalid-version-3.12.1")
     py3_exe = os.path.join(py3_folder, "python.exe")
 
     fs.create_dir(py3_folder)
     fs.create_file(py3_exe)
 
-    versions = list(get_pyenv_pythons(tmpdir))
+    with patch("subprocess.run") as run_mock:
+        versions = list(get_pyenv_pythons(pyenv_fld))
+        run_mock.assert_not_called()
 
     assert versions == []
 
@@ -157,7 +159,7 @@ def test_fs_versions_nix(fs):
 
 
 @pytest.mark.skipif(sys.platform == "win32", reason="Test for non-Windows only")
-def test_invalid_ver_nix(fs):
+def test_invalid_ver_nix(fs, uses_details_script):
     # Test folders in fake file system
 
     tmpdir = "~/.pyenv/versions"
@@ -183,7 +185,10 @@ def test_invalid_ver_nix(fs):
     fs.create_dir(os.path.join(py3_folder, "bin"))
     fs.create_file(py3_exe)
 
-    versions = list(get_pyenv_pythons(tmpdir))
+    with patch("subprocess.run") as run_mock:
+        run_mock.side_effect = OSError("Failure")
+        versions = list(get_pyenv_pythons(tmpdir))
+        assert run_mock.call_count == 3
 
     assert versions == []
 

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

@@ -1,2 +0,0 @@
-__version__ = "0.5.3"
-__version_tuple__ = (0, 5, 3)

ducktools_pythonfinder-0.5.3/src/ducktools/pythonfinder/win32/pyenv_search.py

@@ -1,81 +0,0 @@
-# ducktools-pythonfinder
-# MIT License
-#
-# Copyright (c) 2023-2024 David C Ellis
-#
-# 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.
-from __future__ import annotations
-
-import os
-import os.path
-from _collections_abc import Iterator
-
-from ..shared import PythonInstall, get_install_details
-
-
-PYENV_VERSIONS_FOLDER = os.path.join(os.environ.get("PYENV_ROOT", ""), "versions")
-
-
-def get_pyenv_pythons(
-    versions_folder: str | os.PathLike = PYENV_VERSIONS_FOLDER,
-) -> Iterator[PythonInstall]:
-    if not os.path.exists(versions_folder):
-        return
-
-    for p in os.scandir(versions_folder):
-        path_base = os.path.basename(p.path)
-
-        if path_base.startswith("pypy"):
-            executable = os.path.join(p.path, "pypy.exe")
-            if os.path.exists(executable):
-                yield get_install_details(executable)
-        elif path_base.startswith("graalpy"):
-            # Graalpy exe in bin subfolder
-            executable = os.path.join(p.path, "bin", "graalpy.exe")
-            if os.path.exists(executable):
-                yield get_install_details(executable)
-        else:
-            # Regular CPython
-            executable = os.path.join(p.path, "python.exe")
-
-            if os.path.exists(executable):
-                split_version = p.name.split("-")
-
-                # If there are 1 or 2 arguments this is a recognised version
-                # Otherwise it is unrecognised
-                if len(split_version) == 2:
-                    version, arch = split_version
-
-                    # win32 in pyenv name means 32 bit python install
-                    # 'arm' is the only alternative which will be 64bit
-                    arch = "32bit" if arch == "win32" else "64bit"
-                    try:
-                        yield PythonInstall.from_str(
-                            version, executable, architecture=arch
-                        )
-                    except ValueError:
-                        pass
-                elif len(split_version) == 1:
-                    version = split_version[0]
-                    try:
-                        yield PythonInstall.from_str(
-                            version, executable, architecture="64bit"
-                        )
-                    except ValueError:
-                        pass