def __init__(self, name, sources, *args, **kwargs):
cfg_ext = cfg.make_extension(python=True, **kwargs)
self.cxx = cfg_ext.pop('cxx', None)
self.cc = cfg_ext.pop('cc', None)
self._sources = sources
Extension.__init__(self, name, sources, *args, **cfg_ext)
self.__dict__.pop("sources", None)
def gen_ext(module, fortran_options):
src = module.replace('.', '/') + '.f90'
ext = Extension(
name=module,
sources=[src], # <- should be a list type
extra_f90_compile_args=fortran_options)
return ext
def __init__(self, name, sources, *args, **kwargs):
# the goal is to rely on original Extension
# to do so we convert the .py to .cpp with pythran
# and register the .cpp in place of the .py
# That's stage 0, and it's enough if you get the source
# from github and `python setup.py install it`
#
# *But* if you want to distribute the source through
# `python setup.py sdist` then the .py no longer exists
# and only the .cpp is distributed. That's stage 1
import pythran.toolchain as tc
cxx_sources = []
for source in sources:
base, ext = os.path.splitext(source)
if ext == ".cpp":
output_file = source
stage = 1
else:
output_file = base + '.cpp' # target name
# stage 0 when we have the .py
if os.path.exists(source):
stage = 0
# stage 1 otherwise. `.cpp' should already be there
# as generated upon stage 0
else:
assert os.path.exists(output_file)
stage = 1
source = output_file
# stage-dependant processing
if stage == 0:
# get the last name in the path
if '.' in name:
module_name = os.path.splitext(name)[-1][1:]
else:
module_name = name
tc.compile_pythranfile(source,
output_file,
module_name,
cpponly=True)
cxx_sources.append(output_file)
cfg_ext = cfg.make_extension(python=True, **kwargs)
self.cxx = cfg_ext.pop('cxx')
Extension.__init__(self, name, cxx_sources, *args, **cfg_ext)
def compile_cxxfile(module_name, cxxfile, output_binary=None, **kwargs):
'''c++ file -> native module
Return the filename of the produced shared library
Raises CompileError on failure
'''
builddir = mkdtemp()
buildtmp = mkdtemp()
extension_args = make_extension(**kwargs)
extension = Extension(module_name, [cxxfile],
language="c++",
**extension_args)
try:
setup(
name=module_name,
ext_modules=[extension],
# fake CLI call
script_name='setup.py',
script_args=[
'--verbose'
if logger.isEnabledFor(logging.INFO) else '--quiet',
'build_ext',
'--build-lib',
builddir,
'--build-temp',
buildtmp,
])
except SystemExit as e:
raise CompileError(e.args)
[target] = glob.glob(os.path.join(builddir, module_name + "*"))
if not output_binary:
output_binary = os.path.join(os.getcwd(),
module_name + os.path.splitext(target)[1])
shutil.move(target, output_binary)
shutil.rmtree(builddir)
shutil.rmtree(buildtmp)
logger.info("Generated module: " + module_name)
logger.info("Output: " + output_binary)
return output_binary
def compile_extns(extensions=None, dirname=None, inc_dirs=None):
"""compile cython extensions
`extensions` is list of extensions to compile (None => all pyx files)
`dirname` is directory in which extensions are found (None = current directory)
`inc_dirs` is list of additional cython include directories
"""
if dirname is None:
dirname = os.path.abspath(os.curdir)
olddir = os.path.abspath(os.curdir)
os.chdir(dirname)
if extensions is None:
extensions = sorted([f[:-4] for f in os.listdir(os.curdir) if f.endswith('.pyx')])
if inc_dirs is None:
inc_dirs = []
inc_dirs.append(os.path.join(os.path.split(os.path.abspath(os.path.curdir))[0],'source'))
print inc_dirs
sys.argvold = sys.argv[:]
sys.argv = [__file__, 'build_ext','--inplace']
inc_dirs = [numpy.get_include()] + inc_dirs
cargs = []#'-O3']
# extension modules
extns = []
for extnname in extensions:
extn = Extension(extnname, [extnname+".pyx"], include_dirs=inc_dirs,
language='c++', extra_compile_args=cargs)
extn = get_spcl_extn(extn)
extns.append(extn)
setup(name='PySPH-bench',
ext_modules = extns,
include_package_data = True,
cmdclass={'build_ext': build_ext},
)
os.chdir(olddir)
sys.argv = sys.argvold
#!/usr/bin/python
from distutils.core import setup
from numpy.distutils.extension import Extension
import numpy
numpyinc = numpy.get_include()
module = Extension(
'radermacher',
sources = ['main.c', 'tiltang.c', 'willsq.c', 'transform.c', 'radon.c',],
include_dirs=[numpyinc,],
extra_compile_args=['-fopenmp',],
extra_link_args=['-lgomp',],
)
setup(
name='Radermacher',
version='1.1',
description='Radermacher functions for use in Appion',
author='Neil R. Voss',
author_email='*****@*****.**',
url='http://ami.scripps.edu/redmine/projects/appion/wiki/Compile_Radermacher',
license="Apache v2.0",
ext_modules=[module]
)
from numpy.distutils.core import setup
from numpy.distutils.extension import Extension
from numpy.distutils.misc_util import get_numpy_include_dirs
from Cython.Distutils import build_ext
setup(cmdclass={'build_ext': build_ext},
ext_modules=[Extension("bootstrap", ["bootstrap.pyx"])],
include_dirs=get_numpy_include_dirs())
description=DESCRIPTION,
long_description = long_description,
long_description_content_type="text/markdown",
packages=[NAME],
include_package_data=True,
platforms='any',
classifiers=[
'Programming Language :: Python',
'Development Status :: 3 - Alpha',
'Natural Language :: English',
'Environment :: Console',
'Intended Audience :: Science/Research',
'License :: OSI Approved :: MIT License',
'Operating System :: OS Independent',
'Topic :: Scientific/Engineering :: Mathematics',
]
)
# Readthedocs uses the --force option, and does not work if we ask to
# compile fortran code, so we disable this in that case.
if '--force' in sys.argv:
from setuptools import setup
else:
from numpy.distutils.core import setup
from numpy.distutils.extension import Extension
ext = Extension(name=NAME + ".lowdiscrepancy",
sources=["src/LowDiscrepancy.f"])
METADATA['ext_modules'] = [ext,]
setup(**METADATA)
#!/usr/bin/env python
if __name__ == '__main__':
from numpy.distutils.core import setup
from numpy.distutils.extension import Extension
from Cython.Build import cythonize
ext = []
ext += [Extension(name='slippy.cdc3d', sources=['slippy/cdc3d.pyx'])]
setup(name='SlipPy',
packages=['slippy'],
scripts=['exec/slippy', 'exec/plot_slippy'],
version='0.1.0',
description=
'module for inverting coseismic slip from GPS and InSAR data',
author='Trever Hines',
author_email='*****@*****.**',
url='https://github.com/treverhines/SlipPy',
ext_modules=cythonize(ext))
maintainer=MAINTAINER,
maintainer_email=MAINTAINER_EMAIL,
description=DESCRIPTION,
license=LICENSE,
url=URL,
download_url=DOWNLOAD_URL,
long_description=long_description,
classifiers=[
'Development Status :: 3 - Alpha', 'Environment :: Console',
'Intended Audience :: Developers',
'Intended Audience :: Science/Research',
'License :: OSI Approved :: GNU General Public License (GPL)',
'Topic :: Scientific/Engineering'
],
cmdclass=hooks.cmdclass,
ext_modules=[
Extension('pystudio.pystudio', ['pystudio/pystudio.pyx'],
language='c++',
depends=[
'pystudio/dispatcheraccess.pyx',
'pystudio/parameters.pyx',
'pystudio/paramscomputer.pyx', 'pystudio/requests.pyx',
'pystudio/libdispatcheraccess.pxd',
'pystudio/libhelpers.pxd', 'pystudio/libqt.pxd'
],
libraries=libraries,
include_dirs=include_dirs,
library_dirs=[libdispatcheraccess],
runtime_library_dirs=[libdispatcheraccess])
])
#FORTRAN code extension
#-------------------------------------------------------------------
#make sure you use the setup from numpy
from numpy.distutils.core import setup # this is numpy's setup
from numpy.distutils.extension import Extension
#from numpy import get_include
from Cython.Build import cythonize
# these are the almost intact gslib code
gslib_kt3d = Extension(
name='pygslib.gslib.__gslib__kt3d',
sources=[
'for_code/kt3d/kt3d.f90', 'for_code/kt3d/gslib/setrot.f90',
'for_code/kt3d/gslib/getindx.f90',
'for_code/kt3d/gslib/picksupr.f90',
'for_code/kt3d/gslib/setsupr.f90',
'for_code/kt3d/gslib/sqdist.f90', 'for_code/kt3d/gslib/cova3.f90',
'for_code/kt3d/gslib/ktsol.f90', 'for_code/kt3d/gslib/sortem.f90',
'for_code/kt3d/gslib/srchsupr.f90'
],
f2py_options=['only:', 'pykt3d', 'set_unest', ':'])
gslib_postik = Extension(
name='pygslib.gslib.__gslib__postik',
sources=[
'for_code/postik/postik.f90', 'for_code/postik/gslib/beyond.f90',
'for_code/postik/gslib/locate.f90',
'for_code/postik/gslib/powint.f90',
'for_code/postik/gslib/sortem.f90'
],
f2py_options=['only:', 'postik', 'set_unest', 'get_unest', ':'])
from distutils.util import get_platform
from numpy.distutils.extension import Extension
import numpy
if get_platform() == 'win32':
define_macros = []
else:
define_macros = [('HAS_RUSAGE', None)]
numpyinc = numpy.get_include()
module = Extension('libcv._libcv',
sources=[
'mserpy.c', 'mser.c', 'geometry.c', 'lautil.c',
'util.c', 'csift.c', 'mutil.c', 'image.c', 'match.c',
'unionfind.c'
],
define_macros=define_macros,
include_dirs=[
numpyinc,
])
setup(
name='libcv',
version='0.2',
description='wrapper around libCV',
ext_modules=[module],
packages=['libcv'],
package_dir={'libcv': ''},
)
name = 'qubic'
long_description = open('README.rst').read()
keywords = 'scientific computing'
platforms = 'MacOS X,Linux,Solaris,Unix,Windows'
delattr(os, 'link') # force sdist to copy files
hooks.F90_COMPILE_ARGS_GFORTRAN += ['-fpack-derived', '-g']
hooks.F90_COMPILE_ARGS_IFORT += ['-align norecords', '-g']
if sys.platform == 'darwin':
hooks.F77_COMPILE_OPT_GFORTRAN = ['-O2']
hooks.F90_COMPILE_OPT_GFORTRAN = ['-O2']
ext_modules = [
Extension('qubic._flib',
sources=['src/polarization.f90.src', 'src/xpol.f90'],
include_dirs=['.', np.get_include()],
libraries=['gomp', ('fmod', {
'sources': ['src/wig3j.f']
})])
]
setup(name=name,
version=hooks.get_version(name, VERSION),
description='Simulation and map-making tools for the QUBIC experiment.',
long_description=long_description,
url='',
author='Pierre Chanial',
author_email='*****@*****.**',
install_requires=[
'progressbar', 'pyoperators>=0.13.2', 'pysimulators>=1.0.8',
'healpy>=0.6.1', 'pyYAML'
],
#!/usr/bin/env python
if __name__ == '__main__':
from numpy.distutils.core import setup
from numpy.distutils.extension import Extension
from Cython.Build import cythonize
ext = []
ext += [Extension(name='rbf.halton',sources=['rbf/halton.pyx'])]
ext += [Extension(name='rbf.misc.bspline',sources=['rbf/misc/bspline.pyx'])]
ext += [Extension(name='rbf.geometry',sources=['rbf/geometry.pyx'])]
ext += [Extension(name='rbf.poly',sources=['rbf/poly.pyx'])]
setup(name='RBF',
version='1.2',
description='Package containing the tools necessary for radial basis function (RBF) applications',
author='Trever Hines',
author_email='*****@*****.**',
url='www.github.com/treverhines/RBF',
packages=['rbf','rbf.misc'],
ext_modules=cythonize(ext),
license='MIT')
from numpy.distutils.core import setup
from numpy.distutils.extension import Extension
extension = Extension("gcvspline._gcvspl", ["gcvspline/gcvspl.f"])
setup(
name='gcvspline',
version='0.4',
description=
'A Python wrapper for gcvspl.f, a FORTRAN package for generalized, cross-validatory spline smoothing and differentiation.',
url='https://github.com/charlesll/gcvspline',
author='Charles Le Losq and Yu Feng',
author_email='*****@*****.**',
license='GNU-GPLv3',
packages=['gcvspline', 'gcvspline.tests'],
install_requires=['numpy>=1.12'],
ext_modules=[extension],
zip_safe=False)
short_description = __doc__.split("\n")
# from https://github.com/pytest-dev/pytest-runner#conditional-requirement
needs_pytest = {'pytest', 'test', 'ptr'}.intersection(sys.argv)
pytest_runner = ['pytest-runner'] if needs_pytest else []
try:
with open("README.md", "r") as handle:
long_description = handle.read()
except:
long_description = "\n".join(short_description[2:])
ext_math = Extension(
name = 'molsysmt.lib.libmath',
extra_compile_args = [],
libraries = [],
language = 'f90',
sources = ['molsysmt/lib/libmath.f90'],
)
ext_pbc = Extension(
name = 'molsysmt.lib.libpbc',
extra_compile_args = [],
libraries = [],
language = 'f90',
sources = ['molsysmt/lib/libpbc.f90'],
)
ext_com = Extension(
name = 'molsysmt.lib.libcom',
extra_compile_args = [],
# You should have received a copy of the GNU General Public License
# along with FMMV; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
from os import environ
from numpy.distutils.core import setup
from numpy.distutils.extension import Extension
NUMPY_INCLUDE = environ.get('NUMPY_INCLUDE')
INC_INSTALLDIR = environ.get('INC_INSTALLDIR')
LIB_INSTALLDIR = environ.get('LIB_INSTALLDIR')
module2d = Extension('fmmv2d',
define_macros=[('FMM_DIM', '2')],
include_dirs=[INC_INSTALLDIR, NUMPY_INCLUDE],
libraries=['fmmv2d'],
library_dirs=[LIB_INSTALLDIR],
sources=['fmmvmodule.c'])
module2df = Extension('fmmv2df',
define_macros=[('USE_SINGLE_PRECISION', '1'),
('FMM_DIM', '2')],
include_dirs=[INC_INSTALLDIR, NUMPY_INCLUDE],
libraries=['fmmv2df'],
library_dirs=[LIB_INSTALLDIR],
sources=['fmmvmodule.c'])
module3d = Extension('fmmv3d',
define_macros=[('FMM_DIM', '3')],
include_dirs=[INC_INSTALLDIR, NUMPY_INCLUDE],
libraries=['fmmv3d'],
"""Setup script for f2py-wrapped library.
"""
# Third-party modules
from numpy.distutils.core import setup
from numpy.distutils.extension import Extension
# Build the extension module object
extmod = Extension(
name='simple',
# List here the interface (.pyf) file, plus any sources
# that need to be explicitly compiled into the wrapped
# module (i.e., not already part of one of the fortran
# libraries listed below):
sources=['simple.pyf', 'simple.f90'],
# Additional libraries required by our extension modules
libraries=[],
# Add '--debug-capi' for verbose debugging of low-level
# calls
#f2py_options = ['--debug-capi'],
)
# Make the actual distutils setup call
setup(
name='simple', # name of the generated extension (.so)
description='Segmentation library',
author='Felipe Arrate',
ext_modules=[extmod],
)
# To compile f90 with f2py 'setup' has to come from numpy.
# This is not the case with cython.
# In addition, the option cmdclass = {'build_ext': build_ext} is not needed
# Check for example:
# https://github.com/perrette/python-fortran-cpp-template/blob/master/setup.py
# https://stackoverflow.com/questions/14453208/mixing-f2py-with-distutils
# https://gist.github.com/johntut/1d8edea1fd0f5f1c057c
from numpy.distutils.core import setup
from numpy.distutils.extension import Extension
ext_math = Extension(
name='vector_normalization.lib.libmath',
extra_compile_args=[],
libraries=[],
language='f90',
sources=['vector_normalization/lib/libmath.f90'],
)
setup(
name='vector_normalization',
version='1.0',
author='Diego Prada | UIBCDF Lab',
author_email='*****@*****.**',
package_dir={'vector_normalization': 'vector_normalization'},
packages=setuptools.find_packages(),
ext_modules=[ext_math],
url='http://uibcdf.org',
download_url='https://github.com/uibcdf/TestConda_withF90Libs',
license='MIT',
build_ext_failed = True
print(e, file=sys.stderr)
cmdclass["build_ext"] = BuildExt
# make cython extension instances
for d in cy_defs:
if d is None:
continue
src_lst = d[1]
_ext = Extension(d[0],
src_lst,
extra_compile_args=cy_ccflags,
extra_link_args=cy_ldflags,
**d[2])
ext_mods += [_ext]
if has_cython and use_cython:
ext_mods = cythonize(ext_mods, nthreads=_nprocs)
# make fortran extension instances
try:
fc = _fcompiler.new_fcompiler(dry_run=True)
except ValueError:
fc = None
if fc is None:
# warn the user at the very end so they're more likely to see the warning
from numpy.distutils.core import setup
from numpy.distutils.extension import Extension
setup(
name='MolModExt',
version='0.001',
description=
'MolModExt implements a few number crunching routines for the molmod package in C.',
author='Toon Verstraelen',
author_email='*****@*****.**',
url='http://molmod.ugent.be/code/',
ext_modules=[
Extension("molmod.ext", [
"lib/interface.pyf",
"lib/ff.c",
"lib/graphs.c",
"lib/similarity.c",
"lib/molecules.c",
"lib/volume.c",
]),
],
packages=['molmod'],
package_dir={'molmod': 'lib'},
classifiers=[
'Development Status :: 3 - Alpha', 'Environment :: Console',
'Intended Audience :: Science/Research',
'License :: OSI Approved :: GNU General Public License (GPL)',
'Operating System :: POSIX :: Linux', 'Programming Language :: Python',
'Topic :: Science/Engineering :: Molecular Science'
],
)
from numpy import get_include
from numpy.distutils.core import setup
from numpy.distutils.extension import Extension
#from setuptools import setup, Extension
from Cython.Build import cythonize
from Cython.Distutils import build_ext
NAME = 'helloworld'
NUMPY_INC = get_include()
extensions = [
Extension(name=NAME + ".cext",
include_dirs=[NUMPY_INC],
sources=["cext.pyx"],
define_macros=[('NPY_NO_DEPRECATED_API', 'NPY_1_7_API_VERSION')
]),
Extension(name=NAME + ".fext",
sources=["fext.f90"],
language='fortran',
define_macros=[('NPY_NO_DEPRECATED_API', 'NPY_1_7_API_VERSION')
]),
]
extensions = cythonize(extensions, language_level=3)
setup(name=NAME, ext_modules=extensions)
import sys
import os
import glob
import numpy as np
from numpy.distutils.core import setup
from numpy.distutils.extension import Extension
version = 0.1
extensions = [
Extension("torontonian_samples",
sources=[
'src/kinds.f90', 'src/structures.f90', 'src/vars.f90',
'src/torontonian_samples.f90'
],
extra_f90_compile_args=[
"-fdefault-real-8", '-fbacktrace', '-fno-align-commons',
'-fbounds-check', "-fPIC"
],
extra_link_args=['-fopenmp'])
]
info = {
'name': 'torontonian_samples',
'version': version,
'maintainer': 'Xanadu Inc.',
'maintainer_email': '*****@*****.**',
'url': 'http://xanadu.ai',
'license': 'Apache License 2.0',
'packages': [
'torontonian_samples',
'molmod.io.test',
],
data_files=[
('share/molmod', [
"data/periodic.csv", "data/bonds.csv", "data/mass.mas03",
"data/nubtab03.asc", "data/toyff_angles.txt"
]),
('share/molmod/test', glob('data/test/*')),
] +
[('share/molmod/examples/%s' % os.path.basename(dn), glob('%s/*.*' % dn))
for dn in glob('data/examples/???_*')],
ext_modules=[
Extension("molmod.ext", [
"molmod/ext.pyf",
"molmod/common.c",
"molmod/ff.c",
"molmod/graphs.c",
"molmod/similarity.c",
"molmod/molecules.c",
"molmod/unit_cells.c",
]),
],
classifiers=[
'Development Status :: 3 - Alpha', 'Environment :: Console',
'Intended Audience :: Science/Research',
'License :: OSI Approved :: GNU General Public License (GPL)',
'Operating System :: POSIX :: Linux', 'Programming Language :: Python',
'Topic :: Science/Engineering :: Molecular Science'
],
)
spath = os.path.abspath(__file__).split("setup.py")[0]
#Define CRTM *.bin directory location
outdir = os.path.join(spath,'PyGEOMET','utils','crtm_coeff')
#Determine if the directory already exist
if (os.path.isdir(outdir)):
exist = True
else:
exist = False
#Check to see if the user enable CRTM
#**Note: CRTM must be compiled by the user separately before using
# within PyGEOMET. Also, we haven't found an easy way to do this on Windows.
if USE_CRTM:
#Check to make sure the user has provided correct paths to CRTM
if (os.path.isdir(crtm_path)):
extensions = [Extension("PyGEOMET.utils.wrf_cython",["PyGEOMET/utils/wrf_cython.pyx"],
extra_compile_args = ["-ffast-math"]),
Extension("PyGEOMET.utils.crtm_python",["PyGEOMET/utils/crtm_python.f90"],
include_dirs=[crtm_include],
extra_link_args = [crtm_lib])]
#Link CRTM *.bin files into expected directory
#Create output directory if it doesn't exist
if (exist == False):
os.makedirs(outdir)
else: #Clear the directory
#Get the files in the directory
bin_files = glob.glob(os.path.join(outdir,'*.bin'))
for f in bin_files:
os.remove(f)
#AerosolCoeff
shutil.copy(os.path.join(crtm_path,'fix','AerosolCoeff',endian,'AerosolCoeff.bin'),
os.path.join(outdir,'AerosolCoeff.bin'))
import os
import numpy as np
from numpy.distutils.core import setup
from numpy.distutils.extension import Extension
# # Numpy header files
numpy_lib = os.path.split(np.__file__)[0]
numpy_include = os.path.join(numpy_lib, 'core/include')
setup(
name="align",
version='0.0.1',
description="tools for aligning two molecular structures",
packages=["align",
"align._src",
"align.tests",
],
ext_modules=[
Extension("align._src.minperm", ["align/_src/minperm.f90"],
extra_compile_args=['-Wextra', '-pedantic', '-funroll-loops', '-O2', ],
),
Extension("align._src._cost_matrix", ["align/_src/_cost_matrix.c"],
include_dirs=[numpy_include],
extra_compile_args = ['-Wextra','-pedantic','-funroll-loops','-O2',],
),
]
)
license = 'GPL' copyright = '''Copyright © 2001-2008 LOGILAB S.A. (Paris, FRANCE). http://www.logilab.fr/ -- mailto:[email protected]''' short_desc = "Hidden Markov Models in Python" long_desc = """Hidden Markov Models in Python Implementation based on _A Tutorial on Hidden Markov Models and Selected Applications in Speech Recognition_, by Lawrence Rabiner, IEEE, 1989. This module uses numeric python multyarrays to improve performance and reduce memory usage.""" author = "Alexandre Fayolle" author_email = "*****@*****.**" web = "http://www.logilab.org/projects/%s" % distname ftp = "ftp://ftp.logilab.org/pub/%s" % modname mailinglist = "http://lists.logilab.org/mailman/listinfo/ai-projects" subpackage_of = 'logilab' try: from numpy.distutils.extension import Extension from numpy.distutils.misc_util import Configuration fmod = Extension('logilab.hmm._hmmf', ['_hmmf.pyf', '_hmmf.f90'], libraries=['gfortran']) cmod = Extension('logilab.hmm._hmm_c', ['_hmm.c'], libraries=['m']) ext_modules = [fmod, cmod] except: pass
USE_LAPACK = True
CFLAGS += [" -lopenblas -DLAPACKE=1"]
libraries += ["openblas"]
extra_link_args_CPP[0] += " -lopenblas"
extensions = cythonize([
Extension(
"libwalrus",
sources=[
"thewalrus/libwalrus." + ext,
],
depends=[
"include/libwalrus.hpp", "include/eigenvalue_hafnian.hpp",
"include/recursive_hafnian.hpp",
"include/repeated_hafnian.hpp", "include/hafnian_approx.hpp",
"include/torontonian.hpp", "include/permanent.hpp",
"include/hermite_multidimensional.hpp", "include/stdafx.h",
"include/fsum.hpp"
],
include_dirs=C_INCLUDE_PATH,
library_dirs=['/usr/lib', '/usr/local/lib'] + LD_LIBRARY_PATH,
libraries=libraries,
language="c++",
extra_compile_args=["-std=c++11"] + CFLAGS,
extra_link_args=extra_link_args_CPP)
],
compile_time_env={
'_OPENMP': USE_OPENMP,
'LAPACKE': USE_LAPACK
})
else:
"Intended Audience :: Science/Research",
"Topic :: Scientific/Engineering :: Atmospheric Science",
]
)
return config
pamgasabs_path = 'libs/pamgasabs/pamgasabs'
pamgasabs = Extension(
'pamtra2.libs.pamgasabs.pamgasabs_lib',
sources=[
'%s/pamgasabs_lib/pamgasabs_lib.pyf' % pamgasabs_path,
'%s/pamgasabs_lib/kinds.f90' % pamgasabs_path,
'%s/pamgasabs_lib/report_module.f90' % pamgasabs_path,
'%s/pamgasabs_lib/constants.f90' % pamgasabs_path,
'%s/pamgasabs_lib/gasabs_module.f90' % pamgasabs_path,
'%s/pamgasabs_lib/rosen98_gasabs.f90' % pamgasabs_path,
'%s/pamgasabs_lib/mpm93.f90' % pamgasabs_path,
],
extra_compile_args = [ "-fPIC"],
**kw)
pyrasim_path = 'libs/pyPamtraRadarSimulator/pyPamtraRadarSimulator'
pyrasim = Extension(
'pamtra2.libs.pyPamtraRadarSimulator.pyPamtraRadarSimulatorLib',
sources=[
'%s/pyPamtraRadarSimulatorLib/pyPamtraRadarSimulatorLib.pyf' %
pyrasim_path,
'%s/pyPamtraRadarSimulatorLib/kinds.f90' % pyrasim_path,
'%s/pyPamtraRadarSimulatorLib/report_module.f90' % pyrasim_path,
keywords='fusedwake',
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'Intended Audience :: Developers',
'License :: OSI Approved :: GNU Affero v3',
'Natural Language :: English',
"Programming Language :: Python :: 2",
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
],
test_suite='tests',
tests_require=test_requirements,
ext_package='fusedwake',
ext_modules=[Extension('gcl.fortran',
glob.glob(os.path.join('fusedwake', 'gcl', 'fortran',
'GCL.f'))),
Extension('noj.fortran',
glob.glob(os.path.join('fusedwake', 'noj', 'fortran',
'NOJ.f'))),
Extension('noj.fortran_mod',
glob.glob(os.path.join('fusedwake', 'noj', 'fortran',
'Mod_NOJ.f'))),
Extension('gau.fortran',
glob.glob(os.path.join('fusedwake', 'gau', 'fortran',
'GAU.f')))],
)