forked from pyrocko/pyrocko
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
751 lines
23 KiB
751 lines
23 KiB
from __future__ import absolute_import, division, print_function
|
|
import sys
|
|
import os
|
|
import os.path as op
|
|
import time
|
|
import shutil
|
|
import tempfile
|
|
try:
|
|
import numpy
|
|
except ImportError:
|
|
# numpy might not be available when running install_prerequisites
|
|
class numpy():
|
|
def __init__(self):
|
|
pass
|
|
|
|
@classmethod
|
|
def get_include(self):
|
|
return None
|
|
|
|
from distutils.sysconfig import get_python_inc
|
|
from setuptools import setup, Extension, Command
|
|
from setuptools.command.build_py import build_py
|
|
from setuptools.command.build_ext import build_ext
|
|
from setuptools.command.install import install
|
|
|
|
packname = 'pyrocko'
|
|
version = '2019.06.06'
|
|
|
|
|
|
class NotInAGitRepos(Exception):
|
|
pass
|
|
|
|
|
|
def git_infos():
|
|
'''Query git about sha1 of last commit and check if there are local \
|
|
modifications.'''
|
|
|
|
from subprocess import Popen, PIPE
|
|
import re
|
|
|
|
def q(c):
|
|
return Popen(c, stdout=PIPE).communicate()[0]
|
|
|
|
if not op.exists('.git'):
|
|
raise NotInAGitRepos()
|
|
|
|
sha1 = q(['git', 'log', '--pretty=oneline', '-n1']).split()[0]
|
|
sha1 = re.sub(br'[^0-9a-f]', '', sha1)
|
|
sha1 = str(sha1.decode('ascii'))
|
|
sstatus = q(['git', 'status', '--porcelain', '-uno'])
|
|
local_modifications = bool(sstatus.strip())
|
|
return sha1, local_modifications
|
|
|
|
|
|
def bash_completions_dir():
|
|
from subprocess import Popen, PIPE
|
|
|
|
def q(c):
|
|
return Popen(c, stdout=PIPE).communicate()[0]
|
|
|
|
try:
|
|
d = q(['pkg-config', 'bash-completion', '--variable=completionsdir'])
|
|
return d.strip().decode('utf-8')
|
|
except Exception:
|
|
return None
|
|
|
|
|
|
def make_info_module(packname, version):
|
|
'''Put version and revision information into file src/info.py.'''
|
|
|
|
sha1, local_modifications = None, None
|
|
combi = '%s-%s' % (packname, version)
|
|
try:
|
|
sha1, local_modifications = git_infos()
|
|
combi += '-%s' % sha1
|
|
if local_modifications:
|
|
combi += '-modified'
|
|
|
|
except (OSError, NotInAGitRepos):
|
|
pass
|
|
|
|
datestr = time.strftime('%Y-%m-%d_%H:%M:%S')
|
|
combi += '-%s' % datestr
|
|
|
|
s = '''# This module is automatically created from setup.py
|
|
git_sha1 = %s
|
|
local_modifications = %s
|
|
version = %s
|
|
long_version = %s # noqa
|
|
installed_date = %s
|
|
''' % tuple([repr(x) for x in (
|
|
sha1, local_modifications, version, combi, datestr)])
|
|
|
|
try:
|
|
f = open(op.join('src', 'info.py'), 'w')
|
|
f.write(s)
|
|
f.close()
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
def make_prerequisites():
|
|
from subprocess import check_call
|
|
try:
|
|
check_call(['sh', 'prerequisites/prerequisites.sh'])
|
|
except Exception:
|
|
sys.exit('error: failed to build the included prerequisites with '
|
|
'"sh prerequisites/prerequisites.sh"')
|
|
|
|
|
|
def get_readme_paths():
|
|
paths = []
|
|
|
|
for (path, dirnames, filenames) in os.walk(
|
|
op.join(op.dirname(__file__), 'src')):
|
|
paths.extend(
|
|
[op.join(path.split('/', 1)[1], fn) for fn in filenames if
|
|
fn == 'README.md'])
|
|
return paths
|
|
|
|
|
|
def get_build_include(lib_name):
|
|
return op.join(op.dirname(op.abspath(__file__)), lib_name)
|
|
|
|
|
|
def find_pyrocko_installs():
|
|
found = []
|
|
seen = set()
|
|
orig_sys_path = sys.path
|
|
for p in sys.path:
|
|
|
|
ap = op.abspath(p)
|
|
if ap == op.abspath('.'):
|
|
continue
|
|
|
|
if ap in seen:
|
|
continue
|
|
|
|
seen.add(ap)
|
|
|
|
sys.path = [p]
|
|
|
|
try:
|
|
import pyrocko
|
|
dpath = op.dirname(op.abspath(pyrocko.__file__))
|
|
x = (pyrocko.installed_date, p, dpath,
|
|
pyrocko.long_version)
|
|
found.append(x)
|
|
del sys.modules['pyrocko']
|
|
del sys.modules['pyrocko.info']
|
|
except (ImportError, AttributeError):
|
|
pass
|
|
|
|
sys.path = orig_sys_path
|
|
return found
|
|
|
|
|
|
def print_installs(found, file):
|
|
print(
|
|
'\nsys.path configuration is: \n %s\n' % '\n '.join(sys.path),
|
|
file=file)
|
|
|
|
dates = sorted([xx[0] for xx in found])
|
|
i = 1
|
|
|
|
for (installed_date, p, installed_path, long_version) in found:
|
|
oldnew = ''
|
|
if len(dates) >= 2:
|
|
if installed_date == dates[0]:
|
|
oldnew = ' (oldest)'
|
|
|
|
if installed_date == dates[-1]:
|
|
oldnew = ' (newest)'
|
|
|
|
print('''Pyrocko installation #%i:
|
|
date installed: %s%s
|
|
version: %s
|
|
path: %s
|
|
''' % (i, installed_date, oldnew, long_version, installed_path), file=file)
|
|
i += 1
|
|
|
|
|
|
def check_multiple_install():
|
|
found = find_pyrocko_installs()
|
|
e = sys.stderr
|
|
|
|
dates = sorted([xx[0] for xx in found])
|
|
|
|
if len(found) > 1:
|
|
print_installs(found, e)
|
|
|
|
if len(found) > 1:
|
|
print(
|
|
'''Installation #1 is used with default sys.path configuration.
|
|
|
|
WARNING: Multiple installations of Pyrocko are present on this system.''',
|
|
file=e)
|
|
if found[0][0] != dates[-1]:
|
|
print('WARNING: Not using newest installed version.', file=e)
|
|
|
|
|
|
def check_pyrocko_install_compat():
|
|
found = find_pyrocko_installs()
|
|
if len(found) == 0:
|
|
return
|
|
|
|
expected_submodules = ['gui', 'dataset', 'client',
|
|
'streaming', 'io', 'model']
|
|
|
|
installed_date, p, install_path, long_version = found[0]
|
|
|
|
installed_submodules = [d for d in os.listdir(install_path)
|
|
if op.isdir(op.join(install_path, d))]
|
|
|
|
if not all([ed in installed_submodules for ed in expected_submodules]):
|
|
|
|
print_installs(found, sys.stdout)
|
|
|
|
print('''\n
|
|
###############################################################################
|
|
|
|
WARNING: Found an old, incompatible, Pyrocko installation!
|
|
|
|
Please purge the old installation and the 'build' directory before installing
|
|
this new version:
|
|
|
|
sudo rm -rf '%s' build
|
|
|
|
###############################################################################
|
|
''' % install_path)
|
|
|
|
sys.exit(1)
|
|
|
|
|
|
class CheckInstalls(Command):
|
|
description = '''check for multiple installations of Pyrocko'''
|
|
user_options = []
|
|
|
|
def initialize_options(self):
|
|
pass
|
|
|
|
def finalize_options(self):
|
|
pass
|
|
|
|
def run(self):
|
|
check_multiple_install()
|
|
|
|
|
|
class Uninstall(Command):
|
|
description = 'delete installations of Pyrocko known to the invoked ' \
|
|
'Python interpreter'''
|
|
|
|
user_options = []
|
|
|
|
def initialize_options(self):
|
|
pass
|
|
|
|
def finalize_options(self):
|
|
pass
|
|
|
|
def run(self):
|
|
found = find_pyrocko_installs()
|
|
print_installs(found, sys.stdout)
|
|
|
|
if found:
|
|
print('''
|
|
Use the following commands to remove the Pyrocko installation(s) known to the
|
|
currently running Python interpreter:
|
|
|
|
sudo rm -rf build''')
|
|
|
|
for _, _, install_path, _ in found:
|
|
print(' sudo rm -rf "%s"' % install_path)
|
|
|
|
print()
|
|
|
|
else:
|
|
print('''
|
|
No Pyrocko installations found with the currently running Python interpreter.
|
|
''')
|
|
|
|
|
|
class CustomInstallCommand(install):
|
|
|
|
def symlink_interpreter(self):
|
|
if hasattr(self, 'install_scripts') and sys.executable:
|
|
target = os.path.join(self.install_scripts, 'pyrocko-python')
|
|
if os.path.exists(target):
|
|
os.unlink(target)
|
|
|
|
os.symlink(sys.executable, target)
|
|
|
|
def run(self):
|
|
check_pyrocko_install_compat()
|
|
install.run(self)
|
|
self.symlink_interpreter()
|
|
check_multiple_install()
|
|
bd_dir = bash_completions_dir()
|
|
if bd_dir:
|
|
try:
|
|
shutil.copy('extras/pyrocko', bd_dir)
|
|
print('Installing pyrocko bash_completion to "%s"' % bd_dir)
|
|
except Exception:
|
|
print(
|
|
'Could not install pyrocko bash_completion to "%s" '
|
|
'(continuing without)'
|
|
% bd_dir)
|
|
|
|
|
|
class InstallPrerequisits(Command):
|
|
description = '''install prerequisites with system package manager'''
|
|
user_options = [
|
|
('force-yes', None, 'Do not ask for confirmation to install')]
|
|
|
|
def initialize_options(self):
|
|
self.force_yes = False
|
|
|
|
def finalize_options(self):
|
|
pass
|
|
|
|
def run(self):
|
|
|
|
from subprocess import Popen, PIPE, STDOUT
|
|
import platform
|
|
|
|
distribution = platform.linux_distribution()[0].lower().rstrip()
|
|
|
|
if distribution == 'ubuntu':
|
|
distribution = 'debian'
|
|
|
|
if distribution.startswith('centos'):
|
|
distribution = 'centos'
|
|
|
|
fn = 'prerequisites/prerequisites_%s_python%i.sh' % (
|
|
distribution, sys.version_info.major)
|
|
|
|
if not self.force_yes:
|
|
try:
|
|
input = raw_input
|
|
except NameError:
|
|
pass
|
|
|
|
confirm = input('Execute: %s \n\
|
|
proceed? [y/n]' % open(fn, 'r').read())
|
|
if not confirm.lower() == 'y':
|
|
sys.exit(0)
|
|
|
|
p = Popen(['sh', fn], stdin=PIPE, stdout=PIPE, stderr=STDOUT,
|
|
shell=False)
|
|
|
|
while p.poll() is None:
|
|
print(p.stdout.readline().decode(
|
|
'ascii', errors='replace').rstrip())
|
|
|
|
print(p.stdout.read().decode('ascii', errors='replace'))
|
|
|
|
|
|
class CustomBuildPyCommand(build_py):
|
|
|
|
def make_compat_modules(self):
|
|
mapping = [
|
|
('pyrocko', 'css', ['pyrocko.io.css']),
|
|
('pyrocko', 'datacube', ['pyrocko.io.datacube']),
|
|
('pyrocko.fdsn', '__init__', []),
|
|
('pyrocko.fdsn', 'enhanced_sacpz', ['pyrocko.io.enhanced_sacpz']),
|
|
('pyrocko.fdsn', 'station', ['pyrocko.io.stationxml']),
|
|
('pyrocko', 'gcf', ['pyrocko.io.gcf']),
|
|
('pyrocko', 'gse1', ['pyrocko.io.gse1']),
|
|
('pyrocko', 'gse2_io_wrap', ['pyrocko.io.gse2']),
|
|
('pyrocko', 'ims', ['pyrocko.io.ims']),
|
|
('pyrocko', 'io_common', ['pyrocko.io.io_common']),
|
|
('pyrocko', 'kan', ['pyrocko.io.kan']),
|
|
('pyrocko', 'mseed', ['pyrocko.io.mseed']),
|
|
('pyrocko', 'rdseed', ['pyrocko.io.rdseed']),
|
|
('pyrocko.fdsn', 'resp', ['pyrocko.io.resp']),
|
|
('pyrocko', 'sacio', ['pyrocko.io.sac']),
|
|
('pyrocko', 'segy', ['pyrocko.io.segy']),
|
|
('pyrocko', 'seisan_response', ['pyrocko.io.seisan_response']),
|
|
('pyrocko', 'seisan_waveform', ['pyrocko.io.seisan_waveform']),
|
|
('pyrocko', 'suds', ['pyrocko.io.suds']),
|
|
('pyrocko', 'yaff', ['pyrocko.io.yaff']),
|
|
('pyrocko', 'eventdata', ['pyrocko.io.eventdata']),
|
|
('pyrocko.fdsn', 'ws', ['pyrocko.client.fdsn']),
|
|
('pyrocko', 'catalog', ['pyrocko.client.catalog']),
|
|
('pyrocko', 'iris_ws', ['pyrocko.client.iris']),
|
|
('pyrocko', 'crust2x2', ['pyrocko.dataset.crust2x2']),
|
|
('pyrocko', 'crustdb', ['pyrocko.dataset.crustdb']),
|
|
('pyrocko', 'geonames', ['pyrocko.dataset.geonames']),
|
|
('pyrocko', 'tectonics', ['pyrocko.dataset.tectonics']),
|
|
('pyrocko', 'topo', ['pyrocko.dataset.topo']),
|
|
('pyrocko', 'automap', ['pyrocko.plot.automap']),
|
|
('pyrocko', 'beachball', ['pyrocko.plot.beachball']),
|
|
('pyrocko', 'cake_plot', ['pyrocko.plot.cake_plot']),
|
|
('pyrocko', 'gmtpy', ['pyrocko.plot.gmtpy']),
|
|
('pyrocko', 'hudson', ['pyrocko.plot.hudson']),
|
|
('pyrocko', 'response_plot', ['pyrocko.plot.response']),
|
|
('pyrocko', 'snuffling', ['pyrocko.gui.snuffling']),
|
|
('pyrocko', 'pile_viewer', ['pyrocko.gui.pile_viewer']),
|
|
('pyrocko', 'marker', ['pyrocko.gui.marker']),
|
|
('pyrocko', 'snuffler', ['pyrocko.gui.snuffler']),
|
|
('pyrocko', 'gui_util', ['pyrocko.gui.util']),
|
|
]
|
|
|
|
for (package, compat_module, import_modules) in mapping:
|
|
module_code = '''
|
|
import sys
|
|
import pyrocko
|
|
if pyrocko.grumpy:
|
|
sys.stderr.write('using renamed pyrocko module: %s.%s\\n')
|
|
sys.stderr.write(' -> should now use: %s\\n\\n')
|
|
|
|
''' % (package, compat_module, ', '.join(import_modules)) + ''.join(
|
|
['from %s import *\n' % module for module in import_modules])
|
|
|
|
outfile = self.get_module_outfile(
|
|
self.build_lib, package.split('.'), compat_module)
|
|
|
|
dir = os.path.dirname(outfile)
|
|
self.mkpath(dir)
|
|
with open(outfile, 'w') as f:
|
|
f.write(module_code)
|
|
|
|
def run(self):
|
|
make_info_module(packname, version)
|
|
self.make_compat_modules()
|
|
build_py.run(self)
|
|
|
|
|
|
class CustomBuildExtCommand(build_ext):
|
|
def run(self):
|
|
make_prerequisites()
|
|
build_ext.run(self)
|
|
|
|
|
|
class CustomBuildAppCommand(build_ext):
|
|
def run(self):
|
|
self.make_app()
|
|
|
|
def make_app(self):
|
|
import glob
|
|
import os
|
|
import shutil
|
|
from setuptools import setup
|
|
|
|
APP = ['apps/snuffler']
|
|
DATA_FILES = []
|
|
OPTIONS = {
|
|
'argv_emulation': True,
|
|
'iconfile': 'src/data/snuffler.icns',
|
|
'packages': 'pyrocko',
|
|
'excludes': [
|
|
'PyQt4.QtDesigner',
|
|
'PyQt4.QtScript',
|
|
'PyQt4.QtScriptTools',
|
|
'PyQt4.QtTest',
|
|
'PyQt4.QtCLucene',
|
|
'PyQt4.QtDeclarative',
|
|
'PyQt4.QtHelp',
|
|
'PyQt4.QtSql',
|
|
'PyQt4.QtTest',
|
|
'PyQt4.QtXml',
|
|
'PyQt4.QtXmlPatterns',
|
|
'PyQt4.QtMultimedia',
|
|
'PyQt4.phonon',
|
|
'matplotlib.tests',
|
|
'matplotlib.testing'],
|
|
'plist': 'src/data/Info.plist'}
|
|
|
|
setup(
|
|
app=APP,
|
|
data_files=DATA_FILES,
|
|
options={'py2app': OPTIONS},
|
|
setup_requires=['py2app'],
|
|
)
|
|
|
|
# Manually delete files which refuse to be ignored using 'excludes':
|
|
want_delete = glob.glob(
|
|
'dist/snuffler.app/Contents/Frameworks/libvtk*')
|
|
|
|
map(os.remove, want_delete)
|
|
|
|
want_delete_dir = glob.glob(
|
|
'dist/Snuffler.app/Contents/Resources/lib/python2.7/'
|
|
'matplotlib/test*')
|
|
map(shutil.rmtree, want_delete_dir)
|
|
|
|
|
|
def _check_for_openmp():
|
|
"""Check whether the default compiler supports OpenMP.
|
|
This routine is adapted from pynbody // yt.
|
|
Thanks to Nathan Goldbaum and Andrew Pontzen.
|
|
"""
|
|
import distutils.sysconfig
|
|
import subprocess
|
|
|
|
tmpdir = tempfile.mkdtemp(prefix='pyrocko')
|
|
compiler = os.environ.get(
|
|
'CC', distutils.sysconfig.get_config_var('CC')).split()[0]
|
|
|
|
# Attempt to compile a test script.
|
|
# See http://openmp.org/wp/openmp-compilers/
|
|
tmpfile = op.join(tmpdir, 'check_openmp.c')
|
|
with open(tmpfile, 'w') as f:
|
|
f.write('''
|
|
#include <omp.h>
|
|
#include <stdio.h>
|
|
int main() {
|
|
#pragma omp parallel
|
|
printf("Hello from thread %d", omp_get_thread_num());
|
|
}
|
|
''')
|
|
|
|
try:
|
|
with open(os.devnull, 'w') as fnull:
|
|
exit_code = subprocess.call([compiler, '-fopenmp', '-o%s'
|
|
% op.join(tmpdir, 'check_openmp'),
|
|
tmpfile],
|
|
stdout=fnull, stderr=fnull)
|
|
except OSError:
|
|
exit_code = 1
|
|
finally:
|
|
shutil.rmtree(tmpdir)
|
|
|
|
if exit_code == 0:
|
|
print('Continuing your build using OpenMP...')
|
|
return True
|
|
|
|
import multiprocessing
|
|
import platform
|
|
if multiprocessing.cpu_count() > 1:
|
|
print('''WARNING
|
|
OpenMP support is not available in your default C compiler, even though
|
|
your machine has more than one core available.
|
|
Some routines in pyrocko are parallelized using OpenMP and these will
|
|
only run on one core with your current configuration.
|
|
''')
|
|
if platform.uname()[0] == 'Darwin':
|
|
print('''Since you are running on Mac OS, it's likely that the problem here
|
|
is Apple's Clang, which does not support OpenMP at all. The easiest
|
|
way to get around this is to download the latest version of gcc from
|
|
here: http://hpc.sourceforge.net. After downloading, just point the
|
|
CC environment variable to the real gcc and OpenMP support should
|
|
get enabled automatically. Something like this -
|
|
sudo tar -xzf /path/to/download.tar.gz /
|
|
export CC='/usr/local/bin/gcc'
|
|
python setup.py clean
|
|
python setup.py build
|
|
''')
|
|
print('Continuing your build without OpenMP...')
|
|
return False
|
|
|
|
|
|
if _check_for_openmp():
|
|
omp_arg = ['-fopenmp']
|
|
omp_lib = ['-lgomp']
|
|
else:
|
|
omp_arg = []
|
|
omp_lib = []
|
|
|
|
|
|
subpacknames = [
|
|
'pyrocko.gf',
|
|
'pyrocko.fomosto',
|
|
'pyrocko.fomosto.report',
|
|
'pyrocko.client',
|
|
'pyrocko.apps',
|
|
'pyrocko.io',
|
|
'pyrocko.model',
|
|
'pyrocko.plot',
|
|
'pyrocko.gui',
|
|
'pyrocko.gui.snufflings',
|
|
'pyrocko.gui.snufflings.map',
|
|
'pyrocko.dataset',
|
|
'pyrocko.dataset.topo',
|
|
'pyrocko.streaming',
|
|
'pyrocko.scenario',
|
|
'pyrocko.scenario.targets',
|
|
'pyrocko.scenario.sources',
|
|
'pyrocko.obspy_compat',
|
|
]
|
|
|
|
|
|
setup(
|
|
cmdclass={
|
|
'install': CustomInstallCommand,
|
|
'build_py': CustomBuildPyCommand,
|
|
# 'py2app': CustomBuildAppCommand,
|
|
'build_ext': CustomBuildExtCommand,
|
|
'check_multiple_install': CheckInstalls,
|
|
'install_prerequisites': InstallPrerequisits,
|
|
'uninstall': Uninstall,
|
|
},
|
|
|
|
name=packname,
|
|
version=version,
|
|
description='A versatile seismology toolkit for Python.',
|
|
long_description=open('maintenance/readme-pip.rst', 'rb').read().decode('utf8'),
|
|
author='The Pyrocko Developers',
|
|
author_email='info@pyrocko.org',
|
|
url='https://pyrocko.org',
|
|
license='GPLv3',
|
|
classifiers=[
|
|
'License :: OSI Approved :: GNU General Public License v3 (GPLv3)',
|
|
'Development Status :: 5 - Production/Stable',
|
|
'Intended Audience :: Science/Research',
|
|
'Programming Language :: Python :: 2.7',
|
|
'Programming Language :: Python :: 3',
|
|
'Programming Language :: C',
|
|
'Programming Language :: Python :: Implementation :: CPython',
|
|
'Operating System :: POSIX',
|
|
'Operating System :: MacOS',
|
|
'Topic :: Scientific/Engineering',
|
|
'Topic :: Scientific/Engineering :: Physics',
|
|
'Topic :: Scientific/Engineering :: Visualization',
|
|
'Topic :: Scientific/Engineering :: Information Analysis',
|
|
'Topic :: Software Development :: Libraries :: Application Frameworks',
|
|
],
|
|
keywords=[
|
|
'seismology, waveform analysis, earthquake modelling, geophysics,'
|
|
' geophysical inversion'],
|
|
python_requires='>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, <4',
|
|
install_requires=[],
|
|
|
|
extras_require={
|
|
'gui_scripts': ['PyQt4'],
|
|
},
|
|
|
|
packages=[packname] + subpacknames,
|
|
package_dir={'pyrocko': 'src'},
|
|
ext_package=packname,
|
|
ext_modules=[
|
|
Extension(
|
|
'util_ext',
|
|
extra_compile_args=['-Wextra'],
|
|
sources=[op.join('src', 'ext', 'util_ext.c')]),
|
|
|
|
Extension(
|
|
'signal_ext',
|
|
include_dirs=[get_python_inc(), numpy.get_include()],
|
|
extra_compile_args=['-Wextra'],
|
|
sources=[op.join('src', 'ext', 'signal_ext.c')]),
|
|
|
|
Extension(
|
|
'mseed_ext',
|
|
include_dirs=[get_python_inc(), numpy.get_include(),
|
|
get_build_include('libmseed/')],
|
|
library_dirs=[get_build_include('libmseed/')],
|
|
libraries=['mseed'],
|
|
extra_compile_args=['-Wextra'],
|
|
sources=[op.join('src', 'io', 'ext', 'mseed_ext.c')]),
|
|
|
|
Extension(
|
|
'evalresp_ext',
|
|
include_dirs=[get_python_inc(), numpy.get_include(),
|
|
get_build_include('evalresp-3.3.0/include/')],
|
|
library_dirs=[get_build_include('evalresp-3.3.0/lib/')],
|
|
libraries=['evresp'],
|
|
extra_compile_args=[
|
|
'-Wextra',
|
|
'-I%s' % get_build_include('evalresp-3.3.0/include')],
|
|
sources=[op.join('src', 'ext', 'evalresp_ext.c')]),
|
|
|
|
Extension(
|
|
'ims_ext',
|
|
include_dirs=[get_python_inc(), numpy.get_include()],
|
|
extra_compile_args=['-Wextra'],
|
|
sources=[op.join('src', 'io', 'ext', 'ims_ext.c')]),
|
|
|
|
Extension(
|
|
'datacube_ext',
|
|
include_dirs=[get_python_inc(), numpy.get_include()],
|
|
extra_compile_args=['-Wextra'],
|
|
sources=[op.join('src', 'io', 'ext', 'datacube_ext.c')]),
|
|
|
|
Extension(
|
|
'autopick_ext',
|
|
include_dirs=[get_python_inc(), numpy.get_include()],
|
|
extra_compile_args=['-Wextra'],
|
|
sources=[op.join('src', 'ext', 'autopick_ext.c')]),
|
|
|
|
Extension(
|
|
'gf.store_ext',
|
|
include_dirs=[get_python_inc(), numpy.get_include()],
|
|
extra_compile_args=['-D_FILE_OFFSET_BITS=64', '-Wextra'] + omp_arg,
|
|
extra_link_args=[] + omp_lib,
|
|
sources=[op.join('src', 'gf', 'ext', 'store_ext.c')]),
|
|
|
|
Extension(
|
|
'eikonal_ext',
|
|
include_dirs=[get_python_inc(), numpy.get_include()],
|
|
extra_compile_args=['-Wextra'] + omp_arg,
|
|
extra_link_args=[] + omp_lib,
|
|
sources=[op.join('src', 'ext', 'eikonal_ext.c')]),
|
|
|
|
Extension(
|
|
'parstack_ext',
|
|
include_dirs=[get_python_inc(), numpy.get_include()],
|
|
extra_compile_args=['-Wextra'] + omp_arg,
|
|
extra_link_args=[] + omp_lib,
|
|
sources=[op.join('src', 'ext', 'parstack_ext.c')]),
|
|
|
|
Extension(
|
|
'ahfullgreen_ext',
|
|
include_dirs=[get_python_inc(), numpy.get_include()],
|
|
extra_compile_args=['-Wextra'],
|
|
sources=[op.join('src', 'ext', 'ahfullgreen_ext.c')]),
|
|
|
|
Extension(
|
|
'orthodrome_ext',
|
|
include_dirs=[get_python_inc(), numpy.get_include()],
|
|
extra_compile_args=['-Wextra'],
|
|
sources=[op.join('src', 'ext', 'orthodrome_ext.c')]),
|
|
|
|
Extension(
|
|
"avl",
|
|
sources=[op.join('src', 'ext', 'pyavl-1.12', 'avl.c'),
|
|
op.join('src', 'ext', 'pyavl-1.12', 'avlmodule.c')],
|
|
define_macros=[('HAVE_AVL_VERIFY', None),
|
|
('AVL_FOR_PYTHON', None)],
|
|
include_dirs=[get_python_inc()],
|
|
extra_compile_args=['-Wno-parentheses', '-Wno-uninitialized'],
|
|
extra_link_args=[] if sys.platform != 'sunos5' else ['-Wl,-x']),
|
|
],
|
|
|
|
scripts=[
|
|
'src/apps/gmtpy-epstopdf',
|
|
],
|
|
|
|
entry_points={
|
|
'console_scripts':
|
|
['fomosto = pyrocko.apps.fomosto:main',
|
|
'cake = pyrocko.apps.cake:main',
|
|
'automap = pyrocko.apps.automap:main',
|
|
'hamster = pyrocko.apps.hamster:main',
|
|
'jackseis = pyrocko.apps.jackseis:main',
|
|
'colosseo = pyrocko.apps.colosseo:main'],
|
|
'gui_scripts':
|
|
['snuffler = pyrocko.apps.snuffler:main']
|
|
},
|
|
|
|
package_data={
|
|
packname: ['data/*.png',
|
|
'data/*.html',
|
|
'data/earthmodels/*.nd',
|
|
'data/colortables/*.cpt',
|
|
'data/tectonics/*.txt',
|
|
'data/fomosto_report/gfreport.*',
|
|
'gui/snufflings/map/*ml',
|
|
'gui/snufflings/map/*.js',
|
|
] + get_readme_paths()}
|
|
)
|
|
|