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):
build_ext.finalize_options(self)
# Add Numpy header search path path
import numpy
self.include_dirs.append(numpy.get_include())
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('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):
_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)
try:
__builtins__.__NUMPY_SETUP__ = False
except AttributeError as e:
pass
import numpy as np
self.include_dirs.append(np.get_include())
def finalize_options(self):
build_ext.finalize_options(self)
if build_exe:
# need to be done in-place, otherwise build_exe_options['path'] will use
# the unmodified version because it is computed before build_ext is
# called
cxfreeze_searchpath.insert(0, self.build_lib)
def finalize_options(self):
if "--%s" % CYTHONIZE_ARG in self.distribution.script_args or CYTHONIZE_COMMAND in self.distribution.script_args:
self.run_command('clean')
print("build_c_from_pyx: regenerating .c files from Cython")
extensions = cythonize(ext_modules,compiler_directives=CYTHON_ARGS)
self.extensions = extensions
build_ext.finalize_options(self)
def finalize_options(self):
_build_ext.finalize_options(self)
# Fix to work with bootstrapped numpy installation
# http://stackoverflow.com/a/21621689/579416
# 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)
if build_exe:
# need to be done in-place, otherwise build_exe_options['path'] will use
# the unmodified version because it is computed before build_ext is
# called
cxfreeze_searchpath.insert(0, self.build_lib)
def finalize_options(self):
# For inplace building
self.inplace = True
# Remove files needing gsl,
self.distribution.ext_modules = [
ext for ext in self.distribution.ext_modules
if "denoising" not in ext.name
]
build_ext.finalize_options(self)
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 as np
self.include_dirs.append(np.get_include())
# finalize pcl_helper directories
self.cwd_pcl_helper_dir_lib = os.path.join(cwd, pcl_helper_dir_lib)
self.build_pcl_helper_dir_lib = os.path.join(self.build_lib, pcl_helper_dir_lib)
# check global flag SKIP_PCL_HELPER
self.skip_pcl_helper = self.skip_pcl_helper or SKIP_PCL_HELPER
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
import eigency
self.include_dirs += [r"GeneralTmm/src/CppTmm/CppTmm",
r"GeneralTmm/src/eigen_3.2.4",
r"GeneralTmm/src/Simplex",
numpy.get_include()] + \
eigency.get_includes(include_eigen = False)
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 as np
self.include_dirs.append(np.get_include())
# finalize pcl_helper directories
self.cwd_pcl_helper_dir_lib = os.path.join(cwd, pcl_helper_dir_lib)
self.build_pcl_helper_dir_lib = os.path.join(self.build_lib,
pcl_helper_dir_lib)
# check global flag SKIP_PCL_HELPER
self.skip_pcl_helper = self.skip_pcl_helper or SKIP_PCL_HELPER
def finalize_options(self):
if "--%s" % CYTHONIZE_ARG in self.distribution.script_args or CYTHONIZE_COMMAND in self.distribution.script_args:
self.run_command('clean')
print("build_c_from_pyx: regenerating .c files from Cython")
extensions = cythonize(
ext_modules,
compiler_directives=CYTHON_ARGS,
compile_time_env=CYTHON_COMPILE_TIME_ENV,
)
self.extensions = extensions
build_ext.finalize_options(self)
def finalize_options(self):
# Force inplace building for ease of importation
self.inplace = True
# If trying to build everything without cythongsl installed, raise.
if not have_cython_gsl:
raise ValueError(
'cannot find gsl package (required for denoising). Try\n' +
' pip install cythongsl\nand\n' +
' sudo apt-get install libgsl0-dev libgsl0ldbl\n' +
'or use build_no_gsl')
build_ext.finalize_options(self)
def finalize_options(self):
_build_ext.finalize_options(self)
# Prevent numpy from thinking it is still in its setup process:
__builtins__.__NUMPY_SETUP__ = False
try:
import numpy
except ImportError:
#guess
site_packages = [p for p in sys.path if sys.prefix in p and '-packages' in p][0]
include_dir = os.path.join(site_packages,'numpy','core','include')
#still see an error since bdist_wheel is attempted be built before numpy is installed.
#this would all work except that 'setup_requires' parameter doesn't seem to work with pip.
else:
include_dir = numpy.get_include()
self.include_dirs.append(include_dir)
def finalize_options(self):
retval = build_ext.finalize_options(self)
global build_path
if (self.build_lib is not None and exists(self.build_lib)
and not self.inplace):
build_path = self.build_lib
return retval
def finalize_options(self):
retval = build_ext.finalize_options(self)
global build_path
if (self.build_lib is not None and exists(self.build_lib) and
not self.inplace):
build_path = self.build_lib
return retval
def finalize_options(self):
# pylint: disable-msg=assignment-from-no-return
retval = build_ext.finalize_options(self)
global build_path # noqa
if (self.build_lib is not None and exists(self.build_lib)
and not self.inplace):
build_path = self.build_lib
return retval
def finalize_options(self):
# Finalizing father's \"user_options\".
_build_ext.finalize_options(self)
# If yet \"None\", finalize own new \"user_options\" searching their
# values.
if (self.mpi_include_path is None):
self.mpi_include_path = self.find_mpi_include_path()
if (self.bitpit_path is None):
self.bitpit_path = self.find_bipit_path()
if (self.madeleine_path is None):
self.madeleine_path = self.find_madeleine_path()
# Check if the source to pass at the \"Extension\" class is present and
# finishes with \".pyx\".
self.check_extensions_source()
# Define \"custom cython\" extensions.
self.extensions = self.def_ext_modules()
def finalize_options(self):
# Add a copy of the _compiler.so module as well, but only if there
# are in fact C modules to compile (otherwise there's no reason to
# include a record of the compiler used)
# Note, self.extensions may not be set yet, but
# self.distribution.ext_modules is where any extension modules
# passed to setup() can be found
extensions = self.distribution.ext_modules
if extensions:
src_path = os.path.relpath(
os.path.join(os.path.dirname(__file__), 'src'))
shutil.copy2(os.path.join(src_path, 'compiler.c'),
os.path.join(self.package_name, '_compiler.c'))
ext = Extension(self.package_name + '._compiler',
[os.path.join(self.package_name, '_compiler.c')])
extensions.insert(0, ext)
basecls.finalize_options(self)
# Generate
if self.uses_cython:
try:
from Cython import __version__ as cython_version
except ImportError:
# This shouldn't happen if we made it this far
cython_version = None
if (cython_version is not None and
cython_version != self.uses_cython):
self.force_rebuild = True
# Update the used cython version
self.uses_cython = cython_version
# Regardless of the value of the '--force' option, force a rebuild
# if the debug flag changed from the last build
if self.force_rebuild:
self.force = True
def finalize_options(self):
build_ext_c.finalize_options(self)
# set binding so that compiled methods can be inspected
self.cython_directives['binding'] = True
def finalize_options(self):
# Force inplace building for ease of importation
self.inplace = True
build_ext.finalize_options(self)
def finalize_options(self):
self.ensure_string_list('libraries')
_build_ext.finalize_options(self)
def finalize_options(self):
build_ext.finalize_options(self)
sys.path.insert(0, self.build_lib)
def finalize_options(self):
CythonBuildExtCmd.finalize_options(self)
def finalize_options(self): CythonBuildExtCmd.finalize_options(self)
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):
self.ensure_string_list('libraries')
_build_ext.finalize_options(self)
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 'OMPFLAG' in os.environ:
self.ompflag = os.environ['OMPFLAG']
if 'OMPLIB' in os.environ:
self.ompflag = os.environ['OMPLIB']
def finalize_options(self):
build_ext.finalize_options(self)
self.include_dirs.insert(0, 'include')
self.pyrex_include_dirs.extend(self.include_dirs)
def finalize_options(self):
build_ext.finalize_options(self)
self.include_dirs.insert(0, 'libpurple')
self.pyrex_include_dirs.extend(self.include_dirs)
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):
build_ext_c.finalize_options(self)
# set binding so that compiled methods can be inspected
self.cython_directives['binding'] = True
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):
# Force inplace building for ease of importation
self.inplace = True
build_ext.finalize_options(self)
