Пример #1
0
def get_cxxflags():
    from distutils.ccompiler import new_compiler
    from distutils.sysconfig import customize_compiler
    from distutils import sysconfig
    from platform import system
    if system() == DARWIN_KEY:
        CXX_FLAGS["gcc"] = CXX_FLAGS["gcc-mac"]
        CXX_FLAGS["cc"] = CXX_FLAGS["clang"]
        CXX_FLAGS["c++"] = CXX_FLAGS["clang"]
    elif system() == LINUX_KEY:
        CXX_FLAGS["gcc"] = CXX_FLAGS["gcc-linux"]
        CXX_FLAGS["cc"] = CXX_FLAGS["gcc"]
        CXX_FLAGS["c++"] = CXX_FLAGS["gcc"]
    else:
        raise UnsupportedCompilerException("System: %s is not supported by HOPE" % system())
    
    sysconfig.get_config_vars() #init vars
    compiler = new_compiler()
    customize_compiler(compiler)
    compiler_name = compiler.compiler[0].split("/")[-1]
    
    _check_version(compiler_name, compiler.compiler[0])
    
    for name, flags in CXX_FLAGS.items():
        if compiler_name.startswith(name):
            return flags
    raise UnsupportedCompilerException("Unknown compiler: {0}".format(compiler_name))
Пример #2
0
def find_python_library():
    "Return the full path to the Python library (empty string if not found)"
    pyver = sysconfig.get_python_version()
    libpython_names = [
        "python%s" % pyver.replace(".", ""),
        "python%smu" % pyver,
        "python%sm" % pyver,
        "python%su" % pyver,
        "python%s" % pyver,
        ]
    dirs = [
        "%s/lib" % os.environ.get("PYTHON_DIR", ""),
        "%s" % sysconfig.get_config_vars().get("LIBDIR", ""),
        "/usr/lib/%s" % sysconfig.get_config_vars().get("MULTIARCH", ""),
        "/usr/local/lib",
        "/opt/local/lib",
        "/usr/lib",
        "/usr/lib64",
        ]
    libpython = None
    cc = new_compiler()
    for name in libpython_names:
        libpython = cc.find_library_file(dirs, name)
        if libpython is not None:
            break
    return libpython or ""
Пример #3
0
    def finalize_options(self):
        undefined_temp = self.build_temp is None
        self.set_undefined_options('build',
                                   ('build_scripts', 'build_dir'),
                                   ('build_temp', 'build_temp'),
                                   ('compiler', 'compiler'),
                                   ('debug', 'debug'),
                                   ('force', 'force'))
        if undefined_temp:
            self.build_temp = os.path.join(self.build_temp, 'scripts')

        self.scripts = self.distribution.scripts or []

        # Get the linker arguments for building executables
        if os.name == 'posix':
            args = sysconfig.get_config_vars('LDFLAGS', 'LINKFORSHARED')
            self.link_preargs = ' '.join(args).split()

            args = sysconfig.get_config_vars('LIBS', 'MODLIBS', 'SYSLIBS',
                                             'LDLAST')
            self.link_postargs = ' '.join(args).split()
        else:
            self.link_preargs = []
            self.link_postargs = []

        # Get the extension for executables
        self.exe_extension = sysconfig.get_config_var('EXE') or ''
        if self.debug and os.name == 'nt':
            self.exe_extension = '_d' + self.exe_extension
        return
Пример #4
0
    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')
Пример #5
0
def get_venv_basedir():
    """Returns the base directory of the virtualenv, useful to read configuration and plugins"""

    exec_prefix = get_config_vars()['exec_prefix']

    if hasattr(sys, 'real_prefix') is False or exec_prefix.startswith(sys.real_prefix):
        raise EnvironmentError('You must be in a virtual environment')

    return os.path.abspath(get_config_vars()['exec_prefix'] + '/../')
Пример #6
0
def ask_supports_thread():
    from distutils.core import Distribution
    from distutils.sysconfig import get_config_vars
    get_config_vars()      # workaround for a bug of distutils, e.g. on OS/X
    config = Distribution().get_command_obj('config')
    ok = config.try_compile('__thread int some_threadlocal_variable_42;')
    if ok:
        define_macros.append(('USE__THREAD', None))
    else:
        sys.stderr.write("Note: will not use '__thread' in the C code\n")
        sys.stderr.write("The above error message can be safely ignored\n")
Пример #7
0
def inspect_cuda():
    """ Return cuda device information and nvcc/cuda setup """
    nvcc_settings = nvcc_compiler_settings()
    sysconfig.get_config_vars()
    nvcc_compiler = ccompiler.new_compiler()
    sysconfig.customize_compiler(nvcc_compiler)
    customize_compiler_for_nvcc(nvcc_compiler, nvcc_settings)

    output = inspect_cuda_version_and_devices(nvcc_compiler, nvcc_settings)

    return json.loads(output), nvcc_settings
Пример #8
0
def remove_from_cflags(flags):
    if not windows_check():
        keys = ["OPT", "CFLAGS"]
        if python_version == '2.5':
            keys = ["CFLAGS"]

        for key in keys:
            cv_opt = sysconfig.get_config_vars()[key]
            for flag in flags:
                cv_opt = cv_opt.replace(flag, " ")
            sysconfig.get_config_vars()[key] = " ".join(cv_opt.split())
Пример #9
0
 def __init__(self):
     self.flags = (
         'OPT',
         'CFLAGS',
         'CPPFLAGS',
         'EXTRA_CFLAGS',
         'BASECFLAGS',
         'PY_CFLAGS',
     )
     self.state = sysconfig.get_config_vars(*self.flags)
     self.config_vars = sysconfig.get_config_vars()
Пример #10
0
def _linker_vars(file_exts):
  linking_compiler = get_config_vars("LDSHARED")[0]
  file_exts = set(file_exts)
  runtime_libs = ""
  cxx = False
  if 'cpp' in file_exts:
    linking_compiler = get_config_vars("LDCXXSHARED")[0]
    cxx = True
  if 'f90' in file_exts:
    if cxx:
      runtime_libs = "-lc -lstdc++"
    linking_compiler = " ".join([compiler['f90']] + linking_compiler.split()[1:])
  return (linking_compiler, runtime_libs)
Пример #11
0
  def run(self) :

    #print self.distribution.find_config_files()
    print self.distribution.command_options
    self.distribution.parse_config_files()
    print self.prefix
    print self.get_sub_commands()
    print self.__dict__
    print get_config_vars('prefix')

    # delete scripts
    for script in self.distribution.scripts :
        self.remove_path(os.path.basename(script))
Пример #12
0
def get_compiler_command():
    """
    Returns the name of the executable used by the default compiler on the
    system used by distutils to build C extensions.
    """

    get_config_vars()
    compiler = new_compiler()
    customize_compiler(compiler)
    if isinstance(compiler, MSVCCompiler):
        compiler.initialize()
        # Normally the compiler path will be quoted as it contains spaces
        return '"%s"' % compiler.cc
    return compiler.compiler[0]
Пример #13
0
def _fixup_compiler():
    if 'CC' in os.environ:
        # CC is in the environment, always use explicit
        # overrides.
        return

    try:
        # Newer version of python have support for dealing with
        # the compiler mess w.r.t. various versions of Apple's SDKs
        import _osx_support
        _osx_support.customize_compiler(get_config_vars())
    except (ImportError, AttributeError, KeyError):
        pass

    cc = oldcc = get_config_var('CC').split()[0]
    cc = _find_executable(cc)
    if cc is not None and os.path.basename(cc).startswith('gcc'):
        # Check if compiler is LLVM-GCC, that's known to
        # generate bad code.
        data = os.popen("'%s' --version 2>/dev/null"%(
            cc.replace("'", "'\"'\"'"),)).read()
        if 'llvm-gcc' in data:
            cc = None

    if cc is not None and not _working_compiler(cc):

        cc = None

    if cc is None:
        # Default compiler is not useable, try finding 'clang'
        cc = _find_executable('clang')
        if cc is None:
            cc = os.popen("/usr/bin/xcrun -find clang").read()

    if not cc:
        raise DistutilsPlatformError("Cannot locate compiler candidate")

    if not _working_compiler(cc):
        raise DistutilsPlatformError("Cannot locate a working compiler")

    if cc != oldcc:
        log.info("Use '%s' instead of '%s' as the compiler"%(cc, oldcc))

        vars = get_config_vars()
        for env in ('BLDSHARED', 'LDSHARED', 'CC', 'CXX'):
            if env in vars and env not in os.environ:
                split = vars[env].split()
                split[0] = cc if env != 'CXX' else cc + '++'
                vars[env] = ' '.join(split)
Пример #14
0
 def initialize_options(self, *args):
     from distutils.sysconfig import get_config_vars
     (opt,) = get_config_vars('OPT')
     if opt:
         os.environ['OPT'] = ' '.join(flag for flag in opt.split() 
                                  if flag and flag != '-Wstrict-prototypes')
     build_ext.initialize_options(self)
Пример #15
0
def configure_pyexe(exe, config_cmd):
    from distutils import sysconfig
    if sys.platform.startswith('win'):
        return
    if (sys.platform == 'darwin' and
        ('Anaconda' in sys.version or
         'Continuum Analytics' in sys.version)):
        py_version = sysconfig.get_python_version()
        py_abiflags = getattr(sys, 'abiflags', '')
        exe.libraries += ['python' + py_version + py_abiflags]
        return
    #
    from distutils.util import split_quoted
    cfg_vars = sysconfig.get_config_vars()
    libraries = []
    library_dirs = []
    link_args = []
    if not sysconfig.get_config_var('Py_ENABLE_SHARED'):
        py_version = sysconfig.get_python_version()
        py_abiflags = getattr(sys, 'abiflags', '')
        libraries = ['python' + py_version + py_abiflags]
    if sys.platform == 'darwin':
        fwkdir = cfg_vars.get('PYTHONFRAMEWORKDIR')
        if (fwkdir and fwkdir != 'no-framework' and
            fwkdir in cfg_vars.get('LINKFORSHARED', '')):
            del libraries[:]
    for var in ('LIBDIR', 'LIBPL'):
        library_dirs += split_quoted(cfg_vars.get(var, ''))
    for var in ('LDFLAGS',
                'LIBS', 'MODLIBS', 'SYSLIBS',
                'LDLAST'):
        link_args += split_quoted(cfg_vars.get(var, ''))
    exe.libraries += libraries
    exe.library_dirs += library_dirs
    exe.extra_link_args += link_args
Пример #16
0
    def test_version_int(self):
        source = self.mkdtemp()
        target = self.mkdtemp()
        expected = self.write_sample_scripts(source)


        cmd = self.get_build_scripts_cmd(target,
                                         [os.path.join(source, fn)
                                          for fn in expected])
        cmd.finalize_options()

        # http://bugs.python.org/issue4524
        #
        # On linux-g++-32 with command line `./configure --enable-ipv6
        # --with-suffix=3`, python is compiled okay but the build scripts
        # failed when writing the name of the executable
        old = sysconfig.get_config_vars().get('VERSION')
        sysconfig._config_vars['VERSION'] = 4
        try:
            cmd.run()
        finally:
            if old is not None:
                sysconfig._config_vars['VERSION'] = old

        built = os.listdir(target)
        for name in expected:
            self.assert_(name in built)
    def setUp(self):
        if "agent_remote_stress_test" not in config:
            raise SkipTest()

        virtualenv_home = sysconfig.get_config_vars("exec_prefix")[0]
        log_path = os.path.join(virtualenv_home, "logs")
        mkdir_p(log_path)
        log_file = os.path.join(log_path, self.id() + ".log")
        logger = logging.getLogger()
        handler = logging.FileHandler(log_file, mode='w', encoding=None,
                                      delay=False)
        logger.addHandler(handler)

        logging.info("PY_STRESS_START:%d" % int(time.time() * 1000))

        if "host" in config["agent_remote_stress_test"]:
            self.hosts = [config["agent_remote_stress_test"]["host"]]
        elif "hostfile" in config["agent_remote_stress_test"]:
            with open(config["agent_remote_stress_test"]["hostfile"]) as f:
                self.hosts = f.read().splitlines()

        self.vms_per_thread = int(config["agent_remote_stress_test"].get(
            "vms_per_thread", self.DEFAULT_VMS_PER_THREAD))
        self.threads_per_host = int(config["agent_remote_stress_test"].get(
            "threads_per_host", self.DEFAULT_THREADS_PER_HOST))
        self.place_to_create_ratio = int(
            config["agent_remote_stress_test"].get(
                "place_to_create_ratio", self.DEFAULT_PLACE_TO_CREATE_RATIO))
        self.clear()
