ducktools-pythonfinder 0.5.4__tar.gz → 0.6.0__tar.gz

{ducktools_pythonfinder-0.5.4/src/ducktools_pythonfinder.egg-info → ducktools_pythonfinder-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ducktools-pythonfinder
-Version: 0.5.4
+Version: 0.6.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.5.4 → ducktools_pythonfinder-0.6.0}/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
@@ -140,23 +141,16 @@ def display_local_installs(
         compatible = tuple(int(i) for i in compatible.split("."))
 
     installs = list_python_installs(query_executables=query_executables)
-    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} |"
 
-    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
@@ -190,7 +184,35 @@ def display_local_installs(
         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(

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

@@ -0,0 +1,2 @@
+__version__ = "0.6.0"
+__version_tuple__ = (0, 6, 0)

{ducktools_pythonfinder-0.5.4 → ducktools_pythonfinder-0.6.0}/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.4 → ducktools_pythonfinder-0.6.0}/src/ducktools/pythonfinder/shared.py

@@ -46,7 +46,7 @@ _laz = LazyImporter(
 )
 
 
-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):
@@ -57,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"
@@ -131,6 +131,7 @@ class PythonInstall(Prefab):
     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,
@@ -147,6 +148,22 @@ class PythonInstall(Prefab):
     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,
@@ -242,7 +259,6 @@ def get_install_details(executable: str) -> PythonInstall | None:
     try:
         output = _laz.json.loads(detail_output)
     except _laz.json.JSONDecodeError as e:
-        print(e)
         return None
 
     return PythonInstall.from_json(**output)
@@ -275,7 +291,7 @@ def get_uv_python_path() -> str | None:
             text=True,
             capture_output=True
         )
-    except _laz.subprocess.CalledProcessError:
+    except (_laz.subprocess.CalledProcessError, FileNotFoundError):
         uv_python_dir = None
     else:
         # remove newline
