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_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.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): 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.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): 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): 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): 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) 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