import os

__all__ = [

'get_config_h_filename',

'get_config_var',

'get_config_vars',

'get_makefile_filename',

'get_path',

'get_path_names',

'get_paths',

'get_platform',

'get_python_version',

'get_scheme_names',

'parse_config_h',

]

_INSTALL_SCHEMES = {

'posix_prefix': {

'stdlib': '{installed_base}/lib64/python{py_version_short}',

'platstdlib': '{platbase}/lib64/python{py_version_short}',

'include':

'{installed_base}/include/python{py_version_short}{abiflags}',

'platinclude':

'{installed_platbase}/include/python{py_version_short}{abiflags}',

'scripts': '{base}/bin',

'data': '{base}',

},

'posix_home': {

'stdlib': '{installed_base}/lib/python',

'platstdlib': '{base}/lib/python',

'purelib': '{base}/lib/python',

'platlib': '{base}/lib/python',

'include': '{installed_base}/include/python',

'platinclude': '{installed_base}/include/python',

'scripts': '{base}/bin',

'data': '{base}',

},

'nt': {

'stdlib': '{installed_base}/Lib',

'platstdlib': '{base}/Lib',

'purelib': '{base}/Lib/site-packages',

'platlib': '{base}/Lib/site-packages',

'include': '{installed_base}/Include',

'platinclude': '{installed_base}/Include',

'scripts': '{base}/Scripts',

'data': '{base}',

},

'nt_user': {

'stdlib': '{userbase}/Python{py_version_nodot}',

'platstdlib': '{userbase}/Python{py_version_nodot}',

'purelib': '{userbase}/Python{py_version_nodot}/site-packages',

'platlib': '{userbase}/Python{py_version_nodot}/site-packages',

'include': '{userbase}/Python{py_version_nodot}/Include',

'data': '{userbase}',

},

'posix_user': {

'stdlib': '{userbase}/lib64/python{py_version_short}',

'platstdlib': '{userbase}/lib64/python{py_version_short}',

'include': '{userbase}/include/python{py_version_short}',

'scripts': '{userbase}/bin',

'data': '{userbase}',

},

'osx_framework_user': {

'stdlib': '{userbase}/lib/python',

'platstdlib': '{userbase}/lib/python',

'purelib': '{userbase}/lib/python/site-packages',

'platlib': '{userbase}/lib/python/site-packages',

'include': '{userbase}/include',

'scripts': '{userbase}/bin',

'data': '{userbase}',

},

}

# Force pip to use distutils paths instead of sysconfig

# https://github.com/pypa/pip/issues/10647

_PIP_USE_SYSCONFIG = False

# This is used by distutils.command.install in the stdlib

# as well as pypa/distutils (e.g. bundled in setuptools).

# The self.prefix value is set to sys.prefix + /local/

# if neither RPM build nor virtual environment is

# detected to make distutils install packages

# into the separate location.

# https://fedoraproject.org/wiki/Changes/Making_sudo_pip_safe

if (not (hasattr(sys, 'real_prefix') or

sys.prefix != sys.base_prefix) and

'RPM_BUILD_ROOT' not in os.environ):

_prefix_addition = "/local"

_SCHEME_KEYS = ('stdlib', 'platstdlib', 'purelib', 'platlib', 'include',

'scripts', 'data')

_PY_VERSION_SHORT = '%d.%d' % sys.version_info[:2]

_PY_VERSION_SHORT_NO_DOT = '%d%d' % sys.version_info[:2]

_CONFIG_VARS = None

_USER_BASE = None

def _safe_realpath(path):

try:

return realpath(path)

except OSError:

return path

else:

# sys.executable can be empty if argv[0] has been changed and Python is

# unable to retrieve the real program name

if (os.name == 'nt' and

_PROJECT_BASE.lower().endswith(('\\pcbuild\\win32', '\\pcbuild\\amd64'))):

if "_PYTHON_PROJECT_BASE" in os.environ:

_PROJECT_BASE = _safe_realpath(os.environ["_PYTHON_PROJECT_BASE"])

return True

return False

if os.name == 'nt':

def _fix_pcbuild(d):

if d and os.path.normcase(d).startswith(

os.path.normcase(os.path.join(_PREFIX, "PCbuild"))):

return _PREFIX

return d

_PROJECT_BASE = _fix_pcbuild(_PROJECT_BASE)

_sys_home = _fix_pcbuild(_sys_home)

def is_python_build(check_home=False):

if check_home and _sys_home:

return _is_python_source_dir(_sys_home)

return _is_python_source_dir(_PROJECT_BASE)

_PYTHON_BUILD = is_python_build(True)

if _PYTHON_BUILD:

for scheme in ('posix_prefix', 'posix_home'):

_INSTALL_SCHEMES[scheme]['include'] = '{srcdir}/Include'

