'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',

'posix_prefix': {

'stdlib': '{base}/lib/python{py_version_short}',

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

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

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

'include':

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

'platinclude':

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

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

'data': '{base}',

},

'posix_home': {

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

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

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

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

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

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

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

'data' : '{base}',

},

'nt': {

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

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

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

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

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

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

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

'data' : '{base}',

},

'os2': {

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

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

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

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

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

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

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

'data' : '{base}',

},

'os2_home': {

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

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

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

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

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

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

'data' : '{userbase}',

},

'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',

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

'data' : '{userbase}',

},

'posix_user': {

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

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

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

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

'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}',

},

try:

return realpath(path)

except OSError:

for fn in ("Setup.dist", "Setup.local"):

if os.path.isfile(os.path.join(_PROJECT_BASE, "Modules", fn)):

return True

try:

return s.format(**local_vars)

except KeyError:

try:

return s.format(**os.environ)

except KeyError as var:

target_keys = target_dict.keys()

for key, value in other_dict.items():

if key in target_keys:

continue

res = {}

if vars is None:

vars = {}

_extend_dict(vars, get_config_vars())

for key, value in _INSTALL_SCHEMES[scheme].items():

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

value = os.path.expanduser(value)

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

if os.name == 'posix':

# the default scheme for posix is posix_prefix

return 'posix_prefix'

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

def joinuser(*args):

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

# what about 'os2emx', 'riscos' ?

if os.name == "nt":

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

return env_base if env_base else joinuser(base, "Python")

if sys.platform == "darwin":

framework = get_config_var("PYTHONFRAMEWORK")

if framework:

return env_base if env_base else joinuser("~", "Library", framework, "%d.%d"%(

sys.version_info[:2]))

"""Parse a Makefile-style file.

import re

# Regexes needed for parsing Makefile (and similar syntaxes,

# like old-style Setup files).

_variable_rx = re.compile("([a-zA-Z][a-zA-Z0-9_]+)\s*=\s*(.*)")

_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 = {}

with open(filename, errors="surrogateescape") as f:

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]

m = _findvar1_rx.search(value) or _findvar2_rx.search(value)

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_') \

and name[3:] in renamed_variables:

name = name[3:]

if name not in done:

done[name] = value

else:

# 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 the path of the Makefile."""

if _PYTHON_BUILD:

return os.path.join(_PROJECT_BASE, "Makefile")

