mirror of
https://github.com/python/cpython
synced 2024-09-05 08:17:45 +00:00
![Christian Heimes](/assets/img/avatar_default.png)
- On WASI `ENOTCAPABLE` is now mapped to `PermissionError`. - The `errno` modules exposes the new error number. - `getpath.py` now ignores `PermissionError` when it cannot open landmark files `pybuilddir.txt` and `pyenv.cfg`.
753 lines
31 KiB
Python
753 lines
31 KiB
Python
# ******************************************************************************
|
|
# getpath.py
|
|
# ******************************************************************************
|
|
|
|
# This script is designed to be precompiled to bytecode, frozen into the
|
|
# main binary, and then directly evaluated. It is not an importable module,
|
|
# and does not import any other modules (besides winreg on Windows).
|
|
# Rather, the values listed below must be specified in the globals dict
|
|
# used when evaluating the bytecode.
|
|
|
|
# See _PyConfig_InitPathConfig in Modules/getpath.c for the execution.
|
|
|
|
# ******************************************************************************
|
|
# REQUIRED GLOBALS
|
|
# ******************************************************************************
|
|
|
|
# ** Helper functions **
|
|
# abspath(path) -- make relative paths absolute against CWD
|
|
# basename(path) -- the filename of path
|
|
# dirname(path) -- the directory name of path
|
|
# hassuffix(path, suffix) -- returns True if path has suffix
|
|
# isabs(path) -- path is absolute or not
|
|
# isdir(path) -- path exists and is a directory
|
|
# isfile(path) -- path exists and is a file
|
|
# isxfile(path) -- path exists and is an executable file
|
|
# joinpath(*paths) -- combine the paths
|
|
# readlines(path) -- a list of each line of text in the UTF-8 encoded file
|
|
# realpath(path) -- resolves symlinks in path
|
|
# warn(message) -- print a warning (if enabled)
|
|
|
|
# ** Values known at compile time **
|
|
# os_name -- [in] one of 'nt', 'posix', 'darwin'
|
|
# PREFIX -- [in] sysconfig.get_config_var(...)
|
|
# EXEC_PREFIX -- [in] sysconfig.get_config_var(...)
|
|
# PYTHONPATH -- [in] sysconfig.get_config_var(...)
|
|
# WITH_NEXT_FRAMEWORK -- [in] sysconfig.get_config_var(...)
|
|
# VPATH -- [in] sysconfig.get_config_var(...)
|
|
# PLATLIBDIR -- [in] sysconfig.get_config_var(...)
|
|
# PYDEBUGEXT -- [in, opt] '_d' on Windows for debug builds
|
|
# EXE_SUFFIX -- [in, opt] '.exe' on Windows/Cygwin/similar
|
|
# VERSION_MAJOR -- [in] sys.version_info.major
|
|
# VERSION_MINOR -- [in] sys.version_info.minor
|
|
# PYWINVER -- [in] the Windows platform-specific version (e.g. 3.8-32)
|
|
|
|
# ** Values read from the environment **
|
|
# There is no need to check the use_environment flag before reading
|
|
# these, as the flag will be tested in this script.
|
|
# Also note that ENV_PYTHONPATH is read from config['pythonpath_env']
|
|
# to allow for embedders who choose to specify it via that struct.
|
|
# ENV_PATH -- [in] getenv(...)
|
|
# ENV_PYTHONHOME -- [in] getenv(...)
|
|
# ENV_PYTHONEXECUTABLE -- [in] getenv(...)
|
|
# ENV___PYVENV_LAUNCHER__ -- [in] getenv(...)
|
|
|
|
# ** Values calculated at runtime **
|
|
# config -- [in/out] dict of the PyConfig structure
|
|
# real_executable -- [in, optional] resolved path to main process
|
|
# On Windows and macOS, read directly from the running process
|
|
# Otherwise, leave None and it will be calculated from executable
|
|
# executable_dir -- [in, optional] real directory containing binary
|
|
# If None, will be calculated from real_executable or executable
|
|
# py_setpath -- [in] argument provided to Py_SetPath
|
|
# If None, 'prefix' and 'exec_prefix' may be updated in config
|
|
# library -- [in, optional] path of dylib/DLL/so
|
|
# Only used for locating ._pth files
|
|
# winreg -- [in, optional] the winreg module (only on Windows)
|
|
|
|
# ******************************************************************************
|
|
# HIGH-LEVEL ALGORITHM
|
|
# ******************************************************************************
|
|
|
|
# IMPORTANT: The code is the actual specification at time of writing.
|
|
# This prose description is based on the original comment from the old
|
|
# getpath.c to help capture the intent, but should not be considered
|
|
# a specification.
|
|
|
|
# Search in some common locations for the associated Python libraries.
|
|
|
|
# Two directories must be found, the platform independent directory
|
|
# (prefix), containing the common .py and .pyc files, and the platform
|
|
# dependent directory (exec_prefix), containing the shared library
|
|
# modules. Note that prefix and exec_prefix can be the same directory,
|
|
# but for some installations, they are different.
|
|
|
|
# This script carries out separate searches for prefix and exec_prefix.
|
|
# Each search tries a number of different locations until a ``landmark''
|
|
# file or directory is found. If no prefix or exec_prefix is found, a
|
|
# warning message is issued and the preprocessor defined PREFIX and
|
|
# EXEC_PREFIX are used (even though they will not work); python carries on
|
|
# as best as is possible, but most imports will fail.
|
|
|
|
# Before any searches are done, the location of the executable is
|
|
# determined. If Py_SetPath() was called, or if we are running on
|
|
# Windows, the 'real_executable' path is used (if known). Otherwise,
|
|
# we use the config-specified program name or default to argv[0].
|
|
# If this has one or more slashes in it, it is made absolute against
|
|
# the current working directory. If it only contains a name, it must
|
|
# have been invoked from the shell's path, so we search $PATH for the
|
|
# named executable and use that. If the executable was not found on
|
|
# $PATH (or there was no $PATH environment variable), the original
|
|
# argv[0] string is used.
|
|
|
|
# At this point, provided Py_SetPath was not used, the
|
|
# __PYVENV_LAUNCHER__ variable may override the executable (on macOS,
|
|
# the PYTHON_EXECUTABLE variable may also override). This allows
|
|
# certain launchers that run Python as a subprocess to properly
|
|
# specify the executable path. They are not intended for users.
|
|
|
|
# Next, the executable location is examined to see if it is a symbolic
|
|
# link. If so, the link is realpath-ed and the directory of the link
|
|
# target is used for the remaining searches. The same steps are
|
|
# performed for prefix and for exec_prefix, but with different landmarks.
|
|
|
|
# Step 1. Are we running in a virtual environment? Unless 'home' has
|
|
# been specified another way, check for a pyvenv.cfg and use its 'home'
|
|
# property to override the executable dir used later for prefix searches.
|
|
# We do not activate the venv here - that is performed later by site.py.
|
|
|
|
# Step 2. Is there a ._pth file? A ._pth file lives adjacent to the
|
|
# runtime library (if any) or the actual executable (not the symlink),
|
|
# and contains precisely the intended contents of sys.path as relative
|
|
# paths (to its own location). Its presence also enables isolated mode
|
|
# and suppresses other environment variable usage. Unless already
|
|
# specified by Py_SetHome(), the directory containing the ._pth file is
|
|
# set as 'home'.
|
|
|
|
# Step 3. Are we running python out of the build directory? This is
|
|
# checked by looking for the BUILDDIR_TXT file, which contains the
|
|
# relative path to the platlib dir. The executable_dir value is
|
|
# derived from joining the VPATH preprocessor variable to the
|
|
# directory containing pybuilddir.txt. If it is not found, the
|
|
# BUILD_LANDMARK file is found, which is part of the source tree.
|
|
# prefix is then found by searching up for a file that should only
|
|
# exist in the source tree, and the stdlib dir is set to prefix/Lib.
|
|
|
|
# Step 4. If 'home' is set, either by Py_SetHome(), ENV_PYTHONHOME,
|
|
# a pyvenv.cfg file, ._pth file, or by detecting a build directory, it
|
|
# is assumed to point to prefix and exec_prefix. $PYTHONHOME can be a
|
|
# single directory, which is used for both, or the prefix and exec_prefix
|
|
# directories separated by DELIM (colon on POSIX; semicolon on Windows).
|
|
|
|
# Step 5. Try to find prefix and exec_prefix relative to executable_dir,
|
|
# backtracking up the path until it is exhausted. This is the most common
|
|
# step to succeed. Note that if prefix and exec_prefix are different,
|
|
# exec_prefix is more likely to be found; however if exec_prefix is a
|
|
# subdirectory of prefix, both will be found.
|
|
|
|
# Step 6. Search the directories pointed to by the preprocessor variables
|
|
# PREFIX and EXEC_PREFIX. These are supplied by the Makefile but can be
|
|
# passed in as options to the configure script.
|
|
|
|
# That's it!
|
|
|
|
# Well, almost. Once we have determined prefix and exec_prefix, the
|
|
# preprocessor variable PYTHONPATH is used to construct a path. Each
|
|
# relative path on PYTHONPATH is prefixed with prefix. Then the directory
|
|
# containing the shared library modules is appended. The environment
|
|
# variable $PYTHONPATH is inserted in front of it all. On POSIX, if we are
|
|
# in a build directory, both prefix and exec_prefix are reset to the
|
|
# corresponding preprocessor variables (so sys.prefix will reflect the
|
|
# installation location, even though sys.path points into the build
|
|
# directory). This seems to make more sense given that currently the only
|
|
# known use of sys.prefix and sys.exec_prefix is for the ILU installation
|
|
# process to find the installed Python tree.
|
|
|
|
# An embedding application can use Py_SetPath() to override all of
|
|
# these automatic path computations.
|
|
|
|
|
|
# ******************************************************************************
|
|
# PLATFORM CONSTANTS
|
|
# ******************************************************************************
|
|
|
|
platlibdir = config.get('platlibdir') or PLATLIBDIR
|
|
|
|
if os_name == 'posix' or os_name == 'darwin':
|
|
BUILDDIR_TXT = 'pybuilddir.txt'
|
|
BUILD_LANDMARK = 'Modules/Setup.local'
|
|
DEFAULT_PROGRAM_NAME = f'python{VERSION_MAJOR}'
|
|
STDLIB_SUBDIR = f'{platlibdir}/python{VERSION_MAJOR}.{VERSION_MINOR}'
|
|
STDLIB_LANDMARKS = [f'{STDLIB_SUBDIR}/os.py', f'{STDLIB_SUBDIR}/os.pyc']
|
|
PLATSTDLIB_LANDMARK = f'{platlibdir}/python{VERSION_MAJOR}.{VERSION_MINOR}/lib-dynload'
|
|
BUILDSTDLIB_LANDMARKS = ['Lib/os.py']
|
|
VENV_LANDMARK = 'pyvenv.cfg'
|
|
ZIP_LANDMARK = f'{platlibdir}/python{VERSION_MAJOR}{VERSION_MINOR}.zip'
|
|
DELIM = ':'
|
|
SEP = '/'
|
|
|
|
elif os_name == 'nt':
|
|
BUILDDIR_TXT = 'pybuilddir.txt'
|
|
BUILD_LANDMARK = f'{VPATH}\\Modules\\Setup.local'
|
|
DEFAULT_PROGRAM_NAME = f'python'
|
|
STDLIB_SUBDIR = 'Lib'
|
|
STDLIB_LANDMARKS = [f'{STDLIB_SUBDIR}\\os.py', f'{STDLIB_SUBDIR}\\os.pyc']
|
|
PLATSTDLIB_LANDMARK = f'{platlibdir}'
|
|
BUILDSTDLIB_LANDMARKS = ['Lib\\os.py']
|
|
VENV_LANDMARK = 'pyvenv.cfg'
|
|
ZIP_LANDMARK = f'python{VERSION_MAJOR}{VERSION_MINOR}{PYDEBUGEXT or ""}.zip'
|
|
WINREG_KEY = f'SOFTWARE\\Python\\PythonCore\\{PYWINVER}\\PythonPath'
|
|
DELIM = ';'
|
|
SEP = '\\'
|
|
|
|
|
|
# ******************************************************************************
|
|
# HELPER FUNCTIONS (note that we prefer C functions for performance)
|
|
# ******************************************************************************
|
|
|
|
def search_up(prefix, *landmarks, test=isfile):
|
|
while prefix:
|
|
if any(test(joinpath(prefix, f)) for f in landmarks):
|
|
return prefix
|
|
prefix = dirname(prefix)
|
|
|
|
|
|
# ******************************************************************************
|
|
# READ VARIABLES FROM config
|
|
# ******************************************************************************
|
|
|
|
program_name = config.get('program_name')
|
|
home = config.get('home')
|
|
executable = config.get('executable')
|
|
base_executable = config.get('base_executable')
|
|
prefix = config.get('prefix')
|
|
exec_prefix = config.get('exec_prefix')
|
|
base_prefix = config.get('base_prefix')
|
|
base_exec_prefix = config.get('base_exec_prefix')
|
|
ENV_PYTHONPATH = config['pythonpath_env']
|
|
use_environment = config.get('use_environment', 1)
|
|
|
|
pythonpath = config.get('module_search_paths')
|
|
pythonpath_was_set = config.get('module_search_paths_set')
|
|
|
|
real_executable_dir = None
|
|
stdlib_dir = None
|
|
platstdlib_dir = None
|
|
|
|
# ******************************************************************************
|
|
# CALCULATE program_name
|
|
# ******************************************************************************
|
|
|
|
program_name_was_set = bool(program_name)
|
|
|
|
if not program_name:
|
|
try:
|
|
program_name = config.get('orig_argv', [])[0]
|
|
except IndexError:
|
|
pass
|
|
|
|
if not program_name:
|
|
program_name = DEFAULT_PROGRAM_NAME
|
|
|
|
if EXE_SUFFIX and not hassuffix(program_name, EXE_SUFFIX) and isxfile(program_name + EXE_SUFFIX):
|
|
program_name = program_name + EXE_SUFFIX
|
|
|
|
|
|
# ******************************************************************************
|
|
# CALCULATE executable
|
|
# ******************************************************************************
|
|
|
|
if py_setpath:
|
|
# When Py_SetPath has been called, executable defaults to
|
|
# the real executable path.
|
|
if not executable:
|
|
executable = real_executable
|
|
|
|
if not executable and SEP in program_name:
|
|
# Resolve partial path program_name against current directory
|
|
executable = abspath(program_name)
|
|
|
|
if not executable:
|
|
# All platforms default to real_executable if known at this
|
|
# stage. POSIX does not set this value.
|
|
executable = real_executable
|
|
elif os_name == 'darwin':
|
|
# QUIRK: On macOS we may know the real executable path, but
|
|
# if our caller has lied to us about it (e.g. most of
|
|
# test_embed), we need to use their path in order to detect
|
|
# whether we are in a build tree. This is true even if the
|
|
# executable path was provided in the config.
|
|
real_executable = executable
|
|
|
|
if not executable and program_name and ENV_PATH:
|
|
# Resolve names against PATH.
|
|
# NOTE: The use_environment value is ignored for this lookup.
|
|
# To properly isolate, launch Python with a full path.
|
|
for p in ENV_PATH.split(DELIM):
|
|
p = joinpath(p, program_name)
|
|
if isxfile(p):
|
|
executable = p
|
|
break
|
|
|
|
if not executable:
|
|
executable = ''
|
|
# When we cannot calculate the executable, subsequent searches
|
|
# look in the current working directory. Here, we emulate that
|
|
# (the former getpath.c would do it apparently by accident).
|
|
executable_dir = abspath('.')
|
|
# Also need to set this fallback in case we are running from a
|
|
# build directory with an invalid argv0 (i.e. test_sys.test_executable)
|
|
real_executable_dir = executable_dir
|
|
|
|
if ENV_PYTHONEXECUTABLE or ENV___PYVENV_LAUNCHER__:
|
|
# If set, these variables imply that we should be using them as
|
|
# sys.executable and when searching for venvs. However, we should
|
|
# use the argv0 path for prefix calculation
|
|
|
|
if os_name == 'darwin' and WITH_NEXT_FRAMEWORK:
|
|
# In a framework build the binary in {sys.exec_prefix}/bin is
|
|
# a stub executable that execs the real interpreter in an
|
|
# embedded app bundle. That bundle is an implementation detail
|
|
# and should not affect base_executable.
|
|
base_executable = f"{dirname(library)}/bin/python{VERSION_MAJOR}.{VERSION_MINOR}"
|
|
else:
|
|
base_executable = executable
|
|
|
|
if not real_executable:
|
|
real_executable = base_executable
|
|
#real_executable_dir = dirname(real_executable)
|
|
executable = ENV_PYTHONEXECUTABLE or ENV___PYVENV_LAUNCHER__
|
|
executable_dir = dirname(executable)
|
|
|
|
|
|
# ******************************************************************************
|
|
# CALCULATE (default) home
|
|
# ******************************************************************************
|
|
|
|
# Used later to distinguish between Py_SetPythonHome and other
|
|
# ways that it may have been set
|
|
home_was_set = False
|
|
|
|
if home:
|
|
home_was_set = True
|
|
elif use_environment and ENV_PYTHONHOME and not py_setpath:
|
|
home = ENV_PYTHONHOME
|
|
|
|
|
|
# ******************************************************************************
|
|
# READ pyvenv.cfg
|
|
# ******************************************************************************
|
|
|
|
venv_prefix = None
|
|
|
|
# Calling Py_SetPythonHome(), Py_SetPath() or
|
|
# setting $PYTHONHOME will override venv detection.
|
|
if not home and not py_setpath:
|
|
try:
|
|
# prefix2 is just to avoid calculating dirname again later,
|
|
# as the path in venv_prefix is the more common case.
|
|
venv_prefix2 = executable_dir or dirname(executable)
|
|
venv_prefix = dirname(venv_prefix2)
|
|
try:
|
|
# Read pyvenv.cfg from one level above executable
|
|
pyvenvcfg = readlines(joinpath(venv_prefix, VENV_LANDMARK))
|
|
except (FileNotFoundError, PermissionError):
|
|
# Try the same directory as executable
|
|
pyvenvcfg = readlines(joinpath(venv_prefix2, VENV_LANDMARK))
|
|
venv_prefix = venv_prefix2
|
|
except (FileNotFoundError, PermissionError):
|
|
venv_prefix = None
|
|
pyvenvcfg = []
|
|
|
|
for line in pyvenvcfg:
|
|
key, had_equ, value = line.partition('=')
|
|
if had_equ and key.strip().lower() == 'home':
|
|
executable_dir = real_executable_dir = value.strip()
|
|
if not base_executable:
|
|
# First try to resolve symlinked executables, since that may be
|
|
# more accurate than assuming the executable in 'home'.
|
|
try:
|
|
base_executable = realpath(executable)
|
|
if base_executable == executable:
|
|
# No change, so probably not a link. Clear it and fall back
|
|
base_executable = ''
|
|
except OSError:
|
|
pass
|
|
if not base_executable:
|
|
base_executable = joinpath(executable_dir, basename(executable))
|
|
break
|
|
else:
|
|
venv_prefix = None
|
|
|
|
|
|
# ******************************************************************************
|
|
# CALCULATE base_executable, real_executable AND executable_dir
|
|
# ******************************************************************************
|
|
|
|
if not base_executable:
|
|
base_executable = executable or real_executable or ''
|
|
|
|
if not real_executable:
|
|
real_executable = base_executable
|
|
|
|
try:
|
|
real_executable = realpath(real_executable)
|
|
except OSError as ex:
|
|
# Only warn if the file actually exists and was unresolvable
|
|
# Otherwise users who specify a fake executable may get spurious warnings.
|
|
if isfile(real_executable):
|
|
warn(f'Failed to find real location of {base_executable}')
|
|
|
|
if not executable_dir and os_name == 'darwin' and library:
|
|
# QUIRK: macOS checks adjacent to its library early
|
|
library_dir = dirname(library)
|
|
if any(isfile(joinpath(library_dir, p)) for p in STDLIB_LANDMARKS):
|
|
# Exceptions here should abort the whole process (to match
|
|
# previous behavior)
|
|
executable_dir = realpath(library_dir)
|
|
real_executable_dir = executable_dir
|
|
|
|
# If we do not have the executable's directory, we can calculate it.
|
|
# This is the directory used to find prefix/exec_prefix if necessary.
|
|
if not executable_dir:
|
|
executable_dir = real_executable_dir = dirname(real_executable)
|
|
|
|
# If we do not have the real executable's directory, we calculate it.
|
|
# This is the directory used to detect build layouts.
|
|
if not real_executable_dir:
|
|
real_executable_dir = dirname(real_executable)
|
|
|
|
# ******************************************************************************
|
|
# DETECT _pth FILE
|
|
# ******************************************************************************
|
|
|
|
# The contents of an optional ._pth file are used to totally override
|
|
# sys.path calculation. Its presence also implies isolated mode and
|
|
# no-site (unless explicitly requested)
|
|
pth = None
|
|
pth_dir = None
|
|
|
|
# Calling Py_SetPythonHome() or Py_SetPath() will override ._pth search,
|
|
# but environment variables and command-line options cannot.
|
|
if not py_setpath and not home_was_set:
|
|
# 1. Check adjacent to the main DLL/dylib/so (if set)
|
|
# 2. Check adjacent to the original executable
|
|
# 3. Check adjacent to our actual executable
|
|
# This may allow a venv to override the base_executable's
|
|
# ._pth file, but it cannot override the library's one.
|
|
for p in [library, executable, real_executable]:
|
|
if p:
|
|
if os_name == 'nt' and (hassuffix(p, 'exe') or hassuffix(p, 'dll')):
|
|
p = p.rpartition('.')[0]
|
|
p += '._pth'
|
|
try:
|
|
pth = readlines(p)
|
|
pth_dir = dirname(p)
|
|
break
|
|
except OSError:
|
|
pass
|
|
|
|
# If we found a ._pth file, disable environment and home
|
|
# detection now. Later, we will do the rest.
|
|
if pth_dir:
|
|
use_environment = 0
|
|
home = pth_dir
|
|
pythonpath = []
|
|
|
|
|
|
# ******************************************************************************
|
|
# CHECK FOR BUILD DIRECTORY
|
|
# ******************************************************************************
|
|
|
|
build_prefix = None
|
|
|
|
if ((not home_was_set and real_executable_dir and not py_setpath)
|
|
or config.get('_is_python_build', 0) > 0):
|
|
# Detect a build marker and use it to infer prefix, exec_prefix,
|
|
# stdlib_dir and the platstdlib_dir directories.
|
|
try:
|
|
platstdlib_dir = joinpath(
|
|
real_executable_dir,
|
|
readlines(joinpath(real_executable_dir, BUILDDIR_TXT))[0],
|
|
)
|
|
build_prefix = joinpath(real_executable_dir, VPATH)
|
|
except IndexError:
|
|
# File exists but is empty
|
|
platstdlib_dir = real_executable_dir
|
|
build_prefix = joinpath(real_executable_dir, VPATH)
|
|
except (FileNotFoundError, PermissionError):
|
|
if isfile(joinpath(real_executable_dir, BUILD_LANDMARK)):
|
|
build_prefix = joinpath(real_executable_dir, VPATH)
|
|
if os_name == 'nt':
|
|
# QUIRK: Windows builds need platstdlib_dir to be the executable
|
|
# dir. Normally the builddir marker handles this, but in this
|
|
# case we need to correct manually.
|
|
platstdlib_dir = real_executable_dir
|
|
|
|
if build_prefix:
|
|
if os_name == 'nt':
|
|
# QUIRK: No searching for more landmarks on Windows
|
|
build_stdlib_prefix = build_prefix
|
|
else:
|
|
build_stdlib_prefix = search_up(build_prefix, *BUILDSTDLIB_LANDMARKS)
|
|
# Always use the build prefix for stdlib
|
|
if build_stdlib_prefix:
|
|
stdlib_dir = joinpath(build_stdlib_prefix, 'Lib')
|
|
else:
|
|
stdlib_dir = joinpath(build_prefix, 'Lib')
|
|
# Only use the build prefix for prefix if it hasn't already been set
|
|
if not prefix:
|
|
prefix = build_stdlib_prefix
|
|
# Do not warn, because 'prefix' never equals 'build_prefix' on POSIX
|
|
#elif not venv_prefix and prefix != build_prefix:
|
|
# warn('Detected development environment but prefix is already set')
|
|
if not exec_prefix:
|
|
exec_prefix = build_prefix
|
|
# Do not warn, because 'exec_prefix' never equals 'build_prefix' on POSIX
|
|
#elif not venv_prefix and exec_prefix != build_prefix:
|
|
# warn('Detected development environment but exec_prefix is already set')
|
|
config['_is_python_build'] = 1
|
|
|
|
|
|
# ******************************************************************************
|
|
# CALCULATE prefix AND exec_prefix
|
|
# ******************************************************************************
|
|
|
|
if py_setpath:
|
|
# As documented, calling Py_SetPath will force both prefix
|
|
# and exec_prefix to the empty string.
|
|
prefix = exec_prefix = ''
|
|
|
|
else:
|
|
# Read prefix and exec_prefix from explicitly set home
|
|
if home:
|
|
# When multiple paths are listed with ':' or ';' delimiters,
|
|
# split into prefix:exec_prefix
|
|
prefix, had_delim, exec_prefix = home.partition(DELIM)
|
|
if not had_delim:
|
|
exec_prefix = prefix
|
|
# Reset the standard library directory if it was already set
|
|
stdlib_dir = None
|
|
|
|
|
|
# First try to detect prefix by looking alongside our runtime library, if known
|
|
if library and not prefix:
|
|
library_dir = dirname(library)
|
|
if ZIP_LANDMARK:
|
|
if os_name == 'nt':
|
|
# QUIRK: Windows does not search up for ZIP file
|
|
if isfile(joinpath(library_dir, ZIP_LANDMARK)):
|
|
prefix = library_dir
|
|
else:
|
|
prefix = search_up(library_dir, ZIP_LANDMARK)
|
|
if STDLIB_SUBDIR and STDLIB_LANDMARKS and not prefix:
|
|
if any(isfile(joinpath(library_dir, f)) for f in STDLIB_LANDMARKS):
|
|
prefix = library_dir
|
|
stdlib_dir = joinpath(prefix, STDLIB_SUBDIR)
|
|
|
|
|
|
# Detect prefix by looking for zip file
|
|
if ZIP_LANDMARK and executable_dir and not prefix:
|
|
if os_name == 'nt':
|
|
# QUIRK: Windows does not search up for ZIP file
|
|
if isfile(joinpath(executable_dir, ZIP_LANDMARK)):
|
|
prefix = executable_dir
|
|
else:
|
|
prefix = search_up(executable_dir, ZIP_LANDMARK)
|
|
if prefix:
|
|
stdlib_dir = joinpath(prefix, STDLIB_SUBDIR)
|
|
if not isdir(stdlib_dir):
|
|
stdlib_dir = None
|
|
|
|
|
|
# Detect prefix by searching from our executable location for the stdlib_dir
|
|
if STDLIB_SUBDIR and STDLIB_LANDMARKS and executable_dir and not prefix:
|
|
prefix = search_up(executable_dir, *STDLIB_LANDMARKS)
|
|
if prefix:
|
|
stdlib_dir = joinpath(prefix, STDLIB_SUBDIR)
|
|
|
|
if PREFIX and not prefix:
|
|
prefix = PREFIX
|
|
if not any(isfile(joinpath(prefix, f)) for f in STDLIB_LANDMARKS):
|
|
warn('Could not find platform independent libraries <prefix>')
|
|
|
|
if not prefix:
|
|
prefix = abspath('')
|
|
warn('Could not find platform independent libraries <prefix>')
|
|
|
|
|
|
# Detect exec_prefix by searching from executable for the platstdlib_dir
|
|
if PLATSTDLIB_LANDMARK and not exec_prefix:
|
|
if executable_dir:
|
|
exec_prefix = search_up(executable_dir, PLATSTDLIB_LANDMARK, test=isdir)
|
|
if not exec_prefix:
|
|
if EXEC_PREFIX:
|
|
exec_prefix = EXEC_PREFIX
|
|
if not isdir(joinpath(exec_prefix, PLATSTDLIB_LANDMARK)):
|
|
warn('Could not find platform dependent libraries <exec_prefix>')
|
|
else:
|
|
warn('Could not find platform dependent libraries <exec_prefix>')
|
|
|
|
# Fallback: assume exec_prefix == prefix
|
|
if not exec_prefix:
|
|
exec_prefix = prefix
|
|
|
|
|
|
if not prefix or not exec_prefix:
|
|
warn('Consider setting $PYTHONHOME to <prefix>[:<exec_prefix>]')
|
|
|
|
|
|
# If we haven't set [plat]stdlib_dir already, set them now
|
|
if not stdlib_dir:
|
|
if prefix:
|
|
stdlib_dir = joinpath(prefix, STDLIB_SUBDIR)
|
|
else:
|
|
stdlib_dir = ''
|
|
|
|
if not platstdlib_dir:
|
|
if exec_prefix:
|
|
platstdlib_dir = joinpath(exec_prefix, PLATSTDLIB_LANDMARK)
|
|
else:
|
|
platstdlib_dir = ''
|
|
|
|
|
|
# For a venv, update the main prefix/exec_prefix but leave the base ones unchanged
|
|
# XXX: We currently do not update prefix here, but it happens in site.py
|
|
#if venv_prefix:
|
|
# base_prefix = prefix
|
|
# base_exec_prefix = exec_prefix
|
|
# prefix = exec_prefix = venv_prefix
|
|
|
|
|
|
# ******************************************************************************
|
|
# UPDATE pythonpath (sys.path)
|
|
# ******************************************************************************
|
|
|
|
if py_setpath:
|
|
# If Py_SetPath was called then it overrides any existing search path
|
|
config['module_search_paths'] = py_setpath.split(DELIM)
|
|
config['module_search_paths_set'] = 1
|
|
|
|
elif not pythonpath_was_set:
|
|
# If pythonpath was already explicitly set or calculated, we leave it alone.
|
|
# This won't matter in normal use, but if an embedded host is trying to
|
|
# recalculate paths while running then we do not want to change it.
|
|
pythonpath = []
|
|
|
|
# First add entries from the process environment
|
|
if use_environment and ENV_PYTHONPATH:
|
|
for p in ENV_PYTHONPATH.split(DELIM):
|
|
pythonpath.append(abspath(p))
|
|
|
|
# Then add the default zip file
|
|
if os_name == 'nt':
|
|
# QUIRK: Windows uses the library directory rather than the prefix
|
|
if library:
|
|
library_dir = dirname(library)
|
|
else:
|
|
library_dir = executable_dir
|
|
pythonpath.append(joinpath(library_dir, ZIP_LANDMARK))
|
|
elif build_prefix or venv_prefix:
|
|
# QUIRK: POSIX uses the default prefix when in the build directory
|
|
# or a venv
|
|
pythonpath.append(joinpath(PREFIX, ZIP_LANDMARK))
|
|
else:
|
|
pythonpath.append(joinpath(prefix, ZIP_LANDMARK))
|
|
|
|
if os_name == 'nt' and use_environment and winreg:
|
|
# QUIRK: Windows also lists paths in the registry. Paths are stored
|
|
# as the default value of each subkey of
|
|
# {HKCU,HKLM}\Software\Python\PythonCore\{winver}\PythonPath
|
|
# where winver is sys.winver (typically '3.x' or '3.x-32')
|
|
for hk in (winreg.HKEY_CURRENT_USER, winreg.HKEY_LOCAL_MACHINE):
|
|
try:
|
|
key = winreg.OpenKeyEx(hk, WINREG_KEY)
|
|
try:
|
|
i = 0
|
|
while True:
|
|
try:
|
|
v = winreg.QueryValue(key, winreg.EnumKey(key, i))
|
|
except OSError:
|
|
break
|
|
if isinstance(v, str):
|
|
pythonpath.append(v)
|
|
i += 1
|
|
finally:
|
|
winreg.CloseKey(key)
|
|
except OSError:
|
|
pass
|
|
|
|
# Then add any entries compiled into the PYTHONPATH macro.
|
|
if PYTHONPATH:
|
|
for p in PYTHONPATH.split(DELIM):
|
|
pythonpath.append(joinpath(prefix, p))
|
|
|
|
# Then add stdlib_dir and platstdlib_dir
|
|
if os_name == 'nt' and venv_prefix:
|
|
# QUIRK: Windows generates paths differently in a venv
|
|
if platstdlib_dir:
|
|
pythonpath.append(platstdlib_dir)
|
|
if stdlib_dir:
|
|
pythonpath.append(stdlib_dir)
|
|
pythonpath.append(executable_dir)
|
|
else:
|
|
if stdlib_dir:
|
|
pythonpath.append(stdlib_dir)
|
|
if platstdlib_dir:
|
|
pythonpath.append(platstdlib_dir)
|
|
|
|
config['module_search_paths'] = pythonpath
|
|
config['module_search_paths_set'] = 1
|
|
|
|
|
|
# ******************************************************************************
|
|
# POSIX prefix/exec_prefix QUIRKS
|
|
# ******************************************************************************
|
|
|
|
# QUIRK: Non-Windows replaces prefix/exec_prefix with defaults when running
|
|
# in build directory. This happens after pythonpath calculation.
|
|
if os_name != 'nt' and build_prefix:
|
|
prefix = config.get('prefix') or PREFIX
|
|
exec_prefix = config.get('exec_prefix') or EXEC_PREFIX or prefix
|
|
|
|
|
|
# ******************************************************************************
|
|
# SET pythonpath FROM _PTH FILE
|
|
# ******************************************************************************
|
|
|
|
if pth:
|
|
config['isolated'] = 1
|
|
config['use_environment'] = 0
|
|
config['site_import'] = 0
|
|
config['safe_path'] = 1
|
|
pythonpath = []
|
|
for line in pth:
|
|
line = line.partition('#')[0].strip()
|
|
if not line:
|
|
pass
|
|
elif line == 'import site':
|
|
config['site_import'] = 1
|
|
elif line.startswith('import '):
|
|
warn("unsupported 'import' line in ._pth file")
|
|
else:
|
|
pythonpath.append(joinpath(pth_dir, line))
|
|
config['module_search_paths'] = pythonpath
|
|
config['module_search_paths_set'] = 1
|
|
|
|
# ******************************************************************************
|
|
# UPDATE config FROM CALCULATED VALUES
|
|
# ******************************************************************************
|
|
|
|
config['program_name'] = program_name
|
|
config['home'] = home
|
|
config['executable'] = executable
|
|
config['base_executable'] = base_executable
|
|
config['prefix'] = prefix
|
|
config['exec_prefix'] = exec_prefix
|
|
config['base_prefix'] = base_prefix or prefix
|
|
config['base_exec_prefix'] = base_exec_prefix or exec_prefix
|
|
|
|
config['platlibdir'] = platlibdir
|
|
config['stdlib_dir'] = stdlib_dir
|
|
config['platstdlib_dir'] = platstdlib_dir
|