Пример #18
0
def customize_compiler2(compiler):
    (cc, cxx, opt, cflags, ccshared, ldshared, so_ext) = \
         sysconfig.get_config_vars('CC', 'CXX', 'OPT', 'CFLAGS',
                                   'CCSHARED', 'LDSHARED', 'SO')

    if 0:
        print "cc=", cc
        print "cxx=", cxx
        print "opt=", opt
        print "cflags=", cflags
        print "ccshared=", ccshared

        
    cflags = cflags.replace("-DNDEBUG", "")
    cflags = cflags.replace("-O2", "")

    cpp = cc + " -E"
    cc_cmd = cc + ' ' + cflags

    compiler.set_executables(
        preprocessor=cpp,
        compiler=cc_cmd,
        compiler_so=cc_cmd + ' ' + ccshared,
        compiler_cxx=cxx,
        linker_so=ldshared,
        linker_exe=cc)

    compiler.shared_lib_extension = so_ext
    return
Пример #19
0
 def test_ext_fullpath(self):
     ext = sysconfig.get_config_vars()['SO']
     dist = Distribution()
     cmd = build_ext(dist)
     cmd.inplace = 1
     cmd.distribution.package_dir = {'': 'src'}
     cmd.distribution.packages = ['lxml', 'lxml.html']
     curdir = os.getcwd()
     wanted = os.path.join(curdir, 'src', 'lxml', 'etree' + ext)
     path = cmd.get_ext_fullpath('lxml.etree')
     self.assertEqual(wanted, path)
     cmd.inplace = 0
     cmd.build_lib = os.path.join(curdir, 'tmpdir')
     wanted = os.path.join(curdir, 'tmpdir', 'lxml', 'etree' + ext)
     path = cmd.get_ext_fullpath('lxml.etree')
     self.assertEqual(wanted, path)
     build_py = cmd.get_finalized_command('build_py')
     build_py.package_dir = {}
     cmd.distribution.packages = ['twisted', 'twisted.runner.portmap']
     path = cmd.get_ext_fullpath('twisted.runner.portmap')
     wanted = os.path.join(curdir, 'tmpdir', 'twisted', 'runner', 'portmap' + ext)
     self.assertEqual(wanted, path)
     cmd.inplace = 1
     path = cmd.get_ext_fullpath('twisted.runner.portmap')
     wanted = os.path.join(curdir, 'twisted', 'runner', 'portmap' + ext)
     self.assertEqual(wanted, path)
Пример #20
0
def UnixCCompiler__compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
    """Compile a single source files with a Unix-style compiler."""
    # HP ad-hoc fix, see ticket 1383
    ccomp = self.compiler_so
    if ccomp[0] == 'aCC':
        # remove flags that will trigger ANSI-C mode for aCC
        if '-Ae' in ccomp:
            ccomp.remove('-Ae')
        if '-Aa' in ccomp:
            ccomp.remove('-Aa')
        # add flags for (almost) sane C++ handling
        ccomp += ['-AA']
        self.compiler_so = ccomp
    # ensure OPT environment variable is read
    if 'OPT' in os.environ:
        from distutils.sysconfig import get_config_vars
        opt = " ".join(os.environ['OPT'].split())
        gcv_opt = " ".join(get_config_vars('OPT')[0].split())
        ccomp_s = " ".join(self.compiler_so)
        if opt not in ccomp_s:
            ccomp_s = ccomp_s.replace(gcv_opt, opt)
            self.compiler_so = ccomp_s.split()
        llink_s = " ".join(self.linker_so)
        if opt not in llink_s:
            self.linker_so = llink_s.split() + opt.split()

    display = '%s: %s' % (os.path.basename(self.compiler_so[0]), src)
    try:
        self.spawn(self.compiler_so + cc_args + [src, '-o', obj] +
                   extra_postargs, display = display)
    except DistutilsExecError:
        msg = str(get_exception())
        raise CompileError(msg)
Пример #21
0
def setup_install():
    'Perform the equivalent of "python setup.py install".'
    from distutils.core import setup, Extension
    from distutils.sysconfig import get_config_vars
    from ncptl_config import expanded_ncptl_config

    # Ensure we were passed the location of our input files.
    if len(sys.argv) < 3:
        abend('"install" requires the name of the top build directory')
    top_builddir = sys.argv[2]
    srcfile = os.path.abspath(os.path.join(top_builddir, "libncptl_wrap.c"))
    libdir = os.path.abspath(os.path.join(top_builddir, ".libs"))

    # Be sure to link with whatever libraries libncptl needs.
    linkargs = string.split(expanded_ncptl_config["LDFLAGS"] + " " + expanded_ncptl_config["LIBS"])

    # Use Python's distutils to install everything in a "conceptual" directory.
    distobj = setup(name='conceptual-python',
                    version=expanded_ncptl_config["PACKAGE_VERSION"],
                    script_args=["install"] + sys.argv[3:],
                    package_dir={"conceptual": top_builddir,
                                 "": top_builddir},
                    py_modules=["pyncptl", "conceptual.__init__"],
                    ext_modules=[Extension("conceptual._pyncptl",
                                           sources=[srcfile],
                                           extra_compile_args=get_config_vars("CCSHARED") + string.split(expanded_ncptl_config["CPPFLAGS"]),
                                           extra_link_args=linkargs + string.split(expanded_ncptl_config["LDFLAGS"]),
                                           library_dirs=[libdir],
                                           libraries=["ncptl"])])
Пример #22
0
    def build_extensions(self):
        import platform
        from distutils import sysconfig
        if (hasattr(self.compiler, 'compiler') and
                len(self.compiler.compiler) > 0):
            cc_name = self.compiler.compiler[0]
            stdcpp = '-std=c++11'
            if 'gcc' in cc_name and not _check_gcc_cpp11(cc_name):
                stdcpp = '-std=c++0x'
            for e in self.extensions:
                e.extra_compile_args.append(stdcpp)
                e.extra_compile_args.append('-Wno-deprecated-declarations')
                e.extra_compile_args.append('-Wno-unused-local-typedefs')
                e.extra_compile_args.append('-Wno-sign-compare')
                e.extra_compile_args.append('-Wno-self-assign')
                e.extra_compile_args.append('-Wno-macro-redefined')
                e.extra_compile_args.append('-Wno-unused-const-variable')

            conf_vars = sysconfig.get_config_vars()
            if 'MACOSX_DEPLOYMENT_TARGET' in conf_vars and len(conf_vars[
                    'MACOSX_DEPLOYMENT_TARGET']) > 0:
                _v1, _v2 = conf_vars['MACOSX_DEPLOYMENT_TARGET'].split('.')
                if int(_v1) == 10 and int(_v2) < 9:
                    stdcpp = '--stdlib=libc++'
                    for e in self.extensions:
                        e.extra_compile_args.append(stdcpp)
        build_ext.build_extensions(self)
Пример #23
0
    def test_ext_fullpath(self):
        ext = sysconfig.get_config_vars()["SO"]
        dist = Distribution()
        cmd = build_ext(dist)
        cmd.inplace = 1
        cmd.distribution.package_dir = {"": "src"}
        cmd.distribution.packages = ["lxml", "lxml.html"]
        curdir = os.getcwd()
        wanted = os.path.join(curdir, "src", "lxml", "etree" + ext)
        path = cmd.get_ext_fullpath("lxml.etree")
        self.assertEquals(wanted, path)

        # building lxml.etree not inplace
        cmd.inplace = 0
        cmd.build_lib = os.path.join(curdir, "tmpdir")
        wanted = os.path.join(curdir, "tmpdir", "lxml", "etree" + ext)
        path = cmd.get_ext_fullpath("lxml.etree")
        self.assertEquals(wanted, path)

        # building twisted.runner.portmap not inplace
        build_py = cmd.get_finalized_command("build_py")
        build_py.package_dir = {}
        cmd.distribution.packages = ["twisted", "twisted.runner.portmap"]
        path = cmd.get_ext_fullpath("twisted.runner.portmap")
        wanted = os.path.join(curdir, "tmpdir", "twisted", "runner", "portmap" + ext)
        self.assertEquals(wanted, path)

        # building twisted.runner.portmap inplace
        cmd.inplace = 1
        path = cmd.get_ext_fullpath("twisted.runner.portmap")
        wanted = os.path.join(curdir, "twisted", "runner", "portmap" + ext)
        self.assertEquals(wanted, path)
Пример #24
0
def my_init_posix():
  print('my_init_posix: changing gcc to g++')
  save_init_posix()
  g = sysconfig.get_config_vars()
  g['CC'] = 'g++'
  g['LDSHARED'] = 'g++ -shared'
  g['PY_CFLAGS'] = g['PY_CFLAGS'].replace('-O3', '')
Пример #25
0
    def run(self):
        verify_platform()

        if not self.use_system_libffi:
            for ext in self.extensions:
                if ext.name == 'objc._objc':
                    if ext.sources[:-len(FFI_SOURCE)] != FFI_SOURCE:
                        ext.sources.extend(FFI_SOURCE)
                        ext.extra_compile_args.extend(FFI_CFLAGS)

        if self.deployment_target is not None:
            os.environ['MACOSX_DEPLOYMENT_TARGET'] = self.deployment_target

        if self.sdk_root != 'python':
            if '-isysroot' not in CFLAGS:
                CFLAGS.extend(['-isysroot', self.sdk_root])
                EXT_CFLAGS.extend(['-isysroot', self.sdk_root])
                OBJC_LDFLAGS.extend(['-isysroot', self.sdk_root])


        cflags = get_config_var('CFLAGS')
        if '-mno-fused-madd' in cflags:
            cflags = cflags.replace('-mno-fused-madd', '')
            get_config_vars()['CFLAGS'] = cflags

        _fixup_compiler()

        build_ext.build_ext.run(self)
        extensions = self.extensions
        self.extensions = [
                e for e in extensions if e.name.startswith('PyObjCTest') ]
        self.copy_extensions_to_source()
        self.extensions = extensions
Пример #26
0
def main():
  # Use Makefile for windows. distutils doesn't work well with windows.
  if sys.platform == 'win32':
    pydll = ('C:\windows\system32\python%s.dll' %
             sysconfig.get_config_vars('VERSION')[0])
    os.system('make -f Makefile.win32 %s PY_HOME="%s" PY_DLL="%s"' %
              (' '.join(sys.argv[1:]), sys.prefix, pydll))
    return

  pacparser_module = Extension('_pacparser',
                               include_dirs = ['../spidermonkey/js/src', '..'],
                               sources = ['pacparser_py.c'],
                               extra_objects = ['../pacparser.o', '../libjs.a'])
  setup (name = 'pacparser',
         version = '1',
         description = 'Pacparser package',
         author = 'Manu Garg',
         author_email = '*****@*****.**',
         url = 'http://code.google.com/p/pacparser',
         long_description = 'python library to parse proxy auto-config (PAC) '
                           'files.',
         license = 'LGPL',
         ext_package = 'pacparser',
         ext_modules = [pacparser_module],
         py_modules = ['pacparser.__init__'])
Пример #27
0
        def run(self):
            here = os.path.abspath(os.getcwd())
            from distutils import sysconfig

            config = sysconfig.get_config_vars()
            try:
                restore = senv(("CFLAGS", config["CFLAGS"]), ("LDFLAGS", config["LDFLAGS"]))
                try:
                    os.chdir(LRMQDIST())
                    if not os.path.isfile("config.h"):
                        print("- configure rabbitmq-c...")
                        os.system(CMD_CONFIGURE)
                    # print('- make rabbitmq-c...')
                    # os.chdir(LRMQSRC())
                    # os.system(''%s' all' % find_make())
                finally:
                    os.environ.update(restore)
            finally:
                os.chdir(here)
            restore = senv(
                # ('LDFLAGS', ' '.join(glob(LRMQSRC('*.o')))),
                ("CFLAGS", " ".join(self.stdcflags))
            )
            codegen()
            try:
                _build.run(self)
            finally:
                os.environ.update(restore)
Пример #28
0
 def run(self):
     here = os.path.abspath(os.getcwd())
     H = lambda *x: os.path.join(here, *x)
     from distutils import sysconfig
     config = sysconfig.get_config_vars()
     try:
         restore = senv(('CFLAGS', config['CFLAGS']),
             ('LDFLAGS', config['LDFLAGS']))
         try:
             os.chdir(LRMQDIST())
             if not os.path.isfile('config.h'):
                 print('- configure rabbitmq-c...')
                 os.system('/bin/sh configure --disable-tools \
                            --disable-docs --disable-dependency-tracking')
             #print('- make rabbitmq-c...')
             #os.chdir(LRMQSRC())
             #os.system(''%s' all' % find_make())
         finally:
             os.environ.update(restore)
     finally:
         os.chdir(here)
     restore = senv(
         #('LDFLAGS', ' '.join(glob(LRMQSRC('*.o')))),
         ('CFLAGS', ' '.join(self.stdcflags)),
     )
     codegen()
     try:
         _build.run(self)
     finally:
         os.environ.update(restore)
