Exemple #1
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)
Exemple #2
0
 def build_extensions(self):
     import subprocess
     subprocess.call(["make", "-f", "Makefile", "clean"],
                     cwd=XPALIB_DIR)
     subprocess.call(["sh", "./configure"], cwd=XPALIB_DIR)
     subprocess.call(["make", "-f", "Makefile"], cwd=XPALIB_DIR)
     build_ext.build_extensions(self)
Exemple #3
0
 def build_extensions(self):
     compiler = self.compiler
     if sys.platform != 'win32':
         build_ext.build_extensions(self)
     else:
         print("Warning: the C extensions will not be built since the compiler could not be found.\n"\
                 "See https://github.com/bsmurphy/PyKrige/issues/8 ")
Exemple #4
0
    def build_extensions(self):
        numpy_incl = pkg_resources.resource_filename('numpy', 'core/include')

        for ext in self.extensions:
            if hasattr(ext, 'include_dirs') and not numpy_incl in ext.include_dirs:
                ext.include_dirs.append(numpy_incl)
        _build_ext.build_extensions(self)
Exemple #5
0
 def build_extensions(self):
     customize_compiler(self.compiler)
     try:
         self.compiler.compiler_so.remove("-Wstrict-prototypes")
     except (AttributeError, ValueError):
         pass
     build_ext.build_extensions(self)
Exemple #6
0
    def build_extensions(self):
        print('Build configuration is:')
        for opt, value in c_options.items():
            print(' * {0} = {1}'.format(opt, value))
        print('Generate config.h')
        config_h = join(dirname(__file__), 'kivy', 'graphics', 'config.h')
        with open(config_h, 'w') as fd:
            fd.write('// Autogenerated file for Kivy C configuration\n')
            for k, v in c_options.items():
                fd.write('#define __{0} {1}\n'.format(k.upper(), int(v)))

        print('Generate config.pxi')
        config_pxi = join(dirname(__file__), 'kivy', 'graphics', 'config.pxi')
        with open(config_pxi, 'w') as fd:
            fd.write('# Autogenerated file for Kivy Cython configuration\n')
            for k, v in c_options.items():
                fd.write('DEF {0} = {1}\n'.format(k.upper(), int(v)))
            fd.write('DEF PY3 = {0}\n'.format(int(PY3)))

        c = self.compiler.compiler_type
        print('Detected compiler is {}'.format(c))
        if c != 'msvc':
            for e in self.extensions:
                e.extra_link_args += ['-lm']

        build_ext.build_extensions(self)
Exemple #7
0
    def build_extensions(self):
        print('Build configuration is:')
        for opt, value in c_options.items():
            print(' * {0} = {1}'.format(opt, value))
        print('Generate config.h')
        config_h_fn = expand('graphics', 'config.h')
        config_h = '// Autogenerated file for Kivy C configuration\n'
        config_h += '#define __PY3 {0}\n'.format(int(PY3))
        for k, v in c_options.items():
            config_h += '#define __{0} {1}\n'.format(k.upper(), int(v))
        self.update_if_changed(config_h_fn, config_h)

        print('Generate config.pxi')
        config_pxi_fn = expand('graphics', 'config.pxi')
        # update the pxi only if the content changed
        config_pxi = '# Autogenerated file for Kivy Cython configuration\n'
        config_pxi += 'DEF PY3 = {0}\n'.format(int(PY3))
        for k, v in c_options.items():
            config_pxi += 'DEF {0} = {1}\n'.format(k.upper(), int(v))
        self.update_if_changed(config_pxi_fn, config_pxi)

        c = self.compiler.compiler_type
        print('Detected compiler is {}'.format(c))
        if c != 'msvc':
            for e in self.extensions:
                e.extra_link_args += ['-lm']

        build_ext.build_extensions(self)
Exemple #8
0
 def build_extensions(self):
     binary = self.compiler.compiler[0]
     if is_clang(binary):
         for e in self.extensions:
             e.extra_compile_args.append('-stdlib=libc++')
             if platform.system() == 'Darwin':
                 e.extra_compile_args.append('-mmacosx-version-min=10.7')
     build_ext.build_extensions(self)
Exemple #9
0
 def build_extensions(self, *args, **kwargs):
     compiler_type = self.compiler.compiler_type
     if compiler_type not in extra_args:
         compiler_type = 'unix'  # probably some unix-like compiler
     # merge compile and link arguments with global arguments for current compiler
     for e in self.extensions:
         e.extra_compile_args = list(set(e.extra_compile_args + extra_args[compiler_type]['extra_compile_args']))
         e.extra_link_args = list(set(e.extra_link_args + extra_args[compiler_type]['extra_link_args']))
     _build_ext.build_extensions(self, *args, **kwargs)
Exemple #10
0
 def build_extensions(self):
     try:
         build_ext.build_extensions(self)
     except ext_errors:
         print("**************************************************")
         print("WARNING: Cython extensions failed to build. Falling back to pure Python implementation.\n"
               "See https://github.com/bsmurphy/PyKrige/issues/8 for more information.")
         print("**************************************************")
         raise BuildFailed()
Exemple #11
0
 def build_extensions(self):
     if use_openmp:
         compiler = self.compiler.compiler_type
         for ext in self.extensions:
             if compiler in BUILD_ARGS:
                 ext.extra_compile_args = BUILD_ARGS[compiler]
             if compiler in LINK_ARGS:
                 ext.extra_link_args    = LINK_ARGS[compiler]
     build_ext.build_extensions(self)
Exemple #12
0
 def build_extensions(self):
     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)
     build_ext.build_extensions(self)
Exemple #13
0
 def build_extensions(self):
     customize_compiler(self.compiler)
     try:
         self.compiler.compiler_so.remove("-Wstrict-prototypes")
     except (AttributeError, ValueError):
         pass
     lto_flags=["-flto", "-flto-partition=none", "-fuse-linker-plugin",
                "-ffat-lto-objects"]
     self.compiler.compiler_so = [f for f in self.compiler.compiler_so if f not in lto_flags]
     build_ext.build_extensions(self)
