def finalize_options(self):
if self.bdist_dir is None:
bdist_base = self.get_finalized_command('bdist').bdist_base
self.bdist_dir = os.path.join(bdist_base, 'inno')
self.set_undefined_options('bdist',
('keep_temp', 'keep_temp'),
('dist_dir', 'dist_dir'),
('skip_build', 'skip_build'))
if not self.target_version:
self.target_version = get_python_version()
if not self.skip_build and (self.distribution.has_ext_modules() or
self.distribution.has_scripts()):
short_version = get_python_version()
if self.target_version != short_version:
raise DistutilsOptionError(
"target version can only be %s, or the '--skip_build'"
" option must be specified" % short_version)
self.target_version = short_version
self.license_file = self.distribution.license_file
if self.license_file:
self.license_file = util.convert_path(self.license_file)
self.output_basename = '%s.win32'
return
def configure_pyexe(exe, config_cmd):
from distutils import sysconfig
if sys.platform.startswith('win'):
return
if (sys.platform == 'darwin' and
('Anaconda' in sys.version or
'Continuum Analytics' in sys.version)):
py_version = sysconfig.get_python_version()
py_abiflags = getattr(sys, 'abiflags', '')
exe.libraries += ['python' + py_version + py_abiflags]
return
#
from distutils.util import split_quoted
cfg_vars = sysconfig.get_config_vars()
libraries = []
library_dirs = []
link_args = []
if not sysconfig.get_config_var('Py_ENABLE_SHARED'):
py_version = sysconfig.get_python_version()
py_abiflags = getattr(sys, 'abiflags', '')
libraries = ['python' + py_version + py_abiflags]
if sys.platform == 'darwin':
fwkdir = cfg_vars.get('PYTHONFRAMEWORKDIR')
if (fwkdir and fwkdir != 'no-framework' and
fwkdir in cfg_vars.get('LINKFORSHARED', '')):
del libraries[:]
for var in ('LIBDIR', 'LIBPL'):
library_dirs += split_quoted(cfg_vars.get(var, ''))
for var in ('LDFLAGS',
'LIBS', 'MODLIBS', 'SYSLIBS',
'LDLAST'):
link_args += split_quoted(cfg_vars.get(var, ''))
exe.libraries += libraries
exe.library_dirs += library_dirs
exe.extra_link_args += link_args
def init_env():
from setup.build_environment import msvc, is64bit, win_inc, win_lib, NMAKE
from distutils import sysconfig
linker = None
if isunix:
cc = os.environ.get('CC', 'gcc')
cxx = os.environ.get('CXX', 'g++')
debug = ''
# debug = '-ggdb'
cflags = os.environ.get('OVERRIDE_CFLAGS',
'-Wall -DNDEBUG %s -fno-strict-aliasing -pipe' % debug)
cflags = shlex.split(cflags) + ['-fPIC']
ldflags = os.environ.get('OVERRIDE_LDFLAGS', '-Wall')
ldflags = shlex.split(ldflags)
cflags += shlex.split(os.environ.get('CFLAGS', ''))
ldflags += shlex.split(os.environ.get('LDFLAGS', ''))
cflags += ['-fvisibility=hidden']
if islinux:
cflags.append('-pthread')
ldflags.append('-shared')
cflags.append('-I'+sysconfig.get_python_inc())
ldflags.append('-lpython'+sysconfig.get_python_version())
if isbsd:
cflags.append('-pthread')
ldflags.append('-shared')
cflags.append('-I'+sysconfig.get_python_inc())
ldflags.append('-lpython'+sysconfig.get_python_version())
if ishaiku:
cflags.append('-lpthread')
ldflags.append('-shared')
cflags.append('-I'+sysconfig.get_python_inc())
ldflags.append('-lpython'+sysconfig.get_python_version())
if isosx:
cflags.append('-D_OSX')
ldflags.extend('-bundle -undefined dynamic_lookup'.split())
cflags.extend(['-fno-common', '-dynamic'])
cflags.append('-I'+sysconfig.get_python_inc())
if iswindows:
cc = cxx = msvc.cc
cflags = '/c /nologo /MD /W3 /EHsc /DNDEBUG'.split()
ldflags = '/DLL /nologo /INCREMENTAL:NO /NODEFAULTLIB:libcmt.lib'.split()
# cflags = '/c /nologo /Ox /MD /W3 /EHsc /Zi'.split()
# ldflags = '/DLL /nologo /INCREMENTAL:NO /DEBUG'.split()
if is64bit:
cflags.append('/GS-')
for p in win_inc:
cflags.append('-I'+p)
for p in win_lib:
ldflags.append('/LIBPATH:'+p)
cflags.append('-I%s'%sysconfig.get_python_inc())
ldflags.append('/LIBPATH:'+os.path.join(sysconfig.PREFIX, 'libs'))
linker = msvc.linker
return namedtuple('Environment', 'cc cxx cflags ldflags linker make')(
cc=cc, cxx=cxx, cflags=cflags, ldflags=ldflags, linker=linker, make=NMAKE if iswindows else 'make')
def run(self):
"""Run the distutils command"""
log.info("installing library code to %s" % self.bdist_dir)
self.dist_name = get_dist_name(self.distribution,
source_only_dist=True,
python_version=get_python_version()[0])
self.dist_target = os.path.join(self.dist_dir, self.dist_name)
log.info("distribution will be available as '%s'" % self.dist_target)
# build command: just to get the build_base
cmdbuild = self.get_finalized_command("build")
self.build_base = cmdbuild.build_base
# install command
install = self.reinitialize_command('install_lib',
reinit_subcommands=1)
install.compile = False
install.warn_dir = 0
install.install_dir = self.bdist_dir
log.info("installing to %s" % self.bdist_dir)
self.run_command('install_lib')
# install extra files
extra_files = {
'version.py': os.path.join(
self.bdist_dir, os.path.normpath('mysql/connector/version.py')),
}
for src, dest in extra_files.items():
self.copy_file(src, dest)
# install_egg_info command
cmd_egginfo = self.get_finalized_command('install_egg_info')
cmd_egginfo.install_dir = self.bdist_dir
self.run_command('install_egg_info')
# we need the py2.x converted to py2 in the filename
old_egginfo = cmd_egginfo.get_outputs()[0]
new_egginfo = old_egginfo.replace(
'-py' + sys.version[:3],
'-py' + get_python_version()[0])
move_file(old_egginfo, new_egginfo)
# create distribution
info_files = [
('README', 'README.txt'),
('COPYING', 'COPYING.txt')
]
copy_tree(self.bdist_dir, self.dist_target)
pkg_info = mkpath(os.path.join(self.dist_target))
for src, dst in info_files:
if dst is None:
copy_file(src, self.dist_target)
else:
copy_file(src, os.path.join(self.dist_target, dst))
if not self.keep_temp:
remove_tree(self.build_base, dry_run=self.dry_run)
def find_python_library():
"Return the full path to the Python library (empty string if not found)"
pyver = sysconfig.get_python_version()
libpython_names = [
"python%s" % pyver.replace(".", ""),
"python%smu" % pyver,
"python%sm" % pyver,
"python%su" % pyver,
"python%s" % pyver,
]
dirs = [
"%s/lib" % os.environ.get("PYTHON_DIR", ""),
"%s" % sysconfig.get_config_vars().get("LIBDIR", ""),
"/usr/lib/%s" % sysconfig.get_config_vars().get("MULTIARCH", ""),
"/usr/local/lib",
"/opt/local/lib",
"/usr/lib",
"/usr/lib64",
]
libpython = None
cc = new_compiler()
for name in libpython_names:
libpython = cc.find_library_file(dirs, name)
if libpython is not None:
break
return libpython or ""
def finalize_options(self):
if self.bdist_dir is None:
bdist_base = self.get_finalized_command("bdist").bdist_base
self.bdist_dir = os.path.join(bdist_base, "msi")
short_version = get_python_version()
if self.target_version:
if not self.skip_build and self.distribution.has_ext_modules() and self.target_version != short_version:
raise DistutilsOptionError, "target version can only be %s, or the '--skip_build'" " option must be specified" % (
short_version,
)
else:
self.target_version = short_version
self.set_undefined_options("bdist", ("dist_dir", "dist_dir"), ("plat_name", "plat_name"))
if self.pre_install_script:
raise DistutilsOptionError, "the pre-install-script feature is not yet implemented"
if self.install_script:
for script in self.distribution.scripts:
if self.install_script == os.path.basename(script):
break
else:
raise DistutilsOptionError, "install_script '%s' not found in scripts" % self.install_script
self.install_script_key = None
def get_exe_bytes(self):
# If a target-version other than the current version has been
# specified, then using the MSVC version from *this* build is no good.
# Without actually finding and executing the target version and parsing
# its sys.version, we just hard-code our knowledge of old versions.
# NOTE: Possible alternative is to allow "--target-version" to
# specify a Python executable rather than a simple version string.
# We can then execute this program to obtain any info we need, such
# as the real sys.version string for the build.
cur_version = get_python_version()
# If the target version is *later* than us, then we assume they
# use what we use
# string compares seem wrong, but are what sysconfig.py itself uses
if self.target_version and self.target_version < cur_version:
if self.target_version < "2.4":
bv = 6.0
elif self.target_version == "2.4":
bv = 7.1
elif self.target_version == "2.5":
bv = 8.0
elif self.target_version <= "3.2":
bv = 9.0
elif self.target_version <= "3.4":
bv = 10.0
else:
bv = 14.0
else:
# for current version - use authoritative check.
try:
from msvcrt import CRT_ASSEMBLY_VERSION
except ImportError:
# cross-building, so assume the latest version
bv = 14.0
else:
bv = float('.'.join(CRT_ASSEMBLY_VERSION.split('.', 2)[:2]))
# wininst-x.y.exe is in the same directory as this file
directory = os.path.dirname(__file__)
# we must use a wininst-x.y.exe built with the same C compiler
# used for python. XXX What about mingw, borland, and so on?
# if plat_name starts with "win" but is not "win32"
# we want to strip "win" and leave the rest (e.g. -amd64)
# for all other cases, we don't want any suffix
if self.plat_name != 'win32' and self.plat_name[:3] == 'win':
sfix = self.plat_name[3:]
else:
sfix = ''
filename = os.path.join(directory, "wininst-%.1f%s.exe" % (bv, sfix))
try:
f = open(filename, "rb")
except IOError as e:
raise DistutilsFileError(str(e) + ', %s not included in the Debian packages.' % filename)
try:
return f.read()
finally:
f.close()
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 get_exe_bytes(self):
from distutils.msvccompiler import get_build_version
# If a target-version other than the current version has been
# specified, then using the MSVC version from *this* build is no good.
# Without actually finding and executing the target version and parsing
# its sys.version, we just hard-code our knowledge of old versions.
# NOTE: Possible alternative is to allow "--target-version" to
# specify a Python executable rather than a simple version string.
# We can then execute this program to obtain any info we need, such
# as the real sys.version string for the build.
cur_version = get_python_version()
if self.target_version and self.target_version != cur_version:
# If the target version is *later* than us, then we assume they
# use what we use
# string compares seem wrong, but are what sysconfig.py itself uses
if self.target_version > cur_version:
bv = get_build_version()
else:
if self.target_version < "2.4":
bv = "6"
else:
bv = "7.1"
else:
# for current version - use authoritative check.
bv = get_build_version()
# wininst-x.y.exe is in the same directory as this file
directory = os.path.dirname(__file__)
# we must use a wininst-x.y.exe built with the same C compiler
# used for python. XXX What about mingw, borland, and so on?
filename = os.path.join(directory, "wininst-%s.exe" % bv)
return open(filename, "rb").read()
def get_install_args(self, global_options, record_filename, root, prefix):
install_args = [sys.executable, "-u"]
install_args.append('-c')
install_args.append(SETUPTOOLS_SHIM % self.setup_py)
install_args += list(global_options) + \
['install', '--record', record_filename]
if not self.as_egg:
install_args += ['--single-version-externally-managed']
if root is not None:
install_args += ['--root', root]
if prefix is not None:
install_args += ['--prefix', prefix]
if self.pycompile:
install_args += ["--compile"]
else:
install_args += ["--no-compile"]
if running_under_virtualenv():
py_ver_str = 'python' + sysconfig.get_python_version()
install_args += ['--install-headers',
os.path.join(sys.prefix, 'include', 'site',
py_ver_str, self.name)]
return install_args
def executables():
import sys
from distutils import sysconfig
libraries = []
library_dirs = []
compile_args = []
link_args = []
py_version = sysconfig.get_python_version()
cfgDict = sysconfig.get_config_vars()
if not sys.platform.startswith('win'):
if '-pthread' in cfgDict.get('CC', ''):
compile_args.append('-pthread')
libraries = ['python' + py_version]
for var in ('LIBDIR', 'LIBPL'):
library_dirs += cfgDict.get(var, '').split()
if '-pthread' in cfgDict.get('LINKCC', ''):
link_args.append('-pthread')
for var in ('LDFLAGS',
'LIBS', 'MODLIBS', 'SYSLIBS',
'LDLAST'):
link_args += cfgDict.get(var, '').split()
# MPI-enabled Python interpreter
pyexe = dict(name='python%s-mpi' % py_version,
sources=['src/python.c'],
libraries=libraries,
library_dirs=library_dirs,
extra_compile_args=compile_args,
extra_link_args=link_args)
return [pyexe]
def finalize_options(self):
"""Finalize the options"""
if self.bdist_dir is None:
bdist_base = self.get_finalized_command("bdist").bdist_base
self.bdist_dir = os.path.join(bdist_base, "egg")
self.set_undefined_options("bdist", ("dist_dir", "dist_dir"), ("plat_name", "plat_name"))
commercial_license = "Other/Proprietary License"
self.distribution.metadata.license = commercial_license
python_version = get_python_version()
if self.include_sources:
pyver = python_version[0:2]
else:
pyver = python_version
# Change classifiers
new_classifiers = []
for classifier in self.distribution.metadata.classifiers:
if classifier.startswith("License ::"):
classifier = "License :: " + commercial_license
elif classifier.startswith("Programming Language ::") and (pyver not in classifier):
log.info("removing classifier %s" % classifier)
continue
new_classifiers.append(classifier)
self.distribution.metadata.classifiers = new_classifiers
def finalize_options(self):
ei_cmd = self.ei_cmd = self.get_finalized_command("egg_info")
self.egg_info = ei_cmd.egg_info
if self.bdist_dir is None:
bdist_base = self.get_finalized_command("bdist").bdist_base
self.bdist_dir = os.path.join(bdist_base, "egg")
if self.plat_name is None:
self.plat_name = get_build_platform()
self.set_undefined_options("bdist", ("dist_dir", "dist_dir"))
if self.egg_output is None:
# Compute filename of the output egg
basename = Distribution(
None,
None,
ei_cmd.egg_name,
ei_cmd.egg_version,
get_python_version(),
self.distribution.has_ext_modules() and self.plat_name,
).egg_name()
self.egg_output = os.path.join(self.dist_dir, basename + ".egg")
def finalize_options(self):
if self.bdist_dir is None:
bdist_base = self.get_finalized_command('bdist').bdist_base
self.bdist_dir = os.path.join(bdist_base, 'msi')
short_version = get_python_version()
if (not self.target_version) and self.distribution.has_ext_modules():
self.target_version = short_version
if self.target_version:
self.versions = [self.target_version]
if not self.skip_build and self.distribution.has_ext_modules()\
and self.target_version != short_version:
raise DistutilsOptionError(
"target version can only be %s, or the '--skip-build'"
" option must be specified" % (short_version,))
else:
self.versions = list(self.all_versions)
self.set_undefined_options('bdist',
('dist_dir', 'dist_dir'),
('plat_name', 'plat_name'),
)
if self.pre_install_script:
raise DistutilsOptionError(
"the pre-install-script feature is not yet implemented")
if self.install_script:
for script in self.distribution.scripts:
if self.install_script == os.path.basename(script):
break
else:
raise DistutilsOptionError(
"install_script '%s' not found in scripts"
% self.install_script)
self.install_script_key = None
def finalize_options(self):
ei_cmd = self.get_finalized_command('egg_info')
self.egg_info = ei_cmd.egg_info
if self.bdist_dir is None:
bdist_base = self.get_finalized_command('bdist').bdist_base
self.bdist_dir = os.path.join(bdist_base, 'venv')
if self.no_plat_name:
self.plat_name = ''
elif self.plat_name is None:
self.plat_name = get_build_platform()
if self.requirements is None and os.path.exists('requirements.txt'):
self.requirements = 'requirements.txt'
if self.no_archive_root:
self.archive_root = '.'
elif self.archive_root is None:
self.archive_root = self.distribution.get_fullname()
elif not self.archive_root:
self.archive_root = '.'
self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
basename = self.distribution.get_fullname()
if self.plat_name:
basename = '%s.%s-py%s' % (basename, self.plat_name,
get_python_version())
self.venv_output = os.path.join(self.dist_dir, basename + '.tar.gz')
def finalize_options (self):
if self.bdist_dir is None:
if self.skip_build and self.plat_name:
# If build is skipped and plat_name is overridden, bdist will
# not see the correct 'plat_name' - so set that up manually.
bdist = self.distribution.get_command_obj('bdist')
bdist.plat_name = self.plat_name
# next the command will be initialized using that name
bdist_base = self.get_finalized_command('bdist').bdist_base
self.bdist_dir = os.path.join(bdist_base, 'wininst')
if not self.target_version:
self.target_version = ""
if not self.skip_build and self.distribution.has_ext_modules():
short_version = get_python_version()
if self.target_version and self.target_version != short_version:
raise DistutilsOptionError, \
"target version can only be %s, or the '--skip_build'" \
" option must be specified" % (short_version,)
self.target_version = short_version
self.set_undefined_options('bdist',
('dist_dir', 'dist_dir'),
('plat_name', 'plat_name'),
)
if self.install_script:
for script in self.distribution.scripts:
if self.install_script == os.path.basename(script):
break
else:
raise DistutilsOptionError, \
"install_script '%s' not found in scripts" % \
self.install_script
def rpmbuild(sname, sversion, srpmdata):
try:
# Default .spec
os.system('./setup.py bdist_rpm --spec-only')
# Default tarball
os.system('./setup.py sdist --dist-dir ~/rpmbuild/SOURCES/')
# Python Lib dir and Version
pylib = get_python_lib()
pyver = get_python_version()
# Applying the changes to the .spec (%files/%config/%dir/%post):
# Initialize spec with the basic
newspec = brpmdata
for l in open('dist/%s.spec' % sname).readlines():
# Remove the defaults:
# '%files -f INSTALLED_FILES'
# '%defattr(-,root,root,-)'
if '%files -f INSTALLED_FILES' not in l and '%defattr' not in l:
newspec += l
# Insert the user defined specs (%files/%config/%dir/%post):
newspec += srpmdata
# Replace the Python Lib dir and Version by the real ones
newspec = newspec.replace('@@PYLIB_MARKER@@', pylib)
newspec = newspec.replace('@@PYVER_MARKER@@', pyver)
open('dist/%s.spec' % sname, 'w').write(newspec)
# Create the new RPM
os.system('rpmbuild -bb dist/%s.spec' % sname)
# Copy the created RPM to dist/
os.system('/bin/cp ~/rpmbuild/RPMS/noarch/%s-%s-*.rpm dist/' % (sname, sversion))
except Exception, why:
print 'ERR: Error building the RPM with custom .spec file: [%s]' % why
def run(self):
# generate the metadata first
self.run_command('egg_info')
venv_dir = self.bdist_dir
virtualenv.create_environment(
venv_dir,
never_download=True,
)
pip_cmd = [os.path.join(venv_dir, 'bin', 'pip'), 'install', '.']
if self.requirements:
pip_cmd.extend(['-r', self.requirements])
subprocess.check_call(pip_cmd)
self.copy_file(os.path.join(self.egg_info, 'PKG-INFO'), venv_dir)
virtualenv.make_environment_relocatable(venv_dir)
log.info("creating '%s' and adding '%s' to it", self.venv_output,
venv_dir)
mkpath(os.path.dirname(self.venv_output))
with closing(tarfile.open(self.venv_output, 'w:gz')) as tar:
tar.add(venv_dir, self.archive_root)
self.distribution.dist_files.append(('bdist_venv', get_python_version(),
self.venv_output))
if not self.keep_temp:
remove_tree(venv_dir)
def finalize_options(self):
self.set_undefined_options('build',
('build_base', 'build_base'))
self.set_undefined_options('bdist',
('dist_dir', 'dist_dir'))
if not self.prefix:
self.prefix = os.path.join(self.build_base, 'wininst')
supported = ['2.6', '2.7', '3.3', '3.4']
if self.python_version not in supported:
raise DistutilsOptionError(
"The --python-version should be a supported version, one "
"of %s" % ','.join(supported))
if self.python_version[0] != get_python_version()[0]:
raise DistutilsError(
"Python v3 distributions need to be build with a "
"supported Python v3 installation.")
if self.with_mysql_capi:
cmd_build = self.get_finalized_command('build')
self.connc_lib = os.path.join(cmd_build.build_temp, 'connc', 'lib')
self.connc_include = os.path.join(cmd_build.build_temp,
'connc', 'include')
self._finalize_connector_c(self.with_mysql_capi)
else:
self.connc_lib = None
self.connc_lib = None
def build_dlib():
"""use cmake to build and install the extension
"""
if cmake_path is None:
raise DistutilsSetupError("Cannot find cmake in the path. Please specify its path with --cmake parameter.")
platform_arch = platform.architecture()[0]
log.info("Detected Python architecture: %s" % platform_arch)
# make sure build artifacts are generated for the version of Python currently running
cmake_extra_arch = []
if sys.version_info >= (3, 0):
cmake_extra_arch += ["-DPYTHON3=yes"]
if platform_arch == "64bit" and sys.platform == "win32":
# 64bit build on Windows
if not generator_set:
# see if we can deduce the 64bit default generator
cmake_extra_arch += get_msvc_win64_generator()
# help cmake to find Python library in 64bit Python in Windows
# because cmake is 32bit and cannot find PYTHON_LIBRARY from registry.
inc_dir = get_python_inc()
cmake_extra_arch += ["-DPYTHON_INCLUDE_DIR={inc}".format(inc=inc_dir)]
# this imitates cmake in path resolution
py_ver = get_python_version()
for ext in [py_ver.replace(".", "") + ".lib", py_ver + "mu.lib", py_ver + "m.lib", py_ver + "u.lib"]:
py_lib = os.path.abspath(os.path.join(inc_dir, "../libs/", "python" + ext))
if os.path.exists(py_lib):
cmake_extra_arch += ["-DPYTHON_LIBRARY={lib}".format(lib=py_lib)]
break
build_dir = os.path.join(script_dir, "./tools/python/build")
if os.path.exists(build_dir):
log.info("Removing build directory %s" % build_dir)
rmtree(build_dir)
try:
os.makedirs(build_dir)
except OSError:
pass
# cd build
os.chdir(build_dir)
log.info("Configuring cmake ...")
cmake_cmd = [cmake_path, ".."] + cmake_extra + cmake_extra_arch
if run_process(cmake_cmd):
raise DistutilsSetupError("cmake configuration failed!")
log.info("Build using cmake ...")
cmake_cmd = [cmake_path, "--build", ".", "--config", cmake_config, "--target", "install"]
if run_process(cmake_cmd):
raise DistutilsSetupError("cmake build failed!")
# cd back where setup awaits
os.chdir(script_dir)
def configure():
"""
Look up the dependencies
- Python.h
- numpy headers
- boost headers (from configuration flag)
meanwhile, pass through any config-looking arguments (ex: --boost=...)
"""
# Python.h
python_inc = sysconfig.get_python_inc()
# Libpython
python_libdir = join(sysconfig.get_python_lib(standard_lib=True), "config")
python_lib = "python" + sysconfig.get_python_version()
if '--version' in sys.argv:
return "--version"
# numpy headers
try:
import numpy
numpy_inc = numpy.get_include()
except ImportError:
die("Requires numpy >= 1.6.0")
configArgs = []
for arg in sys.argv[:]:
if arg.startswith("-") and arg not in ["--help", "--version"]:
configArgs.append(arg)
sys.argv.remove(arg)
configArgs.append("--python-include=%s " % python_inc)
configArgs.append("--numpy-include=%s " % numpy_inc)
return " ".join(configArgs)
def get_python_lib_dirs():
lib_dirs = []
if os.name == 'nt':
lib_dirs.append(os.path.join(sys.exec_prefix, 'libs'))
elif os.name == 'os2':
lib_dirs.append(os.path.join(sys.exec_prefix, 'Config'))
if sys.platform[:6] == 'cygwin' or sys.platform[:6] == 'atheos':
if sys.excutable.startswith(os.path.join(sys.exec_prefix, "bin")):
lib_dirs.append(os.path.join(sys.prefix, "lib",
"python" + sysconfig.get_python_version(), "config"))
else:
lib_dirs.append(".")
sysconfig.get_config_var('Py_ENABLE_SHARED')
if ((sys.platform.startswith('linux') or sys.platform.startswith('gnu')
or sys.platform.startswith('sunos'))
and sysconfig.get_config_var('Py_ENABLE_SHARED')):
if sys.executable.startswith(os.path.join(sys.exec_prefix, "bin")):
# building third party extensions
lib_dirs.append(sysconfig.get_config_var('LIBDIR'))
else:
# building python standard extensions
lib_dirs.append('.')
return lib_dirs
def _exists():
"""PolyBoRi convention: checking optional components for prerequisites here
>>> _exists()
True
"""
from distutils.sysconfig import get_python_version
return float(get_python_version()) > 2.4
def cpp_ext(name, sources, libs=None, use_hdf5=False):
"""Helper function for setting up extension dictionary.
Parameters
----------
name : str
Module name
sources : list of str
Files to compile
libs : list of str
Additional files to link against
use_hdf5 : bool
Link against hdf5?
"""
ext = {'name': name}
ext['sources'] = [os.path.join(cpp_dir, s) for s in sources if s.endswith('cpp')] + \
[os.path.join(pyt_dir, s) for s in sources if s.endswith('pyx')] + \
[s for s in sources if not any([s.endswith(suf) for suf in ['cpp', 'pyx']])]
ext["libraries"] = []
ext['include_dirs'] = [pyt_dir, cpp_dir, numpy_include]
ext['language'] = "c++"
# may need to be more general
ext['library_dirs'] = ['build/lib/pyne/lib',
'build/lib.{0}-{1}/pyne/lib'.format(get_platform(), get_python_version()),
]
# perfectly general, thanks to dynamic runtime linking of $ORIGIN
#ext['runtime_library_dirs'] = ['${ORIGIN}/lib', '${ORIGIN}']
ext['runtime_library_dirs'] = ['${ORIGIN}/lib', '${ORIGIN}', '${ORIGIN}/.',
'${ORIGIN}/../lib', '${ORIGIN}/..',]
#ext['runtime_library_dirs'] = ['${ORIGIN}/lib', '${ORIGIN}', '${ORIGIN}/.'] + \
# [os.path.abspath(p) for p in ext['library_dirs']] + \
# [os.path.abspath(p + '/pyne/lib') for p in sys.path] + \
# [os.path.abspath(p + '/pyne') for p in sys.path] + \
# [os.path.abspath(p) for p in sys.path]
if os.name == 'posix':
#ext["extra_compile_args"] = ["-Wno-strict-prototypes"]
ext["undef_macros"] = ["NDEBUG"]
if use_hdf5:
ext["libraries"] += posix_hdf5_libs
if libs is not None:
ext["libraries"] += libs
elif os.name == 'nt':
ext["extra_compile_args"] = ["/EHsc"]
ext["define_macros"] = [("_WIN32", None)]
if use_hdf5:
ext["libraries"] += nt_hdf5_libs
ext["extra_compile_args"] += nt_hdf5_extra_compile_args
ext["define_macros"] += nt_hdf5_macros
if libs is not None:
ext["libraries"] += libs
return ext
def _get_fullname():
if not self.include_sources:
pyver = '-py' + get_python_version()
return "{name}-commercial-{version}{edition}{pyver}".format(
name=self.distribution.get_name(),
version=self.distribution.get_version(),
edition=self.edition or '',
pyver=pyver
)
def initialize_options (self):
"""Initialize the options"""
self.bdist_dir = None
self.keep_temp = 0
self.dist_dir = None
self.include_sources = True
self.wix_install = WIX_INSTALL
self.python_version = get_python_version()[:3]
self.edition = EDITION
def Version():
po = excons.GetArgument("with-python")
if po is not None:
rv = _GetPythonSpec(po)
if rv is not None:
return rv[0]
return str(sysconfig.get_python_version())
def get_egg_filename(self):
def make_egg_safe(name):
return re.sub('[^a-zA-Z0-9.]+', '_', name)
name = make_egg_safe(self.distribution.get_name())
version = make_egg_safe(self.distribution.get_version())
platform = get_python_version()
if self.distribution.has_ext_modules():
platform += '-' + self.plat_name
return '%s-%s-py%s.egg' % (name, version, platform)
def finalize_options(self):
ei_cmd = self.ei_cmd = self.get_finalized_command("egg_info")
self.egg_info = ei_cmd.egg_info
basename = pkg_resources.Distribution(
None, None, ei_cmd.egg_name, ei_cmd.egg_version,
get_python_version(),
self.distribution.has_ext_modules() and pkg_utils.get_build_platform).egg_name()
print basename
def generate(env):
cv = get_config_vars()
pylib = 'python'+get_python_version()
pylibpath = [cv[var] for var in ('LIBDIR', 'LIBPL')]
env.Append(CPPPATH=[get_python_inc(),numpy.get_include()])
if Arch.isWindows():
env.Append(LIBS=pylib.replace(".",""))
env.Append(LIBPATH=pylibpath)
else:
env.Append(LIBS=pylib)
env.Append(LIBPATH=pylibpath)
def install(self, install_options, global_options=(), root=None):
if self.editable:
self.install_editable(install_options, global_options)
return
if self.is_wheel:
version = pip.wheel.wheel_version(self.source_dir)
pip.wheel.check_compatibility(version, self.name)
self.move_wheel_files(self.source_dir, root=root)
self.install_succeeded = True
return
temp_location = tempfile.mkdtemp('-record', 'pip-')
record_filename = os.path.join(temp_location, 'install-record.txt')
try:
install_args = [sys.executable]
install_args.append('-c')
install_args.append(
"import setuptools, tokenize;__file__=%r;"
"exec(compile(getattr(tokenize, 'open', open)(__file__).read()"
".replace('\\r\\n', '\\n'), __file__, 'exec'))" % self.setup_py
)
install_args += list(global_options) + \
['install', '--record', record_filename]
if not self.as_egg:
install_args += ['--single-version-externally-managed']
if root is not None:
install_args += ['--root', root]
if self.pycompile:
install_args += ["--compile"]
else:
install_args += ["--no-compile"]
if running_under_virtualenv():
# FIXME: I'm not sure if this is a reasonable location;
# probably not but we can't put it in the default location, as
# that is a virtualenv symlink that isn't writable
py_ver_str = 'python' + sysconfig.get_python_version()
install_args += ['--install-headers',
os.path.join(sys.prefix, 'include', 'site',
py_ver_str)]
logger.notify('Running setup.py install for %s' % self.name)
logger.indent += 2
try:
call_subprocess(
install_args + install_options,
cwd=self.source_dir,
filter_stdout=self._filter_install,
show_stdout=False,
)
finally:
logger.indent -= 2
if not os.path.exists(record_filename):
logger.notify('Record file %s not found' % record_filename)
return
self.install_succeeded = True
if self.as_egg:
# there's no --always-unzip option we can pass to install
# command so we unable to save the installed-files.txt
return
def prepend_root(path):
if root is None or not os.path.isabs(path):
return path
else:
return change_root(root, path)
f = open(record_filename)
for line in f:
line = line.strip()
if line.endswith('.egg-info'):
egg_info_dir = prepend_root(line)
break
else:
logger.warn(
'Could not find .egg-info directory in install record for '
'%s' % self
)
f.close()
# FIXME: put the record somewhere
# FIXME: should this be an error?
return
f.close()
new_lines = []
f = open(record_filename)
for line in f:
filename = line.strip()
if os.path.isdir(filename):
filename += os.path.sep
new_lines.append(
make_path_relative(prepend_root(filename), egg_info_dir)
)
f.close()
f = open(os.path.join(egg_info_dir, 'installed-files.txt'), 'w')
f.write('\n'.join(new_lines) + '\n')
f.close()
finally:
if os.path.exists(record_filename):
os.remove(record_filename)
os.rmdir(temp_location)
class _MSIDist(Command):
""""Create a MSI distribution"""
user_options = [
('bdist-dir=', 'd',
"temporary directory for creating the distribution"),
('keep-temp', 'k', "keep the pseudo-installation tree around after " +
"creating the distribution archive"),
('dist-dir=', 'd', "directory to put final built distributions in"),
('wix-install=', None,
"location of the Windows Installer XML installation"
"(default: %s)" % wix.WIX_INSTALL_PATH),
('wix-required-version=', None,
"required version the Windows Installer XML installation"
"(default: %s)" % wix.WIX_REQUIRED_VERSION),
('python-version=', None, "target Python version"),
('prepare-stage', 'p',
"only stage installation for this python {} version, used later for"
"a single msi".format(get_python_version()[:3])),
('combine-stage', 'c',
"Unify the prepared msi stages to only one single msi"),
] + COMMON_USER_OPTIONS + CEXT_OPTIONS
boolean_options = [
'keep-temp', 'include-sources', 'prepare-stage', 'combine-stage'
]
negative_opt = {}
def initialize_options(self):
self.prefix = None
self.build_base = None
self.bdist_dir = None
self.keep_temp = 0
self.dist_dir = None
self.include_sources = True
self.wix_install = wix.WIX_INSTALL_PATH
self.wix_required_version = wix.WIX_REQUIRED_VERSION
self.python_version = get_python_version()[:3]
self.edition = EDITION
self.with_mysql_capi = None
self.with_protobuf_include_dir = None
self.with_protobuf_lib_dir = None
self.with_protoc = None
self.with_cext = False
self.extra_compile_args = None
self.extra_link_args = None
self.connc_lib = None
self.connc_lib = None
self.prepare_stage = False
self.combine_stage = False
def finalize_options(self):
self.set_undefined_options('build', ('build_base', 'build_base'))
self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
if not self.prefix:
self.prefix = os.path.join(
self.build_base,
DIST_PATH_FORMAT.format(self.python_version[0],
self.python_version[2]))
self.supported_versions = ['2.7', '3.4', '3.5', '3.6', '3.7', '3.8']
self.dist_path = {}
for py_ver in self.supported_versions:
self.dist_path[py_ver] = os.path.join(
self.build_base, DIST_PATH_FORMAT.format(*py_ver.split('.')))
if self.python_version not in self.supported_versions:
raise DistutilsOptionError(
"The --python-version should be a supported version, one "
"of %s" % ','.join(self.supported_versions))
if self.python_version[0] != get_python_version()[0]:
raise DistutilsError(
"Python v3 distributions need to be build with a "
"supported Python v3 installation.")
self.with_cext = any(
(self.with_mysql_capi, self.with_protobuf_include_dir,
self.with_protobuf_lib_dir, self.with_protoc))
if self.with_cext:
if not self.with_mysql_capi or \
not os.path.isdir(self.with_mysql_capi):
log.error("Location of MySQL C API (Connector/C) must be "
"provided.")
sys.exit(1)
else:
cmd_build = self.get_finalized_command('build')
self.connc_lib = os.path.join(cmd_build.build_temp, 'connc',
'lib')
self.connc_include = os.path.join(cmd_build.build_temp,
'connc', 'include')
self._finalize_connector_c(self.with_mysql_capi)
if not self.with_protobuf_include_dir or \
not os.path.isdir(self.with_protobuf_include_dir):
log.error("Location of Protobuf include directory must be "
"provided.")
sys.exit(1)
else:
self.with_protobuf_include_dir = \
os.path.abspath(self.with_protobuf_include_dir)
if not self.with_protobuf_lib_dir or \
not os.path.isdir(self.with_protobuf_lib_dir):
log.error("Location of Protobuf library directory must be "
"provided.")
sys.exit(1)
else:
self.with_protobuf_lib_dir = \
os.path.abspath(self.with_protobuf_lib_dir)
if not self.with_protoc or not os.path.isfile(self.with_protoc):
log.error("Protobuf protoc binary is not valid.")
sys.exit(1)
else:
self.with_protoc = os.path.abspath(self.with_protoc)
def _finalize_connector_c(self, connc_loc):
if not os.path.isdir(connc_loc):
log.error("MySQL C API should be a directory")
sys.exit(1)
copy_tree(os.path.join(connc_loc, 'lib'), self.connc_lib)
copy_tree(os.path.join(connc_loc, 'include'), self.connc_include)
if ARCH_64BIT:
for filename in ["libssl-1_1-x64.dll", "libcrypto-1_1-x64.dll"]:
src = os.path.join(connc_loc, "bin", filename)
dst = self.connc_lib
log.info("copying {0} -> {1}".format(src, dst))
shutil.copy(src, dst)
else:
for filename in ["libssl-1_1.dll", "libcrypto-1_1.dll"]:
src = os.path.join(connc_loc, "bin", filename)
dst = self.connc_lib
log.info("copying {0} -> {1}".format(src, dst))
shutil.copy(src, dst)
for lib_file in os.listdir(self.connc_lib):
if os.name == 'posix' and not lib_file.endswith('.a'):
os.unlink(os.path.join(self.connc_lib, lib_file))
def finalize_msi_descriptor(self):
"""Returns the finalized and customized path of the msi descriptor.
"""
base_xml_path = os.path.join(MSIDATA_ROOT, "product.wxs")
result_xml_path = os.path.join(MSIDATA_ROOT, 'cpy_product_desc.wxs')
if get_platform() == 'win32':
add_arch_dep_elems(base_xml_path,
result_xml_path,
for32=True,
log=log,
add_vs_redist=False)
else:
add_arch_dep_elems(base_xml_path,
result_xml_path,
log=log,
add_vs_redist=self.with_cext)
return result_xml_path
def _get_wixobj_name(self, myc_version=None, python_version=None):
"""Get the name for the wixobj-file
Returns a string
"""
raise NotImplementedError
def find_bdist_paths(self):
"""Find compresed distribution files or valid distribution paths.
"""
valid_bdist_paths = {}
bdist_paths = {
'2.7':
os.path.join(os.path.abspath(self.dist_path['2.7']), 'Lib',
'site-packages'),
'3.4':
os.path.join(os.path.abspath(self.dist_path['3.4']), 'Lib',
'site-packages'),
'3.5':
os.path.join(os.path.abspath(self.dist_path['3.5']), 'Lib',
'site-packages'),
'3.6':
os.path.join(os.path.abspath(self.dist_path['3.6']), 'Lib',
'site-packages'),
'3.7':
os.path.join(os.path.abspath(self.dist_path['3.7']), 'Lib',
'site-packages'),
'3.8':
os.path.join(os.path.abspath(self.dist_path['3.8']), 'Lib',
'site-packages')
}
for py_ver in self.supported_versions:
bdist_paths[py_ver] = os.path.join(
os.path.abspath(self.dist_path[py_ver]), 'Lib',
'site-packages')
zip_fn = "{}.zip".format(
DIST_PATH_FORMAT.format(*py_ver.split(".")))
log.info("Locating zip: %s at %s", zip_fn, os.path.curdir)
bdist_path = None
if os.path.exists(zip_fn) and \
zipfile.is_zipfile(zip_fn):
with zipfile.ZipFile(zip_fn) as zip_f:
zip_f.extractall()
else:
log.warn("Unable to find zip: %s at %s", zip_fn,
os.path.curdir)
if bdist_path is None:
bdist_path = bdist_paths[py_ver]
log.info("Checking for extracted distribution at %s",
bdist_path)
if os.path.exists(bdist_path):
valid_bdist_paths[py_ver] = bdist_path
log.info("Distribution path found at %s", bdist_path)
else:
log.warn("Unable to find distribution path for %s", py_ver)
return valid_bdist_paths
def _create_msi(self, dry_run=0):
"""Create the Windows Installer using WiX
Creates the Windows Installer using WiX and returns the name of
the created MSI file.
Raises DistutilsError on errors.
Returns a string
"""
# load the upgrade codes
with open(os.path.join(MSIDATA_ROOT, 'upgrade_codes.json')) as fp:
upgrade_codes = json.load(fp)
# version variables for Connector/Python and Python
mycver = self.distribution.metadata.version
match = re.match("(\d+)\.(\d+).(\d+).*", mycver)
if not match:
raise ValueError("Failed parsing version from %s" % mycver)
(major, minor, patch) = match.groups()
pyver = self.python_version
pymajor = pyver[0]
pyminor = pyver[2]
# check whether we have an upgrade code
try:
upgrade_code = upgrade_codes[mycver[0:3]][pyver]
except KeyError:
raise DistutilsError(
"No upgrade code found for version v{cpy_ver}, "
"Python v{py_ver}".format(cpy_ver=mycver, py_ver=pyver))
log.info("upgrade code for v%s, Python v%s: %s" %
(mycver, pyver, upgrade_code))
self.pyver_bdist_paths = self.find_bdist_paths()
# wixobj's basename is the name of the installer
wixobj = self._get_wixobj_name()
msi = os.path.abspath(
os.path.join(self.dist_dir, wixobj.replace('.wixobj', '.msi')))
wixer = wix.WiX(self.wxs,
out=wixobj,
msi_out=msi,
base_path=self.build_base,
install=self.wix_install)
# correct newlines and version in text files
log.info("Fixing newlines in text files")
info_files = []
for txt_file_dest, txt_file_path in self.fix_txtfiles.items():
txt_fixed = os.path.join(self.build_base, txt_file_dest)
info_files.append(txt_fixed)
content = open(txt_file_path, 'rb').read()
if b'\r\n' not in content:
log.info("converting newlines in %s", txt_fixed)
content = content.replace(b'\n', b'\r\n')
open(txt_fixed, 'wb').write(content)
else:
log.info("not converting newlines in %s, this is odd",
txt_fixed)
open(txt_fixed, 'wb').write(content)
digit_needle = 'Connector/Python \d{1,2}.\d{1,2}'
xy_needle = 'Connector/Python X.Y'
xy_sub = 'Connector/Python {0}.{1}'
for info_file in info_files:
log.info("correcting version in %s", info_file)
with open(info_file, 'r+') as fp:
content = fp.readlines()
for i, line in enumerate(content):
content[i] = re.sub(digit_needle,
xy_sub.format(*VERSION[0:2]), line)
line = content[i]
content[i] = re.sub(xy_needle,
xy_sub.format(*VERSION[0:2]), line)
fp.seek(0)
fp.write(''.join(content))
plat_type = 'x64' if ARCH_64BIT else 'x86'
win64 = 'yes' if ARCH_64BIT else 'no'
pyd_arch = 'win_amd64' if ARCH_64BIT else 'win32'
directory_id = 'ProgramFiles64Folder' if ARCH_64BIT else \
'ProgramFilesFolder'
# For 3.5 the driver names are pretty complex, see
# https://www.python.org/dev/peps/pep-0425/
if pymajor == '3' and int(pyminor) >= 5:
pyd_ext = ".cp%s%s-%s.pyd" % (pyver[0], 5, pyd_arch)
else:
pyd_ext = ".pyd"
cext_lib_name = "_mysql_connector" + pyd_ext
cext_xpb_name = "_mysqlxpb" + pyd_ext
if self.connc_lib:
if ARCH_64BIT:
libcrypto_dll_path = os.path.join(
os.path.abspath(self.connc_lib), 'libcrypto-1_1-x64.dll')
libssl_dll_path = os.path.join(os.path.abspath(self.connc_lib),
'libssl-1_1-x64.dll')
else:
libcrypto_dll_path = os.path.join(
os.path.abspath(self.connc_lib), 'libcrypto-1_1.dll')
libssl_dll_path = os.path.join(os.path.abspath(self.connc_lib),
'libssl-1_1.dll')
else:
libcrypto_dll_path = ''
libssl_dll_path = ''
# WiX preprocessor variables
params = {
'Version': '.'.join([major, minor, patch]),
'FullVersion': mycver,
'PythonVersion': pyver,
'PythonMajor': pymajor,
'PythonMinor': pyminor,
'Major_Version': major,
'Minor_Version': minor,
'Patch_Version': patch,
'Platform': plat_type,
'Directory_Id': directory_id,
'PythonInstallDir': 'Python%s' % pyver.replace('.', ''),
'PyExt': 'pyc' if not self.include_sources else 'py',
'UpgradeCode': upgrade_code,
'ManualPDF': os.path.abspath(
os.path.join('docs', 'mysql-connector-python.pdf')),
'ManualHTML': os.path.abspath(
os.path.join('docs', 'mysql-connector-python.html')),
'UpgradeCode': upgrade_code,
'MagicTag': get_magic_tag(),
'BuildDir': os.path.abspath(self.build_base),
'LibMySQLDLL': os.path.join(
os.path.abspath(self.connc_lib), 'libmysql.dll') \
if self.connc_lib else '',
'LIBcryptoDLL': libcrypto_dll_path,
'LIBSSLDLL': libssl_dll_path,
'Win64': win64,
'BitmapDir': os.path.join(os.getcwd(), "cpyint", "data",
"MSWindows"),
}
for py_ver in self.supported_versions:
ver = py_ver.split(".")
params['BDist{}{}'.format(*ver)] = ""
if ver[0] == '3' and int(ver[1]) >= 5:
pyd_ext = ".cp%s%s-%s.pyd" % (ver[0], ver[1], pyd_arch)
else:
pyd_ext = ".pyd"
params['CExtLibName{}{}'.format(*ver)] = \
"_mysql_connector{}".format(pyd_ext)
params['CExtXPBName{}{}'.format(*ver)] = \
"_mysqlxpb{}".format(pyd_ext)
params['HaveCExt{}{}'.format(*ver)] = 0
if py_ver in self.pyver_bdist_paths:
params['BDist{}{}'.format(*ver)] = \
self.pyver_bdist_paths[py_ver]
if os.path.exists(
os.path.join(self.pyver_bdist_paths[py_ver],
params['CExtLibName{}{}'.format(*ver)])):
params['HaveCExt{}{}'.format(*ver)] = 1
log.info("### wixer params:")
for param in params:
log.info(" %s: %s", param, params[param])
wixer.set_parameters(params)
if not dry_run:
try:
wixer.compile()
wixer.link()
except DistutilsError:
raise
if not self.keep_temp and not dry_run:
log.info('WiX: cleaning up')
os.unlink(msi.replace('.msi', '.wixpdb'))
return msi
def _prepare(self):
log.info("Preparing installation in %s", self.build_base)
cmd_install = self.reinitialize_command('install',
reinit_subcommands=1)
cmd_install.prefix = self.prefix
cmd_install.with_mysql_capi = self.with_mysql_capi
cmd_install.with_protobuf_include_dir = self.with_protobuf_include_dir
cmd_install.with_protobuf_lib_dir = self.with_protobuf_lib_dir
cmd_install.with_protoc = self.with_protoc
cmd_install.extra_compile_args = self.extra_compile_args
cmd_install.extra_link_args = self.extra_link_args
cmd_install.static = False
cmd_install.ensure_finalized()
cmd_install.run()
def run(self):
"""Run the distutils command"""
if os.name != 'nt':
log.info("This command is only useful on Windows. "
"Forcing dry run.")
self.dry_run = True
log.info("generating INFO_SRC and INFO_BIN files")
generate_info_files()
if not self.combine_stage:
self._prepare()
if self.prepare_stage:
zip_fn = os.path.join(
self.dist_dir, "{}.zip".format(os.path.abspath(self.prefix)))
log.info("generating stage: %s", zip_fn)
with zipfile.ZipFile(zip_fn, "w", zipfile.ZIP_DEFLATED) as zip_f:
# Read all directory, subdirectories and file lists
for root, _, files in os.walk(self.prefix):
for filename in files:
# Create the full filepath by using os module.
filePath = os.path.join(root, filename)
log.info(" adding file: %s", filePath)
zip_f.write(filePath)
log.info("stage created: %s", zip_fn)
else:
wix.check_wix_install(
wix_install_path=self.wix_install,
wix_required_version=self.wix_required_version,
dry_run=self.dry_run)
# create the Windows Installer
msi_file = self._create_msi(dry_run=self.dry_run)
log.info("created MSI as %s" % msi_file)
if not self.keep_temp:
remove_tree(self.build_base, dry_run=self.dry_run)
if ARCH_64BIT:
for filename in [
"libssl-1_1-x64.dll", "libcrypto-1_1-x64.dll"
]:
dll_file = os.path.join(os.getcwd(), filename)
if os.path.exists(dll_file):
os.unlink(dll_file)
else:
for filename in ["libssl-1_1.dll", "libcrypto-1_1.dll"]:
dll_file = os.path.join(os.getcwd(), filename)
if os.path.exists(dll_file):
os.unlink(dll_file)
def run(self):
if DEBUG:
print 'before _get_package_data():'
print 'vendor =', self.vendor
print 'packager =', self.packager
print 'doc_files =', self.doc_files
print 'changelog =', self.changelog
if self.spec_only:
spec_dir = self.dist_dir
self.mkpath(spec_dir)
else:
rpm_dir = {}
for d in ('SOURCES', 'SPECS', 'BUILD', 'RPMS', 'SRPMS'):
rpm_dir[d] = os.path.join(self.rpm_base, d)
self.mkpath(rpm_dir[d])
spec_dir = rpm_dir['SPECS']
spec_path = os.path.join(spec_dir,
'%s.spec' % self.distribution.get_name())
self.execute(write_file, (spec_path, self._make_spec_file()),
"writing '%s'" % spec_path)
if self.spec_only:
return
else:
saved_dist_files = self.distribution.dist_files[:]
sdist = self.reinitialize_command('sdist')
if self.use_bzip2:
sdist.formats = ['bztar']
else:
sdist.formats = ['gztar']
self.run_command('sdist')
self.distribution.dist_files = saved_dist_files
source = sdist.get_archive_files()[0]
source_dir = rpm_dir['SOURCES']
self.copy_file(source, source_dir)
if self.icon:
if os.path.exists(self.icon):
self.copy_file(self.icon, source_dir)
else:
raise DistutilsFileError, "icon file '%s' does not exist" % self.icon
log.info('building RPMs')
rpm_cmd = ['rpm']
if os.path.exists('/usr/bin/rpmbuild') or os.path.exists(
'/bin/rpmbuild'):
rpm_cmd = ['rpmbuild']
if self.source_only:
rpm_cmd.append('-bs')
elif self.binary_only:
rpm_cmd.append('-bb')
else:
rpm_cmd.append('-ba')
if self.rpm3_mode:
rpm_cmd.extend([
'--define',
'_topdir %s' % os.path.abspath(self.rpm_base)
])
if not self.keep_temp:
rpm_cmd.append('--clean')
if self.quiet:
rpm_cmd.append('--quiet')
rpm_cmd.append(spec_path)
nvr_string = '%{name}-%{version}-%{release}'
src_rpm = nvr_string + '.src.rpm'
non_src_rpm = '%{arch}/' + nvr_string + '.%{arch}.rpm'
q_cmd = "rpm -q --qf '%s %s\\n' --specfile '%s'" % (
src_rpm, non_src_rpm, spec_path)
out = os.popen(q_cmd)
try:
binary_rpms = []
source_rpm = None
while 1:
line = out.readline()
if not line:
break
l = string.split(string.strip(line))
if not len(l) == 2:
raise AssertionError
binary_rpms.append(l[1])
source_rpm = source_rpm is None and l[0]
status = out.close()
if status:
raise DistutilsExecError('Failed to execute: %s' %
repr(q_cmd))
finally:
out.close()
self.spawn(rpm_cmd)
if not self.dry_run:
pyversion = self.distribution.has_ext_modules(
) and get_python_version()
else:
pyversion = 'any'
if not self.binary_only:
srpm = os.path.join(rpm_dir['SRPMS'], source_rpm)
if not os.path.exists(srpm):
raise AssertionError
self.move_file(srpm, self.dist_dir)
filename = os.path.join(self.dist_dir, source_rpm)
self.distribution.dist_files.append(
('bdist_rpm', pyversion, filename))
if not self.source_only:
for rpm in binary_rpms:
rpm = os.path.join(rpm_dir['RPMS'], rpm)
if os.path.exists(rpm):
self.move_file(rpm, self.dist_dir)
filename = os.path.join(self.dist_dir,
os.path.basename(rpm))
self.distribution.dist_files.append(
('bdist_rpm', pyversion, filename))
return
def _get_egg_name(self):
ei_cmd = self.get_finalized_command("egg_info")
return Distribution(
None, None, ei_cmd.egg_name, ei_cmd.egg_version,
get_python_version(),
self.distribution.has_ext_modules() and self.plat_name).egg_name()
def run(self):
"""Run the distutils command"""
log.info("installing library code to %s" % self.bdist_dir)
log.info("generating INFO_SRC and INFO_BIN files")
generate_info_files()
self.dist_name = get_dist_name(self.distribution,
source_only_dist=True,
python_version=get_python_version()[0])
self.dist_target = os.path.join(self.dist_dir, self.dist_name)
log.info("distribution will be available as '%s'" % self.dist_target)
# build command: just to get the build_base
cmdbuild = self.get_finalized_command("build")
self.build_base = cmdbuild.build_base
# install command
install = self.reinitialize_command('install_lib',
reinit_subcommands=1)
install.compile = False
install.warn_dir = 0
install.install_dir = self.bdist_dir
log.info("installing to %s" % self.bdist_dir)
self.run_command('install_lib')
# install extra files
extra_files = {}
for src, dest in extra_files.items():
self.copy_file(src, dest)
# install_egg_info command
cmd_egginfo = self.get_finalized_command('install_egg_info')
cmd_egginfo.install_dir = self.bdist_dir
self.run_command('install_egg_info')
# we need the py2.x converted to py2 in the filename
old_egginfo = cmd_egginfo.get_outputs()[0]
new_egginfo = old_egginfo.replace('-py' + sys.version[:3],
'-py' + get_python_version()[0])
move_file(old_egginfo, new_egginfo)
# create distribution
info_files = [
('README.txt', 'README.txt'),
('LICENSE.txt', 'LICENSE.txt'),
('README.rst', 'README.rst'),
('CONTRIBUTING.rst', 'CONTRIBUTING.rst'),
('docs/INFO_SRC', 'INFO_SRC'),
('docs/INFO_BIN', 'INFO_BIN'),
]
copy_tree(self.bdist_dir, self.dist_target)
pkg_info = mkpath(os.path.join(self.dist_target))
for src, dst in info_files:
if dst is None:
copy_file(src, self.dist_target)
else:
copy_file(src, os.path.join(self.dist_target, dst))
if not self.keep_temp:
remove_tree(self.build_base, dry_run=self.dry_run)
def run(self):
# Generate metadata first
self.run_command("egg_info")
# We run install_lib before install_data, because some data hacks
# pull their data path from the install_lib command.
log.info("installing library code to %s" % self.bdist_dir)
instcmd = self.get_finalized_command('install')
old_root = instcmd.root
instcmd.root = None
cmd = self.call_command('install_lib', warn_dir=0)
instcmd.root = old_root
all_outputs, ext_outputs = self.get_ext_outputs()
self.stubs = []
to_compile = []
for (p, ext_name) in enumerate(ext_outputs):
filename, ext = os.path.splitext(ext_name)
pyfile = os.path.join(self.bdist_dir,
strip_module(filename) + '.py')
self.stubs.append(pyfile)
log.info("creating stub loader for %s" % ext_name)
if not self.dry_run:
write_stub(os.path.basename(ext_name), pyfile)
to_compile.append(pyfile)
ext_outputs[p] = ext_name.replace(os.sep, '/')
to_compile.extend(self.make_init_files())
if to_compile:
cmd.byte_compile(to_compile)
if self.distribution.data_files:
self.do_install_data()
# Make the EGG-INFO directory
archive_root = self.bdist_dir
egg_info = os.path.join(archive_root, 'EGG-INFO')
self.mkpath(egg_info)
if self.distribution.scripts:
script_dir = os.path.join(egg_info, 'scripts')
log.info("installing scripts to %s" % script_dir)
self.call_command('install_scripts',
install_dir=script_dir,
no_ep=1)
self.copy_metadata_to(egg_info)
native_libs = os.path.join(egg_info, "native_libs.txt")
if all_outputs:
log.info("writing %s" % native_libs)
if not self.dry_run:
ensure_directory(native_libs)
libs_file = open(native_libs, 'wt')
libs_file.write('\n'.join(all_outputs))
libs_file.write('\n')
libs_file.close()
elif os.path.isfile(native_libs):
log.info("removing %s" % native_libs)
if not self.dry_run:
os.unlink(native_libs)
write_safety_flag(os.path.join(archive_root, 'EGG-INFO'),
self.zip_safe())
if os.path.exists(os.path.join(self.egg_info, 'depends.txt')):
log.warn(
"WARNING: 'depends.txt' will not be used by setuptools 0.6!\n"
"Use the install_requires/extras_require setup() args instead."
)
if self.exclude_source_files:
self.zap_pyfiles()
# Make the archive
make_zipfile(self.egg_output,
archive_root,
verbose=self.verbose,
dry_run=self.dry_run,
mode=self.gen_header())
if not self.keep_temp:
remove_tree(self.bdist_dir, dry_run=self.dry_run)
# Add to 'Distribution.dist_files' so that the "upload" command works
getattr(self.distribution, 'dist_files', []).append(
('bdist_egg', get_python_version(), self.egg_output))
def get_boost_python_builddir(self):
return os.path.join(
self.omim_builddir,
'boost-build-python{}'.format(get_python_version()),
)
def run(self):
if (sys.platform != "win32"
and (self.distribution.has_ext_modules()
or self.distribution.has_c_libraries())):
raise DistutilsPlatformError \
("distribution contains extensions and/or C libraries; "
"must be compiled on a Windows 32 platform")
if not self.skip_build:
self.run_command('build')
install = self.reinitialize_command('install', reinit_subcommands=1)
install.root = self.bdist_dir
install.skip_build = self.skip_build
install.warn_dir = 0
install.plat_name = self.plat_name
install_lib = self.reinitialize_command('install_lib')
# we do not want to main pyc or pyo files
install_lib.compile = 0
install_lib.optimize = 0
if self.distribution.has_ext_modules():
# If we are building an installer for a Python version other
# than the one we are currently running, then we need to ensure
# our build_lib reflects the other Python version rather than ours.
# Note that for target_version!=sys.version, we must have skipped the
# build step, so there is no issue with enforcing the build of this
# version.
target_version = self.target_version
if not target_version:
assert self.skip_build, "Should have already checked this"
target_version = '%d.%d' % sys.version_info[:2]
plat_specifier = ".%s-%s" % (self.plat_name, target_version)
build = self.get_finalized_command('build')
build.build_lib = os.path.join(build.build_base,
'lib' + plat_specifier)
# Use a custom scheme for the zip-file, because we have to decide
# at installation time which scheme to use.
for key in ('purelib', 'platlib', 'headers', 'scripts', 'data'):
value = key.upper()
if key == 'headers':
value = value + '/Include/$dist_name'
setattr(install, 'install_' + key, value)
log.info("installing to %s", self.bdist_dir)
install.ensure_finalized()
# avoid warning of 'install_lib' about installing
# into a directory not in sys.path
sys.path.insert(0, os.path.join(self.bdist_dir, 'PURELIB'))
install.run()
del sys.path[0]
# And make an archive relative to the root of the
# pseudo-installation tree.
from tempfile import mktemp
archive_basename = mktemp()
fullname = self.distribution.get_fullname()
arcname = self.make_archive(archive_basename,
"zip",
root_dir=self.bdist_dir)
# create an exe containing the zip-file
self.create_exe(arcname, fullname, self.bitmap)
if self.distribution.has_ext_modules():
pyversion = get_python_version()
else:
pyversion = 'any'
self.distribution.dist_files.append(
('bdist_wininst', pyversion,
self.get_installer_filename(fullname)))
# remove the zip-file again
log.debug("removing temporary file '%s'", arcname)
os.remove(arcname)
if not self.keep_temp:
remove_tree(self.bdist_dir, dry_run=self.dry_run)
def finalize_options(self):
from distutils import sysconfig
self.set_undefined_options(
'build',
('build_lib', 'build_lib'),
('build_temp', 'build_temp'),
('compiler', 'compiler'),
('debug', 'debug'),
('force', 'force'),
('parallel', 'parallel'),
('plat_name', 'plat_name'),
)
if self.package is None:
self.package = self.distribution.ext_package
self.extensions = self.distribution.ext_modules
# Make sure Python's include directories (for Python.h, pyconfig.h,
# etc.) are in the include search path.
py_include = sysconfig.get_python_inc()
plat_py_include = sysconfig.get_python_inc(plat_specific=1)
if self.include_dirs is None:
self.include_dirs = self.distribution.include_dirs or []
if isinstance(self.include_dirs, str):
self.include_dirs = self.include_dirs.split(os.pathsep)
# If in a virtualenv, add its include directory
# Issue 16116
if sys.exec_prefix != sys.base_exec_prefix:
self.include_dirs.append(os.path.join(sys.exec_prefix, 'include'))
# Put the Python "system" include dir at the end, so that
# any local include dirs take precedence.
self.include_dirs.extend(py_include.split(os.path.pathsep))
if plat_py_include != py_include:
self.include_dirs.extend(plat_py_include.split(os.path.pathsep))
self.ensure_string_list('libraries')
self.ensure_string_list('link_objects')
# Life is easier if we're not forever checking for None, so
# simplify these options to empty lists if unset
if self.libraries is None:
self.libraries = []
if self.library_dirs is None:
self.library_dirs = []
elif isinstance(self.library_dirs, str):
self.library_dirs = self.library_dirs.split(os.pathsep)
if self.rpath is None:
self.rpath = []
elif isinstance(self.rpath, str):
self.rpath = self.rpath.split(os.pathsep)
# for extensions under windows use different directories
# for Release and Debug builds.
# also Python's library directory must be appended to library_dirs
if os.name == 'nt':
# the 'libs' directory is for binary installs - we assume that
# must be the *native* platform. But we don't really support
# cross-compiling via a binary install anyway, so we let it go.
self.library_dirs.append(os.path.join(sys.exec_prefix, 'libs'))
if sys.base_exec_prefix != sys.prefix: # Issue 16116
self.library_dirs.append(
os.path.join(sys.base_exec_prefix, 'libs'))
if self.debug:
self.build_temp = os.path.join(self.build_temp, "Debug")
else:
self.build_temp = os.path.join(self.build_temp, "Release")
# Append the source distribution include and library directories,
# this allows distutils on windows to work in the source tree
self.include_dirs.append(os.path.dirname(get_config_h_filename()))
_sys_home = getattr(sys, '_home', None)
if _sys_home:
self.library_dirs.append(_sys_home)
# Use the .lib files for the correct architecture
if self.plat_name == 'win32':
suffix = 'win32'
else:
# win-amd64
suffix = self.plat_name[4:]
new_lib = os.path.join(sys.exec_prefix, 'PCbuild')
if suffix:
new_lib = os.path.join(new_lib, suffix)
self.library_dirs.append(new_lib)
# For extensions under Cygwin, Python's library directory must be
# appended to library_dirs
if sys.platform[:6] == 'cygwin':
if sys.executable.startswith(os.path.join(sys.exec_prefix, "bin")):
# building third party extensions
self.library_dirs.append(
os.path.join(sys.prefix, "lib",
"python" + get_python_version(), "config"))
else:
# building python standard extensions
self.library_dirs.append('.')
# For building extensions with a shared Python library,
# Python's library directory must be appended to library_dirs
# See Issues: #1600860, #4366
if (sysconfig.get_config_var('Py_ENABLE_SHARED')):
if not sysconfig.python_build:
# building third party extensions
self.library_dirs.append(sysconfig.get_config_var('LIBDIR'))
else:
# building python standard extensions
self.library_dirs.append('.')
# 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 will be set to '1'. Multiple
# symbols can be separated with commas.
if self.define:
defines = self.define.split(',')
self.define = [(symbol, '1') for symbol in defines]
# The option for macros to undefine is also a string from the
# option parsing, but has to be a list. Multiple symbols can also
# be separated with commas here.
if self.undef:
self.undef = self.undef.split(',')
if self.swig_opts is None:
self.swig_opts = []
else:
self.swig_opts = self.swig_opts.split(' ')
# Finally add the user include and library directories if requested
if self.user:
user_include = os.path.join(USER_BASE, "include")
user_lib = os.path.join(USER_BASE, "lib")
if os.path.isdir(user_include):
self.include_dirs.append(user_include)
if os.path.isdir(user_lib):
self.library_dirs.append(user_lib)
self.rpath.append(user_lib)
if isinstance(self.parallel, str):
try:
self.parallel = int(self.parallel)
except ValueError:
raise DistutilsOptionError("parallel should be an integer")
def install(self,
install_options,
global_options=[],
root=None,
prefix=None,
strip_file_prefix=None):
if self.editable:
self.install_editable(install_options,
global_options,
prefix=prefix)
return
if self.is_wheel:
version = pip.wheel.wheel_version(self.source_dir)
pip.wheel.check_compatibility(version, self.name)
self.move_wheel_files(self.source_dir,
root=root,
prefix=prefix,
strip_file_prefix=strip_file_prefix)
self.install_succeeded = True
return
# Extend the list of global and install options passed on to
# the setup.py call with the ones from the requirements file.
# Options specified in requirements file override those
# specified on the command line, since the last option given
# to setup.py is the one that is used.
global_options += self.options.get('global_options', [])
install_options += self.options.get('install_options', [])
if self.isolated:
global_options = list(global_options) + ["--no-user-cfg"]
temp_location = tempfile.mkdtemp('-record', 'pip-')
record_filename = os.path.join(temp_location, 'install-record.txt')
try:
install_args = [sys.executable, "-u"]
install_args.append('-c')
install_args.append(SETUPTOOLS_SHIM % self.setup_py)
install_args += list(global_options) + \
['install', '--record', record_filename]
if not self.as_egg:
install_args += ['--single-version-externally-managed']
if root is not None:
install_args += ['--root', root]
if prefix is not None:
install_args += ['--prefix', prefix]
if self.pycompile:
install_args += ["--compile"]
else:
install_args += ["--no-compile"]
if running_under_virtualenv():
py_ver_str = 'python' + sysconfig.get_python_version()
install_args += [
'--install-headers',
os.path.join(sys.prefix, 'include', 'site', py_ver_str,
self.name)
]
msg = 'Running setup.py install for %s' % (self.name, )
with open_spinner(msg) as spinner:
with indent_log():
call_subprocess(
install_args + install_options,
cwd=self.source_dir,
show_stdout=False,
spinner=spinner,
)
if not os.path.exists(record_filename):
logger.debug('Record file %s not found', record_filename)
return
self.install_succeeded = True
if self.as_egg:
# there's no --always-unzip option we can pass to install
# command so we unable to save the installed-files.txt
return
def prepend_root(path):
if root is None or not os.path.isabs(path):
return path
else:
return change_root(root, path)
with open(record_filename) as f:
for line in f:
directory = os.path.dirname(line)
if directory.endswith('.egg-info'):
egg_info_dir = prepend_root(directory)
break
else:
logger.warning(
'Could not find .egg-info directory in install record'
' for %s',
self,
)
# FIXME: put the record somewhere
# FIXME: should this be an error?
return
new_lines = []
with open(record_filename) as f:
for line in f:
filename = line.strip()
if os.path.isdir(filename):
filename += os.path.sep
new_lines.append(
os.path.relpath(prepend_root(filename), egg_info_dir))
inst_files_path = os.path.join(egg_info_dir, 'installed-files.txt')
with open(inst_files_path, 'w') as f:
f.write('\n'.join(new_lines) + '\n')
finally:
if os.path.exists(record_filename):
os.remove(record_filename)
rmtree(temp_location)
def finalize_options(self):
from distutils import sysconfig
self.set_undefined_options('build', ('build_lib', 'build_lib'),
('build_temp', 'build_temp'),
('compiler', 'compiler'),
('debug', 'debug'), ('force', 'force'),
('parallel', 'parallel'),
('plat_name', 'plat_name'))
if self.package is None:
self.package = self.distribution.ext_package
self.extensions = self.distribution.ext_modules
py_include = sysconfig.get_python_inc()
plat_py_include = sysconfig.get_python_inc(plat_specific=1)
if self.include_dirs is None:
self.include_dirs = self.distribution.include_dirs or []
if isinstance(self.include_dirs, str):
self.include_dirs = self.include_dirs.split(os.pathsep)
if sys.exec_prefix != sys.base_exec_prefix:
self.include_dirs.append(os.path.join(sys.exec_prefix, 'include'))
self.include_dirs.append(py_include)
if plat_py_include != py_include:
self.include_dirs.append(plat_py_include)
self.ensure_string_list('libraries')
self.ensure_string_list('link_objects')
if self.libraries is None:
self.libraries = []
if self.library_dirs is None:
self.library_dirs = []
elif isinstance(self.library_dirs, str):
self.library_dirs = self.library_dirs.split(os.pathsep)
if self.rpath is None:
self.rpath = []
elif isinstance(self.rpath, str):
self.rpath = self.rpath.split(os.pathsep)
if os.name == 'nt':
self.library_dirs.append(os.path.join(sys.exec_prefix, 'libs'))
if sys.base_exec_prefix != sys.prefix:
self.library_dirs.append(
os.path.join(sys.base_exec_prefix, 'libs'))
if self.debug:
self.build_temp = os.path.join(self.build_temp, 'Debug')
else:
self.build_temp = os.path.join(self.build_temp, 'Release')
self.include_dirs.append(os.path.dirname(get_config_h_filename()))
_sys_home = getattr(sys, '_home', None)
if _sys_home:
self.library_dirs.append(_sys_home)
if self.plat_name == 'win32':
suffix = 'win32'
else:
suffix = self.plat_name[4:]
new_lib = os.path.join(sys.exec_prefix, 'PCbuild')
if suffix:
new_lib = os.path.join(new_lib, suffix)
self.library_dirs.append(new_lib)
if sys.platform[:6] == 'cygwin' or sys.platform[:6] == 'atheos':
if sys.executable.startswith(os.path.join(sys.exec_prefix, 'bin')):
self.library_dirs.append(
os.path.join(sys.prefix, 'lib',
'python' + get_python_version(), 'config'))
else:
self.library_dirs.append('.')
if sysconfig.get_config_var('Py_ENABLE_SHARED'):
if not sysconfig.python_build:
self.library_dirs.append(sysconfig.get_config_var('LIBDIR'))
else:
self.library_dirs.append('.')
if self.define:
defines = self.define.split(',')
self.define = [(symbol, '1') for symbol in defines]
if self.undef:
self.undef = self.undef.split(',')
if self.swig_opts is None:
self.swig_opts = []
else:
self.swig_opts = self.swig_opts.split(' ')
if self.user:
user_include = os.path.join(USER_BASE, 'include')
user_lib = os.path.join(USER_BASE, 'lib')
if os.path.isdir(user_include):
self.include_dirs.append(user_include)
if os.path.isdir(user_lib):
self.library_dirs.append(user_lib)
self.rpath.append(user_lib)
if isinstance(self.parallel, str):
try:
self.parallel = int(self.parallel)
except ValueError:
raise DistutilsOptionError('parallel should be an integer')
from distutils.sysconfig import get_python_version
if 'QUIP_ROOT' in os.environ:
quip_root = os.environ['QUIP_ROOT']
else:
quip_root = os.path.join(os.getcwd(), '..')
try:
quip_arch = os.environ['QUIP_ARCH']
except KeyError:
raise RuntimeError(
'You need to define the architecture using the QUIP_ARCH variable. Check out the arch/ subdirectory.'
)
print('QUIP_ARCH', quip_arch)
platform = '{0}-{1}'.format(get_platform(), get_python_version())
print('platform', platform)
# extend sys.path
print(os.path.join(quip_root, 'build/{0}/'.format(quip_arch)))
sys.path.insert(0, os.path.join(quip_root, 'build/{0}/'.format(quip_arch)))
import quippy
print('Successfully imported quippy3')
# find tests and run them
# ONLY RUNS ONE NOW, THE ONE THAT IS DONE
suite = unittest.defaultTestLoader.discover(
os.getcwd()) # fixme run all tests not just one
unittest.TextTestRunner().run(suite)
def finalize_options (self):
from distutils import sysconfig
self.set_undefined_options('build',
('build_lib', 'build_lib'),
('build_temp', 'build_temp'),
('compiler', 'compiler'),
('debug', 'debug'),
('force', 'force'))
if self.package is None:
self.package = self.distribution.ext_package
self.extensions = self.distribution.ext_modules
# Make sure Python's include directories (for Python.h, pyconfig.h,
# etc.) are in the include search path.
py_include = sysconfig.get_python_inc()
plat_py_include = sysconfig.get_python_inc(plat_specific=1)
if self.include_dirs is None:
self.include_dirs = self.distribution.include_dirs or []
if type(self.include_dirs) is StringType:
self.include_dirs = string.split(self.include_dirs, os.pathsep)
# Put the Python "system" include dir at the end, so that
# any local include dirs take precedence.
self.include_dirs.append(py_include)
if plat_py_include != py_include:
self.include_dirs.append(plat_py_include)
if type(self.libraries) is StringType:
self.libraries = [self.libraries]
# Life is easier if we're not forever checking for None, so
# simplify these options to empty lists if unset
if self.libraries is None:
self.libraries = []
if self.library_dirs is None:
self.library_dirs = []
elif type(self.library_dirs) is StringType:
self.library_dirs = string.split(self.library_dirs, os.pathsep)
if self.rpath is None:
self.rpath = []
elif type(self.rpath) is StringType:
self.rpath = string.split(self.rpath, os.pathsep)
# for extensions under windows use different directories
# for Release and Debug builds.
# also Python's library directory must be appended to library_dirs
if os.name == 'nt':
self.library_dirs.append(os.path.join(sys.exec_prefix, 'libs'))
if self.debug:
self.build_temp = os.path.join(self.build_temp, "Debug")
else:
self.build_temp = os.path.join(self.build_temp, "Release")
# Append the source distribution include and library directories,
# this allows distutils on windows to work in the source tree
self.include_dirs.append(os.path.join(sys.exec_prefix, 'PC'))
self.library_dirs.append(os.path.join(sys.exec_prefix, 'PCBuild'))
# OS/2 (EMX) doesn't support Debug vs Release builds, but has the
# import libraries in its "Config" subdirectory
if os.name == 'os2':
self.library_dirs.append(os.path.join(sys.exec_prefix, 'Config'))
# for extensions under Cygwin and AtheOS Python's library directory must be
# appended to library_dirs
if sys.platform[:6] == 'cygwin' or sys.platform[:6] == 'atheos':
if string.find(sys.executable, sys.exec_prefix) != -1:
# building third party extensions
self.library_dirs.append(os.path.join(sys.prefix, "lib",
"python" + get_python_version(),
"config"))
else:
# building python standard extensions
self.library_dirs.append('.')
# 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 will be set to '1'. Multiple
# symbols can be separated with commas.
if self.define:
defines = string.split(self.define, ',')
self.define = map(lambda symbol: (symbol, '1'), defines)
# The option for macros to undefine is also a string from the
# option parsing, but has to be a list. Multiple symbols can also
# be separated with commas here.
if self.undef:
self.undef = string.split(self.undef, ',')
def finalize_options(self):
from distutils import sysconfig
self.set_undefined_options('build',
('build_lib', 'build_lib'),
('build_temp', 'build_temp'),
('compiler', 'compiler'),
('debug', 'debug'),
('force', 'force'),
('plat_name', 'plat_name'),
)
if self.package is None:
self.package = self.distribution.ext_package
self.extensions = self.distribution.ext_modules
# Make sure Python's include directories (for Python.h, pyconfig.h,
# etc.) are in the include search path.
py_include = sysconfig.get_python_inc()
plat_py_include = sysconfig.get_python_inc(plat_specific=1)
if self.include_dirs is None:
self.include_dirs = self.distribution.include_dirs or []
if isinstance(self.include_dirs, str):
self.include_dirs = self.include_dirs.split(os.pathsep)
# Put the Python "system" include dir at the end, so that
# any local include dirs take precedence.
self.include_dirs.append(py_include)
if plat_py_include != py_include:
self.include_dirs.append(plat_py_include)
self.ensure_string_list('libraries')
self.ensure_string_list('link_objects')
# Life is easier if we're not forever checking for None, so
# simplify these options to empty lists if unset
if self.libraries is None:
self.libraries = []
if self.library_dirs is None:
self.library_dirs = []
elif type(self.library_dirs) is StringType:
self.library_dirs = string.split(self.library_dirs, os.pathsep)
if self.rpath is None:
self.rpath = []
elif type(self.rpath) is StringType:
self.rpath = string.split(self.rpath, os.pathsep)
# for extensions under windows use different directories
# for Release and Debug builds.
# also Python's library directory must be appended to library_dirs
if os.name == 'nt':
# the 'libs' directory is for binary installs - we assume that
# must be the *native* platform. But we don't really support
# cross-compiling via a binary install anyway, so we let it go.
self.library_dirs.append(os.path.join(sys.exec_prefix, 'libs'))
if self.debug:
self.build_temp = os.path.join(self.build_temp, "Debug")
else:
self.build_temp = os.path.join(self.build_temp, "Release")
# Append the source distribution include and library directories,
# this allows distutils on windows to work in the source tree
self.include_dirs.append(os.path.join(sys.exec_prefix, 'PC'))
if MSVC_VERSION >= 9:
# Use the .lib files for the correct architecture
if self.plat_name == 'win32':
suffix = 'win32'
else:
# win-amd64 or win-ia64
suffix = self.plat_name[4:]
if MSVC_VERSION >= 14:
ldir = os.path.join(sys.exec_prefix, 'PCbuild')
if suffix != 'win32':
ldir = os.path.join(ldir, suffix)
self.library_dirs.append(ldir)
else:
# We could have been built in one of two places; add both
for d in ('PCbuild',), ('PC', 'VS9.0'):
new_lib = os.path.join(sys.exec_prefix, *d)
if suffix:
new_lib = os.path.join(new_lib, suffix)
self.library_dirs.append(new_lib)
elif MSVC_VERSION == 8:
self.library_dirs.append(os.path.join(sys.exec_prefix,
'PC', 'VS8.0'))
elif MSVC_VERSION == 7:
self.library_dirs.append(os.path.join(sys.exec_prefix,
'PC', 'VS7.1'))
else:
self.library_dirs.append(os.path.join(sys.exec_prefix,
'PC', 'VC6'))
# OS/2 (EMX) doesn't support Debug vs Release builds, but has the
# import libraries in its "Config" subdirectory
if os.name == 'os2':
self.library_dirs.append(os.path.join(sys.exec_prefix, 'Config'))
# for extensions under Cygwin and AtheOS Python's library directory must be
# appended to library_dirs
if sys.platform[:6] == 'cygwin' or sys.platform[:6] == 'atheos':
if sys.executable.startswith(os.path.join(sys.exec_prefix, "bin")):
# building third party extensions
self.library_dirs.append(os.path.join(sys.prefix, "lib",
"python" + get_python_version(),
"config"))
else:
# building python standard extensions
self.library_dirs.append('.')
# For building extensions with a shared Python library,
# Python's library directory must be appended to library_dirs
# See Issues: #1600860, #4366
if (sysconfig.get_config_var('Py_ENABLE_SHARED')):
if not sysconfig.python_build:
# building third party extensions
self.library_dirs.append(sysconfig.get_config_var('LIBDIR'))
else:
# building python standard extensions
self.library_dirs.append('.')
# 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 will be set to '1'. Multiple
# symbols can be separated with commas.
if self.define:
defines = self.define.split(',')
self.define = map(lambda symbol: (symbol, '1'), defines)
# The option for macros to undefine is also a string from the
# option parsing, but has to be a list. Multiple symbols can also
# be separated with commas here.
if self.undef:
self.undef = self.undef.split(',')
if self.swig_opts is None:
self.swig_opts = []
else:
self.swig_opts = self.swig_opts.split(' ')
# Finally add the user include and library directories if requested
if self.user:
user_include = os.path.join(USER_BASE, "include")
user_lib = os.path.join(USER_BASE, "lib")
if os.path.isdir(user_include):
self.include_dirs.append(user_include)
if os.path.isdir(user_lib):
self.library_dirs.append(user_lib)
self.rpath.append(user_lib)
def build_dlib():
"""use cmake to build and install the extension
"""
if cmake_path is None:
raise DistutilsSetupError("Cannot find cmake in the path. Please specify its path with --cmake parameter.")
platform_arch = platform.architecture()[0]
log.info("Detected Python architecture: %s" % platform_arch)
# make sure build artifacts are generated for the version of Python currently running
cmake_extra_arch = []
if sys.version_info >= (3, 0):
cmake_extra_arch += ['-DPYTHON3=yes']
if platform_arch == '64bit' and sys.platform == "win32":
# 64bit build on Windows
if not generator_set:
# see if we can deduce the 64bit default generator
cmake_extra_arch += get_msvc_win64_generator()
# help cmake to find Python library in 64bit Python in Windows
# because cmake is 32bit and cannot find PYTHON_LIBRARY from registry.
inc_dir = get_python_inc()
cmake_extra_arch += ['-DPYTHON_INCLUDE_DIR={inc}'.format(inc=inc_dir)]
# this imitates cmake in path resolution
py_ver = get_python_version()
for ext in [py_ver.replace(".", "") + '.lib', py_ver + 'mu.lib', py_ver + 'm.lib', py_ver + 'u.lib']:
py_lib = os.path.abspath(os.path.join(inc_dir, '../libs/', 'python' + ext))
if os.path.exists(py_lib):
cmake_extra_arch += ['-DPYTHON_LIBRARY={lib}'.format(lib=py_lib)]
break
build_dir = os.path.join(script_dir, "./tools/python/build")
if os.path.exists(build_dir):
log.info('Removing build directory %s' % build_dir)
rmtree(build_dir)
try:
os.makedirs(build_dir)
except OSError:
pass
# cd build
os.chdir(build_dir)
log.info('Configuring cmake ...')
cmake_cmd = [
cmake_path,
"..",
] + cmake_extra + cmake_extra_arch
if run_process(cmake_cmd):
raise DistutilsSetupError("cmake configuration failed!")
log.info('Build using cmake ...')
cmake_cmd = [
cmake_path,
"--build", ".",
"--config", cmake_config,
"--target", "install",
]
if run_process(cmake_cmd):
raise DistutilsSetupError("cmake build failed!")
# cd back where setup awaits
os.chdir(script_dir)
def run(self):
if DEBUG:
print("before _get_package_data():")
print("vendor =", self.vendor)
print("packager =", self.packager)
print("doc_files =", self.doc_files)
print("changelog =", self.changelog)
# make directories
if self.spec_only:
spec_dir = self.dist_dir
self.mkpath(spec_dir)
else:
rpm_dir = {}
for d in ('SOURCES', 'SPECS', 'BUILD', 'RPMS', 'SRPMS'):
rpm_dir[d] = os.path.join(self.rpm_base, d)
self.mkpath(rpm_dir[d])
spec_dir = rpm_dir['SPECS']
# Spec file goes into 'dist_dir' if '--spec-only specified',
# build/rpm.<plat> otherwise.
spec_path = os.path.join(spec_dir,
"%s.spec" % self.distribution.get_name())
self.execute(write_file, (spec_path, self._make_spec_file()),
"writing '%s'" % spec_path)
if self.spec_only: # stop if requested
return
# Make a source distribution and copy to SOURCES directory with
# optional icon.
saved_dist_files = self.distribution.dist_files[:]
sdist = self.reinitialize_command('sdist')
if self.use_bzip2:
sdist.formats = ['bztar']
else:
sdist.formats = ['gztar']
self.run_command('sdist')
self.distribution.dist_files = saved_dist_files
source = sdist.get_archive_files()[0]
source_dir = rpm_dir['SOURCES']
self.copy_file(source, source_dir)
if self.icon:
if os.path.exists(self.icon):
self.copy_file(self.icon, source_dir)
else:
raise DistutilsFileError("icon file '%s' does not exist" %
self.icon)
# build package
log.info("building RPMs")
rpm_cmd = ['rpm']
if os.path.exists('/usr/bin/rpmbuild') or \
os.path.exists('/bin/rpmbuild'):
rpm_cmd = ['rpmbuild']
if self.source_only: # what kind of RPMs?
rpm_cmd.append('-bs')
elif self.binary_only:
rpm_cmd.append('-bb')
else:
rpm_cmd.append('-ba')
if self.rpm3_mode:
rpm_cmd.extend(
['--define',
'_topdir %s' % os.path.abspath(self.rpm_base)])
if not self.keep_temp:
rpm_cmd.append('--clean')
if self.quiet:
rpm_cmd.append('--quiet')
rpm_cmd.append(spec_path)
# Determine the binary rpm names that should be built out of this spec
# file
# Note that some of these may not be really built (if the file
# list is empty)
nvr_string = "%{name}-%{version}-%{release}"
src_rpm = nvr_string + ".src.rpm"
non_src_rpm = "%{arch}/" + nvr_string + ".%{arch}.rpm"
q_cmd = r"rpm -q --qf '%s %s\n' --specfile '%s'" % (
src_rpm, non_src_rpm, spec_path)
out = os.popen(q_cmd)
try:
binary_rpms = []
source_rpm = None
while True:
line = out.readline()
if not line:
break
l = line.strip().split()
assert (len(l) == 2)
binary_rpms.append(l[1])
# The source rpm is named after the first entry in the spec file
if source_rpm is None:
source_rpm = l[0]
status = out.close()
if status:
raise DistutilsExecError("Failed to execute: %s" % repr(q_cmd))
finally:
out.close()
self.spawn(rpm_cmd)
if not self.dry_run:
if self.distribution.has_ext_modules():
pyversion = get_python_version()
else:
pyversion = 'any'
if not self.binary_only:
srpm = os.path.join(rpm_dir['SRPMS'], source_rpm)
assert (os.path.exists(srpm))
self.move_file(srpm, self.dist_dir)
filename = os.path.join(self.dist_dir, source_rpm)
self.distribution.dist_files.append(
('bdist_rpm', pyversion, filename))
if not self.source_only:
for rpm in binary_rpms:
rpm = os.path.join(rpm_dir['RPMS'], rpm)
if os.path.exists(rpm):
self.move_file(rpm, self.dist_dir)
filename = os.path.join(self.dist_dir,
os.path.basename(rpm))
self.distribution.dist_files.append(
('bdist_rpm', pyversion, filename))
def build_dlib():
"""use cmake to build and install the extension
"""
if cmake_path is None:
cmake_install_url = "https://cmake.org/install/"
message = ("You can install cmake using the instructions at " +
cmake_install_url)
msg_pkgmanager = ("You can install cmake on {0} using "
"`sudo {1} install cmake`.")
if sys.platform == "darwin":
pkgmanagers = ('brew', 'port')
for manager in pkgmanagers:
if find_executable(manager) is not None:
message = msg_pkgmanager.format('OSX', manager)
break
elif sys.platform.startswith('linux'):
try:
import distro
except ImportError as err:
import pip
pip_exit = pip.main(['install', '-q', 'distro'])
if pip_exit > 0:
log.debug("Unable to install `distro` to identify "
"the recommended command. Falling back "
"to default error message.")
distro = err
else:
import distro
if not isinstance(distro, ImportError):
distname = distro.id()
if distname in ('debian', 'ubuntu'):
message = msg_pkgmanager.format(
distname.title(), 'apt-get')
elif distname in ('fedora', 'centos', 'redhat'):
pkgmanagers = ("dnf", "yum")
for manager in pkgmanagers:
if find_executable(manager) is not None:
message = msg_pkgmanager.format(
distname.title(), manager)
break
raise DistutilsSetupError(
"Cannot find cmake, ensure it is installed and in the path.\n"
+ message + "\n"
"You can also specify its path with --cmake parameter.")
platform_arch = platform.architecture()[0]
log.info("Detected Python architecture: %s" % platform_arch)
# make sure build artifacts are generated for the version of Python currently running
cmake_extra_arch = []
inc_dir = get_python_inc()
lib_dir = get_config_var('LIBDIR')
if (inc_dir != None):
cmake_extra_arch += ['-DPYTHON_INCLUDE_DIR=' + inc_dir]
if (lib_dir != None):
cmake_extra_arch += ['-DCMAKE_LIBRARY_PATH=' + lib_dir]
if sys.version_info >= (3, 0):
cmake_extra_arch += ['-DPYTHON3=yes']
log.info("Detected platform: %s" % sys.platform)
if sys.platform == "darwin":
# build on OS X
# by default, cmake will choose the system python lib in /usr/lib
# this checks the sysconfig and will correctly pick up a brewed python lib
# e.g. in /usr/local/Cellar
py_ver = get_python_version()
# check: in some virtual environments the libpython has the form "libpython_#m.dylib
py_lib = os.path.join(get_config_var('LIBDIR'),
'libpython' + py_ver + '.dylib')
if not os.path.isfile(py_lib):
py_lib = os.path.join(get_config_var('LIBDIR'),
'libpython' + py_ver + 'm.dylib')
cmake_extra_arch += ['-DPYTHON_LIBRARY={lib}'.format(lib=py_lib)]
if sys.platform == "win32":
if platform_arch == '64bit':
cmake_extra_arch += ['-DCMAKE_GENERATOR_PLATFORM=x64']
# Setting the cmake generator only works in versions of cmake >= 3.1
if (LooseVersion(get_cmake_version(cmake_path)) <
LooseVersion("3.1.0")):
raise DistutilsSetupError(
"You need to install a newer version of cmake. Version 3.1 or newer is required."
)
# this imitates cmake in path resolution
py_ver = get_python_version()
for ext in [
py_ver.replace(".", "") + '.lib', py_ver + 'mu.lib',
py_ver + 'm.lib', py_ver + 'u.lib'
]:
py_lib = os.path.abspath(
os.path.join(inc_dir, '../libs/', 'python' + ext))
if os.path.exists(py_lib):
cmake_extra_arch += [
'-DPYTHON_LIBRARY={lib}'.format(lib=py_lib)
]
break
build_dir = os.path.join(script_dir, "./tools/python/build")
if os.path.exists(build_dir):
log.info('Removing build directory %s' % build_dir)
rmtree(build_dir)
try:
os.makedirs(build_dir)
except OSError:
pass
# cd build
os.chdir(build_dir)
log.info('Configuring cmake ...')
cmake_cmd = [
cmake_path,
"..",
] + cmake_extra + cmake_extra_arch
if run_process(cmake_cmd):
raise DistutilsSetupError("cmake configuration failed!")
log.info('Build using cmake ...')
cmake_cmd = [
cmake_path,
"--build",
".",
"--config",
cmake_config,
"--target",
"install",
]
if run_process(cmake_cmd):
raise DistutilsSetupError("cmake build failed!")
# cd back where setup awaits
os.chdir(script_dir)
def run(self):
if DEBUG:
print "before _get_package_data():"
print "vendor =", self.vendor
print "packager =", self.packager
print "doc_files =", self.doc_files
print "changelog =", self.changelog
# make directories
if self.spec_only:
spec_dir = self.dist_dir
self.mkpath(spec_dir)
else:
rpm_dir = {}
for d in ('SOURCES', 'SPECS', 'BUILD', 'RPMS', 'SRPMS'):
rpm_dir[d] = os.path.join(self.rpm_base, d)
self.mkpath(rpm_dir[d])
spec_dir = rpm_dir['SPECS']
# Spec file goes into 'dist_dir' if '--spec-only specified',
# build/rpm.<plat> otherwise.
spec_path = os.path.join(spec_dir,
"%s.spec" % self.distribution.get_name())
self.execute(write_file, (spec_path, self._make_spec_file()),
"writing '%s'" % spec_path)
if self.spec_only: # stop if requested
return
# Make a source distribution and copy to SOURCES directory with
# optional icon.
saved_dist_files = self.distribution.dist_files[:]
sdist = self.reinitialize_command('sdist')
if self.use_bzip2:
sdist.formats = ['bztar']
else:
sdist.formats = ['gztar']
self.run_command('sdist')
self.distribution.dist_files = saved_dist_files
source = sdist.get_archive_files()[0]
source_dir = rpm_dir['SOURCES']
self.copy_file(source, source_dir)
if self.icon:
if os.path.exists(self.icon):
self.copy_file(self.icon, source_dir)
else:
raise DistutilsFileError, \
"icon file '%s' does not exist" % self.icon
# build package
log.info("building RPMs")
rpm_cmd = ['rpm']
if os.path.exists('/usr/bin/rpmbuild') or \
os.path.exists('/bin/rpmbuild'):
rpm_cmd = ['rpmbuild']
if self.source_only: # what kind of RPMs?
rpm_cmd.append('-bs')
elif self.binary_only:
rpm_cmd.append('-bb')
else:
rpm_cmd.append('-ba')
if self.rpm3_mode:
rpm_cmd.extend(
['--define',
'_topdir %s' % os.path.abspath(self.rpm_base)])
if not self.keep_temp:
rpm_cmd.append('--clean')
rpm_cmd.append(spec_path)
self.spawn(rpm_cmd)
# XXX this is a nasty hack -- we really should have a proper way to
# find out the names of the RPM files created; also, this assumes
# that RPM creates exactly one source and one binary RPM.
if not self.dry_run:
if not self.binary_only:
srpms = glob.glob(os.path.join(rpm_dir['SRPMS'], "*.rpm"))
assert len(srpms) == 1, \
"unexpected number of SRPM files found: %s" % srpms
dist_file = ('bdist_rpm', 'any', self._dist_path(srpms[0]))
self.distribution.dist_files.append(dist_file)
self.move_file(srpms[0], self.dist_dir)
if not self.source_only:
rpms = glob.glob(os.path.join(rpm_dir['RPMS'], "*/*.rpm"))
debuginfo = glob.glob(
os.path.join(rpm_dir['RPMS'], "*/*debuginfo*.rpm"))
if debuginfo:
rpms.remove(debuginfo[0])
assert len(rpms) == 1, \
"unexpected number of RPM files found: %s" % rpms
dist_file = ('bdist_rpm', get_python_version(),
self._dist_path(rpms[0]))
self.distribution.dist_files.append(dist_file)
self.move_file(rpms[0], self.dist_dir)
if debuginfo:
dist_file = ('bdist_rpm', get_python_version(),
self._dist_path(debuginfo[0]))
self.move_file(debuginfo[0], self.dist_dir)
# Notes about STD_LIB_DIR
# Consider arch-specific installation for STD_LIB_DIR definition
# :mod:`distutils.sysconfig` contains to much hardcoded values to rely on
#
# :see: `Problems with /usr/lib64 builds <http://bugs.python.org/issue1294959>`_
# :see: `FHS <http://www.pathname.com/fhs/pub/fhs-2.3.html#LIBLTQUALGTALTERNATEFORMATESSENTIAL>`_
if sys.platform.startswith('win'):
PY_SOURCE_EXTS = ('py', 'pyw')
PY_COMPILED_EXTS = ('dll', 'pyd')
STD_LIB_DIR = get_python_lib(standard_lib=1)
else:
PY_SOURCE_EXTS = ('py', )
PY_COMPILED_EXTS = ('so', )
# extend lib dir with some arch-dependant paths
STD_LIB_DIR = join(get_config_var("LIBDIR"),
"python%s" % get_python_version())
BUILTIN_MODULES = dict(
zip(sys.builtin_module_names, [1] * len(sys.builtin_module_names)))
class NoSourceFile(Exception):
"""exception raised when we are not able to get a python
source file for a precompiled file
"""
class LazyObject(object):
def __init__(self, module, obj):
self.module = module
self.obj = obj
def init_env():
from setup.build_environment import msvc, is64bit, win_inc, win_lib, NMAKE
from distutils import sysconfig
linker = None
if isunix:
cc = os.environ.get('CC', 'gcc')
cxx = os.environ.get('CXX', 'g++')
debug = ''
# debug = '-ggdb'
cflags = os.environ.get(
'OVERRIDE_CFLAGS',
'-Wall -DNDEBUG %s -fno-strict-aliasing -pipe' % debug)
cflags = shlex.split(cflags) + ['-fPIC']
ldflags = os.environ.get('OVERRIDE_LDFLAGS', '-Wall')
ldflags = shlex.split(ldflags)
cflags += shlex.split(os.environ.get('CFLAGS', ''))
ldflags += shlex.split(os.environ.get('LDFLAGS', ''))
cflags += ['-fvisibility=hidden']
if islinux:
cflags.append('-pthread')
ldflags.append('-shared')
cflags.append('-I' + sysconfig.get_python_inc())
ldflags.append('-lpython' + sysconfig.get_python_version())
if isbsd:
cflags.append('-pthread')
ldflags.append('-shared')
cflags.append('-I' + sysconfig.get_python_inc())
ldflags.append('-lpython' + sysconfig.get_python_version())
if ishaiku:
cflags.append('-lpthread')
ldflags.append('-shared')
cflags.append('-I' + sysconfig.get_python_inc())
ldflags.append('-lpython' + sysconfig.get_python_version())
if isosx:
cflags.append('-D_OSX')
ldflags.extend('-bundle -undefined dynamic_lookup'.split())
cflags.extend(['-fno-common', '-dynamic'])
cflags.append('-I' + sysconfig.get_python_inc())
if iswindows:
cc = cxx = msvc.cc
cflags = '/c /nologo /MD /W3 /EHsc /DNDEBUG'.split()
ldflags = '/DLL /nologo /INCREMENTAL:NO /NODEFAULTLIB:libcmt.lib'.split(
)
# cflags = '/c /nologo /Ox /MD /W3 /EHsc /Zi'.split()
# ldflags = '/DLL /nologo /INCREMENTAL:NO /DEBUG'.split()
if is64bit:
cflags.append('/GS-')
for p in win_inc:
cflags.append('-I' + p)
for p in win_lib:
ldflags.append('/LIBPATH:' + p)
cflags.append('-I%s' % sysconfig.get_python_inc())
ldflags.append('/LIBPATH:' + os.path.join(sysconfig.PREFIX, 'libs'))
linker = msvc.linker
return namedtuple('Environment', 'cc cxx cflags ldflags linker make')(
cc=cc,
cxx=cxx,
cflags=cflags,
ldflags=ldflags,
linker=linker,
make=NMAKE if iswindows else 'make')
def get_boost_config_path(self):
return os.path.join(
self.omim_builddir,
'python{}-config.jam'.format(get_python_version()),
)
# Copyright (C) 2009, 2010, 2011, 2012, 2013
# David Aguilar <*****@*****.**>
"""Provides the main() routine and ColaApplicaiton"""
from __future__ import division, absolute_import, unicode_literals
import argparse
import glob
import os
import signal
import sys
# Make homebrew work by default
if sys.platform == 'darwin':
from distutils import sysconfig
python_version = sysconfig.get_python_version()
homebrew_mods = '/usr/local/lib/python%s/site-packages' % python_version
if os.path.isdir(homebrew_mods):
sys.path.append(homebrew_mods)
import sip
sip.setapi('QString', 1)
sip.setapi('QDate', 1)
sip.setapi('QDateTime', 1)
sip.setapi('QTextStream', 1)
sip.setapi('QTime', 1)
sip.setapi('QUrl', 1)
sip.setapi('QVariant', 1)
try:
from PyQt4 import QtGui
from PyQt4 import QtCore
def get_exe_bytes(self):
# If a target-version other than the current version has been
# specified, then using the MSVC version from *this* build is no good.
# Without actually finding and executing the target version and parsing
# its sys.version, we just hard-code our knowledge of old versions.
# NOTE: Possible alternative is to allow "--target-version" to
# specify a Python executable rather than a simple version string.
# We can then execute this program to obtain any info we need, such
# as the real sys.version string for the build.
cur_version = get_python_version()
# If the target version is *later* than us, then we assume they
# use what we use
# string compares seem wrong, but are what sysconfig.py itself uses
if self.target_version and self.target_version < cur_version:
if self.target_version < "2.4":
bv = '6.0'
elif self.target_version == "2.4":
bv = '7.1'
elif self.target_version == "2.5":
bv = '8.0'
elif self.target_version <= "3.2":
bv = '9.0'
elif self.target_version <= "3.4":
bv = '10.0'
else:
bv = '14.0'
else:
# for current version - use authoritative check.
try:
from msvcrt import CRT_ASSEMBLY_VERSION
except ImportError:
# cross-building, so assume the latest version
bv = '14.0'
else:
bv = '.'.join(CRT_ASSEMBLY_VERSION.split('.', 2)[:2])
if bv == '14.11':
# v141 and v140 are binary compatible,
# so keep using the 14.0 stub.
bv = '14.0'
# wininst-x.y.exe is in the same directory as this file
directory = os.path.dirname(__file__)
# we must use a wininst-x.y.exe built with the same C compiler
# used for python. XXX What about mingw, borland, and so on?
# if plat_name starts with "win" but is not "win32"
# we want to strip "win" and leave the rest (e.g. -amd64)
# for all other cases, we don't want any suffix
if self.plat_name != 'win32' and self.plat_name[:3] == 'win':
sfix = self.plat_name[3:]
else:
sfix = ''
filename = os.path.join(directory, "wininst-%s%s.exe" % (bv, sfix))
try:
f = open(filename, "rb")
except IOError as e:
raise DistutilsFileError(
str(e) +
', %s not included in the Debian packages.' % filename)
try:
return f.read()
finally:
f.close()
def run(self):
build_scripts = self.reinitialize_command('build_scripts')
build_scripts.executable = 'python'
if not self.skip_build:
self.run_command('build')
install = self.reinitialize_command('install', reinit_subcommands=True)
install.root = self.bdist_dir
install.compile = False
install.skip_build = self.skip_build
install.warn_dir = False
# A wheel without setuptools scripts is more cross-platform.
# Use the (undocumented) `no_ep` option to setuptools'
# install_scripts command to avoid creating entry point scripts.
install_scripts = self.reinitialize_command('install_scripts')
install_scripts.no_ep = True
# Use a custom scheme for the archive, because we have to decide
# at installation time which scheme to use.
for key in ('headers', 'scripts', 'data', 'purelib', 'platlib'):
setattr(install, 'install_' + key,
os.path.join(self.data_dir, key))
basedir_observed = ''
if os.name == 'nt':
# win32 barfs if any of these are ''; could be '.'?
# (distutils.command.install:change_roots bug)
basedir_observed = os.path.normpath(
os.path.join(self.data_dir, '..'))
self.install_libbase = self.install_lib = basedir_observed
setattr(install,
'install_purelib' if self.root_is_pure else 'install_platlib',
basedir_observed)
logger.info("installing to %s", self.bdist_dir)
self.run_command('install')
archive_basename = self.get_archive_basename()
pseudoinstall_root = os.path.join(self.dist_dir, archive_basename)
if not self.relative:
archive_root = self.bdist_dir
else:
archive_root = os.path.join(
self.bdist_dir, self._ensure_relative(install.install_base))
self.set_undefined_options('install_egg_info',
('target', 'egginfo_dir'))
self.distinfo_dir = os.path.join(self.bdist_dir,
'%s.dist-info' % self.wheel_dist_name)
self.egg2dist(self.egginfo_dir, self.distinfo_dir)
self.write_wheelfile(self.distinfo_dir)
self.write_record(self.bdist_dir, self.distinfo_dir)
# Make the archive
if not os.path.exists(self.dist_dir):
os.makedirs(self.dist_dir)
wheel_name = archive_wheelfile(pseudoinstall_root, archive_root)
# Sign the archive
if 'WHEEL_TOOL' in os.environ:
subprocess.call([os.environ['WHEEL_TOOL'], 'sign', wheel_name])
# Add to 'Distribution.dist_files' so that the "upload" command works
getattr(self.distribution, 'dist_files', []).append(
('bdist_wheel', get_python_version(), wheel_name))
if not self.keep_temp:
if self.dry_run:
logger.info('removing %s', self.bdist_dir)
else:
rmtree(self.bdist_dir)
class SourceGPL(sdist):
"""Create source GNU GPLv2 distribution for specific Python version
This class generates a source distribution GNU GPLv2 licensed for the
Python version that is used. SourceGPL is used by other commands to
generate RPM or other packages.
"""
description = 'create a source distribution for Python v%s.x' % (
get_python_version()[0])
user_options = [
('debug', None, "turn debugging on"),
('bdist-dir=', 'd',
"temporary directory for creating the distribution"),
('keep-temp', 'k', "keep the pseudo-installation tree around after " +
"creating the distribution archive"),
('dist-dir=', 'd', "directory to put final built distributions in"),
]
boolean_options = [
'keep-temp',
]
negative_opt = []
def initialize_options(self):
"""Initialize the options"""
self.bdist_dir = None
self.keep_temp = 0
self.dist_dir = None
self.plat_name = ''
self.debug = False
def finalize_options(self):
"""Finalize the options"""
if self.bdist_dir is None:
bdist_base = self.get_finalized_command('bdist').bdist_base
self.bdist_dir = os.path.join(bdist_base, 'dist')
self.set_undefined_options(
'bdist',
('dist_dir', 'dist_dir'),
)
python_version = get_python_version()
pyver = python_version[0:2]
# Change classifiers
new_classifiers = []
for classifier in self.distribution.metadata.classifiers:
if (classifier.startswith("Programming Language ::")
and (pyver not in classifier)):
log.info("removing classifier %s" % classifier)
continue
new_classifiers.append(classifier)
self.distribution.metadata.classifiers = new_classifiers
license = open('README.txt', 'r').read()
self.distribution.metadata.long_description += "\n" + license
def run(self):
"""Run the distutils command"""
log.info("installing library code to %s" % self.bdist_dir)
log.info("generating INFO_SRC and INFO_BIN files")
generate_info_files()
self.dist_name = get_dist_name(self.distribution,
source_only_dist=True,
python_version=get_python_version()[0])
self.dist_target = os.path.join(self.dist_dir, self.dist_name)
log.info("distribution will be available as '%s'" % self.dist_target)
# build command: just to get the build_base
cmdbuild = self.get_finalized_command("build")
self.build_base = cmdbuild.build_base
# install command
install = self.reinitialize_command('install_lib',
reinit_subcommands=1)
install.compile = False
install.warn_dir = 0
install.install_dir = self.bdist_dir
log.info("installing to %s" % self.bdist_dir)
self.run_command('install_lib')
# install extra files
extra_files = {}
for src, dest in extra_files.items():
self.copy_file(src, dest)
# install_egg_info command
cmd_egginfo = self.get_finalized_command('install_egg_info')
cmd_egginfo.install_dir = self.bdist_dir
self.run_command('install_egg_info')
# we need the py2.x converted to py2 in the filename
old_egginfo = cmd_egginfo.get_outputs()[0]
new_egginfo = old_egginfo.replace('-py' + sys.version[:3],
'-py' + get_python_version()[0])
move_file(old_egginfo, new_egginfo)
# create distribution
info_files = [
('README.txt', 'README.txt'),
('LICENSE.txt', 'LICENSE.txt'),
('README.rst', 'README.rst'),
('CONTRIBUTING.rst', 'CONTRIBUTING.rst'),
('docs/INFO_SRC', 'INFO_SRC'),
('docs/INFO_BIN', 'INFO_BIN'),
]
copy_tree(self.bdist_dir, self.dist_target)
pkg_info = mkpath(os.path.join(self.dist_target))
for src, dst in info_files:
if dst is None:
copy_file(src, self.dist_target)
else:
copy_file(src, os.path.join(self.dist_target, dst))
if not self.keep_temp:
remove_tree(self.build_base, dry_run=self.dry_run)
def finalize_options(self):
from distutils import sysconfig
self.set_undefined_options('build', ('build_lib', 'build_lib'), ('build_temp', 'build_temp'), ('compiler', 'compiler'), ('debug', 'debug'), ('force', 'force'), ('plat_name', 'plat_name'))
if self.package is None:
self.package = self.distribution.ext_package
self.extensions = self.distribution.ext_modules
py_include = sysconfig.get_python_inc()
plat_py_include = sysconfig.get_python_inc(plat_specific=1)
if self.include_dirs is None:
self.include_dirs = self.distribution.include_dirs or []
if isinstance(self.include_dirs, str):
self.include_dirs = self.include_dirs.split(os.pathsep)
self.include_dirs.append(py_include)
if plat_py_include != py_include:
self.include_dirs.append(plat_py_include)
self.ensure_string_list('libraries')
if self.libraries is None:
self.libraries = []
if self.library_dirs is None:
self.library_dirs = []
elif type(self.library_dirs) is StringType:
self.library_dirs = string.split(self.library_dirs, os.pathsep)
if self.rpath is None:
self.rpath = []
elif type(self.rpath) is StringType:
self.rpath = string.split(self.rpath, os.pathsep)
if os.name == 'nt':
self.library_dirs.append(os.path.join(sys.exec_prefix, 'libs'))
if self.debug:
self.build_temp = os.path.join(self.build_temp, 'Debug')
else:
self.build_temp = os.path.join(self.build_temp, 'Release')
self.include_dirs.append(os.path.join(sys.exec_prefix, 'PC'))
if MSVC_VERSION == 9:
if self.plat_name == 'win32':
suffix = ''
else:
suffix = self.plat_name[4:]
new_lib = os.path.join(sys.exec_prefix, 'PCbuild')
if suffix:
new_lib = os.path.join(new_lib, suffix)
self.library_dirs.append(new_lib)
elif MSVC_VERSION == 8:
self.library_dirs.append(os.path.join(sys.exec_prefix, 'PC', 'VS8.0'))
elif MSVC_VERSION == 7:
self.library_dirs.append(os.path.join(sys.exec_prefix, 'PC', 'VS7.1'))
else:
self.library_dirs.append(os.path.join(sys.exec_prefix, 'PC', 'VC6'))
if os.name == 'os2':
self.library_dirs.append(os.path.join(sys.exec_prefix, 'Config'))
if sys.platform[:6] == 'cygwin' or sys.platform[:6] == 'atheos':
if sys.executable.startswith(os.path.join(sys.exec_prefix, 'bin')):
self.library_dirs.append(os.path.join(sys.prefix, 'lib', 'python' + get_python_version(), 'config'))
else:
self.library_dirs.append('.')
if sysconfig.get_config_var('Py_ENABLE_SHARED'):
if sys.executable.startswith(os.path.join(sys.exec_prefix, 'bin')):
self.library_dirs.append(sysconfig.get_config_var('LIBDIR'))
else:
self.library_dirs.append('.')
if self.define:
defines = self.define.split(',')
self.define = map(lambda symbol: (symbol, '1'), defines)
if self.undef:
self.undef = self.undef.split(',')
if self.swig_opts is None:
self.swig_opts = []
else:
self.swig_opts = self.swig_opts.split(' ')
if self.user:
user_include = os.path.join(USER_BASE, 'include')
user_lib = os.path.join(USER_BASE, 'lib')
if os.path.isdir(user_include):
self.include_dirs.append(user_include)
if os.path.isdir(user_lib):
self.library_dirs.append(user_lib)
self.rpath.append(user_lib)
return
def run(self):
"""Run the distutils command"""
log.info("installing library code to %s" % self.bdist_dir)
log.info("generating INFO_SRC and INFO_BIN files")
generate_info_files()
dist_name = self.distribution.get_fullname()
self.dist_target = os.path.join(self.dist_dir, dist_name)
log.info("distribution will be available as '%s'" % self.dist_target)
# build command: just to get the build_base
cmdbuild = self.get_finalized_command("build")
self.build_base = cmdbuild.build_base
# install command
install = self.reinitialize_command('install_lib',
reinit_subcommands=1)
install.compile = False
install.warn_dir = 0
install.install_dir = self.bdist_dir
log.info("installing to %s" % self.bdist_dir)
self.run_command('install_lib')
# install extra files
extra_files = {}
for src, dest in extra_files.items():
self.copy_file(src, dest)
# install_egg_info command
cmd_egginfo = self.get_finalized_command('install_egg_info')
cmd_egginfo.install_dir = self.bdist_dir
self.run_command('install_egg_info')
installed_files = install.get_outputs()
# remove the GPL license
ignore = [
os.path.join(self.bdist_dir,
os.path.normcase('mysql/__init__.py')),
os.path.join(self.bdist_dir, 'mysql', 'connector', 'locales',
'eng', '__init__.py'),
cmd_egginfo.target,
]
django_backend = os.path.join('connector', 'django')
for pyfile in installed_files:
if '.py' not in pyfile:
continue
if pyfile not in ignore and django_backend not in pyfile:
commercial.remove_gpl(pyfile, dry_run=self.dry_run)
log.info("setting license information in version.py")
loc_version_py = os.path.join(
self.bdist_dir, os.path.normcase('mysql/connector/version.py'))
version_py = open(loc_version_py, 'r').readlines()
for (nr, line) in enumerate(version_py):
if line.startswith('LICENSE'):
version_py[nr] = 'LICENSE = "Commercial"\n'
fp = open(loc_version_py, 'w')
fp.write(''.join(version_py))
fp.close()
# compile and remove sources
if not self.include_sources:
util.byte_compile(installed_files,
optimize=0,
force=True,
prefix=install.install_dir)
self._remove_sources()
if get_python_version().startswith('3'):
log.info("copying byte code from __pycache__")
self._copy_from_pycache(os.path.join(self.bdist_dir, 'mysql'))
self._copy_from_pycache(os.path.join(self.bdist_dir, 'mysqlx'))
# create distribution
info_files = [
('cpyint/data/commercial/README_COM.txt', 'README.txt'),
('cpyint/data/commercial/LICENSE_COM.txt', 'LICENSE.txt'),
('README.rst', 'README.rst'),
('CONTRIBUTING.rst', 'CONTRIBUTING.rst'),
('docs/INFO_SRC', 'INFO_SRC'),
('docs/INFO_BIN', 'INFO_BIN'),
]
copy_tree(self.bdist_dir, self.dist_target)
mkpath(os.path.join(self.dist_target))
xy_needle = 'Connector/Python X.Y'
xy_sub = 'Connector/Python {0}.{1}'
for src, dst in info_files:
if dst is None:
dest_name, _ = copy_file(src, self.dist_target)
else:
dest_name, _ = copy_file(src,
os.path.join(self.dist_target, dst))
with open(dest_name, 'r+') as fp:
content = fp.readlines()
for i, line in enumerate(content):
if xy_needle in line:
content[i] = line.replace(xy_needle,
xy_sub.format(*VERSION[0:2]))
fp.seek(0)
fp.write(''.join(content))
add_docs(os.path.join(self.dist_target, 'docs'))
self._write_setuppy()
if not self.keep_temp:
remove_tree(self.build_base, dry_run=self.dry_run)
debug = ''
# debug = '-ggdb'
cflags = os.environ.get(
'OVERRIDE_CFLAGS',
'-Wall -DNDEBUG %s -fno-strict-aliasing -pipe' % debug)
cflags = shlex.split(cflags) + ['-fPIC']
ldflags = os.environ.get('OVERRIDE_LDFLAGS', '-Wall')
ldflags = shlex.split(ldflags)
cflags += shlex.split(os.environ.get('CFLAGS', ''))
ldflags += shlex.split(os.environ.get('LDFLAGS', ''))
if islinux:
cflags.append('-pthread')
ldflags.append('-shared')
cflags.append('-I' + sysconfig.get_python_inc())
ldflags.append('-lpython' + sysconfig.get_python_version())
if isbsd:
cflags.append('-pthread')
ldflags.append('-shared')
cflags.append('-I' + sysconfig.get_python_inc())
ldflags.append('-lpython' + sysconfig.get_python_version())
if isosx:
cflags.append('-D_OSX')
ldflags.extend('-bundle -undefined dynamic_lookup'.split())
cflags.extend(['-fno-common', '-dynamic'])
cflags.append('-I' + sysconfig.get_python_inc())
if iswindows:
cc = cxx = msvc.cc
def finalize_options(self):
self.set_undefined_options('build', ('build_base', 'build_base'))
self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
if not self.prefix:
self.prefix = os.path.join(
self.build_base,
DIST_PATH_FORMAT.format(self.python_version[0],
self.python_version[2]))
self.supported_versions = ['2.7', '3.4', '3.5', '3.6', '3.7', '3.8']
self.dist_path = {}
for py_ver in self.supported_versions:
self.dist_path[py_ver] = os.path.join(
self.build_base, DIST_PATH_FORMAT.format(*py_ver.split('.')))
if self.python_version not in self.supported_versions:
raise DistutilsOptionError(
"The --python-version should be a supported version, one "
"of %s" % ','.join(self.supported_versions))
if self.python_version[0] != get_python_version()[0]:
raise DistutilsError(
"Python v3 distributions need to be build with a "
"supported Python v3 installation.")
self.with_cext = any(
(self.with_mysql_capi, self.with_protobuf_include_dir,
self.with_protobuf_lib_dir, self.with_protoc))
if self.with_cext:
if not self.with_mysql_capi or \
not os.path.isdir(self.with_mysql_capi):
log.error("Location of MySQL C API (Connector/C) must be "
"provided.")
sys.exit(1)
else:
cmd_build = self.get_finalized_command('build')
self.connc_lib = os.path.join(cmd_build.build_temp, 'connc',
'lib')
self.connc_include = os.path.join(cmd_build.build_temp,
'connc', 'include')
self._finalize_connector_c(self.with_mysql_capi)
if not self.with_protobuf_include_dir or \
not os.path.isdir(self.with_protobuf_include_dir):
log.error("Location of Protobuf include directory must be "
"provided.")
sys.exit(1)
else:
self.with_protobuf_include_dir = \
os.path.abspath(self.with_protobuf_include_dir)
if not self.with_protobuf_lib_dir or \
not os.path.isdir(self.with_protobuf_lib_dir):
log.error("Location of Protobuf library directory must be "
"provided.")
sys.exit(1)
else:
self.with_protobuf_lib_dir = \
os.path.abspath(self.with_protobuf_lib_dir)
if not self.with_protoc or not os.path.isfile(self.with_protoc):
log.error("Protobuf protoc binary is not valid.")
sys.exit(1)
else:
self.with_protoc = os.path.abspath(self.with_protoc)
def run(self):
build_scripts = self.reinitialize_command('build_scripts')
build_scripts.executable = 'python'
build_scripts.force = True
build_ext = self.reinitialize_command('build_ext')
build_ext.inplace = False
if not self.skip_build:
self.run_command('build')
install = self.reinitialize_command('install',
reinit_subcommands=True)
install.root = self.bdist_dir
install.compile = False
install.skip_build = self.skip_build
install.warn_dir = False
# A wheel without setuptools scripts is more cross-platform.
# Use the (undocumented) `no_ep` option to setuptools'
# install_scripts command to avoid creating entry point scripts.
install_scripts = self.reinitialize_command('install_scripts')
install_scripts.no_ep = True
# Use a custom scheme for the archive, because we have to decide
# at installation time which scheme to use.
for key in ('headers', 'scripts', 'data', 'purelib', 'platlib'):
setattr(install,
'install_' + key,
os.path.join(self.data_dir, key))
basedir_observed = ''
if os.name == 'nt':
# win32 barfs if any of these are ''; could be '.'?
# (distutils.command.install:change_roots bug)
basedir_observed = os.path.normpath(os.path.join(self.data_dir, '..'))
self.install_libbase = self.install_lib = basedir_observed
setattr(install,
'install_purelib' if self.root_is_pure else 'install_platlib',
basedir_observed)
logger.info("installing to %s", self.bdist_dir)
self.run_command('install')
impl_tag, abi_tag, plat_tag = self.get_tag()
archive_basename = "{}-{}-{}-{}".format(self.wheel_dist_name, impl_tag, abi_tag, plat_tag)
if not self.relative:
archive_root = self.bdist_dir
else:
archive_root = os.path.join(
self.bdist_dir,
self._ensure_relative(install.install_base))
self.set_undefined_options('install_egg_info', ('target', 'egginfo_dir'))
distinfo_dirname = '{}-{}.dist-info'.format(
safer_name(self.distribution.get_name()),
safer_version(self.distribution.get_version()))
distinfo_dir = os.path.join(self.bdist_dir, distinfo_dirname)
self.egg2dist(self.egginfo_dir, distinfo_dir)
self.write_wheelfile(distinfo_dir)
# Make the archive
if not os.path.exists(self.dist_dir):
os.makedirs(self.dist_dir)
wheel_path = os.path.join(self.dist_dir, archive_basename + '.whl')
with WheelFile(wheel_path, 'w', self.compression) as wf:
wf.write_files(archive_root)
# Add to 'Distribution.dist_files' so that the "upload" command works
getattr(self.distribution, 'dist_files', []).append(
('bdist_wheel', get_python_version(), wheel_path))
if not self.keep_temp:
logger.info('removing %s', self.bdist_dir)
if not self.dry_run:
rmtree(self.bdist_dir, onerror=remove_readonly)