fix(env): prevent crash when invalid Python or Python 2.x is in PATH

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Change Log
 
+## [2.4.2] - Unreleased
+
+### Fixed
+
+- Fix an issue where Poetry commands fail when Python 2.7 is present in the `PATH` ([#10897](https://github.com/python-poetry/poetry/issues/10897)).
+
+
 ## [2.4.1] - 2026-05-09
 
 ### Changed

src/poetry/utils/env/python/manager.py

@@ -4,9 +4,12 @@
 import os
 import sys
 
+from subprocess import CalledProcessError
+
 from functools import cached_property
 from pathlib import Path
 from typing import TYPE_CHECKING
+from typing import Any
 from typing import NamedTuple
 from typing import cast
 from typing import overload
@@ -82,12 +85,23 @@ def __init__(
         else:
             raise ValueError("Either python or executable must be provided")
 
+    @classmethod
+    def _is_valid_python(cls, python: findpython.PythonVersion) -> bool:
+        try:
+            _ = python.interpreter
+            return True
+        except (CalledProcessError, ValueError):
+            return False
+
     @classmethod
     def find_all(cls) -> Iterator[Python]:
         venv_path: Path | None = (
             Path(venv) if (venv := os.environ.get("VIRTUAL_ENV")) else None
         )
         for python in findpython.find_all():
+            if not cls._is_valid_python(python):
+                continue
+
             if venv_path and is_relative_to(python.executable, venv_path):
                 continue
             yield cls(python=python)
@@ -175,33 +189,39 @@ def python(self) -> findpython.PythonVersion:
     def name(self) -> str:
         return cast("str", self._python.name)
 
+    def _get_python_property(self, name: str) -> Any:
+        try:
+            return getattr(self._python, name)
+        except CalledProcessError as e:
+            raise ValueError(f"Invalid Python executable: {self._python.executable}") from e
+
     @property
     def executable(self) -> Path:
-        return cast("Path", self._python.interpreter)
+        return cast("Path", self._get_python_property("interpreter"))
 
     @property
     def implementation(self) -> str:
-        return cast("str", self._python.implementation.lower())
+        return cast("str", self._get_python_property("implementation").lower())
 
     @property
     def free_threaded(self) -> bool:
-        return cast("bool", self._python.freethreaded)
+        return cast("bool", self._get_python_property("freethreaded"))
 
     @property
     def major(self) -> int:
-        return cast("int", self._python.major)
+        return cast("int", self._get_python_property("major"))
 
     @property
     def minor(self) -> int:
-        return cast("int", self._python.minor)
+        return cast("int", self._get_python_property("minor"))
 
     @property
     def patch(self) -> int:
-        return cast("int", self._python.patch)
+        return cast("int", self._get_python_property("patch"))
 
     @property
     def version(self) -> Version:
-        return Version.parse(str(self._python.version))
+        return Version.parse(str(self._get_python_property("version")))
 
     @cached_property
     def patch_version(self) -> Version:
@@ -233,11 +253,12 @@ def get_active_python(cls) -> Python | None:
                  or None if no valid environment is found.
         """
         for python in ShutilWhichPythonProvider().find_pythons():
-            return cls(python=python)
+            if cls._is_valid_python(python):
+                return cls(python=python)
 
         # fallback to findpython, restrict to finding only executables
         # named "python" as the intention here is just that, nothing more
-        if python := findpython.find("python"):
+        if (python := findpython.find("python")) and cls._is_valid_python(python):
             return cls(python=python)
 
         return None
@@ -259,11 +280,13 @@ def get_system_python(cls) -> Python:
     @classmethod
     def get_by_name(cls, python_name: str) -> Python | None:
         # Ignore broken installations.
-        with contextlib.suppress(ValueError):
-            if python := ShutilWhichPythonProvider.find_python_by_name(python_name):
+        with contextlib.suppress(ValueError, CalledProcessError):
+            if (
+                python := ShutilWhichPythonProvider.find_python_by_name(python_name)
+            ) and cls._is_valid_python(python):
                 return cls(python=python)
 
-        if python := findpython.find(python_name):
+        if (python := findpython.find(python_name)) and cls._is_valid_python(python):
             return cls(python=python)
 
         return None

tests/utils/test_python_manager.py

@@ -141,3 +141,77 @@ def test_python_find_compatible(
     python = Python.get_compatible_python(poetry)
 
     assert Version.from_parts(3, 4) <= python.version <= Version.from_parts(4, 0)
+
+
+def test_python_ignores_broken_installations(mocker: MockerFixture) -> None:
+    from subprocess import CalledProcessError
+
+    mock_good_pv = mocker.MagicMock(spec=findpython.PythonVersion)
+    mock_good_pv.executable = Path("/usr/bin/python3.12")
+    mock_good_pv.interpreter = Path("/usr/bin/python3.12")
+    mock_good_pv.version = packaging.version.Version("3.12.0")
+
+    mock_bad_pv = mocker.MagicMock(spec=findpython.PythonVersion)
+    mock_bad_pv.executable = Path("/usr/bin/python2.7")
+    type(mock_bad_pv).interpreter = mocker.PropertyMock(
+        side_effect=CalledProcessError(2, ["/usr/bin/python2.7", "-Ic", "..."])
+    )
+
+    mocker.patch("findpython.find_all", return_value=[mock_bad_pv, mock_good_pv])
+
+    pythons = list(Python.find_all())
+    assert len(pythons) == 1
+    assert pythons[0].executable == Path("/usr/bin/python3.12")
+
+
+def test_get_active_python_ignores_broken_installations(mocker: MockerFixture) -> None:
+    from subprocess import CalledProcessError
+
+    mock_bad_pv = mocker.MagicMock(spec=findpython.PythonVersion)
+    mock_bad_pv.executable = Path("/usr/bin/python2.7")
+    type(mock_bad_pv).interpreter = mocker.PropertyMock(
+        side_effect=CalledProcessError(2, ["/usr/bin/python2.7", "-Ic", "..."])
+    )
+
+    mocker.patch(
+        "poetry.utils.env.python.providers.ShutilWhichPythonProvider.find_pythons",
+        return_value=[mock_bad_pv],
+    )
+    mocker.patch("findpython.find", return_value=None)
+
+    assert Python.get_active_python() is None
+
+
+def test_get_by_name_ignores_broken_installations(mocker: MockerFixture) -> None:
+    from subprocess import CalledProcessError
+
+    mock_bad_pv = mocker.MagicMock(spec=findpython.PythonVersion)
+    mock_bad_pv.executable = Path("/usr/bin/python2.7")
+    type(mock_bad_pv).interpreter = mocker.PropertyMock(
+        side_effect=CalledProcessError(2, ["/usr/bin/python2.7", "-Ic", "..."])
+    )
+
+    mocker.patch(
+        "poetry.utils.env.python.providers.ShutilWhichPythonProvider.find_python_by_name",
+        return_value=mock_bad_pv,
+    )
+    mocker.patch("findpython.find", return_value=None)
+
+    assert Python.get_by_name("python") is None
+
+
+def test_python_properties_raise_value_error_on_subprocess_failure(
+    mocker: MockerFixture,
+) -> None:
+    from subprocess import CalledProcessError
+
+    mock_bad_pv = mocker.MagicMock(spec=findpython.PythonVersion)
+    mock_bad_pv.executable = Path("/usr/bin/python2.7")
+    type(mock_bad_pv).interpreter = mocker.PropertyMock(
+        side_effect=CalledProcessError(2, ["/usr/bin/python2.7", "-Ic", "..."])
+    )
+
+    python = Python(python=mock_bad_pv)
+    with pytest.raises(ValueError, match="Invalid Python executable"):
+        _ = python.executable
+