Exemple #14
0
 def build_extensions(self):
     print 'Generate config.pxi'
     filename = os.path.join(os.path.dirname(__file__), 'config.pxi')
     with open(filename, 'w') as fd:
             for k, v in c_options.iteritems():
                         fd.write('DEF %s = %d\n' % (k.upper(), int(v)))
     build_ext.build_extensions(self)
     os.remove(filename)
     cppfilename = os.path.join(os.path.dirname(__file__), 'cyni.cpp')
     os.remove(cppfilename)
Exemple #15
0
    def build_extensions(self):
        if self.compiler.compiler_type in translator:
            trans = translator[self.compiler.compiler_type]
        else:
            trans = translator["default"]

        for e in self.extensions:
            e.extra_compile_args = [trans[a][0] if a in trans else a for a in e.extra_compile_args]
            e.extra_link_args = [trans[a][1] if a in trans else a for a in e.extra_link_args]
            e.libraries = [trans[arg] for arg in e.libraries if arg in trans]
        build_ext.build_extensions(self)
Exemple #16
0
    def build_extensions(self):
        c = self.compiler.compiler_type
        if c == "msvc":
            for e in self.extensions:
                e.extra_compile_args = ["/EHsc"]
            userdir = os.environ["USERPROFILE"]
            os.environ["INCLUDE"] = (
                userdir + "\\AppData\\Local\\Programs\\Common\\Microsoft\\Visual C++ for Python\\9.0\\VC\\include\\"
            )

        build_ext.build_extensions(self)
Exemple #17
0
    def build_extensions(self):
        numpy_incl = pkg_resources.resource_filename('numpy', 'core/include')

        self.extensions = [ext for ext in self.extensions
                           if ext.name != '__dummy__']

        for ext in self.extensions:
            if (hasattr(ext, 'include_dirs') and
                    numpy_incl not in ext.include_dirs):
                ext.include_dirs.append(numpy_incl)
        _build_ext.build_extensions(self)
Exemple #18
0
 def build_extensions(self):
     extra_compile_args = ['-w', '-Ofast']
     cmd = "echo | %s -E - %s &>/dev/null" % (
         self.compiler.compiler[0], " ".join(extra_compile_args))
     try:
         subprocess.check_call(cmd, shell=True)
     except:
         extra_compile_args = ['-w', '-O3']
     for e in self.extensions:
         e.extra_compile_args = extra_compile_args
     build_ext.build_extensions(self)
Exemple #19
0
    def build_extensions(self):
        # build files
        config_h_fn = ('graphics', 'config.h')
        config_pxi_fn = ('graphics', 'config.pxi')
        config_py_fn = ('setupconfig.py', )

        # generate headers
        config_h = '// Autogenerated file for Kivy C configuration\n'
        config_h += '#define __PY3 {0}\n'.format(int(PY3))
        config_pxi = '# Autogenerated file for Kivy Cython configuration\n'
        config_pxi += 'DEF PY3 = {0}\n'.format(int(PY3))
        config_py = '# Autogenerated file for Kivy configuration\n'
        config_py += 'PY3 = {0}\n'.format(int(PY3))
        config_py += 'CYTHON_MIN = {0}\nCYTHON_MAX = {1}\n'.format(
            repr(MIN_CYTHON_STRING), repr(MAX_CYTHON_STRING))
        config_py += 'CYTHON_BAD = {0}\n'.format(repr(', '.join(map(
            str, CYTHON_UNSUPPORTED))))

        # generate content
        print('Build configuration is:')
        for opt, value in c_options.items():
            value = int(bool(value))
            print(' * {0} = {1}'.format(opt, value))
            opt = opt.upper()
            config_h += '#define __{0} {1}\n'.format(opt, value)
            config_pxi += 'DEF {0} = {1}\n'.format(opt, value)
            config_py += '{0} = {1}\n'.format(opt, value)
        debug = bool(self.debug)
        print(' * debug = {0}'.format(debug))
        config_h += \
            '#if __USE_GLEW && defined(_WIN32)\n#   define GLEW_BUILD\n#endif'

        config_pxi += 'DEF DEBUG = {0}\n'.format(debug)
        config_py += 'DEBUG = {0}\n'.format(debug)
        for fn, content in (
                (config_h_fn, config_h), (config_pxi_fn, config_pxi),
                (config_py_fn, config_py)):
            build_fn = expand(build_path, *fn)
            if self.update_if_changed(build_fn, content):
                print('Updated {}'.format(build_fn))
            src_fn = expand(src_path, *fn)
            if src_fn != build_fn and self.update_if_changed(src_fn, content):
                print('Updated {}'.format(src_fn))

        c = self.compiler.compiler_type
        print('Detected compiler is {}'.format(c))
        if c != 'msvc':
            for e in self.extensions:
                e.extra_link_args += ['-lm']
                if PY3:
                    e.extra_link_args += ['-lpython3.5m']
                
        build_ext.build_extensions(self)
Exemple #20
0
		def build_extensions(self):
			# First patch the files, the run the build
			patchCythonModules(self.build_lib)

			if cythonParallelBuild:
				# Run the parallel build, yay.
				self.check_extensions_list(self.extensions)
				from multiprocessing.pool import Pool
				Pool().map(cyBuildWrapper,
					   ((self, ext) for ext in self.extensions))
			else:
				# Run the normal non-parallel build.
				Cython_build_ext.build_extensions(self)
Exemple #21
0
            def build_extensions(self):
                # add path where 2to3 installed the transformed sources
                # and make sure Python (re-)imports them from there
                already_imported = [ module for module in sys.modules
                                     if module == 'Cython' or module.startswith('Cython.') ]
                for module in already_imported:
                    del sys.modules[module]
                sys.path.insert(0, os.path.join(source_root, self.build_lib))

                if profile:
                    from Cython.Compiler.Options import directive_defaults
                    directive_defaults['profile'] = True
                    print("Enabled profiling for the Cython binary modules")
                build_ext_orig.build_extensions(self)
Exemple #22
0
    def build_extensions(self):
        if self.compiler.compiler_type in translator:
            trans = translator[self.compiler.compiler_type]
        else:
            trans = translator['default']

        for e in self.extensions:
            e.extra_compile_args = [ trans[a][0] if a in trans else a
                                    for a in e.extra_compile_args]
            e.extra_link_args = [ trans[a][1] if a in trans else a
                                 for a in e.extra_link_args]
            e.libraries = list(filter(None, [ trans[a] if a in trans else None
                                        for a in e.libraries]))
        build_ext.build_extensions(self)
