Rewriting python finder to eventually fix a number of issue reports.

Author: matteius

pipenv/vendor/pythonfinder/LICENSE.txt

@@ -1,10 +1,9 @@
 from __future__ import annotations
 
-from .exceptions import InvalidPythonVersion
-from .models import SystemPath
+from .exceptions import InvalidPythonVersion, PythonNotFound
+from .models.python_info import PythonInfo
 from .pythonfinder import Finder
 
-__version__ = "2.1.0"
+__version__ = "3.0.0"
 
-
-__all__ = ["Finder", "SystemPath", "InvalidPythonVersion"]
+__all__ = ["Finder", "PythonInfo", "InvalidPythonVersion", "PythonNotFound"]

pipenv/vendor/pythonfinder/__init__.py

@@ -6,61 +6,109 @@
 import sys
 from pathlib import Path
 
+# Environment variables and constants
 PYENV_ROOT = os.path.expanduser(
     os.path.expandvars(os.environ.get("PYENV_ROOT", "~/.pyenv"))
 )
 PYENV_ROOT = Path(PYENV_ROOT)
 PYENV_INSTALLED = shutil.which("pyenv") is not None
+
 ASDF_DATA_DIR = os.path.expanduser(
     os.path.expandvars(os.environ.get("ASDF_DATA_DIR", "~/.asdf"))
 )
 ASDF_INSTALLED = shutil.which("asdf") is not None
-IS_64BIT_OS = None
+
 SYSTEM_ARCH = platform.architecture()[0]
+IS_64BIT_OS = None
 
 if sys.maxsize > 2**32:
     IS_64BIT_OS = platform.machine() == "AMD64"
 else:
     IS_64BIT_OS = False
 
-
 IGNORE_UNSUPPORTED = bool(os.environ.get("PYTHONFINDER_IGNORE_UNSUPPORTED", False))
-SUBPROCESS_TIMEOUT = os.environ.get("PYTHONFINDER_SUBPROCESS_TIMEOUT", 5)
-"""The default subprocess timeout for determining python versions
+SUBPROCESS_TIMEOUT = int(os.environ.get("PYTHONFINDER_SUBPROCESS_TIMEOUT", 5))
 
-Set to **5** by default.
-"""
 
-
-def set_asdf_paths():
+def get_python_paths() -> list[str]:
+    """
+    Get a list of paths where Python executables might be found.
+    
+    Returns:
+        A list of paths to search for Python executables.
+    """
+    paths = []
+    
+    # Add paths from PATH environment variable
+    if "PATH" in os.environ:
+        paths.extend(os.environ["PATH"].split(os.pathsep))
+    
+    # Add pyenv paths if installed
+    if PYENV_INSTALLED:
+        pyenv_paths = get_pyenv_paths()
+        paths.extend(pyenv_paths)
+    
+    # Add asdf paths if installed
     if ASDF_INSTALLED:
-        python_versions = os.path.join(ASDF_DATA_DIR, "installs", "python")
-        try:
-            # Get a list of all files and directories in the given path
-            all_files_and_dirs = os.listdir(python_versions)
-            # Filter out files and keep only directories
-            for name in all_files_and_dirs:
-                if os.path.isdir(os.path.join(python_versions, name)):
-                    asdf_path = os.path.join(python_versions, name)
-                    asdf_path = os.path.join(asdf_path, "bin")
-                    os.environ["PATH"] = asdf_path + os.pathsep + os.environ["PATH"]
-        except FileNotFoundError:
-            pass
+        asdf_paths = get_asdf_paths()
+        paths.extend(asdf_paths)
+    
+    # Add Windows registry paths if on Windows
+    if os.name == "nt":
+        from .finders.windows_registry import get_registry_python_paths
+        registry_paths = get_registry_python_paths()
+        paths.extend(registry_paths)
+    
+    return paths
 
 
-def set_pyenv_paths():
-    if PYENV_INSTALLED:
-        python_versions = os.path.join(PYENV_ROOT, "versions")
-        is_windows = os.name == "nt"
-        try:
-            # Get a list of all files and directories in the given path
-            all_files_and_dirs = os.listdir(python_versions)
-            # Filter out files and keep only directories
-            for name in all_files_and_dirs:
-                if os.path.isdir(os.path.join(python_versions, name)):
-                    pyenv_path = os.path.join(python_versions, name)
-                    if not is_windows:
-                        pyenv_path = os.path.join(pyenv_path, "bin")
-                    os.environ["PATH"] = pyenv_path + os.pathsep + os.environ["PATH"]
-        except FileNotFoundError:
-            pass
+def get_pyenv_paths() -> list[str]:
+    """
+    Get a list of paths where pyenv Python executables might be found.
+    
+    Returns:
+        A list of paths to search for pyenv Python executables.
+    """
+    paths = []
+    python_versions = os.path.join(PYENV_ROOT, "versions")
+    is_windows = os.name == "nt"
+    
+    try:
+        # Get a list of all files and directories in the given path
+        all_files_and_dirs = os.listdir(python_versions)
+        # Filter out files and keep only directories
+        for name in all_files_and_dirs:
+            version_path = os.path.join(python_versions, name)
+            if os.path.isdir(version_path):
+                if not is_windows:
+                    version_path = os.path.join(version_path, "bin")
+                paths.append(version_path)
+    except FileNotFoundError:
+        pass
+    
+    return paths
+
+
+def get_asdf_paths() -> list[str]:
+    """
+    Get a list of paths where asdf Python executables might be found.
+    
+    Returns:
+        A list of paths to search for asdf Python executables.
+    """
+    paths = []
+    python_versions = os.path.join(ASDF_DATA_DIR, "installs", "python")
+    
+    try:
+        # Get a list of all files and directories in the given path
+        all_files_and_dirs = os.listdir(python_versions)
+        # Filter out files and keep only directories
+        for name in all_files_and_dirs:
+            version_path = os.path.join(python_versions, name)
+            if os.path.isdir(version_path):
+                bin_path = os.path.join(version_path, "bin")
+                paths.append(bin_path)
+    except FileNotFoundError:
+        pass
+    
+    return paths

