ducktools-pythonfinder 0.1.0__py3-none-any.whl

ducktools/pythonfinder/__init__.py

@@ -0,0 +1,40 @@
+# ducktools-pythonfinder
+# Copyright (C) 2024 David C Ellis
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# Find platform python versions
+
+__version__ = "v0.1.0"
+
+__all__ = [
+    "get_python_installs",
+    "list_python_installs",
+    "PythonInstall",
+]
+
+import sys
+from .shared import PythonInstall
+
+match sys.platform:  # pragma: no cover
+    case "win32":
+        from .win32 import get_python_installs
+    case "darwin":
+        from .darwin import get_python_installs
+    case _:
+        from .linux import get_python_installs
+
+
+def list_python_installs():
+    return sorted(get_python_installs(), reverse=True, key=lambda x: x.version)

ducktools/pythonfinder/__main__.py

@@ -0,0 +1,106 @@
+# ducktools-pythonfinder
+# Copyright (C) 2024 David C Ellis
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+
+import sys
+
+from ducktools.lazyimporter import LazyImporter, ModuleImport
+from ducktools.pythonfinder import list_python_installs
+
+_laz = LazyImporter([ModuleImport("argparse")])
+
+
+def parse_args(args):
+    parser = _laz.argparse.ArgumentParser(
+        prog="ducktools-pythonfinder",
+        description="Discover base Python installs",
+    )
+    parser.add_argument("--min", help="Specify minimum Python version")
+    parser.add_argument("--max", help="Specify maximum Python version")
+    parser.add_argument("--exact", help="Specify exact Python version")
+
+    vals = parser.parse_args(args)
+
+    if vals.min:
+        min_ver = tuple(int(i) for i in vals.min.split("."))
+    else:
+        min_ver = None
+
+    if vals.max:
+        max_ver = tuple(int(i) for i in vals.max.split("."))
+    else:
+        max_ver = None
+
+    if vals.exact:
+        exact = tuple(int(i) for i in vals.exact.split("."))
+    else:
+        exact = None
+
+    return min_ver, max_ver, exact
+
+
+def main():
+    if sys.argv[1:]:
+        min_ver, max_ver, exact = parse_args(sys.argv[1:])
+    else:
+        min_ver, max_ver, exact = None, None, None
+
+    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} |"
+
+    print("Discoverable Python Installs")
+    if sys.platform == "win32":
+        print("+ - Listed in the Windows Registry ")
+    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} |")
+    for install in installs:
+        if min_ver and install.version < min_ver:
+            continue
+        elif max_ver and install.version > max_ver:
+            continue
+        elif exact:
+            mismatch = False
+            for i, val in enumerate(exact):
+                if val != install.version[i]:
+                    mismatch = True
+                    break
+            if mismatch:
+                continue
+
+        version_str = install.version_str
+        if install.executable == sys.executable:
+            version_str = f"*{version_str}"
+        elif sys.prefix != sys.base_prefix and install.executable.startswith(
+            sys.base_prefix
+        ):
+            version_str = f"**{version_str}"
+
+        if sys.platform == "win32" and install.metadata.get("InWindowsRegistry"):
+            version_str = f"+{version_str}"
+
+        print(f"| {version_str:>14s} | {install.executable:<{max_executable_len}s} |")
+
+
+main()

ducktools/pythonfinder/darwin/__init__.py

@@ -0,0 +1,19 @@
+# ducktools-pythonfinder
+# Copyright (C) 2024 David C Ellis
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""Currently just copied from linux"""
+
+from ..linux import get_python_installs, get_path_pythons, get_pyenv_pythons

ducktools/pythonfinder/details_script.py

@@ -0,0 +1,58 @@
+# ducktools-pythonfinder
+# Copyright (C) 2024 David C Ellis
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""
+Get the details from a python install as JSON
+"""
+import sys
+
+
+def get_details():
+    try:
+        implementation = sys.implementation.name
+    except AttributeError:  # pragma: no cover
+        # Probably Python 2
+        import platform
+
+        implementation = platform.python_implementation().lower()
+        metadata = {}
+    else:
+        if implementation != "cpython":  # pragma: no cover
+            metadata = {"{}_version".format(implementation): sys.implementation.version}
+        else:
+            metadata = {}
+
+    install = dict(
+        version=list(sys.version_info),
+        executable=sys.executable,
+        architecture="64bit" if (sys.maxsize > 2**32) else "32bit",
+        implementation=implementation,
+        metadata=metadata,
+    )
+
+    return install
+
+
+def main():
+    import json
+
+    install = get_details()
+
+    sys.stdout.write(json.dumps(install))
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

