def test_no_algorithm_group(self): try: self.assertRaises(cli.parse_args(["hash"]), lambda: SystemExit) except SystemExit: self.assertEqual(True, True) #cant find other way to check system exit
def main(): print(HELLO_MSG) args = parse_args() print(args) if args.action == "run": launch_on_all_nodes() elif args.action == "eval": evaluate_all()
def showconfig(): opts, args = cli.parse_args() cf = opts.pop('configfile') print "# Configuration file: %s\n" % cf keys = opts.keys() keys.sort() for key in keys: print '%s=%r' % (key, opts[key]) return 0
def shell(): """ Run an interactive Python shell configured for our models. """ from django.core.management.commands import shell opts, args = cli.parse_args() cmd = shell.Command() cmd.handle_noargs() return 0
def command_sequence_test(self, commands, output): self.stealOutput() expected = self.strip_list(output if type(output) in (list, tuple) else [output]) for command in commands: if type(command) == type(''): args = command.split(' ') else: args = command cli.execute_command_line(*cli.parse_args(args)) self.reset() self.assertEqual(self.strip_list(self.out.buffer), expected)
def main(): params = cli.parse_args() config = Config(params) provider = Conoha() provider.authenticate('', '', '') acls = provider.get_acl_config() for acl_cfg in acls: acl_obj = provider.create_acl_item(acl_cfg.name, acl_cfg.description) for rule_cfg in acl_cfg.rules: provider.add_acl_rule(acl_obj.id, rule_cfg) vm = provider.create_vm() config.apply_hosts(vm)
def activity(self): self.output.setText("请稍等几秒钟......") sentence = self.input.text() print(self.input.text()) args = parse_args() print("ok") IE = TripleIE(sentence, args.ltp, args.clean) out = IE.run() if re.search(r"句子结构不完整", out, flags=0) == None: CL = Classify(sentence, out) out += "句子类型:" + CL.SentenceType() self.output.setText(out)
def showTaggedSuccessTest(self, mode): self.stealOutput() (flag, spec, o) = specify_DADGAD(mode, self.db.host) description = cli.describe_by_mode(o) args = (['show', '-U', '-v', flag, spec, 'rating', '/fluiddb/about'] + self.hostname) cli.execute_command_line(*cli.parse_args(args)) self.reset() self.assertEqual(self.out.buffer, ['Object %s:' % description, '\n', ' /%s/rating = 10' % self.user.encode('UTF-8'), '\n', ' /fluiddb/about = "DADGAD"', '\n']) self.assertEqual(self.err.buffer, [])
def main(): # parse command line arguments args = parse_args() # parse information about products and categories parser = WBParser(args.url) products_collection = parser.parse_products(exclude_desc=args.brief) categories_collection = parser.parse_categories() # display it print("~~~ Products ~~~") pprint(products_collection) print("\n~~~ Categories ~~~") pprint(categories_collection)
def main(args=None): timeit = time.time() repo = Path(sys.argv[0]).resolve().parent.parent langs = repo/'data'/'languages.csv' targets = repo/'data'/'rank_turbulence_divergence' outdir = repo/'data'/'timeseries' plots = repo/'plots' args = cli.parse_args(args) Path(outdir).mkdir(parents=True, exist_ok=True) if args.dtype == 'figures': jhu = Path(args.jhu) / 'csse_covid_19_data/csse_covid_19_time_series' confirmed = jhu / 'time_series_covid19_confirmed_global.csv' deaths = jhu / 'time_series_covid19_deaths_global.csv' us_confirmed = jhu / 'time_series_covid19_confirmed_US.csv' us_deaths = jhu / 'time_series_covid19_deaths_US.csv' contagiograms.plot( consts.contagiograms, savepath=plots, start_date=datetime(2020, 1, 1), t1="1W", t2=7, ) vis.cases( savepath=plots / f'coronagrams_cases', words_by_country=consts.words_by_country, deaths=deaths, confirmed=confirmed, us_deaths=us_deaths, us_confirmed=us_confirmed, lang_hashtbl=Path(langs), ) else: for f in targets.rglob('*grams'): logging.info(f'{f.parent.stem}|{f.stem}') utils.update_timeseries( save_path=outdir/f.parent.stem/f.stem, languages_path=langs, ngrams_path=f, database=f.stem.split('_')[-1] ) logging.info(f'Total time elapsed: {time.time() - timeit:.2f} sec.')
def main(): args = parse_args(args=sys.argv[1:]) (architecture, input_shape, optimizer, learning_rate, n_epochs, pool, n_dense, units, patience, batch_norm, dropouts, maxnorm, l2_reg, patience) = (args.architecture, args.input_shape, args.optimizer, args.learning_rate, args.n_epochs, args.pool, args.n_dense, args.units, args.patience, args.batch_norm, args.dropouts or [], args.maxnorm, args.l2_reg, args.patience) print('Model training with parameters:') pprint(vars(args)) model = PretrainedModel(input_shape=input_shape) model.create(*get(architecture), n_dense=n_dense, pool=pool, units=units, bn=batch_norm, dropouts=dropouts, maxnorm=maxnorm, l2_reg=l2_reg) ok = model.create_model_folder(root=join(MODELS_FOLDER, 'face_landmarks'), subfolder=args.identifier) if not ok: sys.exit(1) model.save_parameters(model.parameters_path) model.compile(optimizer=optimizer) callbacks = [ CSVLogger(filename=model.history_path), EarlyStopping(patience=patience, verbose=1), ModelCheckpoint(filepath=model.weights_path, save_best_only=True, save_weights_only=False) ] model.train(n_epochs=n_epochs, train_folder=LFPW_TRAIN, valid_folder=LFPW_VALID, callbacks=callbacks) avg_rmse = model.score(LFPW_VALID) print(f'Trained model validation RMSE: {avg_rmse:2.4f}') print(f'The folder with results: {model.subfolder}') print(f'Training history file: {model.history_path}')
def _setup_tools(): """ Common setup for various tools. """ opts, args = cli.parse_args() try: zone = _fix_zone(args[0]) except IndexError: log.error(USAGE_ZONE) _check_permissions(zone) # We have to wait until Django is configured to import our models import models globals()['models'] = models return opts, zone
def main(): utils.myprint_switches = ["std"] # [] to suppress printing print("multi.py -- Bayesian audit support program.") utils.start_datetime_string = utils.datetime_string() print("Starting date-time:", utils.start_datetime_string) args = cli.parse_args() e = Election() try: cli.process_args(e, args) finally: utils.close_myprint_files()
def untagTest(self, mode, verbose=True): self.stealOutput() (flag, spec, o) = specify_DADGAD(mode, self.db.host) description = cli.describe_by_mode(o) flags = ['-v', flag] if verbose else [flag] args = ['untag'] + ['-U'] + flags + [spec, 'rating'] + self.hostname cli.execute_command_line(*cli.parse_args(args)) self.reset() if verbose: target = ['Removed tag rating from object %s\n' % description, '\n'] else: target = [] self.assertEqual(self.out.buffer, target) self.assertEqual(self.err.buffer, [])
def main(): args = parse_args({ 'resnet18': resnet18, 'resnet34': resnet34, 'resnet50': resnet50 }) img_sz, trn_sz, val_sz, n, bs = ( args.image_size, args.train_size, args.valid_size, args.n_epochs, args.batch_size, ) arch, log, device, path = ( args.network, args.log, args.device, args.models_path ) defaults.device = args.device tfms = create_transforms() bunch = create_bunch(subset_sizes=(trn_sz, val_sz), img_size=img_sz, bs=bs, ds_tfms=tfms, log=args.log) learn = create_cnn(bunch, arch) learn.metrics = [accuracy, map3] learn.fit_one_cycle(1, max_lr=1e-02) learn.fit_one_cycle(1, max_lr=1e-02 / 2) saved_path = learn.save('base', return_path=True) log.info('Intermediate model saved into %s', saved_path) learn.unfreeze() learn.freeze_to(-1) learn.fit_one_cycle(1, max_lr=slice(2e-04, 1e-03)) saved_path = learn.save('unfreeze_one', return_path=True) log.info('Intermediate model saved into %s', saved_path) learn.unfreeze() learn.fit_one_cycle(1, max_lr=slice(1e-04, 3e-04)) saved_path = learn.save('unfreeze_all', return_path=True) log.info('Intermediate model saved into %s', saved_path) learn.fit_one_cycle(1, max_lr=slice(1e-05, 5e-04)) saved_path = learn.save('unfreeze_all', return_path=True) log.info('Done! The final model is saved into file %s', saved_path)
def main(): args = parse_args(sys.argv[1:]) log_parser = LogParser(LineParser) parsed_lines = log_parser.parse(args.filename) analyzer = Analyzer(parsed_lines, start=args.start, end=args.end) try: stats = analyzer.get_output_stats() except (TypeError, ZeroDivisionError): print(( 'It looks like in given time frame there were made less than two requests.\n' 'Stats are unavailable.')) else: message = ('Requests: {requests}\n' 'Requests per second: {request_per_second}\n' 'Responses: {status_count}\n' 'Avg 2XX response size: {2XX_avg_size}\n').format(**stats) print(message, end='')
def tagTest(self, mode, verbose=True): self.stealOutput() (flag, spec, o) = specify_DADGAD(mode, self.db.host) description = cli.describe_by_mode(o) flags = ['-v', flag] if verbose else [flag] args = ['tag'] + ['-U'] + flags + [spec, 'rating=10'] + self.hostname cli.execute_command_line(*cli.parse_args(args)) self.reset() if verbose: target = ['Tagged object %s with rating = 10' % description, '\n'] else: if mode == 'query': target = ['1 object matched', '\n'] else: target = [] self.assertEqual(self.out.buffer, target) self.assertEqual(self.err.buffer, [])
def main(): args = parse_args({ 'resnet18': resnet18, 'resnet34': resnet34, 'resnet50': resnet50 }) img_sz, trn_sz, val_sz, n, bs = ( args.image_size, args.train_size, args.valid_size, args.n_epochs, args.batch_size, ) arch, log, device, path = (args.network, args.log, args.device, args.models_path) defaults.device = device learn = train(arch=arch, epochs=n, lr=3e-2, img_size=img_sz, batch_size=bs, train_size=trn_sz, valid_size=val_sz, log=log, path=path) name = f'{args.arch_name}_{args.suffix}_{img_sz}_{n}' learn.save(name) # learn = train(arch=arch, # preload=name, # epochs=int(max(1, n//2)), # lr=3e-2/3, # img_size=img_sz*3//2, # batch_size=bs*2, # train_size=trn_sz, # valid_size=val_sz, # log=log, # path=path) print('Done!')
def createdb(): """ Create the database tables needed by psz. """ from django.core.management.commands import syncdb opts, args = cli.parse_args() cmd = syncdb.Command() cmd.handle_noargs() from django.db import connection cursor = connection.cursor() # Django can't created indexes on MySQL text fields # http://code.djangoproject.com/ticket/2495 # so we have to do it by hand if DEFAULTS['db_engine'] == 'mysql': # XXX we should construct the table name dynamically cursor.execute('create index zone_index on psz_dnskey (zone(255))') cursor.execute('create index zone_index on psz_logmessage (zone(255))') return 0
def main(): args = cli.parse_args() # Create the database if it doesn't already exist mkpath(args.database) # Instantiate the requested database instance db = Database(args.database, args.ignore_lock) # Execute a SQL file if args.sql_file: sql_runner.sql_file(args.sql_file, db) # SQL REPL if args.interactive: sql_runner.sql_repl(db) # TODO maybe accept SQL input through STDIN return
def main(): args = parse_args(args=sys.argv[1:]) input_shape, n_epochs, n_top, units, pool, l2, patience = ( args.input_shape, args.n_epochs, args.n_dense, args.units, args.pool, args.l2_reg, args.patience) print('Model training with parameters:') pprint(vars(args)) model = ResNet34(input_shape=input_shape) model.create(pool='avg', n_top=n_top, units=units, l2_reg=l2) model.compile(optimizer=args.optimizer) ok = model.create_model_folder(root=join(MODELS_FOLDER, 'face_landmarks'), subfolder=args.identifier) if not ok: sys.exit(1) model.save_parameters(model.parameters_path) callbacks = [ CSVLogger(filename=model.history_path), EarlyStopping(patience=patience, verbose=1), ModelCheckpoint(filepath=model.weights_path, save_best_only=True, save_weights_only=False) ] model.train(n_epochs=n_epochs, train_folder=LFPW_TRAIN, valid_folder=LFPW_VALID, callbacks=callbacks) avg_rmse = model.score(LFPW_VALID) print(f'Trained model validation RMSE: {avg_rmse:2.4f}') print(f'The folder with results: {model.subfolder}') print(f'Training history file: {model.history_path}')
from sys import argv from cli import parse_args parse_args(argv)
def test_algorithm_group(self): self.assertEqual(cli.parse_args(["--sha1","-c","6","hash"]).sha1,True)
import cli if __name__ == "__main__": cli.parse_args()
def main(): args = parse_args() transformers_logger = logging.getLogger("transformers") transformers_logger.setLevel(logging.ERROR) if args.predict_file is None and args.do_eval: raise ValueError( "Cannot do evaluation without an evaluation data file. Either supply a file to --eval_data_file " "or remove the --do_eval argument.") if args.output_dir and os.path.exists(args.output_dir) and \ os.listdir(args.output_dir) and args.do_train and not args.overwrite_output_dir: raise ValueError( "Output directory ({}) already exists and is not empty. Use --overwrite_output_dir to overcome." .format(args.output_dir)) if args.overwrite_output_dir and os.path.isdir(args.output_dir): shutil.rmtree(args.output_dir) os.mkdir(args.output_dir) # Setup CUDA, GPU & distributed training if args.local_rank == -1 or args.no_cuda: device = torch.device("cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu") args.n_gpu = torch.cuda.device_count() else: # Initializes the distributed backend which will take care of sychronizing nodes/GPUs torch.cuda.set_device(args.local_rank) device = torch.device("cuda", args.local_rank) torch.distributed.init_process_group(backend='nccl') args.n_gpu = 1 args.device = device # Setup logging logging.basicConfig( format='%(asctime)s - %(levelname)s - %(name)s - %(message)s', datefmt='%m/%d/%Y %H:%M:%S', level=logging.INFO if args.local_rank in [-1, 0] else logging.WARN) with open(os.path.join(args.output_dir, 'args.txt'), 'w') as f: f.write(str(args)) for key, val in vars(args).items(): logger.info(f"{key} - {val}") try: write_meta_data(args.output_dir, args) except git.exc.InvalidGitRepositoryError: logger.info("didn't save metadata - No git repo!") logger.info( "Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, amp training: %s", args.local_rank, device, args.n_gpu, bool(args.local_rank != -1), args.amp) # Set seed set_seed(args) # Load pretrained model and tokenizer if args.local_rank not in [-1, 0]: # Barrier to make sure only the first process in distributed training download model & vocab torch.distributed.barrier() if args.config_name: config = AutoConfig.from_pretrained(args.config_name, cache_dir=args.cache_dir) elif args.model_name_or_path: config = AutoConfig.from_pretrained(args.model_name_or_path, cache_dir=args.cache_dir) else: config = CONFIG_MAPPING[args.model_type]() logger.warning( "You are instantiating a new config instance from scratch.") #config.hidden_dropout_prob = args.encoder_dropout_prob if args.tokenizer_name: tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name, cache_dir=args.cache_dir) elif args.model_name_or_path: tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path, cache_dir=args.cache_dir) else: raise ValueError( "You are instantiating a new tokenizer from scratch. This is not supported, but you can do it from another script, save it," "and load it from here, using --tokenizer_name") config_class = LongformerConfig base_model_prefix = "longformer" S2E.config_class = config_class S2E.base_model_prefix = base_model_prefix model = S2E.from_pretrained(args.model_name_or_path, config=config, cache_dir=args.cache_dir, args=args) model.to(args.device) if args.local_rank == 0: # End of barrier to make sure only the first process in distributed training download model & vocab torch.distributed.barrier() logger.info("Training/evaluation parameters %s", args) evaluator = Evaluator(args, tokenizer) # Training if args.do_train: train_dataset = get_dataset(args, tokenizer, evaluate=False) global_step, tr_loss = train(args, train_dataset, model, tokenizer, evaluator) logger.info(" global_step = %s, average loss = %s", global_step, tr_loss) # Saving best-practices: if you use save_pretrained for the model and tokenizer, # you can reload them using from_pretrained() if args.do_train and (args.local_rank == -1 or torch.distributed.get_rank() == 0): # Create output directory if needed if not os.path.exists(args.output_dir) and args.local_rank in [-1, 0]: os.makedirs(args.output_dir) logger.info("Saving model checkpoint to %s", args.output_dir) # Save a trained model, configuration and tokenizer using `save_pretrained()`. # They can then be reloaded using `from_pretrained()` model_to_save = model.module if hasattr( model, 'module') else model # Take care of distributed/parallel training model_to_save.save_pretrained(args.output_dir) tokenizer.save_pretrained(args.output_dir) # Good practice: save your training arguments together with the trained model torch.save(args, os.path.join(args.output_dir, 'training_args.bin')) # Evaluation results = {} if args.do_eval and args.local_rank in [-1, 0]: result = evaluator.evaluate(model, prefix="final_evaluation", official=True) results.update(result) return results return results
states = generate_states( args.size, args.prefix_length, args.amount, f ) assert len(states) != 0 for i in range(len(states)): moved_state = move_state(states[i][0], args.prefix_length) revealed_state = states[i][1] if not args.special: if args.reveal_random: revealed_state = reveal_random_values_simple(args.preselected, moved_state) elif args.reveal: revealed_state = reveal_values_simple(args.preselected, moved_state) else: # args.special if args.reveal_random: revealed_state = reveal_random_values_special(args.preselected_even, args.preselected_odd, moved_state) elif args.reveal: revealed_state = reveal_values_special(args.preselected_even, args.preselected_odd, moved_state) states[i][1] = revealed_state write_states(states, args.smt) if __name__ == '__main__': main(parse_args())
def repl_or_go(): action, args, options, parser = cli.parse_args(sys.argv) if len(args) == 0 and not options.version: REPL('This is fish version %s.' % fishlib.VERSION) else: return cli.go()
axes1[axId].set_yticks([-200,-100,0,100,200]) axes2[axId].set_yticks([-20,-10,0,10,20]) if axId > 0: axes1[axId].yaxis.set_ticklabels([]) axes2[axId].yaxis.set_ticklabels([]) axId += 1 axes1[0].set_ylabel("y") axes2[0].set_ylabel("y") for ax in axes2: ax.set_xlabel("x") if __name__ == "__main__": args = cli.parse_args() def plot_and_save_as_needed(name): if args.save: print("Saving "+name) plt.savefig(name, bbox_inches='tight') if not args.noshow: plt.show() plt.close() dataset = settings.DATASETS[args.dataset_id] experiments = { "BBB": bbb_decay.bbb_decay_base.get_variant("BBB covviz "+dataset), "SLANG L=1":slang.slang_base.get_variant("SLANG covviz L=1 "+dataset), "SLANG L=5":slang.slang_base.get_variant("SLANG covviz L=5 "+dataset),
from cli import parse_args from draw import show_results from rng import * RNG_GENERATORS = { 'raw': lehmer_random, 'uniform': uniform_random, 'gaussian': gaussian_random, 'exponential': exponential_random, 'gamma': gamma_random, 'triangle': triangle_random, 'simpson': simpson_random } if __name__ == '__main__': options = parse_args() rng = RNG_GENERATORS[options.mode](vars(options)) random_values = list(rng) checking_report = indirect_signs_checking( random_values) if options.mode == 'raw' else None numerical_characteristics = numerical_characteristics_estimation( random_values) interval_distribution = count_interval_distribution( random_values, options.intervals_count) periodic_stats = aperiodic_interval_and_period(random_values) show_results(interval_distribution, checking_report, numerical_characteristics, periodic_stats)
def main(): args = cli.parse_args(sys.argv[1:]) cli.handle_parsed_args(args)
def test_character_group(self): self.assertEqual(cli.parse_args(["--sha1","-c","6","hash"]).chars,6)
log_path (str): Path to the log files directory. Returns: list: The relevant epoch numbers. """ if type(spec) is list: return spec metric, n_epochs = spec df = pd.read_csv(os.path.join(log_path, 'history.csv'), index_col=0) df.sort_values(by=metric, ascending=metric in ['val_loss'], inplace=True) return df.index.values[:n_epochs] def _log_parameters(output_path, **params): """Write the given parameter values to a JSON file. Args: output_path (str): Output file path. **params: Parameter values to log. """ with open(output_path, 'w') as f: json.dump(params, f, indent=2) if __name__ == '__main__': try: sys.exit(main(cli.parse_args())) except FileNotFoundError as error: sys.exit(error)
def save_field(self, field_name, output_file=None): """ Save value of the field to the file. :param field_name: :param output_file Output file if it should be different from current settings path :return: """ output_file = output_file if output_file else self.settings_path current_values = {} try: with open(output_file) as save_file: current_values = json.load(save_file) except Exception as error: logger.error("Error while reading settings file: {}".format( str(error))) current_values[field_name] = getattr(self, field_name) try: with open(output_file, mode='w') as save_file: json.dump(current_values, save_file, indent=4, sort_keys=True) except Exception as error: logger.error("Error while reading settings file: {}".format( str(error))) logger.info("Wrote {}:{}".format(field_name, current_values[field_name])) SETTINGS = SettingsManager(cli.parse_args()[0])
p.make_phi() problem_file = coalesce([p.P, p.phi, p.daisy_name], p.daisy_models_name) if not run_spin(problem_file): p.print_no_solution() clean_and_exit() make_all_trails(problem_file, p.max_attacks) trail_cmds = generate_trail_commands(p.daisy_models_name) trails = parse_all_trails(trail_cmds, p.recovery_huh) attackers = make_attackers(trails, trail_cmds, p) write_attackers(attackers) clean_up() ''' # Characterize the attacks if p.characterize_huh: (E, A) = characterizeAttacks(model, phi, with_recovery, attacker_name) clean_up() return 0 if (E + A) > 0 else -1 else: ''' return 0 # assume it worked if not asked to prove it ... if __name__ == "__main__": problem = parse_args() solve_attacker_syn(problem)
# -*- coding: utf-8 -*- # pylint: disable=import-error, no-name-in-module import os from cli import parse_args # parse arguments _args = parse_args() # CLI arguments KILL_SIGNAL = _args.signal SERVER_NAME_HOST = _args.host SERVER_NAME_PORT = _args.port DOCKER_COMPOSE = _args.docker_compose DUMP_PATH = _args.dump_path LOGS_PATH = _args.logs_path API_LOGS = _args.api_logs API_ROOT = _args.api_root INTERVAL = _args.interval MAX_RETRY = _args.max_retry # macros EXIT_SUCCESS = 0 EXIT_FAILURE = 1 # log files FILE = os.path.join(LOGS_PATH, 'dump.log') FAIL = os.path.join(LOGS_PATH, 'fail.log') # unset args
def test_no_algorithm_group(self): try: self.assertRaises(cli.parse_args(["hash"]),lambda :SystemExit) except SystemExit: self.assertEqual(True,True) #cant find other way to check system exit
def test_character_group(self): self.assertEqual( cli.parse_args(["--sha1", "-c", "6", "hash"]).chars, 6)
def test_algorithm_group(self): self.assertEqual( cli.parse_args(["--sha1", "-c", "6", "hash"]).sha1, True)
def choose_hasher(arguments): if arguments.md5: hasher = Hasher.MD5Hasher() elif arguments.sha1: hasher = Hasher.SHA1Hasher() elif arguments.sha256 : hasher = Hasher.SHA256Hasher() return hasher if __name__=="__main__": arguments = cli.parse_args(sys.argv[1:]) # removing the filename hasher = choose_hasher(arguments) key_generator = choose_key_generator(arguments) desired_hash = arguments.hash #matric init_time = time.time() keys=0 for key in key_generator.gen_keywords(): joined_key = "".join(key) output_hash = hasher.getHash(joined_key,True)
We used *time.sleep(2)* in order to avoid issues related to items counting (stochastics fluctuations in time are significant and most of the times the set_score function wouldn't work because of that, compromising the learning process) """ #“Code is more often read than written.” --Guido Van Rossum # author : Simone Azeglio import MalmoPython import time from cli import parse_args from mission import mission if __name__ == "__main__": mazeXMLFile, alg, out = parse_args() m = mission() m.load(mazeXMLFile) while True: m.start() # initialize action action = '' # Loop until mission ends: try: while m.is_running(): time.sleep(0.1) # get observation --> return what the agent can see observations = m.get_observation()
from cli import parse_args from pynytimes import NYTAPI mode, topic_url, articles_to_scrape, driver_path = parse_args() # For testing: If True only one article is scrapped DEMO = False DEMO_TOPIC = 'https://www.nytimes.com/section/world/africa' DEMO_ARTICLE_SCRAP = 1 # Database details HOST = 'localhost' DATABASE = 'nytimes' # your variables USER = '******' PASSWORD = '******' # Settings for the logger LOG = 'log_file.log' NYTname = 'scrapper' # API key for the NYT API nyt = NYTAPI("qeOAmrE6yGzowmzGiIpoK0ZBHOnyJ8BG", https=False)