ducktools-pythonfinder 0.8.1__tar.gz → 0.8.3__tar.gz

{ducktools_pythonfinder-0.8.1/src/ducktools_pythonfinder.egg-info → ducktools_pythonfinder-0.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: ducktools-pythonfinder
-Version: 0.8.1
+Version: 0.8.3
 Summary: Cross platform tool to find available python installations
 Author: David C Ellis
 Project-URL: Homepage, https://github.com/davidcellis/ducktools-pythonfinder
@@ -25,6 +25,7 @@ Provides-Extra: testing
 Requires-Dist: pytest; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
 Requires-Dist: pyfakefs; extra == "testing"
+Dynamic: license-file
 
 # ducktools: pythonfinder #
 

{ducktools_pythonfinder-0.8.1 → ducktools_pythonfinder-0.8.3}/src/ducktools/pythonfinder/__init__.py

@@ -20,7 +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
 # Find platform python versions
 
 __all__ = [
@@ -43,10 +43,10 @@ else:
     from .linux import get_python_installs
 
 
-def list_python_installs(*, query_executables: bool = True, finder: "DetailFinder | None" = None):
+def list_python_installs(*, finder: DetailFinder | None = None):
     finder = DetailFinder() if finder is None else finder
     return sorted(
-        get_python_installs(query_executables=query_executables, finder=finder),
+        get_python_installs(finder=finder),
         reverse=True,
         key=lambda x: (x.version[3], *x.version[:3], x.version[4])
     )

{ducktools_pythonfinder-0.8.1 → ducktools_pythonfinder-0.8.3}/src/ducktools/pythonfinder/__main__.py

@@ -115,11 +115,6 @@ def get_parser():
         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)
 
@@ -169,7 +164,6 @@ 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("."))
@@ -178,7 +172,7 @@ def display_local_installs(
     if compatible:
         compatible = tuple(int(i) for i in compatible.split("."))
 
-    installs = list_python_installs(query_executables=query_executables)
+    installs = list_python_installs()
 
     headings = ["Version", "Executable Location"]
 
@@ -333,7 +327,6 @@ def main():
                 min_ver=vals.min,
                 max_ver=vals.max,
                 compatible=vals.compatible,
-                query_executables=not vals.fast,
             )
     else:
         # No arguments to parse

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

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

{ducktools_pythonfinder-0.8.1 → ducktools_pythonfinder-0.8.3}/src/ducktools/pythonfinder/details_script.py

@@ -90,7 +90,6 @@ def get_details():
                 freethreaded = bool(sysconfig.get_config_var("Py_GIL_DISABLED"))
                 metadata["freethreaded"] = freethreaded
 
