def build_compiled_library(self, library): import distutils.errors dist = self._dist dist.libraries = [to_dist_compiled_library(library)] bld_cmd, compiler = self._setup_clib() base, filename = os.path.split(self._compiled_library_filename(library.name, compiler)) old_build_clib = bld_cmd.build_clib if base: # workaround for a distutils issue: distutils put all C libraries # in the same directory, and we cannot control the output directory # from the name - we need to hack build_clib directory bld_cmd.build_clib = os.path.join(old_build_clib, base) try: try: # workaround for yet another bug in distutils: distutils f***s up when # building a static library if the target alread exists on at least mac # os x. target = os.path.join(old_build_clib, base, filename) try: os.remove(target) except OSError: e = extract_exception() if e.errno != errno.ENOENT: raise bld_cmd.run() return [relpath(target, self._build_base)] except distutils.errors.DistutilsError: e = extract_exception() raise BuildError(str(e)) finally: bld_cmd.build_clib = old_build_clib
def noexc_main(argv=None): def _print_debug(): if BENTOMAKER_DEBUG: tb = sys.exc_info()[2] traceback.print_tb(tb) def _print_error(msg): pprint('RED', msg) pprint('RED', "(You can see the traceback by setting the " \ "BENTOMAKER_DEBUG=1 environment variable)") try: ret = main(argv) except UsageException: _print_debug() e = extract_exception() _print_error(str(e)) sys.exit(1) except ParseError: _print_debug() e = extract_exception() _print_error(str(e)) sys.exit(2) except ConvertionError: _print_debug() e = extract_exception() _print_error("".join(e.args)) sys.exit(3) except CommandExecutionFailure: _print_debug() e = extract_exception() _print_error("".join(e.args)) sys.exit(4) except bento.core.errors.ConfigurationError: _print_debug() e = extract_exception() _print_error(e) sys.exit(8) except bento.core.errors.BuildError: _print_debug() e = extract_exception() _print_error(e) sys.exit(16) except bento.core.errors.InvalidPackage: _print_debug() e = extract_exception() _print_error(e) sys.exit(32) except Exception: msg = """\ %s: Error: %s crashed (uncaught exception %s: %s). Please report this on bento issue tracker: http://github.com/cournape/bento/issues""" if not BENTOMAKER_DEBUG: msg += "\nYou can get a full traceback by setting BENTOMAKER_DEBUG=1" else: _print_debug() e = extract_exception() pprint('RED', msg % (SCRIPT_NAME, SCRIPT_NAME, e.__class__, str(e))) sys.exit(1) sys.exit(ret)
def get_package(self, bento_info, user_flags=None): try: return self._get_package(bento_info, user_flags) except Exception: e = extract_exception() warnings.warn("Resetting invalid cache (error was %r)" % e) self._reset() return self._get_package(bento_info, user_flags)
def get_options(self, bento_info): try: return self._get_options(bento_info) except Exception: e = extract_exception() warnings.warn("Resetting invalid cache (error was %r)" % e) self._reset() return self._get_options(bento_info)
def raw_parse(data, filename=None): try: ret = _parse(data) return ret except ParseError: e = extract_exception() e.filename = filename raise
def build_compiled_library(bld, clib, env=None): builder = bld.builders["ctasks"] try: for p in clib.include_dirs: builder.env["CPPPATH"].insert(0, p) outputs = builder.static_library(clib.name, clib.sources, env) return [n.bldpath() for n in outputs] except RuntimeError: e = extract_exception() msg = "Building library %s failed: %s" % (clib.name, str(e)) raise CommandExecutionFailure(msg)
def test_simple(self): text = """\ NName: foo """ self.assertRaises(ParseError, lambda : PackageDescription.from_string(text)) try: PackageDescription.from_string(text) raise AssertionError("Should raise here !") except ParseError: e = extract_exception() self.assertEqual(str(e), "yacc: Syntax error at line 1, Token(WORD, 'NName')")
def setup(self): extensions = get_extensions(self.pkg, self.run_node) libraries = get_compiled_libraries(self.pkg, self.run_node) yaku_ctx = self.yaku_context if extensions or libraries: for t in ["ctasks", "pyext"]: try: yaku_ctx.use_tools([t]) except yaku.errors.ConfigurationFailure: e = extract_exception() raise ConfigurationError(str(e))
def __init__(self, db_location): self._location = db_location self._first_time = False if not os.path.exists(db_location): ensure_dir(db_location) self._reset() else: try: self.db = self._load_existing_cache(db_location) except Exception: e = extract_exception() warnings.warn("Resetting invalid cached db: (reason: %r)" % e) self._reset()
def makedirs(self, name, mode=MODE_777): head, tail = os.path.split(name) if not tail: head, tail = os.path.split(head) if head and tail and not os.path.exists(head): try: self.makedirs(head, mode) except OSError: e = extract_exception() if e.errno != errno.EEXIST: raise if tail == os.curdir: return self.mkdir(name, mode)
def test_error_string(self): f = self.f f.write("NName: foo") f.flush() try: PackageDescription.from_file(f.name) raise AssertionError("Should raise here !") except ParseError: e = extract_exception() self.assertEqual(str(e), """\ File "%s", line 1 NName: foo ^ Syntax error""" % f.name)
def _rollback_operation(line): operation, arg = line.split() if operation == "MKDIR": try: os.rmdir(arg) except OSError: e = extract_exception() # FIXME: hardcoded errno !! if e.errno != 66: raise elif operation == "COPY": os.remove(arg) else: raise ValueError("Unknown operation: %s" % operation)
def run(self, ctx): argv = ctx.get_command_arguments() p = ctx.options_context.parser o, a = p.parse_args(argv) if o.help: p.print_help() return if len(a) < 1: filename = "bento.info" else: filename = a[0] if not os.path.exists(filename): raise UsageException("%s: error: file %s does not exist" % "bentomaker") f = open(filename, "r") try: data = f.read() try: parsed = build_ast_from_data(data) except ParseError: e = extract_exception() msg = "Error while parsing file %s\n" % filename e.args = (msg,) + e.args raise e if o.flags: try: flags = parsed["flags"] for flag in flags: print(flags[flag]) except KeyError: pass elif o.path: try: paths = parsed["paths"] for path in paths: print(paths[path]) except KeyError: pass elif o.meta_field: try: print(parsed[o.meta_field]) except KeyError: raise ValueError("Field %s not found in metadata" % o.meta_field) else: pprint(parsed) finally: f.close()
def build_extension(self, extension): import distutils.errors dist = self._dist dist.ext_modules = [toyext_to_distext(extension)] bld_cmd, compiler = self._setup_ext() try: bld_cmd.run() base, filename = os.path.split(self._extension_filename(extension.name, bld_cmd)) fullname = os.path.join(bld_cmd.build_lib, base, filename) return [relpath(fullname, self._build_base)] except distutils.errors.DistutilsError: e = extract_exception() raise BuildError(str(e))
def build_extension(bld, extension, env=None): builder = bld.builders["pyext"] try: if env is None: env = {"PYEXT_CPPPATH": extension.include_dirs} else: val = env.get("PYEXT_CPPPATH", []) val.extend(extension.include_dirs) tasks = builder.extension(extension.name, extension.sources, env) if len(tasks) > 1: outputs = tasks[0].gen.outputs else: outputs = [] return [n.bldpath() for n in outputs] except RuntimeError: e = extract_exception() msg = "Building extension %s failed: %s" % \ (extension.name, str(e)) raise CommandExecutionFailure(msg)
def _test_impl(self, data, ref): res = [] while True: tok = self.lexer.token() if not tok: break res.append(tok.type) if is_string(ref): ref = split(ref) try: assert_equal(res, ref) except AssertionError: e = extract_exception() cnt = 0 for i, j in zip(res, ref): if not i == j: break cnt += 1 print("Break at index %d" % cnt) raise e
def analyse_setup_py(filename, setup_args): pprint('PINK', "======================================================") pprint('PINK', " Analysing %s (running %s) .... " % (filename, filename)) # exec_globals contains the globals used to execute the setup.py exec_globals = {} exec_globals.update(globals()) # Some setup.py files call setup from their main, so execute them as if # they were the main script exec_globals["__name__"] = "__main__" exec_globals["__file__"] = os.path.abspath(filename) _saved_argv = sys.argv[:] _saved_sys_path = sys.path try: try: sys.argv = [filename] + setup_args + ["build_py"] # XXX: many packages import themselves to get version at build # time, and setuptools screw this up by inserting stuff first. Is # there a better way ? sys.path.insert(0, os.path.dirname(filename)) execfile(filename, exec_globals) if type == "distutils" and "setuptools" in sys.modules: pprint("YELLOW", "Setuptools detected in distutils mode !!!") except Exception: e = extract_exception() pprint('RED', "Got exception: %s" % e) raise e finally: sys.argv = _saved_argv sys.path = _saved_sys_path if not "dist" in LIVE_OBJECTS: raise ValueError("setup monkey-patching failed") dist = LIVE_OBJECTS["dist"] pprint('PINK', " %s analyse done " % filename) pprint('PINK', "======================================================") return dist
def build_egg(ipkg, ctx, source_root, path=None): meta = PackageMetadata.from_ipkg(ipkg) egg_info = EggInfo.from_ipkg(ipkg, ctx.build_node) # FIXME: fix egg name if path is None: egg = egg_filename(os.path.join("dist", meta.fullname)) else: egg = egg_filename(os.path.join(path, meta.fullname)) ensure_dir(egg) zid = compat.ZipFile(egg, "w", compat.ZIP_DEFLATED) try: ipkg.update_paths({"prefix": source_root.abspath(), "eprefix": source_root.abspath(), "sitedir": source_root.abspath()}) for filename, cnt in egg_info.iter_meta(ctx.build_node): zid.writestr(os.path.join("EGG-INFO", filename), cnt) file_sections = ipkg.resolve_paths(source_root) for kind, source, target in iter_files(file_sections): if not kind in ["executables"]: zid.write(source.abspath(), target.path_from(source_root)) pprint("PINK", "Byte-compiling ...") for kind, source, target in iter_files(file_sections): if kind in ["pythonfiles"]: try: bytecode = bcompile(source.abspath()) except PyCompileError: e = extract_exception() warnings.warn("Error byte-compiling %r" % source.abspath()) else: zid.writestr("%sc" % target.path_from(source_root), bcompile(source.abspath())) finally: zid.close() return
def to_pat(s): lst = to_list(s) ret = [] for x in lst: x = x.replace('\\', '/').replace('//', '/') if x.endswith('/'): x += '**' lst2 = x.split('/') accu = [] for k in lst2: if k == '**': accu.append(k) else: k = k.replace('.', '[.]').replace('*','.*').replace('?', '.').replace('+', '\\+') k = '^%s$' % k try: #print "pattern", k accu.append(re.compile(k)) except Exception: e = extract_exception() raise ValueError("Invalid pattern: %s" % k, e) ret.append(accu) return ret
def create_hook_module(target): import imp safe_name = SAFE_MODULE_NAME.sub("_", target, len(target)) module_name = "bento_hook_%s" % safe_name main_file = os.path.abspath(target) module = imp.new_module(module_name) module.__file__ = main_file code = open(main_file).read() sys.path.insert(0, os.path.dirname(main_file)) try: try: exec(compile(code, main_file, 'exec'), module.__dict__) sys.modules[module_name] = module except SyntaxError: e = extract_exception() raise SyntaxError("Invalid syntax in hook file %s, line %s" % (main_file, e.lineno)) finally: sys.path.pop(0) module.root_path = main_file if not "startup" in __INIT_FUNCS: module.startup = dummy_startup else: module.startup = __INIT_FUNCS["startup"] if not "options" in __INIT_FUNCS: module.options = dummy_options else: module.options = __INIT_FUNCS["options"] if not "shutdown" in __INIT_FUNCS: module.shutdown = dummy_shutdown else: module.shutdown = __INIT_FUNCS["shutdown"] return module
def run(self, ctx): argv = ctx.get_command_arguments() p = ctx.options_context.parser o, a = p.parse_args(argv) if o.help: p.print_help() return if len(a) < 1: filename = "setup.py" else: filename = a[0] if not os.path.exists(filename): raise ValueError("file %s not found" % filename) output = o.output_filename if os.path.exists(output): raise UsageException("file %s exists, not overwritten" % output) if o.verbose: show_output = True else: show_output = False if o.setup_args: setup_args = comma_list_split(o.setup_args) else: setup_args = ["-q", "-n"] tp = o.type convert_log = "convert.log" log = open(convert_log, "w") try: try: if tp == "automatic": try: pprint("PINK", "Catching monkey (this may take a while) ...") tp = detect_monkeys(filename, show_output, log) pprint("PINK", "Detected mode: %s" % tp) except ValueError: e = extract_exception() raise UsageException("Error while detecting setup.py type " \ "(original error: %s)" % str(e)) monkey_patch(tp, filename) # analyse_setup_py put results in LIVE_OBJECTS dist = analyse_setup_py(filename, setup_args) pkg, options = build_pkg(dist, LIVE_OBJECTS, ctx.top_node) out = static_representation(pkg, options) if output == '-': for line in out.splitlines(): pprint("YELLOW", line) else: fid = open(output, "w") try: fid.write(out) finally: fid.close() except ConvertionError: raise except Exception: e = extract_exception() log.write("Error while converting - traceback:\n") tb = sys.exc_info()[2] traceback.print_tb(tb, file=log) msg = "Error while converting %s - you may look at %s for " \ "details (Original exception: %s %s)" raise ConvertionError(msg % (filename, convert_log, type(e), str(e))) finally: log.flush() log.close()