CI: Add PyPy 3.11 to CI checks (#2934)

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: esafak

.github/workflows/check.yaml

@@ -28,6 +28,7 @@ jobs:
           - "3.10"
           - "3.9"
           - "3.8"
+          - pypy-3.11
           - pypy-3.10
           - pypy-3.9
           - pypy-3.8

docs/changelog/2932.feature.rst

@@ -0,0 +1 @@
+Add PyPy 3.11 support. Contributed by :user:`esafak`.

src/virtualenv/discovery/py_info.py

@@ -192,34 +192,57 @@ def _get_tcl_tk_libs():
 
     def _fast_get_system_executable(self):
         """Try to get the system executable by just looking at properties."""
-        if self.real_prefix or (  # noqa: PLR1702
-            self.base_prefix is not None and self.base_prefix != self.prefix
-        ):  # if this is a virtual environment
-            if self.real_prefix is None:
-                base_executable = getattr(sys, "_base_executable", None)  # some platforms may set this to help us
-                if base_executable is not None:  # noqa: SIM102 # use the saved system executable if present
-                    if sys.executable != base_executable:  # we know we're in a virtual environment, cannot be us
-                        if os.path.exists(base_executable):
-                            return base_executable
-                        # Python may return "python" because it was invoked from the POSIX virtual environment
-                        # however some installs/distributions do not provide a version-less "python" binary in
-                        # the system install location (see PEP 394) so try to fallback to a versioned binary.
-                        #
-                        # Gate this to Python 3.11 as `sys._base_executable` path resolution is now relative to
-                        # the 'home' key from pyvenv.cfg which often points to the system install location.
-                        major, minor = self.version_info.major, self.version_info.minor
-                        if self.os == "posix" and (major, minor) >= (3, 11):
-                            # search relative to the directory of sys._base_executable
-                            base_dir = os.path.dirname(base_executable)
-                            for base_executable in [
-                                os.path.join(base_dir, exe) for exe in (f"python{major}", f"python{major}.{minor}")
-                            ]:
-                                if os.path.exists(base_executable):
-                                    return base_executable
-            return None  # in this case we just can't tell easily without poking around FS and calling them, bail
         # if we're not in a virtual environment, this is already a system python, so return the original executable
         # note we must choose the original and not the pure executable as shim scripts might throw us off
-        return self.original_executable
+        if not (self.real_prefix or (self.base_prefix is not None and self.base_prefix != self.prefix)):
+            return self.original_executable
+
+        # if this is NOT a virtual environment, can't determine easily, bail out
+        if self.real_prefix is not None:
+            return None
+
+        base_executable = getattr(sys, "_base_executable", None)  # some platforms may set this to help us
+        if base_executable is None:  # use the saved system executable if present
+            return None
+
+        # we know we're in a virtual environment, can not be us
+        if sys.executable == base_executable:
+            return None
+
+        # We're not in a venv and base_executable exists; use it directly
+        if os.path.exists(base_executable):
+            return base_executable
+
+        # Try fallback for POSIX virtual environments
+        return self._try_posix_fallback_executable(base_executable)
+
+    def _try_posix_fallback_executable(self, base_executable):
+        """
+        Try to find a versioned Python binary as fallback for POSIX virtual environments.
+
+        Python may return "python" because it was invoked from the POSIX virtual environment
+        however some installs/distributions do not provide a version-less "python" binary in
+        the system install location (see PEP 394) so try to fallback to a versioned binary.
+
+        Gate this to Python 3.11 as `sys._base_executable` path resolution is now relative to
+        the 'home' key from pyvenv.cfg which often points to the system install location.
+        """
+        major, minor = self.version_info.major, self.version_info.minor
+        if self.os != "posix" or (major, minor) < (3, 11):
+            return None
+
+        # search relative to the directory of sys._base_executable
+        base_dir = os.path.dirname(base_executable)
+        candidates = [f"python{major}", f"python{major}.{minor}"]
+        if self.implementation == "PyPy":
+            candidates.extend(["pypy", "pypy3", f"pypy{major}", f"pypy{major}.{minor}"])
+
+        for candidate in candidates:
+            full_path = os.path.join(base_dir, candidate)
+            if os.path.exists(full_path):
+                return full_path
+
+        return None  # in this case we just can't tell easily without poking around FS and calling them, bail
 
     def install_path(self, key):
         result = self.distutils_install.get(key)

tests/unit/discovery/py_info/test_py_info.py

@@ -162,27 +162,30 @@ def test_py_info_cache_invalidation_on_py_info_change(mocker, session_app_data):
     # 2. Spy on _run_subprocess
     spy = mocker.spy(cached_py_info, "_run_subprocess")
 
-    # 3. Modify the content of py_info.py
+    # 3. Backup py_info.py
     py_info_script = Path(cached_py_info.__file__).parent / "py_info.py"
     original_content = py_info_script.read_text(encoding="utf-8")
     original_stat = py_info_script.stat()
 
     try:
         # 4. Clear the in-memory cache
         mocker.patch.dict(cached_py_info._CACHE, {}, clear=True)  # noqa: SLF001
+
+        # 5. Modify py_info.py to invalidate the cache
         py_info_script.write_text(original_content + "\n# a comment", encoding="utf-8")
 
-        # 5. Get the PythonInfo object again
+        # 6. Get the PythonInfo object again
         info = PythonInfo.from_exe(sys.executable, session_app_data)
 
-        # 6. Assert that _run_subprocess was called again
+        # 7. Assert that _run_subprocess was called again
+        native_difference = 1 if info.system_executable == info.executable else 0
         if is_macos_brew(info):
-            assert spy.call_count in {2, 3}
+            assert spy.call_count + native_difference in {2, 3}
         else:
-            assert spy.call_count == 2
+            assert spy.call_count + native_difference == 2
 
     finally:
-        # Restore the original content and timestamp
+        # 8. Restore the original content and timestamp
         py_info_script.write_text(original_content, encoding="utf-8")
         os.utime(str(py_info_script), (original_stat.st_atime, original_stat.st_mtime))
 
@@ -433,7 +436,9 @@ def test_custom_venv_install_scheme_is_prefered(mocker):
     assert pyinfo.install_path("purelib").replace(os.sep, "/") == f"lib/python{pyver}/site-packages"
 
 
-@pytest.mark.skipif(not (os.name == "posix" and sys.version_info[:2] >= (3, 11)), reason="POSIX 3.11+ specific")
+@pytest.mark.skipif(
+    IS_PYPY or not (os.name == "posix" and sys.version_info[:2] >= (3, 11)), reason="POSIX 3.11+ specific"
+)
 def test_fallback_existent_system_executable(mocker):
     current = PythonInfo()
     # Posix may execute a "python" out of a venv but try to set the base_executable