-
     install = dict(
         version=list(sys.version_info),
         executable=sys.executable,

{ducktools_pythonfinder-0.8.1 → ducktools_pythonfinder-0.8.3}/src/ducktools/pythonfinder/linux/__init__.py

@@ -73,7 +73,6 @@ def get_path_pythons(*, finder: DetailFinder | None = None) -> Iterator[PythonIn
 
 def get_python_installs(
     *,
-    query_executables: bool = True,
     finder: DetailFinder | None = None,
 ) -> Iterator[PythonInstall]:
     listed_pythons = set()
@@ -81,12 +80,10 @@ def get_python_installs(
     finder = DetailFinder() if finder is None else finder
 
     chain_commands = [
-        get_pyenv_pythons(query_executables=query_executables, finder=finder),
-        get_uv_pythons(query_executables=query_executables, finder=finder),
+        get_pyenv_pythons(finder=finder),
+        get_uv_pythons(finder=finder),
+        get_path_pythons(finder=finder),
     ]
-    if query_executables:
-        chain_commands.append(get_path_pythons(finder=finder))
-
     with finder:
         for py in itertools.chain.from_iterable(chain_commands):
             if py.executable not in listed_pythons:

{ducktools_pythonfinder-0.8.1 → ducktools_pythonfinder-0.8.3}/src/ducktools/pythonfinder/linux/pyenv_search.py

@@ -32,7 +32,7 @@ from _collections_abc import Iterator
 
 from ducktools.lazyimporter import LazyImporter, FromImport, ModuleImport
 
-from ..shared import PythonInstall, DetailFinder, FULL_PY_VER_RE, INSTALLER_CACHE_PATH, version_str_to_tuple
+from ..shared import PythonInstall, DetailFinder, INSTALLER_CACHE_PATH
 
 _laz = LazyImporter(
     [
@@ -42,9 +42,6 @@ _laz = LazyImporter(
     ]
 )
 
-# pyenv folder name for pypy
-PYPY_VER_RE = r"^pypy(?P<pyversion>\d{1,2}\.\d+)-(?P<pypyversion>[\d\.]*)$"
-
 
 def get_pyenv_root() -> str | None:
     # Check if the environment variable exists, if so use that
@@ -77,7 +74,6 @@ def get_pyenv_root() -> str | None:
 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:
@@ -95,28 +91,13 @@ def get_pyenv_pythons(
 
     with finder:
         for p in sorted(os.scandir(versions_folder), key=lambda x: x.path):
-            executable = os.path.join(p.path, "bin/python")
+            # Don't include folders that are venvs
+            venv_indicator = os.path.join(p.path, "pyvenv.cfg")
+            if os.path.exists(venv_indicator):
+                continue
 
+            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"))
-                ):
+                install = finder.get_install_details(executable, managed_by="pyenv")
+                if install:
                     yield install

{ducktools_pythonfinder-0.8.1 → ducktools_pythonfinder-0.8.3}/src/ducktools/pythonfinder/shared.py

@@ -225,12 +225,18 @@ class DetailFinder(Prefab):
         self._raw_cache = {}
         self._dirty_cache = True
 
-    def query_install(self, exe_path: str, managed_by: str | None = None) -> PythonInstall | None:
+    def query_install(
+        self,
+        exe_path: str,
+        managed_by: str | None = None,
+        metadata: dict | 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)
+        :param metadata: Dictionary of install metadata
         :return: a PythonInstall if one exists at the exe Path
         """
         try:
@@ -273,9 +279,19 @@ class DetailFinder(Prefab):
         except _laz.json.JSONDecodeError:
             return None
 
-        return PythonInstall.from_json(**output, managed_by=managed_by)
+        if metadata:
+            output["metadata"].update(metadata)
+
+        install = PythonInstall.from_json(**output, managed_by=managed_by)
 
-    def get_install_details(self, exe_path: str, managed_by=None) -> PythonInstall | None:
+        return install
+
+    def get_install_details(
+        self,
+        exe_path: str,
+        managed_by: str | None = None,
+        metadata: dict | None = None,
+    ) -> PythonInstall | None:
         exe_path = os.path.abspath(exe_path)
         mtime = os.stat(exe_path).st_mtime
 
@@ -287,7 +303,7 @@ class DetailFinder(Prefab):
                 self.raw_cache.pop(exe_path)
 
         if install is None:
-            install = self.query_install(exe_path, managed_by)
+            install = self.query_install(exe_path, managed_by, metadata)
             if install:
                 self.raw_cache[exe_path] = {
                     "mtime": mtime,
@@ -416,6 +432,7 @@ def get_folder_pythons(
     base_folder: str | os.PathLike,
     basenames: tuple[str] = ("python", "pypy"),
     finder: DetailFinder | None = None,
+    managed_by: str | None = None,
 ):
     regexes = [_python_exe_regex(name) for name in basenames]
 
@@ -440,7 +457,7 @@ def get_folder_pythons(
                         continue
                 else:
                     p = file_path.path
-                install = finder.get_install_details(p)
+                install = finder.get_install_details(p, managed_by=managed_by)
                 if install:
                     yield install
 
@@ -483,7 +500,6 @@ def get_uv_python_path() -> str | None:
 
 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"
@@ -493,35 +509,12 @@ def _implementation_from_uv_dir(
     finder = DetailFinder() if finder is None else finder
 
     if os.path.exists(python_path):
-        if match := _laz.re.fullmatch(UV_PYTHON_RE, direntry.name):
-            implementation, version, extra, platform, arch = match.groups()
-            metadata = {
-                "freethreaded": "freethreaded" in extra,
-            }
-
-            try:
-                if implementation in {"cpython"}:
-                    install = PythonInstall.from_str(
-                        version=version,
-                        executable=python_path,
-                        architecture="32bit" if arch in {"i686", "armv7"} else "64bit",
-                        implementation=implementation,
-                        metadata=metadata,
-                        managed_by="Astral",
-                    )
-            except ValueError:
-                pass
-
-        if install is None:
-            # Directory name format has changed or this is an alternate implementation
-            # Slow backup - ask python itself
-            if query_executables:
-                install = finder.get_install_details(python_path, managed_by="Astral")
+        install = finder.get_install_details(python_path, managed_by="Astral")
 
     return install
 
 
-def get_uv_pythons(query_executables=True, finder=None) -> Iterator[PythonInstall]:
+def get_uv_pythons(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():
@@ -532,6 +525,6 @@ def get_uv_pythons(query_executables=True, finder=None) -> Iterator[PythonInstal
                 for f in fld:
                     if (
                         f.is_dir()
-                        and (install := _implementation_from_uv_dir(f, query_executables, finder=finder))
+                        and (install := _implementation_from_uv_dir(f, finder=finder))
                     ):
                         yield install

{ducktools_pythonfinder-0.8.1 → ducktools_pythonfinder-0.8.3}/src/ducktools/pythonfinder/win32/__init__.py

@@ -32,7 +32,6 @@ from .registry_search import get_registered_pythons
 
 def get_python_installs(
     *,
-    query_executables: bool = True,
     finder: DetailFinder | None = None
 ) -> Iterator[PythonInstall]:
     listed_installs = set()
@@ -42,8 +41,8 @@ def get_python_installs(
     with finder:
         for py in itertools.chain(
             get_registered_pythons(),
-            get_pyenv_pythons(query_executables=query_executables, finder=finder),
-            get_uv_pythons(query_executables=query_executables, finder=finder),
+            get_pyenv_pythons(finder=finder),
+            get_uv_pythons(finder=finder),
         ):
             if py.executable not in listed_installs:
                 yield py

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

@@ -0,0 +1,75 @@
+# ducktools-pythonfinder
+# MIT License
+#
+# Copyright (c) 2023-2025 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, DetailFinder
+
+
+def get_pyenv_root() -> str | None:
+    # Check if the environment variable exists, if so use that
+    # Windows PYENV does not have the `pyenv root` command to use as a backup.
+    pyenv_root = os.environ.get("PYENV_ROOT")
+    return pyenv_root
+
+
+def get_pyenv_pythons(
+    versions_folder: str | os.PathLike | None = None,
+    *,
+    finder: DetailFinder | None = None,
+) -> Iterator[PythonInstall]:
+
+    if versions_folder is None:
+        if pyenv_root := get_pyenv_root():
+            versions_folder = os.path.join(pyenv_root, "versions")
+
+    if versions_folder is None or not os.path.exists(versions_folder):
+        return
+
+    finder = DetailFinder() if finder is None else finder
+
+    with finder:
+        for p in os.scandir(versions_folder):
+            # On windows, venv folders usually have the python.exe in \Scripts\
+            # while runtimes have it in the base folder so venvs shouldn't be disovered
+            # but exclude them early anyway
+            venv_indicator = os.path.join(p.path, "pyvenv.cfg")
+            if os.path.exists(venv_indicator):
+                continue
+
+            path_base = os.path.basename(p.path)
+
+            if path_base.startswith("pypy"):
+                executable = os.path.join(p.path, "pypy.exe")
+            elif path_base.startswith("graalpy"):
+                # Graalpy exe in bin subfolder
+                executable = os.path.join(p.path, "bin", "graalpy.exe")
+            else:
+                # Try python.exe
+                executable = os.path.join(p.path, "python.exe")
+
+            if os.path.exists(executable):
+                yield finder.get_install_details(executable, managed_by="pyenv")

ducktools_pythonfinder-0.8.3/src/ducktools/pythonfinder/win32/registry_search.py

@@ -0,0 +1,124 @@
+# ducktools-pythonfinder
+# MIT License
+#
+# Copyright (c) 2023-2025 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
+
+"""
+Search the Windows registry to find python installs
+
+Based on PEP 514 registry entries.
+"""
+
+import os.path
+import winreg  # noqa  # pycharm seems to think winreg doesn't exist in python3.12
+from _collections_abc import Iterator
+
+from ..shared import DetailFinder, PythonInstall, version_str_to_tuple
+
+exclude_companies = {
+    "PyLauncher",  # pylauncher is special cased to be ignored
+}
+
+
+check_pairs = [
+    # Keys defined in PEP 514
+    (winreg.HKEY_CURRENT_USER, r"SOFTWARE\Python", 0),
+    (winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\Python", winreg.KEY_WOW64_64KEY),
+    # For system wide 32 bit python installs
+    (winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\Python", winreg.KEY_WOW64_32KEY),
+]
+
+
+def enum_keys(key):
+    subkey_count, _, _ = winreg.QueryInfoKey(key)
+    for i in range(subkey_count):
+        yield winreg.EnumKey(key, i)
+
+
+def enum_values(key):
+    _, value_count, _ = winreg.QueryInfoKey(key)
+    for i in range(value_count):
+        yield winreg.EnumValue(key, i)
+
+
+def get_registered_pythons(finder: DetailFinder | None = None) -> Iterator[PythonInstall]:
+    finder = DetailFinder() if finder is None else finder
+
+    with finder:
+        for base, py_folder, flags in check_pairs:
+            base_key = None
+            try:
+                base_key = winreg.OpenKeyEx(base, py_folder, access=winreg.KEY_READ | flags)
+            except FileNotFoundError:
+                continue
+            else:
+                # Query the base folder eg: HKEY_LOCAL_MACHINE\SOFTWARE\Python
+                # The values here should be "companies" as defined in the PEP
+                for company in enum_keys(base_key):
+                    if company in exclude_companies:
+                        continue
+
+                    with winreg.OpenKey(base_key, company) as company_key:
+                        comp_metadata = {
+                            "Company": company
+                        }
+
+                        for name, data, _ in enum_values(company_key):
+                            comp_metadata[f"Company{name}"] = data
+
+                        for py_keyname in enum_keys(company_key):
+                            metadata = {
+                                **comp_metadata,
+                                "Tag": py_keyname,
+                            }
+
+                            with winreg.OpenKey(company_key, py_keyname) as py_key:
+                                for name, data, _ in enum_values(py_key):
+                                    metadata[name] = data
+
+                                install_key = None
+                                try:
+                                    install_key = winreg.OpenKey(py_key, "InstallPath")
+                                    python_path, _ = winreg.QueryValueEx(
+                                        install_key,
+                                        "ExecutablePath",
+                                    )
+                                except FileNotFoundError:
+                                    python_path = None
+                                finally:
+                                    if install_key:
+                                        winreg.CloseKey(install_key)
+
+                                metadata["InWindowsRegistry"] = True
+
+                            if python_path:
+                                # Pyenv puts architecture information in the Version value for some reason
+                                if os.path.isfile(python_path):
+                                    yield finder.get_install_details(
+                                        python_path,
+                                        managed_by=metadata["Company"],
+                                        metadata=metadata,
+                                    )
+
+            finally:
+                if base_key:
+                    winreg.CloseKey(base_key)

{ducktools_pythonfinder-0.8.1 → ducktools_pythonfinder-0.8.3/src/ducktools_pythonfinder.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: ducktools-pythonfinder
-Version: 0.8.1
+Version: 0.8.3
 Summary: Cross platform tool to find available python installations
 Author: David C Ellis
 Project-URL: Homepage, https://github.com/davidcellis/ducktools-pythonfinder
@@ -25,6 +25,7 @@ Provides-Extra: testing
 Requires-Dist: pytest; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
 Requires-Dist: pyfakefs; extra == "testing"
+Dynamic: license-file
 
 # ducktools: pythonfinder #
 

{ducktools_pythonfinder-0.8.1 → ducktools_pythonfinder-0.8.3}/tests/test_cache.py

@@ -210,7 +210,7 @@ def test_changed_stat_invalidates(run_mock, temp_finder):
 
             assert temp_finder.raw_cache[fake_abspath]["mtime"] == 1739886571
 
-            querymock.assert_called_with(fake_abspath, None)
+            querymock.assert_called_with(fake_abspath, None, None)
             querymock.reset_mock()
 
             with temp_finder:

{ducktools_pythonfinder-0.8.1 → ducktools_pythonfinder-0.8.3}/tests/test_foldersearch.py

@@ -119,7 +119,7 @@ def test_get_folder_pythons(fs, temp_finder):
     fs.create_file(pypy_exe)
     fs.create_file(non_python_file)
 
-    def mock_func(pth):
+    def mock_func(pth, managed_by=None, metadata=None):
         return pth
 
     with patch.object(
@@ -130,8 +130,8 @@ def test_get_folder_pythons(fs, temp_finder):
 
         get_dets.assert_has_calls(
             [
-                call(python_exe),
-                call(pypy_exe),
+                call(python_exe, managed_by=None),
+                call(pypy_exe, managed_by=None),
             ],
             any_order=True,
         )

{ducktools_pythonfinder-0.8.1 → ducktools_pythonfinder-0.8.3}/tests/test_pyenv.py

@@ -31,7 +31,7 @@ from pathlib import Path
 import pytest
 from unittest.mock import patch, Mock
 
-from ducktools.pythonfinder.shared import PythonInstall
+from ducktools.pythonfinder.shared import PythonInstall, DetailFinder
 from ducktools.pythonfinder import details_script
 
 if sys.platform == "win32":
@@ -90,80 +90,91 @@ def test_mock_versions_folder(temp_finder):
     mock_dir_entry.name = out_ver
     mock_dir_entry.path = os.path.join(versions_folder, out_ver)
 
-    with patch("os.path.exists") as exists_mock, patch("os.scandir") as scandir_mock:
-        exists_mock.return_value = True
-        scandir_mock.return_value = iter([mock_dir_entry])
+    with patch("os.path.exists") as exists_mock, \
+            patch("os.scandir") as scandir_mock, \
+            patch.object(DetailFinder, "get_install_details") as details_mock:
 
-        python_versions = list(get_pyenv_pythons(versions_folder="~/fake/versions", finder=temp_finder))
+        assert os.path.exists is exists_mock
 
-    assert python_versions == [PythonInstall.from_str(version=out_ver, executable=out_executable, managed_by="pyenv")]
+        return_val = PythonInstall.from_str(version=out_ver, executable=out_executable, managed_by="pyenv")
+        details_mock.return_value = return_val
 
+        def false_on_venv_check(pth):
+            # Need to return False on the venv check, but True on all other exists checks
+            return False if pth.endswith("pyvenv.cfg") else True
 
-@pytest.mark.skipif(sys.platform != "win32", reason="Test for Windows only")
-def test_fs_versions_win(fs, temp_finder):
-    # Test with folders in fake file system
+        exists_mock.side_effect = false_on_venv_check
+        scandir_mock.return_value = iter([mock_dir_entry])
 
-    tmpdir = "c:\\fake_folder"
+        python_versions = list(get_pyenv_pythons(versions_folder=versions_folder, finder=temp_finder))
 
-    py_folder = os.path.join(tmpdir, "3.12.1")
-    py_exe = os.path.join(py_folder, "python.exe")
+        details_mock.assert_called_once_with(out_executable, managed_by="pyenv")
 
-    fs.create_dir(py_folder)
-    fs.create_file(py_exe)
+    assert python_versions == [return_val]
 
-    versions = list(get_pyenv_pythons(tmpdir, finder=temp_finder))
 
-    assert versions == [PythonInstall.from_str(version="3.12.1", executable=py_exe, managed_by="pyenv")]
+def test_mock_folder_skip_venv(temp_finder):
+    # If the venv check returns true, make sure the folder is skipped
+    mock_dir_entry = Mock(os.DirEntry)
 
+    out_ver = "3.12.1"
+    if sys.platform == "win32":
+        versions_folder = os.path.join("c:", "fake", "versions")
+        out_executable = os.path.join(versions_folder, out_ver, "python.exe")
+    else:
+        versions_folder = "~/fake/versions"
+        out_executable = os.path.join(versions_folder, out_ver, "bin/python")
 
-@pytest.mark.skipif(sys.platform != "win32", reason="Test for Windows only")
-def test_32bit_version(fs, temp_finder):
-    # Test with folders in fake file system
+    mock_dir_entry.name = out_ver
+    mock_dir_entry.path = os.path.join(versions_folder, out_ver)
 
-    tmpdir = "c:\\fake_folder"
+    with patch("os.path.exists") as exists_mock, \
+            patch("os.scandir") as scandir_mock, \
+            patch.object(DetailFinder, "get_install_details") as details_mock:
 
-    py_folder = os.path.join(tmpdir, "3.12.1-win32")
-    py_exe = os.path.join(py_folder, "python.exe")
+        assert os.path.exists is exists_mock
 
-    fs.create_dir(py_folder)
-    fs.create_file(py_exe)
+        return_val = PythonInstall.from_str(version=out_ver, executable=out_executable, managed_by="pyenv")
+        details_mock.return_value = return_val
+
+        exists_mock.return_value = True
+        scandir_mock.return_value = iter([mock_dir_entry])
+
+        python_versions = list(get_pyenv_pythons(versions_folder=versions_folder, finder=temp_finder))
 
-    versions = list(get_pyenv_pythons(tmpdir, finder=temp_finder))
+        details_mock.assert_not_called()
 
-    assert versions == [
-        PythonInstall.from_str(version="3.12.1", executable=py_exe, architecture="32bit", managed_by="pyenv")
-    ]
+    assert python_versions == []
 
 
 @pytest.mark.skipif(sys.platform != "win32", reason="Test for Windows only")
-def test_invalid_ver_win(fs, uses_details_script, temp_finder):
-    # Ignore non-standard versions
+def test_fs_versions_win(fs, temp_finder):
+    # Test with folders in fake file system
 
-    pyenv_fld = "C:\\Fake_Folder"
+    tmpdir = "c:\\fake_folder"
 
-    py_folder = os.path.join(pyenv_fld, "external-python3.12.1")
+    py_folder = os.path.join(tmpdir, "3.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(pyenv_fld, "ext3.13.0")
-    py2_exe = os.path.join(py2_folder, "python.exe")
-
-    fs.create_dir(py2_folder)
-    fs.create_file(py2_exe)
+    with patch.object(DetailFinder, "get_install_details") as details_mock:
+        return_val = PythonInstall.from_str(version="3.12.1", executable=py_exe, managed_by="pyenv")
+        details_mock.return_value = return_val
+        versions = list(get_pyenv_pythons(tmpdir, finder=temp_finder))
 
-    py3_folder = os.path.join(pyenv_fld, "invalid-version-3.12.1")
-    py3_exe = os.path.join(py3_folder, "python.exe")
+        details_mock.assert_called_once_with(py_exe, managed_by="pyenv")
 
-    fs.create_dir(py3_folder)
-    fs.create_file(py3_exe)
+        assert versions == [return_val]
 
-    with patch("subprocess.run") as run_mock:
-        versions = list(get_pyenv_pythons(pyenv_fld, finder=temp_finder))
-        run_mock.assert_not_called()
+        # Check presence of a 'pyvenv.cfg' ignores the folder
+        details_mock.reset_mock()
+        fs.create_file(os.path.join(py_folder, "pyvenv.cfg"))
 
-    assert versions == []
+        versions = list(get_pyenv_pythons(tmpdir, finder=temp_finder))
+        details_mock.assert_not_called()
+        assert versions == []
 
 
 @pytest.mark.skipif(sys.platform == "win32", reason="Test for non-Windows only")
@@ -179,9 +190,22 @@ def test_fs_versions_nix(fs, temp_finder):
     fs.create_dir(os.path.join(py_folder, "bin"))
     fs.create_file(py_exe)
 
-    versions = list(get_pyenv_pythons(tmpdir, finder=temp_finder))
+    with patch.object(DetailFinder, "get_install_details") as details_mock:
+        return_val = PythonInstall.from_str(version="3.12.1", executable=py_exe, managed_by="pyenv")
+        details_mock.return_value = return_val
+
+        versions = list(get_pyenv_pythons(tmpdir, finder=temp_finder))
+        details_mock.assert_called_once_with(py_exe, managed_by="pyenv")
+
+        assert versions == [return_val]
+
+        details_mock.reset_mock()
 
-    assert versions == [PythonInstall.from_str(version="3.12.1", executable=py_exe, managed_by="pyenv")]
+        # Test the same folder is ignored if a 'pyvenv.cfg' file is discovered
+        fs.create_file(os.path.join(py_folder, "pyvenv.cfg"))
+        versions = list(get_pyenv_pythons(tmpdir, finder=temp_finder))
+        details_mock.assert_not_called()
+        assert versions == []
 
 
 @pytest.mark.skipif(sys.platform == "win32", reason="Test for non-Windows only")

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

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

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

@@ -1,106 +0,0 @@
-# ducktools-pythonfinder
-# MIT License
-#
-# Copyright (c) 2023-2025 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, DetailFinder
-
-
-def get_pyenv_root() -> str | None:
-    # Check if the environment variable exists, if so use that
-    # Windows PYENV does not have the `pyenv root` command to use as a backup.
-    pyenv_root = os.environ.get("PYENV_ROOT")
-    return pyenv_root
-
-
-def get_pyenv_pythons(
-    versions_folder: str | os.PathLike | None = None,
-    *,
-    query_executables: bool = True,
-    finder: DetailFinder | None = None,
-) -> Iterator[PythonInstall]:
-
-    if versions_folder is None:
-        if pyenv_root := get_pyenv_root():
-            versions_folder = os.path.join(pyenv_root, "versions")
-
-    if versions_folder is None or not os.path.exists(versions_folder):
-        return
-
-    finder = DetailFinder() if finder is None else finder
-
-    with finder:
-        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 finder.get_install_details(executable, managed_by="pyenv")
-                        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 finder.get_install_details(executable, managed_by="pyenv")
-                        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=version,
-                            executable=executable,
-                            architecture=arch,
-                            managed_by="pyenv",
-                        )
-                    except ValueError:
-                        pass
-                elif len(split_version) == 1:
-                    version = split_version[0]
-                    try:
-                        yield PythonInstall.from_str(
-                            version=version,
-                            executable=executable,
-                            architecture="64bit",
-                            managed_by="pyenv",
-                        )
-                    except ValueError:
-                        pass

ducktools_pythonfinder-0.8.1/src/ducktools/pythonfinder/win32/registry_search.py

@@ -1,136 +0,0 @@
-# ducktools-pythonfinder
-# MIT License
-#
-# Copyright (c) 2023-2025 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
-
-"""
-Search the Windows registry to find python installs
-
-Based on PEP 514 registry entries.
-"""
-
-import winreg  # noqa  # pycharm seems to think winreg doesn't exist in python3.12
-from _collections_abc import Iterator
-
-from ..shared import PythonInstall, version_str_to_tuple
-
-exclude_companies = {
-    "PyLauncher",  # pylauncher is special cased to be ignored
-}
-
-
-check_pairs = [
-    # Keys defined in PEP 514
-    (winreg.HKEY_CURRENT_USER, r"SOFTWARE\Python", 0),
-    (winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\Python", winreg.KEY_WOW64_64KEY),
-    # For system wide 32 bit python installs
-    (winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\Python", winreg.KEY_WOW64_32KEY),
-]
-
-
-def enum_keys(key):
-    subkey_count, _, _ = winreg.QueryInfoKey(key)
-    for i in range(subkey_count):
-        yield winreg.EnumKey(key, i)
-
-
-def enum_values(key):
-    _, value_count, _ = winreg.QueryInfoKey(key)
-    for i in range(value_count):
-        yield winreg.EnumValue(key, i)
-
-
-def get_registered_pythons() -> Iterator[PythonInstall]:
-    for base, py_folder, flags in check_pairs:
-        base_key = None
-        try:
-            base_key = winreg.OpenKeyEx(base, py_folder, access=winreg.KEY_READ | flags)
-        except FileNotFoundError:
-            continue
-        else:
-            # Query the base folder eg: HKEY_LOCAL_MACHINE\SOFTWARE\Python
-            # The values here should be "companies" as defined in the PEP
-            for company in enum_keys(base_key):
-                if company in exclude_companies:
-                    continue
-
-                with winreg.OpenKey(base_key, company) as company_key:
-                    comp_metadata = {
-                        "Company": company
-                    }
-
-                    for name, data, _ in enum_values(company_key):
-                        comp_metadata[f"Company{name}"] = data
-
-                    for py_keyname in enum_keys(company_key):
-                        metadata = {
-                            **comp_metadata,
-                            "Tag": py_keyname,
-                        }
-
-                        with winreg.OpenKey(company_key, py_keyname) as py_key:
-                            for name, data, _ in enum_values(py_key):
-                                metadata[name] = data
-
-                            install_key = None
-                            try:
-                                install_key = winreg.OpenKey(py_key, "InstallPath")
-                                python_path, _ = winreg.QueryValueEx(
-                                    install_key,
-                                    "ExecutablePath",
-                                )
-                            except FileNotFoundError:
-                                python_path = None
-                            finally:
-                                if install_key:
-                                    winreg.CloseKey(install_key)
-
-                            python_version: str | None = metadata.get("Version")
-
-                            architecture = metadata.get("SysArchitecture")
-
-                            metadata["InWindowsRegistry"] = True
-
-                        if python_path and python_version:
-                            # Pyenv puts architecture information in the Version value for some reason
-                            python_version = python_version.split("-")[0]
-                            version_tuple = version_str_to_tuple(python_version)
-
-                            if (
-                                version_tuple >= (3, 13)
-                                and "freethreaded" in metadata.get("DisplayName", "")
-                            ):
-                                metadata["freethreaded"] = True
-                            try:
-                                yield PythonInstall(
-                                    version=version_tuple,
-                                    executable=python_path,
-                                    architecture=architecture,
-                                    metadata=metadata,
-                                    managed_by=metadata["Company"],
-                                )
-                            except ValueError:
-                                pass
-
-        finally:
-            if base_key:
-                winreg.CloseKey(base_key)