Example #1
0
def cython(pyx_files, working_path=''):
    """Use Cython to convert the given files to C.

    Parameters
    ----------
    pyx_files : list of str
        The input .pyx files.

    """
    # Do not build cython files if target is clean
    if len(sys.argv) >= 2 and sys.argv[1] == 'clean':
        return

    try:
        from Cython.Build import cythonize
    except ImportError:
        # If cython is not found, we do nothing -- the build will make use of
        # the distributed .c files
        print("Cython not found; falling back to pre-built %s" \
              % " ".join([f.replace('.pyx', '.c') for f in pyx_files]))
    else:
        for pyxfile in [os.path.join(working_path, f) for f in pyx_files]:

            # if the .pyx file stayed the same, we don't need to recompile
            if not _changed(pyxfile):
                continue

            cythonize(pyxfile)
Example #2
0
    def _setup_extensions(self):
        # We defer extension setup until this command to leveraage 'setup_requires' pulling in Cython before we
        # attempt to import anything
        self.extensions = []

        if try_murmur3:
            self.extensions.append(murmur3_ext)

        if try_libev:
            self.extensions.append(libev_ext)

        if try_cython:
            try:
                from Cython.Build import cythonize
                cython_candidates = ['cluster', 'concurrent', 'connection', 'cqltypes', 'metadata',
                                     'pool', 'protocol', 'query', 'util']
                compile_args = [] if is_windows else ['-Wno-unused-function']
                self.extensions.extend(cythonize(
                    [Extension('cassandra.%s' % m, ['cassandra/%s.py' % m],
                               extra_compile_args=compile_args)
                        for m in cython_candidates],
                    nthreads=build_concurrency,
                    exclude_failures=True))

                self.extensions.extend(cythonize(NoPatchExtension("*", ["cassandra/*.pyx"], extra_compile_args=compile_args),
                                                 nthreads=build_concurrency))
            except Exception:
                sys.stderr.write("Failed to cythonize one or more modules. These will not be compiled as extensions (optional).\n")
Example #3
0
    def run(self):
        from Cython.Build import cythonize
        from _ExtMaker.GlobalMaker import Maker

        def regenApi(api, version):
            stuff = Maker(glazeAbsPath, specsAbsPath, gladAbsPath, api, {api: version},
                          self.announce, self.extensions, self.profile, self.force_spec_dl)
            stuff.create()

        for api in self.apis:
            regenApi(api, self.versions.get(api))

        cythonizables = []
        for file in os.listdir(glazeAbsPath):
            file = os.path.join(glazeAbsPath, file)
            if os.path.splitext(file)[1] == '.pyx':
                cythonizables.append(file)
            if not os.path.isfile(file) and os.path.basename(file) != 'glad':
                for file2 in os.listdir(file):
                    file2 = os.path.join(file, file2)
                    if os.path.isfile(file2):
                        if os.path.splitext(file2)[1] == '.pyx':
                            cythonizables.append(file2)

        cythonize(cythonizables,
                  language='c++',
                  # compile_time_env={'LIBRARY': b'default'},
                  nthreads=self.jobs,
                  )

        self.announce('Done. Now you can build_ext / install / develop', log.INFO)