_INSTALL_SCHEMES[scheme]['platinclude'] = '{projectbase}/.'

def _subst_vars(s, local_vars):

try:

return s.format(**local_vars)

except KeyError:

try:

return s.format(**os.environ)

except KeyError as var:

def _extend_dict(target_dict, other_dict):

target_keys = target_dict.keys()

for key, value in other_dict.items():

if key in target_keys:

continue

target_dict[key] = value

def _expand_vars(scheme, vars):

res = {}

if vars is None:

vars = {}

_extend_dict(vars, get_config_vars())

if os.name in ('posix', 'nt'):

value = os.path.expanduser(value)

res[key] = os.path.normpath(_subst_vars(value, vars))

return res

def _get_default_scheme():

if os.name == 'posix':

# the default scheme for posix is posix_prefix

return 'posix_prefix'

return os.name

# NOTE: site.py has copy of this function.

# Sync it when modify this function.

def _getuserbase():

env_base = os.environ.get("PYTHONUSERBASE", None)

if env_base:

return env_base

def joinuser(*args):

return os.path.expanduser(os.path.join(*args))

if os.name == "nt":

base = os.environ.get("APPDATA") or "~"

if sys.platform == "darwin" and sys._framework:

return joinuser("~", "Library", sys._framework,

"%d.%d" % sys.version_info[:2])

return joinuser("~", ".local")

def _parse_makefile(filename, vars=None):

"""Parse a Makefile-style file.

A dictionary containing name/value pairs is returned. If an

optional dictionary is passed in as the second argument, it is

used instead of a new dictionary.

"""

# Regexes needed for parsing Makefile (and similar syntaxes,

# like old-style Setup files).

_findvar1_rx = re.compile(r"\$\(([A-Za-z][A-Za-z0-9_]*)\)")

_findvar2_rx = re.compile(r"\${([A-Za-z][A-Za-z0-9_]*)}")

if vars is None:

vars = {}

done = {}

notdone = {}

lines = f.readlines()

for line in lines:

if line.startswith('#') or line.strip() == '':

continue

m = _variable_rx.match(line)

if m:

n, v = m.group(1, 2)

v = v.strip()

# `$$' is a literal `$' in make

tmpv = v.replace('$$', '')

if "$" in tmpv:

notdone[n] = v

else:

try:

v = int(v)

except ValueError:

# insert literal `$'

done[n] = v.replace('$$', '$')

else:

done[n] = v

# do variable interpolation here

variables = list(notdone.keys())

# Variables with a 'PY_' prefix in the makefile. These need to

# be made available without that prefix through sysconfig.

# Special care is needed to ensure that variable expansion works, even

# if the expansion uses the name without a prefix.

renamed_variables = ('CFLAGS', 'LDFLAGS', 'CPPFLAGS')

while len(variables) > 0:

for name in tuple(variables):

value = notdone[name]

m1 = _findvar1_rx.search(value)

m2 = _findvar2_rx.search(value)

if m1 and m2:

m = m1 if m1.start() < m2.start() else m2

else:

m = m1 if m1 else m2

if m is not None:

n = m.group(1)

found = True

if n in done:

item = str(done[n])

elif n in notdone:

# get it on a subsequent round

found = False

elif n in os.environ:

# do it like make: fall back to environment

item = os.environ[n]

elif n in renamed_variables:

if (name.startswith('PY_') and

name[3:] in renamed_variables):

item = ""

elif 'PY_' + n in notdone:

found = False

else:

item = str(done['PY_' + n])

else:

done[n] = item = ""

if found:

after = value[m.end():]

value = value[:m.start()] + item + after

if "$" in after:

notdone[name] = value

else:

try:

value = int(value)

except ValueError:

done[name] = value.strip()

else:

done[name] = value

variables.remove(name)

if name.startswith('PY_') \

name = name[3:]

if name not in done:

done[name] = value

# bogus variable reference (e.g. "prefix=$/opt/python");

# just drop it since we can't deal

done[name] = value

variables.remove(name)

# strip spurious spaces

for k, v in done.items():

if isinstance(v, str):

done[k] = v.strip()

# save the results in the global dictionary

vars.update(done)

return vars

if hasattr(sys, 'abiflags'):

config_dir_name = 'config-%s%s' % (_PY_VERSION_SHORT, sys.abiflags)

else:

config_dir_name = 'config'

if hasattr(sys.implementation, '_multiarch'):

config_dir_name += '-%s' % sys.implementation._multiarch

def _get_sysconfigdata_name():

return os.environ.get('_PYTHON_SYSCONFIGDATA_NAME',

'_sysconfigdata_{abi}_{platform}_{multiarch}'.format(

abi=sys.abiflags,

platform=sys.platform,

multiarch=getattr(sys.implementation, '_multiarch', ''),

))

def _generate_posix_vars():