Exemple #23
0
 def build_extensions(self):
     try:
         build_ext.build_extensions(self)
     except ext_errors:
         print("**************************************************")
         print("WARNING: Cython extensions failed to build (used in abel.direct).\n"
               "Typical reasons for this problem are:\n"
               "  - a C compiler is not installed or not found\n"
               "  - issues using mingw compiler on Windows 64bit (experimental support for now)\n"
               "This only means that the abel.direct C implementation will not be available.\n")
         print("**************************************************")
         # continue the install
         pass
     except:
         raise
Exemple #24
0
 def build_extensions(self):
     ct = self.compiler.compiler_type
     opts = self.c_opts.get(ct, [])
     if ct == 'unix':
         opts.append('-DVERSION_INFO="%s"' % self.distribution.get_version())
         opts.append(cpp_flag(self.compiler))
         if has_flag(self.compiler, '-fopenmp'):
             opts.append('-fopenmp')
         if has_flag(self.compiler, '-fvisibility=hidden'):
             opts.append('-fvisibility=hidden')
     elif ct == 'msvc':
         opts.append('/DVERSION_INFO=\\"%s\\"' % self.distribution.get_version())
     for ext in self.extensions:
         ext.extra_compile_args = opts
     build_ext.build_extensions(self)
Exemple #25
0
    def build_extensions(self):
        print "Generate config.h"
        config_h = join(dirname(__file__), "kivy", "graphics", "config.h")
        with open(config_h, "w") as fd:
            fd.write("// Autogenerated file for Kivy C configuration\n")
            for k, v in c_options.iteritems():
                fd.write("#define __%s %d\n" % (k.upper(), int(v)))

        print "Generate config.pxi"
        config_pxi = join(dirname(__file__), "kivy", "graphics", "config.pxi")
        with open(config_pxi, "w") as fd:
            fd.write("# Autogenerated file for Kivy Cython configuration\n")
            for k, v in c_options.iteritems():
                fd.write("DEF %s = %d\n" % (k.upper(), int(v)))

        build_ext.build_extensions(self)
            def build_extensions(self):
                """
                Lazily append numpy's include directory to Extension includes.
                This is done here rather than at module scope because setup.py
                may be run before numpy has been installed, in which case
                importing numpy and calling `numpy.get_include()` will fail.
                """
                numpy_incl = resource_filename('numpy', 'core/include')
                for ext in self.extensions:
                    ext.include_dirs.append(numpy_incl)

                # This explicitly calls the superclass method rather than the
                # usual super() invocation because distutils' build_class, of
                # which Cython's build_ext is a subclass, is an old-style class
                # in Python 2, which doesn't support `super`.
                cython_build_ext.build_extensions(self)
Exemple #27
0
    def build_extensions(self):
        print 'Generate config.h'
        config_h = join(dirname(__file__), 'kivy', 'graphics', 'config.h')
        with open(config_h, 'w') as fd:
            fd.write('// Autogenerated file for Kivy C configuration\n')
            for k, v in c_options.iteritems():
                fd.write('#define __%s %d\n' % (k.upper(), int(v)))

        print 'Generate config.pxi'
        config_pxi = join(dirname(__file__), 'kivy', 'graphics', 'config.pxi')
        with open(config_pxi, 'w') as fd:
            fd.write('# Autogenerated file for Kivy Cython configuration\n')
            for k, v in c_options.iteritems():
                fd.write('DEF %s = %d\n' % (k.upper(), int(v)))

        build_ext.build_extensions(self)
Exemple #28
0
    def build_extensions(self):
        # build files
        config_h_fn = ("graphics", "config.h")
        config_pxi_fn = ("graphics", "config.pxi")
        config_py_fn = ("setupconfig.py",)

        # generate headers
        config_h = "// Autogenerated file for Kivy C configuration\n"
        config_h += "#define __PY3 {0}\n".format(int(PY3))
        config_pxi = "# Autogenerated file for Kivy Cython configuration\n"
        config_pxi += "DEF PY3 = {0}\n".format(int(PY3))
        config_py = "# Autogenerated file for Kivy configuration\n"
        config_py += "PY3 = {0}\n".format(int(PY3))
        config_py += "CYTHON_MIN = {0}\nCYTHON_MAX = {1}\n".format(repr(MIN_CYTHON_STRING), repr(MAX_CYTHON_STRING))
        config_py += "CYTHON_BAD = {0}\n".format(repr(", ".join(map(str, CYTHON_UNSUPPORTED))))

        # generate content
        print("Build configuration is:")
        for opt, value in c_options.items():
            value = int(bool(value))
            print(" * {0} = {1}".format(opt, value))
            opt = opt.upper()
            config_h += "#define __{0} {1}\n".format(opt, value)
            config_pxi += "DEF {0} = {1}\n".format(opt, value)
            config_py += "{0} = {1}\n".format(opt, value)
        debug = bool(self.debug)
        print(" * debug = {0}".format(debug))
        config_h += "#if __USE_GLEW && defined(_WIN32)\n#   define GLEW_BUILD\n#endif"

        config_pxi += "DEF DEBUG = {0}\n".format(debug)
        config_py += "DEBUG = {0}\n".format(debug)
        for fn, content in ((config_h_fn, config_h), (config_pxi_fn, config_pxi), (config_py_fn, config_py)):
            build_fn = expand(build_path, *fn)
            if self.update_if_changed(build_fn, content):
                print("Updated {}".format(build_fn))
            src_fn = expand(src_path, *fn)
            if src_fn != build_fn and self.update_if_changed(src_fn, content):
                print("Updated {}".format(src_fn))

        c = self.compiler.compiler_type
        print("Detected compiler is {}".format(c))
        if c != "msvc":
            for e in self.extensions:
                e.extra_link_args += ["-lm"]

        build_ext.build_extensions(self)