Example #4
0
def do_setup(cython=False):
    if 'USE_CYTHON' in os.environ:
        if os.environ['USE_CYTHON'] == "false":
            cython = False
    packages = ['freeze']
    if cython:
        print("Installing with cython\n")
        from Cython.Build import cythonize
        if version > 2:
            ext_modules = cythonize([
                "freeze/xfreeze.py",
                "freeze/fpprint.py",
            ])
        else:
            ext_modules = cythonize([
                "freeze/xfreeze.py",
            ])
    else:
        print("Installing without cython\n")
        ext_modules = []

    setup(
        name = "freeze",
        version = __version__,
        packages    = packages,
        ext_modules = ext_modules,

        install_requires = ['six'],

        author = "Adfinis-SyGroup",
        author_email = "https://adfinis-sygroup.ch/",
        description = "Freeze - dump / hash / sort / compare / diff anything",
        long_description = """
Freeze the state of data-structures and objects for data-analysis or testing
(diffing data-structures). Frozen data-structures consist of only tuples
and these are comparable/sortable/hashable. The freeze() function can be used
for many purposes for example implement __hash__() for your complex object
very fast. dump() is intended for testing and analysis.""",
        keywords = "freeze state hash sort compare unittest",
        url = "https://github.com/adfinis-sygroup/freeze",
        classifiers = [
            "Development Status :: 5 - Production/Stable",
            "Environment :: Console",
            "Intended Audience :: Developers",
            "Intended Audience :: Education",
            "Intended Audience :: Information Technology",
            "License :: OSI Approved :: "
            "GNU Affero General Public License v3",
            "Natural Language :: English",
            "Operating System :: OS Independent",
            "Programming Language :: Python :: 2.6",
            "Programming Language :: Python :: 2.7",
            "Programming Language :: Python :: 3.3",
            "Programming Language :: Python :: 3.4",
            "Programming Language :: Python :: 3.5",
            "Topic :: Software Development :: Libraries",
            "Topic :: Scientific/Engineering :: Information Analysis",
            "Topic :: Software Development :: Testing",
        ]
    )
Example #5
0
def check_extensions():
    
    #Cythonize main modules
    ext_list = cythonize(["assimulo"+O.path.sep+"*.pyx"], include_path=[".","assimulo"],include_dirs=[N.get_include()],pyrex_gdb=debug)
    
    #Cythonize Euler
    ext_list = ext_list + cythonize(["assimulo"+O.path.sep+"solvers"+O.path.sep+"euler.pyx"], include_path=[".","assimulo"],include_dirs=[N.get_include()],pyrex_gdb=debug)
    
    for i in ext_list:
        i.include_dirs = [N.get_include()]
        
        #Debug
        if debug:
            i.extra_compile_args = ["-g","-fno-strict-aliasing"]
            i.extra_link_args = ["-g"]
        else:
            i.extra_compile_args = ["-O2", "-fno-strict-aliasing"]
            
    #If Sundials
    if O.path.exists(O.path.join(O.path.join(incdirs,'cvodes'), 'cvodes.h')):
        ext_list = ext_list + cythonize(["assimulo"+O.path.sep+"solvers"+O.path.sep+"sundials.pyx"], include_path=[".","assimulo","assimulo"+O.sep+"lib"],include_dirs=[N.get_include()],pyrex_gdb=debug)
        ext_list[-1].include_dirs = [N.get_include(), "assimulo","assimulo"+O.sep+"lib", incdirs]
        ext_list[-1].library_dirs = [libdirs]
        ext_list[-1].extra_link_args = ["-lsundials_cvodes", "-lsundials_nvecserial", "-lsundials_idas"]
        if debug:
            ext_list[-1].extra_compile_args = ["-g", "-fno-strict-aliasing"]
        else:
            ext_list[-1].extra_compile_args = ["-O2", "-fno-strict-aliasing"]
    
    #Sundials found
    if O.path.exists(O.path.join(O.path.join(incdirs,'cvodes'), 'cvodes.h')):
        cordir = O.path.join(O.path.join('assimulo','lib'),'sundials_core.pyx')
        cordir_KINSOL_wSLU = O.path.join(O.path.join('assimulo','lib'),'sundials_kinsol_core_wSLU.pyx')
        cordir_KINSOL = O.path.join(O.path.join('assimulo','lib'),'sundials_kinsol_core.pyx')
    
        cordir_KINSOL_jmod_wSLU = O.path.join(O.path.join('assimulo','lib'),'kinsol_jmod_wSLU.c')
        cordir_KINSOL_jmod = O.path.join(O.path.join('assimulo','lib'),'kinsol_jmod.c')
    
        cordir_kinpinv = O.path.join(O.path.join('assimulo','lib'),'kinpinv.c')
        cordir_kinslug = O.path.join(O.path.join('assimulo','lib'),'kinslug.c')
        cordir_reg_routines = O.path.join(O.path.join('assimulo','lib'),'reg_routines.c')

        
        wSLU = check_wSLU()
        if wSLU:
            SLUincdir = O.path.join(SLUdir,'SRC')
            SLUlibdir = O.path.join(SLUdir,'lib')
            ext_list = ext_list + [Extension('assimulo.lib.sundials_kinsol_core_wSLU',
                          [cordir_KINSOL_wSLU,cordir_KINSOL_jmod_wSLU,cordir_kinpinv,cordir_kinslug,cordir_reg_routines],
                          include_dirs=[incdirs, N.get_include(),SLUincdir],
                          library_dirs=[libdirs,SLUlibdir,BLASdir],
                          libraries=['sundials_kinsol','sundials_nvecserial','superlu_4.1',BLASname])]
        else:
            ext_list = ext_list + [Extension('assimulo.lib.sundials_kinsol_core',
                          [cordir_KINSOL,cordir_KINSOL_jmod,cordir_kinpinv],
                          include_dirs=[incdirs, N.get_include()],
                          library_dirs=[libdirs],
                          libraries=['sundials_kinsol','sundials_nvecserial'])]
        
    return ext_list