"""Generate the Python module containing build-time variables."""

import pprint

vars = {}

try:

_parse_makefile(makefile, vars)

msg = "invalid Python installation: unable to open %s" % makefile

if hasattr(e, "strerror"):

msg = msg + " (%s)" % e.strerror

# load the installed pyconfig.h:

config_h = get_config_h_filename()

try:

with open(config_h) as f:

parse_config_h(f, vars)

msg = "invalid Python installation: unable to open %s" % config_h

if hasattr(e, "strerror"):

msg = msg + " (%s)" % e.strerror

# On AIX, there are wrong paths to the linker scripts in the Makefile

# -- these paths are relative to the Python source, but when installed

# the scripts are in another directory.

if _PYTHON_BUILD:

# There's a chicken-and-egg situation on OS X with regards to the

# _sysconfigdata module after the changes introduced by #15298:

# get_config_vars() is called by get_platform() as part of the

# `make pybuilddir.txt` target -- which is a precursor to the

# _sysconfigdata.py module being constructed. Unfortunately,

# get_config_vars() eventually calls _init_posix(), which attempts

# to import _sysconfigdata, which we won't have built yet. In order

# for _init_posix() to work, if we're on Darwin, just mock up the

# _sysconfigdata module manually and populate it with the build vars.

# This is more than sufficient for ensuring the subsequent call to

# get_platform() succeeds.

import types

module = types.ModuleType(name)

module.build_time_vars = vars

sys.modules[name] = module

if hasattr(sys, "gettotalrefcount"):

pybuilddir += '-pydebug'

os.makedirs(pybuilddir, exist_ok=True)

with open(destfile, 'w', encoding='utf8') as f:

f.write('# system configuration generated and used by'

' the sysconfig module\n')

f.write('build_time_vars = ')

pprint.pprint(vars, stream=f)

# Create file used for sys.path fixup -- see Modules/getpath.c

with open('pybuilddir.txt', 'w', encoding='ascii') as f:

f.write(pybuilddir)

def _init_posix(vars):

"""Initialize the module as appropriate for POSIX systems."""

# _sysconfigdata is generated at build time, see _generate_posix_vars()

_temp = __import__(name, globals(), locals(), ['build_time_vars'], 0)

build_time_vars = _temp.build_time_vars

def _init_non_posix(vars):

"""Initialize the module as appropriate for NT"""

# set basic install directories

vars['LIBDEST'] = get_path('stdlib')

vars['BINLIBDEST'] = get_path('platstdlib')

vars['INCLUDEPY'] = get_path('include')

vars['EXE'] = '.exe'

vars['VERSION'] = _PY_VERSION_SHORT_NO_DOT

#

# public APIs

#

def parse_config_h(fp, vars=None):

"""Parse a config.h-style file.

A dictionary containing name/value pairs is returned. If an

optional dictionary is passed in as the second argument, it is

used instead of a new dictionary.

"""

if vars is None:

vars = {}

define_rx = re.compile("#define ([A-Z][A-Za-z0-9_]+) (.*)\n")

undef_rx = re.compile("/[*] #undef ([A-Z][A-Za-z0-9_]+) [*]/\n")

while True:

line = fp.readline()

if not line:

break

m = define_rx.match(line)

if m:

n, v = m.group(1, 2)

try:

v = int(v)

except ValueError:

pass

vars[n] = v

else:

m = undef_rx.match(line)

if m:

vars[m.group(1)] = 0

return vars

if _PYTHON_BUILD:

if os.name == "nt":

else:

inc_dir = get_path('platinclude')

return os.path.join(inc_dir, 'pyconfig.h')

def get_path_names():

def get_paths(scheme=_get_default_scheme(), vars=None, expand=True):

``scheme`` is the install scheme name. If not provided, it will

return the default scheme for the current platform.

"""

if expand:

return _expand_vars(scheme, vars)

else:

def get_path(name, scheme=_get_default_scheme(), vars=None, expand=True):

``scheme`` is the install scheme name.

"""

return get_paths(scheme, vars, expand)[name]

def get_config_vars(*args):

"""With no arguments, return a dictionary of all configuration

variables relevant for the current platform.

On Unix, this means every variable defined in Python's installed Makefile;

With arguments, return a list of values that result from looking up

each argument in the configuration variable dictionary.

"""

global _CONFIG_VARS

if _CONFIG_VARS is None:

_CONFIG_VARS = {}

# Normalized versions of prefix and exec_prefix are handy to have;

# in fact, these are the standard versions used most places in the

_CONFIG_VARS['prefix'] = _PREFIX

_CONFIG_VARS['exec_prefix'] = _EXEC_PREFIX

_CONFIG_VARS['py_version'] = _PY_VERSION

_CONFIG_VARS['py_version_short'] = _PY_VERSION_SHORT