@@ -302,7 +318,7 @@ def _implementation_from_uv_dir(
             if query_executables:
                 install = get_install_details(python_path)
         else:
-            if implementation in {"cpython", "pypy"}:
+            if implementation in {"cpython"}:
                 install = PythonInstall.from_str(
                     version=version,
                     executable=python_path,

{ducktools_pythonfinder-0.5.4 → ducktools_pythonfinder-0.6.0/src/ducktools_pythonfinder.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ducktools-pythonfinder
-Version: 0.5.4
+Version: 0.6.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.5.4 → ducktools_pythonfinder-0.6.0}/src/ducktools_pythonfinder.egg-info/SOURCES.txt

@@ -30,6 +30,7 @@ tests/test_foldersearch.py
 tests/test_orgsearch.py
 tests/test_pyenv.py
 tests/test_shared.py
+tests/test_uv_finder.py
 tests/sources/python_versions.txt
 tests/sources/release.json
 tests/sources/release_file.json

{ducktools_pythonfinder-0.5.4 → ducktools_pythonfinder-0.6.0}/tests/conftest.py

@@ -35,3 +35,26 @@ def sources_folder():
 @pytest.fixture
 def uses_details_script(fs):
     fs.add_real_file(details_script.__file__)
+
+
+def pytest_addoption(parser):
+    parser.addoption(
+        "--run-uv-python",
+        action="store_true",
+        default=False,
+        help="Run tests that involve installing UV pythons",
+    )
+
+
+def pytest_configure(config):
+    config.addinivalue_line(
+        "markers", "uv_python: only run test if --run-uv-python is specified"
+    )
+
+
+def pytest_collection_modifyitems(config, items):
+    if not config.getoption("--run-uv-python"):
+        skipper = pytest.mark.skip(reason="Only run when --run-uv-python is given")
+        for item in items:
+            if "uv_python" in item.keywords:
+                item.add_marker(skipper)

ducktools_pythonfinder-0.6.0/tests/test_uv_finder.py

@@ -0,0 +1,146 @@
+# ducktools-pythonfinder
+# MIT License
+# 
+# Copyright (c) 2013-2014 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.
+
+import os
+import subprocess
+
+from tempfile import TemporaryDirectory
+
+import unittest.mock as mock
+
+
+import pytest
+
+from ducktools.pythonfinder.shared import (
+    get_uv_python_path,
+    _implementation_from_uv_dir,
+    get_uv_pythons,
+)
+
+UV_REASON = "UV is not installed - skipping tests that run UV"
+
+
+@pytest.fixture
+def uv_pythondir():
+    # Set the UV python folder to a temporary folder and
+    # yield the temporary folder value
+    uv_python_envkey = "UV_PYTHON_INSTALL_DIR"
+    old_uv_python_dir = os.environ.get(uv_python_envkey)
+    try:
+        with TemporaryDirectory() as tempdir:
+            os.environ[uv_python_envkey] = tempdir
+            yield tempdir
+    finally:
+        if old_uv_python_dir is None:
+            del os.environ[uv_python_envkey]
+        else:
+            os.environ[uv_python_envkey] = old_uv_python_dir
+
+
+class TestUVFakes:
+    def test_fake_get_uv_python_path_success(self, uv_pythondir):
+        # Test the subprocess is called correctly and returned correctly
+        with mock.patch("subprocess.run") as run_mock:
+            run_mock.return_value.stdout = f"{uv_pythondir}\n"
+
+            pydir = get_uv_python_path()
+
+            run_mock.assert_called_once_with(
+                ["uv", "python", "dir"],
+                check=True,
+                text=True,
+                capture_output=True,
+            )
+
+            assert pydir == uv_pythondir
+
+    def test_fake_get_uv_python_path_failure(self, uv_pythondir):
+        # Test the subprocess is called correctly and returned correctly
+        with mock.patch("subprocess.run") as run_mock:
+            run_mock.side_effect = subprocess.CalledProcessError(-1, "uv python dir")
+
+            pydir = get_uv_python_path()
+
+            run_mock.assert_called_once_with(
+                ["uv", "python", "dir"],
+                check=True,
+                text=True,
+                capture_output=True,
+            )
+
+            assert pydir is None
+
+    def test_fake_get_uv_python_path_notfound(self, uv_pythondir):
+        # Test the subprocess is called correctly and returned correctly
+        with mock.patch("subprocess.run") as run_mock:
+            run_mock.side_effect = FileNotFoundError("[Errno 2] No such file or directory: 'uv'")
+
+            pydir = get_uv_python_path()
+
+            run_mock.assert_called_once_with(
+                ["uv", "python", "dir"],
+                check=True,
+                text=True,
+                capture_output=True,
+            )
+
+            assert pydir is None
+
+
+@pytest.mark.skipif(get_uv_python_path() is None, reason=UV_REASON)
+class TestUVReal:
+    def test_real_get_uv_python_path(self, uv_pythondir):
+        # This checks the UV python path has actually been set
+        uv_path = get_uv_python_path()
+        assert uv_path == uv_pythondir
+
+    def test_tempdir_empty(self, uv_pythondir):
+        # Tempdir should not have any python installs initially
+        pythons = list(get_uv_pythons())
+        assert pythons == []
+
+    @pytest.mark.uv_python
+    def test_finds_installed_python(self, uv_pythondir):
+        # Install python 3.12.6 in the tempdir
+        subprocess.run(
+            ["uv", "python", "install", "3.12.6"],
+            check=True,
+        )
+
+        pythons = list(get_uv_pythons())
+        assert len(pythons) == 1
+        assert pythons[0].version_str == "3.12.6"
+        assert pythons[0].implementation == "cpython"
+
+    @pytest.mark.uv_python
+    def test_finds_installed_pypy(self, uv_pythondir):
+        subprocess.run(
+            ["uv", "python", "install", "pypy3.10"],
+            check=True,
+        )
+
+        pythons = list(get_uv_pythons())
+        assert len(pythons) == 1
+        assert pythons[0].version >= (3, 10, 14)
+        assert pythons[0].implementation == "pypy"
+        assert pythons[0].implementation_version >= (7, 3, 17)

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

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