def finalize_options(self):
self.set_undefined_options(
'install',
('extra_compile_args', 'extra_compile_args'),
('extra_link_args', 'extra_link_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")
self.with_mysqlxpb_cext = any((self.with_protobuf_include_dir,
self.with_protobuf_lib_dir,
self.with_protoc))
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)
if self.sndfile_libdir is not None :
self.library_dirs.append(self.sndfile_libdir)
self.rpath.append(self.sndfile_libdir)
if self.sndfile_incdir is not None :
self.include_dirs.append(self.sndfile_incdir)
def finalize_options (self):
build_ext.finalize_options (self)
#
# split libraries, since Python does not expand them by default
#
if self.libraries:
self.libraries = self.libraries[0].split (os.pathsep)
def finalize_options(self):
build_ext.finalize_options(self)
if self.sdl_location is None:
# The default SDL location. This is useful only if your
# SDL source is installed under a common root, with
# sdl_loc/include and sdl_loc/lib directories beneath that
# root. This is the standard way that SDL is distributed
# on Windows, but not on Unix. For a different
# configuration, just specify --include-dirs and
# --library-dirs separately.
if env == ENV_WINDOWS:
# For a default location on Windows, look around for SDL
# in the current directory.
sdl_dirs = glob.glob('SDL*')
# Sort them in order, so that the highest-numbered version
# will (probably) fall to the end.
sdl_dirs.sort()
for dir in sdl_dirs:
if os.path.isdir(os.path.join(dir, 'include')):
self.sdl_location = dir
if self.sdl_location is not None:
# Now append the system paths.
self.include_dirs.append(os.path.join(self.sdl_location, 'include'))
self.library_dirs.append(os.path.join(self.sdl_location, 'lib'))
# Also put the lib dir on the PATH, so py2exe can find SDL.dll.
if env == ENV_WINDOWS:
libdir = os.path.join(self.sdl_location, 'lib')
os.environ["PATH"] = '%s;%s' % (libdir, os.environ["PATH"])
def finalize_options(self):
if self.include_dirs is None:
self.include_dirs = include_dirs
# Needed on recent MacOSX
elif isinstance(self.include_dirs, str) and sys.platform == 'darwin':
self.include_dirs += ':' + ':'.join(include_dirs)
if self.library_dirs is None:
self.library_dirs = library_dirs
# Needed on recent MacOSX
elif isinstance(self.library_dirs, str) and sys.platform == 'darwin':
self.library_dirs += ':' + ':'.join(library_dirs)
if self.libraries is None:
if self.get_compiler() == 'msvc':
libraries.remove('gdal')
libraries.append('gdal_i')
self.libraries = libraries
build_ext.finalize_options(self)
self.include_dirs.append(self.numpy_include_dir)
if self.get_compiler() == 'msvc':
return True
self.gdaldir = self.get_gdal_config('prefix')
self.library_dirs.append(os.path.join(self.gdaldir,'lib'))
self.include_dirs.append(os.path.join(self.gdaldir,'include'))
def finalize_options(self):
# #[ make settings available
""" copy user defined options from the build to the
build_ext class instance """
# this copies the user_options from the build
# to the build_ext class, so I'll have to modify
# the build class as well to allow new options
self.set_undefined_options('build',
('preferred_fortran_compiler',
'preferred_fortran_compiler'),
('preferred_c_compiler',
'preferred_c_compiler'),
('fortran_compiler',
'fortran_compiler'),
('fortran_ld_library_path',
'fortran_ld_library_path'),
('fortran_flags',
'fortran_flags'),
('c_compiler',
'c_compiler'),
('c_ld_library_path',
'c_ld_library_path'),
('c_flags',
'c_flags'),
('download_library_sources',
'download_library_sources')
)
_build_ext.finalize_options(self)
def finalize_options(self):
_build_ext.finalize_options(self)
self.set_undefined_options('build',
('petsc_dir', 'petsc_dir'),
('petsc_arch', 'petsc_arch'))
import sys, os
from distutils import sysconfig
if ((sys.platform.startswith('linux') or
sys.platform.startswith('gnu') or
sys.platform.startswith('sunos')) and
sysconfig.get_config_var('Py_ENABLE_SHARED')):
py_version = sysconfig.get_python_version()
bad_pylib_dir = os.path.join(sys.prefix, "lib",
"python" + py_version,
"config")
try:
self.library_dirs.remove(bad_pylib_dir)
except ValueError:
pass
pylib_dir = sysconfig.get_config_var("LIBDIR")
if pylib_dir not in self.library_dirs:
self.library_dirs.append(pylib_dir)
if pylib_dir not in self.rpath:
self.rpath.append(pylib_dir)
if sys.exec_prefix == '/usr':
self.library_dirs.remove(pylib_dir)
self.rpath.remove(pylib_dir)
def finalize_options(self):
self.pyev_options = {}
build_ext.finalize_options(self)
if "sdist" not in sys.argv:
plat_name = os.name
if plat_name not in pyev_platforms:
raise SystemExit("Aborted: platform '{0}' "
"not supported".format(plat_name))
self.pyev_options.update(pyev_platforms[plat_name])
# libraries
libraries = self.pyev_options["libraries"]
if hasattr(libraries, "__call__"):
libraries = libraries()
if libraries:
if self.libraries:
self.libraries.extend(libraries)
else:
self.libraries = libraries
# define
define_fmt = self.pyev_options["define_fmt"]
define = [
("PYEV_VERSION", define_fmt.format(pyev_version)),
("LIBEV_VERSION", define_fmt.format(libev_version)),
]
if self.define:
self.define.extend(define)
else:
self.define = 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")
# Ensure that self.include_dirs and self.distribution.include_dirs
# refer to the same list object. finalize_options will modify
# self.include_dirs, but self.distribution.include_dirs is used
# during the actual build.
# self.include_dirs is None unless paths are specified with
# --include-dirs.
# The include paths will be passed to the compiler in the order:
# numpy paths, --include-dirs paths, Python include path.
if isinstance(self.include_dirs, str):
self.include_dirs = self.include_dirs.split(os.pathsep)
incl_dirs = self.include_dirs or []
if self.distribution.include_dirs is None:
self.distribution.include_dirs = []
self.include_dirs = self.distribution.include_dirs
self.include_dirs.extend(incl_dirs)
old_build_ext.finalize_options(self)
self.set_undefined_options('build', ('parallel', 'parallel'))
def finalize_options(self):
_build_ext.finalize_options(self)
if self.inplace:
for x in self.distribution.packages:
self.library_dirs.append(x)
else:
self.library_dirs.append(self.build_lib)
for x in self.distribution.packages:
self.library_dirs.append(join(self.build_lib,x))
if sys.platform.lower().startswith("linux"):
# allow shared library to be found in same folder as
# dependent module
for x in self.extensions:
if len(x.libraries): x.runtime_library_dirs=["$ORIGIN"]
# find out the name of built libraries so that
# dependent modules know what name to use
# since debug versions and python3 output names are modified
# depending on the python version, architecture etc...
lib_fix = []
for x in self.extensions:
w = x.name.split('.')[-1]
if w.startswith('lib'):
n = w[3:]
z = self.get_ext_filename(x.name)
z = (splitext(split(z)[-1])[0])[3:]
if z != n: lib_fix.append((x,n,z))
if lib_fix:
for l in lib_fix:
for x in self.extensions:
if l[0] != x and x.libraries:
x.libraries[:] = [v if v!=l[1] else l[2]
for v in x.libraries]
def finalize_options(self):
if self.include_dirs is None:
self.include_dirs = include_dirs
if self.library_dirs is None:
self.library_dirs = library_dirs
if self.libraries is None:
if self.get_compiler() == "msvc":
libraries.remove("gdal")
libraries.append("gdal_i")
self.libraries = libraries
build_ext.finalize_options(self)
self.include_dirs.append(self.numpy_include_dir)
if self.get_compiler() == "msvc":
return True
try:
self.gdaldir = self.get_gdal_config("prefix")
except:
print ("Could not run gdal-config!!!! 1")
try:
self.library_dirs.append(os.path.join(self.gdaldir, "lib"))
print self.library_dirs
except:
print ("Could not run gdal-config!!!! 2")
try:
self.include_dirs.append(os.path.join(self.gdaldir, "include"))
print self.include_dirs
except:
print ("Could not run gdal-config!!!! 3")
def finalize_options(self):
"""Complete the build system configuation."""
build_ext.finalize_options(self)
self.include_dirs.append(".")
self.libraries.append("pq")
self.libraries.append("ucoev")
try:
self.library_dirs.append(self.get_pg_config("libdir"))
self.include_dirs.append(self.get_pg_config("includedir"))
self.include_dirs.append(self.get_pg_config("includedir-server"))
try:
# Here we take a conservative approach: we suppose that
# *at least* PostgreSQL 7.4 is available (this is the only
# 7.x series supported by psycopg 2)
pgversion = self.get_pg_config("version").split()[1]
except:
pgversion = "7.4.0"
pgmajor, pgminor, pgpatch = pgversion.split('.')
define_macros.append(("PG_VERSION_HEX", "0x%02X%02X%02X" %
(int(pgmajor), int(pgminor), int(pgpatch))))
except Warning, w:
if self.pg_config == self.DEFAULT_PG_CONFIG:
sys.stderr.write("Warning: %s" % str(w))
else:
sys.stderr.write("Error: %s" % str(w))
sys.exit(1)
def finalize_options(self):
"""Complete the build system configuation."""
build_ext.finalize_options(self)
if self.pg_config is None:
self.pg_config = self.autodetect_pg_config_path()
if self.pg_config is None:
sys.stderr.write("""\
Error: pg_config executable not found.
Please add the directory containing pg_config to the PATH
or specify the full executable path with the option:
python setup.py build_ext --pg-config /path/to/pg_config build ...
or with the pg_config option in 'setup.cfg'.
""")
sys.exit(1)
self.include_dirs.append(".")
if self.static_libpq:
if not self.link_objects: self.link_objects = []
self.link_objects.append(
os.path.join(self.get_pg_config("libdir"), "libpq.a"))
else:
self.libraries.append("pq")
try:
self.library_dirs.append(self.get_pg_config("libdir"))
self.include_dirs.append(self.get_pg_config("includedir"))
self.include_dirs.append(self.get_pg_config("includedir-server"))
try:
# Here we take a conservative approach: we suppose that
# *at least* PostgreSQL 7.4 is available (this is the only
# 7.x series supported by psycopg 2)
pgversion = self.get_pg_config("version").split()[1]
except:
pgversion = "7.4.0"
verre = re.compile(r"(\d+)\.(\d+)(?:(?:\.(\d+))|(devel|(alpha|beta|rc)\d+))")
m = verre.match(pgversion)
if m:
pgmajor, pgminor, pgpatch = m.group(1, 2, 3)
if pgpatch is None or not pgpatch.isdigit():
pgpatch = 0
else:
sys.stderr.write(
"Error: could not determine PostgreSQL version from '%s'"
% pgversion)
sys.exit(1)
define_macros.append(("PG_VERSION_HEX", "0x%02X%02X%02X" %
(int(pgmajor), int(pgminor), int(pgpatch))))
except Warning:
w = sys.exc_info()[1] # work around py 2/3 different syntax
sys.stderr.write("Error: %s\n" % w)
sys.exit(1)
if hasattr(self, "finalize_" + sys.platform):
getattr(self, "finalize_" + sys.platform)()
def finalize_options(self):
if self.include_dirs is None:
self.include_dirs = include_dirs
includes = self.get_mapserver_config('includes')
includes = includes.split()
for item in includes:
if item[:2] == '-I' or item[:2] == '/I':
if item[2:] not in include_dirs:
self.include_dirs.append( item[2:] )
if self.library_dirs is None:
self.library_dirs = library_dirs
libs = self.get_mapserver_config('libs')
self.library_dirs = self.library_dirs + [x[2:] for x in libs.split() if x[:2] == "-L"]
# silly stuff to deal with setuptools doing things
# like -D-DMYDEFINE
defs = self.get_mapserver_config('defines')
self.define = [x[2:] for x in defs.split() if x[:2] == "-D"]
self.define = ','.join(self.define)
ex_next = False
libs = libs.split()
for x in libs:
if ex_next:
extra_link_args.append(x)
ex_next = False
elif x[:2] == '-l':
libraries.append( x[2:] )
elif x[-4:] == '.lib' or x[-4:] == '.LIB':
dir, lib = os.path.split(x)
libraries.append( lib[:-4] )
if len(dir) > 0:
self.library_dirs.append( dir )
elif x[-2:] == '.a':
extra_link_args.append(x)
elif x[:10] == '-framework':
extra_link_args.append(x)
ex_next = True
elif x[:2] == '-F':
extra_link_args.append(x)
# don't forget to add mapserver lib
self.libraries = unique(libraries) + ['mapserver',]
if self.get_compiler() == 'msvc':
for lib in self.libraries:
if lib == 'mapserver':
self.libraries.remove(lib)
self.libraries.append('mapserver_i')
self.libraries.append('gd')
self.libraries = unique(self.libraries)
build_ext.finalize_options(self)
self.dir = os.path.abspath('../..')
self.library_dirs.append(self.dir)
self.include_dirs.append(self.dir)
def finalize_options(self):
if self.include_dirs is None:
self.include_dirs = include_dirs
includes = self.get_mapserver_config("includes")
includes = includes.split()
for item in includes:
if item[:2] == "-I" or item[:2] == "/I":
if item[2:] not in include_dirs:
self.include_dirs.append(item[2:])
if self.library_dirs is None:
self.library_dirs = library_dirs
libs = self.get_mapserver_config("libs")
self.library_dirs = self.library_dirs + [x[2:] for x in libs.split() if x[:2] == "-L"]
# silly stuff to deal with setuptools doing things
# like -D-DMYDEFINE
defs = self.get_mapserver_config("defines")
self.define = [x[2:] for x in defs.split() if x[:2] == "-D"]
self.define = ",".join(self.define)
ex_next = False
libs = libs.split()
for x in libs:
if ex_next:
extra_link_args.append(x)
ex_next = False
elif x[:2] == "-l":
libraries.append(x[2:])
elif x[-4:] == ".lib" or x[-4:] == ".LIB":
dir, lib = os.path.split(x)
libraries.append(lib[:-4])
if len(dir) > 0:
self.library_dirs.append(dir)
elif x[-2:] == ".a":
extra_link_args.append(x)
elif x[:10] == "-framework":
extra_link_args.append(x)
ex_next = True
elif x[:2] == "-F":
extra_link_args.append(x)
# don't forget to add mapserver lib
self.libraries = unique(libraries) + ["mapserver"]
if self.get_compiler() == "msvc":
for lib in self.libraries:
if lib == "mapserver":
self.libraries.remove(lib)
self.libraries.append("mapserver_i")
self.libraries.append("gd")
self.libraries = unique(self.libraries)
build_ext.finalize_options(self)
self.dir = os.path.abspath("../..")
self.library_dirs.append(self.dir)
self.include_dirs.append(self.dir)
def finalize_options(self):
build_ext.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):
"""Complete the build system configuration."""
build_ext.finalize_options(self)
sip_config = SipConfig(self)
if hasattr(self, "finalize_" + sys.platform):
getattr(self, "finalize_" + sys.platform)()
def finalize_options (self):
if self.library_dirs is None:
self.library_dirs = []
elif isinstance(self.library_dirs, basestring):
self.library_dirs = self.library_dirs.split(os.pathsep)
self.library_dirs.insert(0, os.path.join(sys.real_prefix, "Libs"))
old_build_ext.finalize_options(self)
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)
self.ensure_file_exists("boost_include_dir", "boost/python.hpp")
self.ensure_dirname("boost_library_dir")
self.ensure_file_exists("timbl_include_dir", "timbl/TimblAPI.h")
self.ensure_dirname("timbl_library_dir")
self.ensure_file_exists("libxml2_include_dir", "libxml/tree.h")
self.ensure_dirname("libxml2_library_dir")
def finalize_options(self):
build_ext.finalize_options(self)
if self.devel:
for ext in self.extensions:
if hasattr(ext, "extra_compile_args"):
ext.extra_compile_args.extend(self.extra_cflags)
else:
ext.extra_compile_args = self.extra_cflags
def finalize_options(self):
build_ext.finalize_options(self)
if self.cuda_root is None:
self.cuda_root = os.getenv('CUDA_ROOT', None)
if self.cuda_root is not None:
self._nvcc_bin = os.path.join(self.cuda_root, 'bin', 'nvcc')
else:
self._nvcc_bin = 'nvcc'
def finalize_options(self):
self.set_undefined_options(
'build',
('with_static_binutils','with_static_binutils'))
self.set_undefined_options(
'install',
('with_static_binutils','with_static_binutils'))
build_ext.finalize_options(self)
def finalize_options(self):
build_ext.finalize_options(self)
for x in self.feature:
if getattr(self, "disable_%s" % x):
setattr(self.feature, x, False)
if getattr(self, "enable_%s" % x):
raise ValueError("Conflicting options: --enable-%s and --disable-%s" % (x, x))
if getattr(self, "enable_%s" % x):
self.feature.required.append(x)
def finalize_options(self):
if isinstance(self.include_dirs, str):
self.include_dirs = self.include_dirs.split(os.pathsep)
incl_dirs = self.include_dirs or []
if self.distribution.include_dirs is None:
self.distribution.include_dirs = []
self.include_dirs = self.distribution.include_dirs
self.include_dirs.extend(incl_dirs)
old_build_ext.finalize_options(self)
def finalize_options(self):
"""
Update build options with details about OpenSSL.
"""
build_ext.finalize_options(self)
if self.with_openssl is None:
self.find_openssl()
self.find_openssl_dlls()
self.add_openssl_compile_info()
def finalize_options(self):
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):
self.set_undefined_options('build',
#('r_autoconfig', 'r_autoconfig'),
('r_home', 'r_home'))
_build_ext.finalize_options(self)
if self.r_home is None:
tmp = os.popen("R RHOME")
self.r_home = tmp.readlines()
tmp.close()
self.r_home = ['/app/vendor/R/lib64/R\n']
if len(self.r_home) == 0:
raise SystemExit("Error: Tried to guess R's HOME but no R command in the PATH.")
#Twist if 'R RHOME' spits out a warning
if self.r_home[0].startswith("WARNING"):
self.r_home = self.r_home[1]
else:
self.r_home = self.r_home[0]
#self.r_home = [self.r_home, ]
if self.r_home is None:
raise SystemExit("Error: --r-home not specified.")
else:
self.r_home = self.r_home.split(os.pathsep)
rversions = []
for r_home in self.r_home:
r_home = r_home.strip()
rversion = get_rversion(r_home)
if rversion[0] == 'development' or \
cmp_version(rversion[: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(rversion))
rversions.append(rversion)
config = RConfig()
for about in ('--ldflags', '--cppflags'):
config += get_rconfig(r_home, about)
for about in ('LAPACK_LIBS', 'BLAS_LIBS'):
config += get_rconfig(r_home, about, True)
print(config.__repr__())
self.include_dirs.extend(config._include_dirs)
self.libraries.extend(config._libraries)
self.library_dirs.extend(config._library_dirs)
if self.r_home_modules is None:
self.library_dirs.extend([os.path.join(r_home, 'modules'), ])
else:
self.library_dirs.extend([self.r_home_modules, ])
def finalize_options(self):
if self.jobs:
try:
self.jobs = int(self.jobs)
except ValueError:
raise ValueError("--jobs/-j argument must be an integer")
incl_dirs = self.include_dirs
old_build_ext.finalize_options(self)
if incl_dirs is not None:
self.include_dirs.extend(self.distribution.include_dirs or [])
self.set_undefined_options('build', ('jobs', 'jobs'))
def finalize_options(self):
_build_ext.finalize_options(self)
self.build_lib = build_lib
self.build_temp = build_tmp
def finalize_options(self):
"""Complete the build system configuration."""
# An empty option in the setup.cfg causes self.libraries to include
# an empty string in the list of libraries
if self.libraries is not None and not self.libraries.strip():
self.libraries = None
build_ext.finalize_options(self)
pg_config_helper = PostgresConfig(self)
self.include_dirs.append(".")
if self.static_libpq:
if not getattr(self, 'link_objects', None):
self.link_objects = []
self.link_objects.append(
os.path.join(pg_config_helper.query("libdir"), "libpq.a"))
else:
self.libraries.append("pq")
try:
self.library_dirs.append(pg_config_helper.query("libdir"))
self.include_dirs.append(pg_config_helper.query("includedir"))
self.include_dirs.append(
pg_config_helper.query("includedir-server"))
try:
# Here we take a conservative approach: we suppose that
# *at least* PostgreSQL 7.4 is available (this is the only
# 7.x series supported by psycopg 2)
pgversion = pg_config_helper.query("version").split()[1]
except Exception:
pgversion = "7.4.0"
verre = re.compile(
r"(\d+)(?:\.(\d+))?(?:(?:\.(\d+))|(devel|(?:alpha|beta|rc)\d+))?"
)
m = verre.match(pgversion)
if m:
pgmajor, pgminor, pgpatch = m.group(1, 2, 3)
# Postgres >= 10 doesn't have pgminor anymore.
pgmajor = int(pgmajor)
if pgmajor >= 10:
pgminor, pgpatch = None, pgminor
if pgminor is None or not pgminor.isdigit():
pgminor = 0
if pgpatch is None or not pgpatch.isdigit():
pgpatch = 0
pgminor = int(pgminor)
pgpatch = int(pgpatch)
else:
sys.stderr.write(
"Error: could not determine PostgreSQL version from '%s'" %
pgversion)
sys.exit(1)
define_macros.append(
("PG_VERSION_NUM", "%d%02d%02d" % (pgmajor, pgminor, pgpatch)))
# enable lo64 if libpq >= 9.3 and Python 64 bits
if (pgmajor, pgminor) >= (9, 3) and is_py_64():
define_macros.append(("HAVE_LO64", "1"))
# Inject the flag in the version string already packed up
# because we didn't know the version before.
# With distutils everything is complicated.
for i, t in enumerate(define_macros):
if t[0] == 'PSYCOPG_VERSION':
n = t[1].find(')')
if n > 0:
define_macros[i] = (t[0],
t[1][:n] + ' lo64' + t[1][n:])
except Warning:
w = sys.exc_info()[1] # work around py 2/3 different syntax
sys.stderr.write("Error: %s\n" % w)
sys.exit(1)
if hasattr(self, "finalize_" + sys.platform):
getattr(self, "finalize_" + sys.platform)()
def finalize_options(self):
_build_ext.finalize_options(self)
if not self.esql_informixdir:
self.esql_informixdir = os.getenv("INFORMIXDIR")
if not self.esql_informixdir:
if get_platform() == "win32":
self.esql_informixdir = "C:\\Program Files\\Informix\\Client-SDK"
else:
self.esql_informixdir = "/usr/informix"
os.environ['INFORMIXDIR'] = self.esql_informixdir
self.esql_parts.append(
os.path.join(self.esql_informixdir, 'bin', 'esql'))
if get_platform() == "win32":
if self.esql_parts[0].find(' ') != -1:
self.esql_parts[0] = '"' + self.esql_parts[0] + '"'
if self.esql_threadlib:
os.environ['THREADLIB'] = self.esql_threadlib
self.esql_parts.append('-thread')
if self.define is None:
self.define = []
self.define += [('IFX_THREAD', None), ('_REENTRANT', None)]
if self.esql_static:
self.esql_parts.append('-static')
if self.testing:
self.undef_macros.append('NDEBUG')
# determine esql version
driver_name = "INFORMIX-ESQL"
driver_version = "Unknown"
esqlver = re.compile(r"(IBM)?.*ESQL Version ((\d+)\.(\d+)[^ ]*)")
cout = os.popen(' '.join(self.esql_parts[0:1] + ['-V']), 'r')
esqlversion = None
for line in cout:
matchobj = esqlver.match(line)
if matchobj:
matchgroups = matchobj.groups()
driver_version = matchgroups[1].strip()
esqlversion = int(matchgroups[2] + matchgroups[3])
if matchgroups[0] == "IBM":
# Assume ESQL 9.xx for any IBM branded CSDK.
driver_name = "IBM Informix-ESQL"
esqlversion = 960
if esqlversion == None:
esqlversion = 850
f = open(os.path.join("ext", "esqlver.h"), "w")
f.write("""\
#define DRIVER_NAME "%(driver_name)s"
#define DRIVER_VERSION "%(driver_version)s"
""" % locals())
f.close()
# find esql libs/objects
cout = os.popen(' '.join(self.esql_parts + ['-libs']), 'r')
esql_config = []
lexer = shlex.shlex(cout)
lexer.wordchars += '-.\\/'
while True:
token = lexer.get_token()
if token == '' or token == None: break
if token.startswith('"') and token.endswith('"'):
token = token[1:-1]
esql_config.append(token)
ret = cout.close()
if ret != None:
raise DistutilsSetupError, """\
Can't run esql. Please make sure that:
* You have the Informix CSDK installed,
* INFORMIXDIR is set to where Informix CSDK is installed, and
* esql is in your PATH.
See the README for build requirements.
"""
if get_platform() == "win32":
for arg in esql_config:
if arg.endswith('.lib'):
if self.libraries is None:
self.libraries = []
self.libraries.append(arg[:-4])
else:
for arg in esql_config:
if arg.startswith('-l'):
if self.libraries is None:
self.libraries = []
self.libraries.append(arg[2:])
else:
if self.link_objects is None:
self.link_objects = []
self.link_objects.append(arg)
if self.include_dirs is None:
self.include_dirs = []
self.include_dirs = [os.path.join(self.esql_informixdir,'incl','esql')]\
+ self.include_dirs
if self.library_dirs is None:
self.library_dirs = []
self.library_dirs += [
os.path.join(self.esql_informixdir, 'lib', 'esql'),
os.path.join(self.esql_informixdir, 'lib')
]
def finalize_options(self):
build_ext.finalize_options(self)
gmpy_build_ext.doit(self)
def finalize_options(self):
if self.my_inplace is None:
self.my_inplace = self.inplace
self.inplace = 0
_build_ext.finalize_options(self)
def finalize_options(self):
_build_ext.finalize_options(self)
def finalize_options(self):
build_ext.finalize_options(self)
self.check_flags()
def finalize_options(self):
incl_dirs = self.include_dirs
old_build_ext.finalize_options(self)
if incl_dirs is not None:
self.include_dirs.extend(self.distribution.include_dirs or [])
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.finalize_options(self)
self.set_undefined_options('build', ('build_scripts', 'build_scripts'))
self.extensions = self.distribution.exe_modules
def finalize_options(self):
build_ext.finalize_options(self)
self.pfft_build_dir = os.path.join(self.build_temp, 'depends')
self.include_dirs.insert(0, os.path.join(
self.pfft_build_dir, 'include'))
def finalize_options (self):
if self.library_dirs is None:
self.library_dirs = []
self.library_dirs.insert(0, os.path.join(sys.real_prefix, "Libs"))
old_build_ext.finalize_options(self)
def finalize_options(self):
_build_ext.finalize_options(self)
if self.enable_double:
self.announce(
'will generate code for aubio compiled with HAVE_AUBIO_DOUBLE=1',
level=distutils.log.INFO)
def finalize_options(self):
build_ext.finalize_options(self)
self.EXT_MANAGER.patch_src()
self.extensions = self.EXT_MANAGER.create_extensions()
self.java_libs = self.EXT_MANAGER.create_java_libs()
def finalize_options(self):
build_ext.finalize_options(self)
self.set_undefined_options('build', ('static', 'static'))
self.include_dirs = self.include_dirs or []
self.library_dirs = self.library_dirs or []
self.define = self.define or []
self.libraries = self.libraries or []
extra_compile_args = []
extra_link_args = []
compiler = self.compiler or get_default_compiler()
if compiler == 'msvc':
try:
QL_INSTALL_DIR = os.environ['QL_DIR']
self.include_dirs += [QL_INSTALL_DIR]
self.library_dirs += [os.path.join(QL_INSTALL_DIR, 'lib')]
except KeyError:
print('warning: unable to detect QuantLib installation')
if 'INCLUDE' in os.environ:
dirs = [dir for dir in os.environ['INCLUDE'].split(';')]
self.include_dirs += [d for d in dirs if d.strip()]
if 'LIB' in os.environ:
dirs = [dir for dir in os.environ['LIB'].split(';')]
self.library_dirs += [d for d in dirs if d.strip()]
dbit = round(math.log(sys.maxsize, 2) + 1)
if dbit == 64:
machinetype = '/machine:x64'
else:
machinetype = '/machine:x86'
self.define += [('__WIN32__', None), ('WIN32', None),
('NDEBUG', None), ('_WINDOWS', None),
('NOMINMAX', None)]
extra_compile_args = ['/GR', '/FD', '/Zm250', '/EHsc', '/bigobj']
extra_link_args = ['/subsystem:windows', machinetype]
if self.debug:
if self.static:
extra_compile_args.append('/MTd')
else:
extra_compile_args.append('/MDd')
else:
if self.static:
extra_compile_args.append('/MT')
else:
extra_compile_args.append('/MD')
elif compiler == 'unix':
ql_compile_args = \
os.popen('quantlib-config --cflags').read()[:-1].split()
ql_link_args = \
os.popen('quantlib-config --libs').read()[:-1].split()
self.define += [(arg[2:], None) for arg in ql_compile_args
if arg.startswith('-D')]
self.define += [('NDEBUG', None)]
self.include_dirs += [
arg[2:] for arg in ql_compile_args if arg.startswith('-I')
]
self.library_dirs += [
arg[2:] for arg in ql_link_args if arg.startswith('-L')
]
self.libraries += [
arg[2:] for arg in ql_link_args if arg.startswith('-l')
]
extra_compile_args = [ arg for arg in ql_compile_args
if not arg.startswith('-D')
if not arg.startswith('-I') ] \
+ [ '-Wno-unused' ]
if 'CXXFLAGS' in os.environ:
extra_compile_args += os.environ['CXXFLAGS'].split()
extra_link_args = [
arg for arg in ql_link_args if not arg.startswith('-L')
if not arg.startswith('-l')
]
if 'LDFLAGS' in os.environ:
extra_link_args += os.environ['LDFLAGS'].split()
else:
pass
for ext in self.extensions:
ext.extra_compile_args = ext.extra_compile_args or []
ext.extra_compile_args += extra_compile_args
ext.extra_link_args = ext.extra_link_args or []
ext.extra_link_args += extra_link_args