return os.path.join(get_path('stdlib'),

'config-{}{}'.format(_PY_VERSION_SHORT, sys.abiflags),

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

# load the installed Makefile:

makefile = get_makefile_filename()

try:

_parse_makefile(makefile, vars)

except IOError as e:

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

if hasattr(e, "strerror"):

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

raise IOError(msg)

# load the installed pyconfig.h:

config_h = get_config_h_filename()

try:

with open(config_h) as f:

parse_config_h(f, vars)

except IOError as e:

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

if hasattr(e, "strerror"):

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

raise IOError(msg)

# 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:

"""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['SO'] = '.pyd'

vars['EXT_SUFFIX'] = '.pyd'

vars['EXE'] = '.exe'

vars['VERSION'] = _PY_VERSION_SHORT_NO_DOT

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

import re

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 the path of pyconfig.h."""

if _PYTHON_BUILD:

if os.name == "nt":

inc_dir = os.path.join(_PROJECT_BASE, "PC")

else:

inc_dir = _PROJECT_BASE

else:

inc_dir = get_path('platinclude')

"""Return a tuple containing the schemes names."""

schemes = list(_INSTALL_SCHEMES.keys())

schemes.sort()

"""Return a mapping containing an install scheme.

if expand:

return _expand_vars(scheme, vars)

else:

"""Return a path corresponding to the scheme.

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

import re

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

# Distutils.

_CONFIG_VARS['prefix'] = _PREFIX

_CONFIG_VARS['exec_prefix'] = _EXEC_PREFIX

_CONFIG_VARS['py_version'] = _PY_VERSION

_CONFIG_VARS['py_version_short'] = _PY_VERSION_SHORT

_CONFIG_VARS['py_version_nodot'] = _PY_VERSION[0] + _PY_VERSION[2]

_CONFIG_VARS['base'] = _PREFIX

_CONFIG_VARS['platbase'] = _EXEC_PREFIX

_CONFIG_VARS['projectbase'] = _PROJECT_BASE

try:

_CONFIG_VARS['abiflags'] = sys.abiflags

except AttributeError:

# sys.abiflags may not be defined on all platforms.

_CONFIG_VARS['abiflags'] = ''

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

_init_non_posix(_CONFIG_VARS)

if os.name == 'posix':

_init_posix(_CONFIG_VARS)

# Setting 'userbase' is done below the call to the

# init function to enable using 'get_config_var' in

# the init-function.

_CONFIG_VARS['userbase'] = _getuserbase()

if 'srcdir' not in _CONFIG_VARS:

_CONFIG_VARS['srcdir'] = _PROJECT_BASE

else:

_CONFIG_VARS['srcdir'] = _safe_realpath(_CONFIG_VARS['srcdir'])

# Convert srcdir into an absolute path if it appears necessary.

# Normally it is relative to the build directory. However, during

# testing, for example, we might be running a non-installed python

# from a different directory.

if _PYTHON_BUILD and os.name == "posix":

base = _PROJECT_BASE

try:

cwd = os.getcwd()

except OSError:

cwd = None

if (not os.path.isabs(_CONFIG_VARS['srcdir']) and

base != cwd):

# srcdir is relative and we are not in the same directory

# as the executable. Assume executable is in the build

# directory and make srcdir absolute.

srcdir = os.path.join(base, _CONFIG_VARS['srcdir'])

_CONFIG_VARS['srcdir'] = os.path.normpath(srcdir)

# OS X platforms require special customization to handle

# multi-architecture, multi-os-version installers

if sys.platform == 'darwin':

import _osx_support

_osx_support.customize_config_vars(_CONFIG_VARS)

if args:

vals = []

for name in args:

vals.append(_CONFIG_VARS.get(name))

return vals

else:

"""Return the value of a single variable using the dictionary returned by

"""Return a string that identifies the current platform.

import re

if os.name == 'nt':

# sniff sys.version for architecture.

prefix = " bit ("

i = sys.version.find(prefix)

if i == -1:

return sys.platform

j = sys.version.find(")", i)

look = sys.version[i+len(prefix):j].lower()

if look == 'amd64':

return 'win-amd64'

if look == 'itanium':

return 'win-ia64'

return sys.platform

if os.name != "posix" or not hasattr(os, 'uname'):

# XXX what about the architecture? NT is Intel or Alpha,

# Mac OS is M68k or PPC, etc.

return sys.platform

# Try to distinguish various flavours of Unix

osname, host, release, version, machine = os.uname()

# Convert the OS name to lowercase, remove '/' characters

# (to accommodate BSD/OS), and translate spaces (for "Power Macintosh")

osname = osname.lower().replace('/', '')

machine = machine.replace(' ', '_')

machine = machine.replace('/', '-')

if osname[:5] == "linux":

# At least on Linux/Intel, 'machine' is the processor --

# i386, etc.

# XXX what about Alpha, SPARC, etc?

return "%s-%s" % (osname, machine)

elif osname[:5] == "sunos":

if release[0] >= "5": # SunOS 5 == Solaris 2

osname = "solaris"

release = "%d.%s" % (int(release[0]) - 3, release[2:])

# We can't use "platform.architecture()[0]" because a

# bootstrap problem. We use a dict to get an error

# if some suspicious happens.

bitness = {2147483647:"32bit", 9223372036854775807:"64bit"}

machine += ".%s" % bitness[sys.maxsize]

# fall through to standard osname-release-machine representation

elif osname[:4] == "irix": # could be "irix64"!

return "%s-%s" % (osname, release)

elif osname[:3] == "aix":

return "%s-%s.%s" % (osname, version, release)

elif osname[:6] == "cygwin":

osname = "cygwin"

rel_re = re.compile (r'[\d.]+')

m = rel_re.match(release)

if m:

release = m.group()

elif osname[:6] == "darwin":

import _osx_support

osname, release, machine = _osx_support.get_platform_osx(

get_config_vars(),

osname, release, machine)

for index, (key, value) in enumerate(sorted(data.items())):

if index == 0:

print('{0}: '.format(title))

"""Display all information sysconfig detains."""

print('Platform: "{0}"'.format(get_platform()))

print('Python version: "{0}"'.format(get_python_version()))

print('Current installation scheme: "{0}"'.format(_get_default_scheme()))

print('')

_print_dict('Paths', get_paths())

print('')