Example #6
0
    def run(self):
        # this is already imported, but the import might have failed. If so, raise an ImportError now.
        from Cython.Build import cythonize

        # Make sure the compiled Cython files in the distribution are up-to-date
        cythonize(['voropy/_voro.pyx'])
        _sdist.run(self)
Example #7
0
def my_cythonize(extensions, **_ignore):
    #newextensions = []
    for extension in extensions:
        print(extension.sources)
        should_cythonize = False
        sources = []
        for sfile in extension.sources:
            path, ext = os.path.splitext(sfile)
            if ext in ('.pyx', '.py'):
                should_cythonize = True
                if not cython_present:
                   # if extension.language == 'c++':
                        ext = '.cpp'
                    #else:
                     #   ext = '.c'
            if sfile == 'PyDeepCL.c':
                ext = '.cpp' # hack for now... not sure how to fix this cleanly
                             # yet
            sfile = path + ext
            if sfile.startswith('..'):
                # use mysrc instead
                basename = os.path.basename(sfile)
                sfile = 'mysrc/' + basename
            sources.append(sfile)
        #print(should_cythonize)
        if should_cythonize and cython_present:
            print('cythonizing...')
            cythonize(extension)
        extension.sources[:] = sources    
        #newextensions.append( extension )
    return extensions
Example #8
0
 def compile_cython(self):
     global cython_sources
     try:
         from Cython.Build import cythonize
         cythonize(cython_sources)
     except ImportError:
         pass
Example #9
0
def cython(pyx_files, working_path=''):
    """Use Cython to convert the given files to C.

    Parameters
    ----------
    pyx_files : list of str
        The input .pyx files.

    """
    # Do not build cython files if target is clean
    if len(sys.argv) >= 2 and sys.argv[1] == 'clean':
        return

    try:
        from Cython.Build import cythonize
    except ImportError:
        raise ImportError("Cython not found.")
    else:
        for pyxfile in [os.path.join(working_path, f) for f in pyx_files]:

            # if the .pyx file stayed the same, we don't need to recompile
            if not _changed(pyxfile):
                continue

            cythonize(pyxfile)
Example #10
0
 def run(self):
    cythonize(
       ext_cython_modules,
       include_path=cython_include_path,
       force=(not self.timestamps),
       annotate=self.annotate,
       compiler_directives=self.directive
    )
Example #11
0
 def run(self):
     # Make sure the compiled Cython files in the distribution are up-to-date
     from Cython.Build import cythonize
     cythonize(['_pysndfile.pyx'])
     shutil.move("setup.cfg", "setup.cfg.default")
     shutil.copy2("setup.cfg.dist", "setup.cfg")
     sdist.run(self)
     shutil.move("setup.cfg.default", "setup.cfg")
Example #12
0
File: setup.py Project: kif/pyFAI
 def cythonize_extensions(self):
     from Cython.Build import cythonize
     cythonize(
         self.extensions,
         compiler_directives={'embedsignature': True,
                              'language_level': 3},
         force=True
     )
Example #13
0
        def run(self):
            from Cython.Build import cythonize

            for ext in self.distribution.ext_modules:
                sources = list(s for s in ext.sources if s.endswith('.pyx'))
                cythonize(sources)

            sdist_.run(self)
Example #14
0
    def run(self):

        import Cython
        from Cython.Build import cythonize

        assert float(Cython.__version__) >= 0.22

        cythonize(define_extensions('.pyx'))