Exemple #29
0
    def build_extensions(self):
        global library_dirs, include_dirs

        if WINDOWS:
            # Detect the compiler so we can specify the correct command line switches
            # and libraries
            from distutils.cygwinccompiler import Mingw32CCompiler
            extra_cc_args = []
            # Distutils bug: self.compiler can be a string or a CCompiler
            # subclass instance, see http://bugs.python.org/issue6377
            if isinstance(self.compiler, str):
                compiler = self.compiler
            elif isinstance(self.compiler, Mingw32CCompiler):
                compiler = 'mingw32'
                freetds_dir = 'ming'
                extra_cc_args = [
                    '-Wl,-allow-multiple-definition',
                    '-Wl,-subsystem,windows-mthreads',
                    '-mwindows',
                    '-Wl,--strip-all'
                ]
                libraries = [
                    'libiconv', 'iconv',
                    'sybdb',
                    'ws2_32', 'wsock32', 'kernel32',
                ]
            else:
                compiler = 'msvc'
                freetds_dir = 'vs2008'
                libraries = [
                    'db-lib', 'tds',
                    'ws2_32', 'wsock32', 'kernel32', 'shell32',
                ]

            FREETDS = osp.join(ROOT, 'freetds', '{0}_{1}'.format(freetds_dir, BITNESS))
            for e in self.extensions:
                e.extra_compile_args.extend(extra_cc_args)
                e.libraries.extend(libraries)
                e.include_dirs.append(osp.join(FREETDS, 'include'))
                e.library_dirs.append(osp.join(FREETDS, 'lib'))

        else:
            libraries = [ "sybdb" ]   # on Mandriva you may have to change it to sybdb_mssql
            for e in self.extensions:
                e.libraries.extend(libraries)
        _build_ext.build_extensions(self)
Exemple #30
0
    def build_extensions(self):
        if self.compiler.compiler_type == 'msvc':
            bitness = struct.calcsize("P") * 8
            print "Compiling for", bitness, "bit environment"
            for e in self.extensions:
                e.include_dirs = [numpy.get_include(), 
                                  os.path.join('fftw_wrapper'),]
                e.extra_compile_args = ['/openmp']
                e.libraries = [os.path.join({32 : 'fftw_32', 64: 'fftw_64'}[bitness], 'libfftw3-3')]
        else:
            for e in self.extensions:
                e.include_dirs = [numpy.get_include(), 
                                  os.path.join('fftw_wrapper'),]
                e.extra_compile_args = ['-fopenmp']
                e.extra_link_args = ['-fopenmp', '-lm', '-lfftw3', '-lfftw3_threads']
                

        build_ext.build_extensions(self)
Exemple #31
0
 def build_extensions(self):
     if self.compiler.compiler_type == 'mingw32':
         customize_mingw(self.compiler)
     return build_ext_c.build_extensions(self)
 def build_extensions(self):
     # customize_compiler_for_nvcc(self.compiler) # MSVCComplier doesn't support this.
     self.compiler.src_extensions.append('.cu')
     build_ext.build_extensions(self)
Exemple #33
0
    def build_extensions(self):

        # This code is adapted from
        # scikit-learn/sklearn/_build_utils/openmp_helpers.py
        # (version last updated on 13 Nov 2019; 9876f74)
        # See https://github.com/scikit-learn/scikit-learn and https://scikit-learn.org/.

        if hasattr(self.compiler, 'compiler'):
            compiler = self.compiler.compiler[0]
        else:
            compiler = self.compiler.__class__.__name__

        if sys.platform == "win32" and ('icc' in compiler or 'icl' in compiler):
            for e in self.extensions:
                e.extra_compile_args += ['/Qopenmp', '/Qstd=c++11']
                e.extra_link_args += ['/Qopenmp']
        elif sys.platform == "win32":
            for e in self.extensions:
                e.extra_compile_args += ['/openmp']
                e.extra_link_args += ['/openmp']
        elif sys.platform == "darwin" and ('icc' in compiler or 'icl' in compiler):
            for e in self.extensions:
                e.extra_compile_args += ['-openmp', '-std=c++11']
                e.extra_link_args += ['-openmp']
        elif sys.platform == "darwin":  # and 'openmp' in os.getenv('CPPFLAGS', ''):
            # -fopenmp can't be passed as compile flag when using Apple-clang.
            # OpenMP support has to be enabled during preprocessing.
            #
            # For example, our macOS wheel build jobs use the following environment
            # variables to build with Apple-clang and the brew installed "libomp":
            #
            # export CPPFLAGS="$CPPFLAGS -Xpreprocessor -fopenmp"
            # export CFLAGS="$CFLAGS -I/usr/local/opt/libomp/include"
            # export CXXFLAGS="$CXXFLAGS -I/usr/local/opt/libomp/include"
            # export LDFLAGS="$LDFLAGS -Wl,-rpath,/usr/local/opt/libomp/lib
            #                          -L/usr/local/opt/libomp/lib -lomp"
            for e in self.extensions:
                e.extra_compile_args += ['-std=c++11']
            pass
        elif sys.platform == "linux":
            # Default flag for GCC and clang:
            for e in self.extensions:
                e.extra_compile_args += ['-fopenmp', '-std=c++11']
                e.extra_link_args += ['-fopenmp']
        else:
            pass

        # Old version:
        # c = self.compiler.compiler_type
        # if c == "msvc":
        #     for e in self.extensions:
        #         e.extra_compile_args += "/openmp"
        # elif c == "mingw32":
        #     for e in self.extensions:
        #         e.extra_compile_args += "-fopenmp"
        #         e.extra_link_args += "-fopenmp"
        # elif c == "unix":
        #     # Well... gcc/clang has -fopenmp,
        #     # icc has -openmp, oracle has -xopenmp, etc.
        #     # The user should specify CXXFLAGS and LDFLAGS herself, I think.
        #     pass

        build_ext.build_extensions(self)
