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

{ducktools_pythonfinder-0.5.4/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.4
+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.4 → 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
@@ -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.5.5/src/ducktools/pythonfinder/_version.py

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

{ducktools_pythonfinder-0.5.4 → 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.4 → ducktools_pythonfinder-0.5.5}/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)
@@ -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.5.5/src/ducktools_pythonfinder.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ducktools-pythonfinder
-Version: 0.5.4
+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.4/src/ducktools/pythonfinder/_version.py

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