ducktools/pythonfinder/linux/__init__.py

@@ -0,0 +1,53 @@
+# ducktools-pythonfinder
+# Copyright (C) 2024 David C Ellis
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import os
+import os.path
+import itertools
+from _collections_abc import Iterator
+
+from ..shared import PythonInstall, get_folder_pythons
+from .pyenv_search import get_pyenv_pythons
+
+
+PATH_FOLDERS = os.environ.get("PATH").split(":")
+_PYENV_ROOT = os.environ.get("PYENV_ROOT")
+
+
+def get_path_pythons() -> Iterator[PythonInstall]:
+    exe_names = set()
+
+    for fld in PATH_FOLDERS:
+        # Don't retrieve pyenv installs
+        if _PYENV_ROOT and fld.startswith(_PYENV_ROOT):
+            continue
+        elif not os.path.exists(fld):
+            continue
+
+        for install in get_folder_pythons(fld):
+            name = os.path.basename(install.executable)
+            if name not in exe_names:
+                yield install
+                exe_names.add(name)
+
+
+def get_python_installs():
+    listed_pythons = set()
+
+    for py in itertools.chain(get_pyenv_pythons(), get_path_pythons()):
+        if py.executable not in listed_pythons:
+            yield py
+            listed_pythons.add(py.executable)

ducktools/pythonfinder/linux/pyenv_search.py