Example #15
0
def cythonize_wrapper(modules, **kwargs):
    """ Calls cythonize, filtering useless warnings """
    if not modules:
        return

    with CythonFilter() as cython_filter:
        with redirect_stdout(cython_filter):
            cythonize(modules, **kwargs)
Example #16
0
 def run(self):
     try:
         from Cython.Build import cythonize
         cythonize(os.path.join('pyhsmm','**','*.pyx'))
     except:
         warn('Failed to generate extension files from Cython sources')
     finally:
         _sdist.run(self)
Example #17
0
 def run(self):
     cythonize(extensions)
     for ext in extensions:
         for src in ext.sources:
             if not os.path.exists(src):
                 raise Exception(
                     "Cython-generated file '{0}' not found. "
                     "Run 'python setup.py --usage' for details.".format(src, usage))
     sdist.run(self)
Example #18
0
def configuration(parent_package='', top_path=None):
    from numpy.distutils.misc_util import Configuration
    config = Configuration('models', parent_package, top_path)

    include = os.path.join(get_python_lib(), 'compmech', 'include')
    lib = os.path.join(get_python_lib(), 'compmech', 'lib')

    if os.name == 'nt':
        runtime_library_dirs = None
        if os.environ.get('CONDA_DEFAULT_ENV') is not None:
            #NOTE removing openmp to compile in MiniConda
            args_linear = ['-O0']
            args_nonlinear = ['-O0']
        else:
            args_linear = ['/openmp']
            args_nonlinear = ['/openmp', '/fp:fast']
    else:
        runtime_library_dirs = [lib]
        if os.environ.get('CONDA_DEFAULT_ENV') is not None:
            #NOTE removing openmp to compile in MiniConda
            args_linear = ['-O0']
            args_nonlinear = ['-O0']
        else:
            args_linear = ['-fopenmp']
            args_nonlinear = ['-fopenmp', '-ffast-math']

    config.add_extension('bladestiff1d_clt_donnell_bardell',
                     ['bladestiff1d_clt_donnell_bardell.pyx'],
                     extra_compile_args=args_linear,
                     runtime_library_dirs=runtime_library_dirs,
                     include_dirs=[include],
                     libraries=['bardell_functions', 'bardell'],
                     library_dirs=[lib])

    config.add_extension('bladestiff2d_clt_donnell_bardell',
                     ['bladestiff2d_clt_donnell_bardell.pyx'],
                     extra_compile_args=args_linear,
                     runtime_library_dirs=runtime_library_dirs,
                     include_dirs=[include],
                     libraries=['bardell_functions', 'bardell'],
                     library_dirs=[lib])

    config.add_extension('tstiff2d_clt_donnell_bardell',
                     ['tstiff2d_clt_donnell_bardell.pyx'],
                     extra_compile_args=args_linear,
                     runtime_library_dirs=runtime_library_dirs,
                     include_dirs=[include],
                     libraries=['bardell_functions', 'bardell',
                         'bardell_12', 'bardell_c0c1'],
                     library_dirs=[lib])

    cythonize(config.ext_modules)

    config.make_config_py()

    return config
Example #19
0
    def run(self):
        from Cython.Build import cythonize

        self.generate_pyx()

        cythonize([Extension("lightfm._lightfm_fast_no_openmp",
                             ['lightfm/_lightfm_fast_no_openmp.pyx']),
                   Extension("lightfm._lightfm_fast_openmp",
                             ['lightfm/_lightfm_fast_openmp.pyx'],
                             extra_link_args=['-fopenmp'])])
Example #20
0
def compile_pyx():
    ext_modules = list()

    cparser = cythonize('pyrox/http/parser.pyx')[0]
    cparser.sources.insert(0, 'include/http_el.c')
    ext_modules.append(cparser)

    ext_modules.extend(cythonize('pyrox/http/model_util.pyx'))

    return ext_modules
Example #21
0
    def run(self):
        try:
            from Cython.Build import cythonize

            cythonize([
                module.replace('.', '/') + '.pyx' for module in cython_modules
            ])
        except ImportError:
            pass
        _sdist.run(self)