Exemple #34
0
    def build_extensions(self):
        """
        Specifies compiler and linker flags depending on the compiler.

        .. warning::

            DO NOT USE '-march=native' flag. By using this flag, the compiler
            optimizes the instructions for the native machine of the build time
            and the executable will not be backward compatible to older CPUs.
            As a result, the package will not be distributable on other
            machines as the installation with the binary wheel crashes on other
            machines with this error:

                'illegal instructions (core dumped).'

            An alternative optimization flag is '-mtune=native', which is
            backward compatible and the package can be installed using wheel
            binary file.
        """

        # Get compiler type. This is "unix" (linux, mac) or "msvc" (windows)
        compiler_type = self.compiler.compiler_type

        # Initialize flags
        extra_compile_args = []
        extra_link_args = []

        if compiler_type == 'msvc':

            # This is Microsoft Windows Visual C++ compiler
            msvc_compile_args = ['/O2', '/Wall', '/openmp']
            msvc_link_args = []
            msvc_has_openmp_flag = check_compiler_has_flag(
                    self.compiler,
                    msvc_compile_args,
                    msvc_link_args)

            if msvc_has_openmp_flag:

                # Add flags
                extra_compile_args += msvc_compile_args
                extra_link_args += msvc_link_args

            else:

                # It does not seem msvc accept -fopenmp flag.
                raise RuntimeError(textwrap.dedent(
                    """
                    OpenMP does not seem to be available on %s compiler.
                    """ % compiler_type))

        else:

            # The compile_type is 'unix'. This is either linux or mac.
            # We add common flags that work both for gcc and mac's clang
            extra_compile_args += ['-O3', '-fno-stack-protector', '-Wall']

            # The option '-Wl, ..' will send arguments ot the linker. Here,
            # '--strip-all' will remove all symbols from the shared library.
            if not debug_mode:
                extra_compile_args += ['-g0', '-Wl, --strip-all']

            # Assume compiler is gcc (we do not know yet). Check if the
            # compiler accepts '-fopenmp' flag. Note: clang in mac does not
            # accept this flag alone, but gcc does.
            gcc_compile_args = ['-fopenmp']
            gcc_link_args = ['-fopenmp']
            gcc_has_openmp_flag = check_compiler_has_flag(
                    self.compiler,
                    gcc_compile_args,
                    gcc_link_args)

            if gcc_has_openmp_flag:

                # Assuming this is gcc. Add '-fopenmp' safely.
                extra_compile_args += gcc_compile_args
                extra_link_args += gcc_link_args

            else:

                # Assume compiler is clang (we do not know yet). Check if
                # -fopenmp can be passed through preprocessor. This is how
                # clang compiler accepts -fopenmp.
                clang_compile_args = ['-Xpreprocessor', '-fopenmp']
                clang_link_args = ['-Xpreprocessor', '-fopenmp', '-lomp']
                clang_has_openmp_flag = check_compiler_has_flag(
                        self.compiler,
                        clang_compile_args,
                        clang_link_args)

                if clang_has_openmp_flag:

                    # Assuming this is mac's clag. Add '-fopenmp' through
                    # preprocessor
                    extra_compile_args += clang_compile_args
                    extra_link_args += clang_link_args

                else:

                    # It doesn't seem either gcc or clang accept -fopenmp flag.
                    raise RuntimeError(textwrap.dedent(
                        """
                        OpenMP does not seem to be available on %s compiler.
                        """ % compiler_type))

        # Modify compiler flags for cuda
        if use_cuda:

            # Compile flags for nvcc
            if sys.platform == 'win32':
                extra_compile_args_nvcc = ['/Ox']
            else:
                extra_compile_args_nvcc = ['-arch=sm_35', '--ptxas-options=-v',
                                           '-c', '--compiler-options', '-fPIC',
                                           '-O3', '--verbose', '--shared']

            # The option '-Wl, ..' will send arguments ot the linker. Here,
            # '--strip-all' will remove all symbols from the shared library.
            if debug_mode:
                extra_compile_args_nvcc += ['-g', '-G']
            else:
                extra_compile_args_nvcc += ['--linker-options', '--strip-all']

            # Redefine extra_compile_args list to be a dictionary
            extra_compile_args = {
                'not_nvcc': extra_compile_args,
                'nvcc': extra_compile_args_nvcc
            }

        # Add the flags to all extensions
        for ext in self.extensions:
            ext.extra_compile_args = extra_compile_args
            ext.extra_link_args = extra_link_args

        # Parallel compilation (can also be set via build_ext -j or --parallel)
        # Note: parallel build fails in windows since object files are accessed
        # by race condition.
        # if sys.platform != 'win32':
        #     self.parallel = multiprocessing.cpu_count()

        # Modify compiler for cuda
        if use_cuda:
            cuda = locate_cuda()

            if sys.platform == 'win32':
                customize_windows_compiler_for_nvcc(self.compiler, cuda)
            else:
                customize_unix_compiler_for_nvcc(self.compiler, cuda)

        # Remove warning: command line option '-Wstrict-prototypes' is valid
        # for C/ObjC but not for C++
        try:
            if '-Wstrict-prototypes' in self.compiler.compiler_so:
                self.compiler.compiler_so.remove('-Wstrict-prototypes')
        except (AttributeError, ValueError):
            pass

        # Call parent class to build
        build_ext.build_extensions(self)
Exemple #35
0
 def build_extensions(self):
     build_ext.build_extensions(self)