pipenv/vendor/pythonfinder/environment.py

@@ -3,5 +3,9 @@
 
 class InvalidPythonVersion(Exception):
     """Raised when parsing an invalid python version"""
+    pass
+
 
+class PythonNotFound(Exception):
+    """Raised when a requested Python version is not found"""
     pass

pipenv/vendor/pythonfinder/exceptions.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from .base_finder import BaseFinder
+from .path_finder import PathFinder
+from .system_finder import SystemFinder
+from .pyenv_finder import PyenvFinder
+from .asdf_finder import AsdfFinder
+
+__all__ = [
+    "BaseFinder",
+    "PathFinder",
+    "SystemFinder",
+    "PyenvFinder",
+    "AsdfFinder",
+]
+
+# Import Windows registry finder if on Windows
+import os
+if os.name == "nt":
+    from .windows_registry import WindowsRegistryFinder
+    __all__.append("WindowsRegistryFinder")

pipenv/vendor/pythonfinder/finders/__init__.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Dict, List, Optional, Union
+
+from ..environment import ASDF_DATA_DIR, ASDF_INSTALLED
+from ..utils.path_utils import ensure_path
+from ..utils.version_utils import parse_asdf_version_order
+from .path_finder import PathFinder
+
+
+class AsdfFinder(PathFinder):
+    """
+    Finder that searches for Python in asdf installations.
+    """
+    
+    def __init__(
+        self,
+        data_dir: Optional[Union[str, Path]] = None,
+        ignore_unsupported: bool = True,
+    ):
+        """
+        Initialize a new AsdfFinder.
+        
+        Args:
+            data_dir: The data directory of the asdf installation.
+            ignore_unsupported: Whether to ignore unsupported Python versions.
+        """
+        if not ASDF_INSTALLED:
+            super().__init__(paths=[], ignore_unsupported=ignore_unsupported)
+            return
+        
+        self.data_dir = ensure_path(data_dir or ASDF_DATA_DIR)
+        self.installs_dir = self.data_dir / "installs" / "python"
+        
+        if not self.installs_dir.exists():
+            super().__init__(paths=[], ignore_unsupported=ignore_unsupported)
+            return
+        
+        # Get the asdf version order
+        version_order = parse_asdf_version_order()
+        
+        # Get all version directories
+        version_dirs = {}
+        for path in self.installs_dir.iterdir():
+            if path.is_dir():
+                version_dirs[path.name] = path
+        
+        # Sort the version directories according to the asdf version order
+        paths = []
+        
+        # First add the versions in the asdf version order
+        for version in version_order:
+            if version in version_dirs:
+                bin_dir = version_dirs[version] / "bin"
+                if bin_dir.exists():
+                    paths.append(bin_dir)
+                    del version_dirs[version]
+        
+        # Then add the remaining versions
+        for version_dir in version_dirs.values():
+            bin_dir = version_dir / "bin"
+            if bin_dir.exists():
+                paths.append(bin_dir)
+        
+        super().__init__(
+            paths=paths,
+            only_python=True,
+            ignore_unsupported=ignore_unsupported,
+        )