Example #22
0
def configuration(parent_package='', top_path=None):
    from numpy.distutils.misc_util import Configuration
    config = Configuration('science_features', parent_package, top_path)

    cythonize(os.path.join(base_path, '_lomb_scargle.pyx'))

    config.add_extension('_lomb_scargle', '_lomb_scargle.c',
                         include_dirs=[np.get_include()])

    return config
    def run(self):
        build_ext = self.reinitialize_command('build_ext')
        build_ext.ensure_finalized()

        # generate cython extensions if any exist
        extensions = list(cython_pyx())
        if extensions:
            from Cython.Build import cythonize
            cythonize(extensions, nthreads=cpu_count())

        dst_sdist.sdist.run(self)
Example #24
0
def cythonize_cpp_wrapper(modules, nthreads):
    """ Calls cythonize, filtering useless warnings """
    from Cython.Build import cythonize
    from contextlib import redirect_stdout

    if not modules:
        return

    with CythonFilter() as cython_filter:
        with redirect_stdout(cython_filter):
            cythonize(modules, language='c++', nthreads=nthreads)
Example #25
0
        def run(self):
            # only run if .git is present
            if not os.path.exists('.git'):
                return

            try:
                from Cython.Build import cythonize
                cythonize(extensions())
            except ImportError:
                warnings.warn('at sdist cythonize failed')

            return versioneer.cmd_sdist.run(self)
Example #26
0
    def run(self):
        build_ext = self.reinitialize_command('build_ext')
        build_ext.ensure_finalized()

        # generate cython extensions if any exist
        cython = any(
            os.path.splitext(f)[1] == '.pyx' for e in
            build_ext.extensions for f in e.sources)
        if cython:
            from Cython.Build import cythonize
            cythonize(build_ext.extensions)

        dst_sdist.sdist.run(self)
    def run(self):
        # ensure that the platform checks were performed
        self.run_command('config')

        # only regenerate cython extensions if requested or required
        use_cython = (
            os.environ.get('USE_CYTHON', False) or
            any(not os.path.exists(x) for ext in self.no_cythonize() for x in ext.sources))
        if use_cython:
            from Cython.Build import cythonize
            cythonize(self.extensions, nthreads=cpu_count())

        self.extensions = self.no_cythonize()
        return dst_build_ext.build_ext.run(self)
Example #28
0
 def finalize_options(self):
     from Cython.Build import cythonize
     self.distribution.ext_modules[:] = cythonize(
         self.distribution.ext_modules,
         compiler_directives={'embedsignature': True},
     )
     _build_ext.finalize_options(self)
Example #29
0
def get_extensions():
    from distutils.extension import Extension

    common_extension_args = {
        'include_dirs': get_include_dirs(),
        'library_dirs': get_library_dirs(),
        'libraries': get_libraries()}

    try:
        from Cython.Build import cythonize        
        sources = [os.path.join(os.getcwd(), 'pyfftw', 'pyfftw.pyx')]
        have_cython = True

    except ImportError as e:
        # no cython
        sources = [os.path.join(os.getcwd(), 'pyfftw', 'pyfftw.c')]
        if not os.path.exists(sources[0]):
            raise ImportError(
                str(e) + '. ' + 
                'Cython is required to build the initial .c file.')
        
        have_cython = False

    ext_modules = [
        Extension('pyfftw.pyfftw', sources=sources, 
                  **common_extension_args)]

    if have_cython:
        return cythonize(ext_modules)

    else:
        return ext_modules
Example #30
-21
def configuration(parent_package='',top_path=None):
    from numpy.distutils.misc_util import Configuration
    if os.name == 'nt':
        if os.environ.get('CONDA_DEFAULT_ENV') is not None:
            #NOTE removing openmp to compile in MiniConda
            compile_args = []
        else:
            compile_args = ['/openmp']
    else:
        if os.environ.get('CONDA_DEFAULT_ENV') is not None:
            #NOTE removing openmp to compile in MiniConda
            compile_args = []
        else:
            compile_args = ['-fopenmp']

    config = Configuration('imperfections', parent_package, top_path)
    config.add_extension('mgi',
                         sources=['mgi.pyx'],
                        )

    cythonize(config.ext_modules)

    config.make_config_py()

    return config