def finalize_options(self):
# This ffi is pygit2.ffi due to the path trick used in the beginning
# of the file
from ffi import ffi
self.distribution.ext_modules.append(ffi.verifier.get_extension())
build.finalize_options(self)
def finalize_options(self):
if 'CROSS_COMPILE' in os.environ:
print('Setting up cross compiling environment')
if 'CROOT' in os.environ:
print('Setting up cross compiling prefix')
prefix = os.environ['CROOT']
sysconfig.get_python_lib = get_python_lib
sysconfig.get_python_inc = get_python_inc
sysconfig.PREFIX = prefix
sysconfig.EXEC_PREFIX = prefix
# reinitialize variables
sysconfig._config_vars = None
sysconfig.get_config_var("LDSHARED")
_build_ext.finalize_options = finalize_options
if 'CHOST' in os.environ:
print('Setting up cross compiling platform')
platform = os.environ['CHOST']
sysconfig.PLATFORM = platform
_build_ext.get_ext_filename = get_ext_filename
if 'CARCH' in os.environ:
print('Setting up cross compiling architecture')
os.environ[
'_PYTHON_HOST_PLATFORM'] = 'linux-' + os.environ['CARCH']
os.environ['CC'] = os.environ[
'CROSS_COMPILE'] + sysconfig.get_config_var('CC')
os.environ['LDSHARED'] = os.environ[
'CROSS_COMPILE'] + sysconfig.get_config_var('LDSHARED')
_build.finalize_options(self)
def finalize_options(self):
_build.finalize_options(self)
self.set_undefined_options('config', ('petsc_dir', 'petsc_dir'),
('petsc_arch', 'petsc_arch'))
self.petsc_dir = config.get_petsc_dir(self.petsc_dir)
self.petsc_arch = config.get_petsc_arch(self.petsc_dir,
self.petsc_arch)
def finalize_options (self):
build.finalize_options(self)
for i in xrange(len(include_dirs)):
include_dirs[i] = self.irods_dir + include_dirs[i]
for i in xrange(len(extra_objects)):
extra_objects[i] = self.irods_dir + extra_objects[i]
def finalize_options(self):
build.finalize_options(self)
if not self.doxygen:
if hasattr(self.distribution, "doxygen"):
self.doxygen = self.distribution.doxygen
else:
self.doxygen = "doxygen"
def finalize_options(self):
build.finalize_options(self)
self.hdf5plugin_config = BuildConfig(
config_file=os.path.join(self.build_lib, PROJECT, '_config.py'),
compiler=self.compiler,
hdf5_dir=self.hdf5,
use_cpp11=self.cpp11,
use_sse2=self.sse2,
use_avx2=self.avx2,
use_openmp=self.openmp,
use_native=self.native,
)
logger.info("Build configuration: %s",
self.hdf5plugin_config.get_config_string())
if not self.hdf5plugin_config.use_cpp11:
# Filter out C++11 libraries
self.distribution.libraries = [
(name, info) for name, info in self.distribution.libraries
if '-std=c++11' not in info.get('cflags', [])
]
# Filter out C++11-only extensions
self.distribution.ext_modules = [
ext for ext in self.distribution.ext_modules
if not (isinstance(ext, HDF5PluginExtension)
and ext.cpp11_required)
]
def finalize_options(self):
if self.cross_dir is None:
build.finalize_options(self)
else:
import re, os.path
regexp = ".*\.(win32|win-amd64)-((?:[0-9])\.(?:[0-9]))"
plat, ver = re.match(regexp, self.cross_dir).groups()
if self.plat_name is None:
self.plat_name = plat
if self.cross_ver is None:
self.cross_ver = ver
if self.build_purelib is None:
self.build_purelib = os.path.join(self.build_base,
'lib.{}-{}'.format(self.plat_name, self.cross_ver))
if self.build_platlib is None:
self.build_platlib = os.path.join(self.build_base,
'lib.{}-{}'.format(self.plat_name, self.cross_ver))
if self.build_lib is None:
if self.distribution.ext_modules:
self.build_lib = self.build_platlib
else:
self.build_lib = self.build_purelib
if self.build_temp is None:
self.build_temp = os.path.join(self.build_base,
'temp.{}-{}'.format(self.plat_name, self.cross_ver))
if self.build_scripts is None:
self.build_scripts = os.path.join(self.build_base,
'scripts-{}'.format(self.cross_ver) )
def finalize_options(self):
_build.finalize_options(self)
if not self.rpm_version:
self.rpm_version = self.get_git_describe()
if not self.gtk_version:
self.gtk_version = self.get_gtk_version()
def finalize_options(self):
build_scripts = self.build_scripts
old_build.finalize_options(self)
plat_specifier = ".%s-%s" % (get_platform(), sys.version[0:3])
if build_scripts is None:
self.build_scripts = os.path.join(self.build_base,
'scripts' + plat_specifier)
def finalize_options(self):
build.finalize_options(self)
if self.build_html is None:
self.build_html = os.path.join(self.build_base, 'html')
if self.build_dest is None:
self.build_dest = os.path.join(self.build_base,
'PythonDocumentation')
def finalize_options(self):
_build.finalize_options(self)
if not self.rpm_version:
self.rpm_version = self.get_git_describe()
if not self.gtk_version:
self.gtk_version = self.get_gtk_version()
def finalize_options(self):
build.finalize_options(self)
if self.build_html is None:
self.build_html = os.path.join(self.build_base, 'html')
if self.build_dest is None:
self.build_dest = os.path.join(self.build_base,
'PythonDocumentation')
def finalize_options(self):
build_scripts = self.build_scripts
old_build.finalize_options(self)
plat_specifier = ".{}-{}.{}".format(get_platform(), *sys.version_info[:2])
if build_scripts is None:
self.build_scripts = os.path.join(self.build_base,
'scripts' + plat_specifier)
def finalize_options(self):
build_scripts = self.build_scripts
old_build.finalize_options(self)
plat_specifier = ".%s-%s" % (get_platform(), sys.version[0:3])
if build_scripts is None:
self.build_scripts = os.path.join(self.build_base,
'scripts' + plat_specifier)
def finalize_options(self):
# This ffi is pygit2.ffi due to the path trick used in the beginning
# of the file
from ffi import ffi
self.distribution.ext_modules.append(ffi.verifier.get_extension())
build.finalize_options(self)
def finalize_options(self):
build.finalize_options(self)
if not self.prefix:
install = self.distribution.get_command_obj('install', False)
if install:
self.prefix = install.prefix
else:
self.prefix = sys.prefix
def finalize_options(self):
_build.finalize_options(self)
# Distutils doesn't appear to like when you have --dry-run after the build
# build command so fail out if this is the case.
if self.dry_run != self.distribution.dry_run:
raise DistutilsOptionError("The --dry-run flag must be specified " \
"before the 'build' command")
def finalize_options (self):
_build.finalize_options(self)
# Distutils doesn't appear to like when you have --dry-run after the build
# build command so fail out if this is the case.
if self.dry_run != self.distribution.dry_run:
raise DistutilsOptionError("The --dry-run flag must be specified " \
"before the 'build' command")
def finalize_options(self):
build.finalize_options(self)
self.tempdir = pjoin(self.build_temp, 'scratch')
self.has_run = False
self.config = discover_settings(self.build_base)
if self.zmq is not None:
merge(self.config, config_from_prefix(self.zmq))
self.init_settings_from_config()
def finalize_options(self):
build.finalize_options(self)
if self.enable_man_pages is None:
path = os.path.dirname(os.path.abspath(__file__))
self.enable_man_pages = not os.path.exists(os.path.join(path, 'man'))
if self.enable_html_docs is None:
self.enable_html_docs = False
def finalize_options(self):
build.finalize_options(self)
if self.enable_magic and not self.static:
raise distutils.errors.DistutilsOptionError(
'--enable-magic must be used with --static')
if self.enable_cuckoo and not self.static:
raise distutils.errors.DistutilsOptionError(
'--enable-cuckoo must be used with --static')
def finalize_options(self):
build.finalize_options(self)
if self.enable_magic and self.dynamic_linking:
raise distutils.errors.DistutilsOptionError(
'--enable-magic can''t be used with --dynamic-linking')
if self.enable_cuckoo and self.dynamic_linking:
raise distutils.errors.DistutilsOptionError(
'--enable-cuckoo can''t be used with --dynamic-linking')
def finalize_options(self):
_build.finalize_options(self)
self.set_undefined_options('config',
('petsc_dir', 'petsc_dir'),
('petsc_arch', 'petsc_arch'))
self.petsc_dir = config.get_petsc_dir(self.petsc_dir)
self.petsc_arch = config.get_petsc_arch(self.petsc_dir,
self.petsc_arch)
def finalize_options(self):
from cffi.verifier import Verifier
import _libpassacre
verifier = Verifier(
_libpassacre.ffi, _libpassacre.preamble, modulename='_libpassacre_c',
include_dirs=[libpassacre_build_dir],
extra_objects=[os.path.join(libpassacre_build_dir, 'libpassacre.a')])
self.distribution.ext_modules = [verifier.get_extension()]
_build.finalize_options(self)
def finalize_options(self):
_build.finalize_options(self)
for exe in executables:
print('checking for %r...' % exe)
fpath = which(exe)
if not fpath:
print('WARNING: Missing %r executable!' % exe)
else:
print(fpath)
def finalize_options(self):
build.finalize_options(self)
self.optimize_dimensions = (parse_ranges(self.optimize_dimensions)
if self.optimize_dimensions is not None
else DEFAULT_OPTIMIZED_DIMENSIONS)
self.cpp_opts = split_quoted(self.cpp_opts)
self.copy_mingw_deps = strtobool(self.copy_mingw_deps) if self.copy_mingw_deps is not None else True
def finalize_options(self):
build.finalize_options(self)
self.optimize_dimensions = (parse_ranges(self.optimize_dimensions)
if self.optimize_dimensions is not None
else DEFAULT_OPTIMIZED_DIMENSIONS)
self.cpp_opts = split_quoted(self.cpp_opts)
self.copy_mingw_deps = strtobool(self.copy_mingw_deps) if self.copy_mingw_deps is not None else True
def finalize_options(self):
_build.finalize_options(self)
for exe in executables:
print('checking for %r...' % exe)
fpath = which(exe)
if not fpath:
print('WARNING: Missing %r executable!' % exe)
else:
print(fpath)
def finalize_options(self):
build.finalize_options(self)
# self.set_undefined_options("build_ext", ("download_dir", "download_dir"))
if self.download_dir:
openfst_tar_gz = os.path.join(self.download_dir, self.openfst_basename)
assert os.path.isfile(openfst_tar_gz), (
"File %s does not exist" % openfst_tar_gz
)
else:
self.download_dir = self.build_temp
def finalize_options(self, *args, **kwargs):
build.finalize_options(self, *args, **kwargs)
if self.distribution.has_ext_modules():
## Grab the 'build_ext' command
beco = self.distribution.get_command_obj('build_ext')
## Grab the FFTW flags
if self.with_fftw is not None:
beco.with_fftw = self.with_fftw
def finalize_options(self):
global p4_api_dir, p4_ssl_dir
if self.apidir:
p4_api_dir = self.apidir
if self.ssl:
p4_ssl_dir = self.ssl
build_module.finalize_options(self)
def finalize_options(self):
if self.build_messages is None:
self.build_messages = os.path.join(self.build_base, 'po')
if self.msgfmt_exe is None:
self.announce('Searching msgfmt...')
self.msgfmt_exe = spawn.find_executable('msgfmt')
if self.msgfmt_exe is None:
raise SystemExit('Couldn\'t find "msgfmt".')
self.announce(' ...msgfmt found at %s' % self.msgfmt_exe)
build.finalize_options(self)
def finalize_options(self):
build.finalize_options(self)
if self.osddir is None:
self.osddir = '../build/lib'
setBuildFolder(self.osddir)
if self.cxxflags is None:
self.cxxflags = [(-Wall)]
setCompilerFlags(self.cxxflags)
if self.swigopts:
osd_shim.swig_opts += [self.swigopts]
def finalize_options(self):
orig_build.finalize_options(self)
# prepend our custom command
self.sub_commands = [('build_prepare', None)] + self.sub_commands
self.build_lib = self.build_platlib
if self.distribution.profile:
# so that profiling and non-profiling builds do not clash
self.build_lib += '-profile'
# Cython would otherwise think that .c files need not be regenerated:
self.build_temp += '-profile'
def finalize_options(self):
build.finalize_options(self)
if self.build_locales is None:
self.build_locales = os.path.join(self.build_base, 'locale')
if self.localedir is None:
self.localedir = '/usr/share/locale'
if self.disable_autoupdate is None:
self.disable_autoupdate = False
if self.disable_locales is None:
self.sub_commands.append(('build_locales', None))
def finalize_options(self):
build.finalize_options(self)
if self.enable_magic and self.dynamic_linking:
raise distutils.errors.DistutilsOptionError(
'--enable-magic can'
't be used with --dynamic-linking')
if self.enable_cuckoo and self.dynamic_linking:
raise distutils.errors.DistutilsOptionError(
'--enable-cuckoo can'
't be used with --dynamic-linking')
def finalize_options(self):
build.finalize_options(self)
if self.build_locales is None:
self.build_locales = os.path.join(self.build_base, 'locale')
if self.localedir is None:
self.localedir = '/usr/share/locale'
if self.disable_autoupdate is None:
self.disable_autoupdate = False
if self.disable_locales is None:
self.sub_commands.append(('build_locales', None))
def finalize_options(self):
orig_build.finalize_options(self)
# prepend our custom command
self.sub_commands = [('build_prepare', None)] + self.sub_commands
self.build_lib = self.build_platlib
if self.distribution.profile:
# so that profiling and non-profiling builds do not clash
self.build_lib += '-profile'
# Cython would otherwise think that .c files need not be regenerated:
self.build_temp += '-profile'
def finalize_options(self):
if not os.path.exists('./xcffib'):
print("It looks like you need to generate the binding.")
print("please run 'make xcffib' or 'make check'.")
sys.exit(1)
import xcffib
self.distribution.ext_modules = [xcffib.ffi.verifier.get_extension()]
build.finalize_options(self)
def finalize_options(self):
build.finalize_options(self)
if self.osddir is None:
self.osddir = '../build/lib'
setBuildFolder(self.osddir)
if self.cxxflags is None:
self.cxxflags = [(-Wall)]
setCompilerFlags(self.cxxflags)
if self.swigopts:
osd_shim.swig_opts+=[self.swigopts]
def finalize_options(self):
_build.finalize_options(self)
# The argument parsing will result in self.define being a string, but
# it has to be a list of 2-tuples.
# Multiple symbols can be separated with semi-colons.
if self.define:
defines = self.define.split(';')
self.define = [(s.strip(), None) if '=' not in s else
tuple(ss.strip() for ss in s.split('='))
for s in defines]
cmake_opts.extend(self.define)
def finalize_options(self):
_build.finalize_options(self)
# The argument parsing will result in self.define being a string, but
# it has to be a list of 2-tuples.
# Multiple symbols can be separated with semi-colons.
if self.define:
defines = self.define.split(';')
self.define = [(s.strip(), None) if '=' not in s else
tuple(ss.strip() for ss in s.split('='))
for s in defines]
cargo_opts.extend(self.define)
def finalize_options(self):
# TODO: review this for sanity ...
if self.only_sgio:
self.without_libiscsi = 1
self.only_libiscsi = 0
elif self.only_libiscsi:
self.without_sgio = 1
self.only_sgio = 0
else:
pass
_build.finalize_options(self)
def finalize_options(self):
if self.build_messages is None:
self.build_messages = os.path.join(self.build_base,
'po')
if self.msgfmt_exe is None:
self.announce('Searching msgfmt...')
self.msgfmt_exe = spawn.find_executable('msgfmt')
if self.msgfmt_exe is None:
raise SystemExit('Couldn\'t find "msgfmt".')
self.announce(' ...msgfmt found at %s' % self.msgfmt_exe)
build.finalize_options(self)
def finalize_options(self):
from cryptography.hazmat.bindings.openssl.binding import Binding
from cryptography.hazmat.primitives import constant_time, padding
self.distribution.ext_modules = [
Binding().ffi.verifier.get_extension(),
constant_time._ffi.verifier.get_extension(),
padding._ffi.verifier.get_extension()
]
build.finalize_options(self)
def finalize_options(self):
# TODO: review this for sanity ...
if self.only_sgio:
self.without_libiscsi = 1
self.only_libiscsi = 0
elif self.only_libiscsi:
self.without_sgio = 1
self.only_sgio = 0
else:
pass
_build.finalize_options(self)
def finalize_options(self):
if self.cross_compile and os.environ.has_key('PYTHONXCPREFIX'):
prefix = os.environ['PYTHONXCPREFIX']
sysconfig.get_python_lib = get_python_lib
sysconfig.PREFIX = prefix
sysconfig.EXEC_PREFIX = prefix
# reinitialize variables
sysconfig._config_vars = None
sysconfig.get_config_var("LDSHARED")
_build.finalize_options(self)
def finalize_options(self):
if self.cross_compile and os.environ.has_key('PYTHONXCPREFIX'):
prefix = os.environ['PYTHONXCPREFIX']
sysconfig.get_python_lib = get_python_lib
sysconfig.PREFIX = prefix
sysconfig.EXEC_PREFIX = prefix
# reinitialize variables
sysconfig._config_vars = None
sysconfig.get_config_var("LDSHARED")
_build.finalize_options(self)
def finalize_options(self):
# When --pkg-version was provided as command line
# option of install command, then get this value from global variables
if self.pkg_version is None and PKG_VERSION is not None:
self.pkg_version = PKG_VERSION
_build.finalize_options(self)
# When the pkg-version was not provided as command line options,
# then try to get such information from .git or rpm
if not self.pkg_version:
self.pkg_version = self.get_git_describe()
def finalize_options(self):
_build.finalize_options(self)
plat_specifier = ".%s-%s" % (self.plat_name, sys.version[:3])
if self.build_qlib is None:
self.build_qlib = os.path.join(self.build_base,
'qlib' + plat_specifier)
qarch = self.distribution.qarch
kxver = self.distribution.kxver
if self.build_qext is None:
self.build_qext = os.path.join(self.build_base,
'qext.%s-%s' % (qarch, kxver))
self.build_temp += '-kx_' + kxver
def finalize_options(self):
_build.finalize_options(self)
# The argument parsing will result in self.define being a string, but
# it has to be a list of 2-tuples. All the preprocessor symbols
# specified by the 'define' option without an '=' will be set to '1'.
# Multiple symbols can be separated with commas.
if self.define:
defines = self.define.split(',')
self.define = [(s.strip(), 1) if '=' not in s else
tuple(ss.strip() for ss in s.split('='))
for s in defines]
define_opts.extend(self.define)
def finalize_options(self):
if self.parallel:
try:
self.parallel = int(self.parallel)
except ValueError:
raise ValueError("--parallel/-j argument must be an integer")
build_scripts = self.build_scripts
old_build.finalize_options(self)
plat_specifier = ".%s-%s" % (get_platform(), sys.version[0:3])
if build_scripts is None:
self.build_scripts = os.path.join(self.build_base,
'scripts' + plat_specifier)
def finalize_options(self):
_build.finalize_options(self)
# The argument parsing will result in self.define being a string, but
# it has to be a list of 2-tuples. All the preprocessor symbols
# specified by the 'define' option without an '=' will be set to '1'.
# Multiple symbols can be separated with commas.
if self.define:
defines = self.define.split(',')
self.define = [(s.strip(), 1) if '=' not in s else
tuple(ss.strip() for ss in s.split('='))
for s in defines]
define_opts.extend(self.define)
def finalize_options(self):
_build.finalize_options(self)
plat_specifier = ".%s-%s" % (self.plat_name, sys.version[:3])
if self.build_qlib is None:
self.build_qlib = os.path.join(self.build_base,
'qlib' + plat_specifier)
qarch = self.distribution.qarch
kxver = self.distribution.kxver
if self.build_qext is None:
self.build_qext = os.path.join(self.build_base,
'qext.%s-%s' % (qarch, kxver))
self.build_temp += '-kx_' + kxver
def finalize_options(self):
if self.parallel:
try:
self.parallel = int(self.parallel)
except ValueError:
raise ValueError("--parallel/-j argument must be an integer")
build_scripts = self.build_scripts
old_build.finalize_options(self)
plat_specifier = ".%s-%s" % (get_platform(), sys.version[0:3])
if build_scripts is None:
self.build_scripts = os.path.join(self.build_base,
'scripts' + plat_specifier)
def finalize_options(self):
_build.finalize_options(self)
if self.asan:
# implies debug
self.debug = 1
asancflags = " -O0 -g -fsanitize=address"
cflags = os.environ.get('CFLAGS', '') + asancflags
os.environ['CFLAGS'] = cflags
asanldflags = " -fsanitize=address -shared-libasan"
ldflags = os.environ.get('LDFLAGS', '') + asanldflags
os.environ['LDFLAGS'] = ldflags
def finalize_options(self):
from cryptography.hazmat.bindings.commoncrypto.binding import Binding as CommonCryptoBinding
from cryptography.hazmat.bindings.openssl.binding import Binding as OpenSSLBinding
from cryptography.hazmat.primitives import constant_time, padding
self.distribution.ext_modules = [
OpenSSLBinding().ffi.verifier.get_extension(),
constant_time._ffi.verifier.get_extension(),
padding._ffi.verifier.get_extension(),
]
if CommonCryptoBinding.is_available():
self.distribution.ext_modules.append(CommonCryptoBinding().ffi.verifier.get_extension())
build.finalize_options(self)
def finalize_options(self):
_build.finalize_options(self)
# The argument parsing will result in self.define being a string, but
# it has to be a list of 2-tuples.
# Multiple symbols can be separated with semi-colons.
if self.define:
defines = self.define.split(';')
self.define = [(s.strip(), None) if '=' not in s else
tuple(ss.strip() for ss in s.split('='))
for s in defines]
cmake_opts.extend(self.define)
if self.symengine_dir:
cmake_opts.extend([('SymEngine_DIR', self.symengine_dir)])
if self.generator:
cmake_generator[0] = self.generator
cmake_build_type[0] = self.build_type
