def finalize_options(self):
build_ext.finalize_options(self)
if self.compiler is None:
compiler = get_default_compiler()
else:
compiler = self.compiler
if compiler == "msvc":
# Add msvc specific hacks
if (sys.version_info.major, sys.version_info.minor) < (3, 3):
# The check above is a nasty hack. We're using the python
# version as a proxy for the MSVC version. 2008 doesn't
# have stdint.h, so is needed. 2010 does.
#
# We need to add the path to msvc includes
include_dirs.append(os.path.join(os.getcwd(), "include", "msvc_2008"))
# We need to prepend lib to all the library names
_libraries = []
for each_lib in self.libraries:
_libraries.append("lib" + each_lib)
self.libraries = _libraries
def finalize_options(self):
self.set_undefined_options('build')
try:
r_home = subprocess.check_output(("R", "RHOME"),
universal_newlines=True)
except:
raise SystemExit("Error: Tried to guess R's HOME but no R command in the PATH.")
r_home = r_home.split(os.linesep)
#Twist if 'R RHOME' spits out a warning
if r_home[0].startswith("WARNING"):
r_home = r_home[1].rstrip()
else:
r_home = r_home[0].rstrip()
rexec = RExec(r_home)
if rexec.version[0] == 'development' or \
cmp_version(rexec.version[:2], [2, 8]) == -1:
if self.ignore_check_rversion:
warnings.warn("R did not seem to have the minimum required version number")
else:
raise SystemExit("Error: R >= 2.8 required (and R told '%s')." %'.'.join(rexec.version))
try:
super(build_ext, self).finalize_options()
except TypeError:
# distutils parent class an old style Python class
_build_ext.finalize_options(self)
def finalize_options(self):
build_ext.finalize_options(self)
import builtins
# Prevent numpy from thinking it is still in its setup process:
builtins.__NUMPY_SETUP__ = False
import numpy
self.include_dirs.append(numpy.get_include())
def finalize_options(self):
_build_ext.finalize_options(self)
# Prevent numpy from thinking it is still in its setup process
__builtins__.__NUMPY_SETUP__ = False
print('build_ext: including numpy files')
import numpy
self.include_dirs.append(numpy.get_include())
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)
def finalize_options(self):
print("Finalizing options")
_build_ext.finalize_options(self)
# Prevent numpy from thinking it is still in its setup process:
__builtins__.__NUMPY_SETUP__ = False
import numpy
self.include_dirs.append(numpy.get_include())
def finalize_options(self):
options_pairs = []
if not self.with_mysql_capi:
options_pairs.append(('with_mysql_capi', 'with_mysql_capi'))
if not self.with_protobuf_include_dir:
options_pairs.append(('with_protobuf_include_dir',
'with_protobuf_include_dir'))
if not self.with_protobuf_lib_dir:
options_pairs.append(('with_protobuf_lib_dir',
'with_protobuf_lib_dir'))
if not self.with_protoc:
options_pairs.append(('with_protoc', 'with_protoc'))
if options_pairs:
self.set_undefined_options('install', *options_pairs)
build_ext.finalize_options(self)
print("# Python architecture: {0}".format(py_arch))
print("# Python ARCH_64BIT: {0}".format(ARCH_64BIT))
self.connc_lib = os.path.join(self.build_temp, 'connc', 'lib')
self.connc_include = os.path.join(self.build_temp, 'connc', 'include')
self.protobuf_lib = os.path.join(self.build_temp, 'protobuf', 'lib')
self.protobuf_include = os.path.join(self.build_temp, 'protobuf', 'include')
if self.with_mysql_capi:
self._finalize_connector_c(self.with_mysql_capi)
if not self.with_protobuf_include_dir:
self.with_protobuf_include_dir = \
os.environ.get("MYSQLXPB_PROTOBUF_INCLUDE_DIR")
if not self.with_protobuf_lib_dir:
self.with_protobuf_lib_dir = \
os.environ.get("MYSQLXPB_PROTOBUF_LIB_DIR")
if not self.with_protoc:
self.with_protoc = os.environ.get("MYSQLXPB_PROTOC")
if self.with_protobuf_include_dir:
print("# Protobuf include directory: {0}"
"".format(self.with_protobuf_include_dir))
else:
log.error("Unable to find Protobuf include directory.")
sys.exit(1)
if self.with_protobuf_lib_dir:
print("# Protobuf library directory: {0}"
"".format(self.with_protobuf_lib_dir))
else:
log.error("Unable to find Protobuf library directory.")
sys.exit(1)
if self.with_protoc:
print("# Protobuf protoc binary: {0}".format(self.with_protoc))
else:
log.error("Unable to find Protobuf protoc binary.")
sys.exit(1)
self._finalize_protobuf()
def finalize_options(self):
self.set_undefined_options(
'install',
('extra_compile_args', 'extra_compile_args'),
('with_mysql_capi', 'with_mysql_capi'),
('with_protobuf_include_dir', 'with_protobuf_include_dir'),
('with_protobuf_lib_dir', 'with_protobuf_lib_dir'),
('with_protoc', 'with_protoc'))
build_ext.finalize_options(self)
print("# Python architecture: {0}".format(py_arch))
print("# Python ARCH_64BIT: {0}".format(ARCH_64BIT))
if self.with_mysql_capi:
self._finalize_connector_c(self.with_mysql_capi)
if not self.with_protobuf_include_dir:
self.with_protobuf_include_dir = \
os.environ.get("MYSQLXPB_PROTOBUF_INCLUDE_DIR")
if not self.with_protobuf_lib_dir:
self.with_protobuf_lib_dir = \
os.environ.get("MYSQLXPB_PROTOBUF_LIB_DIR")
if not self.with_protoc:
self.with_protoc = os.environ.get("MYSQLXPB_PROTOC")
def finalize_options(self):
build_ext.finalize_options(self)
if not self.distribution.has_c_libraries():
return
# Go through individual extensions and set their rpath variable and
# library search paths
build_clib = self.get_finalized_command("build_clib")
libnames = [libname for libname, _ in build_clib.libraries]
rpaths_abs = [os.path.dirname(build_clib.get_fullpath(lib))
for lib in build_clib.libraries]
rpaths_abs = list(set(rpaths_abs))
libdirs = [os.path.join(build_clib.build_clib, p)
for p in rpaths_abs]
for ext in self.extensions:
ext_path = self.get_ext_filename(ext.name)
rpaths_rel = [os.path.relpath(p, os.path.dirname(ext_path))
for p in rpaths_abs]
ext.runtime_library_dirs.extend(
["$ORIGIN/{}".format(p) for p in rpaths_rel])
ext.libraries.extend(libnames)
ext.library_dirs.extend(libdirs)
def finalize_options(self):
_build_ext.finalize_options(self)
# Prevent numpy from thinking it is still in its setup process:
if hasattr(__builtins__, '__NUMPY_SETUP__'):
__builtins__.__NUMPY_SETUP__ = False
import numpy
self.include_dirs.append(numpy.get_include())
def finalize_options(self):
_build_ext.finalize_options(self)
# prevent numpy from thinking it is still in its setup process
__builtins__.__NUMPY_SETUP__ = False
import numpy
# place numpy includes first, see gh #156
self.include_dirs.insert(0, numpy.get_include())
def finalize_options(self):
_build_ext.finalize_options(self)
self.set_undefined_options("build",
("force_pyx_compile", "force_pyx_compile"),
("force_template_update", "force_template_update")
)
def finalize_options(self):
# Validate the --enable-openmp and --disable-openmp command line options:
# the user should provide at most one of them.
if self.enable_openmp and self.disable_openmp:
raise _DistutilsOptionError("--enable-openmp and --disable-openmp are mutually exclusive")
# Chain to method in parent class.
_build_ext.finalize_options(self)
def finalize_options(self):
_build_ext.finalize_options(self)
# Before importing numpy, we need to make sure it doesn't think it
# is still during its setup process:
__builtins__.__NUMPY_SETUP__ = False
import numpy
# Add location of numpy headers:
self.include_dirs.append(numpy.get_include())
def finalize_options(self):
self.set_undefined_options('install',
('with_mysql_capi', 'with_mysql_capi'))
build_ext.finalize_options(self)
if self.with_mysql_capi:
self._finalize_connector_c(self.with_mysql_capi)
def finalize_options(self):
build_ext.finalize_options(self)
if self.compiler is None:
compiler = get_default_compiler()
else:
compiler = self.compiler
def finalize_options(self):
self.with_proj4 = self.truthify(self.with_proj4)
self.with_geos = self.truthify(self.with_geos)
self.with_geosadvanced = self.truthify(self.with_geosadvanced)
self.with_iconv = self.truthify(self.with_iconv)
self.with_freexl = self.truthify(self.with_freexl)
build_ext.finalize_options(self)
def finalize_options(self):
build_ext.finalize_options(self)
if self.compiler is None:
compiler = get_default_compiler()
else:
compiler = self.compiler
if compiler == 'msvc':
include_dirs.append('compat/win32')
def finalize_options(self):
_build_ext.finalize_options(self)
# Prevent numpy from thinking it is still in its setup process
try:
del builtins.__NUMPY_SETUP__
except AttributeError:
pass
import numpy
self.include_dirs.append(numpy.get_include())
def finalize_options(self):
# check if the "BOB_BUILD_DIRECTORY" environment variable is set
env = os.environ
if 'BOB_BUILD_DIRECTORY' in env and env['BOB_BUILD_DIRECTORY']:
# HACKISH: check if we are currently developed by inspecting the way we got called
if 'develop' in sys.argv:
self.build_temp = os.path.join(env['BOB_BUILD_DIRECTORY'], 'build_temp')
self.build_lib = os.path.join(env['BOB_BUILD_DIRECTORY'], 'build_lib')
_build_ext.finalize_options(self)
def finalize_options(self):
# Setting include_dirs, library_dirs, swig_opts here instead of in Extension constructor allows them to be
# overridden using -I and -L command line options to python setup.py build_ext.
build_ext.finalize_options(self)
include_dirs, library_dirs = locate_ob()
self.include_dirs.append(include_dirs)
self.library_dirs.append(library_dirs)
self.swig_opts = ['-c++', '-small', '-O', '-templatereduce', '-naturalvar']
self.swig_opts += ['-I%s' % i for i in self.include_dirs]
print('- include_dirs: %s\n- library_dirs: %s' % (self.include_dirs, self.library_dirs))
def finalize_options(self):
_build_ext.finalize_options(self)
# Prevent numpy from thinking it is still in its setup process:
import builtins
if hasattr(builtins, '__NUMPY_SETUP__'):
del builtins.__NUMPY_SETUP__
import importlib
import numpy
importlib.reload(numpy)
self.include_dirs.append(numpy.get_include())
def finalize_options(self):
global do_output
build_ext.finalize_options(self)
# I couldn't find an easy way to send the user option from my_install to my_buld_ext.
# So use a global variable. (UGH!)
if self.njobs is None and 'glob_njobs' in globals():
global glob_njobs
self.njobs = glob_njobs
add_dirs(self, output=do_output)
do_output = False
def finalize_options(self):
if sys.version_info[0] >= 3:
import builtins
else:
import __builtin__ as builtins
_build_ext.finalize_options(self)
# Prevent numpy from thinking it is still in its setup process:
builtins.__NUMPY_SETUP__ = False
import numpy
self.include_dirs.append(numpy.get_include())
def finalize_options(self):
_build_ext.finalize_options(self)
# __builtins__ is a dict when this module isn't __main__
# see https://docs.python.org/2/reference/executionmodel.html
if isinstance(__builtins__, dict):
__builtins__['__NUMPY_SETUP__'] = False
else:
__builtins__.__NUMPY_SETUP__ = False
import numpy as np
self.include_dirs.append(np.get_include())
def finalize_options(self):
if not self.with_mysql_capi:
self.set_undefined_options('install',
('with_mysql_capi', 'with_mysql_capi'))
build_ext.finalize_options(self)
self.connc_lib = os.path.join(self.build_temp, 'connc', 'lib')
self.connc_include = os.path.join(self.build_temp, 'connc', 'include')
if self.with_mysql_capi:
self._finalize_connector_c(self.with_mysql_capi)
def finalize_options(self):
build_ext.finalize_options(self)
if self.compiler is None:
# we use this variable with tox to build using GCC on Windows.
# https://bitbucket.org/hpk42/tox/issues/274/specify-compiler
self.compiler = os.environ.get("DISTUTILS_COMPILER", None)
if self.compiler == "mingw32":
# workaround for virtualenv changing order of libary_dirs on
# Windows, which makes gcc fail to link with the correct libpython
# https://github.com/mingwpy/mingwpy.github.io/issues/31
self.library_dirs.insert(0, os.path.join(sys.exec_prefix, 'libs'))
def finalize_options(self):
'''
In order to avoid premature import of numpy before it gets installed as a dependency
get numpy include directories during the extensions building process
http://stackoverflow.com/questions/19919905/how-to-bootstrap-numpy-installation-in-setup-py
'''
build_ext.finalize_options(self)
# Prevent numpy from thinking it is still in its setup process:
__builtins__.__NUMPY_SETUP__ = False
import numpy
self.include_dirs.append(numpy.get_include())
def finalize_options(self):
# Setting include_dirs, library_dirs, swig_opts here instead of in Extension constructor allows them to be
# overridden using -I and -L command line options to python setup.py build_ext.
if not self.include_dirs and not self.library_dirs:
self.include_dirs, self.library_dirs = locate_ob()
else:
print('Open Babel location manually specified:')
print('- include_dirs: %s\n- library_dirs: %s' % (self.include_dirs, self.library_dirs))
build_ext.finalize_options(self)
self.swig_opts = ['-c++', '-small', '-O', '-templatereduce', '-naturalvar']
self.swig_opts += ['-I%s' % i for i in self.include_dirs]
def finalize_options(self):
build_ext.finalize_options(self)
# Prevent numpy from thinking it is still in its setup process:
# https://docs.python.org/2/library/__builtin__.html#module-__builtin__
if isinstance(__builtins__, dict):
__builtins__["__NUMPY_SETUP__"] = False
else:
__builtins__.__NUMPY_SETUP__ = False
import numpy
self.include_dirs.append(numpy.get_include())
def finalize_options(self):
"""Finalize this command's options."""
build_ext.finalize_options(self)
if self.gen_compiledb:
self.dry_run = True # pylint: disable=attribute-defined-outside-init
def finalize_options(self):
build_ext.finalize_options(self)
if self.cmake_args is None:
self.cmake_args = []
else:
self.cmake_args = shlex.split(self.cmake_args)
def finalize_options(self):
build_ext.finalize_options(self)
import numpy
self.include_dirs.append(numpy.get_include())
def finalize_options(self):
_build_ext.finalize_options(self)
if self.define is not None:
self.define.extend(define_opts)
elif define_opts:
self.define = define_opts
def finalize_options(self):
_build_ext.finalize_options(self)
# Get the value of the skip-driver parameter from the install command.
self.set_undefined_options("install", ("skip_driver", "skip_driver"))
self.set_undefined_options("build", ("skip_driver", "skip_driver"))
def finalize_options(self):
_build_ext.finalize_options(self)
# Prevent numpy from thinking it's still in its setup process
import numpy as np
self.include_dirs.append(np.get_include())
def finalize_options(self):
build_ext.finalize_options(self)
# initialise #define list
self.define = self.define or []
# try to get commit from working directory
flask_commit = run(['git', 'rev-parse', '--short', 'HEAD'],
stdout=PIPE, stderr=DEVNULL, universal_newlines=True
).stdout.strip() or 'missing'
# add commit definition
self.define += [
('FLASKCOMMIT', f'"{flask_commit}"'),
]
# process healpix_dir if given
if self.healpix_dir is not None:
print(f'HEALPix path: {self.healpix_dir}')
# must be a directory
if not os.path.isdir(self.healpix_dir):
raise ValueError(f'not a directory: {self.healpix_dir}')
# infer include directory if not given explicitly
if self.healpix_include_dir is None:
self.healpix_include_dir = os.path.join(self.healpix_dir, 'include', 'healpix_cxx')
# infer lib directory if not given explicitly
if self.healpix_lib_dir is None:
self.healpix_lib_dir = os.path.join(self.healpix_dir, 'lib')
# infer data directory if not given explicitly
if self.healpix_data_dir is None:
self.healpix_data_dir = os.path.join(self.healpix_dir, 'data')
# process healpix_include_dir if given
if self.healpix_include_dir is not None:
print(f'HEALPix include path: {self.healpix_include_dir}')
if not os.path.isdir(self.healpix_include_dir):
raise ValueError(f'not a directory: {self.healpix_include_dir}')
self.include_dirs.append(self.healpix_include_dir)
# process healpix_lib_dir if given
if self.healpix_lib_dir is not None:
print(f'HEALPix lib path: {self.healpix_lib_dir}')
if not os.path.isdir(self.healpix_lib_dir):
raise ValueError(f'not a directory: {self.healpix_lib_dir}')
self.library_dirs.append(self.healpix_lib_dir)
self.rpath.append(self.healpix_lib_dir)
# healpix_data_dir must be given
if self.healpix_data_dir is None:
raise ValueError('missing healpix_data_dir option')
print(f'HEALPix data path: {self.healpix_data_dir}')
if not os.path.isdir(self.healpix_data_dir):
raise ValueError(f'not a directory: {self.healpix_data_dir}')
# add definitions related to HEALPix
self.define += [
('HEALPIX_DATA', f'"{self.healpix_data_dir}"'),
('USEXCOMPLEX', 0),
('USEMAP2TGA', 0),
]
def finalize_options(self):
build_ext.finalize_options(self)
__builtins__.__NUMPY_SETUP__ = False
import numpy # pylint: disable=import-outside-toplevel
self.include_dirs.append(numpy.get_include())
def finalize_options(self):
_build_ext.finalize_options(self)
builtins.__NUMPY_SETUP__ = False
import numpy
self.include_dirs.append(numpy.get_include())
def finalize_options(self):
# Setting parallel to true can break builds when we need to configure
# embedded libraries, which we do by changing directories. If that
# happens while we're compiling, we may not be able to find source code.
build_ext.finalize_options(self)
def finalize_options(self):
build_ext.finalize_options(self)
build_obj = self.distribution.get_command_obj("build")
self.use_openmp = build_obj.use_openmp
self.use_cython = build_obj.use_cython
self.force_cython = build_obj.force_cython
def finalize_options(self):
_build_ext.finalize_options(self)
# Prevent numpy from thinking it is still in its setup process:
__builtins__.__NUMPY_SETUP__ = False
def finalize_options(self):
SetuptoolsBuildExtCmd.finalize_options(self)
def finalize_options(self):
build_ext.finalize_options(self)
# See http://stackoverflow.com/a/21621689/2509873
builtins.__NUMPY_SETUP__ = False
import numpy
self.include_dirs.append(numpy.get_include())
def finalize_options(self):
_build_ext.finalize_options(self)
check_dependencies()
def finalize_options(self):
build_ext.finalize_options(self)
is_windows = platform.system() == 'Windows'
is_py2 = sys.version_info[0] < 3
if self.compiler is None and is_windows and is_py2:
self.compiler = 'mingw32'
def finalize_options(self):
_build_ext.finalize_options(self)
# Prevent numpy from thinking it is still in its setup process:
__builtins__.__NUMPY_SETUP__ = False
import numpy
self.include_dirs.append(numpy.get_include())
def finalize_options(self):
build_ext.finalize_options(self)
def finalize_options(self):
build_ext.finalize_options(self)
self.set_undefined_options("build", ("download_dir", "download_dir"))
def finalize_options(self):
"""Post-process options."""
print("build_ext.finalize_options")
build_ext.finalize_options(self)
def finalize_options(self):
build_ext.finalize_options(self)
import numpy
if not len(BLAS_DICT):
self.look_for_blas()
self.include_dirs.append(numpy.get_include())