Пример #29
0
 def test_get_python_inc(self):
     # The check for srcdir is copied from Python's setup.py,
     # and is necessary to make this test pass when building
     # Python in a directory other than the source directory.
     (srcdir,) = sysconfig.get_config_vars('srcdir')
     if not srcdir:
         inc_dir = sysconfig.get_python_inc()
     else:
         # This test is not really a proper test: when building
         # Python from source, even in the same directory,
         # we won't be testing the same thing as when running
         # distutils' tests on an installed Python. Nevertheless,
         # let's try to do our best: if we are running Python's
         # unittests from a build directory that is not the source
         # directory, the normal inc_dir will exist, it will just not
         # contain anything of interest.
         inc_dir = sysconfig.get_python_inc()
         self.assert_(os.path.isdir(inc_dir))
         # Now test the source location, to make sure Python.h does
         # exist.
         inc_dir = os.path.join(os.getcwd(), srcdir, 'Include')
         inc_dir = os.path.normpath(inc_dir)
     self.assert_(os.path.isdir(inc_dir), inc_dir)
     python_h = os.path.join(inc_dir, "Python.h")
     self.assert_(os.path.isfile(python_h), python_h)
Пример #30
0
 def run(self):
     here = os.path.abspath(os.getcwd())
     H = lambda *x: os.path.join(here, *x)
     from distutils import sysconfig
     config = sysconfig.get_config_vars()
     try:
         restore = senv(("CFLAGS", config["CFLAGS"]),
             ("LDFLAGS", config["LDFLAGS"]))
         try:
             os.chdir(LRMQDIST())
             if not os.path.isfile("config.h"):
                 print("- configure rabbitmq-c...")
                 os.system("/bin/sh configure --disable-dependency-tracking")
             #print("- make rabbitmq-c...")
             #os.chdir(LRMQSRC())
             #os.system('"%s" all' % find_make())
         finally:
             os.environ.update(restore)
     finally:
         os.chdir(here)
     restore = senv(
         #("LDFLAGS", ' '.join(glob(LRMQSRC("*.o")))),
         ("CFLAGS", ' '.join(self.stdcflags)),
     )
     codegen()
     try:
         _build.run(self)
     finally:
         os.environ.update(restore)
Пример #31
0
        readme_content = ""
finally:
    f.close()

PY3 = sys.version_info[0] == 3

# PYTHON-654 - Clang doesn't support -mno-fused-madd but the pythons Apple
# ships are built with it. This is a problem starting with Xcode 5.1
# since clang 3.4 errors out when it encounters unrecognized compiler
# flags. This hack removes -mno-fused-madd from the CFLAGS automatically
# generated by distutils for Apple provided pythons, allowing C extension
# builds to complete without error. The inspiration comes from older
# versions of distutils.sysconfig.get_config_vars.
if sys.platform == 'darwin' and 'clang' in platform.python_compiler().lower():
    from distutils.sysconfig import get_config_vars
    res = get_config_vars()
    for key in ('CFLAGS', 'PY_CFLAGS'):
        if key in res:
            flags = res[key]
            flags = re.sub('-mno-fused-madd', '', flags)
            res[key] = flags

nose_config_options = {
    'with-xunit': '1',    # Write out nosetests.xml for CI.
    'py3where': 'build',  # Tell nose where to find tests under PY3.
}

