def test_getsitepackages(self):
site.PREFIXES = ['xoxo']
dirs = site.getsitepackages()
if (sys.platform == "darwin" and
sysconfig.get_config_var("PYTHONFRAMEWORK")):
# OS X framework builds
site.PREFIXES = ['Python.framework']
dirs = site.getsitepackages()
self.assertEqual(len(dirs), 2)
wanted = os.path.join('/Library',
sysconfig.get_config_var("PYTHONFRAMEWORK"),
'%d.%d' % sys.version_info[:2],
'site-packages')
self.assertEqual(dirs[1], wanted)
elif os.sep == '/':
# OS X non-framwework builds, Linux, FreeBSD, etc
self.assertEqual(len(dirs), 1)
wanted = os.path.join('xoxo', 'lib',
'python%d.%d' % sys.version_info[:2],
'site-packages')
self.assertEqual(dirs[0], wanted)
else:
# other platforms
self.assertEqual(len(dirs), 2)
self.assertEqual(dirs[0], 'xoxo')
wanted = os.path.join('xoxo', 'lib', 'site-packages')
self.assertEqual(dirs[1], wanted)
def copy_python_lib(dest):
files = []
if sys.platform == 'win32':
dllname = "python%s%s.dll" % sys.version_info[:2]
# two location to try
system32path = os.path.join("C:\\", "Windows", "System32")
syswow64path = os.path.join("C:\\", "Windows", "SysWOW64")
files.append(os.path.join(system32path, dllname))
if "64" in platform.machine() and "64" in platform.architecture()[0]:
files.append(os.path.join(syswow64path, dllname))
elif sys.platform == 'linux':
libname = sysconfig.get_config_var("INSTSONAME")
libdir = sysconfig.get_config_var(
'LIBDIR') + (sysconfig.get_config_var("multiarchsubdir") or "")
files.append(os.path.join(libdir, libname))
else:
# osx
pass
dest_folder = os.path.abspath(dest)
for path in files:
if os.path.exists(path):
fil = os.path.basename(path)
root, ext = os.path.splitext(fil)
to = os.path.join(dest_folder, fil)
copy_file(path, to)
def main():
"""Command line utility to retrieve compilation options for python modules'
"""
parser = argparse.ArgumentParser(
description='Retrieves compilation options for python modules.')
parser.add_argument('--libraries', help='Returns libraries',
action='store_true')
parser.add_argument('--includes', help='Returns includes',
action='store_true')
parser.add_argument('--library_dirs', help='Returns library_dirs',
action='store_true')
opts = parser.parse_args()
result = []
if opts.libraries:
python_lib = sysconfig.get_config_var('LDLIBRARY')
if python_lib.endswith(".so"):
python_lib = python_lib[:-3]
if python_lib.startswith("lib"):
python_lib = python_lib[3:]
result.append(python_lib)
if opts.includes:
result.append(sysconfig.get_config_var('INCLUDEPY'))
if opts.library_dirs:
result.append(sysconfig.get_config_var('BINLIBDEST'))
for x in result:
print x
def test_srcdir_independent_of_cwd(self):
# srcdir should be independent of the current working directory
# See Issues #15322, #15364.
srcdir = sysconfig.get_config_var('srcdir')
with change_cwd(os.pardir):
srcdir2 = sysconfig.get_config_var('srcdir')
self.assertEqual(srcdir, srcdir2)
def get_build_cflags():
"""Synthesize a CFLAGS env var from the current python env for building of C modules."""
return '{} {} -I{}'.format(
sysconfig.get_config_var('BASECFLAGS'),
sysconfig.get_config_var('OPT'),
sysconfig.get_path('include')
)
def get_enable_shared():
if WIN32:
return True
from sysconfig import get_config_var
if LINUX:
return get_config_var('Py_ENABLE_SHARED')
if which('pkg-config') is None:
exit(f'pkg-config is required and not found in path. Link to install: {LINK}')
lib = '/Library/Frameworks/Mono.framework/Versions/Current/lib'
# Create a symlink of framework lib/mono to python lib/mono
dst = os.path.join(os.path.dirname(sys.executable)[:-3] + 'lib', 'mono')
if os.path.exists(dst): os.remove(dst)
os.symlink(os.path.join(lib, 'mono'), dst)
paths = [path for path, dirs, files in os.walk(lib) if 'mono-2.pc' in files]
os.environ['PKG_CONFIG_PATH'] = ':'.join(paths)
if len(paths) == 0:
exit(f'Could not find "mono-2.pc" in "{lib}" tree.')
return get_config_var('Py_ENABLE_SHARED')
def fixup_build_ext(cmd):
"""Function needed to make build_ext tests pass.
When Python was built with --enable-shared on Unix, -L. is not enough to
find libpython<blah>.so, because regrtest runs in a tempdir, not in the
source directory where the .so lives.
When Python was built with in debug mode on Windows, build_ext commands
need their debug attribute set, and it is not done automatically for
some reason.
This function handles both of these things. Example use:
cmd = build_ext(dist)
support.fixup_build_ext(cmd)
cmd.ensure_finalized()
Unlike most other Unix platforms, Mac OS X embeds absolute paths
to shared libraries into executables, so the fixup is not needed there.
"""
if os.name == 'nt':
cmd.debug = sys.executable.endswith('_d.exe')
elif sysconfig.get_config_var('Py_ENABLE_SHARED'):
# To further add to the shared builds fun on Unix, we can't just add
# library_dirs to the Extension() instance because that doesn't get
# plumbed through to the final compiler command.
runshared = sysconfig.get_config_var('RUNSHARED')
if runshared is None:
cmd.library_dirs = ['.']
else:
if sys.platform == 'darwin':
cmd.library_dirs = []
else:
name, equals, value = runshared.partition('=')
cmd.library_dirs = value.split(os.pathsep)
def so_path(dir, filename):
'''http://www.python.org/dev/peps/pep-3149/'''
suffix = sysconfig.get_config_var('SO')
if not suffix:
soabi = sysconfig.get_config_var('SOABI')
suffix = ".{}.so".format(soabi)
return os.path.join(dir, filename + suffix)
def load_lib():
"""Find and load libspacepy
Normally this will be in the directory where spacepy is installed,
under libspacepy.
@return: the open library
@rtype: ctypes.CDLL or ctypes.WinDLL
"""
libdir = os.path.dirname(os.path.abspath(__file__))
if sys.platform == 'win32':
libnames = ['spacepy.dll']
elif sys.platform == 'darwin':
libnames = ['libspacepy.dylib', 'libspacepy.so',
'spacepy.dylib', 'spacepy.so']
else:
libnames = ['libspacepy.so']
if sysconfig:
ext = sysconfig.get_config_var('EXT_SUFFIX')
if ext is None:
ext = sysconfig.get_config_var('SO')
if ext:
libnames.append('libspacepy' + ext)
libnames.append('spacepy' + ext)
libpath = None
for n in libnames:
libpath = os.path.join(libdir, n)
if os.path.exists(libpath):
break
if libpath and os.path.exists(libpath):
return ctypes.CDLL(libpath)
else:
return None
def test_cpython_abi_py2(debug, pymalloc, unicode_width, monkeypatch):
has_soabi = sysconfig.get_config_var("SOABI")
if platform.python_implementation() != "CPython" or has_soabi:
diff_debug = debug != sysconfig.get_config_var("Py_DEBUG")
diff_malloc = pymalloc != sysconfig.get_config_var("WITH_PYMALLOC")
unicode_size = sysconfig.get_config_var("Py_UNICODE_SIZE")
diff_unicode_size = unicode_size != unicode_width
if diff_debug or diff_malloc or diff_unicode_size:
config_vars = {
"SOABI": None,
"Py_DEBUG": int(debug),
"WITH_PYMALLOC": int(pymalloc),
"Py_UNICODE_SIZE": unicode_width,
}
monkeypatch.setattr(sysconfig, "get_config_var", config_vars.__getitem__)
else:
config_vars = {
"SOABI": None,
"Py_DEBUG": int(debug),
"WITH_PYMALLOC": int(pymalloc),
"Py_UNICODE_SIZE": unicode_width,
}
monkeypatch.setattr(sysconfig, "get_config_var", config_vars.__getitem__)
options = ""
if debug:
options += "d"
if pymalloc:
options += "m"
if unicode_width == 4:
options += "u"
assert "cp33{}".format(options) == tags._cpython_abi((3, 3))
def _find_libpy3_windows(self, env):
'''
Find python3 libraries on Windows and also verify that the arch matches
what we are building for.
'''
pyarch = sysconfig.get_platform()
arch = detect_cpu_family(env.coredata.compilers)
if arch == 'x86':
arch = '32'
elif arch == 'x86_64':
arch = '64'
else:
# We can't cross-compile Python 3 dependencies on Windows yet
mlog.log('Unknown architecture {!r} for'.format(arch),
mlog.bold(self.name))
self.is_found = False
return
# Pyarch ends in '32' or '64'
if arch != pyarch[-2:]:
mlog.log('Need', mlog.bold(self.name),
'for {}-bit, but found {}-bit'.format(arch, pyarch[-2:]))
self.is_found = False
return
inc = sysconfig.get_path('include')
platinc = sysconfig.get_path('platinclude')
self.compile_args = ['-I' + inc]
if inc != platinc:
self.compile_args.append('-I' + platinc)
# Nothing exposes this directly that I coulf find
basedir = sysconfig.get_config_var('base')
vernum = sysconfig.get_config_var('py_version_nodot')
self.link_args = ['-L{}/libs'.format(basedir),
'-lpython{}'.format(vernum)]
self.version = sysconfig.get_config_var('py_version_short')
self.is_found = True
def sysconfig2():
# import sysconfig module - Provide access to Python’s configuration information
import sysconfig
# returns an installation path corresponding to the path name
print("Path Name : ", sysconfig.get_path("stdlib"))
print()
# returns a string that identifies the current platform.
print("Current Platform : ", sysconfig.get_platform())
print()
# returns the MAJOR.MINOR Python version number as a string
print("Python Version Number : ", sysconfig.get_python_version())
print()
# returns a tuple containing all path names
print("Path Names : ", sysconfig.get_path_names())
print()
# returns a tuple containing all schemes
print("Scheme Names : ", sysconfig.get_scheme_names())
print()
# returns the value of a single variable name.
print("Variable name LIBDIR : ", sysconfig.get_config_var('LIBDIR'))
# returns the value of a single variable name.
print("Variable name LIBDEST : ", sysconfig.get_config_var('LIBDEST'))
def test_getsitepackages(self):
site.PREFIXES = ["xoxo"]
dirs = site.getsitepackages()
if sys.platform in ("os2emx", "riscos"):
self.assertEqual(len(dirs), 1)
wanted = os.path.join("xoxo", "Lib", "site-packages")
self.assertEqual(dirs[0], wanted)
elif sys.platform == "darwin" and sysconfig.get_config_var("PYTHONFRAMEWORK"):
# OS X framework builds
site.PREFIXES = ["Python.framework"]
dirs = site.getsitepackages()
self.assertEqual(len(dirs), 3)
wanted = os.path.join(
"/Library", sysconfig.get_config_var("PYTHONFRAMEWORK"), sys.version[:3], "site-packages"
)
self.assertEqual(dirs[2], wanted)
elif os.sep == "/":
# OS X non-framwework builds, Linux, FreeBSD, etc
self.assertEqual(len(dirs), 3)
wanted = os.path.join("xoxo", "lib", "python" + sys.version[:3], "site-packages")
self.assertEqual(dirs[0], wanted)
wanted = os.path.join("xoxo", "lib", "site-python")
self.assertEqual(dirs[1], wanted)
else:
# other platforms
self.assertEqual(len(dirs), 2)
self.assertEqual(dirs[0], "xoxo")
wanted = os.path.join("xoxo", "lib", "site-packages")
self.assertEqual(dirs[1], wanted)
def fixup_build_ext(cmd):
"""Function needed to make build_ext tests pass.
When Python was build with --enable-shared on Unix, -L. is not good
enough to find the libpython<blah>.so. This is because regrtest runs
it under a tempdir, not in the top level where the .so lives. By the
time we've gotten here, Python's already been chdir'd to the tempdir.
When Python was built with in debug mode on Windows, build_ext commands
need their debug attribute set, and it is not done automatically for
some reason.
This function handles both of these things. Example use:
cmd = build_ext(dist)
support.fixup_build_ext(cmd)
cmd.ensure_finalized()
Unlike most other Unix platforms, Mac OS X embeds absolute paths
to shared libraries into executables, so the fixup is not needed there.
"""
if os.name == 'nt':
cmd.debug = sys.executable.endswith('_d.exe')
elif sysconfig.get_config_var('Py_ENABLE_SHARED'):
runshared = sysconfig.get_config_var('RUNSHARED')
if runshared is None:
cmd.library_dirs = ['.']
elif sys.platform == 'darwin':
cmd.library_dirs = []
else:
name, equals, value = runshared.partition('=')
cmd.library_dirs = [ d for d in value.split(os.pathsep) if d ]
return
def copy_embeddable_python_dylib(dst):
runtime = op.join(sysconfig.get_config_var('PYTHONFRAMEWORKPREFIX'), sysconfig.get_config_var('LDLIBRARY'))
filedest = op.join(dst, 'Python')
shutil.copy(runtime, filedest)
os.chmod(filedest, 0o774) # We need write permission to use install_name_tool
cmd = 'install_name_tool -id @rpath/Python %s' % filedest
print_and_do(cmd)
def fixup_build_ext(cmd):
"""Function needed to make build_ext tests pass.
When Python was build with --enable-shared on Unix, -L. is not good
enough to find the libpython<blah>.so. This is because regrtest runs
it under a tempdir, not in the top level where the .so lives. By the
time we've gotten here, Python's already been chdir'd to the tempdir.
When Python was built with in debug mode on Windows, build_ext commands
need their debug attribute set, and it is not done automatically for
some reason.
This function handles both of these things. Example use:
cmd = build_ext(dist)
support.fixup_build_ext(cmd)
cmd.ensure_finalized()
"""
if os.name == 'nt':
cmd.debug = sys.executable.endswith('_d.exe')
elif sysconfig.get_config_var('Py_ENABLE_SHARED'):
# To further add to the shared builds fun on Unix, we can't just add
# library_dirs to the Extension() instance because that doesn't get
# plumbed through to the final compiler command.
runshared = sysconfig.get_config_var('RUNSHARED')
if runshared is None:
cmd.library_dirs = ['.']
else:
name, equals, value = runshared.partition('=')
cmd.library_dirs = value.split(os.pathsep)
def candidate_names(suffix=SHLIB_SUFFIX):
"""
Iterate over candidate file names of libpython.
Yields
------
name : str
Candidate name libpython.
"""
LDLIBRARY = sysconfig.get_config_var("LDLIBRARY")
if LDLIBRARY:
yield LDLIBRARY
LIBRARY = sysconfig.get_config_var("LIBRARY")
if LIBRARY:
yield os.path.splitext(LIBRARY)[0] + suffix
dlprefix = "" if is_windows else "lib"
sysdata = dict(
v=sys.version_info,
# VERSION is X.Y in Linux/macOS and XY in Windows:
VERSION=(sysconfig.get_config_var("VERSION") or
"{v.major}.{v.minor}".format(v=sys.version_info)),
ABIFLAGS=(sysconfig.get_config_var("ABIFLAGS") or
sysconfig.get_config_var("abiflags") or ""),
)
for stem in [
"python{VERSION}{ABIFLAGS}".format(**sysdata),
"python{VERSION}".format(**sysdata),
"python{v.major}".format(**sysdata),
"python",
]:
yield dlprefix + stem + suffix
def _find_python_dll_file(fail=False):
logging.debug("Searching for Python shared library file")
#
# Prepare list of search directories
#
search_dirs = [sys.prefix]
extra_search_dirs = [sysconfig.get_config_var(name) for name in PYTHON_LIB_DIR_CONFIG_VAR_NAMES]
for extra_dir in extra_search_dirs:
if extra_dir and not extra_dir in search_dirs and os.path.exists(extra_dir):
search_dirs.append(extra_dir)
if platform.system() == 'Windows':
extra_search_dirs = _get_existing_subdirs(search_dirs, "DLLs")
search_dirs = extra_search_dirs + search_dirs
multi_arch_sub_dir = sysconfig.get_config_var('multiarchsubdir')
if multi_arch_sub_dir:
while multi_arch_sub_dir.startswith('/'):
multi_arch_sub_dir = multi_arch_sub_dir[1:]
extra_search_dirs = _get_existing_subdirs(search_dirs, multi_arch_sub_dir)
search_dirs = extra_search_dirs + search_dirs
logging.debug("Potential Python shared library search dirs: %s" % repr(search_dirs))
#
# Prepare list of possible library file names
#
vmaj = str(sys.version_info.major)
vmin = str(sys.version_info.minor)
if platform.system() == 'Windows':
versions = (vmaj + vmin, vmaj, '')
file_names = ['python' + v + '.dll' for v in versions]
elif platform.system() == 'Darwin':
versions = (vmaj + "." + vmin, vmaj, '')
file_names = ['libpython' + v + '.dylib' for v in versions] + \
['libpython' + v + '.so' for v in versions]
else:
versions = (vmaj + "." + vmin, vmaj, '')
file_names = ['libpython' + v + '.so' for v in versions]
logging.debug("Potential Python shared library file names: %s" % repr(file_names))
python_dll_path = _find_file(search_dirs, *file_names)
if python_dll_path:
return python_dll_path
python_dll_path = ctypes.util.find_library(PYTHON_LIB_NAME)
if python_dll_path:
logging.debug(
"No Python shared library file found in all search paths. Using fallback %s" % repr(python_dll_path))
elif fail:
raise RuntimeError("can't find any Python shared library")
return python_dll_path
def ocropus_find_file(fname, gz=True):
"""Search for `fname` in one of the OCRopus data directories, as well as
the current directory). If `gz` is True, search also for gzipped files.
Result of searching $fname is the first existing in:
* $base/$fname
* $base/$fname.gz # if gz
* $base/model/$fname
* $base/model/$fname.gz # if gz
* $base/data/$fname
* $base/data/$fname.gz # if gz
* $base/gui/$fname
* $base/gui/$fname.gz # if gz
$base can be four base paths:
* `$OCROPUS_DATA` environment variable
* current working directory
* ../../../../share/ocropus from this file's install location
* `/usr/local/share/ocropus`
* `$PREFIX/share/ocropus` ($PREFIX being the Python installation
prefix, usually `/usr`)
"""
possible_prefixes = []
if os.getenv("OCROPUS_DATA"):
possible_prefixes.append(os.getenv("OCROPUS_DATA"))
possible_prefixes.append(os.curdir)
possible_prefixes.append(os.path.normpath(os.path.join(
os.path.dirname(inspect.getfile(inspect.currentframe())),
os.pardir, os.pardir, os.pardir, os.pardir, "share", "ocropus")))
possible_prefixes.append("/usr/local/share/ocropus")
# datarootdir is None in windows so don't add it to search list
if sysconfig.get_config_var("datarootdir") is not None:
possible_prefixes.append(os.path.join(
sysconfig.get_config_var("datarootdir"), "ocropus"))
# Unique entries with preserved order in possible_prefixes
# http://stackoverflow.com/a/15637398/201318
possible_prefixes = [possible_prefixes[i] for i in
sorted(numpy.unique(possible_prefixes, return_index=True)[1])]
for prefix in possible_prefixes:
if not os.path.isdir(prefix):
continue
for basename in [".", "models", "data", "gui"]:
if not os.path.isdir(os.path.join(prefix, basename)):
continue
full = os.path.join(prefix, basename, fname)
if os.path.exists(full):
return full
if gz and os.path.exists(full + ".gz"):
return full + ".gz"
raise FileNotFound(fname)
def syspy_so_fpath(self, identifier):
if self.use_multiarch_fnames:
fname = '{}.{}-{}.so'.format(identifier, sysconfig.get_config_var('SOABI'),
sysconfig.get_config_var('MULTIARCH'))
else:
fname = '{}.so'.format(identifier)
return self.package_dpath().joinpath(fname)
def copy_embeddable_python_dylib(dst):
if not sysconfig.get_config_var('PYTHONFRAMEWORKPREFIX'):
raise Exception("Python needs to be compiled with the -framework option. Aborting.")
runtime = op.join(sysconfig.get_config_var('PYTHONFRAMEWORKPREFIX'), sysconfig.get_config_var('LDLIBRARY'))
filedest = op.join(dst, 'Python')
shutil.copy(runtime, filedest)
os.chmod(filedest, 0o774) # We need write permission to use install_name_tool
cmd = 'install_name_tool -id @rpath/Python %s' % filedest
print_and_do(cmd)
def test_cpython_abi_py3(monkeypatch):
has_soabi = bool(sysconfig.get_config_var("SOABI"))
if platform.python_implementation() != "CPython" or not has_soabi:
monkeypatch.setattr(
sysconfig, "get_config_var", lambda key: "'cpython-37m-darwin'"
)
soabi = sysconfig.get_config_var("SOABI").split("-", 2)[1]
result = tags._cpython_abi(sys.version_info[:2])
assert result == "cp{soabi}".format(soabi=soabi)
def test_user_similar(self):
# Issue 8759 : make sure the posix scheme for the users
# is similar to the global posix_prefix one
base = get_config_var("base")
user = get_config_var("userbase")
for name in ("stdlib", "platstdlib", "purelib", "platlib"):
global_path = get_path(name, "posix_prefix")
user_path = get_path(name, "posix_user")
self.assertEquals(user_path, global_path.replace(base, user))
def get_libraries(extralibs=[], debug=False):
"""Return the list of libraries to link against when building a
shared extension. On most platforms, this is just 'ext.libraries';
on Windows, we add the Python library (eg. python20.dll).
"""
# The python library is always needed on Windows. For MSVC, this
# is redundant, since the library is mentioned in a pragma in
# pyconfig.h that MSVC groks. The other Windows compilers all seem
# to need it mentioned explicitly, though, so that's what we do.
# Append '_d' to the python import library on debug builds.
if sys.platform == "win32":
template = "python%d%d"
if debug:
template = template + '_d'
pythonlib = (template %
(sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff))
# don't extend ext.libraries, it may be shared with other
# extensions, it is a reference to the original list
return extralibs + [pythonlib]
elif sys.platform[:6] == "cygwin":
template = "python%d.%d"
pythonlib = (template %
(sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff))
# don't extend ext.libraries, it may be shared with other
# extensions, it is a reference to the original list
return extralibs + [pythonlib]
elif sys.platform[:6] == "atheos":
from distutils import sysconfig
template = "python%d.%d"
pythonlib = (template %
(sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff))
# Get SHLIBS from Makefile
extra = []
for lib in sysconfig.get_config_var('SHLIBS').split():
if lib.startswith('-l'):
extra.append(lib[2:])
else:
extra.append(lib)
# don't extend ext.libraries, it may be shared with other
# extensions, it is a reference to the original list
return extralibs + [pythonlib, "m"] + extra
elif sys.platform == 'darwin':
# Don't use the default code below
return extralibs
elif sys.platform[:3] == 'aix':
# Don't use the default code below
return extralibs
else:
from distutils import sysconfig
if sysconfig.get_config_var('Py_ENABLE_SHARED'):
pythonlib = 'python{}.{}{}'.format(
sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff,
sys.abiflags)
return extralibs + [pythonlib]
else:
return extralibs
def test_user_similar(self):
# Issue 8759 : make sure the posix scheme for the users
# is similar to the global posix_prefix one
base = get_config_var('base')
user = get_config_var('userbase')
for name in ('stdlib', 'platstdlib', 'purelib', 'platlib'):
global_path = get_path(name, 'posix_prefix')
user_path = get_path(name, 'posix_user')
self.assertEqual(user_path, global_path.replace(base, user))
def get_python_version():
python_version = sysconfig.get_config_var('VERSION')
if not python_version:
python_version = sysconfig.get_config_var('py_version_short')
if not python_version:
python_version = ".".join(map(str, sys.version_info[:2]))
return python_version
def get_java2cpython_libdest(self):
if is_win:
python_lib_dir = os.path.join(
sysconfig.get_config_var('platbase'),
'LIBS')
lib_name = "java2cpython" + SO
else:
python_lib_dir = sysconfig.get_config_var('LIBDIR')
lib_name = "libjava2cpython" + SO
return python_lib_dir, lib_name
def __get_libres(self):
'''
Computes libpath based on whether module_name is set or not
Returns-->list of str lib paths to try
PEP3140: ABI version tagged .so files:
https://www.python.org/dev/peps/pep-3149/
There's still one unexplained bit: pypy adds '-' + sys._multiarch()
at the end (looks like 'x86_64-linux-gnu'), but neither py2 or py3 do
Additionally, in older releases of pypy (e.g. build f3ad1e1e1d62
Aug-28-2015), sysconfig.get_config_var('SOABI') returns '' but
shared library still has '.pypy-26' in the name!
So for pypy we try this this variant anyway!
_I_ think Py2 and Py3 _MAY_ start adding sys._multiarch at some time
So, we generate three forms:
1. With sys._multiarch
2. Without sys._multiarch
3. libpath as-is - always tried by self.__openlib anyway
For different versions we try in different order (for efficiency):
Python2 Python3 Pypy
2 --> 1 --> 3 2 --> 1 --> 3 1 --> 2 --> 3
'''
if self._module_name is None:
return []
ending = '.so'
base = self._libpath.rsplit(ending, 1)[0]
abi = sysconfig.get_config_var('SOABI')
if abi is not None:
abi = '.' + abi
else:
abi = ''
multi_arch = sysconfig.get_config_var('MULTIARCH')
if multi_arch is None:
multi_arch = ''
else:
multi_arch = '-' + multi_arch
if PYPY:
n1 = base + abi + multi_arch + ending
n2 = base + abi + ending
else:
n1 = base + abi + ending
n2 = base + abi + multi_arch + ending
if PYPY:
n3 = base + '.pypy-26' + ending
return [n1, n2, n3]
else:
return [n1, n2]
def test_srcdir_independent_of_cwd(self):
# srcdir should be independent of the current working directory
# See Issues #15322, #15364.
srcdir = sysconfig.get_config_var('srcdir')
cwd = os.getcwd()
try:
os.chdir('..')
srcdir2 = sysconfig.get_config_var('srcdir')
finally:
os.chdir(cwd)
self.assertEqual(srcdir, srcdir2)
def get_ext_suffix():
"""Determine library extension for various versions of Python."""
ext_suffix = sysconfig.get_config_var('EXT_SUFFIX')
if ext_suffix:
return ext_suffix
ext_suffix = sysconfig.get_config_var('SO')
if ext_suffix:
return ext_suffix
return '.so'
# (c)2010 Dennis Kaarsemaker <[email protected] # See COPYING for licensing details import distutils.util import glob import os import re import signal import sys import subprocess import unittest so = '.so' try: import sysconfig so = sysconfig.get_config_var('SO') except ImportError: pass curdir = os.path.dirname(__file__) builddir = os.path.join(curdir, 'build', 'lib.%s-%s' % (distutils.util.get_platform(), sys.version[0:3])) # Always run from the builddir if not os.path.exists(builddir) or \ not os.path.exists(os.path.join(builddir, 'prctl.py')) or \ not os.path.exists(os.path.join(builddir, '_prctl' + so)) or \ os.path.getmtime(os.path.join(curdir, 'prctl.py')) > os.path.getmtime(os.path.join(builddir, 'prctl.py')) or \ os.path.getmtime(os.path.join(curdir, '_prctlmodule.c')) > os.path.getmtime(os.path.join(builddir, '_prctl' + so)): sys.stderr.write("Please build the extension first, using ./setup.py build\n") sys.exit(1) sys.path.insert(0, builddir)
def get_sysconfig__CONFIG_VARS(self):
# make sure the dict is initialized
sysconfig.get_config_var('prefix')
return (id(sysconfig._CONFIG_VARS), sysconfig._CONFIG_VARS,
dict(sysconfig._CONFIG_VARS))
STDTESTS, NOTTESTS, PASSED, FAILED,
ENV_CHANGED, SKIPPED, RESOURCE_DENIED,
INTERRUPTED, CHILD_ERROR,
PROGRESS_MIN_TIME, format_test_result)
from test.libregrtest.setup import setup_tests
from test import support
try:
import gc
except ImportError:
gc = None
# When tests are run from the Python build directory, it is best practice
# to keep the test files in a subfolder. This eases the cleanup of leftover
# files using the "make distclean" command.
if sysconfig.is_python_build():
TEMPDIR = sysconfig.get_config_var('abs_builddir')
if TEMPDIR is None:
# bpo-30284: On Windows, only srcdir is available. Using abs_builddir
# mostly matters on UNIX when building Python out of the source tree,
# especially when the source tree is read only.
TEMPDIR = sysconfig.get_config_var('srcdir')
TEMPDIR = os.path.join(TEMPDIR, 'build')
else:
TEMPDIR = tempfile.gettempdir()
TEMPDIR = os.path.abspath(TEMPDIR)
def format_duration(seconds):
if seconds < 1.0:
return '%.0f ms' % (seconds * 1e3)
if seconds < 60.0:
import threading
import unittest
import warnings
from test import support
from test.support import _4G, bigmemtest
from test.support.import_helper import import_fresh_module
from test.support import threading_helper
from http.client import HTTPException
# Were we compiled --with-pydebug or with #define Py_DEBUG?
COMPILED_WITH_PYDEBUG = hasattr(sys, 'gettotalrefcount')
# default builtin hash module
default_builtin_hashes = {'md5', 'sha1', 'sha256', 'sha512', 'sha3', 'blake2'}
# --with-builtin-hashlib-hashes override
builtin_hashes = sysconfig.get_config_var("PY_BUILTIN_HASHLIB_HASHES")
if builtin_hashes is None:
builtin_hashes = default_builtin_hashes
else:
builtin_hashes = {
m.strip() for m in builtin_hashes.strip('"').lower().split(",")
}
# hashlib with and without OpenSSL backend for PBKDF2
# only import builtin_hashlib when all builtin hashes are available.
# Otherwise import prints noise on stderr
openssl_hashlib = import_fresh_module('hashlib', fresh=['_hashlib'])
if builtin_hashes == default_builtin_hashes:
builtin_hashlib = import_fresh_module('hashlib', blocked=['_hashlib'])
else:
builtin_hashlib = None
class TestSysConfig(unittest.TestCase):
def setUp(self):
super(TestSysConfig, self).setUp()
self.sys_path = sys.path[:]
# patching os.uname
if hasattr(os, 'uname'):
self.uname = os.uname
self._uname = os.uname()
else:
self.uname = None
self._set_uname(('', ) * 5)
os.uname = self._get_uname
# saving the environment
self.name = os.name
self.platform = sys.platform
self.version = sys.version
self.sep = os.sep
self.join = os.path.join
self.isabs = os.path.isabs
self.splitdrive = os.path.splitdrive
self._config_vars = sysconfig._CONFIG_VARS, copy(
sysconfig._CONFIG_VARS)
self._added_envvars = []
self._changed_envvars = []
for var in ('MACOSX_DEPLOYMENT_TARGET', 'PATH'):
if var in os.environ:
self._changed_envvars.append((var, os.environ[var]))
else:
self._added_envvars.append(var)
def tearDown(self):
sys.path[:] = self.sys_path
self._cleanup_testfn()
if self.uname is not None:
os.uname = self.uname
else:
del os.uname
os.name = self.name
sys.platform = self.platform
sys.version = self.version
os.sep = self.sep
os.path.join = self.join
os.path.isabs = self.isabs
os.path.splitdrive = self.splitdrive
sysconfig._CONFIG_VARS = self._config_vars[0]
sysconfig._CONFIG_VARS.clear()
sysconfig._CONFIG_VARS.update(self._config_vars[1])
for var, value in self._changed_envvars:
os.environ[var] = value
for var in self._added_envvars:
os.environ.pop(var, None)
super(TestSysConfig, self).tearDown()
def _set_uname(self, uname):
self._uname = os.uname_result(uname)
def _get_uname(self):
return self._uname
def _cleanup_testfn(self):
path = TESTFN
if os.path.isfile(path):
os.remove(path)
elif os.path.isdir(path):
shutil.rmtree(path)
def test_get_path_names(self):
self.assertEqual(get_path_names(), sysconfig._SCHEME_KEYS)
def test_get_paths(self):
scheme = get_paths()
default_scheme = get_default_scheme()
wanted = _expand_vars(default_scheme, None)
wanted = sorted(wanted.items())
scheme = sorted(scheme.items())
self.assertEqual(scheme, wanted)
def test_get_path(self):
config_vars = get_config_vars()
for scheme in _INSTALL_SCHEMES:
for name in _INSTALL_SCHEMES[scheme]:
expected = _INSTALL_SCHEMES[scheme][name].format(**config_vars)
self.assertEqual(
os.path.normpath(get_path(name, scheme)),
os.path.normpath(expected),
)
def test_get_default_scheme(self):
self.assertIn(get_default_scheme(), _INSTALL_SCHEMES)
def test_get_preferred_schemes(self):
expected_schemes = {'prefix', 'home', 'user'}
# Windows.
os.name = 'nt'
schemes = _get_preferred_schemes()
self.assertIsInstance(schemes, dict)
self.assertEqual(set(schemes), expected_schemes)
# Mac and Linux, shared library build.
os.name = 'posix'
schemes = _get_preferred_schemes()
self.assertIsInstance(schemes, dict)
self.assertEqual(set(schemes), expected_schemes)
# Mac, framework build.
os.name = 'posix'
sys.platform = 'darwin'
sys._framework = True
self.assertIsInstance(schemes, dict)
self.assertEqual(set(schemes), expected_schemes)
def test_get_config_vars(self):
cvars = get_config_vars()
self.assertIsInstance(cvars, dict)
self.assertTrue(cvars)
def test_get_platform(self):
# windows XP, 32bits
os.name = 'nt'
sys.version = ('2.4.4 (#71, Oct 18 2006, 08:34:43) '
'[MSC v.1310 32 bit (Intel)]')
sys.platform = 'win32'
self.assertEqual(get_platform(), 'win32')
# windows XP, amd64
os.name = 'nt'
sys.version = ('2.4.4 (#71, Oct 18 2006, 08:34:43) '
'[MSC v.1310 32 bit (Amd64)]')
sys.platform = 'win32'
self.assertEqual(get_platform(), 'win-amd64')
# macbook
os.name = 'posix'
sys.version = ('2.5 (r25:51918, Sep 19 2006, 08:49:13) '
'\n[GCC 4.0.1 (Apple Computer, Inc. build 5341)]')
sys.platform = 'darwin'
self._set_uname(('Darwin', 'macziade', '8.11.1',
('Darwin Kernel Version 8.11.1: '
'Wed Oct 10 18:23:28 PDT 2007; '
'root:xnu-792.25.20~1/RELEASE_I386'), 'PowerPC'))
_osx_support._remove_original_values(get_config_vars())
get_config_vars()['MACOSX_DEPLOYMENT_TARGET'] = '10.3'
get_config_vars()['CFLAGS'] = ('-fno-strict-aliasing -DNDEBUG -g '
'-fwrapv -O3 -Wall -Wstrict-prototypes')
maxint = sys.maxsize
try:
sys.maxsize = 2147483647
self.assertEqual(get_platform(), 'macosx-10.3-ppc')
sys.maxsize = 9223372036854775807
self.assertEqual(get_platform(), 'macosx-10.3-ppc64')
finally:
sys.maxsize = maxint
self._set_uname(('Darwin', 'macziade', '8.11.1',
('Darwin Kernel Version 8.11.1: '
'Wed Oct 10 18:23:28 PDT 2007; '
'root:xnu-792.25.20~1/RELEASE_I386'), 'i386'))
_osx_support._remove_original_values(get_config_vars())
get_config_vars()['MACOSX_DEPLOYMENT_TARGET'] = '10.3'
get_config_vars()['CFLAGS'] = ('-fno-strict-aliasing -DNDEBUG -g '
'-fwrapv -O3 -Wall -Wstrict-prototypes')
maxint = sys.maxsize
try:
sys.maxsize = 2147483647
self.assertEqual(get_platform(), 'macosx-10.3-i386')
sys.maxsize = 9223372036854775807
self.assertEqual(get_platform(), 'macosx-10.3-x86_64')
finally:
sys.maxsize = maxint
# macbook with fat binaries (fat, universal or fat64)
_osx_support._remove_original_values(get_config_vars())
get_config_vars()['MACOSX_DEPLOYMENT_TARGET'] = '10.4'
get_config_vars()['CFLAGS'] = ('-arch ppc -arch i386 -isysroot '
'/Developer/SDKs/MacOSX10.4u.sdk '
'-fno-strict-aliasing -fno-common '
'-dynamic -DNDEBUG -g -O3')
self.assertEqual(get_platform(), 'macosx-10.4-fat')
_osx_support._remove_original_values(get_config_vars())
get_config_vars()['CFLAGS'] = ('-arch x86_64 -arch i386 -isysroot '
'/Developer/SDKs/MacOSX10.4u.sdk '
'-fno-strict-aliasing -fno-common '
'-dynamic -DNDEBUG -g -O3')
self.assertEqual(get_platform(), 'macosx-10.4-intel')
_osx_support._remove_original_values(get_config_vars())
get_config_vars()['CFLAGS'] = (
'-arch x86_64 -arch ppc -arch i386 -isysroot '
'/Developer/SDKs/MacOSX10.4u.sdk '
'-fno-strict-aliasing -fno-common '
'-dynamic -DNDEBUG -g -O3')
self.assertEqual(get_platform(), 'macosx-10.4-fat3')
_osx_support._remove_original_values(get_config_vars())
get_config_vars()['CFLAGS'] = (
'-arch ppc64 -arch x86_64 -arch ppc -arch i386 -isysroot '
'/Developer/SDKs/MacOSX10.4u.sdk '
'-fno-strict-aliasing -fno-common '
'-dynamic -DNDEBUG -g -O3')
self.assertEqual(get_platform(), 'macosx-10.4-universal')
_osx_support._remove_original_values(get_config_vars())
get_config_vars()['CFLAGS'] = ('-arch x86_64 -arch ppc64 -isysroot '
'/Developer/SDKs/MacOSX10.4u.sdk '
'-fno-strict-aliasing -fno-common '
'-dynamic -DNDEBUG -g -O3')
self.assertEqual(get_platform(), 'macosx-10.4-fat64')
for arch in ('ppc', 'i386', 'x86_64', 'ppc64'):
_osx_support._remove_original_values(get_config_vars())
get_config_vars()['CFLAGS'] = ('-arch %s -isysroot '
'/Developer/SDKs/MacOSX10.4u.sdk '
'-fno-strict-aliasing -fno-common '
'-dynamic -DNDEBUG -g -O3' % arch)
self.assertEqual(get_platform(), 'macosx-10.4-%s' % arch)
# linux debian sarge
os.name = 'posix'
sys.version = ('2.3.5 (#1, Jul 4 2007, 17:28:59) '
'\n[GCC 4.1.2 20061115 (prerelease) (Debian 4.1.1-21)]')
sys.platform = 'linux2'
self._set_uname(('Linux', 'aglae', '2.6.21.1dedibox-r7',
'#1 Mon Apr 30 17:25:38 CEST 2007', 'i686'))
self.assertEqual(get_platform(), 'linux-i686')
# XXX more platforms to tests here
def test_get_config_h_filename(self):
config_h = sysconfig.get_config_h_filename()
self.assertTrue(os.path.isfile(config_h), config_h)
def test_get_scheme_names(self):
wanted = ['nt', 'posix_home', 'posix_prefix', 'rpm_prefix', 'venv']
if HAS_USER_BASE:
wanted.extend(['nt_user', 'osx_framework_user', 'posix_user'])
self.assertEqual(get_scheme_names(), tuple(sorted(wanted)))
@skip_unless_symlink
def test_symlink(self): # Issue 7880
with PythonSymlink() as py:
cmd = "-c", "import sysconfig; print(sysconfig.get_platform())"
self.assertEqual(py.call_real(*cmd), py.call_link(*cmd))
@unittest.skipIf('RPM_BUILD_ROOT' not in os.environ,
"Test doesn't expect Fedora's paths")
def test_user_similar(self):
# Issue #8759: make sure the posix scheme for the users
# is similar to the global posix_prefix one
base = get_config_var('base')
if HAS_USER_BASE:
user = get_config_var('userbase')
# the global scheme mirrors the distinction between prefix and
# exec-prefix but not the user scheme, so we have to adapt the paths
# before comparing (issue #9100)
adapt = sys.base_prefix != sys.base_exec_prefix
for name in ('stdlib', 'platstdlib', 'purelib', 'platlib'):
global_path = get_path(name, 'posix_prefix')
if adapt:
global_path = global_path.replace(sys.exec_prefix,
sys.base_prefix)
base = base.replace(sys.exec_prefix, sys.base_prefix)
elif sys.base_prefix != sys.prefix:
# virtual environment? Likewise, we have to adapt the paths
# before comparing
global_path = global_path.replace(sys.base_prefix, sys.prefix)
base = base.replace(sys.base_prefix, sys.prefix)
if HAS_USER_BASE:
user_path = get_path(name, 'posix_user')
expected = global_path.replace(base, user, 1)
# bpo-44860: platlib of posix_user doesn't use sys.platlibdir,
# whereas posix_prefix does.
if name == 'platlib':
# Replace "/lib64/python3.11/site-packages" suffix
# with "/lib/python3.11/site-packages".
py_version_short = sysconfig.get_python_version()
suffix = f'python{py_version_short}/site-packages'
expected = expected.replace(f'/{sys.platlibdir}/{suffix}',
f'/lib/{suffix}')
self.assertEqual(user_path, expected)
def test_main(self):
# just making sure _main() runs and returns things in the stdout
with captured_stdout() as output:
_main()
self.assertTrue(len(output.getvalue().split('\n')) > 0)
@unittest.skipIf(sys.platform == "win32", "Does not apply to Windows")
def test_ldshared_value(self):
ldflags = sysconfig.get_config_var('LDFLAGS')
ldshared = sysconfig.get_config_var('LDSHARED')
self.assertIn(ldflags, ldshared)
@unittest.skipUnless(sys.platform == "darwin",
"test only relevant on MacOSX")
def test_platform_in_subprocess(self):
my_platform = sysconfig.get_platform()
# Test without MACOSX_DEPLOYMENT_TARGET in the environment
env = os.environ.copy()
if 'MACOSX_DEPLOYMENT_TARGET' in env:
del env['MACOSX_DEPLOYMENT_TARGET']
p = subprocess.Popen([
sys.executable,
'-c',
'import sysconfig; print(sysconfig.get_platform())',
],
stdout=subprocess.PIPE,
stderr=subprocess.DEVNULL,
env=env)
test_platform = p.communicate()[0].strip()
test_platform = test_platform.decode('utf-8')
status = p.wait()
self.assertEqual(status, 0)
self.assertEqual(my_platform, test_platform)
# Test with MACOSX_DEPLOYMENT_TARGET in the environment, and
# using a value that is unlikely to be the default one.
env = os.environ.copy()
env['MACOSX_DEPLOYMENT_TARGET'] = '10.1'
p = subprocess.Popen([
sys.executable,
'-c',
'import sysconfig; print(sysconfig.get_platform())',
],
stdout=subprocess.PIPE,
stderr=subprocess.DEVNULL,
env=env)
test_platform = p.communicate()[0].strip()
test_platform = test_platform.decode('utf-8')
status = p.wait()
self.assertEqual(status, 0)
self.assertEqual(my_platform, test_platform)
def test_srcdir(self):
# See Issues #15322, #15364.
srcdir = sysconfig.get_config_var('srcdir')
self.assertTrue(os.path.isabs(srcdir), srcdir)
self.assertTrue(os.path.isdir(srcdir), srcdir)
if sysconfig._PYTHON_BUILD:
# The python executable has not been installed so srcdir
# should be a full source checkout.
Python_h = os.path.join(srcdir, 'Include', 'Python.h')
self.assertTrue(os.path.exists(Python_h), Python_h)
self.assertTrue(sysconfig._is_python_source_dir(srcdir))
elif os.name == 'posix':
makefile_dir = os.path.dirname(sysconfig.get_makefile_filename())
# Issue #19340: srcdir has been realpath'ed already
makefile_dir = os.path.realpath(makefile_dir)
self.assertEqual(makefile_dir, srcdir)
def test_srcdir_independent_of_cwd(self):
# srcdir should be independent of the current working directory
# See Issues #15322, #15364.
srcdir = sysconfig.get_config_var('srcdir')
with change_cwd(os.pardir):
srcdir2 = sysconfig.get_config_var('srcdir')
self.assertEqual(srcdir, srcdir2)
@unittest.skipIf(
sysconfig.get_config_var('EXT_SUFFIX') is None,
'EXT_SUFFIX required for this test')
def test_SO_deprecation(self):
self.assertWarns(DeprecationWarning, sysconfig.get_config_var, 'SO')
@unittest.skipIf(
sysconfig.get_config_var('EXT_SUFFIX') is None,
'EXT_SUFFIX required for this test')
def test_SO_value(self):
with check_warnings(('', DeprecationWarning)):
self.assertEqual(sysconfig.get_config_var('SO'),
sysconfig.get_config_var('EXT_SUFFIX'))
@unittest.skipIf(
sysconfig.get_config_var('EXT_SUFFIX') is None,
'EXT_SUFFIX required for this test')
def test_EXT_SUFFIX_in_vars(self):
import _imp
vars = sysconfig.get_config_vars()
self.assertIsNotNone(vars['SO'])
self.assertEqual(vars['SO'], vars['EXT_SUFFIX'])
self.assertEqual(vars['EXT_SUFFIX'], _imp.extension_suffixes()[0])
@unittest.skipUnless(sys.platform == 'linux'
and hasattr(sys.implementation, '_multiarch'),
'multiarch-specific test')
def test_triplet_in_ext_suffix(self):
ctypes = import_module('ctypes')
import platform, re
machine = platform.machine()
suffix = sysconfig.get_config_var('EXT_SUFFIX')
if re.match('(aarch64|arm|mips|ppc|powerpc|s390|sparc)', machine):
self.assertTrue('linux' in suffix, suffix)
if re.match('(i[3-6]86|x86_64)$', machine):
if ctypes.sizeof(ctypes.c_char_p()) == 4:
self.assertTrue(
suffix.endswith('i386-linux-gnu.so')
or suffix.endswith('x86_64-linux-gnux32.so'), suffix)
else: # 8 byte pointer size
self.assertTrue(suffix.endswith('x86_64-linux-gnu.so'), suffix)
@unittest.skipUnless(sys.platform == 'darwin', 'OS X-specific test')
def test_osx_ext_suffix(self):
suffix = sysconfig.get_config_var('EXT_SUFFIX')
self.assertTrue(suffix.endswith('-darwin.so'), suffix)
def _build_dependency(name, patches=[]):
import shutil
from rpython.tool.runsubprocess import run_subprocess
try:
from urllib.request import urlretrieve
except ImportError:
from urllib import urlretrieve
try:
url, dgst, build_cmds = cffi_dependencies[name]
except KeyError:
return 0, None, None
archive_dir = os.path.join(tempfile.gettempdir(), 'pypy-archives')
if not os.path.isdir(archive_dir):
os.makedirs(archive_dir)
archive = os.path.join(archive_dir, url.rsplit('/', 1)[-1])
# next, fetch the archive to disk, if needed
if not os.path.exists(archive) or _sha256(archive) != dgst:
print('fetching archive', url, file=sys.stderr)
urlretrieve(url, archive)
# make sure the hash matches
if _sha256(archive) != dgst:
return 1, '{} archive {} hash mismatch'.format(name, archive), ''
shutil.rmtree(deps_destdir, ignore_errors=True)
os.makedirs(deps_destdir)
# extract the into our destination directory
print('unpacking archive', archive, file=sys.stderr)
_unpack_tarfile(archive, deps_destdir)
sources = os.path.join(
deps_destdir,
os.path.basename(archive).rsplit('.', 2)[0],
)
# apply any patches
if patches:
for patch in patches:
print('applying patch', patch, file=sys.stderr)
status, stdout, stderr = run_subprocess(
'/usr/bin/patch',
['-p1', '-i', patch],
cwd=sources,
)
if status != 0:
return status, stdout, stderr
env = os.environ
if sys.platform == 'darwin':
target = sysconfig.get_config_var('MACOSX_DEPLOYMENT_TARGET')
if target:
# override the value for building support libraries
env = os.environ.copy()
env['MACOSX_DEPLOYMENT_TARGET'] = target
print('setting MACOSX_DEPLOYMENT_TARGET to "{}"'.format(target))
for args in build_cmds:
print('running', ' '.join(args), 'in', sources, file=sys.stderr)
status, stdout, stderr = run_subprocess(args[0],
args[1:],
cwd=sources,
env=env)
if status != 0:
break
return status, stdout, stderr
def test_sysconfig_module(self):
import sysconfig as global_sysconfig
self.assertEqual(global_sysconfig.get_config_var('CFLAGS'),
sysconfig.get_config_var('CFLAGS'))
self.assertEqual(global_sysconfig.get_config_var('LDFLAGS'),
sysconfig.get_config_var('LDFLAGS'))
# Debug hooks must raise an error if PyMem_Malloc() is called
# without holding the GIL
code = 'import _testcapi; _testcapi.pymem_malloc_without_gil()'
self.check_malloc_without_gil(code)
def test_pyobject_malloc_without_gil(self):
# Debug hooks must raise an error if PyObject_Malloc() is called
# without holding the GIL
code = 'import _testcapi; _testcapi.pyobject_malloc_without_gil()'
self.check_malloc_without_gil(code)
class PyMemMallocDebugTests(PyMemDebugTests):
PYTHONMALLOC = 'malloc_debug'
@unittest.skipUnless(
sysconfig.get_config_var('WITH_PYMALLOC') == 1, 'need pymalloc')
class PyMemPymallocDebugTests(PyMemDebugTests):
PYTHONMALLOC = 'pymalloc_debug'
@unittest.skipUnless(Py_DEBUG, 'need Py_DEBUG')
class PyMemDefaultTests(PyMemDebugTests):
# test default allocator of Python compiled in debug mode
PYTHONMALLOC = ''
if __name__ == "__main__":
unittest.main()
def main():
os.chdir(os.path.dirname(os.path.abspath(__file__)))
# These are neede for source fetching
cmake_source_dir = "opencv"
build_contrib = get_build_env_var_by_name("contrib")
# headless flag to skip GUI deps if needed
build_headless = get_build_env_var_by_name("headless")
# Only import 3rd-party modules after having installed all the build dependencies:
# any of them, or their dependencies, can be updated during that process,
# leading to version conflicts
minimum_supported_numpy = "1.11.1"
if sys.version_info[:2] >= (3, 6):
minimum_supported_numpy = "1.11.3"
if sys.version_info[:2] >= (3, 7):
minimum_supported_numpy = "1.14.5"
numpy_version = get_or_install("numpy", minimum_supported_numpy)
get_or_install("scikit-build")
import skbuild
if os.path.exists('.git'):
import pip._internal.vcs.git as git
g = git.Git(
) # NOTE: pip API's are internal, this has to be refactored
g.run_command(["submodule", "sync"])
g.run_command(
["submodule", "update", "--init", "--recursive", cmake_source_dir])
# if build_contrib:
g.run_command(
["submodule", "update", "--init", "--recursive", "opencv_contrib"])
# https://stackoverflow.com/questions/1405913/python-32bit-or-64bit-mode
x64 = sys.maxsize > 2**32
package_name = "opencv-contrib-python"
print("installing " + package_name)
# if build_contrib and not build_headless:
# package_name = "opencv-contrib-python"
# if build_contrib and build_headless:
# package_name = "opencv-contrib-python-headless"
# if build_headless and not build_contrib:
# package_name = "opencv-python-headless"
long_description = io.open('README.md', encoding="utf-8").read()
package_version = get_opencv_version()
packages = ['cv2', 'cv2.data']
package_data = {
'cv2': ['*%s' % sysconfig.get_config_var('SO')] +
(['*.dll'] if os.name == 'nt' else []) +
["LICENSE.txt", "LICENSE-3RD-PARTY.txt"],
'cv2.data': ["*.xml"]
}
# Files from CMake output to copy to package.
# Path regexes with forward slashes relative to CMake install dir.
rearrange_cmake_output_data = {
'cv2': ([r'bin/opencv_ffmpeg\d{3}%s\.dll' %
('_64' if x64 else '')] if os.name == 'nt' else []) +
# In Windows, in python/X.Y/<arch>/; in Linux, in just python/X.Y/.
# Naming conventions vary so widely between versions and OSes
# had to give up on checking them.
[
'python/cv2[^/]*%(ext)s' % {
'ext': re.escape(sysconfig.get_config_var('SO'))
}
],
'cv2.data': [ # OPENCV_OTHER_INSTALL_PATH
('etc' if os.name == 'nt' else 'share/opencv4') +
r'/haarcascades/.*\.xml'
]
}
# Files in sourcetree outside package dir that should be copied to package.
# Raw paths relative to sourcetree root.
files_outside_package_dir = {
'cv2': ['LICENSE.txt', 'LICENSE-3RD-PARTY.txt']
}
cmake_args = ([
"-G", "Visual Studio 14" + (" Win64" if x64 else '')
] if os.name == 'nt' else [
"-G",
"Unix Makefiles" # don't make CMake try (and fail) Ninja first
]) + [
# skbuild inserts PYTHON_* vars. That doesn't satisfy opencv build scripts in case of Py3
"-DPYTHON%d_EXECUTABLE=%s" % (sys.version_info[0], sys.executable),
"-DBUILD_opencv_python%d=ON" % sys.version_info[0],
"-DOPENCV_SKIP_PYTHON_LOADER=ON",
"-DOPENCV_PYTHON2_INSTALL_PATH=python",
"-DOPENCV_PYTHON3_INSTALL_PATH=python",
# Otherwise, opencv scripts would want to install `.pyd' right into site-packages,
# and skbuild bails out on seeing that
"-DINSTALL_CREATE_DISTRIB=ON",
# See opencv/CMakeLists.txt for options and defaults
"-DBUILD_opencv_apps=OFF",
"-DBUILD_SHARED_LIBS=OFF",
"-DBUILD_TESTS=OFF",
"-DBUILD_PERF_TESTS=OFF",
"-DBUILD_DOCS=OFF",
"-DOPENCV_EXTRA_MODULES_PATH=" +
os.path.abspath("opencv_contrib/modules")
]
# OS-specific components
if (sys.platform == 'darwin'
or sys.platform.startswith('linux')) and not build_headless:
cmake_args.append("-DWITH_QT=4")
if build_headless:
# it seems that cocoa cannot be disabled so on macOS the package is not truly headless
cmake_args.append("-DWITH_WIN32UI=OFF")
cmake_args.append("-DWITH_QT=OFF")
if sys.platform.startswith('linux'):
cmake_args.append("-DWITH_V4L=ON")
cmake_args.append("-DENABLE_PRECOMPILED_HEADERS=OFF")
if all(v in os.environ for v in ('JPEG_INCLUDE_DIR', 'JPEG_LIBRARY')):
cmake_args += [
"-DBUILD_JPEG=OFF",
"-DJPEG_INCLUDE_DIR=%s" % os.environ['JPEG_INCLUDE_DIR'],
"-DJPEG_LIBRARY=%s" % os.environ['JPEG_LIBRARY']
]
# Fixes for macOS builds
if sys.platform == 'darwin':
cmake_args.append(
"-DWITH_LAPACK=OFF") # Some OSX LAPACK fns are incompatible, see
# https://github.com/skvark/opencv-python/issues/21
cmake_args.append("-DCMAKE_CXX_FLAGS=-stdlib=libc++")
if sys.platform.startswith('linux'):
cmake_args.append(
"-DWITH_IPP=OFF") # tests fail with IPP compiled with
# devtoolset-2 GCC 4.8.2 or vanilla GCC 4.9.4
# see https://github.com/skvark/opencv-python/issues/138
if sys.platform.startswith('linux') and not x64:
cmake_args.append("-DCMAKE_CXX_FLAGS=-U__STRICT_ANSI__")
# ABI config variables are introduced in PEP 425
if sys.version_info[:2] < (3, 2):
import warnings
warnings.filterwarnings('ignore', r"Config variable '[^']+' is unset, "
r"Python ABI tag may be incorrect",
category=RuntimeWarning)
del warnings
# works via side effect
RearrangeCMakeOutput(rearrange_cmake_output_data,
files_outside_package_dir, package_data.keys())
skbuild.setup(
name=package_name,
version=package_version,
url='https://github.com/skvark/opencv-python',
license='MIT',
description='Wrapper package for OpenCV python bindings.',
long_description=long_description,
long_description_content_type="text/markdown",
packages=packages,
package_data=package_data,
maintainer="Olli-Pekka Heinisuo",
include_package_data=True,
ext_modules=EmptyListWithLength(),
install_requires="numpy>=%s" % numpy_version,
classifiers=[
'Development Status :: 5 - Production/Stable',
'Environment :: Console',
'Intended Audience :: Developers',
'Intended Audience :: Education',
'Intended Audience :: Information Technology',
'Intended Audience :: Science/Research',
'License :: OSI Approved :: MIT License',
'Operating System :: MacOS',
'Operating System :: Microsoft :: Windows',
'Operating System :: POSIX',
'Operating System :: Unix',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: C++',
'Programming Language :: Python :: Implementation :: CPython',
'Topic :: Scientific/Engineering',
'Topic :: Scientific/Engineering :: Image Recognition',
'Topic :: Software Development',
],
cmake_args=cmake_args,
cmake_source_dir=cmake_source_dir,
)
import json
import platform
import sys
import sysconfig
metadata = {
"major": sys.version_info.major,
"minor": sys.version_info.minor,
"abiflags": sysconfig.get_config_var("ABIFLAGS"),
"interpreter": platform.python_implementation().lower(),
"ext_suffix": sysconfig.get_config_var("EXT_SUFFIX"),
"abi_tag": (sysconfig.get_config_var("SOABI") or "-").split("-")[1]
or None,
"m": sysconfig.get_config_var("WITH_PYMALLOC") == 1,
"u": sysconfig.get_config_var("Py_UNICODE_SIZE") == 4,
"d": sysconfig.get_config_var("Py_DEBUG") == 1,
# This one isn't technically necessary, but still very useful for sanity checks
"platform": sys.platform,
}
print(json.dumps(metadata))
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# Utility script to genertae the python tag + the abi tag + platform tag for a Python
import distutils.util
import sys
import sysconfig
# TODO: pigweed virtualenv don't have pep425tags, will revisit it after figuring out with pigwee
# The below is temporary solution.
#from wheel.pep425tags import get_abbr_impl, get_impl_ver, get_abi_tag, get_platform
#print(get_abbr_impl() + get_impl_ver() + "-" + get_abi_tag() + "-" + get_platform())
abbr_ver = "cp"
impl_ver = str(sys.version_info[0]) + str(sys.version_info[1])
if sysconfig.get_config_var('SOABI') is None:
abi_tag = abbr_ver + impl_ver
else:
abi_tag = 'cp' + sysconfig.get_config_var('SOABI').split('-')[1]
platform_tag = distutils.util.get_platform().replace('.', '_').replace('-', '_')
print(abbr_ver + impl_ver + "-" + abi_tag + "-" + platform_tag)
def get_python_include_dir(python_version):
"""Get include directory associated with the current python
interpreter."""
# determine python include dir
python_include_dir = sysconfig.get_config_var('INCLUDEPY')
# if Python.h not found (or python_include_dir is None), try to find a
# suitable include dir
found_python_h = (python_include_dir is not None or os.path.exists(
os.path.join(python_include_dir, 'Python.h')))
if not found_python_h:
# NOTE(opadron): these possible prefixes must be guarded against
# AttributeErrors and KeyErrors because they each can throw on
# different platforms or even different builds on the same platform.
include_py = sysconfig.get_config_var('INCLUDEPY')
include_dir = sysconfig.get_config_var('INCLUDEDIR')
include = None
plat_include = None
python_inc = None
python_inc2 = None
try:
include = sysconfig.get_path('include')
except (AttributeError, KeyError):
pass
try:
plat_include = sysconfig.get_path('platinclude')
except (AttributeError, KeyError):
pass
try:
python_inc = sysconfig.get_python_inc()
except AttributeError:
pass
if include_py is not None:
include_py = os.path.dirname(include_py)
if include is not None:
include = os.path.dirname(include)
if plat_include is not None:
plat_include = os.path.dirname(plat_include)
if python_inc is not None:
python_inc2 = os.path.join(
python_inc, ".".join(map(str, sys.version_info[:2])))
candidate_prefixes = list(
filter(bool, (
include_py,
include_dir,
include,
plat_include,
python_inc,
python_inc2,
)))
candidate_versions = (python_version, )
if python_version:
candidate_versions += ('', )
candidates = (os.path.join(prefix, ''.join(('python', ver)))
for (prefix, ver) in itertools.product(
candidate_prefixes, candidate_versions))
for candidate in candidates:
if os.path.exists(os.path.join(candidate, 'Python.h')):
# we found an include directory
python_include_dir = candidate
break
# TODO(opadron): what happens if we don't find an include directory?
# Throw SKBuildError?
return python_include_dir
def test_ldshared_value(self):
ldflags = sysconfig.get_config_var('LDFLAGS')
ldshared = sysconfig.get_config_var('LDSHARED')
self.assertIn(ldflags, ldshared)
#!/usr/bin/env python3
import re
import sys
import shutil
import os.path
import subprocess
import sysconfig
import reindent
import untabify
SRCDIR = sysconfig.get_config_var('srcdir')
def n_files_str(count):
"""Return 'N file(s)' with the proper plurality on 'file'."""
return "{} file{}".format(count, "s" if count != 1 else "")
def status(message, modal=False, info=None):
"""Decorator to output status info to stdout."""
def decorated_fxn(fxn):
def call_fxn(*args, **kwargs):
sys.stdout.write(message + ' ... ')
sys.stdout.flush()
result = fxn(*args, **kwargs)
if not modal and not info:
print("done")
elif info:
print(info(result))
else:
def get_config_var(var):
try:
return sysconfig.get_config_var(var)
except IOError as e: # Issue #1074
warnings.warn("{0}".format(e), RuntimeWarning)
return None
except ImportError: # python < 3.4
try:
from imp import cache_from_source
except ImportError: # python < 3.2
def cache_from_source(path):
root, ext = os.path.splitext(path)
return root + '.pyc'
try:
import sysconfig
except ImportError: # pragma: NO COVER
# python < 2.7
# FIXME: incorrect on non-posix systems
EXT_SUFFIX = '.so'
else:
EXT_SUFFIX = (sysconfig.get_config_var('EXT_SUFFIX')
or sysconfig.get_config_var('SO'))
class file_cm(object):
""" Add context manager methods to dumb file-like instances.
"""
def __init__(self, fp):
self._fp = fp
def __enter__(self):
return self._fp
def __exit__(self, typ, inst, tb):
self._fp.close()
git_ver = get_version()
git_num = int(git_ver.split('.')[3].split('+')[0].replace("dev", ""))
except:
git_num = None
include_dirs_numpy = [numpy.get_include()]
cc = None
if 'CC' in os.environ:
if 'clang' in os.environ['CC']:
cc = 'clang'
if 'gcc' in os.environ['CC']:
cc = 'gcc'
# Workaround Python issue 21121
import sysconfig
config_var = sysconfig.get_config_var("CFLAGS")
if config_var is not None and "-Werror=declaration-after-statement" in config_var:
os.environ['CFLAGS'] = config_var.replace(
"-Werror=declaration-after-statement", "")
######################
# _phonopy extension #
######################
include_dirs_phonopy = ['c/harmonic_h', 'c/kspclib_h'] + include_dirs_numpy
sources_phonopy = [
'c/_phonopy.c', 'c/harmonic/dynmat.c', 'c/harmonic/derivative_dynmat.c',
'c/kspclib/kgrid.c', 'c/kspclib/tetrahedron_method.c'
]
if with_openmp:
extra_compile_args_phonopy = [
print("Usage: {0} [{1}]".format(sys.argv[0],
'|'.join('--' + opt
for opt in valid_opts)),
file=sys.stderr)
sys.exit(code)
try:
opts, args = getopt.getopt(sys.argv[1:], '', valid_opts)
except getopt.error:
exit_with_usage()
if not opts:
exit_with_usage()
pyver = sysconfig.get_config_var('VERSION')
getvar = sysconfig.get_config_var
opt_flags = [flag for (flag, val) in opts]
if '--help' in opt_flags:
exit_with_usage(code=0)
for opt in opt_flags:
if opt == '--prefix':
print(sysconfig.get_config_var('prefix'))
elif opt == '--exec-prefix':
print(sysconfig.get_config_var('exec_prefix'))
elif opt in ('--includes', '--cflags'):
def test_attributes(self):
self.assertIsInstance(sys.api_version, int)
self.assertIsInstance(sys.argv, list)
self.assertIn(sys.byteorder, ("little", "big"))
self.assertIsInstance(sys.builtin_module_names, tuple)
self.assertIsInstance(sys.copyright, str)
self.assertIsInstance(sys.exec_prefix, str)
self.assertIsInstance(sys.base_exec_prefix, str)
self.assertIsInstance(sys.executable, str)
self.assertEqual(len(sys.float_info), 11)
self.assertEqual(sys.float_info.radix, 2)
self.assertEqual(len(sys.int_info), 2)
if test.support.check_impl_detail(cpython=True):
self.assertTrue(sys.int_info.bits_per_digit % 5 == 0)
else:
self.assertTrue(sys.int_info.bits_per_digit >= 1)
self.assertTrue(sys.int_info.sizeof_digit >= 1)
self.assertEqual(type(sys.int_info.bits_per_digit), int)
self.assertEqual(type(sys.int_info.sizeof_digit), int)
self.assertIsInstance(sys.hexversion, int)
if test.support.check_impl_detail(cpython=True):
self.assertEqual(len(sys.hash_info), 9)
self.assertLess(sys.hash_info.modulus, 2**sys.hash_info.width)
# sys.hash_info.modulus should be a prime; we do a quick
# probable primality test (doesn't exclude the possibility of
# a Carmichael number)
for x in range(1, 100):
self.assertEqual(
pow(x, sys.hash_info.modulus - 1, sys.hash_info.modulus), 1,
"sys.hash_info.modulus {} is a non-prime".format(
sys.hash_info.modulus))
self.assertIsInstance(sys.hash_info.inf, int)
self.assertIsInstance(sys.hash_info.nan, int)
self.assertIsInstance(sys.hash_info.imag, int)
if test.support.check_impl_detail(cpython=True):
algo = sysconfig.get_config_var("Py_HASH_ALGORITHM")
if sys.hash_info.algorithm in {"fnv", "siphash24"}:
self.assertIn(sys.hash_info.hash_bits, {32, 64})
self.assertIn(sys.hash_info.seed_bits, {32, 64, 128})
if algo == 1:
self.assertEqual(sys.hash_info.algorithm, "siphash24")
elif algo == 2:
self.assertEqual(sys.hash_info.algorithm, "fnv")
else:
self.assertIn(sys.hash_info.algorithm,
{"fnv", "siphash24"})
else:
# PY_HASH_EXTERNAL
self.assertEqual(algo, 0)
self.assertGreaterEqual(sys.hash_info.cutoff, 0)
self.assertLess(sys.hash_info.cutoff, 8)
self.assertIsInstance(sys.maxsize, int)
self.assertIsInstance(sys.maxunicode, int)
self.assertEqual(sys.maxunicode, 0x10FFFF)
self.assertIsInstance(sys.platform, str)
self.assertIsInstance(sys.prefix, str)
self.assertIsInstance(sys.base_prefix, str)
self.assertIsInstance(sys.version, str)
vi = sys.version_info
self.assertIsInstance(vi[:], tuple)
self.assertEqual(len(vi), 5)
self.assertIsInstance(vi[0], int)
self.assertIsInstance(vi[1], int)
self.assertIsInstance(vi[2], int)
self.assertIn(vi[3], ("alpha", "beta", "candidate", "final"))
self.assertIsInstance(vi[4], int)
self.assertIsInstance(vi.major, int)
self.assertIsInstance(vi.minor, int)
self.assertIsInstance(vi.micro, int)
self.assertIn(vi.releaselevel, ("alpha", "beta", "candidate", "final"))
self.assertIsInstance(vi.serial, int)
self.assertEqual(vi[0], vi.major)
self.assertEqual(vi[1], vi.minor)
self.assertEqual(vi[2], vi.micro)
self.assertEqual(vi[3], vi.releaselevel)
self.assertEqual(vi[4], vi.serial)
self.assertTrue(vi > (1, 0, 0))
self.assertIsInstance(sys.float_repr_style, str)
self.assertIn(sys.float_repr_style, ('short', 'legacy'))
if not sys.platform.startswith('win'):
self.assertIsInstance(sys.abiflags, str)
import sys
import sysconfig
import warnings
import numpy as nu
import ctypes
import ctypes.util
from numpy.ctypeslib import ndpointer
import os
from galpy import potential, potential_src
from galpy.util import galpyWarning
#Find and load the library
_lib = None
outerr = None
PY3 = sys.version > '3'
if PY3: #pragma: no cover
_ext_suffix = sysconfig.get_config_var('EXT_SUFFIX')
else:
_ext_suffix = '.so'
for path in sys.path:
try:
_lib = ctypes.CDLL(
os.path.join(path, 'galpy_integrate_c%s' % _ext_suffix))
except OSError as e:
if os.path.exists(
os.path.join(path, 'galpy_integrate_c%s' %
_ext_suffix)): #pragma: no cover
outerr = e
_lib = None
else:
break
if _lib is None: #pragma: no cover
def init_env(debug=False,
sanitize=False,
native_optimizations=True,
profile=False):
global cflags, ldflags, cc, ldpaths
native_optimizations = native_optimizations and not sanitize and not debug
cc, ccver = cc_version()
print('CC:', cc, ccver)
stack_protector = '-fstack-protector'
if ccver >= (4, 9) and cc == 'gcc':
stack_protector += '-strong'
missing_braces = ''
if ccver < (5, 2) and cc == 'gcc':
missing_braces = '-Wno-missing-braces'
optimize = '-g3' if debug or sanitize else '-O3'
sanitize_args = get_sanitize_args(cc, ccver) if sanitize else set()
cflags = os.environ.get('OVERRIDE_CFLAGS', (
'-Wextra -Wno-missing-field-initializers -Wall -std=c99 -D_XOPEN_SOURCE=700'
' -pedantic-errors -Werror {} {} -D{}DEBUG -fwrapv {} {} -pipe {} -fvisibility=hidden'
).format(
optimize,
' '.join(sanitize_args),
('' if debug else 'N'),
stack_protector,
missing_braces,
'-march=native' if native_optimizations else '',
))
cflags = shlex.split(cflags) + shlex.split(
sysconfig.get_config_var('CCSHARED'))
ldflags = os.environ.get(
'OVERRIDE_LDFLAGS',
'-Wall ' + ' '.join(sanitize_args) + ('' if debug else ' -O3'))
ldflags = shlex.split(ldflags)
cflags += shlex.split(os.environ.get('CFLAGS', ''))
ldflags += shlex.split(os.environ.get('LDFLAGS', ''))
if not debug and not sanitize:
# See https://github.com/google/sanitizers/issues/647
cflags.append('-flto'), ldflags.append('-flto')
if profile:
cflags.append('-DWITH_PROFILER')
cflags.append('-g3')
ldflags.append('-lprofiler')
cflags.append('-pthread')
# We add 4000 to the primary version because vim turns on SGR mouse mode
# automatically if this version is high enough
cflags.append('-DPRIMARY_VERSION={}'.format(version[0] + 4000))
cflags.append('-DSECONDARY_VERSION={}'.format(version[1]))
if not is_travis and not isosx:
at_least_version('glew', 2)
cflags.extend(pkg_config('libpng', '--cflags-only-I'))
if not isosx:
cflags.extend(pkg_config('glew', '--cflags-only-I'))
if isosx:
font_libs = ['-framework', 'CoreText', '-framework', 'CoreGraphics']
else:
cflags.extend(pkg_config('fontconfig', '--cflags-only-I'))
font_libs = pkg_config('fontconfig', '--libs')
cflags.extend(pkg_config('harfbuzz', '--cflags-only-I'))
font_libs.extend(pkg_config('harfbuzz', '--libs'))
cflags.extend(pkg_config('glfw3', '--cflags-only-I'))
ldflags.append('-shared')
pylib = get_python_flags(cflags)
if isosx:
glfw_ldflags = pkg_config('--libs', '--static',
'glfw3') + ['-framework', 'OpenGL']
glew_libs = []
else:
glfw_ldflags = pkg_config('glfw3', '--libs')
glew_libs = pkg_config('glew', '--libs')
libpng = pkg_config('libpng', '--libs')
ldpaths = pylib + glew_libs + font_libs + glfw_ldflags + libpng + [
'-lunistring'
]
if not isosx:
ldpaths += ['-lrt']
if '-lz' not in ldpaths:
ldpaths.append('-lz')
try:
os.mkdir(build_dir)
except FileExistsError:
pass
def _generic_abi():
# type: () -> Iterator[str]
abi = sysconfig.get_config_var("SOABI")
if abi:
yield _normalize_string(abi)
if sys.version_info[0] == 2:
# python 2 seems to have hoc.__file__ already filled in so never get here.
try:
import imp
mspec = imp.find_module("neuron")
origin = mspec[1]
except:
pass
else:
from importlib import util
mspec = util.find_spec("neuron")
if mspec:
origin = mspec.origin
if origin is not None:
import sysconfig
hoc_path = origin.rstrip("__init__.py") + "hoc" + sysconfig.get_config_var('SO')
setattr(hoc, "__file__", hoc_path)
else:
# if the above is robust, maybe all this can be removed.
# next try is to derive from nrnversion(6) (only works for autotools build)
import platform
import os
p = h.nrnversion(6)
if "--prefix=" in p:
p = p[p.find('--prefix=') + 9:]
p = p[:p.find("'")]
else:
p = "/usr/local/nrn"
if sys.version_info >= (3, 0):
import sysconfig
hoc_path = p + "/lib/python/neuron/hoc%s" % sysconfig.get_config_var('SO')
def test_osx_ext_suffix(self):
suffix = sysconfig.get_config_var('EXT_SUFFIX')
self.assertTrue(suffix.endswith('-darwin.so'), suffix)
"""Provide access to Python's configuration information. The specific
configuration variables available depend heavily on the platform and
configuration. The values may be retrieved using
get_config_var(name), and the list of variables is available via
get_config_vars().keys(). Additional convenience functions are also
available.
Written by: Fred L. Drake, Jr.
Email: <*****@*****.**>
"""
import _imp
import os
import re
import sys
import warnings
from functools import partial
from .errors import DistutilsPlatformError
from sysconfig import (
_PREFIX as PREFIX,
_BASE_PREFIX as BASE_PREFIX,
_EXEC_PREFIX as EXEC_PREFIX,
_BASE_EXEC_PREFIX as BASE_EXEC_PREFIX,
_PROJECT_BASE as project_base,
_PYTHON_BUILD as python_build,
_init_posix as sysconfig_init_posix,
parse_config_h as sysconfig_parse_config_h,
def test_SO_value(self):
with check_warnings(('', DeprecationWarning)):
self.assertEqual(sysconfig.get_config_var('SO'),
sysconfig.get_config_var('EXT_SUFFIX'))
import enum
import locale
import math
import platform
import sys
import sysconfig
import time
import threading
import unittest
try:
import _testcapi
except ImportError:
_testcapi = None
# Max year is only limited by the size of C int.
SIZEOF_INT = sysconfig.get_config_var('SIZEOF_INT') or 4
TIME_MAXYEAR = (1 << 8 * SIZEOF_INT - 1) - 1
TIME_MINYEAR = -TIME_MAXYEAR - 1 + 1900
SEC_TO_US = 10**6
US_TO_NS = 10**3
MS_TO_NS = 10**6
SEC_TO_NS = 10**9
NS_TO_SEC = 10**9
class _PyTime(enum.IntEnum):
# Round towards minus infinity (-inf)
ROUND_FLOOR = 0
# Round towards infinity (+inf)
ROUND_CEILING = 1
def test_generic_interpreter():
version = sysconfig.get_config_var("py_version_nodot")
if not version:
version = "".join(sys.version_info[:2])
result = tags._generic_interpreter("sillywalk", sys.version_info[:2])
assert result == "sillywalk{version}".format(version=version)
"language_level":3}
cmodules = {
"btom.cmain.py_base_atom":["btom/cmain/py_base_atom.pyx",\
"btom/cmain/c_base_atom.cpp"]
}
cextensions = cythonize([Extension(k,v,language="c++",\
include_dirs=["btom/cmain",numpy.get_include()],\
extra_compile_args=["-std=c++11","-DPARALLEL"])\
for k,v in cmodules.items()])
import os
os.environ["CFLAGS"] = " ".join([
u for u in sysconfig.get_config_var("CFLAGS").split(" ")
if "xHost" not in u
])
os.environ["CC"] = mpi4py.get_config()["mpicc"]
setup(name="btom",
namespace_packages=["btom"],
version='0.1',
url='http://notset/jet',
author="Lukas Linhart",
author_email="*****@*****.**",
license='None',
ext_modules =cythonize(extensions)+cextensions, #+int_modules+cextensions,\
packages=find_packages(),\
zip_safe=False,\
include_package_data=True)
def pythonlib_dir():
"""return path where libpython* is."""
if sys.platform == 'win32':
return os.path.join(sys.prefix, "libs")
else:
return get_config_var('LIBDIR')