@@ -0,0 +1,80 @@
+# ducktools-pythonfinder
+# Copyright (C) 2024 David C Ellis
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""
+Discover python installs that have been created with pyenv
+"""
+
+import os
+import os.path
+from _collections_abc import Iterator
+
+from ducktools.lazyimporter import LazyImporter, ModuleImport
+
+from ..shared import PythonInstall
+from .. import details_script
+
+_laz = LazyImporter(
+    [
+        ModuleImport("re"),
+        ModuleImport("subprocess"),
+        ModuleImport("json"),
+    ]
+)
+
+# pyenv folder names
+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,
+) -> Iterator[PythonInstall]:
+    if not os.path.exists(versions_folder):
+        return
+
+    # Sorting puts standard python versions before pypy
+    # This can lead to much faster returns by potentially yielding
+    # the required python version before checking pypy
+
+    for p in sorted(os.scandir(versions_folder), key=lambda x: x.path):
+        executable = os.path.join(p.path, "bin/python")
+
+        if os.path.exists(executable):
+            if _laz.re.fullmatch(PYTHON_VER_RE, p.name):
+                yield PythonInstall.from_str(p.name, executable)
+            elif _laz.re.fullmatch(PYPY_VER_RE, p.name):
+                details_output = _laz.subprocess.run(
+                    [executable, details_script.__file__],
+                    capture_output=True,
+                    text=True,
+                ).stdout
+
+                if details_output:
+                    try:
+                        details = _laz.json.loads(details_output)
+                    except _laz.json.JSONDecodeError:
+                        pass
+                    else:
+                        yield PythonInstall.from_json(**details)

ducktools/pythonfinder/shared.py

@@ -0,0 +1,181 @@
+# ducktools-pythonfinder
+# Copyright (C) 2024 David C Ellis
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import sys
+import os
+import os.path
+
+from prefab_classes 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"),
+    ]
+)
+
+
+FULL_PY_VER_RE = r"(?P<major>\d+)\.(?P<minor>\d+)\.?(?P<micro>\d*)(?P<releaselevel>[a-zA-Z]*)(?P<serial>\d*)"
+
+
+@prefab
+class PythonInstall:
+    version: tuple[int, int, int, str, int]
+    executable: str
+    architecture: str = "64bit"
+    implementation: str = "cpython"
+    metadata: dict = attribute(default_factory=dict)
+
+    @property
+    def version_str(self) -> str:
+        major, minor, micro, releaselevel, serial = self.version
+
+        match releaselevel:
+            case "alpha":
+                releaselevel = "a"
+            case "beta":
+                releaselevel = "b"
+            case "candidate":
+                releaselevel = "rc"
+            case _:
+                releaselevel = ""
+
+        if serial == 0:
+            serial = ""
+        else:
+            serial = f"{serial}"
+
+        return f"{major}.{minor}.{micro}{releaselevel}{serial}"
+
+    @classmethod
+    def from_str(
+        cls,
+        version: str,
+        executable: str,
+        architecture: str = "64bit",
+        implementation: str = "cpython",
+        metadata: dict | None = None,
+    ):
+        parsed_version = _laz.re.fullmatch(FULL_PY_VER_RE, version)
+
+        if not parsed_version:
+            raise ValueError(f"{version!r} is not a recognised Python version string.")
+
+        major, minor, micro, releaselevel, serial = parsed_version.groups()
+
+        match releaselevel:
+            case "a":
+                releaselevel = "alpha"
+            case "b":
+                releaselevel = "beta"
+            case "rc":
+                releaselevel = "candidate"
+            case _:
+                releaselevel = "final"
+
+        version_tuple = (
+            int(major),
+            int(minor),
+            int(micro) if micro else 0,
+            releaselevel,
+            int(serial if serial != "" else 0),
+        )
+
+        # noinspection PyArgumentList
+        return cls(
+            version=version_tuple,
+            executable=executable,
+            architecture=architecture,
+            implementation=implementation,
+            metadata=metadata,
+        )
+
+    @classmethod
+    def from_json(cls, version, executable, architecture, implementation, metadata):
+        if arch_ver := metadata.get(f"{implementation}_version"):
+            metadata[f"{implementation}_version"] = tuple(arch_ver)
+
+        return cls(
+            tuple(version), executable, architecture, implementation, metadata  # noqa
+        )
+
+    def get_pip_version(self) -> str | None:
+        """
+        Get the version of pip installed on a python install.
+
+        :return: None if pip is not found or the command fails
+                 version number as string otherwise.
+        """
+        pip_call = _laz.subprocess.run(
+            [self.executable, "-c", "import pip; print(pip.__version__, end='')"],
+            text=True,
+            capture_output=True,
+        )
+
+        # Pip call failed
+        if pip_call.returncode != 0:
+            return None
+
+        return pip_call.stdout
+
+
+def _python_exe_regex(basename: str = "python"):
+    if sys.platform == "win32":
+        return _laz.re.compile(rf"{basename}\d?\.?\d*\.exe")
+    else:
+        return _laz.re.compile(rf"{basename}\d?\.?\d*")
+
+
+def get_install_details(executable: str) -> PythonInstall | None:
+    try:
+        detail_output = _laz.subprocess.run(
+            [executable, details_script.__file__],
+            capture_output=True,
+            text=True,
+            check=True,
+        ).stdout
+    except (_laz.subprocess.CalledProcessError, FileNotFoundError):
+        return None
+
+    try:
+        output = _laz.json.loads(detail_output)
+    except _laz.json.JSONDecodeError:
+        return None
+
+    return PythonInstall.from_json(**output)
+
+
+def get_folder_pythons(
+    base_folder: str | os.PathLike, basenames: tuple[str] = ("python", "pypy")
+):
+    regexes = [_python_exe_regex(name) for name in basenames]
+
+    with os.scandir(base_folder) as fld:
+        for file_path in fld:
+            if (
+                not file_path.is_symlink()
+                and file_path.is_file()
+                and any(reg.fullmatch(file_path.name) for reg in regexes)
+            ):
+                install = get_install_details(file_path.path)
+                if install:
+                    yield install

ducktools/pythonfinder/win32/__init__.py

@@ -0,0 +1,14 @@
+from _collections_abc import Iterator
+import itertools
+
+from ..shared import PythonInstall
+from .pyenv_search import get_pyenv_pythons
+from .registry_search import get_registered_pythons
+
+
+def get_python_installs() -> Iterator[PythonInstall]:
+    listed_installs = set()
+    for py in itertools.chain(get_registered_pythons(), get_pyenv_pythons()):
+        if py.executable not in listed_installs:
+            yield py
+            listed_installs.add(py.executable)

ducktools/pythonfinder/win32/pyenv_search.py

@@ -0,0 +1,57 @@
+# ducktools-pythonfinder
+# Copyright (C) 2024 David C Ellis
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import os
+import os.path
+from _collections_abc import Iterator
+
+from ..shared import PythonInstall
+
+
+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):
+        executable = os.path.join(p.path, "python.exe")
+
+        if os.path.exists(executable):
+            match p.name.split("-"):
+                case (version, arch):
+                    # 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
+                case (version,):
+                    # If no arch given pyenv will be 64 bit
+                    try:
+                        yield PythonInstall.from_str(
+                            version, executable, architecture="64bit"
+                        )
+                    except ValueError:
+                        pass
+                case _:
+                    pass  # Skip unrecognised versions