def write_nose_config():
    """Write out setup.cfg. Since py3where has to be set
    for tests to run correctly in Python 3 we create this
    on the fly.
Пример #32
0
    def run(self):
        if use_system():
            return

        # use Python's build environment variables
        build_env = {key: val for key, val in
                     get_config_vars().items() if key in
                     ("LDFLAGS", "CFLAGS", "CC", "CCSHARED", "LDSHARED") and
                     key not in os.environ}
        os.environ.update(build_env)

        # Ensure our temporary build directory exists
        build_temp = os.path.abspath(self.build_temp)
        try:
            os.makedirs(build_temp)
        except OSError as e:
            if e.errno != errno.EEXIST:
                raise

        # Ensure all of our executable files have their permission set
        for filename in [
                "src/libsodium/autogen.sh",
                "src/libsodium/compile",
                "src/libsodium/configure",
                "src/libsodium/depcomp",
                "src/libsodium/install-sh",
                "src/libsodium/missing",
                "src/libsodium/msvc-scripts/process.bat",
                "src/libsodium/test/default/wintest.bat"]:
            os.chmod(here(filename), 0o755)

        if not which("make"):
            raise Exception("ERROR: The 'make' utility is missing from PATH")

        # Locate our configure script
        configure = abshere("src/libsodium/configure")

        # Run ./configure
        configure_flags = ["--disable-shared", "--enable-static",
                           "--disable-debug", "--disable-dependency-tracking",
                           "--with-pic"]
        if platform.system() == "SunOS":
            # On Solaris, libssp doesn't link statically and causes linker
            # errors during import
            configure_flags.append("--disable-ssp")
        if os.environ.get('SODIUM_INSTALL_MINIMAL'):
            configure_flags.append("--enable-minimal")
        subprocess.check_call(
            [configure] + configure_flags +
            ["--prefix", os.path.abspath(self.build_clib)],
            cwd=build_temp,
        )

        make_args = os.environ.get('LIBSODIUM_MAKE_ARGS', '').split()
        # Build the library
        subprocess.check_call(["make"] + make_args, cwd=build_temp)

        # Check the build library
        subprocess.check_call(["make", "check"] + make_args, cwd=build_temp)

        # Install the built library
        subprocess.check_call(["make", "install"] + make_args, cwd=build_temp)
Пример #33
0
#
# Adjust distutils CFLAGS:
#
# - PyObjC won't work when compiled with -O0
# - To make it easier to debug reduce optimization level
#   to -O1 when building with a --with-pydebug build of Python
# - Set optimization to -O4 with normal builds of Python,
#   enables link-time optimization with clang and appears to
#   be (slightly) faster.
#

if "-O0" in get_config_var("CFLAGS"):
    # -O0 doesn't work with some (older?) compilers, unconditionally
    # change -O0 to -O1 to work around that issue.
    print("Change -O0 to -O1 (-O0 miscompiles libffi)")
    config_vars = get_config_vars()
    for k in config_vars:
        if isinstance(config_vars[k], str) and "-O0" in config_vars[k]:
            config_vars[k] = config_vars[k].replace("-O0", "-O1")

if get_config_var("Py_DEBUG"):
    # Running with Py_DEBUG, reduce optimization level
    # to make it easier to debug the code.
    cfg_vars = get_config_vars()
    for k in cfg_vars:
        if isinstance(cfg_vars[k], str) and "-O2" in cfg_vars[k]:
            cfg_vars[k] = cfg_vars[k].replace("-O2", "-O1 -g")
        elif isinstance(cfg_vars[k], str) and "-O3" in cfg_vars[k]:
            cfg_vars[k] = cfg_vars[k].replace("-O3", "-O1 -g")

else:
Пример #34
0
 def test_SO_in_vars(self):
     vars = sysconfig.get_config_vars()
     self.assertIsNotNone(vars['SO'])
     self.assertEqual(vars['SO'], vars['EXT_SUFFIX'])
Пример #35
0
    def configure_step(self):
        """Configure Python package build/install."""

        if self.python_cmd is None:
            self.prepare_python()

        if self.sitecfg is not None:
            # used by some extensions, like numpy, to find certain libs

            finaltxt = self.sitecfg
            if self.sitecfglibdir:
                repl = self.sitecfglibdir
                finaltxt = finaltxt.replace('SITECFGLIBDIR', repl)

            if self.sitecfgincdir:
                repl = self.sitecfgincdir
                finaltxt = finaltxt.replace('SITECFGINCDIR', repl)

            self.log.debug("Using %s: %s" % (self.sitecfgfn, finaltxt))
            try:
                if os.path.exists(self.sitecfgfn):
                    txt = open(self.sitecfgfn).read()
                    self.log.debug("Found %s: %s" % (self.sitecfgfn, txt))
                config = open(self.sitecfgfn, 'w')
                config.write(finaltxt)
                config.close()
            except IOError:
                raise EasyBuildError("Creating %s failed", self.sitecfgfn)

        # ensure that LDSHARED uses CC
        if self.cfg.get('check_ldshared', False):
            curr_cc = os.getenv('CC')
            python_ldshared = get_config_vars('LDSHARED')[0]
            if python_ldshared and curr_cc:
                if python_ldshared.split(' ')[0] == curr_cc:
                    self.log.info(
                        "Python's value for $LDSHARED ('%s') uses current $CC value ('%s'), not touching it",
                        python_ldshared, curr_cc)
                else:
                    self.log.info(
                        "Python's value for $LDSHARED ('%s') doesn't use current $CC value ('%s'), fixing",
                        python_ldshared, curr_cc)
                    env.setvar("LDSHARED", curr_cc + " -shared")
            else:
                if curr_cc:
                    self.log.info(
                        "No $LDSHARED found for Python, setting to '%s -shared'",
                        curr_cc)
                    env.setvar("LDSHARED", curr_cc + " -shared")
                else:
                    self.log.info(
                        "No value set for $CC, so not touching $LDSHARED either"
                    )

        # creates log entries for python being used, for debugging
        run_cmd("%s -V" % self.python_cmd, verbose=False, trace=False)
        run_cmd("%s -c 'import sys; print(sys.executable)'" % self.python_cmd,
                verbose=False,
                trace=False)

        # don't add user site directory to sys.path (equivalent to python -s)
        # see https://www.python.org/dev/peps/pep-0370/
        env.setvar('PYTHONNOUSERSITE', '1', verbose=False)
        run_cmd("%s -c 'import sys; print(sys.path)'" % self.python_cmd,
                verbose=False,
                trace=False)
Пример #36
0
    def finalize_options(self):
        """Finalizes options."""
        # This method (and its helpers, like 'finalize_unix()',
        # 'finalize_other()', and 'select_scheme()') is where the default
        # installation directories for modules, extension modules, and
        # anything else we care to install from a Python module
        # distribution.  Thus, this code makes a pretty important policy
        # statement about how third-party stuff is added to a Python
        # installation!  Note that the actual work of installation is done
        # by the relatively simple 'install_*' commands; they just take
        # their orders from the installation directory options determined
        # here.

        # Check for errors/inconsistencies in the options; first, stuff
        # that's wrong on any platform.

        if ((self.prefix or self.exec_prefix or self.home)
                and (self.install_base or self.install_platbase)):
            raise DistutilsOptionError(
                "must supply either prefix/exec-prefix/home or " +
                "install-base/install-platbase -- not both")

        if self.home and (self.prefix or self.exec_prefix):
            raise DistutilsOptionError(
                "must supply either home or prefix/exec-prefix -- not both")

        if self.user and (self.prefix or self.exec_prefix or self.home
                          or self.install_base or self.install_platbase):
            raise DistutilsOptionError(
                "can't combine user with prefix, "
                "exec_prefix/home, or install_(plat)base")

        # Next, stuff that's wrong (or dubious) only on certain platforms.
        if os.name != "posix":
            if self.exec_prefix:
                self.warn("exec-prefix option ignored on this platform")
                self.exec_prefix = None

        # Now the interesting logic -- so interesting that we farm it out
        # to other methods.  The goal of these methods is to set the final
        # values for the install_{lib,scripts,data,...}  options, using as
        # input a heady brew of prefix, exec_prefix, home, install_base,
        # install_platbase, user-supplied versions of
        # install_{purelib,platlib,lib,scripts,data,...}, and the
        # INSTALL_SCHEME dictionary above.  Phew!

        self.dump_dirs("pre-finalize_{unix,other}")

        if os.name == 'posix':
            self.finalize_unix()
        else:
            self.finalize_other()

        self.dump_dirs("post-finalize_{unix,other}()")

        # Expand configuration variables, tilde, etc. in self.install_base
        # and self.install_platbase -- that way, we can use $base or
        # $platbase in the other installation directories and not worry
        # about needing recursive variable expansion (shudder).

        py_version = sys.version.split()[0]
        (prefix, exec_prefix) = get_config_vars('prefix', 'exec_prefix')
        try:
            abiflags = sys.abiflags
        except AttributeError:
            # sys.abiflags may not be defined on all platforms.
            abiflags = ''
        self.config_vars = {
            'dist_name': self.distribution.get_name,
            'dist_version': self.distribution.get_version(),
            'dist_fullname': self.distribution.get_fullname(),
            'py_version': py_version,
            'py_version_short': '%d.%d' % sys.version_info[:2],
            'py_version_nodot': '%d%d' % sys.version_info[:2],
            'sys_prefix': prefix,
            'prefix': prefix,
            'sys_exec_prefix': exec_prefix,
            'exec_prefix': exec_prefix,
            'abiflags': abiflags,
            'platlibdir': getattr(sys, 'platlibdir', 'lib'),
        }

        if HAS_USER_SITE:
            self.config_vars['userbase'] = self.install_userbase
            self.config_vars['usersite'] = self.install_usersite

        self.expand_basedirs()

        self.dump_dirs("post-expand_basedirs()")

        # Now define config vars for the base directories so we can expand
        # everything else.
        self.config_vars['base'] = self.install_base
        self.config_vars['platbase'] = self.install_platbase

        if DEBUG:
            from pprint import pprint
            print("config vars:")
            pprint(self.config_vars)

        # Expand "~" and configuration variables in the installation
        # directories.
        self.expand_dirs()

        self.dump_dirs("post-expand_dirs()")

        # Create directories in the home dir:
        if self.user:
            self.create_home_path()

        # Pick the actual directory to install all modules to: either
        # install_purelib or install_platlib, depending on whether this
        # module distribution is pure or not.  Of course, if the user
        # already specified install_lib, use their selection.
        if self.install_lib is None:
            if self.distribution.ext_modules:  # has extensions: non-pure
                self.install_lib = self.install_platlib
            else:
                self.install_lib = self.install_purelib

        # Convert directories from Unix /-separated syntax to the local
        # convention.
        self.convert_paths('lib', 'purelib', 'platlib', 'scripts', 'data',
                           'headers', 'userbase', 'usersite')

        # Deprecated
        # Well, we're not actually fully completely finalized yet: we still
        # have to deal with 'extra_path', which is the hack for allowing
        # non-packagized module distributions (hello, Numerical Python!) to
        # get their own directories.
        self.handle_extra_path()
        self.install_libbase = self.install_lib  # needed for .pth file
        self.install_lib = os.path.join(self.install_lib, self.extra_dirs)

        # If a new root directory was supplied, make all the installation
        # dirs relative to it.
        if self.root is not None:
            self.change_roots('libbase', 'lib', 'purelib', 'platlib',
                              'scripts', 'data', 'headers')

        self.dump_dirs("after prepending root")

        # Find out the build directories, ie. where to install from.
        self.set_undefined_options('build', ('build_base', 'build_base'),
                                   ('build_lib', 'build_lib'))
Пример #37
0
import sys
import os

from distutils.core import setup
from distutils.extension import Extension
from Cython.Distutils import build_ext
from numpy.distutils.system_info import default_include_dirs, default_lib_dirs

from distutils.sysconfig import get_config_vars

if sys.platform == 'win32':
    libraries = ["arb", "flint", "mpir", "mpfr", "pthreads"]
else:
    libraries = ["arb", "flint"]
    (opt, ) = get_config_vars('OPT')
    os.environ['OPT'] = " ".join(flag for flag in opt.split()
                                 if flag != '-Wstrict-prototypes')

default_include_dirs += [
    os.path.join(d, "flint") for d in default_include_dirs
]

ext_modules = [
    Extension("flint._flint", ["src/flint/pyflint.pyx"],
              libraries=libraries,
              library_dirs=default_lib_dirs,
              include_dirs=default_include_dirs)
]

for e in ext_modules:
    e.cython_directives = {"embedsignature": True}
Пример #38
0
    # No information available
    print "none"
    sys.exit(1)

if sys.argv[1] == '--includes':
    inc = sysconfig.get_python_inc()
    plat = sysconfig.get_python_inc(plat_specific=1)
    if inc == plat:
        print "-I" + inc
    else:
        print "-I%s -I%s" % (inc, plat)
    sys.exit(0)

if sys.argv[1] == '--compile':
    cc, basecflags, opt, ccshared = \
        sysconfig.get_config_vars('CC', 'BASECFLAGS', 'OPT', 'CCSHARED')
    if basecflags:
        opt = basecflags + ' ' + opt
    print cc, opt, ccshared
    sys.exit(0)


def add_option(options, name, value=None):
    """Add option to list of options"""
    options.append(name)
    if value is not None:
        options.append(value)


def add_option_if_missing(options, name, value=None):
    """Add option to list of options, if it is not already present"""
Пример #39
0
class CompilerDetection(object):
    # Necessary for OSX. See https://github.com/SimTk/mdtraj/issues/576
    # The problem is that distutils.sysconfig.customize_compiler()
    # is necessary to properly invoke the correct compiler for this class
    # (otherwise the CC env variable isn't respected). Unfortunately,
    # distutils.sysconfig.customize_compiler() DIES on OSX unless some
    # appropriate initialization routines have been called. This line
    # has a side effect of calling those initialzation routes, and is therefor
    # necessary for OSX, even though we don't use the result.
    _DONT_REMOVE_ME = get_config_vars()

    def __init__(self, disable_openmp):
        cc = new_compiler()
        customize_compiler(cc)

        self.msvc = cc.compiler_type == 'msvc'
        self._print_compiler_version(cc)

        if disable_openmp:
            self.openmp_enabled = False
        else:
            self.openmp_enabled, openmp_needs_gomp = self._detect_openmp()
        self.sse3_enabled = self._detect_sse3() if not self.msvc else True
        self.sse41_enabled = self._detect_sse41() if not self.msvc else True

        self.compiler_args_sse2 = ['-msse2'
                                   ] if not self.msvc else ['/arch:SSE2']
        self.compiler_args_sse3 = ['-mssse3'] if (self.sse3_enabled
                                                  and not self.msvc) else []

        self.compiler_args_sse41, self.define_macros_sse41 = [], []
        if self.sse41_enabled:
            self.define_macros_sse41 = [('__SSE4__', 1), ('__SSE4_1__', 1)]
            if not self.msvc:
                self.compiler_args_sse41 = ['-msse4']

        if self.openmp_enabled:
            self.compiler_libraries_openmp = ['gomp'
                                              ] if openmp_needs_gomp else []

            if self.msvc:
                self.compiler_args_openmp = ['/openmp']
            else:
                self.compiler_args_openmp = ['-fopenmp']
        else:
            self.compiler_libraries_openmp = []
            self.compiler_args_openmp = []

        if self.msvc:
            self.compiler_args_opt = ['/O2']
        else:
            self.compiler_args_opt = ['-O3', '-funroll-loops']
        print()

    def _print_compiler_version(self, cc):
        print("C compiler:")
        if self.msvc:
            if not cc.initialized:
                cc.initialize()
            cc.spawn([cc.cc])
        else:
            cc.spawn([cc.compiler[0]] + ['-v'])

    def hasfunction(self, cc, funcname, include=None, extra_postargs=None):
        # From http://stackoverflow.com/questions/
        #            7018879/disabling-output-when-compiling-with-distutils
        tmpdir = tempfile.mkdtemp(prefix='hasfunction-')
        devnull = oldstderr = None
        try:
            try:
                fname = os.path.join(tmpdir, 'funcname.c')
                f = open(fname, 'w')
                if include is not None:
                    f.write('#include %s\n' % include)
                f.write('int main(void) {\n')
                f.write('    %s;\n' % funcname)
                f.write('}\n')
                f.close()
                devnull = open(os.devnull, 'w')
                oldstderr = os.dup(sys.stderr.fileno())
                os.dup2(devnull.fileno(), sys.stderr.fileno())
                objects = cc.compile([fname],
                                     output_dir=tmpdir,
                                     extra_postargs=extra_postargs)
                cc.link_executable(objects, os.path.join(tmpdir, 'a.out'))
            except Exception as e:
                return False
            return True
        finally:
            if oldstderr is not None:
                os.dup2(oldstderr, sys.stderr.fileno())
            if devnull is not None:
                devnull.close()
            shutil.rmtree(tmpdir)

    def _print_support_start(self, feature):
        print('Attempting to autodetect {0:6} support...'.format(feature),
              end=' ')

    def _print_support_end(self, feature, status):
        if status is True:
            print('Compiler supports {0}'.format(feature))
        else:
            print('Did not detect {0} support'.format(feature))

    def _detect_openmp(self):
        self._print_support_start('OpenMP')
        compiler = new_compiler()
        customize_compiler(compiler)
        hasopenmp = self.hasfunction(compiler,
                                     'omp_get_num_threads()',
                                     extra_postargs=['-fopenmp', '/openmp'])
        needs_gomp = hasopenmp
        if not hasopenmp:
            compiler.add_library('gomp')
            hasopenmp = self.hasfunction(compiler, 'omp_get_num_threads()')
            needs_gomp = hasopenmp
        self._print_support_end('OpenMP', hasopenmp)
        return hasopenmp, needs_gomp

    def _detect_sse3(self):
        "Does this compiler support SSE3 intrinsics?"
        compiler = new_compiler()
        customize_compiler(compiler)
        self._print_support_start('SSE3')
        result = self.hasfunction(compiler,
                                  '__m128 v; _mm_hadd_ps(v,v)',
                                  include='<pmmintrin.h>',
                                  extra_postargs=['-msse3'])
        self._print_support_end('SSE3', result)
        return result

    def _detect_sse41(self):
        "Does this compiler support SSE4.1 intrinsics?"
        compiler = new_compiler()
        customize_compiler(compiler)
        self._print_support_start('SSE4.1')
        result = self.hasfunction(compiler,
                                  '__m128 v; _mm_round_ps(v,0x00)',
                                  include='<smmintrin.h>',
                                  extra_postargs=['-msse4'])
        self._print_support_end('SSE4.1', result)
        return result
Пример #40
0
import numpy as np
import os
import platform
import warnings


# Import shared libgse2
# create library names
lib_names = [
     # platform specific library name
    'libgse2-%s-%s-py%s' % (platform.system(), platform.architecture()[0],
        ''.join([str(i) for i in platform.python_version_tuple()[:2]])),
     # fallback for pre-packaged libraries
    'libgse2']
# get default file extension for shared objects
lib_extension, = sysconfig.get_config_vars('SO')
# initialize library
clibgse2 = None
for lib_name in lib_names:
    try:
        clibgse2 = C.CDLL(os.path.join(os.path.dirname(__file__), 'lib',
                                       lib_name + lib_extension))
    except Exception, e:
        pass
    else:
        break
if not clibgse2:
    msg = 'Could not load shared library for obspy.gse2.\n\n %s' % (e)
    raise ImportError(msg)

Пример #41
0
        extra_link_args.append("/DEBUG")
else:
    # args to ignore warnings
    extra_compile_args = []
    extra_link_args = []
    if debugging_symbols_requested:
        extra_compile_args.append("-g")

# Build for at least macOS 10.9 when compiling on a 10.9 system or above,
# overriding CPython distuitls behaviour which is to target the version that
# python was built for. This may be overridden by setting
# MACOSX_DEPLOYMENT_TARGET before calling setup.py
if is_platform_mac():
    if "MACOSX_DEPLOYMENT_TARGET" not in os.environ:
        current_system = platform.mac_ver()[0]
        python_target = get_config_vars().get("MACOSX_DEPLOYMENT_TARGET",
                                              current_system)
        if (LooseVersion(python_target) < "10.9"
                and LooseVersion(current_system) >= "10.9"):
            os.environ["MACOSX_DEPLOYMENT_TARGET"] = "10.9"

# enable coverage by building cython files by setting the environment variable
# "PANDAS_CYTHON_COVERAGE" (with a Truthy value) or by running build_ext
# with `--with-cython-coverage`enabled
linetrace = os.environ.get("PANDAS_CYTHON_COVERAGE", False)
if "--with-cython-coverage" in sys.argv:
    linetrace = True
    sys.argv.remove("--with-cython-coverage")

# Note: if not using `cythonize`, coverage can be enabled by
# pinning `ext.cython_directives = directives` to each ext in extensions.
# github.com/cython/cython/wiki/enhancements-compilerdirectives#in-setuppy
Пример #42
0
    sopt = '-%s' % sopt
    if lopt in sys.argv:
        sys.argv.remove(lopt)
    elif sopt in sys.argv:
        sys.argv.remove(sopt)
        sys.argv.remove(specsrc)
except:
    pass

print("Compiling datashm python module - Using sps.c source from", specsrc)

if platform.system() == 'Darwin':
    # ALL default compiler / linker options come from _sysconfigdata

    from distutils.sysconfig import get_config_vars
    get_config_vars(
        "CFLAGS")  # need to call get_config_vars once to populate _config_vars
    from distutils.sysconfig import _config_vars
    # 'CCSHARED': '-arch x86_64 -arch i386 -pipe',
    _config_vars['CCSHARED'] = '-arch x86_64 -pipe'
    # 'LDSHARED': 'cc -bundle -undefined dynamic_lookup -arch x86_64 -arch i386 -Wl,-F.',
    _config_vars[
        'LDSHARED'] = '/usr/bin/clang -bundle -undefined dynamic_lookup -arch x86_64 -Wl,-F.'
    #_config_vars.build_time_vars['OPT']='-DNDEBUG -g -fwrapv -Os -Wall -Wstrict-prototypes'
    _config_vars['OPT'] = '-DNDEBUG -g -fwrapv -Os -Wall -Wstrict-prototypes'

    from os import environ

    environ['CFLAGS'] = '-Qunused-arguments'  #  appended to CFLAGS or CCSHARED
    #environ['BASECFLAGS'] = ''
    #environ['OPT'] = ''
Пример #43
0
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 = configdir.join("module_cache").ensure(dir=1)
    num = 0
    cfiles += eci.separate_module_files
    include_dirs = list(eci.include_dirs)
    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)
Пример #44
0
def _fixup_compiler(use_ccache):
    if "CC" in os.environ:
        # CC is in the environment, always use explicit
        # overrides.
        return

    try:
        # Newer version of python have support for dealing with
        # the compiler mess w.r.t. various versions of Apple's SDKs
        import _osx_support

        _osx_support.customize_compiler(get_config_vars())
    except (ImportError, AttributeError, KeyError):
        pass

    cc = oldcc = get_config_var("CC").split()[0]
    cc = _find_executable(cc)
    if cc is not None and os.path.basename(cc).startswith("gcc"):
        # Check if compiler is LLVM-GCC, that's known to
        # generate bad code.
        with os.popen("'%s' --version 2>/dev/null" %
                      (cc.replace("'", "'\"'\"'"), )) as fp:
            data = fp.read()
        if "llvm-gcc" in data:
            cc = None

    if cc is not None and not _working_compiler(cc):

        cc = None

    if cc is None:
        # Default compiler is not useable, try finding 'clang'
        cc = _find_executable("clang")
        if cc is None:
            cc = os.popen("/usr/bin/xcrun -find clang").read()

    if not cc:
        raise DistutilsPlatformError("Cannot locate compiler candidate")

    if not _working_compiler(cc):
        raise DistutilsPlatformError("Cannot locate a working compiler")

    if use_ccache:
        p = _find_executable("ccache")
        if p is not None:
            log.info("Detected and using 'ccache'")
            cc = "%s %s" % (p, cc)

    if cc != oldcc:
        log.info("Use '%s' instead of '%s' as the compiler" % (cc, oldcc))

        config_vars = get_config_vars()
        for env in ("BLDSHARED", "LDSHARED", "CC", "CXX"):
            if env in config_vars and env not in os.environ:
                split = config_vars[env].split()
                split[0] = cc if env != "CXX" else cc + "++"
                config_vars[env] = " ".join(split)

    cflags = get_config_var("CFLAGS")
    if re.search(r"-arch\s+i386", cflags) is not None:
        raise DistutilsPlatformError(
            "i386 (32-bit) is not supported by PyObjC")

    if re.search(r"-arch\s+ppc", cflags) is not None:
        raise DistutilsPlatformError("PowerPC is not supported by PyObjC")
Пример #45
0
def get_platform():
    """Return a string that identifies the current platform.  This is used
    mainly to distinguish platform-specific build directories and
    platform-specific built distributions.  Typically includes the OS name
    and version and the architecture (as supplied by 'os.uname()'),
    although the exact information included depends on the OS; eg. for IRIX
    the architecture isn't particularly important (IRIX only runs on SGI
    hardware), but for Linux the kernel version isn't particularly
    important.

    Examples of returned values:
       linux-i586
       linux-alpha (?)
       solaris-2.6-sun4u
       irix-5.3
       irix64-6.2

    For non-POSIX platforms, currently just returns 'sys.platform'.
    """
    if os.name != "posix" or not hasattr(os, 'uname'):
        # XXX what about the architecture? NT is Intel or Alpha,
        # Mac OS is M68k or PPC, etc.
        return sys.platform

    # Try to distinguish various flavours of Unix

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

    # Convert the OS name to lowercase, remove '/' characters
    # (to accommodate BSD/OS), and translate spaces (for "Power Macintosh")
    osname = string.lower(osname)
    osname = string.replace(osname, '/', '')
    machine = string.replace(machine, ' ', '_')
    machine = string.replace(machine, '/', '-')

    if osname[:5] == "linux":
        # At least on Linux/Intel, 'machine' is the processor --
        # i386, etc.
        # XXX what about Alpha, SPARC, etc?
        return "%s-%s" % (osname, machine)
    elif osname[:5] == "sunos":
        if release[0] >= "5":  # SunOS 5 == Solaris 2
            osname = "solaris"
            release = "%d.%s" % (int(release[0]) - 3, release[2:])
        # fall through to standard osname-release-machine representation
    elif osname[:4] == "irix":  # could be "irix64"!
        return "%s-%s" % (osname, release)
    elif osname[:3] == "aix":
        return "%s-%s.%s" % (osname, version, release)
    elif osname[:6] == "cygwin":
        osname = "cygwin"
        rel_re = re.compile(r'[\d.]+')
        m = rel_re.match(release)
        if m:
            release = m.group()
    elif osname[:6] == "darwin":
        #
        # For our purposes, we'll assume that the system version from
        # distutils' perspective is what MACOSX_DEPLOYMENT_TARGET is set
        # to. This makes the compatibility story a bit more sane because the
        # machine is going to compile and link as if it were
        # MACOSX_DEPLOYMENT_TARGET.
        from distutils.sysconfig import get_config_vars
        cfgvars = get_config_vars()

        macver = os.environ.get('MACOSX_DEPLOYMENT_TARGET')
        if not macver:
            macver = cfgvars.get('MACOSX_DEPLOYMENT_TARGET')

        if not macver:
            # Get the system version. Reading this plist is a documented
            # way to get the system version (see the documentation for
            # the Gestalt Manager)
            try:
                f = open('/System/Library/CoreServices/SystemVersion.plist')
            except IOError:
                # We're on a plain darwin box, fall back to the default
                # behaviour.
                pass
            else:
                m = re.search(
                    r'<key>ProductUserVisibleVersion</key>\s*' +
                    r'<string>(.*?)</string>', f.read())
                f.close()
                if m is not None:
                    macver = '.'.join(m.group(1).split('.')[:2])
                # else: fall back to the default behaviour

        if macver:
            from distutils.sysconfig import get_config_vars
            release = macver
            osname = 'macosx'
            platver = os.uname()[2]
            osmajor = int(platver.split('.')[0])

            if osmajor >= 8 and \
                    get_config_vars().get('UNIVERSALSDK', '').strip():
                # The universal build will build fat binaries, but not on
                # systems before 10.4
                machine = 'fat'

            elif machine in ('PowerPC', 'Power_Macintosh'):
                # Pick a sane name for the PPC architecture
                machine = 'ppc'

    return "%s-%s-%s" % (osname, release, machine)
Пример #46
0
 def test_get_config_vars(self):
     cvars = sysconfig.get_config_vars()
     self.assertIsInstance(cvars, dict)
     self.assertTrue(cvars)
Пример #47
0
    def run(self):

        # Get the names of library files Name of shared object
        # library, and ensure -bundle isn't called in linking on osx.
        libtype = 'shared'
        rdirs = ['$ORIGIN']
        ldirs = []
        ext_runtime_library_dirs = '$ORIGIN/{}'
        ext_extra_link_args = None
        osx = None
        if 'osx' in self.plat_name or 'darwin' in self.plat_name:
            osx = True
            print('\n\nBuilding under OSX!\n\n\n')
            libtype = 'dylib'
            from distutils import sysconfig
            vars = sysconfig.get_config_vars()
            vars['LDSHARED'] = vars['LDSHARED'].replace(
                '-bundle', '-dynamiclib')
            rdirs = []
            ldirs = ['-Wl,-rpath,'+'@loader_path/']
            ldirs = []
            ext_runtime_library_dirs = None
            ext_extra_link_args = '-Wl,-rpath,@loader_path/{}'
            install_name_pattern = '-Wl,-install_name,@rpath/{}'

        # Ensure the directories and files are in appropriate locations.
        setup_building()

        # Before we can build the extensions, we have to run ./configure
        # and make for HDF5.
        basedir = os.getcwd()
        os.chdir('hdf5')
        env = os.environ
        if not FAKEBUILDING:
            subprocess.check_call('./configure', env=env)
            subprocess.check_call('make', env=env)
        os.chdir(basedir)

        # Now we need to get the header files we need copied into our
        # output directory.
        if not os.path.isdir('include'):
            os.mkdir('include')
        if not os.path.isdir(os.path.join('include', 'star')):
            os.mkdir(os.path.join('include', 'star'))

        # Copy hdf5 needed header files over.
        shutil.copy(os.path.join('hdf5', 'src', 'hdf5.h'), 'include')
        shutil.copy(os.path.join('hdf5', 'src', 'H5public.h'), 'include')
        shutil.copy(os.path.join('hdf5', 'src', 'H5pubconf.h'), 'include')
        shutil.copy(os.path.join('hdf5', 'src', 'H5version.h'), 'include')

        # Get the sources for the ndf and hds dependencies.
        hds_source_dep = []
        for name_ in HDS_DEP_LIBS:
            hds_source_dep += get_source(name_)

        ndf_source_dep = []
        for name_ in ['prm', 'ast', 'ary']:
            ndf_source_dep += get_source(name_)

        hdsex_includedirs = [
            'include', 'hds', 'missingincludes', 'hds_missingincludes',
            os.path.join('hdf5', 'src'),
            os.path.join('hdf5', 'hl', 'src'),
            'starutil', 'starmem', 'cnf', 'ems', 'mers', 'chr', 'one',
            numpy.get_include()
            ]

        from starlink import Ast
        ndfex_includedirs = hdsex_includedirs + \
            ['prm', 'ast', 'ary', 'ast_missingincludes', Ast.get_include()]

        define_macros = get_starlink_macros(osx=osx)

        # Now build all.

        # This is the directory where the extra library's built here
        # have to be copied to, relative to the final build. This must
        # be called '.libs' if you want to use this with
        # cibuildwheel/auditwheel.
        extra_lib_dir = '.libs'

        # Get the compilers.
        compiler = ccompiler.new_compiler(dry_run=FAKEBUILDING, verbose=0)
        compiler2 = ccompiler.new_compiler(verbose=1)

        # Ensure we have any distutils options set.
        customize_compiler(compiler)
        customize_compiler(compiler2)

        # Now go through each extension, build the shared libraries we
        # need and ensure they are copied to the build directory. We
        # will use rpath and $ORIGIN to ensure everything is portable
        # as it will be moved around during the build process by pip
        # etc.
        for ext in self.extensions:
            linked_libraries = []
            if ext.name == 'starlink.hds':

                hds_deps = compiler.compile(sources=hds_source_dep,
                                            output_dir=OUTPUTDIR,
                                            macros=define_macros,
                                            include_dirs=HDS_DEP_INCLUDES,
                                            depends=hds_source_dep,
                                            )

                hds_deps_libname = compiler2.library_filename('pyhdsdeps',
                                                              lib_type=libtype)

                # Build this into a library

                print('Linking HDSDEPS\n\n\n')
                extra_preargs = None
                if osx:
                    extra_preargs = ['-v', '-Wl,-v',
                            install_name_pattern.format(hds_deps_libname)]

                compiler2.link('shared', hds_deps, hds_deps_libname,
                               output_dir=OUTPUTDIR,
                               extra_preargs=extra_preargs,
                               extra_postargs=None)
                linked_libraries += [os.path.join(OUTPUTDIR, hds_deps_libname)]

                # Now build hds-v4 and hds-v5: have to do this separately.
                hdsv4_libname = compiler.library_filename('pyhdsv4', lib_type=libtype)

                hdsv4objs = compiler.compile(sources=get_source('hds-v4'),
                                             output_dir=OUTPUTDIR,
                                             macros=define_macros,
                                             include_dirs=('hds-v4_missingincludes',) + HDS_DEP_INCLUDES,
                                             depends=get_source('hds-v4'))
                extra_preargs = None
                if osx:
                    extra_preargs = [install_name_pattern.format(hdsv4_libname)]

                print('Linking HDSV4\n\n\n')
                compiler2.link('shared', hdsv4objs, hdsv4_libname,
                               output_dir=OUTPUTDIR,
                               extra_preargs=extra_preargs,
                               target_lang='c')

                linked_libraries += [os.path.join(OUTPUTDIR, hdsv4_libname)]

                print('CREATING HDF5 LIBRARY\n\n\n')
                # Create the HDF5 library
                hdf5_libpath = os.path.join('hdf5', 'src', '.libs')
                hdf5_objects = glob.glob(os.path.join(hdf5_libpath, '*.o'))
                hdf5_libname = compiler.library_filename('pystarhdf5', lib_type=libtype)

                extra_preargs = None
                if osx:
                    extra_preargs = [install_name_pattern.format(hdf5_libname)]
                compiler2.link('shared', hdf5_objects, hdf5_libname,
                               output_dir=OUTPUTDIR,
                               library_dirs=[OUTPUTDIR],
                               runtime_library_dirs=rdirs, extra_postargs=ldirs,
                               extra_preargs=extra_preargs)
                linked_libraries += [os.path.join(OUTPUTDIR, hdf5_libname)]

                hdsv5_libname = compiler2.library_filename('pyhdsv5', lib_type=libtype)
                hdsv5objs = compiler.compile(sources=get_source('hds-v5'),
                                             output_dir=OUTPUTDIR,
                                             macros=define_macros,
                                             include_dirs=('hds-v5_missingincludes',) + HDS_DEP_INCLUDES,
                                             depends=get_source('hds-v5'))
                extra_preargs = None
                if osx:
                    extra_preargs = [install_name_pattern.format(hdsv5_libname)]

                compiler2.link('shared', hdsv5objs, hdsv5_libname,
                               output_dir=OUTPUTDIR,
                               libraries=['pystarhdf5'],
                               library_dirs=[OUTPUTDIR],
                               runtime_library_dirs=rdirs,
                               extra_postargs=ldirs,
                               extra_preargs=extra_preargs)
                linked_libraries += [os.path.join(OUTPUTDIR, hdsv5_libname)]

                hds_libname = compiler2.library_filename('pyhds', lib_type=libtype)
                hdsobjs = compiler.compile(sources=get_source('hds'),
                                           output_dir=OUTPUTDIR,
                                           macros=define_macros,
                                           include_dirs=hdsex_includedirs,
                                           depends=get_source('hds'))
                extra_preargs = None
                if osx:
                    extra_preargs = [install_name_pattern.format(hds_libname)]

                compiler2.link('shared', hdsobjs, hds_libname,
                               output_dir=OUTPUTDIR,
                               libraries=['pyhdsdeps', 'pyhdsv5', 'pyhdsv4'],
                               library_dirs=[OUTPUTDIR],
                               runtime_library_dirs=rdirs, extra_postargs=ldirs,
                               extra_preargs=extra_preargs)
                linked_libraries += [os.path.join(OUTPUTDIR, hds_libname)]

                ext.libraries += ['pyhds']
                ext.library_dirs += [OUTPUTDIR]
                if ext_runtime_library_dirs:
                    ext.runtime_library_dirs += [ext_runtime_library_dirs.format(extra_lib_dir)]
                if ext_extra_link_args:
                    ext.extra_link_args += [ext_extra_link_args.format(extra_lib_dir)]

            if ext.name == 'starlink.ndf':
                ndf_libname = compiler2.library_filename('pyndf', lib_type=libtype)
                ndfobjs = compiler.compile(sources=get_source('ndf') + ndf_source_dep,
                                           include_dirs=['ndf/', 'ndf_missingincludes/'] + ndfex_includedirs,
                                           macros=define_macros,
                                           depends=get_source('ndf'))

                extra_preargs = None
                if osx:
                    extra_preargs = [install_name_pattern.format(ndf_libname)]
                compiler2.link('shared', ndfobjs, ndf_libname,
                               output_dir=OUTPUTDIR,
                               libraries=['pyhdsdeps', 'pyhdsv5', 'pyhdsv4', 'pyhds'],
                               library_dirs=[OUTPUTDIR],
                               runtime_library_dirs=rdirs,
                               extra_postargs=ldirs,
                               extra_preargs=extra_preargs)

                linked_libraries += [os.path.join(OUTPUTDIR, ndf_libname)]
                ext.libraries += ['pyndf']
                ext.library_dirs += [OUTPUTDIR]
                if ext_runtime_library_dirs:
                    ext.runtime_library_dirs += [ext_runtime_library_dirs.format(extra_lib_dir)]
                if ext_extra_link_args:
                    ext.extra_link_args += [ext_extra_link_args.format(extra_lib_dir)]

            # Copy over the libraries to the build directory manually, and add to package data.
            if not os.path.isdir(os.path.join(self.build_lib, 'starlink', extra_lib_dir)):
                os.mkdir(os.path.join(self.build_lib, 'starlink', extra_lib_dir))

            for lib in linked_libraries:
                shutil.copy(lib, os.path.join(self.build_lib, 'starlink', extra_lib_dir))
                output_lib = os.path.join('starlink', extra_lib_dir, os.path.split(lib)[1])
                self.distribution.package_data.get('starlink', list()).extend(output_lib)

        # Run the standard build_ext process.
        build_ext.run(self)
Пример #48
0
#! /usr/bin/env python

# BSD 2-Clause License
# Copyright (c) 2016, Roberto Souza and collaborators
# All rights reserved.


# System imports
from distutils.core import *
from distutils      import sysconfig

import os

(opt,) = sysconfig.get_config_vars('OPT')
os.environ['OPT'] = " ".join(flag for flag in opt.split() if flag != '-Wstrict-prototypes')




# Third-party modules - we depend on numpy for everything
import numpy


# Obtain the numpy include directory.  This logic works across numpy versions.
try:
    numpy_include = numpy.get_include()
except AttributeError:
    numpy_include = numpy.get_numpy_include() # get_numpy_include()

def read(fname):
    return open(os.path.join(os.path.dirname(__file__), fname)).read()
Пример #49
0
    def prep_build(self, ext):
        if not CMakeBuild.hasbuilt:
            from distutils.sysconfig import get_python_inc
            import distutils.sysconfig as sysconfig
            cfg = self.cfg_type()
            extdir = os.path.abspath(
                os.path.dirname(self.get_ext_fullpath(ext.name)))

            lcb_api_flags = self.get_lcb_api_flags()
            cmake_args = lcb_api_flags + ['-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=' + extdir,
                                          '-DPYTHON_EXECUTABLE=' + sys.executable]
            cmake_args += ['-DPYTHON_INCLUDE_DIR={}'.format(get_python_inc())]
            self.info.setbase(self.build_temp)
            self.info.cfg=cfg
            from distutils import sysconfig
            import os.path as op
            v = sysconfig.get_config_vars()
            print("LIBDIR {}, LIBPL {}".format(v.get("LIBDIR"), v.get("LIBPL")))
            fpaths = [op.join(v.get(pv, ''), v.get('LDLIBRARY', '')) for pv in ('LIBDIR', 'LIBPL')] + [os.path.normpath(
                os.path.join(get_python_inc(), "..", "..", "lib",
                             "libpython{}.dylib".format('.'.join(map(str, sys.version_info[0:2]))))),
                os.path.join(get_python_inc(), "..", "..", "lib")]
            python_lib = None
            python_libdir = None
            for entry in fpaths:
                if not op.exists(entry):
                    print("fpath {} does not exist".format(entry))
                    continue
                try:
                    print("got fpath {}:".format(entry))
                    if op.isfile(entry):
                        print("fpath {} is file, selecting".format(entry))
                        python_lib = python_lib or entry
                        continue
                    else:
                        entries = os.listdir(entry)
                        print("fpath {} is directory, contents {}".format(entry, entries))
                        for subentry in entries:
                            fullname = op.normpath(op.join(entry, subentry))
                            try:
                                fullname = op.readlink(fullname)
                            except:
                                pass
                            print("trying subentry:{}".format(fullname))

                            if op.exists(fullname):
                                python_lib = python_lib or fullname
                                python_libdir = op.normpath(entry)
                                print("got match {}, breaking out".format(fullname))
                                continue

                except:
                    pass
            cmake_args += ['-DHYBRID_BUILD=TRUE'] if CMakeBuild.hybrid else []
            cmake_args += ['-DPYTHON_LIBFILE={}'.format(python_lib)] if python_lib else []
            cmake_args += ['-DPYTHON_LIBDIR={}'.format(python_libdir)] if python_libdir else []
            cmake_args += [
                '-DPYTHON_VERSION_EXACT={}'.format('.'.join(map(str, sys.version_info[0:2])))] if python_libdir else []
            build_args = ['--config', cfg]
            if platform.system() == "Windows":
                cmake_args += ['-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_{}={}'.format(
                    cfg.upper(),
                    extdir), '-DLCB_NO_MOCK=1']
                if sys.maxsize > 2 ** 32:
                    cmake_args += ['-A', 'x64']
                build_args += ['--', '/m']
            else:
                cmake_args += ['-DCMAKE_BUILD_TYPE=' + cfg.upper()]
                build_args += ['--', '-j2']
            env = os.environ.copy()
            python_executable = win_cmake_path(sys.executable)
            pass_path = False
            if re.match(r'.*(CONAN|ALL).*',PYCBC_SSL_FETCH):
                try:
                    import conans.conan
                    env['PATH'] = env['PATH']+";{}".format(os.path.dirname(conans.conan.__file__))
                    pass_path = True
                except:
                    logging.warning("Cannot find conan : {}".format(traceback.format_exc()))
            if re.match(r'.*(GITHUB|ALL).*', PYCBC_SSL_FETCH):
                pass_path = True
            if pass_path:
                pathsep = ';' if platform.system().lower().startswith('win') else ':'
                env['PYTHONPATH'] = pathsep.join(sys.path)
            cmake_args += [
                           '-DCMAKE_VERBOSE_MAKEFILE:BOOL=ON',
                           '-DPYTHON_EXECUTABLE={}'.format(python_executable)]
            if PYCBC_SSL_FETCH:
                cmake_args += ['-DPYCBC_SSL_FETCH={}'.format(PYCBC_SSL_FETCH)]
            PYCBC_CMAKE_DEBUG = env.get('PYCBC_CMAKE_DEBUG')
            if PYCBC_CMAKE_DEBUG:
                cmake_args += [
                '--trace-source=CMakeLists.txt',
                '--trace-expand']
            cxx_compile_args=filter(re.compile(r'^(?!-std\s*=\s*c(11|99)).*').match, ext.extra_compile_args)
            env['CXXFLAGS'] = '{} {} -DVERSION_INFO=\\"{}\\"'.format(
                env.get('CXXFLAGS', ''), ' '.join(cxx_compile_args),
                self.distribution.get_version())

            env['CFLAGS'] = '{} {}'.format(
                env.get('CFLAGS', ''), ' '.join(ext.extra_compile_args),
                self.distribution.get_version())
            print("Launching build with env: {}, build_args: {}, cmake_args: {}".format(env, build_args, cmake_args))
            if not os.path.exists(self.build_temp):
                os.makedirs(self.build_temp)
            subprocess.check_call(['cmake', ext.sourcedir] + cmake_args, stdout=sys.stdout, stderr=sys.stdout,
                                  cwd=self.build_temp, env=env)
            subprocess.check_call(['cmake', '--build', '.'] + build_args,
                                  cwd=self.build_temp)
            CMakeBuild.hasbuilt = True
            build_dir = os.path.realpath(self.build_lib)

            if CMakeBuild.hybrid:
                if not self.compiler:
                    self.run()

            for name in self.info.entries():
                try:
                    pkg_build_dir=os.path.join(build_dir, cbuild_config.couchbase_core)
                    self.copy_binary_to(cfg, pkg_build_dir, self.info.lcb_pkgs_srcs(), name)
                    self.copy_binary_to(cfg, self.info.pkg_data_dir, self.info.lcb_pkgs_srcs(), name)
                except:
                    print("failure")
                    raise
Пример #50
0
def setup():
    try:
        from setuptools import setup as setup_, Extension
    except ImportError:
        from distutils.core import setup as setup_, Extension
    from distutils.spawn import find_executable
    from distutils.sysconfig import get_config_vars

    scripts_dir = os.path.join(dir_name, 'scripts')
    if os.name == 'nt':
        scripts = [os.path.join(scripts_dir, f)
                   for f in os.listdir(scripts_dir)]
    else:
        scripts = [os.path.join(scripts_dir, f)
                   for f in os.listdir(scripts_dir)
                   if not f.endswith('.bat')]
    packages = ['xdress', 'xdress.clang', 'xdress._enum']
    pack_dir = {'xdress': 'xdress', 'xdress.clang': 'xdress/clang', 
                'xdress._enum': 'xdress/_enum'}
    pack_data = {'xdress': ['*.pxd', '*.pyx', '*.h', '*.cpp'], 
                 'xdress._enum': ['LICENSE', 'README']}

    # llvm+clang configuration can be controlled by the environment variables
    # LLVM_CONFIG, LLVM_CPPFLAGS, LLVM_LDFLAGS, and CLANG_LIBS.  LLVM_CONFIG is
    # not used if both LLVM_CPPFLAGS and LLVM_LDFLAGS are set.

    if 'LLVM_CPPFLAGS' in os.environ and 'LLVM_LDFLAGS' in os.environ:
        llvm_config = True # Will be unused below
    else:
        if 'LLVM_CONFIG' in os.environ:
            llvm_config = os.environ['LLVM_CONFIG']
        else:
            options = 'llvm-config llvm-config-3.5 llvm-config-3.4 llvm-config-3.3 llvm-config-3.2'.split()
            for p in options:
                p = find_executable(p)
                if p is not None:
                    print('using llvm-config from %s'%p)
                    llvm_config = p
                    break
            else:
                print('Disabling clang since llvm-config not found: tried %s'%', '.join(options))
                print('To override, set the LLVM_CONFIG environment variable.')
                llvm_config = None
    if llvm_config is not None:
        try:
            llvm_cppflags = (   os.environ.get('LLVM_CPPFLAGS')
                             or subprocess.check_output([llvm_config,'--cppflags'])).split()
            llvm_ldflags  = (   os.environ.get('LLVM_LDFLAGS')
                             or subprocess.check_output([llvm_config,'--ldflags','--libs'])).split()
        except OSError as e:
            raise OSError("Failed to run llvm-config program '%s': %s" % (llvm_config, e))
        clang_dir = os.path.join(dir_name, 'xdress', 'clang')
        clang_src_dir = os.path.join(clang_dir, 'src')
        clang_libs = (   os.environ.get('CLANG_LIBS')
                      or '''clangTooling clangFrontend clangDriver clangSerialization clangCodeGen
                            clangParse clangSema clangStaticAnalyzerFrontend clangStaticAnalyzerCheckers
                            clangStaticAnalyzerCore clangAnalysis clangARCMigrate clangEdit
                            clangRewriteCore clangAST clangLex clangBasic''').split()
        # If the user sets CFLAGS, make sure we still have our own include path first
        if 'CFLAGS' in os.environ:
            os.environ['CFLAGS'] = '-I%s '%clang_dir + os.environ['CFLAGS']
        # Remove -Wstrict-prototypes to prevent warnings in libclang C++ code,
        # following http://stackoverflow.com/questions/8106258.
        opt, = get_config_vars('OPT')
        os.environ['OPT'] = ' '.join(f for f in opt.split() if f != '-Wstrict-prototypes')
        modules = [Extension('xdress.clang.libclang',
                             sources=glob.glob(os.path.join(clang_src_dir, '*.cpp')),
                             define_macros=[('XDRESS', 1)],
                             include_dirs=[clang_dir],
                             extra_compile_args=llvm_cppflags+['-fno-rtti'],
                             extra_link_args=llvm_ldflags,
                             libraries=clang_libs,
                             language='c++')]
    else:
        modules = ()

    setup_kwargs = {
        "name": "xdress",
        "version": INFO['version'],
        "description": 'xdress',
        "author": 'Anthony Scopatz',
        "author_email": '*****@*****.**',
        "url": 'http://xdress.org/',
        "packages": packages,
        "package_dir": pack_dir,
        "package_data": pack_data,
        "ext_modules": modules,
        "scripts": scripts,
        "description": ("Cython-based, NumPy-aware automatic wrapper generation for "
                        "C / C++."),
        "long_description": long_desc,
        "download_url": ("https://github.com/scopatz/xdress/"
                         "zipball/{0}.{1}").format(*xdress.version.xdress_version[:2]),
        "classifiers": [
            "License :: OSI Approved :: BSD License",
            "Intended Audience :: Developers",
            "Intended Audience :: Science/Research",
            "Programming Language :: C",
            "Programming Language :: C++",
            "Programming Language :: Cython",
            "Programming Language :: Python :: 2",
            "Programming Language :: Python :: 3",
            "Programming Language :: Python :: Implementation :: CPython",
            "Topic :: Scientific/Engineering",
            "Topic :: Software Development :: Code Generators",
            "Topic :: Software Development :: Compilers",
            "Topic :: Utilities",
        ],
        "data_files": [("", ['license', 'configure.py']),],
    }
    # changing dirs for virtualenv
    cwd = os.getcwd()
    os.chdir(dir_name)
    setup_(**setup_kwargs)
    os.chdir(cwd)
Пример #51
0
except ImportError:
    # No information available
    print("none")
    sys.exit(1)

if sys.argv[1] == '--includes':
    inc = sysconfig.get_python_inc()
    plat = sysconfig.get_python_inc(plat_specific=1)
    if inc == plat:
        print("-I" + inc)
    else:
        print("-I%s -I%s" % (inc, plat))
    sys.exit(0)

if sys.argv[1] == '--compile':
    cc, ccshared = sysconfig.get_config_vars('CC', 'CCSHARED')
    print("%s %s" % (cc, ccshared))
    sys.exit(0)


def add_option(options, name, value=None):
    """Add option to list of options"""
    options.append(name)
    if value is not None:
        options.append(value)


def add_option_if_missing(options, name, value=None):
    """Add option to list of options, if it is not already present"""
    if options.count(name) == 0 and options.count("-Wl,%s" % name) == 0:
        add_option(options, name, value)
Пример #52
0
def get_platform():
    """Return a string that identifies the current platform.  This is used
    mainly to distinguish platform-specific build directories and
    platform-specific built distributions.  Typically includes the OS name
    and version and the architecture (as supplied by 'os.uname()'),
    although the exact information included depends on the OS; eg. for IRIX
    the architecture isn't particularly important (IRIX only runs on SGI
    hardware), but for Linux the kernel version isn't particularly
    important.

    Examples of returned values:
       linux-i586
       linux-alpha (?)
       solaris-2.6-sun4u
       irix-5.3
       irix64-6.2

    Windows will return one of:
       win-amd64 (64bit Windows on AMD64 (aka x86_64, Intel64, EM64T, etc)
       win-ia64 (64bit Windows on Itanium)
       win32 (all others - specifically, sys.platform is returned)

    For other non-POSIX platforms, currently just returns 'sys.platform'.
    """
    if os.name == 'nt':
        # sniff sys.version for architecture.
        prefix = " bit ("
        i = sys.version.find(prefix)
        if i == -1:
            return sys.platform
        j = sys.version.find(")", i)
        look = sys.version[i + len(prefix):j].lower()
        if look == 'amd64':
            return 'win-amd64'
        if look == 'itanium':
            return 'win-ia64'
        return sys.platform

    if os.name != "posix" or not hasattr(os, 'uname'):
        # XXX what about the architecture? NT is Intel or Alpha,
        # Mac OS is M68k or PPC, etc.
        return sys.platform

    # Try to distinguish various flavours of Unix

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

    # Convert the OS name to lowercase, remove '/' characters
    # (to accommodate BSD/OS), and translate spaces (for "Power Macintosh")
    osname = osname.lower().replace('/', '')
    machine = machine.replace(' ', '_')
    machine = machine.replace('/', '-')

    if osname[:5] == "linux":
        # At least on Linux/Intel, 'machine' is the processor --
        # i386, etc.
        # XXX what about Alpha, SPARC, etc?
        return "%s-%s" % (osname, machine)
    elif osname[:5] == "sunos":
        if release[0] >= "5":  # SunOS 5 == Solaris 2
            osname = "solaris"
            release = "%d.%s" % (int(release[0]) - 3, release[2:])
        # fall through to standard osname-release-machine representation
    elif osname[:4] == "irix":  # could be "irix64"!
        return "%s-%s" % (osname, release)
    elif osname[:3] == "aix":
        return "%s-%s.%s" % (osname, version, release)
    elif osname[:6] == "cygwin":
        osname = "cygwin"
        rel_re = re.compile(r'[\d.]+', re.ASCII)
        m = rel_re.match(release)
        if m:
            release = m.group()
    elif osname[:6] == "darwin":
        #
        # For our purposes, we'll assume that the system version from
        # distutils' perspective is what MACOSX_DEPLOYMENT_TARGET is set
        # to. This makes the compatibility story a bit more sane because the
        # machine is going to compile and link as if it were
        # MACOSX_DEPLOYMENT_TARGET.
        from distutils.sysconfig import get_config_vars
        cfgvars = get_config_vars()

        macver = os.environ.get('MACOSX_DEPLOYMENT_TARGET')
        if not macver:
            macver = cfgvars.get('MACOSX_DEPLOYMENT_TARGET')

        if 1:
            # Always calculate the release of the running machine,
            # needed to determine if we can build fat binaries or not.

            macrelease = macver
            # Get the system version. Reading this plist is a documented
            # way to get the system version (see the documentation for
            # the Gestalt Manager)
            try:
                f = open('/System/Library/CoreServices/SystemVersion.plist')
            except IOError:
                # We're on a plain darwin box, fall back to the default
                # behaviour.
                pass
            else:
                m = re.search(
                    r'<key>ProductUserVisibleVersion</key>\s*' +
                    r'<string>(.*?)</string>', f.read())
                f.close()
                if m is not None:
                    macrelease = '.'.join(m.group(1).split('.')[:2])
                # else: fall back to the default behaviour

        if not macver:
            macver = macrelease

        if macver:
            from distutils.sysconfig import get_config_vars
            release = macver
            osname = "macosx"

            if (macrelease + '.') >= '10.4.' and \
                    '-arch' in get_config_vars().get('CFLAGS', '').strip():
                # The universal build will build fat binaries, but not on
                # systems before 10.4
                #
                # Try to detect 4-way universal builds, those have machine-type
                # 'universal' instead of 'fat'.

                machine = 'fat'
                cflags = get_config_vars().get('CFLAGS')

                archs = re.findall('-arch\s+(\S+)', cflags)
                archs.sort()
                archs = tuple(archs)

                if len(archs) == 1:
                    machine = archs[0]
                elif archs == ('i386', 'ppc'):
                    machine = 'fat'
                elif archs == ('i386', 'x86_64'):
                    machine = 'intel'
                elif archs == ('i386', 'ppc', 'x86_64'):
                    machine = 'fat3'
                elif archs == ('ppc64', 'x86_64'):
                    machine = 'fat64'
                elif archs == ('i386', 'ppc', 'ppc64', 'x86_64'):
                    machine = 'universal'
                else:
                    raise ValueError("Don't know machine value for archs=%r" %
                                     (archs, ))

            elif machine in ('PowerPC', 'Power_Macintosh'):
                # Pick a sane name for the PPC architecture.
                machine = 'ppc'

    return "%s-%s-%s" % (osname, release, machine)
Пример #53
0
lib_dirs = ReadConfig('build_ext', 'library_dirs',
                      sysconfig.get_config_var('LIBDIR')).split(':')
extra_compile_args = ReadConfig('cc_options', 'extra_compile_args', '').split()
extra_link_args = ReadConfig('cc_options', 'extra_link_args', '').split()

static_libs = []
deps = ['libgflags.a', 'libglog.a']
for dep in deps:
    for lib_dir in lib_dirs:
        path = os.path.join(lib_dir, dep)
        if os.path.isfile(path):
            static_libs.append(path)
assert len(static_libs) == len(deps), (static_libs, deps, lib_dirs)

cvars = sysconfig.get_config_vars()
cvars['OPT'] = str.join(
    ' ',
    RemovePrefixes(
        cvars.get('OPT').split(), ['-g', '-O', '-Wstrict-prototypes']))

# Determine the current version of the package. The easiest way would be to
# import "googleclouddebugger" and read its __version__ attribute.
# Unfortunately we can't do that because "googleclouddebugger" depends on
# "cdbg_native" that hasn't been built yet.
version = None
with open('googleclouddebugger/version.py', 'r') as version_file:
    version_pattern = re.compile(r"^\s*__version__\s*=\s*'([0-9.]*)'")
    for line in version_file:
        match = version_pattern.match(line)
        if match:
Пример #54
0
class CompilerDetection(object):
    # Necessary for OSX. See https://github.com/mdtraj/mdtraj/issues/576
    # The problem is that distutils.sysconfig.customize_compiler()
    # is necessary to properly invoke the correct compiler for this class
    # (otherwise the CC env variable isn't respected). Unfortunately,
    # distutils.sysconfig.customize_compiler() DIES on OSX unless some
    # appropriate initialization routines have been called. This line
    # has a side effect of calling those initialzation routes, and is therefor
    # necessary for OSX, even though we don't use the result.
    _DONT_REMOVE_ME = get_config_vars()

    def __init__(self, disable_openmp):
        self.disable_openmp = disable_openmp
        self._is_initialized = False

    def initialize(self):
        if self._is_initialized:
            return

        cc = new_compiler()
        customize_compiler(cc)

        self.msvc = cc.compiler_type == 'msvc'
        self._print_compiler_version(cc)

        if self.disable_openmp:
            self.openmp_enabled = False
        else:
            self.openmp_enabled, openmp_needs_gomp = self._detect_openmp()
        self.sse3_enabled = self._detect_sse3() if not self.msvc else True
        self.sse41_enabled = self._detect_sse41() if not self.msvc else True

        self.compiler_args_sse2 = ['-msse2'] if not self.msvc else ['/arch:SSE2']
        self.compiler_args_sse3 = ['-mssse3'] if (self.sse3_enabled and not self.msvc) else []
        self.compiler_args_warn = ['-Wno-unused-function', '-Wno-unreachable-code', '-Wno-sign-compare'] if not self.msvc else []

        self.compiler_args_sse41, self.define_macros_sse41 = [], []
        if self.sse41_enabled:
            self.define_macros_sse41 = [('__SSE4__', 1), ('__SSE4_1__', 1)]
            if not self.msvc:
                self.compiler_args_sse41 = ['-msse4']

        if self.openmp_enabled:
            self.compiler_libraries_openmp = []

            if self.msvc:
                self.compiler_args_openmp = ['/openmp']
            else:
                self.compiler_args_openmp = ['-fopenmp']
                if openmp_needs_gomp:
                    self.compiler_libraries_openmp = ['gomp']
        else:
            self.compiler_libraries_openmp = []
            self.compiler_args_openmp = []

        if self.msvc:
            self.compiler_args_opt = ['/O2']
        else:
            self.compiler_args_opt = ['-O3', '-funroll-loops']
        print()
        self._is_initialized = True

    def _print_compiler_version(self, cc):
        print("C compiler:")
        try:
            if self.msvc:
                if not cc.initialized:
                    cc.initialize()
                cc.spawn([cc.cc])
            else:
                cc.spawn([cc.compiler[0]] + ['-v'])
        except DistutilsExecError:
            pass

    def hasfunction(self, funcname, include=None, libraries=None, extra_postargs=None):
        # running in a separate subshell lets us prevent unwanted stdout/stderr
        part1 = '''
from __future__ import print_function
import os
import json
from distutils.ccompiler import new_compiler
from distutils.sysconfig import customize_compiler, get_config_vars

FUNCNAME = json.loads('%(funcname)s')
INCLUDE = json.loads('%(include)s')
LIBRARIES = json.loads('%(libraries)s')
EXTRA_POSTARGS = json.loads('%(extra_postargs)s')
        ''' % {
            'funcname': json.dumps(funcname),
            'include': json.dumps(include),
            'libraries': json.dumps(libraries or []),
            'extra_postargs': json.dumps(extra_postargs)}

        part2 = '''
get_config_vars()  # DON'T REMOVE ME
cc = new_compiler()
customize_compiler(cc)
for library in LIBRARIES:
    cc.add_library(library)

status = 0
try:
    with open('func.c', 'w') as f:
        if INCLUDE is not None:
            f.write('#include %s\\n' % INCLUDE)
        f.write('int main(void) {\\n')
        f.write('    %s;\\n' % FUNCNAME)
        f.write('}\\n')
    objects = cc.compile(['func.c'], output_dir='.',
                         extra_postargs=EXTRA_POSTARGS)
    cc.link_executable(objects, 'a.out')
except Exception as e:
    status = 1
exit(status)
        '''
        tmpdir = tempfile.mkdtemp(prefix='hasfunction-')
        try:
            curdir = os.path.abspath(os.curdir)
            os.chdir(tmpdir)
            with open('script.py', 'w') as f:
                f.write(part1 + part2)
            proc = subprocess.Popen(
                [sys.executable, 'script.py'],
                stderr=subprocess.PIPE, stdout=subprocess.PIPE)
            proc.communicate()
            status = proc.wait()
        finally:
            os.chdir(curdir)
            shutil.rmtree(tmpdir)

        return status == 0

    def _print_support_start(self, feature):
        print('Attempting to autodetect {0:6} support...'.format(feature), end=' ')

    def _print_support_end(self, feature, status):
        if status is True:
            print('Compiler supports {0}'.format(feature))
        else:
            print('Did not detect {0} support'.format(feature))

    def _detect_openmp(self):
        self._print_support_start('OpenMP')
        hasopenmp = self.hasfunction('omp_get_num_threads()', extra_postargs=['-fopenmp', '/openmp'])
        needs_gomp = hasopenmp
        if not hasopenmp:
            hasopenmp = self.hasfunction('omp_get_num_threads()', libraries=['gomp'])
            needs_gomp = hasopenmp
        self._print_support_end('OpenMP', hasopenmp)
        return hasopenmp, needs_gomp

    def _detect_sse3(self):
        "Does this compiler support SSE3 intrinsics?"
        self._print_support_start('SSE3')
        result = self.hasfunction('__m128 v; _mm_hadd_ps(v,v)',
                           include='<pmmintrin.h>',
                           extra_postargs=['-msse3'])
        self._print_support_end('SSE3', result)
        return result

    def _detect_sse41(self):
        "Does this compiler support SSE4.1 intrinsics?"
        self._print_support_start('SSE4.1')
        result = self.hasfunction( '__m128 v; _mm_round_ps(v,0x00)',
                           include='<smmintrin.h>',
                           extra_postargs=['-msse4'])
        self._print_support_end('SSE4.1', result)
        return result
Пример #55
0
    CHANGES = f.read()

extension_options = {
    'sources': ['./rapidjson.cpp'],
    'include_dirs': [rj_include_dir],
    'define_macros': [('PYTHON_RAPIDJSON_VERSION', VERSION)],
}

cxx = sysconfig.get_config_var('CXX')
if cxx and 'g++' in cxx:
    # Avoid warning about invalid flag for C++
    for varname in ('CFLAGS', 'OPT'):
        value = sysconfig.get_config_var(varname)
        if value and '-Wstrict-prototypes' in value:
            value = value.replace('-Wstrict-prototypes', '')
            sysconfig.get_config_vars()[varname] = value

    # Add -pedantic, so we get a warning when using non-standard features, and
    # -Wno-long-long to pacify old gcc (or Apple's hybrids) that treat "long
    # long" as an error under C++ (see issue #69)
    extension_options['extra_compile_args'] = ['-pedantic', '-Wno-long-long']

    # Up to Python 3.7, some structures use "char*" instead of "const char*",
    # and ISO C++ forbids assigning string literal constants
    if sys.version_info < (3, 7):
        extension_options['extra_compile_args'].append('-Wno-write-strings')

setup(name='python-rapidjson',
      version=VERSION,
      description='Python wrapper around rapidjson',
      long_description=LONG_DESCRIPTION + '\n\n' + CHANGES,
Пример #56
0
    raise ValueError("Version string not found")


VERSION = get_version()

if (sys.platform.startswith('linux') or sys.platform.startswith('cygwin')
        or sys.platform.startswith('gnukfreebsd')):
    ostype = 'linux'
    so_ext = '.so'
    LD_LIBRARY_PATH = 'LD_LIBRARY_PATH'
elif sys.platform.startswith('darwin'):
    ostype = 'mac'
    so_ext = '.dylib'
    LD_LIBRARY_PATH = 'DYLD_LIBRARY_PATH'
    from distutils.sysconfig import get_config_vars
    conf_vars = get_config_vars()
    # setuptools/pip install by default generate "bundled" library.  Bundled
    # library cannot be linked at compile time
    # https://stackoverflow.com/questions/24519863/what-are-the-g-flags-to-build-a-true-so-mh-bundle-shared-library-on-mac-osx
    # configs LDSHARED and CCSHARED and SO are hard coded in lib/pythonX.X/_sysconfigdata.py
    # In some Python version, steuptools may correct these configs for OS X on the
    # fly by _customize_compiler_for_shlib function or setup_shlib_compiler function
    # in lib/pythonX.X/site-packages/setuptools/command/build_ext.py.
    # The hacks below ensures that the OS X compiler does not generate bundle
    # libraries.  Relevant code:
    #    lib/pythonX.X/_sysconfigdata.py
    #    lib/pythonX.X/distutils/command/build_ext.py
    #    lib/pythonX.X/distutils/sysconfig.py,  get_config_vars()
    #    lib/pythonX.X/distutils/ccompiler.py,  link_shared_object()
    #    lib/pythonX.X/distutils/unixcompiler.py,  link()
    conf_vars['LDSHARED'] = conf_vars['LDSHARED'].replace(
Пример #57
0
    def hasfunction(self,
                    funcname,
                    include=None,
                    libraries=None,
                    extra_postargs=None):
        # running in a separate subshell lets us prevent unwanted stdout/stderr
        part1 = '''
from __future__ import print_function
import os
import json
from distutils.ccompiler import new_compiler
from distutils.sysconfig import customize_compiler, get_config_vars

FUNCNAME = json.loads('%(funcname)s')
INCLUDE = json.loads('%(include)s')
LIBRARIES = json.loads('%(libraries)s')
EXTRA_POSTARGS = json.loads('%(extra_postargs)s')
        ''' % {
            'funcname': json.dumps(funcname),
            'include': json.dumps(include),
            'libraries': json.dumps(libraries or []),
            'extra_postargs': json.dumps(extra_postargs)
        }

        part2 = '''
get_config_vars()  # DON'T REMOVE ME
cc = new_compiler()
customize_compiler(cc)
for library in LIBRARIES:
    cc.add_library(library)

status = 0
try:
    with open('func.c', 'w') as f:
        if INCLUDE is not None:
            f.write('#include %s\\n' % INCLUDE)
        f.write('int main(void) {\\n')
        f.write('    %s;\\n' % FUNCNAME)
        f.write('}\\n')
    objects = cc.compile(['func.c'], output_dir='.',
                         extra_postargs=EXTRA_POSTARGS)
    cc.link_executable(objects, 'a.out')
except Exception as e:
    status = 1
exit(status)
        '''
        tmpdir = tempfile.mkdtemp(prefix='hasfunction-')
        try:
            curdir = os.path.abspath(os.curdir)
            os.chdir(tmpdir)
            with open('script.py', 'w') as f:
                f.write(part1 + part2)
            proc = subprocess.Popen([sys.executable, 'script.py'],
                                    stderr=subprocess.PIPE,
                                    stdout=subprocess.PIPE)
            proc.communicate()
            status = proc.wait()
        finally:
            os.chdir(curdir)
            shutil.rmtree(tmpdir)

        return status == 0
Пример #58
0
from distutils import sysconfig
import sys
import os
import platform

import versioneer

min_python_version = "3.6"
min_numpy_build_version = "1.11"
min_numpy_run_version = "1.15"
min_llvmlite_version = "0.31.0.dev0"
max_llvmlite_version = "0.33.0.dev0"

if sys.platform.startswith('linux'):
    # Patch for #2555 to make wheels without libpython
    sysconfig.get_config_vars()['Py_ENABLE_SHARED'] = 0


class build_doc(build.build):
    description = "build documentation"

    def run(self):
        spawn(['make', '-C', 'docs', 'html'])


versioneer.VCS = 'git'
versioneer.versionfile_source = 'numba/_version.py'
versioneer.versionfile_build = 'numba/_version.py'
versioneer.tag_prefix = ''
versioneer.parentdir_prefix = 'numba-'
Пример #59
0
    def GetPythonPath(self):

        if self._pwd_ is None:
            self._pwd_ = os.path.dirname(os.path.realpath('__file__'))

        # Get python version
        self.python_version = sys.version_info

        if self.python_version[:2] < (2, 7) or (
                3, 0) <= self.python_version[:2] < (3, 5):
            raise RuntimeError("Python version 2.7 or >= 3.5 required.")

        self.py_major = self.python_version.major
        self.py_minor = self.python_version.minor
        self.py_micro = self.python_version.micro
        self.python_interpreter = 'python' + str(self.py_major) + '.' + str(
            self.py_minor)

        with_pymalloc = ""
        if get_config_var("ABIFLAGS") is not None:
            with_pymalloc = get_config_var("ABIFLAGS")
        self.python_interpreter += with_pymalloc

        # Get python implementation e.g. CPython, PyPy etc
        self.python_implementation = platform.python_implementation()

        # Get python include path
        self.python_include_path = get_python_inc()

        # Get python lib path
        # Note that we need the actual ld path where libpython.so/dylib/dll resides
        # and this seems like the only portable way at the moment
        lib_postfix = ".so"
        if "darwin" in self._os:
            lib_postfix = ".dylib"

        # The following search is split into two searches for /usr/lib and /usr/local
        # for speed purposes
        libpython = "lib" + self.python_interpreter + lib_postfix
        for root, _, filenames in os.walk('/usr/lib/'):
            for filename in fnmatch.filter(filenames, libpython):
                self.python_ld_path = os.path.join(
                    root, filename).rsplit(libpython)[0]
                break
        if self.python_ld_path is None:
            for root, _, filenames in os.walk('/usr/local/'):
                for filename in fnmatch.filter(filenames, libpython):
                    self.python_ld_path = os.path.join(
                        root, filename).rsplit(libpython)[0]
                    break

        # For conda envs change python_ld_path
        if "conda" in sys.version or "Continuum" in sys.version or "Intel" in sys.version:
            self.python_ld_path = get_config_var("LIBDIR")

        # Sanity check
        if self.python_ld_path is None:
            try:
                self.python_ld_path = get_config_var("LIBDIR")
            except:
                raise RuntimeError("Could not find libpython")

        # Get postfix for extensions
        self.extension_postfix = get_config_vars()['SO'][1:]
        if self.extension_postfix is None:
            if "darwin" in self._os:
                self.extension_postfix = "dylib"
            else:
                self.extension_postfix = "so"
Пример #60
0
try:
    from numpy.distutils.misc_util import get_info
    from os.path import dirname
    WITHNUMPY = True
except:
    WITHNUMPY = False

srcs = [x for x in 
    glob.glob("libBigWig/*.c")]
srcs.append("pyBigWig.c")

libs=["m", "z"]

# do not link to python on mac, see https://github.com/deeptools/pyBigWig/issues/58
if 'dynamic_lookup' not in (sysconfig.get_config_var('LDSHARED') or ''):
    if sysconfig.get_config_vars('BLDLIBRARY') is not None:
        #Note the "-l" prefix!
        for e in sysconfig.get_config_vars('BLDLIBRARY')[0].split():
            if e[0:2] == "-l":
                libs.append(e[2:])
    elif sys.version_info[0] >= 3 and sys.version_info[1] >= 3:
        libs.append("python%i.%im" % (sys.version_info[0], sys.version_info[1]))
    else:
        libs.append("python%i.%i" % (sys.version_info[0], sys.version_info[1]))

additional_libs = [sysconfig.get_config_var("LIBDIR"), sysconfig.get_config_var("LIBPL")]

defines = []
try:
    foo, _ = subprocess.Popen(['curl-config', '--libs'], stdout=subprocess.PIPE).communicate()
    libs.append("curl")