def show_sys_vars():
print('os.name = %s, sys.platform = %s' % (os.name, sys.platform))
from distutils import util, ccompiler
print('platform = %s' % util.get_platform())
print('compiler = %s' % ccompiler.get_default_compiler())
from SCons.Environment import Environment
env = Environment()
vars = [
'CC',
'CXX',
'PLATFORM',
'MSVC_VERSION',
'TARGET',
'TARGET_ARCH',
'TARGET_OS',
'MSVS',
'MSVS_VERSION',
'MSVS_ARCH',
'TOOLS',
'HOST_ARCH',
'HOST_OS',
'MSVC_BATCH',
'MSVC_USE_SCRIPT',
]
for var in vars:
print('%s = %r' % (var, env.subst('$' + var)))
def findcc(pathstring):
list = []
from distutils import ccompiler
yourcompiler = ccompiler.get_default_compiler()
if sys.platform == 'sunos5"' or 'irix6':
for a in pathstring:
if os.path.exists('%s/cc' %a) or os.path.exists('%s/CC' %a):
list.append('%s' %a)
if list == []:
print "YOU DO NOT HAVE A C-COMPILER"
sys.exit()
if (sys.platform == 'cygwin') or (os.name == 'nt'):
for a in pathstring:
if os.path.exists('%s/cc' %a):
list.append('%s' %a)
if list == []:
print "YOU DO NOT HAVE A C-COMPILER"
sys.exit()
if (sys.platform == 'linux2') or (sys.platform == 'darwin'):
for a in pathstring:
if os.path.exists('%s/gcc' %a) or os.path.exists('%s/g++' %a):
list.append('%s' %a)
if list == []:
print "YOU DO NOT HAVE A C-COMPILER"
sys.exit()
def finalize_options(self):
build_ext.finalize_options(self)
if self.compiler is None:
compiler = get_default_compiler()
else:
compiler = self.compiler
if compiler == "msvc":
# Add msvc specific hacks
if (sys.version_info.major, sys.version_info.minor) < (3, 3):
# The check above is a nasty hack. We're using the python
# version as a proxy for the MSVC version. 2008 doesn't
# have stdint.h, so is needed. 2010 does.
#
# We need to add the path to msvc includes
include_dirs.append(os.path.join(os.getcwd(), "include", "msvc_2008"))
# We need to prepend lib to all the library names
_libraries = []
for each_lib in self.libraries:
_libraries.append("lib" + each_lib)
self.libraries = _libraries
def getRevison():
compiler = get_default_compiler()
if compiler == 'unix':
res = os.popen('svn info |grep Revision: |cut -c11-')
return res.read().strip()
elif compiler == 'msvc':
return os.popen("run.bat").readlines()[-1].strip()
def getCompilerInfo(cxxCompiler):
"""
Identify compiler
"""
if cxxCompiler is None:
cxxCompiler = ccompiler.get_default_compiler()
if "clang" in cxxCompiler:
cxxCompiler = "Clang"
elif "gnu" in cxxCompiler:
cxxCompiler = "GNU"
# TODO: There is a problem here, because on OS X ccompiler.get_default_compiler()
# returns "unix", not "clang" or "gnu". So we have to handle "unix" and we lose
# the ability to decide which compiler is used.
elif "unix" in cxxCompiler:
cxxCompiler = "unix"
elif "msvc" in cxxCompiler:
cxxCompiler = "MSVC"
elif "mingw" in cxxCompiler:
cxxCompiler = "MinGW"
else:
raise Exception("C++ compiler '%s' is unsupported!" % cxxCompiler)
print "CXX Compiler: {}".format(cxxCompiler)
return cxxCompiler
def compiler_type(self):
compiler = self.compiler
if compiler is None:
return get_default_compiler()
elif isinstance(compiler, str):
return compiler
else:
return compiler.compiler_type
def finalize_options(self):
build_ext.finalize_options(self)
if self.compiler is None:
compiler = get_default_compiler()
else:
compiler = self.compiler
def detect_version(basedir, compiler=None, **compiler_attrs):
"""Compile, link & execute a test program, in empty directory `basedir`.
The C compiler will be updated with any keywords given via setattr.
Parameters
----------
basedir : path
The location where the test program will be compiled and run
compiler : str
The distutils compiler key (e.g. 'unix', 'msvc', or 'mingw32')
**compiler_attrs : dict
Any extra compiler attributes, which will be set via ``setattr(cc)``.
Returns
-------
A dict of properties for zmq compilation, with the following two keys:
vers : tuple
The ZMQ version as a tuple of ints, e.g. (2,2,0)
settings : dict
The compiler options used to compile the test function, e.g. `include_dirs`,
`library_dirs`, `libs`, etc.
"""
if compiler is None:
compiler = get_default_compiler()
cfile = pjoin(basedir, 'vers.cpp')
shutil.copy(pjoin(os.path.dirname(__file__), 'vers.cpp'), cfile)
# check if we need to link against Realtime Extensions library
if sys.platform.startswith('linux'):
cc = ccompiler.new_compiler(compiler=compiler)
cc.output_dir = basedir
if not cc.has_function('timer_create'):
if 'libraries' not in compiler_attrs:
compiler_attrs['libraries'] = []
compiler_attrs['libraries'].append('rt')
cc = get_compiler(compiler=compiler, **compiler_attrs)
efile = test_compilation(cfile, compiler=cc)
patch_lib_paths(efile, cc.library_dirs)
rc, so, se = get_output_error([efile])
if rc:
msg = "Error running version detection script:\n%s\n%s" % (so,se)
logging.error(msg)
raise IOError(msg)
handlers = {'vers': lambda val: tuple(int(v) for v in val.split('.'))}
props = {}
for line in (x for x in so.split('\n') if x):
key, val = line.split(':')
props[key] = handlers[key](val)
return props
def finalize_options(self):
build_ext.finalize_options(self)
if self.compiler is None:
compiler = get_default_compiler()
else:
compiler = self.compiler
if compiler == 'msvc':
include_dirs.append('compat/win32')
def compiler_type(self):
if self.compiler:
return self.compiler
compiler = self.distribution.get_command_obj("build_ext").compiler
if compiler is None:
return get_default_compiler()
elif isinstance(compiler, str):
return compiler
else:
return compiler.compiler_type
def adjust_compiler():
"""
This function detects broken compilers and switches to another. If
the environment variable CC is explicitly set, or a compiler is
specified on the commandline, no override is performed -- the purpose
here is to only override a default compiler.
The specific compilers with problems are:
* The default compiler in XCode-4.2, llvm-gcc-4.2,
segfaults when compiling wcslib.
The set of broken compilers can be updated by changing the
compiler_mapping variable. It is a list of 2-tuples where the
first in the pair is a regular expression matching the version
of the broken compiler, and the second is the compiler to change
to.
"""
global _adjusted_compiler
if _adjusted_compiler:
return
# Whatever the result of this function is, it only needs to be run once
_adjusted_compiler = True
if "CC" in os.environ:
return
if get_distutils_option("compiler", ["build", "build_ext", "build_clib"]) is not None:
return
from distutils import ccompiler, sysconfig
import subprocess
import re
compiler_mapping = [(b"i686-apple-darwin[0-9]*-llvm-gcc-4.2", "clang")]
compiler_type = ccompiler.get_default_compiler()
if compiler_type == "unix":
# We have to get the compiler this way, as this is the one that is
# used if os.environ['CC'] is not set. It is actually read in from
# the Python Makefile. Note that this is not necessarily the same
# compiler as returned by ccompiler.new_compiler()
c_compiler = sysconfig.get_config_var("CC")
process = subprocess.Popen(shlex.split(c_compiler) + ["--version"], stdout=subprocess.PIPE)
output = process.communicate()[0].strip()
version = output.split()[0]
for broken, fixed in compiler_mapping:
if re.match(broken, version):
os.environ["CC"] = fixed
break
def __init__(self):
env = _Environment()
self.arch = env['TARGET_ARCH']
self.platform = sys.platform
self.compiler = ccompiler.get_default_compiler()
self.compiler_version = StrictVersion('0.0')
if self.compiler == 'msvc':
self.compiler_version = StrictVersion(env['MSVC_VERSION'])
os.environ['PATH'] = env['ENV']['PATH']
os.environ['INCLUDE'] = env['ENV']['INCLUDE']
os.environ['LIB'] = env['ENV']['LIB']
os.environ['LIBPATH'] = env['ENV']['LIBPATH']
def setupLibMSEED():
"""
Prepare building of C extension libmseed.
"""
macros = []
extra_link_args = []
extra_compile_args = []
src_obspy = os.path.join('obspy', 'mseed', 'src') + os.sep
src = os.path.join('obspy', 'mseed', 'src', 'libmseed') + os.sep
# get symbols for libmseed
lines = open(src + 'libmseed.def', 'r').readlines()[2:]
symbols = [s.strip() for s in lines if s.strip() != '']
# get symbols for obspy-readbuffer.c
lines = open(src_obspy + 'obspy-readbuffer.def', 'r').readlines()[2:]
symbols += [s.strip() for s in lines if s.strip() != '']
# system specific settings
if IS_WINDOWS:
# needed by libmseed lmplatform.h
macros.append(('WIN32', '1'))
# disable some warnings for MSVC
macros.append(('_CRT_SECURE_NO_WARNINGS', '1'))
if 'msvc' in sys.argv or \
('-c' not in sys.argv and get_default_compiler() == 'msvc'):
if platform.architecture()[0] == '32bit':
# Workaround Win32 and MSVC - see issue #64
extra_compile_args.append("/fp:strict")
# create library name
if IS_DEVELOP:
lib_name = 'libmseed-%s-%s-py%s' % (
platform.system(), platform.architecture()[0],
''.join([str(i) for i in platform.python_version_tuple()[:2]]))
else:
lib_name = 'libmseed'
# setup C extension
lib = MyExtension(lib_name,
define_macros=macros,
libraries=[],
sources=[src + 'fileutils.c', src + 'genutils.c',
src + 'gswap.c', src + 'lmplatform.c',
src + 'lookup.c', src + 'msrutils.c',
src + 'pack.c', src + 'packdata.c',
src + 'traceutils.c', src + 'tracelist.c',
src + 'unpack.c', src + 'unpackdata.c',
src + 'selection.c', src + 'logging.c',
src + 'parseutils.c',
src_obspy + 'obspy-readbuffer.c'],
export_symbols=symbols,
extra_link_args=extra_link_args,
extra_compile_args=extra_compile_args)
return lib
def get_compiler_and_args():
'''
Returns the computed compiler and compilation flags
'''
compiler = prefs['codegen.cpp.compiler']
if compiler == '':
compiler = get_default_compiler()
extra_compile_args = prefs['codegen.cpp.extra_compile_args']
if extra_compile_args is None:
if compiler in ('gcc', 'unix'):
extra_compile_args = prefs['codegen.cpp.extra_compile_args_gcc']
if compiler == 'msvc':
extra_compile_args = prefs['codegen.cpp.extra_compile_args_msvc']
return compiler, extra_compile_args
def finalize_options(self):
build_ext.finalize_options(self)
if self.compiler is None:
compiler = get_default_compiler()
else:
compiler = self.compiler
if compiler == 'msvc':
# Add msvc specific hacks
if (sys.version_info.major, sys.version_info.minor) < (3, 3):
# The check above is a nasty hack. We're using the python
# version as a proxy for the MSVC version. 2008 doesn't
# have stdint.h, so is needed. 2010 does.
#
# We need to add the path to msvc includes
msvc_2008_path = (
os.path.join(os.getcwd(), 'include', 'msvc_2008'))
if self.include_dirs is not None:
self.include_dirs.append(msvc_2008_path)
else:
self.include_dirs = [msvc_2008_path]
elif (sys.version_info.major, sys.version_info.minor) < (3, 5):
# Actually, it seems that appveyor doesn't have a stdint that
# works, so even for 2010 we use our own (hacked) version
# of stdint.
# This should be pretty safe in whatever case.
msvc_2010_path = (
os.path.join(os.getcwd(), 'include', 'msvc_2010'))
if self.include_dirs is not None:
self.include_dirs.append(msvc_2010_path)
else:
self.include_dirs = [msvc_2010_path]
# We need to prepend lib to all the library names
_libraries = []
for each_lib in self.libraries:
_libraries.append('lib' + each_lib)
self.libraries = _libraries
def get_compiler_name(self):
"""Return the name of the C compiler used to compile extensions.
If a compiler was not explicitly set (on the command line, for
example), fall back on the default compiler.
"""
if self.compiler:
# distutils doesn't keep the type of self.compiler uniform; we
# compensate:
if isinstance(self.compiler, str):
name = self.compiler
else:
name = self.compiler.compiler_type
else:
name = get_default_compiler()
return name
def _check_cython_sources(self, extension):
"""
Where relevant, make sure that the .c files associated with .pyx
modules are present (if building without Cython installed).
"""
# Determine the compiler we'll be using
if self.compiler is None:
compiler = get_default_compiler()
else:
compiler = self.compiler
# Replace .pyx with C-equivalents, unless c files are missing
for jdx, src in enumerate(extension.sources):
base, ext = os.path.splitext(src)
pyxfn = base + '.pyx'
cfn = base + '.c'
cppfn = base + '.cpp'
if not os.path.isfile(pyxfn):
continue
if self.uses_cython:
extension.sources[jdx] = pyxfn
else:
if os.path.isfile(cfn):
extension.sources[jdx] = cfn
elif os.path.isfile(cppfn):
extension.sources[jdx] = cppfn
else:
msg = (
'Could not find C/C++ file {0}.(c/cpp) for Cython '
'file {1} when building extension {2}. Cython '
'must be installed to build from a git '
'checkout.'.format(base, pyxfn, extension.name))
raise IOError(errno.ENOENT, msg, cfn)
# Current versions of Cython use deprecated Numpy API features
# the use of which produces a few warnings when compiling.
# These additional flags should squelch those warnings.
# TODO: Feel free to remove this if/when a Cython update
# removes use of the deprecated Numpy API
if compiler == 'unix':
extension.extra_compile_args.extend([
'-Wp,-w', '-Wno-unused-function'])
def get_compiler_option():
""" Determines the compiler that will be used to build extension modules.
Returns
-------
compiler : str
The compiler option specified for the build, build_ext, or build_clib
command; or the default compiler for the platform if none was
specified.
"""
compiler = get_distutils_build_option('compiler')
if compiler is None:
return ccompiler.get_default_compiler()
return compiler
def finalize_options(self):
build_ext.finalize_options(self)
self.set_undefined_options('build', ('static','static'))
self.include_dirs = self.include_dirs or []
self.library_dirs = self.library_dirs or []
self.define = self.define or []
self.libraries = self.libraries or []
extra_compile_args = []
extra_link_args = []
compiler = self.compiler or get_default_compiler()
if compiler == 'msvc':
try:
QL_INSTALL_DIR = os.environ['QL_DIR']
self.include_dirs += [QL_INSTALL_DIR]
self.library_dirs += [os.path.join(QL_INSTALL_DIR, 'lib')]
except KeyError, e:
print 'warning: unable to detect QuantLib installation'
if os.environ.has_key('INCLUDE'):
dirs = [dir for dir in os.environ['INCLUDE'].split(';')]
self.include_dirs += dirs
if os.environ.has_key('LIB'):
dirs = [dir for dir in os.environ['LIB'].split(';')]
self.library_dirs += dirs
self.define += [('__WIN32__', None), ('WIN32', None),
('NDEBUG', None), ('_WINDOWS', None),
('NOMINMAX', None)]
extra_compile_args = ['/GR', '/FD', '/Zm250', '/EHsc' ]
extra_link_args = ['/subsystem:windows', '/machine:I386']
if self.debug:
if self.static:
extra_compile_args.append('/MTd')
else:
extra_compile_args.append('/MDd')
else:
if self.static:
extra_compile_args.append('/MT')
else:
extra_compile_args.append('/MD')
def show_compiler():
from distutils.core import Distribution
dist = Distribution()
dist.parse_config_files()
opt = dist.command_options
try:
fn, compiler_name = opt["build"]["compiler"]
except:
from distutils.ccompiler import get_default_compiler
fn = "default"
compiler_name = get_default_compiler()
from distutils import ccompiler
version = ""
if compiler_name == "msvc":
compiler = ccompiler.new_compiler(compiler=compiler_name)
version = str(compiler._MSVCCompiler__version)
print "{} {} defined by {}".format(compiler_name, version, fn)
def test_customize_compiler(self):
# not testing if default compiler is not unix
if get_default_compiler() != 'unix':
return
os.environ['AR'] = 'xxx'
# make sure AR gets caught
class compiler:
compiler_type = 'unix'
def set_executables(self, **kw):
self.exes = kw
comp = compiler()
sysconfig.customize_compiler(comp)
self.assertEquals(comp.exes['archiver'], 'xxx')
def test_customize_compiler(self):
# not testing if default compiler is not unix
if get_default_compiler() != "unix":
return
self.environ["AR"] = "my_ar"
self.environ["ARFLAGS"] = "-arflags"
# make sure AR gets caught
class compiler:
compiler_type = "unix"
def set_executables(self, **kw):
self.exes = kw
comp = compiler()
sysconfig.customize_compiler(comp)
self.assertEquals(comp.exes["archiver"], "my_ar -arflags")
def test_customize_compiler(self):
# not testing if default compiler is not unix
if get_default_compiler() != 'unix':
return
os.environ['AR'] = 'my_ar'
os.environ['ARFLAGS'] = '-arflags'
# make sure AR gets caught
class compiler:
compiler_type = 'unix'
def set_executables(self, **kw):
self.exes = kw
comp = compiler()
customize_compiler(comp)
self.assertEqual(comp.exes['archiver'], 'my_ar -arflags')
def setup_compiler(self):
self.compiler = self.compiler or get_default_compiler()
self.extra_compile_args = []
self.extra_link_args = []
if self.compiler == 'msvc':
distutils.msvc9compiler.VERSION = 11.0
self.extra_compile_args.append('/EHsc')
if self._debug:
self.extra_compile_args.extend(['/Zi'])
#self.extra_compile_args.extend(['/Od'])
#self.extra_compile_args.extend(['/UNDEBUG'])
self.extra_link_args.extend(['/DEBUG'])
self.extra_compile_args.extend(['/GF', '/GL', '/GT', '/Gy'])
self.extra_link_args.extend(['/OPT:REF', '/OPT:ICF', '/LTCG'])
else:
self.extra_compile_args.extend(['/GF', '/GL', '/GT', '/Gy'])
self.extra_link_args.extend(['/OPT:REF', '/OPT:ICF', '/LTCG'])
for ext_module in self.distribution.ext_modules:
ext_module.extra_compile_args.extend(self.extra_compile_args)
ext_module.extra_link_args.extend(self.extra_link_args)
class SysconfigTestCase(support.EnvironGuard, unittest.TestCase):
def setUp(self):
super(SysconfigTestCase, self).setUp()
self.makefile = None
def tearDown(self):
if self.makefile is not None:
os.unlink(self.makefile)
self.cleanup_testfn()
super(SysconfigTestCase, self).tearDown()
def cleanup_testfn(self):
path = test.test_support.TESTFN
if os.path.isfile(path):
os.remove(path)
elif os.path.isdir(path):
shutil.rmtree(path)
def test_get_python_lib(self):
lib_dir = sysconfig.get_python_lib()
# XXX doesn't work on Linux when Python was never installed before
#self.assertTrue(os.path.isdir(lib_dir), lib_dir)
# test for pythonxx.lib?
self.assertNotEqual(sysconfig.get_python_lib(),
sysconfig.get_python_lib(prefix=TESTFN))
_sysconfig = __import__('sysconfig')
res = sysconfig.get_python_lib(True, True)
self.assertEqual(_sysconfig.get_path('platstdlib'), res)
def test_get_python_inc(self):
inc_dir = sysconfig.get_python_inc()
# This is not much of a test. We make sure Python.h exists
# in the directory returned by get_python_inc() but we don't know
# it is the correct file.
self.assertTrue(os.path.isdir(inc_dir), inc_dir)
python_h = os.path.join(inc_dir, "Python.h")
self.assertTrue(os.path.isfile(python_h), python_h)
def customize_compiler(self):
# make sure AR gets caught
class compiler:
compiler_type = 'unix'
def set_executables(self, **kw):
self.exes = kw
sysconfig_vars = {
'AR': 'sc_ar',
'CC': 'sc_cc',
'CXX': 'sc_cxx',
'ARFLAGS': '--sc-arflags',
'CFLAGS': '--sc-cflags',
'CCSHARED': '--sc-ccshared',
'LDSHARED': 'sc_ldshared',
'SO': 'sc_shutil_suffix',
}
comp = compiler()
old_vars = dict(sysconfig._config_vars)
try:
# On macOS, disable _osx_support.customize_compiler()
sysconfig._config_vars['CUSTOMIZED_OSX_COMPILER'] = 'True'
for key, value in sysconfig_vars.items():
sysconfig._config_vars[key] = value
sysconfig.customize_compiler(comp)
finally:
sysconfig._config_vars.clear()
sysconfig._config_vars.update(old_vars)
return comp
@unittest.skipUnless(get_default_compiler() == 'unix',
'not testing if default compiler is not unix')
def test_customize_compiler(self):
# Make sure that sysconfig._config_vars is initialized
sysconfig.get_config_vars()
os.environ['AR'] = 'env_ar'
os.environ['CC'] = 'env_cc'
os.environ['CPP'] = 'env_cpp'
os.environ['CXX'] = 'env_cxx --env-cxx-flags'
os.environ['LDSHARED'] = 'env_ldshared'
os.environ['LDFLAGS'] = '--env-ldflags'
os.environ['ARFLAGS'] = '--env-arflags'
os.environ['CFLAGS'] = '--env-cflags'
os.environ['CPPFLAGS'] = '--env-cppflags'
comp = self.customize_compiler()
self.assertEqual(comp.exes['archiver'], 'env_ar --env-arflags')
self.assertEqual(comp.exes['preprocessor'], 'env_cpp --env-cppflags')
self.assertEqual(comp.exes['compiler'],
'env_cc --sc-cflags --env-cflags --env-cppflags')
self.assertEqual(comp.exes['compiler_so'],
('env_cc --sc-cflags '
'--env-cflags '
'--env-cppflags --sc-ccshared'))
self.assertEqual(comp.exes['compiler_cxx'], 'env_cxx --env-cxx-flags')
self.assertEqual(comp.exes['linker_exe'], 'env_cc')
self.assertEqual(comp.exes['linker_so'],
('env_ldshared --env-ldflags --env-cflags'
' --env-cppflags'))
self.assertEqual(comp.shared_lib_extension, 'sc_shutil_suffix')
del os.environ['AR']
del os.environ['CC']
del os.environ['CPP']
del os.environ['CXX']
del os.environ['LDSHARED']
del os.environ['LDFLAGS']
del os.environ['ARFLAGS']
del os.environ['CFLAGS']
del os.environ['CPPFLAGS']
comp = self.customize_compiler()
self.assertEqual(comp.exes['archiver'], 'sc_ar --sc-arflags')
self.assertEqual(comp.exes['preprocessor'], 'sc_cc -E')
self.assertEqual(comp.exes['compiler'], 'sc_cc --sc-cflags')
self.assertEqual(comp.exes['compiler_so'],
'sc_cc --sc-cflags --sc-ccshared')
self.assertEqual(comp.exes['compiler_cxx'], 'sc_cxx')
self.assertEqual(comp.exes['linker_exe'], 'sc_cc')
self.assertEqual(comp.exes['linker_so'], 'sc_ldshared')
self.assertEqual(comp.shared_lib_extension, 'sc_shutil_suffix')
def test_parse_makefile_base(self):
self.makefile = test.test_support.TESTFN
fd = open(self.makefile, 'w')
try:
fd.write(r"CONFIG_ARGS= '--arg1=optarg1' 'ENV=LIB'" '\n')
fd.write('VAR=$OTHER\nOTHER=foo')
finally:
fd.close()
d = sysconfig.parse_makefile(self.makefile)
self.assertEqual(d, {
'CONFIG_ARGS': "'--arg1=optarg1' 'ENV=LIB'",
'OTHER': 'foo'
})
def test_parse_makefile_literal_dollar(self):
self.makefile = test.test_support.TESTFN
fd = open(self.makefile, 'w')
try:
fd.write(r"CONFIG_ARGS= '--arg1=optarg1' 'ENV=\$$LIB'" '\n')
fd.write('VAR=$OTHER\nOTHER=foo')
finally:
fd.close()
d = sysconfig.parse_makefile(self.makefile)
self.assertEqual(d, {
'CONFIG_ARGS': r"'--arg1=optarg1' 'ENV=\$LIB'",
'OTHER': 'foo'
})
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'))
@unittest.skipIf(sysconfig.get_config_var('CUSTOMIZED_OSX_COMPILER'),
'compiler flags customized')
def test_sysconfig_compiler_vars(self):
# On OS X, binary installers support extension module building on
# various levels of the operating system with differing Xcode
# configurations. This requires customization of some of the
# compiler configuration directives to suit the environment on
# the installed machine. Some of these customizations may require
# running external programs and, so, are deferred until needed by
# the first extension module build. With Python 3.3, only
# the Distutils version of sysconfig is used for extension module
# builds, which happens earlier in the Distutils tests. This may
# cause the following tests to fail since no tests have caused
# the global version of sysconfig to call the customization yet.
# The solution for now is to simply skip this test in this case.
# The longer-term solution is to only have one version of sysconfig.
import sysconfig as global_sysconfig
if sysconfig.get_config_var('CUSTOMIZED_OSX_COMPILER'):
self.skipTest('compiler flags customized')
self.assertEqual(global_sysconfig.get_config_var('LDSHARED'),
sysconfig.get_config_var('LDSHARED'))
self.assertEqual(global_sysconfig.get_config_var('CC'),
sysconfig.get_config_var('CC'))
def test_customize_compiler_before_get_config_vars(self):
# Issue #21923: test that a Distribution compiler
# instance can be called without an explicit call to
# get_config_vars().
with open(TESTFN, 'w') as f:
f.writelines(
textwrap.dedent('''\
from distutils.core import Distribution
config = Distribution().get_command_obj('config')
# try_compile may pass or it may fail if no compiler
# is found but it should not raise an exception.
rc = config.try_compile('int x;')
'''))
p = subprocess.Popen([str(sys.executable), TESTFN],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
universal_newlines=True)
outs, errs = p.communicate()
self.assertEqual(0, p.returncode, "Subprocess failed: " + outs)
SUP_EXTERNAL = 1
sys.argv.remove("--external")
# You should add external library by option: --libraries zstd
# And probably include paths by option: --include-dirs /usr/include/zstd
# And probably library paths by option: --library-dirs /usr/lib/i386-linux-gnu
if "--libraries" not in sys.argv:
# Add something default
ext_libraries = ["zstd"]
EXTRA_OPT = 0
if "--extra-optimization" in sys.argv:
# Support legacy output format functions
EXTRA_OPT = 1
sys.argv.remove("--extra-optimization")
if ccompiler.get_default_compiler() == "msvc":
extra_compile_args = ["/Wall"]
if EXTRA_OPT:
extra_compile_args.insert(0, "/O2")
else:
extra_compile_args.insert(0, "/Ot")
else:
extra_compile_args = [
"-std=c99", "-Wall", "-DFORTIFY_SOURCE=2", "-fstack-protector"
]
if EXTRA_OPT:
extra_compile_args.insert(0, "-march=native")
extra_compile_args.insert(0, "-O3")
else:
extra_compile_args.insert(0, "-O2")
"UnsharpMask", "XbmDecode", "XbmEncode", "ZipDecode",
"ZipEncode", "TiffDecode", "Jpeg2KDecode", "Jpeg2KEncode",
"BoxBlur", "QuantPngQuant", "codec_fd")
DEBUG = False
class DependencyException(Exception):
pass
class RequiredDependencyException(Exception):
pass
PLATFORM_MINGW = 'mingw' in ccompiler.get_default_compiler()
PLATFORM_PYPY = hasattr(sys, 'pypy_version_info')
def _dbg(s, tp=None):
if DEBUG:
if tp:
print(s % tp)
return
print(s)
def _add_directory(path, subdir, where=None):
if subdir is None:
return
subdir = os.path.realpath(subdir)
def setupLibMSEED():
"""
Prepare building of C extension libmseed.
"""
# hack to prevent build_ext to append __init__ to the export symbols
class finallist(list):
def append(self, object):
return
class MyExtension(Extension):
def __init__(self, *args, **kwargs):
Extension.__init__(self, *args, **kwargs)
self.export_symbols = finallist(self.export_symbols)
macros = []
extra_link_args = []
extra_compile_args = []
src_obspy = os.path.join('obspy', 'mseed', 'src') + os.sep
src = os.path.join('obspy', 'mseed', 'src', 'libmseed') + os.sep
# get symbols for libmseed
lines = open(src + 'libmseed.def', 'r').readlines()[2:]
symbols = [s.strip() for s in lines if s.strip() != '']
# get symbols for obspy-readbuffer.c
lines = open(src_obspy + 'obspy-readbuffer.def', 'r').readlines()[2:]
symbols += [s.strip() for s in lines if s.strip() != '']
# system specific settings
if platform.system() == "Windows":
# needed by libmseed lmplatform.h
macros.append(('WIN32', '1'))
# disable some warnings for MSVC
macros.append(('_CRT_SECURE_NO_WARNINGS', '1'))
if 'msvc' in sys.argv or \
('-c' not in sys.argv and get_default_compiler() == 'msvc'):
if platform.architecture()[0] == '32bit':
# Workaround Win32 and MSVC - see issue #64
extra_compile_args.append("/fp:strict")
# create library name
if 'develop' in sys.argv:
lib_name = 'libmseed-%s-%s-py%s' % (
platform.system(), platform.architecture()[0], ''.join(
[str(i) for i in platform.python_version_tuple()[:2]]))
else:
lib_name = 'libmseed'
# setup C extension
lib = MyExtension(
lib_name,
define_macros=macros,
libraries=[],
sources=[
src + 'fileutils.c', src + 'genutils.c', src + 'gswap.c',
src + 'lmplatform.c', src + 'lookup.c', src + 'msrutils.c',
src + 'pack.c', src + 'packdata.c', src + 'traceutils.c',
src + 'tracelist.c', src + 'unpack.c', src + 'unpackdata.c',
src + 'selection.c', src + 'logging.c', src + 'parseutils.c',
src_obspy + 'obspy-readbuffer.c'
],
export_symbols=symbols,
extra_link_args=extra_link_args,
extra_compile_args=extra_compile_args)
return lib
if os.path.exists("MANIFEST"):
os.remove("MANIFEST")
with open("README.md") as file:
long_description = file.read()
CPP14_CONFIG = defaultdict(lambda: ["-std=c++14"], {
"unix": ["-std=c++14"],
"msvc": ["/std:c++14"]
})
CPP03_CONFIG = defaultdict(lambda: ["-std=c++03"], {
"unix": ["-std=c++03"],
"msvc": ["/std:c++03"]
})
_COMPILER = get_default_compiler()
omp_args, _ = check_for_openmp()
if os.name == "nt":
std_libs = []
else:
std_libs = ["m"]
CPP14_FLAG = CPP14_CONFIG[_COMPILER]
CPP03_FLAG = CPP03_CONFIG[_COMPILER]
cythonize_aliases = {
"LIB_DIR":
"yt/utilities/lib/",
"LIB_DIR_EWAH": ["yt/utilities/lib/", "yt/utilities/lib/ewahboolarray/"],
# local script imports:
from buildutils import (
discover_settings, v_str, save_config, load_config, detect_zmq,
warn, fatal, debug, line, copy_and_patch_libzmq, localpath,
fetch_uuid, fetch_libzmq, stage_platform_hpp,
bundled_version, customize_mingw,
)
#-----------------------------------------------------------------------------
# Flags
#-----------------------------------------------------------------------------
# ignore unused-function and strict-aliasing warnings, of which there
# will be many from the Cython generated code:
# note that this is only for gcc-style compilers
if get_default_compiler() in ('unix', 'mingw32'):
ignore_common_warnings=True
else:
ignore_common_warnings=False
# the minimum zeromq version this will work against:
min_zmq = (2,1,4)
# set dylib ext:
if sys.platform.startswith('win'):
lib_ext = '.dll'
elif sys.platform == 'darwin':
lib_ext = '.dylib'
else:
lib_ext = '.so'
import os
from distutils import ccompiler
from cffi import FFI
_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__)))
_ASSIMP_CPP = os.path.join(_ROOT, "assimp.cpp")
_ASSIMP_H = os.path.join(_ROOT, "assimp.h")
_LIB_ASSIMP = None
_LIB_IRRXML = None
_LIB_ZLIB = None
if ccompiler.get_default_compiler() == "unix":
# Default libs path for Unix systems
_LIB_ASSIMP = os.path.join(_ROOT, "..", "..", "assimp", "build", "lib", "libassimp.a") # noqa
_LIB_IRRXML = os.path.join(_ROOT, "..", "..", "assimp", "build", "lib", "libIrrXML.a") # noqa
_LIB_ZLIB = os.path.join(_ROOT, "..", "..", "assimp", "build", "lib", "libzlibstatic.a") # noqa
elif ccompiler.get_default_compiler() == "msvc":
# Default libs path for Windows
_LIB_ASSIMP = os.path.join(_ROOT, "..", "..", "assimp", "build", "lib", "Release", "assimp.lib") # noqa
_LIB_IRRXML = os.path.join(_ROOT, "..", "..", "assimp", "build", "lib", "Release", "IrrXML.lib") # noqa
_LIB_ZLIB = os.path.join(_ROOT, "..", "..", "assimp", "build", "lib", "Release", "zlibstatic.lib") # noqa
# Allow to override path through env vars
if "YOGA_BUILD_LIB_ASSIMP" in os.environ:
_LIB_ASSIMP = os.environ["YOGA_BUILD_LIB_ASSIMP"]
if "YOGA_BUILD_LIB_IRRXML" in os.environ:
_LIB_IRRXML = os.environ["YOGA_BUILD_LIB_IRRXML"]
def finalize_options(self):
build_ext.finalize_options(self)
if self.compiler is None:
compiler = get_default_compiler()
else:
compiler = self.compiler
cfg_vars = sysconfig.get_config_vars()
# Hack around OSX setting a -m flag
if "macosx" in get_build_platform() and "CFLAGS" in cfg_vars:
print("System C-flags:")
print(cfg_vars["CFLAGS"])
cflags = []
for flag in cfg_vars["CFLAGS"].split():
if flag in ["-m", "-isysroot"]:
continue
# Remove sdk links
if flag.endswith(".sdk"):
continue
cflags.append(flag)
cfg_vars["CFLAGS"] = " ".join(cflags)
print("Editted C-flags:")
print(cfg_vars["CFLAGS"])
# Remove unsupported C-flags
unsupported_flags = [
"-fuse-linker-plugin", "-ffat-lto-objects", "-flto-partition=none"
]
for key in ["CFLAGS", "LDFLAGS", "LDSHARED"]:
if key in cfg_vars:
print("System {0}:".format(key))
print(cfg_vars[key])
flags = []
for flag in cfg_vars[key].split():
if flag in unsupported_flags:
continue
flags.append(flag)
cfg_vars[key] = " ".join(flags)
print("Editted {0}:".format(key))
print(cfg_vars[key])
if compiler == 'msvc':
# Add msvc specific hacks
# Sort linking issues with init exported symbols
def _get_export_symbols(self, ext):
return ext.export_symbols
build_ext.get_export_symbols = _get_export_symbols
if (sys.version_info.major, sys.version_info.minor) < (3, 3):
# The check above is a nasty hack. We're using the python
# version as a proxy for the MSVC version. 2008 doesn't
# have stdint.h, so is needed. 2010 does.
#
# We need to add the path to msvc includes
msvc_2008_path = (os.path.join(os.getcwd(), 'include',
'msvc_2008'))
if self.include_dirs is not None:
self.include_dirs.append(msvc_2008_path)
else:
self.include_dirs = [msvc_2008_path]
elif (sys.version_info.major, sys.version_info.minor) < (3, 5):
# Actually, it seems that appveyor doesn't have a stdint that
# works, so even for 2010 we use our own (hacked) version
# of stdint.
# This should be pretty safe in whatever case.
msvc_2010_path = (os.path.join(os.getcwd(), 'include',
'msvc_2010'))
if self.include_dirs is not None:
self.include_dirs.append(msvc_2010_path)
else:
self.include_dirs = [msvc_2010_path]
# We need to prepend lib to all the library names
_libraries = []
for each_lib in self.libraries:
_libraries.append('lib' + each_lib)
self.libraries = _libraries
"UnpackYCC", "UnsharpMask", "XbmDecode", "XbmEncode", "ZipDecode",
"ZipEncode", "TiffDecode", "Jpeg2KDecode", "Jpeg2KEncode", "BoxBlur",
"QuantPngQuant", "codec_fd")
DEBUG = False
class DependencyException(Exception):
pass
class RequiredDependencyException(Exception):
pass
PLATFORM_MINGW = 'mingw' in ccompiler.get_default_compiler()
PLATFORM_PYPY = hasattr(sys, 'pypy_version_info')
def _dbg(s, tp=None):
if DEBUG:
if tp:
print(s % tp)
return
print(s)
def _find_library_dirs_ldconfig():
# Based on ctypes.util from Python 2
if sys.platform.startswith("linux") or sys.platform.startswith("gnu"):
source_name)
module_suffix = iset if iset else "ref"
return Extension(
"nanolib._work_{}".format(module_suffix),
include_dirs=[source_path],
sources=[os.path.join("src", "nanolib-work-module", "work.c")] +
SOURCE_FILES[source_name],
extra_compile_args=get_compile_args(iset, build_platform))
EXTENSIONS_TO_BUILD = []
_machine = platform.machine()
_is_unix_compiler = get_default_compiler() == "unix"
# https://stackoverflow.com/a/45125525
_is_arm = _machine.startswith("arm")
_is_aarch64 = _machine.startswith("aarch64")
# 'AMD64' only appears on Windows
_is_x86 = _machine.startswith("x86") or _machine in ("i386", "i686", "AMD64")
if _is_x86:
EXTENSIONS_TO_BUILD = [
create_work_extension("sse", "avx", "x86"),
create_work_extension("sse", "sse4_1", "x86"),
create_work_extension("sse", "ssse3", "x86"),
create_work_extension("sse", "sse2", "x86"),
create_work_extension("ref", None, "x86")
]
class SysconfigTestCase(support.EnvironGuard, unittest.TestCase):
def setUp(self):
super(SysconfigTestCase, self).setUp()
self.makefile = None
def tearDown(self):
if self.makefile is not None:
os.unlink(self.makefile)
self.cleanup_testfn()
super(SysconfigTestCase, self).tearDown()
def cleanup_testfn(self):
if os.path.isfile(TESTFN):
os.remove(TESTFN)
elif os.path.isdir(TESTFN):
shutil.rmtree(TESTFN)
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_python_lib(self):
# XXX doesn't work on Linux when Python was never installed before
#self.assertTrue(os.path.isdir(lib_dir), lib_dir)
# test for pythonxx.lib?
self.assertNotEqual(sysconfig.get_python_lib(),
sysconfig.get_python_lib(prefix=TESTFN))
def test_get_python_inc(self):
inc_dir = sysconfig.get_python_inc()
# This is not much of a test. We make sure Python.h exists
# in the directory returned by get_python_inc() but we don't know
# it is the correct file.
self.assertTrue(os.path.isdir(inc_dir), inc_dir)
python_h = os.path.join(inc_dir, "Python.h")
self.assertTrue(os.path.isfile(python_h), python_h)
def test_get_config_vars(self):
cvars = sysconfig.get_config_vars()
self.assertIsInstance(cvars, dict)
self.assertTrue(cvars)
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':
self.assertEqual(
os.path.dirname(sysconfig.get_makefile_filename()), 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')
cwd = os.getcwd()
try:
os.chdir('..')
srcdir2 = sysconfig.get_config_var('srcdir')
finally:
os.chdir(cwd)
self.assertEqual(srcdir, srcdir2)
@unittest.skipUnless(get_default_compiler() == 'unix',
'not testing if default compiler is not unix')
def test_customize_compiler(self):
os.environ['AR'] = 'my_ar'
os.environ['ARFLAGS'] = '-arflags'
# make sure AR gets caught
class compiler:
compiler_type = 'unix'
def set_executables(self, **kw):
self.exes = kw
comp = compiler()
sysconfig.customize_compiler(comp)
self.assertEqual(comp.exes['archiver'], 'my_ar -arflags')
def test_parse_makefile_base(self):
self.makefile = TESTFN
fd = open(self.makefile, 'w')
try:
fd.write(r"CONFIG_ARGS= '--arg1=optarg1' 'ENV=LIB'" '\n')
fd.write('VAR=$OTHER\nOTHER=foo')
finally:
fd.close()
d = sysconfig.parse_makefile(self.makefile)
self.assertEqual(d, {
'CONFIG_ARGS': "'--arg1=optarg1' 'ENV=LIB'",
'OTHER': 'foo'
})
def test_parse_makefile_literal_dollar(self):
self.makefile = TESTFN
fd = open(self.makefile, 'w')
try:
fd.write(r"CONFIG_ARGS= '--arg1=optarg1' 'ENV=\$$LIB'" '\n')
fd.write('VAR=$OTHER\nOTHER=foo')
finally:
fd.close()
d = sysconfig.parse_makefile(self.makefile)
self.assertEqual(d, {
'CONFIG_ARGS': r"'--arg1=optarg1' 'ENV=\$LIB'",
'OTHER': 'foo'
})
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'))
@unittest.skipIf(sysconfig.get_config_var('CUSTOMIZED_OSX_COMPILER'),
'compiler flags customized')
def test_sysconfig_compiler_vars(self):
# On OS X, binary installers support extension module building on
# various levels of the operating system with differing Xcode
# configurations. This requires customization of some of the
# compiler configuration directives to suit the environment on
# the installed machine. Some of these customizations may require
# running external programs and, so, are deferred until needed by
# the first extension module build. With Python 3.3, only
# the Distutils version of sysconfig is used for extension module
# builds, which happens earlier in the Distutils tests. This may
# cause the following tests to fail since no tests have caused
# the global version of sysconfig to call the customization yet.
# The solution for now is to simply skip this test in this case.
# The longer-term solution is to only have one version of sysconfig.
import sysconfig as global_sysconfig
if sysconfig.get_config_var('CUSTOMIZED_OSX_COMPILER'):
self.skipTest('compiler flags customized')
self.assertEqual(global_sysconfig.get_config_var('LDSHARED'),
sysconfig.get_config_var('LDSHARED'))
self.assertEqual(global_sysconfig.get_config_var('CC'),
sysconfig.get_config_var('CC'))
@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_SO_in_vars(self):
vars = sysconfig.get_config_vars()
self.assertIsNotNone(vars['SO'])
self.assertEqual(vars['SO'], vars['EXT_SUFFIX'])
def _adjust_compiler(self):
"""
This function detects broken compilers and switches to another. If
the environment variable CC is explicitly set, or a compiler is
specified on the commandline, no override is performed -- the
purpose here is to only override a default compiler.
The specific compilers with problems are:
* The default compiler in XCode-4.2, llvm-gcc-4.2,
segfaults when compiling wcslib.
The set of broken compilers can be updated by changing the
compiler_mapping variable. It is a list of 2-tuples where the
first in the pair is a regular expression matching the version of
the broken compiler, and the second is the compiler to change to.
"""
if 'CC' in os.environ:
# Check that CC is not set to llvm-gcc-4.2
c_compiler = os.environ['CC']
try:
version = get_compiler_version(c_compiler)
except OSError:
msg = textwrap.dedent("""
The C compiler set by the CC environment variable:
{compiler:s}
cannot be found or executed.
""".format(compiler=c_compiler))
log.warn(msg)
sys.exit(1)
for broken, fixed in self._broken_compiler_mapping:
if re.match(broken, version):
msg = textwrap.dedent(
"""Compiler specified by CC environment variable
({compiler:s}:{version:s}) will fail to compile
{pkg:s}.
Please set CC={fixed:s} and try again.
You can do this, for example, by running:
CC={fixed:s} python setup.py <command>
where <command> is the command you ran.
""".format(compiler=c_compiler,
version=version,
pkg=self.package_name,
fixed=fixed))
log.warn(msg)
sys.exit(1)
# If C compiler is set via CC, and isn't broken, we are good to go. We
# should definitely not try accessing the compiler specified by
# ``sysconfig.get_config_var('CC')`` lower down, because this may fail
# if the compiler used to compile Python is missing (and maybe this is
# why the user is setting CC). For example, the official Python 2.7.3
# MacOS X binary was compiled with gcc-4.2, which is no longer available
# in XCode 4.
return
if self.compiler is not None:
# At this point, self.compiler will be set only if a compiler
# was specified in the command-line or via setup.cfg, in which
# case we don't do anything
return
compiler_type = ccompiler.get_default_compiler()
if compiler_type == 'unix':
# We have to get the compiler this way, as this is the one that is
# used if os.environ['CC'] is not set. It is actually read in from
# the Python Makefile. Note that this is not necessarily the same
# compiler as returned by ccompiler.new_compiler()
c_compiler = sysconfig.get_config_var('CC')
try:
version = get_compiler_version(c_compiler)
except OSError:
msg = textwrap.dedent("""
The C compiler used to compile Python {compiler:s}, and
which is normally used to compile C extensions, is not
available. You can explicitly specify which compiler to
use by setting the CC environment variable, for example:
CC=gcc python setup.py <command>
or if you are using MacOS X, you can try:
CC=clang python setup.py <command>
""".format(compiler=c_compiler))
log.warn(msg)
sys.exit(1)
for broken, fixed in self._broken_compiler_mapping:
if re.match(broken, version):
os.environ['CC'] = fixed
break
def adjust_compiler():
"""
This function detects broken compilers and switches to another. If
the environment variable CC is explicitly set, or a compiler is
specified on the commandline, no override is performed -- the purpose
here is to only override a default compiler.
The specific compilers with problems are:
* The default compiler in XCode-4.2, llvm-gcc-4.2,
segfaults when compiling wcslib.
The set of broken compilers can be updated by changing the
compiler_mapping variable. It is a list of 2-tuples where the
first in the pair is a regular expression matching the version
of the broken compiler, and the second is the compiler to change
to.
"""
from distutils import ccompiler, sysconfig
import re
compiler_mapping = [
(b'i686-apple-darwin[0-9]*-llvm-gcc-4.2', 'clang')
]
global _adjusted_compiler
if _adjusted_compiler:
return
# Whatever the result of this function is, it only needs to be run once
_adjusted_compiler = True
if 'CC' in os.environ:
# Check that CC is not set to llvm-gcc-4.2
c_compiler = os.environ['CC']
version = get_compiler_version(c_compiler)
for broken, fixed in compiler_mapping:
if re.match(broken, version):
print("Compiler specified by CC environment variable ({0:s}: {1:s}) will fail to compile Astropy. Please set CC={2:s} and try again. You can do this for example by doing:\n\n CC={2:s} python setup.py <command>\n\nwhere <command> is the command you ran.".format(c_compiler, version, fixed))
sys.exit(1)
if get_distutils_build_option('compiler'):
return
compiler_type = ccompiler.get_default_compiler()
if compiler_type == 'unix':
# We have to get the compiler this way, as this is the one that is
# used if os.environ['CC'] is not set. It is actually read in from
# the Python Makefile. Note that this is not necessarily the same
# compiler as returned by ccompiler.new_compiler()
c_compiler = sysconfig.get_config_var('CC')
version = get_compiler_version(c_compiler)
for broken, fixed in compiler_mapping:
if re.match(broken, version):
os.environ['CC'] = fixed
break
def finalize_options(self):
build_ext.finalize_options(self)
if self.compiler is None:
compiler = get_default_compiler()
else:
compiler = self.compiler
# Hack around OSX setting a -m flag
cfg_vars = sysconfig.get_config_vars()
if "macosx" in get_build_platform() and "CFLAGS" in cfg_vars:
print("System C-flags:")
print(cfg_vars["CFLAGS"])
cflags = list(set(cfg_vars["CFLAGS"].split()))
if "-m" in cflags:
cflags.remove("-m")
if "-isysroot" in cflags:
cflags.remove("-isysroot")
# Remove sdk links
sdk_flags = []
for cflag in cflags:
if cflag.endswith(".sdk"):
sdk_flags.append(cflag)
for cflag in sdk_flags:
cflags.remove(cflag)
cflags = list(set(cflags))
cfg_vars["CFLAGS"] = " ".join(cflags)
print("Editted C-flags:")
print(cfg_vars["CFLAGS"])
os.environ["CFLAGS"] = " ".join(cflags)
if compiler == 'msvc':
# Add msvc specific hacks
# Sort linking issues with init exported symbols
def _get_export_symbols(self, ext):
return ext.export_symbols
build_ext.get_export_symbols = _get_export_symbols
if (sys.version_info.major, sys.version_info.minor) < (3, 3):
# The check above is a nasty hack. We're using the python
# version as a proxy for the MSVC version. 2008 doesn't
# have stdint.h, so is needed. 2010 does.
#
# We need to add the path to msvc includes
msvc_2008_path = (
os.path.join(os.getcwd(), 'include', 'msvc_2008'))
if self.include_dirs is not None:
self.include_dirs.append(msvc_2008_path)
else:
self.include_dirs = [msvc_2008_path]
elif (sys.version_info.major, sys.version_info.minor) < (3, 5):
# Actually, it seems that appveyor doesn't have a stdint that
# works, so even for 2010 we use our own (hacked) version
# of stdint.
# This should be pretty safe in whatever case.
msvc_2010_path = (
os.path.join(os.getcwd(), 'include', 'msvc_2010'))
if self.include_dirs is not None:
self.include_dirs.append(msvc_2010_path)
else:
self.include_dirs = [msvc_2010_path]
# We need to prepend lib to all the library names
_libraries = []
for each_lib in self.libraries:
_libraries.append('lib' + each_lib)
self.libraries = _libraries
plat = get_platname_32bit()
sys.argv.extend(["--plat-name", plat])
ext_modules = [
Extension(
'cdiffer',
sources=['src/cdiffer.cpp'],
language="c++",
include_dirs=["src"],
extra_compile_args=[
"/std:c++14" if os.name == "nt" else "-std=c++14",
# "/IC:/usr/lib/boost",
]
)]
if any("--debug" in x or "-g" in x for x in sys.argv) and get_default_compiler() == "msvc":
ext_modules = [
Extension(
'cdiffer',
sources=['src/cdiffer.cpp'],
# Reason is Debuging Error "Access violation executing location 0x00000000" when using mwArray in Visual-C++
undef_macros=["_DEBUG"],
extra_compile_args=[
# Reason https://docs.microsoft.com/ja-jp/cpp/build/reference/ltcg-link-time-code-generation?view=msvc-160
"/GL",
"/Wall", "/wd", "4514", "/wd 4820", "/wd 5045", "/wd 4100", "/wd 4191", "/wd 4710",
# Reason unicode string crash #
"/source-charset:utf-8",
# Reason IDE warning link crash #
"/FC",
"/std:c++14",
for file in all_cython_files])
snappy_ext_files.add('cython' + os.sep + 'SnapPy.c', cy_source_mod_time)
hp_snappy_ext_files.add('cython' + os.sep + 'SnapPyHP.cpp', cy_source_mod_time)
for file in code:
snappy_ext_files.add(file)
hp_file = 'quad_double' + replace_ext(file, 'cpp')[len('kernel'):]
assert os.path.exists(hp_file)
hp_snappy_ext_files.add(hp_file, modtime(file))
for hp_file in hp_qd_code:
hp_snappy_ext_files.add(hp_file)
# The compiler we will be using
cc = get_default_compiler()
for arg in sys.argv:
if arg.startswith('--compiler='):
cc = arg.split('=')[1]
# The SnapPy extension
snappy_extra_compile_args = []
snappy_extra_link_args = []
if sys.platform == 'win32':
if cc == 'msvc':
snappy_extra_compile_args.append('/EHsc')
# Uncomment to get debugging symbols for msvc.
# snappy_extra_compile_args += ['/DDEBUG', '/Zi',
# '/FdSnapPy.cp37-win_amd64.pdb']
else:
if sys.version_info.major == 2:
# Import the version string.
# Any .py files that are used at install time must be registered in
# obspy.core.tests.test_util_misc.UtilMiscTestCase.test_no_obspy_imports!
UTIL_PATH = os.path.join(SETUP_DIRECTORY, "obspy", "core", "util")
sys.path.insert(0, UTIL_PATH)
from version import get_git_version # @UnresolvedImport
sys.path.pop(0)
LOCAL_PATH = os.path.join(SETUP_DIRECTORY, "setup.py")
DOCSTRING = __doc__.split("\n")
# check for MSVC
if platform.system() == "Windows" and ('msvc' in sys.argv
or '-c' not in sys.argv
and get_default_compiler() == 'msvc'):
IS_MSVC = True
else:
IS_MSVC = False
# Use system libraries? Set later...
EXTERNAL_EVALRESP = False
EXTERNAL_LIBMSEED = False
# Hard dependencies needed to install/run ObsPy.
INSTALL_REQUIRES = [
'numpy>=1.15.0',
'scipy>=1.0.0',
'matplotlib>=3.2.0',
'lxml',
'setuptools',
"QuantPngQuant",
"codec_fd",
)
DEBUG = False
class DependencyException(Exception):
pass
class RequiredDependencyException(Exception):
pass
PLATFORM_MINGW = "mingw" in ccompiler.get_default_compiler()
PLATFORM_PYPY = hasattr(sys, "pypy_version_info")
def _dbg(s, tp=None):
if DEBUG:
if tp:
print(s % tp)
return
print(s)
def _find_library_dirs_ldconfig():
# Based on ctypes.util from Python 2
if sys.platform.startswith("linux") or sys.platform.startswith("gnu"):
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from distutils.core import setup, Extension
from distutils.ccompiler import get_default_compiler
# get the version from the source
CLIENT_VERSION = "unknown"
exec(open('mlat/client/version.py').read())
more_warnings = False
extra_compile_args = []
if more_warnings and get_default_compiler() == 'unix':
# let's assume this is GCC
extra_compile_args.append('-Wpointer-arith')
modes_ext = Extension(
'_modes',
sources=['_modes.c', 'modes_reader.c', 'modes_message.c', 'modes_crc.c'],
extra_compile_args=extra_compile_args)
setup(name='MlatClient',
version=CLIENT_VERSION,
description='Multilateration client package',
author='Oliver Jowett',
author_email='*****@*****.**',
packages=['mlat', 'mlat.client', 'flightaware', 'flightaware.client'],
ext_modules=[modes_ext],
os.remove("MANIFEST")
with open("README.md") as file:
long_description = file.read()
if check_for_openmp():
omp_args = ["-fopenmp"]
else:
omp_args = []
if os.name == "nt":
std_libs = []
else:
std_libs = ["m"]
if get_default_compiler() == "msvc":
CPP14_FLAG = ["/std:c++14"]
else:
CPP14_FLAG = ["--std=c++14"]
cythonize_aliases = {
"LIB_DIR":
"yt/utilities/lib/",
"LIB_DIR_EWAH": ["yt/utilities/lib/", "yt/utilities/lib/ewahboolarray/"],
"LIB_DIR_GEOM": ["yt/utilities/lib/", "yt/geometry/"],
"LIB_DIR_GEOM_ARTIO": [
"yt/utilities/lib/",
"yt/geometry/",
"yt/frontends/artio/artio_headers/",
],
"STD_LIBS":
def run(self):
"""Implementation of the run() function.
See class ditutils.cmd.Command for background.
"""
# At this point, 'self.compiler' is None or a string, but this
# will change while running the corresponding distutils command
self.compiler_name = self.compiler
if self.compiler_name is None:
# Then try to get the default compiler name
from distutils.ccompiler import get_default_compiler
self.compiler_name = get_default_compiler()
# Now process all extensions in the given order
for ext in self.extensions[:]:
if isinstance(ext, CustomBuildStep):
# Then we execute a sequence of subprocesses or a functions
print("\nExecuting custom build step '%s'" % ext.name)
for args in ext.function_list:
if isinstance(args[0], str):
# Then execute a subprocess
print(" ".join(map(str, args)))
if subprocess.call(list(map(str, args))) != 0:
err = "Subprocess %s failed"
raise ValueError(err % args[0])
else:
# Then execute a python function
args[0](*(args[1:]))
elif isinstance(ext, SharedExtension):
# Then we build a shared librry using method
# self.build_shared_extension()
# Evaluate extra_compile_args and extra_link_args to a string
ext.extra_compile_args = self.eval_extra_args(
ext.extra_compile_args)
ext.extra_link_args = self.eval_extra_args(ext.extra_link_args)
print("\nBuilding shared library '%s'" % ext.name)
self.build_shared_extension(ext)
elif isinstance(ext, str):
# A string is taken as a comment
pass
else:
# A standard Extension is build in the same way as in the
# base class. We rely on the fact that setuptools always
# builds the python extension in the build directory,
# even if the 'inplace' option has not been set.
# Evaluate extra_compile_args and extra_link_args to a string
ext.extra_compile_args = self.eval_extra_args(
ext.extra_compile_args)
ext.extra_link_args = self.eval_extra_args(ext.extra_link_args)
# Save the old value of self.compiler because the self.run()
# method appears to change it so that it self.run() method
# cannot be applied twice.
compiler = self.compiler
extensions = self.extensions
self.extensions = [ext] # Build one extension only
inplace = self.inplace
self.inplace = True # Always bild inplace
force = self.force
self.force = True # Always force building
# Run the corresponding mathod of the base class
super(BuildExtCmd, self).run()
# Restore old attributes
self.extensions = extensions
self.inplace = inplace
self.force = True
self.compiler = compiler
def finalize_options(self):
build_ext.finalize_options(self)
self.set_undefined_options('build', ('static','static'))
self.include_dirs = self.include_dirs or []
self.library_dirs = self.library_dirs or []
self.define = self.define or []
self.libraries = self.libraries or []
extra_compile_args = []
extra_link_args = []
compiler = self.compiler or get_default_compiler()
if compiler == 'msvc':
try:
QL_INSTALL_DIR = os.environ['QL_DIR']
self.include_dirs += [QL_INSTALL_DIR]
self.library_dirs += [os.path.join(QL_INSTALL_DIR, 'lib')]
except KeyError:
print('warning: unable to detect QuantLib installation')
if 'INCLUDE' in os.environ:
dirs = [dir for dir in os.environ['INCLUDE'].split(';')]
self.include_dirs += [ d for d in dirs if d.strip() ]
if 'LIB' in os.environ:
dirs = [dir for dir in os.environ['LIB'].split(';')]
self.library_dirs += [ d for d in dirs if d.strip() ]
dbit = round(math.log(sys.maxsize, 2) + 1)
if dbit == 64:
machinetype = '/machine:x64'
else:
machinetype = '/machine:x86'
self.define += [('__WIN32__', None), ('WIN32', None),
('NDEBUG', None), ('_WINDOWS', None),
('NOMINMAX', None)]
extra_compile_args = ['/GR', '/FD', '/Zm250', '/EHsc', '/bigobj' ]
extra_link_args = ['/subsystem:windows', machinetype]
if self.debug:
if self.static:
extra_compile_args.append('/MTd')
else:
extra_compile_args.append('/MDd')
else:
if self.static:
extra_compile_args.append('/MT')
else:
extra_compile_args.append('/MD')
elif compiler == 'unix':
ql_compile_args = \
os.popen('quantlib-config --cflags').read()[:-1].split()
ql_link_args = \
os.popen('quantlib-config --libs').read()[:-1].split()
self.define += [ (arg[2:],None) for arg in ql_compile_args
if arg.startswith('-D') ]
self.include_dirs += [ arg[2:] for arg in ql_compile_args
if arg.startswith('-I') ]
self.library_dirs += [ arg[2:] for arg in ql_link_args
if arg.startswith('-L') ]
self.libraries += [ arg[2:] for arg in ql_link_args
if arg.startswith('-l') ]
extra_compile_args = [ arg for arg in ql_compile_args
if not arg.startswith('-D')
if not arg.startswith('-I') ] \
+ [ '-Wno-unused' ]
if 'CXXFLAGS' in os.environ:
extra_compile_args += os.environ['CXXFLAGS'].split()
extra_link_args = [ arg for arg in ql_link_args
if not arg.startswith('-L')
if not arg.startswith('-l') ]
else:
pass
for ext in self.extensions:
ext.extra_compile_args = ext.extra_compile_args or []
ext.extra_compile_args += extra_compile_args
ext.extra_link_args = ext.extra_link_args or []
ext.extra_link_args += extra_link_args
def compile_c_module(cfiles, modbasename, eci, tmpdir=None):
#try:
# from distutils.log import set_threshold
# set_threshold(10000)
#except ImportError:
# print "ERROR IMPORTING"
# pass
cfiles = [py.path.local(f) for f in cfiles]
if tmpdir is None:
tmpdir = udir.join("module_cache").ensure(dir=1)
num = 0
cfiles += eci.separate_module_files
include_dirs = list(eci.include_dirs)
include_dirs.append(py.path.local(pypydir).join('translator', 'c'))
library_dirs = list(eci.library_dirs)
if sys.platform == 'darwin': # support Fink & Darwinports
for s in ('/sw/', '/opt/local/'):
if s + 'include' not in include_dirs and \
os.path.exists(s + 'include'):
include_dirs.append(s + 'include')
if s + 'lib' not in library_dirs and \
os.path.exists(s + 'lib'):
library_dirs.append(s + 'lib')
num = 0
modname = modbasename
while 1:
if not tmpdir.join(modname + so_ext).check():
break
num += 1
modname = '%s_%d' % (modbasename, num)
lastdir = tmpdir.chdir()
libraries = eci.libraries
ensure_correct_math()
try:
if debug: print "modname", modname
c = stdoutcapture.Capture(mixed_out_err=True)
try:
try:
if compiler_command():
# GCC-ish options only
from distutils import sysconfig
gcv = sysconfig.get_config_vars()
cmd = compiler_command().replace('%s',
str(tmpdir.join(modname)))
for dir in [gcv['INCLUDEPY']] + list(include_dirs):
cmd += ' -I%s' % dir
for dir in library_dirs:
cmd += ' -L%s' % dir
os.system(cmd)
else:
from distutils.dist import Distribution
from distutils.extension import Extension
from distutils.ccompiler import get_default_compiler
saved_environ = os.environ.items()
try:
# distutils.core.setup() is really meant for end-user
# interactive usage, because it eats most exceptions and
# turn them into SystemExits. Instead, we directly
# instantiate a Distribution, which also allows us to
# ignore unwanted features like config files.
extra_compile_args = []
# ensure correct math on windows
if sys.platform == 'win32':
extra_compile_args.append(
'/Op') # get extra precision
if get_default_compiler() == 'unix':
old_version = False
try:
g = os.popen('gcc --version', 'r')
verinfo = g.read()
g.close()
except (OSError, IOError):
pass
else:
old_version = verinfo.startswith('2')
if not old_version:
extra_compile_args.extend([
"-Wno-unused-label", "-Wno-unused-variable"
])
attrs = {
'name':
"testmodule",
'ext_modules': [
Extension(
modname,
[str(cfile) for cfile in cfiles],
include_dirs=include_dirs,
library_dirs=library_dirs,
extra_compile_args=extra_compile_args,
libraries=list(libraries),
)
],
'script_name':
'setup.py',
'script_args':
['-q', 'build_ext', '--inplace', '--force'],
}
dist = Distribution(attrs)
if not dist.parse_command_line():
raise ValueError, "distutils cmdline parse error"
dist.run_commands()
finally:
for key, value in saved_environ:
if os.environ.get(key) != value:
os.environ[key] = value
finally:
foutput, foutput = c.done()
data = foutput.read()
if data:
fdump = open("%s.errors" % modname, "w")
fdump.write(data)
fdump.close()
# XXX do we need to do some check on fout/ferr?
# XXX not a nice way to import a module
except:
print >> sys.stderr, data
raise
finally:
lastdir.chdir()
return str(tmpdir.join(modname) + so_ext)
def get_compiler(self):
return self.compiler or get_default_compiler()
class SysconfigTestCase(support.EnvironGuard, unittest.TestCase):
def setUp(self):
super(SysconfigTestCase, self).setUp()
self.makefile = None
def tearDown(self):
if self.makefile is not None:
os.unlink(self.makefile)
self.cleanup_testfn()
super(SysconfigTestCase, self).tearDown()
def cleanup_testfn(self):
if os.path.isfile(TESTFN):
os.remove(TESTFN)
elif os.path.isdir(TESTFN):
shutil.rmtree(TESTFN)
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_python_lib(self):
# XXX doesn't work on Linux when Python was never installed before
#self.assertTrue(os.path.isdir(lib_dir), lib_dir)
# test for pythonxx.lib?
self.assertNotEqual(sysconfig.get_python_lib(),
sysconfig.get_python_lib(prefix=TESTFN))
def test_get_config_vars(self):
cvars = sysconfig.get_config_vars()
self.assertIsInstance(cvars, dict)
self.assertTrue(cvars)
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':
self.assertEqual(
os.path.dirname(sysconfig.get_makefile_filename()),
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')
cwd = os.getcwd()
try:
os.chdir('..')
srcdir2 = sysconfig.get_config_var('srcdir')
finally:
os.chdir(cwd)
self.assertEqual(srcdir, srcdir2)
def customize_compiler(self):
# make sure AR gets caught
class compiler:
compiler_type = 'unix'
def set_executables(self, **kw):
self.exes = kw
sysconfig_vars = {
'AR': 'sc_ar',
'CC': 'sc_cc',
'CXX': 'sc_cxx',
'ARFLAGS': '--sc-arflags',
'CFLAGS': '--sc-cflags',
'CCSHARED': '--sc-ccshared',
'LDSHARED': 'sc_ldshared',
'SHLIB_SUFFIX': 'sc_shutil_suffix',
# On macOS, disable _osx_support.customize_compiler()
'CUSTOMIZED_OSX_COMPILER': 'True',
}
comp = compiler()
with contextlib.ExitStack() as cm:
for key, value in sysconfig_vars.items():
cm.enter_context(swap_item(sysconfig._config_vars, key, value))
sysconfig.customize_compiler(comp)
return comp
@unittest.skipUnless(get_default_compiler() == 'unix',
'not testing if default compiler is not unix')
def test_customize_compiler(self):
# Make sure that sysconfig._config_vars is initialized
sysconfig.get_config_vars()
os.environ['AR'] = 'env_ar'
os.environ['CC'] = 'env_cc'
os.environ['CPP'] = 'env_cpp'
os.environ['CXX'] = 'env_cxx --env-cxx-flags'
os.environ['LDSHARED'] = 'env_ldshared'
os.environ['LDFLAGS'] = '--env-ldflags'
os.environ['ARFLAGS'] = '--env-arflags'
os.environ['CFLAGS'] = '--env-cflags'
os.environ['CPPFLAGS'] = '--env-cppflags'
comp = self.customize_compiler()
self.assertEqual(comp.exes['archiver'],
'env_ar --env-arflags')
self.assertEqual(comp.exes['preprocessor'],
'env_cpp --env-cppflags')
self.assertEqual(comp.exes['compiler'],
'env_cc --sc-cflags --env-cflags --env-cppflags')
self.assertEqual(comp.exes['compiler_so'],
('env_cc --sc-cflags '
'--env-cflags ''--env-cppflags --sc-ccshared'))
self.assertEqual(comp.exes['compiler_cxx'],
'env_cxx --env-cxx-flags')
self.assertEqual(comp.exes['linker_exe'],
'env_cc')
self.assertEqual(comp.exes['linker_so'],
('env_ldshared --env-ldflags --env-cflags'
' --env-cppflags'))
self.assertEqual(comp.shared_lib_extension, 'sc_shutil_suffix')
del os.environ['AR']
del os.environ['CC']
del os.environ['CPP']
del os.environ['CXX']
del os.environ['LDSHARED']
del os.environ['LDFLAGS']
del os.environ['ARFLAGS']
del os.environ['CFLAGS']
del os.environ['CPPFLAGS']
comp = self.customize_compiler()
self.assertEqual(comp.exes['archiver'],
'sc_ar --sc-arflags')
self.assertEqual(comp.exes['preprocessor'],
'sc_cc -E')
self.assertEqual(comp.exes['compiler'],
'sc_cc --sc-cflags')
self.assertEqual(comp.exes['compiler_so'],
'sc_cc --sc-cflags --sc-ccshared')
self.assertEqual(comp.exes['compiler_cxx'],
'sc_cxx')
self.assertEqual(comp.exes['linker_exe'],
'sc_cc')
self.assertEqual(comp.exes['linker_so'],
'sc_ldshared')
self.assertEqual(comp.shared_lib_extension, 'sc_shutil_suffix')
def test_parse_makefile_base(self):
self.makefile = TESTFN
fd = open(self.makefile, 'w')
try:
fd.write(r"CONFIG_ARGS= '--arg1=optarg1' 'ENV=LIB'" '\n')
fd.write('VAR=$OTHER\nOTHER=foo')
finally:
fd.close()
d = sysconfig.parse_makefile(self.makefile)
self.assertEqual(d, {'CONFIG_ARGS': "'--arg1=optarg1' 'ENV=LIB'",
'OTHER': 'foo'})
def test_parse_makefile_literal_dollar(self):
self.makefile = TESTFN
fd = open(self.makefile, 'w')
try:
fd.write(r"CONFIG_ARGS= '--arg1=optarg1' 'ENV=\$$LIB'" '\n')
fd.write('VAR=$OTHER\nOTHER=foo')
finally:
fd.close()
d = sysconfig.parse_makefile(self.makefile)
self.assertEqual(d, {'CONFIG_ARGS': r"'--arg1=optarg1' 'ENV=\$LIB'",
'OTHER': 'foo'})
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'))
@unittest.skipIf(sysconfig.get_config_var('CUSTOMIZED_OSX_COMPILER'),
'compiler flags customized')
def test_sysconfig_compiler_vars(self):
# On OS X, binary installers support extension module building on
# various levels of the operating system with differing Xcode
# configurations. This requires customization of some of the
# compiler configuration directives to suit the environment on
# the installed machine. Some of these customizations may require
# running external programs and, so, are deferred until needed by
# the first extension module build. With Python 3.3, only
# the Distutils version of sysconfig is used for extension module
# builds, which happens earlier in the Distutils tests. This may
# cause the following tests to fail since no tests have caused
# the global version of sysconfig to call the customization yet.
# The solution for now is to simply skip this test in this case.
# The longer-term solution is to only have one version of sysconfig.
import sysconfig as global_sysconfig
if sysconfig.get_config_var('CUSTOMIZED_OSX_COMPILER'):
self.skipTest('compiler flags customized')
self.assertEqual(global_sysconfig.get_config_var('LDSHARED'),
sysconfig.get_config_var('LDSHARED'))
self.assertEqual(global_sysconfig.get_config_var('CC'),
sysconfig.get_config_var('CC'))
@requires_subprocess()
def test_customize_compiler_before_get_config_vars(self):
# Issue #21923: test that a Distribution compiler
# instance can be called without an explicit call to
# get_config_vars().
with open(TESTFN, 'w') as f:
f.writelines(textwrap.dedent('''\
from distutils.core import Distribution
config = Distribution().get_command_obj('config')
# try_compile may pass or it may fail if no compiler
# is found but it should not raise an exception.
rc = config.try_compile('int x;')
'''))
p = subprocess.Popen([str(sys.executable), TESTFN],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
universal_newlines=True)
outs, errs = p.communicate()
self.assertEqual(0, p.returncode, "Subprocess failed: " + outs)
import os
import sys
import numpy
sys.path.append('./code')
from distutils.core import setup, Extension
from distutils.ccompiler import CCompiler, get_default_compiler
from utils import parallelCCompiler
from numpy.distutils.intelccompiler import IntelCCompiler
from numpy import any
INTEL_PATH = '/opt/intel/'
# heuristic for figuring out which compiler is being used (icc, gcc)
if any(['intel' in arg for arg in sys.argv]) or 'intel' in get_default_compiler():
# icc-specific options
include_dirs=[
os.path.join(INTEL_PATH, 'mkl/include')]
library_dirs=[
os.path.join(INTEL_PATH, 'mkl/lib'),
os.path.join(INTEL_PATH, 'lib')]
libraries = [
'mkl_intel_lp64',
'mkl_intel_thread',
'mkl_core',
'mkl_def',
'iomp5']
extra_compile_args = [
'-DEIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS',
'-DEIGEN_USE_MKL_ALL',
from __future__ import division
#from __future__ import unicode_literals
from __future__ import print_function
from __future__ import absolute_import
import os, sys
from os.path import join
# We require Python v2.7 or newer
if sys.version_info[:2] < (2, 7):
raise RuntimeError("This requires Python v2.7 or newer")
# Prepare for compiling the source code
from distutils.ccompiler import get_default_compiler
import numpy
compiler_name = get_default_compiler(
) # TODO: this isn't the compiler that will necessarily be used, but is a good guess...
compiler_opt = {
'msvc': [
'/D_SCL_SECURE_NO_WARNINGS', '/EHsc', '/O2',
'/DNPY_NO_DEPRECATED_API=7', '/bigobj', '/openmp'
],
# TODO: older versions of gcc need -std=c++0x instead of -std=c++11
'unix': ['-std=c++11', '-O3', '-DNPY_NO_DEPRECATED_API=7',
'-fopenmp'], # gcc/clang (whatever is system default)
'mingw32': ['-std=c++11', '-O3', '-DNPY_NO_DEPRECATED_API=7', '-fopenmp'],
'cygwin': ['-std=c++11', '-O3', '-DNPY_NO_DEPRECATED_API=7', '-fopenmp'],
}
linker_opt = {
'msvc': [],
'unix': ['-fopenmp'], # gcc/clang (whatever is system default)
'mingw32': ['-fopenmp'],
def get_compiler(self):
"""Return the C compiler used for building the extension."""
return self.compiler or get_default_compiler()
ccompiler = None
for arg in sys.argv[1:]:
if arg.startswith('--compiler='):
defcomp = list(getattr(cc, '_default_compilers'))
val = arg.split('=', 1)[1]
for i, compspec in enumerate(defcomp):
if compspec[0] == os.name:
defcomp[i] = (os.name, val)
sys.argv.remove(arg)
cc._default_compilers = tuple(defcomp)
ccompiler = val
break
# Obtain C compiler ID if unspecified
if ccompiler is None:
ccompiler = cc.get_default_compiler()
# Prevent linking against MSVCRxx.dll on Windows when compiled with mingw32
if win_platform:
class IntWithLstrip(int):
def lstrip(self, _=None):
return self
dummy_msvc_runtime_library = False
save_msvc_runtime_version = numpy.distutils.misc_util.msvc_runtime_version
def msvc_runtime_version_override():
if dummy_msvc_runtime_library:
return
return save_msvc_runtime_version()
class CCompilerTestCase(support.EnvironGuard, unittest.TestCase):
def test_set_executables(self):
class MyCCompiler(CCompiler):
executables = {'compiler': '', 'compiler_cxx': '', 'linker': ''}
compiler = MyCCompiler()
# set executable as list
compiler.set_executables(compiler=['env', 'OMPI_MPICC=clang', 'mpicc'])
self.assertEqual(compiler.compiler,
['env', 'OMPI_MPICC=clang', 'mpicc'])
# set executable as string
compiler.set_executables(compiler_cxx='env OMPI_MPICXX=clang++ mpicxx')
self.assertEqual(compiler.compiler_cxx,
['env', 'OMPI_MPICXX=clang++', 'mpicxx'])
# set executable as unicode string
compiler.set_executables(linker=u'env OMPI_MPICXX=clang++ mpiCC')
self.assertEqual(compiler.linker,
[u'env', u'OMPI_MPICXX=clang++', u'mpiCC'])
def test_gen_lib_options(self):
compiler = FakeCompiler()
libdirs = ['lib1', 'lib2']
runlibdirs = ['runlib1']
libs = [os.path.join('dir', 'name'), 'name2']
opts = gen_lib_options(compiler, libdirs, runlibdirs, libs)
wanted = ['-Llib1', '-Llib2', '-cool', '-Rrunlib1', 'found', '-lname2']
self.assertEqual(opts, wanted)
def test_debug_print(self):
class MyCCompiler(CCompiler):
executables = {}
compiler = MyCCompiler()
with captured_stdout() as stdout:
compiler.debug_print('xxx')
stdout.seek(0)
self.assertEqual(stdout.read(), '')
debug.DEBUG = True
try:
with captured_stdout() as stdout:
compiler.debug_print('xxx')
stdout.seek(0)
self.assertEqual(stdout.read(), 'xxx\n')
finally:
debug.DEBUG = False
@unittest.skipUnless(get_default_compiler() == 'unix',
'not testing if default compiler is not unix')
def test_customize_compiler(self):
os.environ['AR'] = 'my_ar'
os.environ['ARFLAGS'] = '-arflags'
# make sure AR gets caught
class compiler:
compiler_type = 'unix'
def set_executables(self, **kw):
self.exes = kw
comp = compiler()
customize_compiler(comp)
self.assertEqual(comp.exes['archiver'], 'my_ar -arflags')
os.chdir(build_dir)
return ret_code
if sys.platform != 'darwin' and sys.platform != 'win32':
build_dependency('s2n')
build_dependency('aws-c-common')
build_dependency('aws-c-io')
build_dependency('aws-c-mqtt')
build_dependency('aws-c-cal')
build_dependency('aws-c-http')
os.chdir(current_dir)
from distutils.ccompiler import get_default_compiler
compiler_type = get_default_compiler()
aws_c_libs = ['aws-c-mqtt', 'aws-c-io', 'aws-c-common', 'aws-c-cal', 'aws-c-http']
def get_from_env(key):
try:
return os.environ[key]
except:
return ""
# fetch the CFLAGS/LDFLAGS from env
cflags = get_from_env('CFLAGS').split()
ldflags = get_from_env('LDFLAGS').split()
include_dirs = [path.join(dep_install_path, 'include')]
libraries = list(aws_c_libs)
def get_compiler(self):
return self.compiler or get_default_compiler()
import os
import distutils.ccompiler as dist_ccomp
import distutils.command.build as dist_build
#
from setuptools import setup, Extension
from setuptools.command.install import install
def rename_files(dirpath, fromsuf, tosuf):
for fn in os.listdir(dirpath):
if fn.endswith(fromsuf):
os.rename(dirpath + fn, dirpath + fn[:-len(fromsuf)] + tosuf)
if dist_ccomp.get_default_compiler() == 'msvc':
# MSVC requires C files to be actually C++ in order to compile them with
# support for "modern" C features
print('compiling C extensions with MSVC: renaming .c to .cc')
rename_files('./C_alg/', '.c', '.cc')
rename_files('./C_py/', '.c', '.cc')
pycomp128 = Extension('pycomp128',
sources=['C_py/pycomp128.cc', 'C_alg/comp128.cc'])
pykasumi = Extension('pykasumi',
sources=['C_py/pykasumi.cc', 'C_alg/Kasumi.cc'])
pysnow = Extension('pysnow',
sources=['C_py/pysnow.cc', 'C_alg/SNOW_3G.cc'])
pyzuc = Extension('pyzuc', sources=['C_py/pyzuc.cc', 'C_alg/ZUC.cc'])
else:
pycomp128 = Extension('pycomp128',
sources=['C_py/pycomp128.c', 'C_alg/comp128.c'])
try:
import nose
except ImportError:
nose = None
# local script imports:
from buildutils import (discover_settings, v_str, localpath, savepickle, loadpickle, detect_zmq,
warn, fatal, copy_and_patch_libzmq)
#-----------------------------------------------------------------------------
# Flags
#-----------------------------------------------------------------------------
# ignore unused-function and strict-aliasing warnings, of which there
# will be many from the Cython generated code:
# note that this is only for gcc-style compilers
if get_default_compiler() in ('unix', 'mingw32'):
ignore_common_warnings=True
else:
ignore_common_warnings=False
# the minimum zeromq version this will work against:
min_zmq = (2,1,4)
# set dylib ext:
if sys.platform.startswith('win'):
lib_ext = '.dll'
elif sys.platform == 'darwin':
lib_ext = '.1.dylib'
else:
lib_ext = '.so.1'
def postop():
if dist_ccomp.get_default_compiler() == 'msvc':
# reverting the renaming
rename_files('./C_alg/', '.cc', '.c')
rename_files('./C_py/', '.cc', '.c')
