Refine the getpath implementation for pyvenv case, and get the tests to pass

Author: pelson

Lib/test/test_embed.py

@@ -1618,13 +1618,7 @@ def test_init_pyvenv_cfg(self):
              tempfile.TemporaryDirectory() as pyvenv_home:
             ver = sys.version_info
 
-            if not MS_WINDOWS:
-                lib_dynload = os.path.join(pyvenv_home,
-                                           sys.platlibdir,
-                                           f'python{ver.major}.{ver.minor}{ABI_THREAD}',
-                                           'lib-dynload')
-                os.makedirs(lib_dynload)
-            else:
+            if MS_WINDOWS:
                 lib_folder = os.path.join(pyvenv_home, 'Lib')
                 os.makedirs(lib_folder)
                 # getpath.py uses Lib\os.py as the LANDMARK
@@ -1639,9 +1633,7 @@ def test_init_pyvenv_cfg(self):
                 print("include-system-site-packages = false", file=fp)
 
             paths = self.module_search_paths()
-            if not MS_WINDOWS:
-                paths[-1] = lib_dynload
-            else:
+            if MS_WINDOWS:
                 paths = [
                     os.path.join(tmpdir, os.path.basename(paths[0])),
                     pyvenv_home,
@@ -1650,7 +1642,7 @@ def test_init_pyvenv_cfg(self):
 
             executable = self.test_exe
             base_executable = os.path.join(pyvenv_home, os.path.basename(executable))
-            exec_prefix = pyvenv_home
+            exec_prefix = sys.base_exec_prefix
             config = {
                 'base_prefix': sysconfig.get_config_var("prefix"),
                 'base_exec_prefix': exec_prefix,
@@ -1659,16 +1651,15 @@ def test_init_pyvenv_cfg(self):
                 'base_executable': base_executable,
                 'executable': executable,
                 'module_search_paths': paths,
+                'use_frozen_modules': bool(not support.Py_DEBUG),
             }
             if MS_WINDOWS:
                 config['base_prefix'] = pyvenv_home
                 config['stdlib_dir'] = os.path.join(pyvenv_home, 'Lib')
-                config['use_frozen_modules'] = bool(not support.Py_DEBUG)
             else:
                 # cannot reliably assume stdlib_dir here because it
                 # depends too much on our build. But it ought to be found
                 config['stdlib_dir'] = self.IGNORE_CONFIG
-                config['use_frozen_modules'] = bool(not support.Py_DEBUG)
 
             env = self.copy_paths_by_env(config)
             self.check_all_configs("test_init_compat_config", config,

Lib/test/test_venv.py

@@ -684,7 +684,6 @@ def test_zippath_from_non_installed_posix(self):
         shutil.copy2(sys.executable, bindir)
         libdir = os.path.join(non_installed_dir, platlibdir, self.lib[1])
         os.makedirs(libdir)
-        landmark = os.path.join(libdir, "os.py")
         abi_thread = "t" if sysconfig.get_config_var("Py_GIL_DISABLED") else ""
         stdlib_zip = f"python{sys.version_info.major}{sys.version_info.minor}{abi_thread}"
         zip_landmark = os.path.join(non_installed_dir,
@@ -748,9 +747,9 @@ def test_zippath_from_non_installed_posix(self):
         subprocess.check_call(cmd, env=child_env)
         # Now check the venv created from the non-installed python has
         # correct zip path in pythonpath.
-        cmd = [self.envpy(), '-S', '-c', 'import sys; print(sys.path)']
+        cmd = [self.envpy(), '-S', '-c', "import sys; print('\\n'.join(sys.path))"]
         out, err = check_output(cmd)
-        self.assertTrue(zip_landmark.encode() in out)
+        self.assertIn(zip_landmark, out.decode())
 
     @unittest.skipIf(os.name == 'nt', 'not relevant on Windows')
     @requireVenvCreate
@@ -764,8 +763,9 @@ def test_venv_from_venv_with_symlink(self):
         self.addCleanup(rmtree, public_prefix)
         public_bin_dir = os.path.join(public_prefix, 'bin')
         os.mkdir(public_bin_dir)
-        public_exe = os.path.join(public_bin_dir, self.exe)
+        public_exe = os.path.join(public_bin_dir, 'python3')
         os.symlink(sys.executable, public_exe)
+        underlying_prefix = sys.base_prefix
         cmd = [public_exe,
                "-m",
                "venv",
@@ -796,6 +796,24 @@ def test_venv_from_venv_with_symlink(self):
         contents = (pathlib.Path(second_venv) / 'pyvenv.cfg').read_text()
         self.assertIn(f'home = {public_bin_dir}\n', contents)
 
+        # Now validate the important sys values.
+        venv2_sys, _ = check_output(
+            [os.path.join(second_venv, 'bin', 'python3'),
+             '-S', '-c',
+             "import sys; print(f'{sys._base_executable=}\\n{sys.base_exec_prefix=}\\n{sys.base_prefix=}')"],
+            encoding='utf8',
+        )
+        self.assertEqual(
+            '\n'.join([
+                # The base executable should be the public one, while the exec_prefix can be the
+                # internal one (and the same as the original interpreter's base_prefix).
+                f"sys._base_executable='{public_exe}'",
+                f"sys.base_exec_prefix='{underlying_prefix}'",
+                f"sys.base_prefix='{underlying_prefix}'",
+            ]),
+            venv2_sys.strip(),
+        )
+
     @requireVenvCreate
     def test_activate_shell_script_has_no_dos_newlines(self):
         """

Modules/getpath.py

@@ -383,22 +383,22 @@ def search_up(prefix, *landmarks, test=isfile):
             # it in 'home'.
             if not base_executable:
                 _home_executable = joinpath(executable_dir, DEFAULT_PROGRAM_NAME)
-                _realpath_executable = None
+                _executable_realpath = None
                 try:
-                    _realpath_executable = realpath(executable)
+                    _executable_realpath = realpath(executable)
 
                     # If the realpath of the executable identified in home is the same as
-                    # the realpath of the venv's executable use the (potentially not fully
-                    # resolved via realpath) path from home.
-                    if realpath(_home_executable) == _realpath_executable:
+                    # the realpath of the venv's executable, then use the (potentially not
+                    # fully resolved via realpath) path from home.
+                    if realpath(_home_executable) == _executable_realpath:
                         base_executable = _home_executable
                 except OSError:
                     pass
                 if not base_executable:
-                    if _realpath_executable and _realpath_executable != executable:
+                    if _executable_realpath and _executable_realpath != executable:
                         # Try to resolve symlinked executables, since that may be
                         # more accurate than assuming the executable in 'home'.
-                        base_executable = _realpath_executable
+                        base_executable = _executable_realpath
                 if not base_executable:
                     base_executable = joinpath(executable_dir, basename(executable))
                     # It's possible "python" is executed from within a posix venv but that
@@ -407,10 +407,10 @@ def search_up(prefix, *landmarks, test=isfile):
                     #
                     # In this case, try to fall back to known alternatives
                     if os_name != 'nt' and not isfile(base_executable):
-                        base_exe = basename(executable)
+                        _base_exe = basename(executable)
                         for candidate in (DEFAULT_PROGRAM_NAME, f'python{VERSION_MAJOR}.{VERSION_MINOR}'):
                             candidate += EXE_SUFFIX if EXE_SUFFIX else ''
-                            if base_exe == candidate:
+                            if _base_exe == candidate:
                                 continue
                             candidate = joinpath(executable_dir, candidate)
                             # Only set base_executable if the candidate exists.