def main(): configuration.load_components_info() configuration.load_default_config() import cliargparse cliargs = cliargparse.parse_cli_args() # This must be done *before* checking for existing processes, because a # configuration file may haven't been set in the command arguments configfile = configuration.set_configuration_file(cliargs) configuration.set_update_only(cliargs) if dbus: check_existing_processes(configfile) configuration.load_configuration() import logger logger.set_logger(cliargs) # Make sure the main thread has a known name threading.current_thread().setName(configuration.MAIN_THREAD_NAME) sys.excepthook = handle_uncaught_exception # The application must crash also if an exception is raised in a secondary # thread, for example because if the thread has blocked the databases, it # won't release them otherwise; yes, they could be released in a finally # clause, but that would leave the database in an unknown state, which is # pretty bad install_thread_excepthook()
def init(): """ Activate object for working: __config__, __db_data__ """ __config__.read('config.ini') set_logger( 'xProject.log', mode=__config__['logger']['mode'], level=__config__['logger']['level'] ) load_db() update_db(int(__config__['db_csv']['timeout']))
def main(host, db_type, port, file_name, mysql_host, mysql_port, db, user, password, target_url, interval, log_level): set_logger(getattr(logging, log_level)) proxy_list = load_file(file_name) if db_type == "sqlite": queue = SqliteQueue() else: queue = MysqlQueue(mysql_host, mysql_port, db, user, password) checker = ProxyCheck(proxy_list, queue, target_url) relay_handler = HttpRelayHandler(queue, (host, port)) scheldurer = Manager(checker, queue, relay_handler, interval) scheldurer.run()
def main(): logger.set_logger() from wsgiref import simple_server app = falcon.API(middleware=[CORSMiddleware()]) app.add_route("/instances", InstanceListResource()) app.add_route("/instances/{file}", InstanceResource()) app.add_route( "/instances/{file}/solutions", SolutionListResource()) app.add_route( "/instances/{file}/solutions/{solution_name}", SolutionResource()) httpd = simple_server.make_server("127.0.0.1", 8000, app) httpd.serve_forever()
def __init__(self, infile, refgenome, pattern, output_name_pattern, window_size=200): self._infile = pathlib.Path(infile) if not self._infile.exists(): raise Exception('Can not find input file.') self._refgenome = pathlib.Path(refgenome) if not self._refgenome.exists(): raise Exception('Can not find refgenome file') self._pattern = pattern if '/' in self._pattern: self._length_of_pattern = len(self._pattern) - 2 else: self._length_of_pattern = len(self._pattern) self._window_size = window_size if not self._window_size % 2 == 0: raise Exception('Please specify an even number for window_size') self._output_name_pattern = output_name_pattern self._dict_apalfc = None self._opened_ref = None self._lgr = logger.set_logger(self._infile.name[:-3] + 'log')
def main(): parser = ArgumentParser() parser.add_argument("--lang", required=True, help="language") parser.add_argument( "--labels", required=True, help="path to file with Wikidata labels and aliases for language LANG") parser.add_argument( "--sitelinks", required=True, help="path to file with Wikidata sitelinks for language LANG") parser.add_argument( "--wd-graph", required=True, help="path to Wikidata graph (represented with adjacency lists)") parser.add_argument("--wp-sections", required=True, help="path to file with Wikipedia sections") parser.add_argument("--output", required=True, help="path to output file") args = parser.parse_args() log = set_logger("logs/match_{}.{}".format(args.lang, int(time.time()))) do_process(args, log)
def __init__(self, infile, refgenome, pattern, output_name_pattern, window_size=200): self._infile = pathlib.Path(infile) if not self._infile.exists(): raise Exception('Can not find input file.') self._refgenome = pathlib.Path(refgenome) if not self._refgenome.exists(): raise Exception('Can not find refgenome file') self._pattern = pattern if '/' in self._pattern: self._length_of_pattern = len(self._pattern) - 2 else: self._length_of_pattern = len(self._pattern) self._window_size = window_size if not self._window_size % 2 == 0: raise Exception('Please specify an even number for window_size') self._output_name_pattern = output_name_pattern self._dict_apalfc = None self._opened_ref = None self._lgr = logger.set_logger(self._infile.name[:-3]+'log')
def __init__(self, reference, infilename, sample_name, window_size): self._reference = reference self._infilename = pathlib.Path(infilename) self._sample_name = sample_name self._window_size = window_size self._cached_dict = None # the name of the input is supposed to be XXXXXX.bed self._lgr = logger.set_logger(self._infilename.name[:-4] + '.log')
def __init__(self, rcTable, window_size, hasHeader, delrc): myclasses.RCTableCacher.__init__(self, rcTable, hasHeader) self._window_size = window_size self._sorted_dict = None self._nodup_dict = None self._merged_dict = None self._delrc = delrc self._lgr = logger.set_logger(self._rcTable.name[:-4] + '.log')
def main(): # os.environ['CUDA_VISIBLE_DEVICES'] = '3' config = get_args() logger = set_logger(config) dataset = StockDataset(config) config.num_relations = dataset.num_relations config.num_companies = dataset.num_companies run_config = tf.ConfigProto() run_config.gpu_options.allow_growth = True model_name = config.model_type exp_name = '%s_%s_%s_%s_%s_%s_%s_%s'%(config.data_type, model_name, str(config.test_phase), str(config.test_size), str(config.train_proportion), str(config.lr), str(config.dropout), str(config.lookback)) if not (os.path.exists(os.path.join(config.save_dir, exp_name))): os.makedirs(os.path.join(config.save_dir, exp_name)) sess = tf.Session(config=run_config) model = init_prediction_model(config) init = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) sess.run(init) def model_summary(logger): model_vars = tf.trainable_variables() slim.model_analyzer.analyze_vars(model_vars, print_info=True) model_summary(logger) #Training evaluator = Evaluator(config, logger) trainer = Trainer(sess, model, dataset, config, logger, evaluator) trainer.train() #Testing loader = tf.train.Saver(max_to_keep=None) loader.restore(sess, tf.train.latest_checkpoint(os.path.join(config.save_dir, exp_name))) print("saved at {}/{}".format(config.save_dir, exp_name)) print("load best evaluation model") test_loss, report_all, report_topk = evaluator.evaluate(sess, model, dataset, 'test', trainer.best_f1['neighbors']) te_pred_rate, te_acc, te_cpt_acc, te_mac_f1, te_mic_f1, te_exp_rt, te_sharpe = report_all logstr = 'EPOCH {} TEST ALL \nloss : {:2.4f} accuracy : {:2.4f} hit ratio : {:2.4f} pred_rate : {} macro f1 : {:2.4f} micro f1 : {:2.4f} expected return : {:2.4f} sharpe : {:2.4f}'\ .format(trainer.best_f1['epoch'],test_loss,te_acc,te_cpt_acc,te_pred_rate,te_mac_f1,te_mic_f1,te_exp_rt, te_sharpe) logger.info(logstr) te_pred_rate, te_acc, te_cpt_acc, te_mac_f1, te_mic_f1, te_exp_rt, te_sharpe = report_topk logstr = 'EPOCH {} TEST TopK \nloss : {:2.4f} accuracy : {:2.4f} hit ratio : {:2.4f} pred_rate : {} macro f1 : {:2.4f} micro f1 : {:2.4f} expected return : {:2.4f} sharpe : {:2.4f}'\ .format(trainer.best_f1['epoch'],test_loss,te_acc,te_cpt_acc,te_pred_rate,te_mac_f1,te_mic_f1,te_exp_rt, te_sharpe) logger.info(logstr) #Print Log with open('%s_log.log'%model_name, 'a') as out_: out_.write("%d phase\n"%(config.test_phase)) out_.write("%f\t%f\t%f\t%f\t%f\t%f\t%s\t%f\t%f\t%f\t%f\t%f\t%f\t%s\t%d\n"%( report_all[1], report_all[2], report_all[3], report_all[4], report_all[5], report_all[6], str(report_all[0]), report_topk[1], report_topk[2], report_topk[3], report_topk[4], report_topk[5], report_topk[6], str(report_topk[0]), trainer.best_f1['epoch']))
def __init__(self, controllers, **kw): self._debug = kw.get('debug', False) self._init_exc_info = None self._worker = None # TODO: following is shit... #try: if kw.has_key('loggers'): for name, data in kw.get('loggers').items(): file = data.get('file') fname = file.get('name') size = file.get('size') count = file.get('count') set_logger(name, fname, max_bytes = size, backup_count = count) if kw.has_key('exc_wrapper'): exc_wrapper = kw.get('exc_wrapper') log_setup = ExcInfoWrapper._logging log_setup['init'] = exc_wrapper.get('init', log_setup['init']) log_setup['call'] = exc_wrapper.get('call', log_setup['call']) if kw.has_key('monitor'): monitor = kw.get('monitor') force_restart = monitor.get('force_restart', True) self._monitor = Monitor(force_restart=force_restart) for i in monitor.get('track_files', []): self._monitor.track(i) self._monitor.start() #except: # self._init_exc_info = ExcInfoWrapper() if FrontControllerWorker is None: self._init_exc_info = init_exc_info else: try: self._worker = FrontControllerWorker(**controllers) except: self._init_exc_info = ExcInfoWrapper()
def __init__(self, model_dir: str, lr: float = 10e-3, batch_size: int = 4, max_seq_len: int = 128, verbose: bool = False, filter_results: bool = False, **_): """Model dir will be a full path if the binary is present, and will be just the name of the "model_dir" if it is not.""" super().__init__() self.filter_results = filter_results self.model_dir = model_dir self.lr = lr self.max_seq_len = max_seq_len self.batch_size = batch_size self.logger = set_logger(model_dir, verbose=verbose)
def __init__(self, make, env_name, replay_buffer_size=50000, sample_size=2048, seed=0, is_primary=False, path=None, **kwargs): super(Worker, self).__init__() self.make = make self.env_name = env_name self.replay_buffer_size = replay_buffer_size self.sample_size = sample_size self.seed = seed self.kwargs = kwargs self.is_primary = is_primary self.daemon = True self.pipe, self.worker_pipe = multiprocessing.Pipe() from logger import set_logger if path is None and self.is_primary: # save the model if it's the primary import datetime date = str(datetime.datetime.now()).split('.')[0] path = f'/tmp/AWR/{env_name}_{date}' if not os.path.exists(path): os.makedirs(path) self.path = path if path is not None and path != 'tmp': set_logger(os.path.join(path, 'log.txt')) import logging self.print = logging.info else: self.print = print self.start()
def main(): parser = argparse.ArgumentParser() parser.add_argument("--input", required=True) parser.add_argument("--output", required=True) args = parser.parse_args() log = set_logger("logs/filter_res.{}".format(int(time.time()))) do_filter(args, log) log.info("Filtering: finish")
def __init__(self, ls_inputs, undefined, outputname): ''' This app class takes a list of single-sample RC files and merge them into one. Default settings merge the list of files derived from defined masterlist. If you want to merge "Unidentified" UID_files, specify --undefined upon calling. ''' self._ls_inputs = utils.list_inputs_from_file(ls_inputs) # self._ls_inputs contains a list of Path() objects that are through existing check self._undefined = undefined # default is True, when undefined is given in command line, it turns False self._outputname = outputname self._lgr = logger.set_logger('Merged_' + self._outputname[:-4] + '.log')
def __init__(self, reference, infilename, window_size, deny_number): # infilename could be a path/file, pack them in a Path() object will be better self.infilename = pathlib.Path(infilename) if not self.infilename.exists(): raise Exception('The input SAM does not exist!') self.reference = pathlib.Path(reference) if not self.reference.exists(): raise Exception('The input reference does not exist!') self.window_size = window_size self.deny_number = deny_number # the name of the infile should be XXXXXX.sam self._lgr = logger.set_logger(self.infilename.name[:-4] + '.log')
def main(): # os.environ['CUDA_VISIBLE_DEVICES'] = '3' config = get_args() logger = set_logger(config) dataset = StockDataset(config) config.num_relations = dataset.num_relations config.num_companies = dataset.num_companies run_config = tf.ConfigProto(log_device_placement=False) run_config.gpu_options.allow_growth = True exp_name = '%s_%s_%s_%s_%s_%s_%s_%s' % ( config.data_type, config.model_type, str(config.test_phase), str(config.test_size), str(config.train_proportion), str( config.lr), str(config.dropout), str(config.lookback)) # save train file if not (os.path.exists(os.path.join(config.save_dir, exp_name))): os.makedirs(os.path.join(config.save_dir, exp_name)) sess = tf.Session(config=run_config) model = init_prediction_model(config) init = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) sess.run(init) def model_summary(): model_vars = tf.trainable_variables() slim.model_analyzer.analyze_vars( model_vars, print_info=True) # print the name and shapes of the variables model_summary() if 'graph' in config.model_type: evaluator = GEvaluator(config, logger) # trainer = GTrainer(sess, model, dataset, config, logger, evaluator) else: evaluator = Evaluator(config, logger) # trainer = Trainer(sess, model, dataset, config, logger, evaluator) # trainer.train() #Testing loader = tf.train.Saver(max_to_keep=None) loader.restore( sess, tf.train.latest_checkpoint(os.path.join(config.save_dir, exp_name))) print("saved at {}/{}".format(config.save_dir, exp_name)) print("load best evaluation model") test_loss, report = evaluator.evaluate(sess, model, dataset, 'test', True) te_pred_rate, te_acc, te_cpt_acc, te_mac_f1, te_mic_f1, te_exp_rt, te_sharpe = report logstr = 'TEST ALL \nloss : {:2.4f} accuracy : {:2.4f} hit ratio : {:2.4f} pred_rate : {} macro f1 : {:2.4f} micro f1 : {:2.4f} expected return : {:2.4f} sharpe : {:2.4f}'\ .format(test_loss,te_acc,te_cpt_acc,te_pred_rate,te_mac_f1,te_mic_f1,te_exp_rt, te_sharpe) logger.info(logstr)
def __init__(self, controllers, **kw): self._debug = kw.get('debug', False) self._init_exc_info = None self._worker = None # TODO: following is shit... #try: if kw.has_key('loggers'): for name, data in kw.get('loggers').items(): file = data.get('file') fname = file.get('name') size = file.get('size') count = file.get('count') set_logger(name, fname, max_bytes=size, backup_count=count) if kw.has_key('exc_wrapper'): exc_wrapper = kw.get('exc_wrapper') log_setup = ExcInfoWrapper._logging log_setup['init'] = exc_wrapper.get('init', log_setup['init']) log_setup['call'] = exc_wrapper.get('call', log_setup['call']) if kw.has_key('monitor'): monitor = kw.get('monitor') force_restart = monitor.get('force_restart', True) self._monitor = Monitor(force_restart=force_restart) for i in monitor.get('track_files', []): self._monitor.track(i) self._monitor.start() #except: # self._init_exc_info = ExcInfoWrapper() if FrontControllerWorker is None: self._init_exc_info = init_exc_info else: try: self._worker = FrontControllerWorker(**controllers) except: self._init_exc_info = ExcInfoWrapper()
def main(): config = get_args() logger = set_logger(config) dataset = StockDataset(config) config.num_relations = dataset.num_relations config.num_companies = dataset.num_companies run_config = tf.ConfigProto(log_device_placement=False) run_config.gpu_options.allow_growth = True exp_name = '%s_%s_%s_%s_%s_%s_%s_%s'%(config.data_type, config.model_type, str(config.test_phase), str(config.test_size), str(config.train_proportion), str(config.lr), str(config.dropout), str(config.lookback)) # save train file if not (os.path.exists(os.path.join(config.save_dir, exp_name))): os.makedirs(os.path.join(config.save_dir, exp_name)) sess = tf.Session(config=run_config) model = init_prediction_model(config) init = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) sess.run(init) def model_summary(): model_vars = tf.trainable_variables() slim.model_analyzer.analyze_vars(model_vars, print_info=True) # print the name and shapes of the variables model_summary() if config.mode == 'train': if 'graph' in config.model_type: evaluator = GEvaluator(config, logger) trainer = GTrainer(sess, model, dataset, config, logger, evaluator) else: evaluator = Evaluator(config, logger) trainer = Trainer(sess, model, dataset, config, logger, evaluator) trainer.train() #Testing loader = tf.train.Saver(max_to_keep=None) loader.restore(sess, tf.train.latest_checkpoint(os.path.join(config.save_dir, exp_name))) print("load best evaluation model") test_loss, report = evaluator.evaluate(sess, model, dataset, 'test') te_pred_rate, te_acc, te_cpt_acc, te_mac_f1, te_mic_f1, te_exp_rt = report logstr = 'EPOCH {} TEST ALL \nloss : {:2.4f} accuracy : {:2.4f} hit ratio : {:2.4f} pred_rate : {} macro f1 : {:2.4f} micro f1 : {:2.4f} expected return : {:2.4f}'\ .format(trainer.best_f1['epoch'],test_loss,te_acc,te_cpt_acc,te_pred_rate,te_mac_f1,te_mic_f1,te_exp_rt) logger.info(logstr) with open('%s_log.log'%config.GNN_model+'_'+config.model_type+'_'+config.data_type+'_'+config.price_model+'_'+str(config.test_phase), 'a') as out_: out_.write("%d phase\n"%(config.test_phase)) out_.write("%f\t%f\t%f\t%f\t%f\t%s\t%d\n"%( report[1], report[2], report[3], report[4], report[5], str(report[0]), trainer.best_f1['epoch']))
def main(): parser = argparse.ArgumentParser() parser.add_argument("--dump", required=True, help="path to Wikipedia dump file") parser.add_argument("--output", required=True, help="path to output file") args = parser.parse_args() log = set_logger("logs/process_wikipedia_{}.{}".format( args.lang, int(time.time()))) process_wikipedia(args, log)
def main(): args = parser.parse_args() log = logger.set_logger(LOG_FILENAME, debug_mode=args.log_level, print_to_screen=args.verbose) log.info(f'booting bot v{VERSION} on {platform()}') log.info('\n\t'.join([ 'arguments:', f'log-level: {args.log_level}', f'verbose: {args.verbose}', f'mode: {args.mode}', f'configuration filename: {args.config_file}' ])) bot = bot_server(config_file=args.config_file) if not bot.is_valid(): log.error('could not create bot server, aborting') else: log.info('server created successfuly') bot.run(args.mode) log.info('shutting down.')
parser.add_argument('--lam', default=1e-4, type=float, help='L2 regularization') parser.add_argument('--seed', default=0, type=int, help='seed for hashing') parser.add_argument('--subsample_max', default=60, type=int, help='max subsampled training labels') parser.add_argument('--K', default=50, type=int, help='top K reviewers per paper considered for assignment') args = parser.parse_args() logger = set_logger("assignment") logger.info(args) def precision_evaluate(w, X, y): preds = X.dot(w) preds = np.reshape(preds, (num_reviewer, int(X.shape[0] / num_reviewer))) y = np.reshape(y, (num_reviewer, int(X.shape[0] / num_reviewer))) indices = np.argsort(preds, 1) prec_at_k = np.zeros((preds.shape[0], 10)) for i in range(preds.shape[0]): out = y[i, indices[i, -1:-11:-1]] == 1 prec_at_k[i] = np.cumsum(out).astype(float) / np.arange(1, 11) logger.info("top10papers: " + repr(prec_at_k.mean(0))) prec_top_paper = prec_at_k.mean(0)
def main(): config = get_args() logger = set_logger(config) dataset = StockDataset(config)
help='print info to screen') config.args = parser.parse_args() config.args.torch_device = 'cuda' if torch.cuda.is_available( ) and not config.args.ignore_cuda else 'cpu' config.args.use_cuda = config.args.torch_device == 'cuda' # create run dir and setup if not config.args.ignore_timestamp: config.args.runname += datetime.datetime.now().strftime('_%Y%m%d_%H%M%S') run_dir = os.path.join(config.args.save_dir, config.args.runname) os.makedirs(run_dir, exist_ok=True) logger.set_logger( os.path.join(run_dir, 'log_' + str(config.args.runname) + '.log')) configfile = os.path.join(run_dir, 'conf_' + str(config.args.runname) + '.config') config.log.info(f'==> Created subdir for run at: {run_dir}') # save configuration parameters with open(configfile, 'w') as f: for arg in vars(config.args): f.write('{}: {}\n'.format(arg, getattr(config.args, arg))) config.log.info('==> Loading dataset...') config.cast_graph = ds.get_cast_graph() train_loader, eval_loader, test_loader = ds.get_loaders()
def __init__(self, rcTable, hasHeader): myclasses.RCTableCacher.__init__(self, rcTable, hasHeader) self._rcMatrix = None self._sumList_perGene = None self._sumList_perApA = None self._lgr = logger.set_logger(self._rcTable.name[:-4] + '.log')
@return: web app """ ssl_ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH) ssl_ctx.load_cert_chain(os.path.join("certificates", "server.crt"), os.path.join("certificates", "server.key")) return tornado.web.Application([(r"/alke", WebSocketHandler)], debug=True, websocket_ping_interval=0, websocket_max_message_size=1000000000, ssl_options=ssl_ctx) if __name__ == "__main__": # set up session logger set_logger(level='debug') # set up web application app = make_app() app.listen(5000, ssl_options={ "certfile": os.path.join("certificates", "server.crt"), "keyfile": os.path.join("certificates", "server.key"), }) # instantiate tf model before running the inference to prevent slow loading times instantiate_model() # inference first image -> otherwise first frame processed slowly img_first = cv2.imread("first_frame_instance_model.jpg") process_image(img_first)
import argparse from logger import set_logger parser = argparse.ArgumentParser() parser.add_argument('--output_dir', default='./results/', type=str, help='output dir') parser.add_argument('--lam', default=1e-4, type=float, help='L2 regularization') parser.add_argument('--num_seeds_X', default=1, type=int, help='seed for hashing') parser.add_argument('--num_seeds_results', default=1, type=int, help='seed for attack sampling') parser.add_argument('--subsample_max', default=60, type=int, help='max subsampled training labels') parser.add_argument('--K', default=50, type=int, help='top K reviewers per paper considered for assignment') parser.add_argument('--num_sim', default=10, type=int, help='the number of samples in each bins') parser.add_argument('--L', default=0, type=int, help='the colluding size for attack evalaution') parser.add_argument('--cheat_mode', default="white_box", type=str, help="white_box / black_box /simple_black_box") args = parser.parse_args() logger = set_logger("attack results evaluation") logger.info(args) num_paper, num_reviewer, _, _, hashed_ratio = get_global_variable() num_sim = args.num_sim X_seeds = range(args.num_seeds_X) K = args.K lam = args.lam subsample_max = args.subsample_max cheat_mode = args.cheat_mode L = args.L X_csr_s = [] H_inv_s = [] y, y_train = load_y(hashed_ratio, logger, subsample_max=subsample_max) preds_s = []
import argparse import logger import requests.exceptions from ASFConnector import ASFConnector _REGEX_CDKEY = re.compile('\w{5}-\w{5}-\w{5}') _REGEX_COMMAND_BOT_ARGS = '^[/!]\w+\s*(?P<bot>\w+)?\s+(?P<arg>.*)' _REGEX_COMMAND_RAW = '^[/!](?P<input>(?P<command>\w+).*)' _REGEX_COMMAND = '^[/!]\w+\s*(?P<bot>\w+)?' _ENV_TELEGRAM_BOT_TOKEN = "TELEGRAM_BOT_TOKEN" _ENV_TELEGRAM_USER_ALIAS = "TELEGRAM_USER_ALIAS" _ENV_ASF_IPC_HOST = "ASF_IPC_HOST" _ENV_ASF_IPC_PORT = "ASF_IPC_PORT" _ENV_ASF_IPC_PASSWORD = "******" LOG = logger.set_logger('ASFBot') parser = argparse.ArgumentParser() parser.add_argument("-v", "--verbosity", help="Defines log verbosity", choices=['CRITICAL', 'ERROR', 'WARN', 'INFO', 'DEBUG'], default='INFO') parser.add_argument("--host", help="ASF IPC host. Default: 127.0.0.1", default='127.0.0.1') parser.add_argument("--port", help="ASF IPC port. Default: 1242", default='1242') parser.add_argument("--password", help="ASF IPC password.", default=None)
help='max subsampled training labels') args = parser.parse_args() num_paper, num_reviewer, input_dir, max_pc_quota, hashed_ratio = get_global_variable( ) seeds = range(args.num_seeds) L_attack = args.L_attack K = args.K lam = args.lam subsample_max = args.subsample_max cheat_mode = args.cheat_mode c_train = 2.0 / (num_reviewer * num_paper) logger = set_logger( "detect_tpr", "{}/detect_tpr/log_detect_tpr_collusion_{}_top_{}_{}_lam_{}_subsample_max_{}_seed_{}.txt" .format(args.output_dir, L_attack, K, cheat_mode, lam, subsample_max, args.seed)) logger.info(args) #1. init data X_csr_s = [] H_inv_s = [] y, y_train = load_y(hashed_ratio, logger, subsample_max=subsample_max) preds_s = [] for seed in seeds: X_csr, H_inv = load_X_and_H_inv(hashed_ratio, seed, logger, lam) preds = load_preds(X_csr, y_train, H_inv, hashed_ratio,
def setUpClass(cls): LOG_NAME = 'QuakeSounds_Bot.test' logger.set_logger(LOG_NAME) cls.db = Database(provider='sqlite')
current_image = api_client.inspect_image( running_container['Config']['Image']) try: latest_image = image.pull_latest(current_image) except docker.errors.APIError as e: logging.error(e) continue # If current running container is running latest image if not image.is_up_to_date(current_image['Id'], latest_image['Id']): logging.info(('{} will be updated').format( container.get_name(running_container))) # new container object to create new container from new_config = container.NewContainerProperties( running_container, latest_image['RepoTags'][0]) container.stop(running_container) container.remove(running_container) new_container = container.create_new_container( new_config.__dict__) container.start(new_container) image.remove(current_image) logging.info('All containers up to date') if __name__ == "__main__": set_logger('debug') schedule.every(defaults.INTERVAL).seconds.do(main) while True: schedule.run_pending() time.sleep(defaults.INTERVAL - 5)
def main(): lg.set_logger('imdbparser') imdb = IMDBGetter(IMDB_FTP_URL) imdb.get_file(QUOTES_FILENAME)
""" self.gui.setButton(VideoClient.CONNECT_BUTTON, f"In a call with {nickname}") def display_connect(self): """ This function will be called when a call ends. Changes the connect and hold buttons names to the default ones. :return: """ self.gui.setButton(VideoClient.CONNECT_BUTTON, VideoClient.CONNECT_BUTTON) self.gui.setButton(VideoClient.HOLD_BUTTON, VideoClient.HOLD_BUTTON) if __name__ == '__main__': parser = argparse.ArgumentParser(description='Samtale') parser.add_argument('-log_level', action='store', nargs='?', default='info', choices=['debug', 'info', 'warning', 'error'], required=False, help='Indicate logging level') args = parser.parse_args() set_logger(args) VideoClient().start() _exit(0)