def run(self): create_rpm.run(self, False) # we have one dir under BUILDROOT # we move under the buildroot/pkg-name dir as we do not want then to be part of remote sync _cwd = os.path.join( self.rpm_top_dir, 'BUILDROOT', os.listdir(os.path.join(self.rpm_top_dir, 'BUILDROOT'))[0]) _cmd = ( '/usr/bin/rsync', '-rltvz', '--no-times', '-e', 'ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null', '--progress', '.', 'opc@%s:/tmp/rsynced' % str(self.remote_ip)) ec = subprocess.call(_cmd, cwd=_cwd) if ec != 0: raise DistutilsExecError("rpmbuild execution failed")
def run(self): # sphinx-build -b html docs build\docs_html # defer import so not all setups require sphinx from sphinx.application import Sphinx from sphinx.util.console import nocolor, color_terminal nocolor() source_dir = os.path.join(MYPATH, 'docs') target_dir = os.path.join(MYPATH, 'build', 'docs_html') doctree_dir = os.path.join(target_dir, '.doctree') app = Sphinx(source_dir, source_dir, target_dir, doctree_dir, 'html') app.build() if app.statuscode: raise DistutilsExecError( 'caused by %s builder.' % app.builder.name)
def _spawn_nt(cmd, search_path=1, verbose=0, dry_run=0): executable = cmd[0] cmd = _nt_quote_args(cmd) if search_path: # either we find one or it stays the same executable = find_executable(executable) or executable log.info(' '.join([executable] + cmd[1:])) if not dry_run: # spawn for NT requires a full path to the .exe try: rc = os.spawnv(os.P_WAIT, executable, cmd) except OSError as exc: # this seems to happen when the command isn't found if not DEBUG: cmd = executable raise DistutilsExecError("command %r failed: %s" % (cmd, exc.args[-1])) if rc != 0: # and this reflects the command running but failing if not DEBUG: cmd = executable raise DistutilsExecError("command %r failed with exit status %d" % (cmd, rc))
def run(self): try: from pylint import lint except ImportError: raise DistutilsExecError('pylint is not installed') lint_args = [MODULEDIR] rcfile = os.path.join(TOPDIR, '.pylintrc') if os.path.exists(rcfile): lint_args.extend(['--rcfile', rcfile]) if self.errors_only: lint_args.append('-E') lint_args.extend(['--output-format', self.output_format]) lint.Run(lint_args)
def run(self): # type: () -> None if not color_terminal(): nocolor() if not self.verbose: # type: ignore status_stream = StringIO() else: status_stream = sys.stdout # type: ignore confoverrides = {} 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 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) 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) if not self.link_index: continue src = app.config.master_doc + app.builder.out_suffix # type: ignore dst = app.builder.get_outfilename('index') # type: ignore os.symlink(src, dst)
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(pkgdist.TOPDIR, '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(pkgdist.TOPDIR, '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(pkgdist.TOPDIR, 'ebd', 'generate_eapi_func_list.bash'), eapi], cwd=ebd_dir, env=env, stdout=f): raise DistutilsExecError( "generating EAPI %s function list failed" % eapi)
def run(self): if not color_terminal(): nocolor() if not self.verbose: status_stream = StringIO() else: status_stream = sys.stdout confoverrides = {} 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 app = Sphinx(self.source_dir, self.config_dir, self.builder_target_dir, self.doctree_dir, self.builder, confoverrides, status_stream, freshenv=self.fresh_env, warningiserror=self.warning_is_error) try: app.build(force_all=self.all_files) if app.statuscode: raise DistutilsExecError( 'caused by %s builder.' % app.builder.name) except Exception as err: if self.pdb: import pdb print(darkred('Exception occurred while building, starting debugger:'), file=sys.stderr) traceback.print_exc() pdb.post_mortem(sys.exc_info()[2]) else: from docutils.utils import SystemMessage if isinstance(err, SystemMessage): print(darkred('reST markup error:'), file=sys.stderr) print(err.args[0].encode('ascii', 'backslashreplace'), file=sys.stderr) else: raise if self.link_index: src = app.config.master_doc + app.builder.out_suffix dst = app.builder.get_outfilename('index') os.symlink(src, dst)
def GetSetupSrcDir(): ''' Get the original directory in which setup.py was located, even if setup.py is run through pip. "Platform-independent", though linux and windows untested. :return: setupSrcDir as a string ''' dirVars = ['PWD', 'CD'] for dirVar in dirVars: if os.environ[dirVar]: return os.environ[dirVar] # if we got here something went wrong, so raise an error DistutilsExecError( 'While looking for the original setup.py directory, os.environ did not contain relevant variable: %s' % dirVars)
def run(self): from snakeoil.dist import unittest_extensions build_ext = self.reinitialize_command('build_ext') build_py = self.reinitialize_command('build_py') build_ext.inplace = build_py.inplace = self.inplace build_ext.force = build_py.force = self.force build_ext.ensure_finalized() build_py.ensure_finalized() if self.include_dirs: build_ext.include_dirs = self.include_dirs if not self.pure_python: self.run_command('build_ext') if not self.inplace: self.run_command('build_py') syspath = sys.path[:] mods_to_wipe = () if not self.inplace: cwd = os.getcwd() syspath = [x for x in sys.path if x != cwd] test_path = os.path.abspath(build_py.build_lib) syspath.insert(0, test_path) mods = build_py.find_all_modules() mods_to_wipe = set(x[0] for x in mods) mods_to_wipe.update('.'.join(x[:2]) for x in mods) namespaces = self.namespaces if not self.namespaces: namespaces = [self.default_test_namespace] retval = unittest_extensions.run_tests(namespaces, disable_fork=self.disable_fork, blacklist=self.blacklist, pythonpath=syspath, modules_to_wipe=mods_to_wipe) # remove temporary plugincache so it isn't installed plugincache = os.path.join(os.path.abspath(build_py.build_lib), build_py.package_namespace, 'plugins/plugincache') if os.path.exists(plugincache): os.remove(plugincache) if retval: raise DistutilsExecError("tests failed; return %i" % (retval, ))
def run(self): if os.path.exists(self._indexfilename): with open(self._indexfilename, 'w') as f: f.write('# empty\n') # here no extension enabled, disabled() lists up everything code = ('import pprint; from mercurial import extensions; ' 'pprint.pprint(extensions.disabled())') out, err = runcmd([sys.executable, '-c', code], env) if err: raise DistutilsExecError(err) with open(self._indexfilename, 'w') as f: f.write('# this file is autogenerated by setup.py\n') f.write('docs = ') f.write(out)
def run(self): if self.uptodate(): print("Nothing to do") return if not os.path.exists("autoconf"): os.makedirs("autoconf") if not os.path.exists("autoconf/m4"): os.makedirs("autoconf/m4") with open(os.path.join("autoconf", "configure.ac"), "w") as outfile: outfile.write(self.create_configure_ac()) with open(os.path.join("autoconf", "Makefile.am"), "w") as outfile: outfile.write("print-dist-archives:\n\t@echo '$(DIST_ARCHIVES)'\n") res = os.system("cd autoconf; autoreconf -i") exit_code = res >> 8 if exit_code: raise DistutilsExecError()
def run(self): self.run_command('build') # build if not alredy run orig_path = sys.path[:] try: build_path = abspath(self.build_lib) sys.path.insert(0, build_path) import ceygen.tests as t assert dirname(t.__file__) == join(build_path, 'ceygen', 'tests') suite = unittest.TestLoader().loadTestsFromModule(t) result = unittest.TextTestRunner(verbosity=self.verbose).run(suite) if not result.wasSuccessful(): raise Exception("There were test failures") except Exception as e: raise DistutilsExecError(e) finally: sys.path = orig_path
def build_extension(self, ext): if not isinstance(ext, Executable): build_ext.build_extension(self, ext) return cmd = [sys.executable, ext.script, 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) dest_path = os.path.dirname(dest_path) # I have the impression that this is not the ideal place to declare # this list of files, but for now that's good enough. # I would appreciate some input form Cosimo here on a better approach. # -- Felipe Sanches for dll_filename in [ "Compat.dll", "Glyph.dll", "IronPython.dll", "mono-webkit.dll", "OTFontFileVal.dll", "ValCommon.dll", "GMath.dll", "IronPython.Modules.dll", "OTFontFile.dll", "SharpFont.dll" ]: dll_fullpath = os.path.join(ext.output_dir, dll_filename) copy_file(dll_fullpath, dest_path, verbose=self.verbose, dry_run=self.dry_run)
def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts): compiler_so = self.compiler_so if sys.platform == 'darwin': compiler_so = _osx_support.compiler_fixup(compiler_so, cc_args + extra_postargs) 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 compilers available on iOS, sorry. Command was: ", cc_args) # self.spawn(compiler_so + cc_args + [src, '-o', obj] + extra_postargs) except DistutilsExecError as msg: raise CompileError(msg)
def __init__(self): _gsl_Location.__init__(self) try: import gsl_site except ImportError as des: msg = "I do not know how to run gsl-config \n"+\ "on this system. Therefore you must provide me with the information\n" +\ "where to find the GSL library. I could not import `gsl_site'.\n" +\ "Reason: %s. Copy gsl_site_example.py to gsl_site.py.\n"+\ "Edit the variables in that file to reflect your installation." raise DistutilsExecError(msg % des) self.prefix = gsl_site.prefix self.cflags = gsl_site.cflags self.libs = gsl_site.libs self.swig = gsl_site.swig self.version = self._split_version(gsl_site.version)
def run(self): self.run_command('autoconf') if self.uptodate(): print("Nothing to do") return toks = ['./configure'] options = self.distribution.get_option_dict(self.__class__.__name__) for name, value in options.items(): toks.append('--%s=%s' % (name.replace('_', '-'), value[1])) cmd = "export PYTHON=%s; cd autoconf; " % sys.executable \ + " ".join(toks) print("Configure: %s" % cmd) res = os.system(cmd) exit_code = res >> 8 if exit_code: raise DistutilsExecError()
def create_configure_ac(self): """ Create the `configure.ac` script from the configure_ac setup variable. """ configure_ac = self.distribution.configure_ac for name in ('AC_PREREQ', 'AC_INIT', 'AC_CONFIG_MACRO_DIR', 'AM_INIT_AUTOMAKE', 'AC_CONFIG_FILES', 'AC_OUTPUT'): if name in configure_ac: raise DistutilsExecError("Don't provide `%s` in configure_ac" % name) autoconf_version = self.distribution.autoconf_version if autoconf_version is not None: prereq = "AC_PREREQ([%s])" % autoconf_version else: prereq = "" return self.configure_ac_tmpl % ( prereq, self.distribution.metadata.name or "foo", self.distribution.metadata.version or "1", configure_ac)
def run(self, do_cleanup=True): """ Run the actual sdist command and create the tarball under tarball_dir. Returns ------- No return value. Raises ------ DistutilsExecError On any error. """ log.info("running sdist command now...") self.run_command('sdist') log.info("tarball created, building the RPM now...") _cwd = os.path.dirname(os.path.abspath(__file__)) log.info('current wd [%s]' % _cwd) redefined_top_dir = os.path.join(_cwd, self.rpm_top_dir) spec_file_abs_path = os.path.join(_cwd, self.spec_file_path) v_opt = '--quiet' if self.verbose: v_opt = '-v' if do_cleanup: rpmbuild_cmd = ('/bin/rpmbuild', v_opt, '--define', '_topdir %s' % redefined_top_dir, '-ba', spec_file_abs_path) else: rpmbuild_cmd = ('/bin/rpmbuild', v_opt, '--define', '_topdir %s' % redefined_top_dir, '--noclean', '-ba', spec_file_abs_path) log.info('executing %s' % ' '.join(rpmbuild_cmd)) ec = subprocess.call(rpmbuild_cmd) if ec != 0: raise DistutilsExecError("rpmbuild execution failed")
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") log.info("writing lookup config to %r" % path) with open(path, "w") as f: os.chmod(path, 0o644) 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 = ('bash', '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, )) extra_progs = ('sandbox', ) for prog in extra_progs: try: prog_path = process.find_binary(prog) except process.CommandNotFound: prog_path = '' f.write("%s_BINARY=%r\n" % (prog.upper(), prog_path)) byte_compile([path], prefix=python_base) byte_compile([path], optimize=2, prefix=python_base)
def install(self): """Install docs to target dirs.""" source_path = self.find_content() if source_path is None: raise DistutilsExecError('no generated sphinx content') # determine mapping from doc files to install paths content = self._map_paths(get_file_paths(source_path)) # create directories directories = set(map(os.path.dirname, content.values())) directories.discard('') for x in sorted(directories): self.mkpath(os.path.join(self.install_dir, x)) # copy docs over for src, dst in sorted(content.items()): self.copy_file(os.path.join(source_path, src), os.path.join(self.install_dir, dst))
def run(self): # Ensure the extension is built self.run_command('build') # test the uninstalled extensions libdir = os.path.join(os.getcwd(), self.build_lib) sys.path.insert(0, libdir) import testsuite try: failures = testsuite.run() except RuntimeError, msg: sys.stderr.write('error: %s\n' % msg) raise DistutilsExecError( 'please consult the "Troubleshooting" section in the README file.' )
def copy_file(self, src, dest, *args, **kwds): """ Overridden to validate Python sources before copying them. """ if src.endswith('.py') or (sys.platform == 'win32' and src.endswith('.pyw')): try: # Python 2.3+ f = open(src, 'rU') except: # Python 2.2 f = open(src, 'r') codestring = f.read() codestring = codestring.replace("\r\n", "\n") codestring = codestring.replace("\r", "\n") else: codestring = f.read() f.close() if codestring and codestring[-1] != '\n': codestring = codestring + '\n' try: compile(codestring, src, 'exec') except SyntaxError, detail: msg, (filename, lineno, offset, line) = detail if not filename: filename = src L = [ 'Syntax error in file "%s", line %d: %s' % (filename, lineno, msg) ] if line is not None: i = 0 while i < len(line) and line[i].isspace(): i = i + 1 L.append(' %s' % line.strip()) if offset is not None: s = ' ' for c in line[i:offset - 1]: if c.isspace(): s = s + c else: s = s + ' ' L.append('%s^' % s) raise DistutilsExecError('\n'.join(L))
def CCompiler_spawn(self, cmd, display=None): cmd = quote_args(cmd) """ 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) s, o = exec_command(cmd) if s: 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('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 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 is None: if verbose: zipoptions = '-r' else: zipoptions = '-rq' try: spawn(['zip', zipoptions, zip_filename, base_dir], dry_run=dry_run) except DistutilsExecError: 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) for dirpath, dirnames, filenames in os.walk(base_dir): 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 run(self): self.run_command('build') # build if not alredy run orig_path = sys.path[:] try: tests_path = abspath(self.build_lib) sys.path.insert(0, tests_path) import pybayes.stresses if dirname(pybayes.stresses.__file__) != join( tests_path, 'pybayes', 'stresses'): raise Exception( "Expected that imported pybayes.stresses would be from " + "{0}, but it was from {1} instead".format( tests_path, dirname(pybayes.tests.__file__))) suite = unittest.TestLoader().loadTestsFromModule(pybayes.stresses) result = unittest.TextTestRunner(verbosity=self.verbose).run(suite) if not result.wasSuccessful(): raise Exception("There were test failures") except Exception as e: raise DistutilsExecError(e) finally: sys.path = orig_path
def run(self, firstrun=True): self.source_path = self.find_content() if self.source_path is None: if not firstrun: raise DistutilsExecError( "no pregenerated sphinx content, and sphinx isn't available " "to generate it; bailing") self.run_command(self.build_command) return self.run(False) content = self.scan_content() content = self.content directories = set(map(os.path.dirname, content.values())) directories.discard('') for x in sorted(directories): self.mkpath(os.path.join(self.path, x)) for src, dst in sorted(content.items()): self.copy_file(os.path.join(self.source_path, src), os.path.join(self.path, dst))
class run_check(Command): """ Run all of the tests for the package using uninstalled (local) files """ description = "Automatically run the test suite for the package." user_options = [] def initialize_options(self): self.build_lib = None return def finalize_options(self): # Obtain the build_lib directory from the build command self.set_undefined_options('build', ('build_lib', 'build_lib')) return def run(self): # Ensure the extension is built self.run_command('build') # test the uninstalled extensions libdir = os.path.join(os.getcwd(), self.build_lib) sys.path.insert(0, libdir) import testsuite try: failures = testsuite.run() except RuntimeError, msg: sys.stderr.write('error: %s\n' % msg) raise DistutilsExecError( 'please consult the "Troubleshooting" section in the README file.' ) if failures > 0: raise DistutilsExecError('check failed.') return
def msvc_spawn_and_write_d_file(obj, src, cmd, env, dry_run): ''' Run command with /showIncludes and convert output to dependency (.d) file. ''' log.info(' '.join(cmd)) if dry_run: return process = subprocess.Popen(cmd + ['/showIncludes'], env=env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True) out = process.communicate()[0] deps = set([src]) for line in out.splitlines(): if not line.startswith('Note: including file:'): sys.stderr.write(line + '\n') continue dep = line[21:].strip() dep_lower = dep.lower() if not ( # filter out system headers 'microsoft visual studio' in dep_lower or 'windows kits' in dep_lower): deps.add(dep) if process.returncode != 0: raise DistutilsExecError("command %r failed with exit status %d" % (cmd, process.returncode)) with open(os.path.splitext(obj)[0] + '.d', 'w') as handle: handle.write(': ') for dep in deps: handle.write(' \\\n') handle.write(dep.replace('\\', '\\\\').replace(' ', '\\ '))
def run_for_extension(self, ext: RustExtension): # Make sure that if pythonXX-sys is used, it builds against the current # executing python interpreter. bindir = os.path.dirname(sys.executable) env = os.environ.copy() env.update({ # disables rust's pkg-config seeking for specified packages, # which causes pythonXX-sys to fall back to detecting the # interpreter from the path. "PYTHON_2.7_NO_PKG_CONFIG": "1", "PATH": bindir + os.pathsep + os.environ.get("PATH", ""), }) if not os.path.exists(ext.path): raise DistutilsFileError( f"can't find Rust extension project file: {ext.path}") features = set(ext.features) features.update(rust_features(ext=False, binding=ext.binding)) # test cargo command feature_args = ["--features", " ".join(features)] if features else [] args = (["cargo", "test", "--manifest-path", ext.path] + feature_args + list(ext.args or [])) # Execute cargo command print(" ".join(args)) try: subprocess.check_output(args, env=env) except subprocess.CalledProcessError as e: raise CompileError("cargo failed with code: %d\n%s" % (e.returncode, e.output.decode("utf-8"))) except OSError: raise DistutilsExecError( "Unable to execute 'cargo' - this package " "requires Rust to be installed and " "cargo to be on the PATH") else: print(f"test completed for '{ext.name}' extension")
def run(self): if not color_terminal(): # Windows' poor cmd box doesn't understand ANSI sequences nocolor() if not self.verbose: status_stream = StringIO() else: status_stream = sys.stdout confoverrides = {} 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 app = Sphinx(self.source_dir, self.config_dir, self.builder_target_dir, self.doctree_dir, self.builder, confoverrides, status_stream, freshenv=self.fresh_env) try: app.build(force_all=self.all_files) if app.statuscode: raise DistutilsExecError('caused by %s builder.' % app.builder.name) except Exception, err: from docutils.utils import SystemMessage if isinstance(err, SystemMessage): print >> sys.stderr, darkred('reST markup error:') print >> sys.stderr, err.args[0].encode( 'ascii', 'backslashreplace') else: raise