def _main(): if on_mac(): die("Cross-checking is only supported on Linux hosts.") setup_logging() logging.debug("args: %s", " ".join(sys.argv)) # earlier plumbum versions are missing features such as TEE if pb.__version__ < c.MIN_PLUMBUM_VERSION: err = "locally installed version {} of plumbum is too old.\n" \ .format(pb.__version__) err += "please upgrade plumbum to version {} or later." \ .format(c.MIN_PLUMBUM_VERSION) die(err) args = _parse_args() if args.clean_all: logging.info("cleaning all dependencies and previous built files") shutil.rmtree(c.CLANG_XCHECK_PLUGIN_BLD, ignore_errors=True) make = get_cmd_or_die('make') with pb.local.cwd(c.LIBFAKECHECKS_DIR): make('clean') # clang 3.6.0 is known to work; 3.4.0 known to not work. ensure_clang_version([3, 6, 0]) # NOTE: it seems safe to disable this check since we now # that we use a rust-toolchain file for rustc versioning. # ensure_rustc_version(c.CUSTOM_RUST_RUSTC_VERSION) ensure_dir(c.CLANG_XCHECK_PLUGIN_BLD) ensure_dir(c.BUILD_DIR) git_ignore_dir(c.BUILD_DIR) build_clang_plugin(args)
def _main(): setup_logging() logging.debug("args: %s", " ".join(sys.argv)) # earlier plumbum versions are missing features such as TEE if pb.__version__ < c.MIN_PLUMBUM_VERSION: err = "locally installed version {} of plumbum is too old.\n" \ .format(pb.__version__) err += "please upgrade plumbum to version {} or later." \ .format(c.MIN_PLUMBUM_VERSION) die(err) args = _parse_args() if args.clean_all: logging.info("cleaning all dependencies and previous built files") shutil.rmtree(c.CLANG_XCHECK_PLUGIN_BLD, ignore_errors=True) # prerequisites if not have_rust_toolchain(c.CUSTOM_RUST_NAME): die("missing rust toolchain: " + c.CUSTOM_RUST_NAME, errno.ENOENT) # clang 3.6.0 is known to work; 3.4.0 known to not work. ensure_clang_version([3, 6, 0]) ensure_rustc_version(c.CUSTOM_RUST_RUSTC_VERSION) ensure_dir(c.CLANG_XCHECK_PLUGIN_BLD) ensure_dir(c.DEPS_DIR) git_ignore_dir(c.DEPS_DIR) build_clang_plugin(args)
def test_setup_logging_invalid_log_level(self): logger = Mock() with self.assertRaises(Exception) as context: common.setup_logging(logger, '/dev/null', '%(name)s: %(message)s', 'banana') assert str(context.exception) == 'Invalid log level: BANANA'
def main(): """Generate a new csmith test case and compare its execution to the translated Rust version.""" validate_csmith_home() common.setup_logging() with tempfile.TemporaryDirectory('_c2rust_csmith') as dirname: # generate filenames based on tempdir output_c_name = os.path.join(dirname, 'output.c') output_c_exe_name = os.path.join(dirname, 'output.c.exe') output_rs_name = os.path.join(dirname, 'output.rs') output_rs_exec_name = os.path.join(dirname, 'output.rs.exe') logging.info("Using temporary directory: %s", dirname) # Generate and run C version generate_c_source(dirname, output_c_name) compile_c_file(output_c_name, output_c_exe_name) expected_output = execute_driver(output_c_exe_name) # Generate and run Rust version transpile_file(dirname, output_c_name) compile_rust_file(output_c_name, output_rs_name, output_rs_exec_name) actual_output = execute_driver(output_rs_exec_name) if expected_output == actual_output: logging.info("Match") else: logging.info("FAILURE: %s %s", expected_output, actual_output) copyfile(output_c_name, 'output.c') copyfile(output_rs_name, 'output.rs')
def main(): oparser = add_options() (options, args) = oparser.parse_args() if not args: oparser.print_help() sys.exit() if not os.path.isfile(args[0]): print "Configuration file %s not existing." % args[0] sys.exit(-1) config_file = norm_path(args[0]) config = configuration.parse_merge(config_file) loglevel = config.getroot().get("loglevel", 10) common.setup_logging("~/.flof/flof.log", loglevel) register_bundled_workers() if options.only: WorkerRegistry.workers = filter(lambda a: a in options.only.split(","), WorkerRegistry.workers) if options.do_not: WorkerRegistry.workers = filter(lambda a: a not in options.do_not.split(","), WorkerRegistry.workers) os.chdir(os.path.dirname(norm_path(args[0]))) context = ContextManager({"config_file" : config_file}) context.overrides = parse_context(options.context) RootWorker(config, context).run()
def __init__(self, config_file): """ Initialize the config object loading from ini file :param config_path: the path to the configuration file to load """ # Initial log setup setup_logging("promoter", logging.DEBUG) self.git_root, self.script_root = get_root_paths(self.log) self.log.debug("Config file passed: %s", config_file) self.log.debug("Git root %s", self.git_root) if config_file is None: raise ConfigError("Empty config file") # The path is either absolute ot it's relative to the code root if not os.path.isabs(config_file): config_file = os.path.join(self.script_root, "config", config_file) try: os.stat(config_file) except OSError: self.log.error("Configuration file not found") raise self.log.debug("Using config file %s", config_file) self._file_config = self.load_from_ini(config_file) self._config = self.load_config(config_file, self._file_config) # Load keys as config attributes for key, value in self._config.items(): setattr(self, key, value)
def main(): oparser = add_options() (options, args) = oparser.parse_args() if not args: oparser.print_help() sys.exit() if not os.path.isfile(args[0]): print "Configuration file %s not existing." % args[0] sys.exit(-1) config_file = norm_path(args[0]) config = configuration.parse_merge(config_file) loglevel = config.getroot().get("loglevel", 10) common.setup_logging("~/.flof/flof.log", loglevel) register_bundled_workers() if options.only: WorkerRegistry.workers = filter(lambda a: a in options.only.split(","), WorkerRegistry.workers) if options.do_not: WorkerRegistry.workers = filter( lambda a: a not in options.do_not.split(","), WorkerRegistry.workers) os.chdir(os.path.dirname(norm_path(args[0]))) context = ContextManager({"config_file": config_file}) context.overrides = parse_context(options.context) RootWorker(config, context).run()
def main(argv): # setup and parse arguments parser = argparse.ArgumentParser(description=DESCRIPTION) parser.add_argument('-o', '--output', required=True, action='store', metavar='DIR', help='the output directory where files will be rebuilt') parser.add_argument('inputs', metavar='IN_DIR', type=str, nargs='+', help='list of directories from where input chunks are taken') parser.add_argument('-f', '--force', action='store_true', help='overwrite the output directory, even if it exists') parser.add_argument('-v', '--verbose', action='store_true', help='detailed output of operations') parser.add_argument('-d', '--debug', action='store_true', help='debug information') # create namespace with args ns = parser.parse_args(args=argv) common.setup_logging(ns) _verify_args(ns) _fec_decode(ns)
def main(): setup_logging() # checkout_and_build_libclevrbuf() build_libfakechecks() test_clang_cross_checks() test_rust_cross_checks()
def _main(): setup_logging() logging.debug("args: %s", " ".join(sys.argv)) # FIXME: allow env/cli override of LLVM_SRC and LLVM_BLD # FIXME: check that cmake and ninja are installed # FIXME: option to build LLVM/Clang from master? args = _parse_args() if args.clean_all: logging.info("cleaning all dependencies and previous built files") shutil.rmtree(c.LLVM_SRC, ignore_errors=True) shutil.rmtree(c.LLVM_BLD, ignore_errors=True) shutil.rmtree(c.BUILD_DIR, ignore_errors=True) shutil.rmtree(c.AST_EXPO_PRJ_DIR, ignore_errors=True) cargo = get_cmd_or_die("cargo") with pb.local.cwd(c.ROOT_DIR): invoke(cargo, "clean") ensure_dir(c.LLVM_BLD) ensure_dir(c.BUILD_DIR) git_ignore_dir(c.BUILD_DIR) download_llvm_sources() configure_and_build_llvm(args) build_transpiler(args) print_success_msg(args)
def main(): setup_logging() if not len(sys.argv) == 3: print( "usage: print_clang_ast.py <file.c> path/to/compile_commands.json", file=sys.stderr) exit(1) c_file: str = os.path.basename(sys.argv[1]) compile_commands_path: str = sys.argv[2] # do we have clang in path? get_cmd_or_die("clang") try: with open(compile_commands_path, "r") as fh: commands = json.load(fh) except FileNotFoundError: die(f"file not found: " + compile_commands_path) commands = filter( lambda c: os.path.basename(c["file"]) == c_file, commands) cmd = next(commands, None) if not cmd: die(f"no command to compile {c_file}") elif next(commands, None): logging.warning(f"warning: found multiple commands for {c_file}") dump_ast(cmd)
def __init__(self, config_class=PromoterConfig): """ Initialize the config object loading from ini file :param config_path: the path to the configuration file to load :param validate: A comma separated list of checks for the config file """ # Initial log setup setup_logging("promoter", logging.DEBUG) self.git_root = None self.script_root = None self.git_root, self.script_root = get_root_paths(self.log) self.log.debug("Git root %s", self.git_root) self.log.debug("Script root %s", self.git_root) self.rel_roots_map = { "global_defaults": os.path.join(self.script_root, "config_environments"), "environments_pool": os.path.join(self.script_root, "config_environments"), } self.global_defaults = self.load_yaml_config("global_defaults", "global_defaults.yaml") self.global_defaults['git_root'] = self.git_root self.global_defaults['script_root'] = self.script_root self.config_class = config_class
def test_setup_logging_correct_log_file(self, mock_log_info): __, filepath = tempfile.mkstemp() setup_logging("tests", logging.DEBUG, log_file=filepath) os.unlink(filepath) mock_log_info.assert_has_calls([ mock.call('Set up logging level %%s on: file %s' % filepath, 'DEBUG') ])
def test_close_logging(self): __, filepath = tempfile.mkstemp() setup_logging("test", logging.DEBUG, log_file=filepath) logger = logging.getLogger("test") self.assertGreater(len(logger.handlers), 0) close_logging("test") self.assertEqual(len(logger.handlers), 0) os.unlink(filepath)
def _main(): setup_logging() logging.debug("args: %s", " ".join(sys.argv)) # FIXME: allow env/cli override of LLVM_SRC, LLVM_VER, and LLVM_BLD # FIXME: check that cmake and ninja are installed # FIXME: option to build LLVM/Clang from master? # earlier plumbum versions are missing features such as TEE if pb.__version__ < c.MIN_PLUMBUM_VERSION: err = "locally installed version {} of plumbum is too old.\n" \ .format(pb.__version__) err += "please upgrade plumbum to version {} or later." \ .format(c.MIN_PLUMBUM_VERSION) die(err) args = _parse_args() # prerequisites if not have_rust_toolchain(c.CUSTOM_RUST_NAME): die("missing rust toolchain: " + c.CUSTOM_RUST_NAME, errno.ENOENT) # clang 3.6.0 is known to work; 3.4.0 known to not work. ensure_clang_version([3, 6, 0]) if args.clean_all: logging.info("cleaning all dependencies and previous built files") shutil.rmtree(c.LLVM_SRC, ignore_errors=True) shutil.rmtree(c.LLVM_BLD, ignore_errors=True) shutil.rmtree(c.DEPS_DIR, ignore_errors=True) shutil.rmtree(c.AST_EXPO_PRJ_DIR, ignore_errors=True) cargo = get_cmd_or_die("cargo") with pb.local.cwd(c.ROOT_DIR): invoke(cargo, "clean") ensure_dir(c.LLVM_BLD) ensure_dir(c.DEPS_DIR) git_ignore_dir(c.DEPS_DIR) download_llvm_sources() update_cmakelists() configure_and_build_llvm(args) build_transpiler(args) # print a helpful message on how to run c2rust bin directly c2rust_bin_path = 'target/debug/c2rust' if args.debug \ else 'target/release/c2rust' c2rust_bin_path = os.path.join(c.ROOT_DIR, c2rust_bin_path) # if os.path.curdir abs_curdir = os.path.abspath(os.path.curdir) common_path = os.path.commonpath([abs_curdir, c2rust_bin_path]) if common_path != "/": c2rust_bin_path = "." + c2rust_bin_path[len(common_path):] print("success! you may now run", c2rust_bin_path)
def _main(): setup_logging() logging.debug("args: %s", " ".join(sys.argv)) # FIXME: allow env/cli override of LLVM_SRC, LLVM_VER, and LLVM_BLD # FIXME: check that cmake and ninja are installed # FIXME: option to build LLVM/Clang from master? # earlier plumbum versions are missing features such as TEE if pb.__version__ < c.MIN_PLUMBUM_VERSION: err = "locally installed version {} of plumbum is too old.\n" \ .format(pb.__version__) err += "please upgrade plumbum to version {} or later." \ .format(c.MIN_PLUMBUM_VERSION) die(err) args = _parse_args() if args.clean_all: logging.info("cleaning all dependencies and previous built files") shutil.rmtree(c.LLVM_SRC, ignore_errors=True) shutil.rmtree(c.LLVM_BLD, ignore_errors=True) shutil.rmtree(c.DEPS_DIR, ignore_errors=True) # prerequisites if not have_rust_toolchain(c.CUSTOM_RUST_NAME): die("missing rust toolchain: " + c.CUSTOM_RUST_NAME, errno.ENOENT) # clang 3.6.0 is known to work; 3.4.0 known to not work. ensure_clang_version([3, 6, 0]) ensure_rustc_version(c.CUSTOM_RUST_RUSTC_VERSION) ensure_dir(c.LLVM_BLD) ensure_dir(c.DEPS_DIR) git_ignore_dir(c.DEPS_DIR) if on_linux(): build_a_bear() if not os.path.isfile(c.BEAR_BIN): die("bear not found", errno.ENOENT) download_llvm_sources() integrate_ast_exporter() cc_db = install_tinycbor() configure_and_build_llvm(args) # NOTE: we're not doing this anymore since it is # faster and takes less space to simply pull the # prebuilt nightly binaries with rustup # download_and_build_custom_rustc(args) build_ast_importer(args.debug) if not on_mac() and args.sanity_test: test_ast_exporter(cc_db)
def main(): setup_logging() # prerequisites if not have_rust_toolchain(c.CUSTOM_RUST_NAME): die("missing rust toolchain: " + c.CUSTOM_RUST_NAME, errno.ENOENT) # checkout_and_build_libclevrbuf() test_cross_checks()
def main(): setup_logging() logging.debug("args: %s", " ".join(sys.argv)) args = parse_args() c.update_args(args) transpile_files(args.commands_json, args.filter, args.extra_impo_args, args.import_only, args.verbose, args.emit_build_files, args.main, args.cross_checks, args.use_fakechecks, args.cross_check_config, args.reloop_cfgs) logging.info("success")
def main(): arg_parser = argparse.ArgumentParser() # Register common args. common.register_args(arg_parser) # Filters for targets. arg_parser.add_argument('--include_inactive', type=bool, default=True) arg_parser.add_argument('--include_normal', type=bool, default=False) arg_parser.add_argument('--include_honorable', type=bool, default=False) arg_parser.add_argument('--include_strong', type=bool, default=False) arg_parser.add_argument('--rank_min', type=int, required=True, help='Min rank to send probes') arg_parser.add_argument('--rank_max', type=int, required=True, help='Max rank to send probes') # Scan config. arg_parser.add_argument('--planet_num', type=int, default=0, help='Which planet to send probes from') arg_parser.add_argument('--parallelism', type=int, required=True, help='Num missions to send at a time') arg_parser.add_argument('-n', '--max_scans', type=int, required=True, help='Num of scans before exiting') arg_parser.add_argument('--systems_to_skip', type=int, default=0, help='Skip the N closest systems') arg_parser.add_argument( '--galaxy', type=int, help='If present, scan this galaxy instead of the home galaxy') # Args for universe structure. arg_parser.add_argument('--num_galaxies', type=int, default=7) arg_parser.add_argument('--num_systems', type=int, default=499) args = arg_parser.parse_args() common.setup_logging(args) b = common.open_browser_and_connect(args) scan(b, args)
def main(): common.setup_logging() calc_pe_ratio_ftm() calc_garp_ratio() calc_ranks() calc_magic_formula_trailing() calc_magic_formula_future() calc_magic_formula_ranks()
def sanity_check(self, config, file_config, checks="all"): """ There are several exceptions that can block the load - Missing main section - Missing criteria section for one of the specified candidates - Missing jobs in criteria section - Missing mandatory parameters - Missing password """ conf_ok = True mandatory_parameters = [ "distro_name", "distro_version", "release", "api_url", "log_file", ] if checks == "all": checks = ["logs", "parameters", "password", "criteria"] if 'logs' in checks: try: setup_logging('promoter', config['log_level'], config['log_file']) except LoggingError: conf_ok = False for key, value in config.items(): if key in mandatory_parameters and key not in file_config['main']: self.log.warning( "Missing parameter in configuration file: %s." " Using default value: %s" "", key, value) if 'username' not in file_config['main']: self.log.warning( "Missing parameter in configuration file: " "username. Using default value: %s" "", config['dlrnauth_username']) if "password" in checks: if config['dlrnauth_password'] is None: self.log.error("No dlrnapi password found in env") conf_ok = False if "criteria" in checks: for target_name, job_list in \ config['promotion_criteria_map'].items(): if not job_list: self.log.error("No jobs in criteria for target %s", target_name) conf_ok = False return conf_ok
def main(): # TODO: implement rustfmt and diff actions from `run-test.sh` setup_logging() ensure_rustc_version(c.CUSTOM_RUST_RUSTC_VERSION) # TODO: update rustfmt version check once idiomize bitrot has been fixed # ensure_rustfmt_version() test_dir = os.path.join(c.RREF_DIR, "tests") assert os.path.isdir(test_dir), "test dir missing: " + test_dir idiomize_binary = os.path.join(c.RREF_DIR, "target/debug/idiomize") if not os.path.isfile(idiomize_binary): die("build idiomize binary first. expected: " + idiomize_binary) testcases = get_testcases(test_dir) run_tests(sorted(testcases))
def main(): setup_logging() parser = ArgumentParser() parser.add_argument('channel_directory') parser.add_argument('local_path') args = parser.parse_args() local_path = Path(args.local_path) upload( args.channel_directory, local_path.name, local_path, )
def main(): port = common.get_port() leader.spawn(port) common.setup_logging() logger.info("ssvim starting! :>") selector = selectors.DefaultSelector() client = Client(port, selector) client.run() while True: for key, mask in selector.select(): callback = key.data callback(key.fileobj)
def setup_app(usage="%prog [options] ...", description=None, argstest=lambda args: len(args) == 0, logname='app', extra_options=None): u"""Функция, выполняющая основные настройки cli-приложения @param usage: строка использования для OptionParser @param description: описание приложения @param argstest: функция, проверяющая правильность неименованных аргументов @param logname: имя программы для сообщений в log """ parser = common.default_option_parser() parser.usage = usage parser.description = description and re.sub(r"\s+", " ", description) if extra_options is not None: group = OptionGroup(parser, parser.expand_prog_name("%prog options")) extra_options(group) parser.add_option_group(group) (options, args) = parser.parse_args() setup_encoding(options.io_encoding) ExceptionHandler() if options.help_exit_codes: common.print_exit_codes() sys.exit(exit_codes.success) if len(inspect.getargspec(argstest)[0]) == 1: args_valid = argstest(args) else: args_valid = argstest(args, options) if not args_valid: parser.print_help() sys.exit(exit_codes.bad_usage) common.setup_logging(options) common.finalize_options(options) service = PilotService(options.pilot_url, build_ssl_ctx(options), options.retries, options.connection_debug) if options.timeout is not None: signal.signal(signal.SIGALRM, sigalrm_handler) signal.alarm(options.timeout) return (options, args, logging.getLogger(logname), service)
def main(): common.setup_logging() parser = argparse.ArgumentParser() args = parser.parse_args() for exchange in EXCHANGES: LOGGER.info('Getting exchange: %s' % exchange) for company in get_companies(exchange): data.set_company( symbol=company.symbol, name=company.name, sector=company.sector, industry=company.industry, )
def main(): common.setup_logging("talk_asyncio_server", level=logging.DEBUG) loop = asyncio.get_event_loop() server_future = loop.create_server(QuestionHandler, config.SERVER_HOST, config.SERVER_PORT) loop.run_until_complete(server_future) logging.info("Starting server...") try: loop.run_forever() except KeyboardInterrupt: pass except Exception as ex: logging.error("Error in execution: %s", ex)
def main(argv): manual, name = parse_cmd_args(argv) auto = not manual client = None try: if auto: common.setup_logging() else: FORMAT = '%(filename)s: %(message)s' logging.basicConfig(level=logging.DEBUG, format=FORMAT, filename='client.log') logging.info('Logging started') client = Client(name, common.HOST, common.PORT, auto=auto) # join the server client.send_msg('[cjoin|{}]'.format(name.ljust(8))) while not client.msgs: client.recv_msgs() msg = client.get_msg() assert msg, 'No msg, self.msgs = '.format(client.msgs) while message.msg_type(msg) != 'sjoin': # logging.warn('Client {} received an unexpected message: {}'.format(client.name, msg)) msg = client.get_msg() # validate msg name = message.fields(msg)[0].strip() client.player = common.Player(name) logging.info('Client {} successfully joined with name {}'.format(client.name, name)) if client.gui: client.gui.print_msg("Succesfully joined server with name {}".format( client.player.name)) client.game_loop() if client.gui: client.gui.print_msg("Quitting, press any key to confirm") client.disconnect() if client.gui: client.gui.curses_thread.join() logging.info("Client %s quitting", client.name) except Exception as ex: logging.info('Client caught exception: %s', ex) raise ex return
def main(): setup_logging('ddns2.log') config = get_config('router', 'ddns') logging.info("starting ddns") ddns_config = config['DDNS_CONFIG'] resource4 = ddns_config['resource4'] resource6 = ddns_config['resource6'] domain = ddns_config['domain'] pppoe_interface = ddns_config['pppoe_interface'] ipv6_pool_name = ddns_config['ipv6_pool_name'] logging.info("loaded config, connecting to router") router_api = RouterOsApiPool(**(config['ROUTER_CONFIG'])).get_api() while True: try: for local_ip, resource in ((get_local_ipv4(router_api, pppoe_interface), resource4), (get_local_ipv6(router_api, ipv6_pool_name), resource6)): current_ip, record_name = get_current_record_ip( domain, resource) if local_ip is not None and current_ip != local_ip: logging.info( f"updating record {record_name} from {current_ip} to {local_ip}" ) update_record_ip(domain, resource, local_ip) heartbeat() except RouterOsApiConnectionError: logging.warning('resetting router api') router_api = RouterOsApiPool( **(get_config('router')['ROUTER_CONFIG'])).get_api() except JSONDecodeError: logging.exception('linode JSONDecodeError') except (requests.exceptions.RequestException, OSError): logging.exception('RequestException issues') except: logging.exception("error") raise finally: sleep(30)
def main(): # TODO: implement rustfmt and diff actions from `run-test.sh` setup_logging() # NOTE: it seems safe to disable this check since we now # that we use a rust-toolchain file for rustc versioning. # ensure_rustc_version(c.CUSTOM_RUST_RUSTC_VERSION) # TODO: update rustfmt version check once c2rust-refactor bitrot has been fixed # ensure_rustfmt_version() test_dir = os.path.join(c.RREF_DIR, "tests") assert os.path.isdir(test_dir), "test dir missing: " + test_dir refactor_binary = os.path.join(c.ROOT_DIR, "target/debug/c2rust-refactor") if not os.path.isfile(refactor_binary): die("build refactor binary first. expected: " + refactor_binary) testcases = get_testcases(test_dir) run_tests(sorted(testcases))
def main(): common.setup_logging("talk_asyncio_server", level=logging.DEBUG) loop = asyncio.get_event_loop() server_future = loop.create_server( QuestionHandler, config.SERVER_HOST, config.SERVER_PORT ) loop.run_until_complete(server_future) logging.info("Starting server...") try: loop.run_forever() except KeyboardInterrupt: pass except Exception as ex: logging.error("Error in execution: %s", ex)
def main(): logger = common.setup_logging() # What are we going to do? logger.info(__doc__) # Determine some arguments we need for api calls base_url = common.get_base_url() token = common.get_token_from_env() if not token: logger.fatal("ATHERA_API_TOKEN not set in env") return 1 # Show the token expiry token_helper = common.TokenHelper(token) logger.info("Token expires {}".format(token_helper.get_expiry_string())) # API calls all need an active group to define the 'Context' of the request. We only care about the top-level groups, orgs. Ask for user input. selector = common.GroupSelector(logger, base_url, token) group_id = selector.get_org() if not group_id: return 2 logger.info("Selected {}".format(group_id)) # Feed this into the class which will query the app_families endpoint searcher = AppSearcher(logger, base_url, group_id, token) # Fetch the search term target = input("-- Enter the app name (or part of) to search for: ") # Run the search families = searcher.search_families(target) if families: # List comprehension to filter bundled. Bundled apps are legacy and should not be used result = list(filter(lambda f: 'Bundled' not in f['name'], families)) if len(result) == 0: logger.info("-- No apps found (bundled apps are ignored)") # Pretty-print the output for f in result: logger.info("{:50} {}".format(f['name'], f['id'])) if 'apps' not in f: logger.error("Missing apps data") continue apps = f['apps'] interactive_app = apps[ 'interactive'] if 'interactive' in apps else None compute_app = apps['compute'] if 'compute' in apps else None if interactive_app: for k, v in interactive_app.items(): logger.info("-- interactive {:35} {}".format(k, v)) if compute_app: for k, v in compute_app.items(): logger.info("-- compute {:35} {}".format(k, v))
def _main(): setup_logging() logging.debug("args: %s", " ".join(sys.argv)) # FIXME: allow env/cli override of LLVM_SRC and LLVM_BLD # FIXME: check that cmake and ninja are installed # FIXME: option to build LLVM/Clang from master? # earlier plumbum versions are missing features such as TEE if pb.__version__ < c.MIN_PLUMBUM_VERSION: err = "locally installed version {} of plumbum is too old.\n" \ .format(pb.__version__) err += "please upgrade plumbum to version {} or later." \ .format(c.MIN_PLUMBUM_VERSION) die(err) args = _parse_args() # prerequisites if not have_rust_toolchain(c.CUSTOM_RUST_NAME): die("missing rust toolchain: " + c.CUSTOM_RUST_NAME, errno.ENOENT) # clang 3.6.0 is known to work; 3.4.0 known to not work. ensure_clang_version([3, 6, 0]) if args.clean_all: logging.info("cleaning all dependencies and previous built files") shutil.rmtree(c.LLVM_SRC, ignore_errors=True) shutil.rmtree(c.LLVM_BLD, ignore_errors=True) shutil.rmtree(c.BUILD_DIR, ignore_errors=True) shutil.rmtree(c.AST_EXPO_PRJ_DIR, ignore_errors=True) cargo = get_cmd_or_die("cargo") with pb.local.cwd(c.ROOT_DIR): invoke(cargo, "clean") ensure_dir(c.LLVM_BLD) ensure_dir(c.BUILD_DIR) git_ignore_dir(c.BUILD_DIR) download_llvm_sources() update_cmakelists() configure_and_build_llvm(args) build_transpiler(args) print_success_msg(args)
def main(): common.setup_logging(is_leader=True) port = common.get_port() selector = selectors.DefaultSelector() leader = Leader(port, selector) try: leader.run() except Exception as e: # The server is already active. return while True: if not leader.clients and leader.had_clients: break for key, mask in selector.select(): callback = key.data callback(key.fileobj)
def main(): common.setup_logging() parser = argparse.ArgumentParser() parser.add_argument('--sleep-time', dest='sleep_time', type=float, default=1) subparsers = parser.add_subparsers() parser_yahoo_finance = subparsers.add_parser('yahoo_finance') parser_yahoo_finance.set_defaults(func=yahoo_finance) parser_quandl = subparsers.add_parser('quandl') parser_quandl.set_defaults(func=quandl) parser_yahoo_roa = subparsers.add_parser('yahoo_roa') parser_yahoo_roa.set_defaults(func=yahoo_roa) args = parser.parse_args() args.func(sleep_time=args.sleep_time)
def main(): args = docopt(__doc__) setup_logging(logging.DEBUG if args['--debug'] else logging.WARNING) ds = [date(y,m,1) for y in [2015,2016] for m in range(1,13)] ds = {d.strftime('%b%y').lower(): 'test_samples/vyp-{}-en.pdf'.format(d.strftime('%Y-%m')) for d in ds} filename = args['<file>'] if filename in ds: filename = ds[filename] if filename.lower().endswith('.zip'): pdfname = extract_pdf_from_zip(filename) else: pdfname = filename try: #text = open(filename, 'r').read() text = load_pdf_file(pdfname) except FileNotFoundError: print("File not found: {}".format(pdfname)) sys.exit(1) if filename.lower().endswith('.zip'): os.remove(pdfname) ie = IncomeExtractor(text) if args['extract']: result = ie.extract_amounts() pretty(result) elif args['gnucash']: ie.gnucash() elif args['verify']: iv = IncomeVerificator(ie) iv.verify(assumptions=args['--assumptions'])
def main(argv): # setup and parse arguments parser = argparse.ArgumentParser(description=DESCRIPTION) parser.add_argument('-i', '--input', required=True, action='store', metavar='IN_DIR', help='directory to stripe across output directories') parser.add_argument('outputs', metavar='OUT_DIR', type=str, nargs='+', help='a directory to strip TO') parser.add_argument('-k', '--shares', required=True, action='store', type=int, help='the number of shares to use for striping (must be smaller than\ the number of output directories)') parser.add_argument('-f', '--force', action='store_true', help='overwrite existing files in output directories') parser.add_argument('-v', '--verbose', action='store_true', help='detailed output of operations') parser.add_argument('-d', '--debug', action='store_true', help='debug information') # create namespace with args ns = parser.parse_args(args=argv) common.setup_logging(ns) _verify_args(ns) _make_output_dirs(ns) _fec_encode(ns)
def main(argv): global FilesSyncQueue global logger global foreground # parse argv parse_argv(argv, globals()) # daemonize daemonize(SYNCER_PID, foreground) # initialize logging logger = setup_logging(argv[0], CONSOLE_LOG_LEVEL, FILE_LOG_LEVEL, LOG_FORMAT, SYNCER_LOG, DATE_FORMAT) # sanity check if not os.path.isdir(WATCH_DIR): logger.critical('Watched directory %s does not exist. ' 'Bailing out.' % WATCH_DIR) sys.exit(1) # if FilesSyncQueue is nonexistant or damaged, truncate it try: FilesSyncQueue = read_atomic(FILES_SYNC_FILE) except (IOError, AttributeError, EOFError): logger.warn('Unusable file sync queue file %s. Recreating.' % FILES_SYNC_FILE) pass write_atomic(FILES_SYNC_FILE, FilesSyncQueue) # start main loop logger.debug('File sync service starting... Entering wait loop.') while True: while decisionlogic(): pass time.sleep(SLEEP_TIME)
print("Running {} sec automated game".format(TEST_DURATION)) for i in range(TEST_DURATION): time.sleep(1) print(i+1) # cleanup server.stop() server_thread.join() print("Shutdown server") for thread in client_threads: thread.join(timeout=1) print("Shutdown clients") if __name__ == '__main__': GUI = True common.setup_logging(to_file=GUI) # unittest.main() # Uncomment to unit-test utility functions h = '192.168.10.100' lh = 'localhost' if not GUI: # speed test print("Performing automated test to see if game crashes") client.AUTOPLAY_PAUSE = 0 test_game(lh, 60, gui=GUI) else: print("Starting GUI to test user interaction") time.sleep(.5) # gui test client.AUTOPLAY_PAUSE = .1 test_game(lh, 40, gui=GUI) logging.info('Logging finished')
from pyreto.roth_erev import VariantRothErev from pyreto.util import ManualNormalExplorer from pybrain.rl.explorers import BoltzmannExplorer #@UnusedImport from pybrain.rl.learners import Q, QLambda, SARSA #@UnusedImport from pybrain.rl.learners import ENAC, Reinforce #@UnusedImport from common import \ get_case6ww, get_case6ww2, setup_logging, get_discrete_task_agent, \ get_zero_task_agent, save_results, run_experiment, \ get_continuous_task_agent, get_neg_one_task_agent from plot import plot5_1, plot5_2, plot5_3, plot5_4 #@UnusedImport setup_logging() decommit = False auctionType = DISCRIMINATIVE #FIRST_PRICE cap = 100.0 #profile = [1.0, 1.0] markups = (0, 10, 20, 30) withholds = None markupMax = 30.0 withholdMax = None nOffer = 1 nStates = 1
examples_as_indices = True learn_embeddings = False hidden_sizes = [300] hidden_activation = 'hard_sigmoid' # 'relu' l2_lambda = 1e-5 # 1e-4 dropout = 0.5 batch_size = 50 epochs = 10 learning_rate = 0.001 loss = 'categorical_crossentropy' # 'mse' config = settings.from_cli(['datadir', 'wordvecs'], Defaults) optimizer = Adam(config.learning_rate) data_name = path.basename(config.datadir.rstrip('/')) common.setup_logging(data_name) settings.log_with(config, info) # Data data = input_data.read_data_sets(config.datadir, config.wordvecs, config) embedding = common.word_to_vector_to_matrix(config.word_to_vector) if config.max_train_examples and len(data.train) > config.max_train_examples: warn('cropping train data from %d to %d' % (len(data.train), config.max_train_examples)) data.train.crop(config.max_train_examples) # Model model = Sequential()
except getopt.GetoptError as ex: print(ex.msg) usage() sys.exit() else: if minplayers < 3: minplayers = 3 if lobbytimeout < 0: lobbytimeout = 15 if turntimeout < 1: turntimeout = 1 return turntimeout, lobbytimeout, minplayers def main(argv): global TURNTIMEOUT global LOBBYTIMEOUT global MINPLAYERS TURNTIMEOUT, LOBBYTIMEOUT, MINPLAYERS = parse_cmd_args(argv) start_server() logging.info('Game server started') start_game() logging.info('Game server shutdown') if __name__ == '__main__': common.setup_logging() main(sys.argv[1:])
"who forget to deliver, and some bad examiners who forget to " \ "publish and correct.") p.add_option("--deadline", dest="deadline", default=None, help="Deadline. If this is specified, --deadline-profile is "\ "ignored. Format: YYYY-MM-DD. Time will always be 00:00.") p.add_option("--pubtime-diff", dest="pubtime_diff", default=14, type='int', help="Number of days between publishing time and deadline. "\ "Defaults to 14.") add_quiet_opt(p) add_debug_opt(p) (opt, args) = p.parse_args() setup_logging(opt) # Django must be imported after setting DJANGO_SETTINGS_MODULE set_django_settings_module(opt) load_devilry_plugins() from django.contrib.auth.models import User from devilry.apps.core.models import Delivery from devilry.apps.core.testhelpers import create_from_path from devilry.apps.core.gradeplugin import registry def exit_help(): p.print_help() raise SystemExit() if len(args) != 1: exit_help() setup_logging(opt)
hidden_sizes = [300] hidden_activation = 'hard_sigmoid' # 'relu' batch_size = 50 epochs = 10 loss = 'categorical_crossentropy' # 'mse' verbosity = 1 # 0=quiet, 1=progress bar, 2=one line per epoch iobes = False # Map tags to IOBES on input token_level_eval = False # Token-level eval even if IOB-like tagging optimizer = 'adam' # 'sgd' test = False config = settings.from_cli(['datadir', 'wordvecs'], Defaults) optimizer = optimizers.get(config.optimizer) output_name = 'mlp--' + path.basename(config.datadir.rstrip('/')) common.setup_logging(output_name) settings.log_with(config, info) # Data data = input_data.read_data_sets(config.datadir, config.wordvecs, config) embedding = common.word_to_vector_to_matrix(config.word_to_vector) if config.max_train_examples and len(data.train) > config.max_train_examples: warn('cropping train data from %d to %d' % (len(data.train), config.max_train_examples)) data.train.crop(config.max_train_examples) # Model model = Sequential()
def test_setup_logging_log_level(self): logger = Mock() common.setup_logging(logger, '/dev/null', '%(name)s: %(message)s', 'info') logger.setLevel.assert_called_with(20)
def main(argv): global FilesActionMap global FilesHashMap global FilesSyncQueue global logger global foreground # parse argv parse_argv(argv, globals()) # daemonize daemonize(SUMMER_PID, foreground) # initialize logging logger = setup_logging(argv[0], CONSOLE_LOG_LEVEL, FILE_LOG_LEVEL, LOG_FORMAT, SUMMER_LOG, DATE_FORMAT) # sanity check if not os.path.isdir(WATCH_DIR): logger.critical('Watched directory %s does not exist. ' 'Bailing out.' % WATCH_DIR) sys.exit(1) # if FilesActionMap is nonexistant or damaged, truncate it try: FilesActionMap = read_atomic(FILES_STATUS_FILE) except (IOError, AttributeError, EOFError): logger.warn('Unusable action map status file %s. Recreating.' % FILES_STATUS_FILE) pass write_atomic(FILES_STATUS_FILE, FilesActionMap) # if FilesHashMap is nonexistant or damaged, truncate it try: FilesHashMap = read_atomic(FILES_HASH_FILE) except (IOError, AttributeError, EOFError): logger.warn('Unusable hash map file %s. Recreating.' % FILES_HASH_FILE) pass write_atomic(FILES_HASH_FILE, FilesHashMap) # if FilesSyncQueue is nonexistant or damaged, truncate it try: FilesSyncQueue = read_atomic(FILES_SYNC_FILE) except (IOError, AttributeError, EOFError): logger.warn('Unusable sync queue file %s. Recreating.' % FILES_SYNC_FILE) pass write_atomic(FILES_SYNC_FILE, FilesSyncQueue) # clear non-existant files from checksum map, most probably due to # changes when monitor was inactive for path in FilesHashMap.keys(): if not os.path.exists(path): logger.warn('File %s is in hash map, but not on disk. ' 'Deleting from map and trying to delete remotely.' % path) # remove from hash file FilesHashMap = read_atomic(FILES_HASH_FILE) del FilesHashMap[path] write_atomic(FILES_HASH_FILE, FilesHashMap) # enqueue to remove remotely FilesSyncQueue = read_atomic(FILES_SYNC_FILE) FilesSyncQueue.append((path, 'remove', 0)) write_atomic(FILES_SYNC_FILE, FilesSyncQueue) # start main loop logger.debug('Checksumming service starting... Entering wait loop.') while True: while decisionlogic(): pass time.sleep(SLEEP_TIME)
self.client_id = client_id def check_stop_client(): global answers_received if answers_received == clients_no: logging.info("stopping client reactor") reactor.stop() def run_client(): clients = [None] * clients_no for i in range(clients_no): clients[i] = CuriousClientFactory() clients[i].setId(i) reactor.connectTCP(config.SERVER_HOST, config.SERVER_PORT, clients[i]) lc = task.LoopingCall(check_stop_client) lc.start(2) reactor.run() if __name__ == "__main__": common.setup_logging("talk_twisted_client", level=logging.DEBUG) run_client()
def main(argv): global FilesActionMap global logger global foreground # parse argv parse_argv(argv, globals()) # daemonize daemonize(MONITOR_PID, foreground) # initialize logging logger = setup_logging(argv[0], CONSOLE_LOG_LEVEL, FILE_LOG_LEVEL, LOG_FORMAT, MONITOR_LOG, DATE_FORMAT) # sanity check if not os.path.isdir(WATCH_DIR): logger.critical('Watched directory %s does not exist. ' 'Bailing out.' % WATCH_DIR) sys.exit(1) # if FilesActionMap is nonexistant or damaged, truncate it try: FilesActionMap = read_atomic(FILES_STATUS_FILE) except (IOError, AttributeError, EOFError): logger.warn('Unusable action map status file %s. Recreating.' % FILES_STATUS_FILE) pass write_atomic(FILES_STATUS_FILE, FilesActionMap) # initial recursive walk (initial events) for root, dirs, files in os.walk(WATCH_DIR): for name in files: path = os.path.join(root, name) FilesActionMap[path] = ('created', time.time()) for name in dirs: path = os.path.join(root, name) FilesActionMap[path] = ('created_dir', time.time()) write_atomic(FILES_STATUS_FILE, FilesActionMap) logger.debug('Initial events %s. Commiting.' % FilesActionMap) # start inotify monitor watch_manager = pyinotify.WatchManager() handler = ProcessEventHandler() notifier = pyinotify.Notifier(watch_manager, default_proc_fun=handler, read_freq=SLEEP_TIME) # try coalescing events if possible try: notifier.coalesce_events() logger.debug('Successfuly enabled events coalescing. Good.') except AttributeError: pass # catch only create/delete/modify/attrib events; don't monitor # IN_MODIFY, instead use IN_CLOSE_WRITE when file has been written to # and finally closed; and monitor IN_MOVED_TO when using temporary # files for atomicity as well as IN_MOVED_FROM when file is moved from # watched path event_mask = pyinotify.IN_CREATE|pyinotify.IN_DELETE|\ pyinotify.IN_CLOSE_WRITE|pyinotify.IN_ATTRIB|\ pyinotify.IN_MOVED_TO|pyinotify.IN_MOVED_FROM|\ pyinotify.IN_ISDIR|pyinotify.IN_UNMOUNT|\ pyinotify.IN_Q_OVERFLOW watch_manager.add_watch(WATCH_DIR, event_mask, rec=True, auto_add=True) # enter loop logger.debug('Inotify handler starting... Entering notify loop.') notifier.loop()
print(prettify(str(final_smv))) return 0 if __name__ == "__main__": parser = argparse.ArgumentParser(description='Transforms spec SMV into valid SMV') parser.add_argument('-v', '--verbose', action='count', help='verbose output', default=-1) parser.add_argument('smv', metavar='smv', type=argparse.FileType(), help='input SMV file') args = parser.parse_args() logger = setup_logging(__name__, verbose_level=args.verbose) logger.info("run with args:%s", args) try: exit(main(args.smv.read().splitlines(), os.path.dirname(args.smv.name))) except KeyboardInterrupt: print() # empty line, so that command line prompt is on a new one except SystemExit: pass except BaseException as e: from logging import INFO # print exception in an appropriate format logger.setLevel(INFO) logger.exception(e)
def delete(self, jid): """ Delete a specific job, given by the job ID from the queue. """ return self.jobqueue.delete(jid) def get_queue(self): """ Returns the entire queue as a list of jobs. Each job is represented by a dictionary. """ return self.jobqueue.as_dict() def abort(self, jid): """ Aborts a job. Do nothing, if the job is not running. """ self.jobqueue.abort(jid) return 0 def reprio(self, jid, new_prio): """ Change the priority of the given job. """ return self.jobqueue.reprio(jid, new_prio) def add_options(): """ Factory function for the OptionParser for command line parsing. """ parser = optparse.OptionParser(usage="%prog [options]") parser.add_option("-c", "--config", help="Add/overwrite configuration options. Syntax: 'section.key=value,...'") return parser if __name__ == "__main__": common.setup_logging("~/.flof/flofserver.log") oparser = add_options() (options, args) = oparser.parse_args() configuration = Configuration(cmd_config = options.config) FlofServer(configuration)
import logging from tcpsender import * from tcpsender_args import * from common import timer_dec, setup_logging, press_any_key @timer_dec def run(log): args = get_args(log) tcp_sender_run(log, args) if __name__ == '__main__': log = object try: log = setup_logging() log = logging.getLogger(__name__) run(log) log.debug(__name__ + 'finish!') except Exception as inst: log.exception(inst) #print(inst) else: log.debug('TCPSender successful done!') pass finally: log.debug('Finish!') #press_any_key() pass
# otherwise make sure that a Marathon URL was specified else: if args.marathon is None: arg_parser.error('argument --marathon/-m is required') if args.marathon_lb is None: arg_parser.error('argument --marathon-lb/-l is required') if args.json is None: arg_parser.error('argument --json/-j is required') return args if __name__ == '__main__': args = process_arguments() set_request_retries() setup_logging(logger, args.syslog_socket, args.log_format, args.log_level) try: if do_zdd(args): sys.exit(0) else: sys.exit(1) except Exception as e: if hasattr(e, 'zdd_exit_status'): if hasattr(e, 'error'): logger.exception(str(e.error)) else: logger.exception(traceback.print_exc()) sys.exit(e.zdd_exit_status) else: # For Unknown Exceptions
defferedAnswer = self.factory.knowledge_engine.getAnswer(question) defferedAnswer.addCallback(self.sendAnswer, client_id) def sendAnswer(self, answer, client_id): logging.debug("sending answer to client %s: [%s]", client_id, answer) self.transport.write(answer) self.transport.loseConnection() class KnowledgeFactory(protocol.ServerFactory): protocol = KnowledgeProtocol knowledge_engine = knowledge_engine.KnowledgeEngine() def start_server(): factory = KnowledgeFactory() endpoints.serverFromString( reactor, "tcp:%s" % config.SERVER_PORT).listen(factory) logging.info("server started on port %d", config.SERVER_PORT) reactor.run() reactor.callLater(100, reactor.stop) logging.info("server execution ended") if __name__ == "__main__": common.setup_logging("talk_twisted_server", level=logging.DEBUG) start_server()