Exemple #36
0
    def build_extensions(self):
        # Register .cu and .cuh as valid source extensions.
        self.compiler.src_extensions += [".cu", ".cuh"]
        # Save the original _compile method for later.
        if self.compiler.compiler_type == "msvc":
            self.compiler._cpp_extensions += [".cu", ".cuh"]
            original_compile = self.compiler.compile
            original_spawn = self.compiler.spawn
        else:
            original_compile = self.compiler._compile

        def unix_wrap_compile(obj, src, ext, cc_args, extra_postargs, pp_opts):
            # Copy before we make any modifications.
            cflags = copy.deepcopy(extra_postargs)
            try:
                original_compiler = self.compiler.compiler_so
                if _is_cuda_file(src):
                    nvcc = _join_cuda_home("bin", "nvcc")
                    if not isinstance(nvcc, list):
                        nvcc = [nvcc]
                    self.compiler.set_executable("compiler_so", nvcc)
                    if isinstance(cflags, dict):
                        cflags = cflags["nvcc"]
                    cflags = (COMMON_NVCC_FLAGS +
                              ["--compiler-options", "'-fPIC'"] + cflags +
                              COMPUTE_CAPABILITY_ARGS)
                elif isinstance(cflags, dict):
                    cflags = cflags["cxx"]
                # NVCC does not allow multiple -std to be passed, so we avoid
                # overriding the option if the user explicitly passed it.
                if not any(flag.startswith("-std=") for flag in cflags):
                    cflags.append("-std=c++11")

                original_compile(obj, src, ext, cc_args, cflags, pp_opts)
            finally:
                # Put the original compiler back in place.
                self.compiler.set_executable("compiler_so", original_compiler)

        def win_wrap_compile(
            sources,
            output_dir=None,
            macros=None,
            include_dirs=None,
            debug=0,
            extra_preargs=None,
            extra_postargs=None,
            depends=None,
        ):

            cflags = copy.deepcopy(extra_postargs)
            extra_postargs = None

            def spawn(cmd, cflags):
                # Using regex to match src, obj and include files
                src_regex = re.compile("/T(p|c)(.*)")
                src_list = [
                    m.group(2) for m in (src_regex.match(elem) for elem in cmd)
                    if m
                ]

                obj_regex = re.compile("/Fo(.*)")
                obj_list = [
                    m.group(1) for m in (obj_regex.match(elem) for elem in cmd)
                    if m
                ]

                include_regex = re.compile(r"((\-|\/)I.*)")
                include_list = [
                    m.group(1)
                    for m in (include_regex.match(elem) for elem in cmd) if m
                ]

                if len(src_list) >= 1 and len(obj_list) >= 1:
                    src = src_list[0]
                    obj = obj_list[0]
                    if _is_cuda_file(src):
                        nvcc = _join_cuda_home("bin", "nvcc")
                        if isinstance(cflags, dict):
                            cflags = cflags["nvcc"]
                        elif not isinstance(cflags, list):
                            cflags = []

                        cflags = COMMON_NVCC_FLAGS + cflags + COMPUTE_CAPABILITY_ARGS
                        for flag in COMMON_MSVC_FLAGS:
                            cflags = ["-Xcompiler", flag] + cflags
                        for macro in macros:
                            if len(macro) == 2:
                                if macro[1] == None:
                                    cflags += ["--define-macro", macro[0]]
                                else:
                                    cflags += [
                                        "--define-macro",
                                        "{}={}".format(macro[0], macro[1])
                                    ]
                            elif len(macro) == 1:
                                cflags += ["--undefine-macro", macro[0]]

                        cmd = [nvcc, "-c", src, "-o", obj
                               ] + include_list + cflags
                    elif isinstance(cflags, dict):
                        cflags = COMMON_MSVC_FLAGS  # + self.cflags['cxx']
                        cmd += cflags
                    elif isinstance(cflags, list):
                        cflags = COMMON_MSVC_FLAGS + cflags
                        cmd += cflags

                return original_spawn(cmd)

            try:
                self.compiler.spawn = lambda cmd: spawn(cmd, cflags)
                return original_compile(
                    sources,
                    output_dir,
                    macros,
                    include_dirs,
                    debug,
                    extra_preargs,
                    extra_postargs,
                    depends,
                )
            finally:
                self.compiler.spawn = original_spawn

        # Monkey-patch the _compile method.
        if self.compiler.compiler_type == "msvc":
            self.compiler.compile = win_wrap_compile
        else:
            self.compiler._compile = unix_wrap_compile

        build_ext.build_extensions(self)
Exemple #37
0
 def build_extensions(self):
     customize_compiler(self.compiler)
     build_ext.build_extensions(self)
Exemple #38
0
    def build_extensions(self):
        print("Running custom build_ext")

        numpy_incl = pkg_resources.resource_filename("numpy", "core/include")

        if sys.platform == "darwin":
            # Platform: Mac OS
            version, _, _ = platform.mac_ver()
            parts = version.split(".")
            major = int(parts[0])
            minor = int(parts[1])
            patch = int(parts[2]) if len(parts) == 3 else None

            if minor >= 15:
                # Greater than Mac OS: 10.15
                extra_compile_args = [
                    "-I/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/System/Library/Frameworks/Accelerate.framework/Versions/Current/Frameworks/vecLib.framework/Headers/"
                ]
            elif minor >= 10:
                # Greater than Mac OS: 10.10
                extra_compile_args = [
                    "-I/System/Library/Frameworks/Accelerate.framework/Versions/A/Frameworks/vecLib.framework/Versions/Current/Headers"
                ]
            else:
                extra_compile_args = [
                    "-I/System/Library/Frameworks/vecLib.framework/Headers"
                ]

            ext_module = Extension(
                name="st_dsne",
                sources=[
                    "dsne/includes/st_dsne/dsne.cpp",
                    "dsne/st_dsne.pyx",
                ],
                include_dirs=["dsne/includes/st_dsne/"],
                extra_compile_args=extra_compile_args,
                extra_link_args=[
                    "-Wl,-framework", "-Wl,Accelerate", "-lcblas"
                ],
                language="c++",
            )

            self.extensions.append(ext_module)
        else:
            # Platform: Linux
            extra_link_args = ["-lcblas"]

            ext_module = Extension(
                name="st_dsne",
                sources=[
                    "dsne/includes/st_dsne/dsne.cpp",
                    "dsne/st_dsne.pyx",
                ],
                include_dirs=["/usr/local/include", "dsne/includes/st_dsne/"],
                library_dirs=["/usr/local/lib"],
                extra_compile_args=["-msse2", "-O3", "-fPIC", "-w"],
                extra_link_args=extra_link_args,
                language="c++",
            )
            self.extensions.append(ext_module)

        self.extensions = [
            ext for ext in self.extensions if ext.name != "__dummy__"
        ]

        for ext in self.extensions:
            if hasattr(ext,
                       "include_dirs") and numpy_incl not in ext.include_dirs:
                ext.include_dirs.append(numpy_incl)

        _build_ext.build_extensions(self)
Exemple #39
0
 def build_extensions(self):
     compiler = self.compiler.compiler_type
     args = BUILD_ARGS[compiler]
     for ext in self.extensions:
         ext.extra_compile_args = args
     build_ext.build_extensions(self)
Exemple #40
0
 def build_extensions(self):
     self.extensions = my_cythonize(self.extensions)
     return build_ext.build_extensions(self)
Exemple #41
0
 def build_extensions(self):
     fully_define_extension(self)
     customize_compiler_for_nvcc(self.compiler)
     build_ext.build_extensions(self)
