def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
"""Compile 'src' to product 'obj'."""
src_flags = {}
if is_f_file(src) and not has_f90_header(src):
flavor = ":f77"
compiler = self.compiler_f77
src_flags = get_f77flags(src)
extra_compile_args = self.extra_f77_compile_args or []
elif is_free_format(src):
flavor = ":f90"
compiler = self.compiler_f90
if compiler is None:
raise DistutilsExecError(
"f90 not supported by %s needed for %s"
% (self.__class__.__name__, src)
)
extra_compile_args = self.extra_f90_compile_args or []
else:
flavor = ":fix"
compiler = self.compiler_fix
if compiler is None:
raise DistutilsExecError(
"f90 (fixed) not supported by %s needed for %s"
% (self.__class__.__name__, src)
)
extra_compile_args = self.extra_f90_compile_args or []
if self.object_switch[-1] == " ":
o_args = [self.object_switch.strip(), obj]
else:
o_args = [self.object_switch.strip() + obj]
assert self.compile_switch.strip()
s_args = [self.compile_switch, src]
if extra_compile_args:
log.info(
"extra %s options: %r" % (flavor[1:], " ".join(extra_compile_args))
)
extra_flags = src_flags.get(self.compiler_type, [])
if extra_flags:
log.info("using compile options from source: %r" % " ".join(extra_flags))
command = (
compiler
+ cc_args
+ extra_flags
+ s_args
+ o_args
+ extra_postargs
+ extra_compile_args
)
display = "%s: %s" % (os.path.basename(compiler[0]) + flavor, src)
try:
self.spawn(command, display=display)
except DistutilsExecError:
msg = str(get_exception())
raise CompileError(msg)
def finalize_options(self):
# if a test dir isn't specified explicitly try to find one
if self.test_dir is None:
for path in (os.path.join(REPODIR, 'test',
'module'), os.path.join(REPODIR, 'test'),
os.path.join(REPODIR, 'tests', 'module'),
os.path.join(REPODIR, 'tests'),
os.path.join(MODULEDIR, 'test'),
os.path.join(MODULEDIR, 'tests')):
if os.path.exists(path):
self.test_dir = path
break
else:
raise DistutilsExecError(
'cannot automatically determine test directory')
self.test_args = []
if self.targets is not None:
targets = [
os.path.join(self.test_dir, x) for x in self.targets.split()
]
self.test_args.extend(targets)
else:
self.test_args.append(self.test_dir)
self.coverage = bool(self.coverage)
self.skip_build = bool(self.skip_build)
if self.verbose:
self.test_args.append('-v')
if self.match is not None:
self.test_args.extend(['-k', self.match])
if self.coverage or self.report:
try:
import pytest_cov
self.test_args.extend(['--cov', MODULE_NAME])
except ImportError:
raise DistutilsExecError(
'install pytest-cov for coverage support')
coveragerc = os.path.join(REPODIR, '.coveragerc')
if os.path.exists(coveragerc):
self.test_args.extend(['--cov-config', coveragerc])
if self.report is None:
# disable coverage report output
self.test_args.extend(['--cov-report='])
else:
self.test_args.extend(['--cov-report', self.report])
if self.jobs is not None:
try:
import xdist
self.test_args.extend(['-n', self.jobs])
except ImportError:
raise DistutilsExecError(
'install pytest-xdist for -j/--jobs support')
# add custom pytest args
self.test_args.extend(shlex.split(self.pytest_args))
def get_mysql_config_info(mysql_config):
"""Get MySQL information using mysql_config tool
Returns a dict.
"""
options = ['cflags', 'include', 'libs', 'libs_r', 'plugindir', 'version']
cmd = [mysql_config] + ["--{0}".format(opt) for opt in options]
try:
proc = Popen(cmd, stdout=PIPE, universal_newlines=True)
stdout, _ = proc.communicate()
except OSError as exc:
raise DistutilsExecError("Failed executing mysql_config: {0}".format(
str(exc)))
info = {}
for option, line in zip(options, stdout.split('\n')):
info[option] = line.strip()
info['version'] = tuple([int(v) for v in info['version'].split('.')[0:3]])
libs = shlex.split(info['libs'])
info['lib_dir'] = libs[0].replace('-L', '')
info['libs'] = [lib.replace('-l', '') for lib in libs[1:]]
libs = shlex.split(info['libs_r'])
info['lib_r_dir'] = libs[0].replace('-L', '')
info['libs_r'] = [lib.replace('-l', '') for lib in libs[1:]]
info['include'] = info['include'].replace('-I', '')
# Try to figure out the architecture
info['arch'] = None
if os.name == 'posix':
pathname = os.path.join(info['lib_dir'], 'lib' + info['libs'][0]) + '*'
lib = glob(pathname)[0]
stdout = None
try:
proc = Popen(['file', lib], stdout=PIPE, universal_newlines=True)
stdout, _ = proc.communicate()
except OSError as exc:
raise DistutilsExecError(
"Although the system seems POSIX, the file-command could not "
"be executed: {0}".format(str(exc)))
if stdout:
if '64' in stdout:
info['arch'] = "x86_64"
else:
info['arch'] = "i386"
else:
raise DistutilsExecError(
"Failed getting out put from the file-command")
else:
raise DistutilsExecError(
"Cannot determine architecture on {0} systems".format(os.name))
return info
def spawn(cmd, search_path=1, verbose=0, dry_run=0, env=None):
"""Run another program, specified as a command list 'cmd', in a new process.
'cmd' is just the argument list for the new process, ie.
cmd[0] is the program to run and cmd[1:] are the rest of its arguments.
There is no way to run a program with a name different from that of its
executable.
If 'search_path' is true (the default), the system's executable
search path will be used to find the program; otherwise, cmd[0]
must be the exact path to the executable. If 'dry_run' is true,
the command will not actually be run.
Raise DistutilsExecError if running the program fails in any way; just
return on success.
"""
# cmd is documented as a list, but just in case some code passes a tuple
# in, protect our %-formatting code against horrible death
cmd = list(cmd)
log.info(subprocess.list2cmdline(cmd))
if dry_run:
return
if search_path:
executable = find_executable(cmd[0])
if executable is not None:
cmd[0] = executable
env = env if env is not None else dict(os.environ)
if sys.platform == 'darwin':
from distutils.util import MACOSX_VERSION_VAR, get_macosx_target_ver
macosx_target_ver = get_macosx_target_ver()
if macosx_target_ver:
env[MACOSX_VERSION_VAR] = macosx_target_ver
try:
proc = subprocess.Popen(cmd, env=env)
proc.wait()
exitcode = proc.returncode
except OSError as exc:
if not DEBUG:
cmd = cmd[0]
raise DistutilsExecError("command %r failed: %s" %
(cmd, exc.args[-1])) from exc
if exitcode:
if not DEBUG:
cmd = cmd[0]
raise DistutilsExecError("command %r failed with exit code %s" %
(cmd, exitcode))
def write_pkgcore_ebd_funclists(root, target, scripts_dir, python_base='.'):
"Generate bash function lists from ebd implementation for env filtering." ""
ebd_dir = target
if root != '/':
ebd_dir = os.path.join(root, target.lstrip('/'))
log.info("Writing ebd function lists to %s" %
os.path.join(ebd_dir, 'funcnames'))
try:
os.makedirs(os.path.join(ebd_dir, 'funcnames'))
except OSError as e:
if e.errno != errno.EEXIST:
raise
# Add scripts dir to PATH and set the current python binary for filter-env
# usage in global scope.
env = {
'PATH':
os.pathsep.join(
[os.path.abspath(scripts_dir),
os.environ.get('PATH', '')]),
'PKGCORE_PYTHON_BINARY':
sys.executable,
'PKGCORE_PYTHONPATH':
os.path.abspath(python_base),
}
# generate global function list
with open(os.path.join(ebd_dir, 'funcnames', 'global'), 'w') as f:
if subprocess.call([
os.path.join(os.getcwd(), 'ebd',
'generate_global_func_list.bash')
],
cwd=ebd_dir,
env=env,
stdout=f):
raise DistutilsExecError("generating global function list failed")
# generate EAPI specific function lists
eapis = (x.split('.')[0]
for x in os.listdir(os.path.join(os.getcwd(), 'ebd', 'eapi'))
if x.split('.')[0].isdigit())
for eapi in sorted(eapis):
with open(os.path.join(ebd_dir, 'funcnames', eapi), 'w') as f:
if subprocess.call([
os.path.join(os.getcwd(), 'ebd',
'generate_eapi_func_list.bash'), eapi
],
cwd=ebd_dir,
env=env,
stdout=f):
raise DistutilsExecError(
"generating EAPI %s function list failed" % eapi)
def write_pkgcore_ebd_cmdlists(root, target):
"Generate bash function lists from ebd implementation for env filtering." ""
ebd_dir = target
if root != '/':
ebd_dir = os.path.join(root, target.lstrip('/'))
os.makedirs(os.path.join(ebd_dir, 'cmds'), exist_ok=True)
# generate EAPI specific command lists
with pkgdist.syspath(pkgdist.PACKAGEDIR):
from pkgcore.ebuild.eapi import EAPI
for eapi_obj in EAPI.known_eapis.values():
eapi = str(eapi_obj)
os.makedirs(os.path.join(ebd_dir, 'cmds', eapi), exist_ok=True)
path = os.path.join(ebd_dir, 'cmds', eapi, 'banned')
log.info(f'writing EAPI {eapi} banned command list: {path!r}')
with open(path, 'w') as f:
if subprocess.call([
os.path.join(pkgdist.REPODIR, 'ebd',
'generate_eapi_cmd_list'), '-b', eapi
],
cwd=ebd_dir,
stdout=f):
raise DistutilsExecError(
f'generating EAPI {eapi} banned command list failed')
path = os.path.join(ebd_dir, 'cmds', eapi, 'deprecated')
log.info(f'writing EAPI {eapi} deprecated command list: {path!r}')
with open(path, 'w') as f:
if subprocess.call([
os.path.join(pkgdist.REPODIR, 'ebd',
'generate_eapi_cmd_list'), '-d', eapi
],
cwd=ebd_dir,
stdout=f):
raise DistutilsExecError(
f'generating EAPI {eapi} deprecated command list failed'
)
path = os.path.join(ebd_dir, 'cmds', eapi, 'internal')
log.info(f'writing EAPI {eapi} internal command list: {path!r}')
with open(path, 'w') as f:
if subprocess.call([
os.path.join(pkgdist.REPODIR, 'ebd',
'generate_eapi_cmd_list'), '-i', eapi
],
cwd=ebd_dir,
stdout=f):
raise DistutilsExecError(
f'generating EAPI {eapi} internal command list failed')
def run(self):
import subprocess
try:
# Hide stdout but allow stderr
subprocess.check_call(["pandoc", "-v"], stdout=open(os.devnull))
except subprocess.CalledProcessError:
raise DistutilsExecError(
"rst2ipynb requires the Haskell program 'pandoc'. It seems to be installed, but it did not work properly."
)
except OSError:
raise DistutilsExecError(
"rst2ipynb requires the Haskell program 'pandoc'. You need to install it on your system."
)
install.run(self)
def write_pkgcore_ebd_eapi_libs(root,
target,
scripts_dir=None,
python_base='.'):
"Generate bash EAPI scope libs for sourcing." ""
if scripts_dir is None:
scripts_dir = os.path.join(pkgdist.REPODIR, 'bin')
ebd_dir = target
if root != '/':
ebd_dir = os.path.join(root, target.lstrip('/'))
log.info("Writing ebd libs %s" % os.path.join(ebd_dir, 'libs'))
# Add scripts dir to PATH and set the current python binary for filter-env
# usage in global scope.
env = {
'PATH':
os.pathsep.join([pkgdist.SCRIPTS_DIR,
os.environ.get('PATH', '')]),
'PKGCORE_PYTHON_BINARY': sys.executable,
'PKGCORE_PYTHONPATH': os.path.abspath(python_base),
}
script = os.path.join(pkgdist.REPODIR, 'ebd', 'generate_eapi_lib')
with pkgdist.syspath(pkgdist.PACKAGEDIR):
from pkgcore.ebuild.eapi import EAPI
for eapi_obj in EAPI.known_eapis.values():
eapi = str(eapi_obj)
os.makedirs(os.path.join(ebd_dir, 'libs', eapi), exist_ok=True)
# generate global scope lib
with open(os.path.join(ebd_dir, 'libs', eapi, 'global'), 'w') as f:
if subprocess.call([script, eapi],
cwd=ebd_dir,
env=env,
stdout=f):
raise DistutilsExecError(
f"generating global scope EAPI {eapi} lib failed")
for phase in eapi_obj.phases.values():
# generate phase scope lib
with open(os.path.join(ebd_dir, 'libs', eapi, phase),
'w') as f:
if subprocess.call([script, '-s', phase, eapi],
cwd=ebd_dir,
env=env,
stdout=f):
raise DistutilsExecError(
f"generating {phase} phase scope EAPI {eapi} lib failed"
)
def build_extension(self, ext):
if not isinstance(ext, Executable):
build_ext.build_extension(self, ext)
return
cmd = [sys.executable, ext.script] + ext.options + [ext.target]
if self.force:
cmd += ["--force"]
log.debug("running '{}'".format(" ".join(cmd)))
if not self.dry_run:
env = self._compiler_env.copy()
if ext.env:
env.update(ext.env)
p = subprocess.run(cmd, cwd=ext.cwd, env=env)
if p.returncode != 0:
from distutils.errors import DistutilsExecError
raise DistutilsExecError("running '{}' script failed".format(
ext.script))
exe_fullpath = os.path.join(ext.output_dir, ext.target)
dest_path = self.get_ext_fullpath(ext.name)
mkpath(os.path.dirname(dest_path),
verbose=self.verbose,
dry_run=self.dry_run)
copy_file(exe_fullpath,
dest_path,
verbose=self.verbose,
dry_run=self.dry_run)
def CCompiler_spawn(self, cmd, display=None):
"""
Execute a command in a sub-process.
Parameters
----------
cmd : str
The command to execute.
display : str or sequence of str, optional
The text to add to the log file kept by `numpy.distutils`.
If not given, `display` is equal to `cmd`.
Returns
-------
None
Raises
------
DistutilsExecError
If the command failed, i.e. the exit status was not 0.
"""
if display is None:
display = cmd
if is_sequence(display):
display = ' '.join(list(display))
log.info(display)
try:
subprocess.check_output(cmd)
except subprocess.CalledProcessError as exc:
o = exc.output
s = exc.returncode
except OSError:
# OSError doesn't have the same hooks for the exception
# output, but exec_command() historically would use an
# empty string for EnvironmentError (base class for
# OSError)
o = b''
# status previously used by exec_command() for parent
# of OSError
s = 127
else:
# use a convenience return here so that any kind of
# caught exception will execute the default code after the
# try / except block, which handles various exceptions
return None
if is_sequence(cmd):
cmd = ' '.join(list(cmd))
try:
print(o)
except UnicodeError:
# When installing through pip, `o` can contain non-ascii chars
pass
if re.search(b'Too many open files', o):
msg = '\nTry rerunning setup command until build succeeds.'
else:
msg = ''
raise DistutilsExecError('Command "%s" failed with exit status %d%s' %
(cmd, s, msg))
def _spawn_openvms(cmd, search_path=1, verbose=0, dry_run=0):
log.info(' '.join(cmd))
if dry_run:
return
try:
proc = subprocess.Popen(cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
except OSError:
proc = subprocess.Popen(cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True)
data, error = proc.communicate()
rc = proc.wait()
if data:
data = data.decode()
else:
data = ''
if error:
error = error.decode()
else:
error = ''
if verbose:
log.info(data)
log.info(error)
if rc:
if error == '':
error = data
raise DistutilsExecError("command %r failed: %r" % (cmd, error))
def check_version(self, required_version, this_version):
this_version = tuple(this_version)
#print("req '%s' this '%s'" %(required_version, this_version))
min_length = min(len(required_version), len(this_version))
for pos in range(min_length):
t_val = this_version[pos]
test_val = required_version[pos]
#print("\t %d: req '%s' this '%s'" %( pos, test_val, t_val))
this_type = type(t_val)
if this_type == type(" "):
t_val = int(t_val)
if type(test_val) == type(" "):
test_val = int(test_val)
if t_val > test_val:
# already larger
return 1
elif t_val == test_val:
continue
elif t_val < test_val:
return 0
else:
raise DistutilsExecError("incorrect version specification")
# problematic: 0.9 < 0.9.0, but assures that 0.9.1 > 0.9
if len(required_version) > len(this_version): return 0
return 1
def spawn(cmd, search_path=1, verbose=0, dry_run=0):
"""Run another program, specified as a command list 'cmd', in a new process.
'cmd' is just the argument list for the new process, ie.
cmd[0] is the program to run and cmd[1:] are the rest of its arguments.
There is no way to run a program with a name different from that of its
executable.
If 'search_path' is true (the default), the system's executable
search path will be used to find the program; otherwise, cmd[0]
must be the exact path to the executable. If 'dry_run' is true,
the command will not actually be run.
Raise DistutilsExecError if running the program fails in any way; just
return on success.
"""
# cmd is documented as a list, but just in case some code passes a tuple
# in, protect our %-formatting code against horrible death
cmd = list(cmd)
log.info(' '.join(cmd))
if dry_run:
return
if search_path:
executable = find_executable(cmd[0])
if executable is not None:
cmd[0] = executable
env = None
if sys.platform == 'darwin':
global _cfg_target, _cfg_target_split
if _cfg_target is None:
from distutils import sysconfig
_cfg_target = sysconfig.get_config_var(
'MACOSX_DEPLOYMENT_TARGET') or ''
if _cfg_target:
_cfg_target_split = [int(x) for x in _cfg_target.split('.')]
if _cfg_target:
# ensure that the deployment target of build process is not less
# than that used when the interpreter was built. This ensures
# extension modules are built with correct compatibility values
cur_target = os.environ.get('MACOSX_DEPLOYMENT_TARGET',
_cfg_target)
if _cfg_target_split > [int(x) for x in cur_target.split('.')]:
my_msg = ('$MACOSX_DEPLOYMENT_TARGET mismatch: '
'now "%s" but "%s" during configure' %
(cur_target, _cfg_target))
raise DistutilsPlatformError(my_msg)
env = dict(os.environ, MACOSX_DEPLOYMENT_TARGET=cur_target)
proc = subprocess.Popen(cmd, env=env)
proc.wait()
exitcode = proc.returncode
if exitcode:
if not DEBUG:
cmd = cmd[0]
raise DistutilsExecError("command %r failed with exit code %s" %
(cmd, exitcode))
def _spawn_qnx(cmd, search_path=1, verbose=0, dry_run=0):
log.info(' '.join(cmd))
if dry_run:
return
try:
if search_path:
rc = os.spawnvp(os.P_WAIT, cmd[0], cmd)
else:
rc = os.spawnv(os.P_WAIT, cmd[0], cmd)
except OSError as exc:
raise DistutilsExecError("command '%s' failed: %s" %
(cmd[0], exc.args[-1]))
if rc != 0:
msg = "command '%s' failed with exit status %d" % (cmd[0], rc)
log.debug(msg)
raise DistutilsExecError(msg)
def write_pkgcore_lookup_configs(python_base, install_prefix, injected_bin_path=()):
"""Generate file of install path constants."""
path = os.path.join(python_base, "pkgcore", "_const.py")
try:
os.makedirs(os.path.dirname(path))
except OSError as e:
if e.errno != errno.EEXIST:
raise
log.info("writing lookup config to %r" % path)
with open(path, "w") as f:
os.chmod(path, 0o644)
# write more dynamic _const file for wheel installs
if install_prefix != os.path.abspath(sys.prefix):
import textwrap
f.write(textwrap.dedent("""\
import os.path as osp
import sys
from snakeoil import process
INSTALL_PREFIX = osp.abspath(sys.prefix)
DATA_PATH = osp.join(INSTALL_PREFIX, {!r})
CONFIG_PATH = osp.join(INSTALL_PREFIX, {!r})
LIBDIR_PATH = osp.join(INSTALL_PREFIX, {!r})
EBD_PATH = osp.join(INSTALL_PREFIX, {!r})
INJECTED_BIN_PATH = ()
CP_BINARY = process.find_binary('cp')
""".format(
DATA_INSTALL_OFFSET, CONFIG_INSTALL_OFFSET,
LIBDIR_INSTALL_OFFSET, EBD_INSTALL_OFFSET)))
else:
f.write("INSTALL_PREFIX=%r\n" % install_prefix)
f.write("DATA_PATH=%r\n" %
os.path.join(install_prefix, DATA_INSTALL_OFFSET))
f.write("CONFIG_PATH=%r\n" %
os.path.join(install_prefix, CONFIG_INSTALL_OFFSET))
f.write("LIBDIR_PATH=%r\n" %
os.path.join(install_prefix, LIBDIR_INSTALL_OFFSET))
f.write("EBD_PATH=%r\n" %
os.path.join(install_prefix, EBD_INSTALL_OFFSET))
# This is added to suppress the default behaviour of looking
# within the repo for a bin subdir.
f.write("INJECTED_BIN_PATH=%r\n" % (tuple(injected_bin_path),))
# Static paths for various utilities.
from snakeoil import process
required_progs = ('cp',)
try:
for prog in required_progs:
prog_path = process.find_binary(prog)
f.write("%s_BINARY=%r\n" % (prog.upper(), prog_path))
except process.CommandNotFound:
raise DistutilsExecError(
"generating lookup config failed: required utility %r missing from PATH" % (prog,))
f.close()
byte_compile([path], prefix=python_base)
byte_compile([path], optimize=2, prefix=python_base)
def compile(self,
sources,
output_dir=None,
macros=None,
include_dirs=None,
debug=0,
extra_preargs=None,
extra_postargs=None,
depends=None):
if output_dir:
try:
os.makedirs(output_dir)
except OSError:
pass
objects = []
for src in sources:
file, ext = os.path.splitext(src)
if output_dir:
obj = os.path.join(output_dir, os.path.basename(file) + ".o")
else:
obj = file + ".o"
if ext == ".f90":
self.compiler_so = ["gfortran"]
#cc_args = ["-O", "-c", "-ffree-form"]
cc_args = ["-c"]
extra_postargs = []
try:
self.spawn(self.compiler_so + cc_args + [src, '-o', obj] +
extra_postargs)
except DistutilsExecError(msg):
raise CompileError(msg)
objects.append(obj)
return objects
def preprocess(self, source, output_file=None, macros=None,
include_dirs=None, extra_preargs=None, extra_postargs=None):
fixed_args = self._fix_compile_args(None, macros, include_dirs)
ignore, macros, include_dirs = fixed_args
pp_opts = gen_preprocess_options(macros, include_dirs)
pp_args = self.preprocessor + pp_opts
if output_file:
pp_args.extend(['-o', output_file])
if extra_preargs:
pp_args[:0] = extra_preargs
if extra_postargs:
pp_args.extend(extra_postargs)
pp_args.append(source)
# We need to preprocess: either we're being forced to, or we're
# generating output to stdout, or there's a target output file and
# the source file is newer than the target (or the target doesn't
# exist).
if self.force or output_file is None or newer(source, output_file):
if output_file:
self.mkpath(os.path.dirname(output_file))
try:
# iOS: since clang is not available, we send a nicer error message:
if (sys.platform == 'darwin' and os.uname().machine.startswith('iP')):
raise DistutilsExecError("There are no preprocessors available on iOS, sorry. Command was: ", pp_args)
#
self.spawn(pp_args)
except DistutilsExecError as msg:
raise CompileError(msg)
def run(self):
try:
import pytest
except ImportError:
raise DistutilsExecError('pytest is not installed')
if self.skip_build:
builddir = MODULEDIR
else:
# build extensions and byte-compile python
build_ext = self.reinitialize_command('build_ext')
build_py = self.reinitialize_command('build_py')
build_ext.ensure_finalized()
build_py.ensure_finalized()
self.run_command('build_ext')
self.run_command('build_py')
builddir = os.path.abspath(build_py.build_lib)
# force reimport of project from builddir
sys.modules.pop(MODULE_NAME, None)
with syspath(builddir):
from snakeoil.contexts import chdir
# Change the current working directory to the builddir during testing
# so coverage paths are correct.
with chdir(builddir):
ret = pytest.main(self.test_args)
sys.exit(ret)
def compile_ts():
lang_dir = pjoin('build', 'lang')
if not os.path.isdir(lang_dir):
os.makedirs(lang_dir)
lres = find_executable('lrelease-qt4') or find_executable('lrelease')
if not lres:
raise DistutilsExecError('lrelease not found')
trans = [
os.path.basename(i).split('.')[0]
for i in glob(pjoin('translation', '*.ts'))
]
for i in trans:
spawn([
lres,
pjoin('translation', i + '.ts'), '-qm',
pjoin(lang_dir, i + '.qm')
])
# copy corresponding Qt translations to build/lang
if sys.platform != 'win32':
# linux have complete qt library, so don't include; ignore warnings when compile_rc
return
pyside_dir = pjoin(get_python_lib(), 'PySide')
for i in trans:
target = pjoin(lang_dir, 'qt_%s.qm' % i)
if not os.path.isfile(target):
print('copy to ' + target)
shutil.copy(pjoin(pyside_dir, 'translations', 'qt_%s.qm' % i),
target)
def make_zipfile(base_name, base_dir, verbose=0, dry_run=0):
"""Create a zip file from all the files under 'base_dir'.
The output zip file will be named 'base_name' + ".zip". Uses either the
"zipfile" Python module (if available) or the InfoZIP "zip" utility
(if installed and found on the default search path). If neither tool is
available, raises DistutilsExecError. Returns the name of the output zip
file.
"""
zip_filename = base_name + ".zip"
mkpath(os.path.dirname(zip_filename), dry_run=dry_run)
# If zipfile module is not available, try spawning an external
# 'zip' command.
if zipfile is None:
if verbose:
zipoptions = "-r"
else:
zipoptions = "-rq"
try:
spawn(["zip", zipoptions, zip_filename, base_dir], dry_run=dry_run)
except DistutilsExecError:
# XXX really should distinguish between "couldn't find
# external 'zip' command" and "zip failed".
raise DistutilsExecError(
("unable to create zip file '%s': "
"could neither import the 'zipfile' module nor "
"find a standalone zip utility") % zip_filename)
else:
log.info("creating '%s' and adding '%s' to it", zip_filename, base_dir)
if not dry_run:
try:
zip = zipfile.ZipFile(zip_filename,
"w",
compression=zipfile.ZIP_DEFLATED)
except RuntimeError:
zip = zipfile.ZipFile(zip_filename,
"w",
compression=zipfile.ZIP_STORED)
if base_dir != os.curdir:
path = os.path.normpath(os.path.join(base_dir, ''))
zip.write(path, path)
log.info("adding '%s'", path)
for dirpath, dirnames, filenames in os.walk(base_dir):
for name in dirnames:
path = os.path.normpath(os.path.join(dirpath, name, ''))
zip.write(path, path)
log.info("adding '%s'", path)
for name in filenames:
path = os.path.normpath(os.path.join(dirpath, name))
if os.path.isfile(path):
zip.write(path, path)
log.info("adding '%s'", path)
zip.close()
return zip_filename
def create_static_lib(self, objects, output_libname,
output_dir=None, debug=0, target_lang=None):
objects, output_dir = self._fix_object_args(objects, output_dir)
output_filename = \
self.library_filename(output_libname, output_dir=output_dir)
if self._need_link(objects, output_filename):
self.mkpath(os.path.dirname(output_filename))
self.spawn(self.archiver +
[output_filename] +
objects + self.objects)
# Not many Unices required ranlib anymore -- SunOS 4.x is, I
# think the only major Unix that does. Maybe we need some
# platform intelligence here to skip ranlib if it's not
# needed -- or maybe Python's configure script took care of
# it for us, hence the check for leading colon.
if self.ranlib:
try:
# iOS: since clang is not available, we send a nicer error message:
if (sys.platform == 'darwin' and os.uname().machine.startswith('iP')):
raise DistutilsExecError("There are no static linkers available on iOS, sorry.")
#
self.spawn(self.ranlib + [output_filename])
except DistutilsExecError as msg:
raise LibError(msg)
else:
log.debug("skipping %s (up-to-date)", output_filename)
def run(self):
"""
Run `lessc` for each file.
"""
if not self.files:
return
# lessc --include-path=/home/ikus060/workspace/Minarca/rdiffweb.git/rdiffweb/static/less minarca_brand/main.less
for f in self.files:
args = ['lessc']
if self.include_path:
args.append('--include-path=' + self.include_path)
if self.compress:
args.append('--compress')
# Source
args.append(f)
# Destination
destination = f.replace('.less', '.css')
if self.output_dir:
destination = os.path.join(self.output_dir,
os.path.basename(destination))
args.append(destination)
# Execute command line.
try:
subprocess.check_call(args)
except:
raise DistutilsExecError('fail to compile .less files into ' +
f)
def run(self):
if not os.path.exists("epydoc.cfg"):
return
self.mkpath("doc/html")
stat = os.system("epydoc --config epydoc.cfg %s/*.py" % (PACKAGE))
if not stat == 0:
raise DistutilsExecError("failed to run epydoc")
def spawn(self, cmd, dry_run=False, cwd=None):
cmd = list(cmd)
log.info(' '.join(cmd))
if dry_run:
return
try:
exitcode = subprocess.call(cmd, cwd=cwd)
except OSError as exc:
raise DistutilsExecError("command %r failed: %s" %
(cmd, exc.args[-1])) from exc
if exitcode:
raise DistutilsExecError("command %r failed with exit code %s" %
(cmd, exitcode))
def build_extension(self, ext):
if not isinstance(ext, Executable):
build_ext.build_extension(self, ext)
return
exe_fullpath = os.path.join(ext.output_dir, ext.target)
cmd = ext.build_cmd
log.debug("running '{}'".format(cmd))
if not self.dry_run:
env = self._compiler_env.copy()
if ext.env:
env.update(ext.env)
p = subprocess.run(cmd, cwd=ext.cwd, env=env, shell=True)
if p.returncode != 0:
from distutils.errors import DistutilsExecError
raise DistutilsExecError("running '{}' command failed".format(
ext.build_cmd))
dest_path = self.get_ext_fullpath(ext.name)
mkpath(os.path.dirname(dest_path),
verbose=self.verbose,
dry_run=self.dry_run)
copy_file(exe_fullpath,
dest_path,
verbose=self.verbose,
dry_run=self.dry_run)
def _spawn_posix(cmd, search_path=1, verbose=0, dry_run=0):
log.info(' '.join(cmd))
if dry_run:
return
exec_fn = search_path and os.execvp or os.execv
pid = os.fork()
if pid == 0: # in the child
try:
exec_fn(cmd[0], cmd)
except OSError as e:
sys.stderr.write("unable to execute %s: %s\n" %
(cmd[0], e.strerror))
os._exit(1)
sys.stderr.write("unable to execute %s for unknown reasons" % cmd[0])
os._exit(1)
else: # in the parent
# Loop until the child either exits or is terminated by a signal
# (ie. keep waiting if it's merely stopped)
while 1:
try:
pid, status = os.waitpid(pid, 0)
except OSError as exc:
import errno
if exc.errno == errno.EINTR:
continue
raise DistutilsExecError("command '%s' failed: %s" %
(cmd[0], exc[-1]))
if os.WIFSIGNALED(status):
raise DistutilsExecError("command '%s' terminated by signal %d" % \
(cmd[0], os.WTERMSIG(status)))
elif os.WIFEXITED(status):
exit_status = os.WEXITSTATUS(status)
if exit_status == 0:
return # hey, it succeeded!
else:
raise DistutilsExecError("command '%s' failed with exit status %d" % \
(cmd[0], exit_status))
elif os.WIFSTOPPED(status):
continue
else:
raise DistutilsExecError("unknown error executing '%s': termination status %d" % \
(cmd[0], status))
def run(self):
# make sure we're testing the latest
self.run_command('build')
# setup java classpath
version = self.distribution.metadata.get_version()
classpath = os.path.join(self.java_build, 'jep-' + version + '.jar')
classpath += os.pathsep + os.path.join(self.java_build, 'jep-' + version + '-test.jar')
classpath += os.pathsep + 'src/test/python/lib/sqlitejdbc-v056.jar'
classpath += os.pathsep + 'src/test/python/lib/fakenetty.jar'
# setup environment variables
environment = {}
if not is_osx() and not is_windows():
environment['LD_LIBRARY_PATH'] = sysconfig.get_config_var('LIBDIR')
# http://bugs.python.org/issue20614
if is_windows():
environment['SYSTEMROOT'] = os.environ['SYSTEMROOT']
java_path = os.path.join(get_java_home(), 'bin')
# if multiple versions of python are installed, this helps ensure the right
# version is used
executable = sys.executable
if executable:
py_path = os.path.dirname(executable)
# java_path before python_path because py_path might point to a
# default system path, like /usr/bin, which can contain other java
# executables. Since all the subprocesses are Java running jep it
# is very important to get the right java.
environment['PATH'] = java_path + os.pathsep + py_path + os.pathsep + os.environ['PATH']
else:
environment['PATH'] = java_path + os.pathsep + os.environ['PATH']
venv = hasattr(sys, 'real_prefix') or (hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix)
if not venv:
# PYTHONHOME helps locate libraries but should not be set in a virtual env
prefix = sysconfig.get_config_var('prefix')
exec_prefix = sysconfig.get_config_var('exec_prefix')
if prefix == exec_prefix:
environment['PYTHONHOME'] = prefix
else:
environment['PYTHONHOME'] = prefix + ':' + exec_prefix
# find the jep library and makes sure it's named correctly
build_ext = self.get_finalized_command('build_ext')
jep_lib = build_ext.get_outputs()[0]
built_dir = os.path.dirname(jep_lib)
link_native_lib(built_dir, jep_lib)
environment['PYTHONPATH'] = self.get_finalized_command('build').build_lib
# actually kick off the tests
import subprocess
args = [os.path.join(java_path, 'java'),
'-classpath', '{0}'.format(classpath),
'jep.Run', 'src/test/python/runtests.py']
p = subprocess.Popen(args, env=environment)
rc = p.wait()
if rc != 0:
raise DistutilsExecError("Unit tests failed with exit status %d" % (rc))
def _spawn_java(cmd, search_path=1, verbose=0, dry_run=0):
executable = cmd[0]
cmd = ' '.join(_nt_quote_args(cmd))
log.info(cmd)
if not dry_run:
try:
rc = os.system(cmd) >> 8
except OSError as exc:
# this seems to happen when the command isn't found
raise DistutilsExecError("command '%s' failed: %s" %
(executable, exc[-1]))
if rc != 0:
# and this reflects the command running but failing
print(
("command '%s' failed with exit status %d" % (executable, rc)))
raise DistutilsExecError(
"command '%s' failed with exit status %d" % (executable, rc))
def run(self) -> None:
warnings.warn('setup.py build_sphinx is deprecated.',
RemovedInSphinx70Warning,
stacklevel=2)
if not color_terminal():
nocolor()
if not self.verbose: # type: ignore
status_stream = StringIO()
else:
status_stream = sys.stdout # type: ignore
confoverrides: Dict[str, Any] = {}
if self.project:
confoverrides['project'] = self.project
if self.version:
confoverrides['version'] = self.version
if self.release:
confoverrides['release'] = self.release
if self.today:
confoverrides['today'] = self.today
if self.copyright:
confoverrides['copyright'] = self.copyright
if self.nitpicky:
confoverrides['nitpicky'] = self.nitpicky
for builder, builder_target_dir in self.builder_target_dirs:
app = None
try:
confdir = self.config_dir or self.source_dir
with patch_docutils(confdir), docutils_namespace():
app = Sphinx(self.source_dir,
self.config_dir,
builder_target_dir,
self.doctree_dir,
builder,
confoverrides,
status_stream,
freshenv=self.fresh_env,
warningiserror=self.warning_is_error,
verbosity=self.verbosity,
keep_going=self.keep_going)
app.build(force_all=self.all_files)
if app.statuscode:
raise DistutilsExecError('caused by %s builder.' %
app.builder.name)
except Exception as exc:
handle_exception(app, self, exc, sys.stderr)
if not self.pdb:
raise SystemExit(1) from exc
if not self.link_index:
continue
src = app.config.root_doc + app.builder.out_suffix # type: ignore
dst = app.builder.get_outfilename('index') # type: ignore
os.symlink(src, dst)
def run(self):
cmd = ['invoke', 'css']
if self.minify:
cmd.append('--minify')
if self.force:
cmd.append('--force')
try:
p = Popen(cmd,
cwd=pjoin(repo_root, "jupyter_notebook"),
stderr=PIPE)
except OSError:
raise DistutilsExecError(
"invoke is required to rebuild css (pip install invoke)")
out, err = p.communicate()
if p.returncode:
if sys.version_info[0] >= 3:
err = err.decode('utf8', 'replace')
raise DistutilsExecError(err.strip())