Exemple #42
0
 def build_extensions(self):
     customize_compiler_for_nvcc(self.compiler)
     build_ext.build_extensions(self)
Exemple #43
0
 def build_extensions(self):
     # First patch the files, the run the normal build
     patchCythonModules(self.build_lib)
     Cython_build_ext.build_extensions(self)
Exemple #44
0
    def build_extensions(self):
        # Register .cu and .cuh as valid source extensions.
        self.compiler.src_extensions += ['.cu', '.cuh']
        # Save the original _compile method for later.
        if self.compiler.compiler_type == 'msvc':
            self.compiler._cpp_extensions += ['.cu', '.cuh']
            original_compile = self.compiler.compile
            original_spawn = self.compiler.spawn
        else:
            original_compile = self.compiler._compile

        def unix_wrap_compile(obj, src, ext, cc_args, extra_postargs, pp_opts):
            # Copy before we make any modifications.
            cflags = copy.deepcopy(extra_postargs)
            try:
                original_compiler = self.compiler.compiler_so
                if _is_cuda_file(src):
                    nvcc = _join_cuda_home('bin', 'nvcc')
                    if not isinstance(nvcc, list):
                        nvcc = [nvcc]
                    self.compiler.set_executable('compiler_so', nvcc)
                    if isinstance(cflags, dict):
                        cflags = cflags['nvcc']
                    cflags = COMMON_NVCC_FLAGS + [
                        '--compiler-options', "'-fPIC'"
                    ] + cflags + COMPUTE_CAPABILITY_ARGS
                elif isinstance(cflags, dict):
                    cflags = cflags['cxx']
                # NVCC does not allow multiple -std to be passed, so we avoid
                # overriding the option if the user explicitly passed it.
                if not any(flag.startswith('-std=') for flag in cflags):
                    cflags.append('-std=c++11')

                original_compile(obj, src, ext, cc_args, cflags, pp_opts)
            finally:
                # Put the original compiler back in place.
                self.compiler.set_executable('compiler_so', original_compiler)

        def win_wrap_compile(sources,
                             output_dir=None,
                             macros=None,
                             include_dirs=None,
                             debug=0,
                             extra_preargs=None,
                             extra_postargs=None,
                             depends=None):

            cflags = copy.deepcopy(extra_postargs)
            extra_postargs = None

            def spawn(cmd, cflags):
                # Using regex to match src, obj and include files
                src_regex = re.compile('/T(p|c)(.*)')
                src_list = [
                    m.group(2) for m in (src_regex.match(elem) for elem in cmd)
                    if m
                ]

                obj_regex = re.compile('/Fo(.*)')
                obj_list = [
                    m.group(1) for m in (obj_regex.match(elem) for elem in cmd)
                    if m
                ]

                include_regex = re.compile(r'((\-|\/)I.*)')
                include_list = [
                    m.group(1)
                    for m in (include_regex.match(elem) for elem in cmd) if m
                ]

                if len(src_list) >= 1 and len(obj_list) >= 1:
                    src = src_list[0]
                    obj = obj_list[0]
                    if _is_cuda_file(src):
                        nvcc = _join_cuda_home('bin', 'nvcc')
                        if isinstance(cflags, dict):
                            cflags = cflags['nvcc']
                        elif not isinstance(cflags, list):
                            cflags = []

                        cflags = COMMON_NVCC_FLAGS + cflags + COMPUTE_CAPABILITY_ARGS
                        for flag in COMMON_MSVC_FLAGS:
                            cflags = ['-Xcompiler', flag] + cflags
                        cmd = [nvcc, '-c', src, '-o', obj
                               ] + include_list + cflags
                    elif isinstance(cflags, dict):
                        cflags = COMMON_MSVC_FLAGS  #+ self.cflags['cxx']
                        cmd += cflags
                    elif isinstance(cflags, list):
                        cflags = COMMON_MSVC_FLAGS + cflags
                        cmd += cflags

                return original_spawn(cmd)

            try:
                self.compiler.spawn = lambda cmd: spawn(cmd, cflags)
                return original_compile(sources, output_dir, macros,
                                        include_dirs, debug, extra_preargs,
                                        extra_postargs, depends)
            finally:
                self.compiler.spawn = original_spawn

        # Monkey-patch the _compile method.
        if self.compiler.compiler_type == 'msvc':
            self.compiler.compile = win_wrap_compile
        else:
            self.compiler._compile = unix_wrap_compile

        build_ext.build_extensions(self)
Exemple #45
0
    def build_extensions(self):
        if self.distribution.disable_ext:
            return

        return build_ext.build_extensions(self)
Exemple #46
0
 def build_extensions(self):
     build_ext_options.build_options(self)
     build_ext.build_extensions(self)
Exemple #47
0
    def build_extensions(self):
        ## Lookup blas files and headers first
        nocblas_err_msg = "\n\nNo CBLAS library found - please install one with e.g. "
        nocblas_err_msg += "'sudo apt-get install libopenblas-dev' (or 'intel-mkl-full') (Debian/Ubuntu)"
        nocblas_err_msg += ", 'conda install mkl-devel' (Linux / Mac)"
        nocblas_err_msg += ", or 'pip install mkl-devel' (Windows / Linux / Mac)."
        from_rtd = os.environ.get('READTHEDOCS') == 'True'
        if not from_rtd:
            blas_path, blas_file, incl_path, incl_file, flags = findblas.find_blas(
            )
            if (blas_file is None) or (blas_path is None):
                raise ValueError(nocblas_err_msg)
            elif blas_file == "mkl_rt.dll":
                txt = "Found MKL library at:\n" + os.path.join(
                    blas_path, blas_file)
                txt += "\nHowever, it is missing .lib files - please install them with 'pip install mkl-devel'."
                raise ValueError(txt)
            elif bool(re.search(r"\.dll$", blas_file)):
                txt = "Found BLAS library at:\n" + os.path.join(
                    blas_path, blas_file)
                txt += "\nBut .lib files are missing! Please reinstall it (e.g. 'pip install mkl-devel')."
                raise ValueError(txt)
            else:
                if platform[:3] != "win":
                    print("Installation: Using BLAS library found in:\n" +
                          os.path.join(blas_path, blas_file) + "\n\n")
        else:
            flags = ['_FOR_RTD']
            blas_path, blas_file, incl_path, incl_file = [None] * 4

        ## if no CBLAS and no functions are present, there will be no prototypes for the cblas API
        if "NO_CBLAS" in flags:
            raise ValueError(nocblas_err_msg)

        ## Add findblas' header
        ## if installing with pip or setuptools, will be here (this is the ideal case)
        if os.path.exists(
                re.sub(r"__init__\.py$", "findblas.h", findblas.__file__)):
            finblas_head_fold = re.sub(r"__init__\.py$", "", findblas.__file__)

        ## if installing with distutils, will be placed here (this should ideally not happen)
        elif os.path.exists(os.path.join(sys.prefix, "include", "findblas.h")):
            finblas_head_fold = os.path.join(sys.prefix, "include")

        elif os.path.exists(os.path.join(sys.prefix, "findblas.h")):
            finblas_head_fold = sys.prefix

        ## if on a PEP518 environment, might be located elsewhere
        else:
            candidate_paths = [sys.prefix]
            try:
                candidate_paths.append(os.environ['PYTHONPATH'])
            except:
                pass
            if platform[:3] == "win":
                candidate_paths += os.environ['PATH'].split(";")
            else:
                candidate_paths += os.environ['PATH'].split(":")

            for path in candidate_paths:
                if bool(re.search(r"[Oo]verlay", path)):
                    clean_path = re.sub(r"^(.*[Oo]verlay).*$", r"\1", path)
                    if os.path.exists(
                            os.path.join(clean_path, "include", "findblas.h")):
                        finblas_head_fold = os.path.join(clean_path, "include")
                        break
                    elif os.path.exists(os.path.join(clean_path,
                                                     "findblas.h")):
                        finblas_head_fold = clean_path
                        break
                    elif os.path.exists(
                            os.path.join(clean_path, "site-packages",
                                         "findblas", "findblas.h")):
                        finblas_head_fold = os.path.join(
                            clean_path, "site-packages", "findblas")
                        break
                    elif os.path.exists(
                            os.path.join(clean_path, "Lib", "site-packages",
                                         "findblas", "findblas.h")):
                        finblas_head_fold = os.path.join(
                            clean_path, "Lib", "site-packages", "findblas")
                        break
                    elif os.path.exists(
                            os.path.join(clean_path, "lib", "site-packages",
                                         "findblas", "findblas.h")):
                        finblas_head_fold = os.path.join(
                            clean_path, "lib", "site-packages", "findblas")
                        break

            ## if still not found, try to get it from pip itself
            else:
                import pip
                import io
                from contextlib import redirect_stdout
                pip_outp = io.StringIO()
                with redirect_stdout(pip_outp):
                    pip.main(['show', '-f', 'findblas'])
                pip_outp = pip_outp.getvalue()
                pip_outp = pip_outp.split("\n")
                for ln in pip_outp:
                    if bool(re.search(r"^Location", ln)):
                        files_root = re.sub(r"^Location:\s+", "", ln)
                        break
                for ln in pip_outp:
                    if bool(re.search(r"findblas\.h$", ln)):
                        finblas_head_fold = os.path.join(
                            files_root,
                            re.sub(r"^(.*)[/\\]*findblas\.h$", r"\1", ln))
                        break

                ## if the header file doesn't exist, shall raise en error
                else:
                    raise ValueError(
                        "Could not find header file from 'findblas' - please try reinstalling with 'pip install --force findblas'"
                    )

        ## Pass extra flags for the header
        warning_msg = "No CBLAS headers were found - function propotypes might be unreliable."
        mkl_err_msg = "Missing MKL CBLAS headers, please reinstall with e.g. 'conda install mkl-include' or 'pip install mkl-include'."
        gsl_err_msg = "Missing GSL CBLAS headers, please reinstall with e.g. 'conda install gsl'."
        if incl_file == "mkl_cblas.h":
            flags.append("MKL_OWN_INCL_CBLAS")
        elif incl_file == "mkl_blas.h":
            raise ValueError(mkl_err_msg)
        elif incl_file == "cblas-openblas.h":
            flags.append("OPENBLAS_OWN_INCL")
        elif incl_file == "gsl_cblas.h":
            flags.append("GSL_OWN_INCL_CBLAS")
        elif incl_file == "gsl_blas.h":
            raise ValueError(gsl_err_msg)
        elif incl_file == "INCL_CBLAS":
            flags.append("INCL_CBLAS")
        elif incl_file == "blas.h":
            flags.append("INCL_BLAS")
            warnings.warn(warning_msg)
        elif (incl_path is None) or (incl_file is None):
            flags.append("NO_CBLAS_HEADER")
            warnings.warn(warning_msg)
        else:
            pass

        ## Now add them to the extension
        for e in self.extensions:
            if not from_rtd:
                if self.compiler.compiler_type == 'msvc':  # visual studio
                    e.extra_link_args += [os.path.join(blas_path, blas_file)]
                else:  # everything else which cares about following standards
                    if platform[:3] != "dar":
                        e.extra_link_args += [
                            "-L" + blas_path, "-l:" + blas_file
                        ]
                    else:
                        blas_shortened = re.sub(r"^lib", "", blas_file)
                        blas_shortened = re.sub(r"\.[A-Za-z]+$", "",
                                                blas_shortened)
                        e.extra_link_args += [
                            "-L" + blas_path, "-l" + blas_shortened
                        ]
                    if bool(re.search(r"\.a$", blas_file)):
                        if (bool(re.search(r"gsl", blas_file))):
                            e.extra_link_args += ["-lgslcblas"]
                        else:
                            e.extra_link_args += ["-lcblas", "-lblas"]
                    else:
                        if platform[:3] == "dar":
                            e.extra_link_args += ["-Wl,-rpath," + blas_path]
                        else:
                            e.extra_link_args += ["-Wl,-rpath=" + blas_path]

            else:
                e.sources.append(os.path.join(finblas_head_fold, "rtd_mock.c"))
            e.define_macros += [(f, None) for f in flags]
            if incl_path is not None:
                e.include_dirs.append(incl_path)
            e.include_dirs.append(finblas_head_fold)

        build_ext.build_extensions(self)
Exemple #48
0
 def build_extensions(self):
     self._update_extensions()
     build_ext.build_extensions(self)