def _parse_command_line_args(): from argparse import ArgumentParser as AP ap = AP(description='Load two files and check if their values are similar') ap.add_argument('input1', help='Text file that contains single value series') ap.add_argument('input2', help='Text file that contains single value series') ap.add_argument('--threshold', type=float, default=1e-2, help='Relative threshold for value comparison') return ap.parse_args()
def get_args(self): parser = AP( description= "Collecting the kernel version you input and output all of the dates of commit." ) h = """You should input the version as three parts and separate them with SPACE. And if you input 'c' as the end of input, the result will be cumulative.""" parser.add_argument("-v", "--version", required=True, nargs="+", help=h) return parser
def command_build(self): ''' Dv_cli build [-dest target_dir] // <- build specified tb ''' parser = AP() parser.add_argument( 'name', metavar='NAME', #nargs='+', help='a name of the object type to instance') pargs = parser.parse_args(args=self.subcmd_args) dvbuild = dv_build.dv_build() dvbuild.command_build(pargs.name)
def main(): ap = AP() ap.add_argument("--config", help="config file", default="i2ptunnel.json") ap.add_argument("--debug", default=False, help="enable debug mode", action="store_const", const=True) args = ap.parse_args() lvl = logging.WARN if args.debug: lvl = logging.DEBUG logging.basicConfig(level=lvl, format='%(asctime)s %(levelname)s %(name)s >> %(message)s') log = logging.getLogger("pyi2ptunnel.main") log.debug('debug on') if os.path.exists(args.config): cfg = config.Load(args.config) log.info('loaded config') samaddr = "tcp:127.0.0.1:7657" # check config for override if "sam" in cfg and "addr" in cfg["sam"]: samaddr = cfg["sam"]["addr"] apptunnel = tunnel.TunnelFactory(api="SAM", apiEndpoint=samaddr) tunnels = list() tunnels_config = cfg.get('clients', list()) for tunnel_cfg in tunnels_config: type = tunnel_cfg.get("type") tun_name = tunnel_cfg.get("name") if type: # build tunnel factory tun = apptunnel.createClient(type, **tunnel_cfg.get("args", dict())) if tun: ep_str = tunnel_cfg.get("listen") if ep_str: # start it up ep = serverFromString(reactor, str(ep_str)) ep.listen(tun) log.info("{} will listen on {}".format(tun_name, ep_str)) else: log.error("no listen address specified for {}".format(tun_name)) else: log.error("no tunnel type specified for {}".format(tun_name)) log.info("run reactor") reactor.run() else: log.error("no such file: {}".format(args.config))
def options(argv): usages = "python3 {} -i file_in -l [length] -o [overlap]".format(argv[0]) description = "script for splitting sequence into parts with given length and overlap size." p = AP(usage=usages, description=description) p.add_argument("-i", dest="file_in", metavar="file_in", help="Sequence file in format of txt") p.add_argument("-o", dest="overlap", metavar="[int]", help="overlap size.", type=int) p.add_argument("-l", dest="length", metavar="[int]", help="sequence length after splitted", type=int) p.add_argument( "-s", dest="start", metavar="[left/right]", choices=["left", "right"], help="Sequence split start from left or right. (default: left)", default="left") p.add_argument("-t", dest="transform", action="store_true", help="Output sequence in transform. (default: False)", default=False) p.add_argument( "-w", dest="inturn", action="store_true", help= "Output sequence in turn of transformed or not, the first sequence depend on option -t. (default: False)", default=False) p.add_argument( "-r", dest="report", action="store_true", help="print sequence split result on screen. (default: False)", default=False) if len(argv) == 1: p.print_help() exit(1) return p.parse_args(argv[1:])
def main(argv=None): argv = (argv or sys.argv)[1:] parser = AP() parser.add_argument('source', type=str, help='source directory to make the gif with') parser.add_argument('output', type=str, help='the desired final output filename') parser.set_defaults(func=gifit) args = parser.parse_args(argv) try: args.func(args=args) except Exception as e: parser.error((str(e)))
def main(): # default mempo usk mempo_usk = 'USK@oRy7ltZLJM-w-kcOBdiZS1pAA8P-BxZ3BPiiqkmfk0E,6a1KFG6S-Bwp6E-MplW52iH~Y3La6GigQVQDeMjI6rg,AQACAAE/deb.mempo.org' # init argparser ap = AP() ap.add_argument( "--usk", default=mempo_usk, type=str, help="custom freenet address to download from (BE VERY CAREFUL)") ap.add_argument("--debug", action="store_const", default=False, const=True, help="enable debug output") ap.add_argument("--freenet", default="http://127.0.0.1:8888/", type=str, help="url of freenet proxy") ap.add_argument("--revision", required=True, type=int, help="freenet repo revision number") # parse args args = ap.parse_args() # determin log level lvl = args.debug and logging.DEBUG or logging.INFO # config logging logging.basicConfig( format="%(created)d -- %(name)s-%(levelname)s: %(message)s") # set level of mempo logger log = logging.getLogger("mempo") log.setLevel(lvl) # tell the user stuff log.info("\t--> obtaining mempo repository via freenet") log.warn("\t!!! This WILL take a long time") log.info("\t--> using freenet proxy: {}".format(args.freenet)) log.info("\t--> using revision: {}".format(args.revision)) # do it :^3 get_all(args.usk, args.revision, args.freenet)
def main(): """ main function for keygen """ argparser = AP() argparser.add_argument('--keyfile', type=str, required=True, help='place to put generated keys') args = argparser.parse_args() secret = SigningKey.generate() with open(args.keyfile, 'wb') as wfile: wfile.write(b'd1:s64:') wfile.write(secret.encode()) wfile.write(secret.verify_key.encode()) wfile.write(b'e') print("{}.loki".format(base32z(secret.verify_key.encode())))
def _parse_command_line_args(): from argparse import ArgumentParser as AP ap = AP( description=( 'Run Initializer and check if the distribution of ' 'the resulting values is desired one') ) ap.add_argument( 'config', help='YAML file with initializer config and test config' ) ap.add_argument( '--output', help='Name of output HDF5 file.' ) ap.add_argument( '--key', help='Name of dataset in the output file.', default='input' ) return ap.parse_args()
def create_commom_argparse(self, parser=None): if (parser == None): parser = AP() parser.add_argument( '--name', '-n', metavar=('NAME'), action='store', dest='name', required=True, help="provide the name of the verification component") parser.add_argument( '--kind', '-k', metavar=('KIND'), action='store', dest='kind', required=True, help="provide the kind of the verification component") parser.add_argument( '--package', '-p', metavar=('PKG'), action='store', dest='package', required=False, help="provide the name of the template else defaults to <name>_pkg" ) parser.add_argument('--parent', '-r', metavar=('PARENT'), action='store', dest='parent', required=False, help="provide the name of the parent class") parser.add_argument('--set', '-s', nargs=2, metavar=('KEY', 'VALUE'), action='append', default=[], dest='config', help='Override config KEY with VALUE expression') return parser
def _parse_command_line_args(): from argparse import ArgumentParser as AP ap = AP( description='Feed batch data to layer and save the output to file' ) ap.add_argument( 'config', help='File contains layer and run config.' ) ap.add_argument( '--output', help='Output data file.' ) ap.add_argument( '--debug', help='Enable debug log', action='store_true' ) return ap.parse_args()
def __init__(self): self.project = dv_project.dv_project() parser = AP(description= "Top level command for building Verification Environments", usage=sys.argv[0] + ''' <command> [<args>] build_agent - Build a drive uvm component build_test - Build a test component''') parser.add_argument('command', help="sub-command to run") args = parser.parse_args(sys.argv[1:2]) self.subcmd_args = sys.argv[2:] if not hasattr(self, 'command_' + args.command): print("Unknown command") parser.print_help() exit(1) # dispatch to the sub-command getattr(self, 'command_' + args.command)()
def build(): prs = AP() prs.add_argument('-group', type=str, default=[], nargs="+", action="append", required=True, help="Filenames defining monster groups to fight") prs.add_argument( '-seed', type=int, default=None, help="Set global RNG seed (default not set--psuedorandom)") prs.add_argument('-max-turns', type=int, default=None, help="Limit turns in each brawl (default None)") return prs
def main(): p = AP() p.add_argument('-o', required=True) p.add_argument('--rebuild', action='store_true') p.add_argument('--lang', default='es') p.add_argument('--country', default='MX') p.add_argument('--search_terms', nargs='+', default=[ 'covid', 'coronavirus', 'pandemia', 'cubrebocas', 'tapabocas', 'cuarentena', 'distanciamiento social', 'Quédate en Casa', 'sars cov-2' ]) p.add_argument('--test', action='store_true') args = p.parse_args() os.makedirs(args.o, exist_ok=True) n_days = (NOW - START).days if args.test: n_days = 5 days_iter = np.random.permutation(n_days) api = API(args.search_terms, args.lang, args.country) def worker(day): out_path = f'{args.o}/{day}.txt' if not args.rebuild: if os.path.exists(out_path): return from_ = START + (day * DAY) to_ = from_ + DAY from_ = from_.strftime('%Y-%m-%d') to_ = to_.strftime('%Y-%m-%d') results = api(from_, to_) with open(out_path, 'w') as fjson: fjson.write('\n'.join(json.dumps(r) for r in results)) Parallel(n_jobs=8, verbose=10, prefer='threads')(delayed(worker)(day) for day in days_iter)
def load_env(): """ define interface and load any environment variables required """ parser = AP() parser.add_argument('--train', nargs='+', required=True, help='Path to training data') parser.add_argument('--train_desc', required=True , help='Describe the training data set') parser.add_argument('--test', nargs='*', help='Path to test data. Must be omitted or '+\ 'same number of tool files as as --train (and in the same order)') parser.add_argument('--test_desc', help='Describe the test data set') parser.add_argument('--tool_names', nargs='+', required=True, help='Names of each tool in the same order '+\ 'as given for --train (and --test if provided)') parser.add_argument('--trunc_max', nargs='*', type=float, help='Truncate maximum values. Must match order of training data') parser.add_argument('--trunc_min', nargs='*', type=float, help='Truncate minimum values. Must match order of training data') parser.add_argument('--debug', action='store_true', help='Turn on debugging output (STDERR)') parser.add_argument('--inc_pred', action='store_true', help='Include tool prediction categories '+\ 'in regression. NOTE: must be present in all input files') parser.add_argument('--filter', type=float, default=-1, help='Percentage of total reads to remove '+\ 'around mean score, default -1 (disabled)') parser.add_argument('--testIsTraining', action='store_true', help='Use functions for handling training data for the test parameters') parser.add_argument('--no_scaling', action='store_true', help='Disable score scaling') args = parser.parse_args() # check that the number of command line arguments make sense if len(args.train) != len(args.tool_names): print('Tool names must match training files', file=sys.stderr) sys.exit(-1) if args.test and len(args.test) != len(args.train): print('Test files must match training files', file=sys.stderr) sys.exit(-1) if args.test and not args.test_desc: print('Description of test data set required', file=sys.stderr) sys.exit(-1) if args.trunc_max and len(args.trunc_max) != len(args.train): print('Truncation maximum values must match against each training input', file=sys.stderr) sys.exit(-1) if args.trunc_min and len(args.trunc_min) != len(args.train): print('Truncation minimum values must match against each training input', file=sys.stderr) sys.exit(-1) return args
def main(): from argparse import ArgumentParser as AP parser = AP( description= 'Mini python script to replace specified value in PCAP(or any binary) file.' ) parser.add_argument('-s', '--srcpcap', help='Path to the raw PCAP file to be anonymized.', required=True) parser.add_argument('-d', '--dstpcap', help='Filename of the anonymized PCAP file.', default='anonymized.pcap') parser.add_argument( '-v', '--strvals', help='A pair of values before/after anonymized in STRING format.', metavar='STRVAL', nargs=2, action='append') parser.add_argument( '-x', '--hexvals', help='A pair of values before/after anonymized in HEX format.', metavar='HEXVAL', nargs=2, action='append') args = parser.parse_args() validate_args(args.strvals, args.hexvals) p = PcapHandler(args.srcpcap, args.dstpcap) if args.strvals is not None: r = p.replace_strval(args.strvals) if args.hexvals is not None: r = p.replace_hexval(args.hexvals) p.write_pcap(r)
def create_connect_argparse(self, parser=None): ''' inst foo --in bar [-as foo_inst] [-parameter myparm myparmvalue] ''' if (parser == None): parser = AP() parser.add_argument( 'name', metavar='NAME', #nargs='+', help='a name of the object type to instance') parser.add_argument( '--in', '-i', metavar=('INST_LOCATION'), action='store', dest='inst_loc', required=True, help="provide the name of the class to place the instance") parser.add_argument('--as', '-a', metavar=('INST_NAME'), action='store', dest='inst_name', required=True, help="provide the name of the instance") parser.add_argument( '--num', '-n', metavar=('NUM'), action='store', dest='inst_num', required=False, help= "provide the number of instance as an integer 'q' for a queue or 'd' for dynamic array" ) return parser
def _parse_command_line_args(): from argparse import ArgumentParser as AP ap = AP( description=('Create sample batch from MNIST dataset. ' '(http://deeplearning.net/data/mnist/mnist.pkl.gz) ' 'Resulting batch has shape (N=10, C[=4], H[=28], W[=27])' 'where the first index corresponds to digit.')) ap.add_argument('output', help='Output file path') ap.add_argument('--input', help='mnist.pkl data', default=os.path.join('data', 'mnist.pkl.gz')) ap.add_argument('--key', default='input', help='Name of dataset to create') ap.add_argument('--height', default=28, type=int, help='batch height.') ap.add_argument('--width', default=27, type=int, help='batch width.') ap.add_argument('--channel', default=4, type=int, help='#Channels in batch.') ap.add_argument('--plot', action='store_true', help='Visualize the resulting data') return ap.parse_args()
def _parse_command_line_args(): from argparse import ArgumentParser as AP ap = AP( description=('Given a set of DQN parameters, evaluate the performace')) ap.add_argument('env', help='Environment configuration file') ap.add_argument('agent', help='Agent configuration file') ap.add_argument('input_dir', help='Directory where trained parameters are stored') ap.add_argument('output_dir', help='Directory where evaluation result is written') ap.add_argument('--prefix', default='DQN', help='Prefix of trained parameter files') ap.add_argument('--timelimit', type=float, default=300, help='Time limit of one episode') ap.add_argument('--episodes', type=int, default=30, help='#Episodes to run') return ap.parse_args()
def main(): parser = AP() parser.add_argument("-i", "--inputdir", dest="inputdir", help="InputDirectory", required=True) parser.add_argument("-s", "--searchstring", dest="searchstring", help="Search String", required=True) parser.add_argument("-o", "--outputdir", dest="outputdir", help="JSON Output Dir + Name", required=True) if len(sys.argv) < 3: parser.print_help() sys.exit(1) args = parser.parse_args() new = searchthis(args.inputdir, args.searchstring) with open(args.outputdir, 'w') as outfile: json.dump(new, outfile)
def parse_args(argv): """ Command line parser Parameters ---------- argv : list of strings list to parsed Returns ------- namespace: Parsed arguments """ p = AP(formatter_class=AHF) p.add_argument('--cores', '-c', type=int, default=1, help='Number of cores for multiprocessing') p.add_argument('--debug', '-d', action="store_true", help='Keep pylauncher workdir after completion') p.add_argument('cmdfile', type=str, help="""Input commands file""") return p.parse_args(args=argv)
def option(argv): from argparse import ArgumentParser as AP usages = "python3 {} -f fa -i prefix -o outputdir".format(argv[0]) p = AP(usage=usages) p.add_argument("-f", dest="fa", metavar="[fa]", help="fasta file.", required=True) p.add_argument("-i", dest="prefix", metavar="[prefix]", help="prefix of *.NC.cluster", required=True) p.add_argument("-o", dest="out", metavar="[outputdir]", help="outputdir path", required=True) if len(argv) == 1: p.print_help() exit(1) return p.parse_args(argv[1:])
def reset_original_mac(interface=None): if interface is None: print('No interface were provided') print_interfaces() exit(1) check_interface(interface) origin_mac = check_output(['ethtool', '-P', interface]).decode().split()[-1] change_mac(origin_mac, interface) check_sudo() parser = AP() parser.add_argument('-i', '--interface', dest='interface', default=None, help='select an interface to change the mac address') parser.add_argument( '-m', '--mac', dest='mac', default=rand_mac(), help= 'specify a new mac to change. If not mac address were supply a random mac address will be generated' ) parser.add_argument(
def main(): ap = AP() ap.add_argument('--dir', type=str, default='testnet_tmp') ap.add_argument('--svc', type=int, default=20, help='number of service nodes') ap.add_argument('--baseport', type=int, default=19000) ap.add_argument('--clients', type=int, default=200, help='number of client nodes') ap.add_argument('--bin', type=str, required=True) ap.add_argument('--out', type=str, required=True) ap.add_argument('--connect', type=int, default=10) args = ap.parse_args() basedir = os.path.abspath(args.dir) for nodeid in range(args.svc): config = CP() config['bind'] = { 'lo': str(args.baseport + nodeid) } config['netdb'] = { 'dir': 'netdb' } config['connect'] = {} for otherid in range(args.svc): if otherid != nodeid: name = svcNodeName(otherid) config['connect'][name] = os.path.join( basedir, name, 'rc.signed') d = os.path.join(args.dir, svcNodeName(nodeid)) if not os.path.exists(d): os.mkdir(d) fp = os.path.join(d, 'daemon.ini') with open(fp, 'w') as f: config.write(f) for nodeid in range(args.clients): config = CP() config['netdb'] = { 'dir': 'netdb' } config['connect'] = {} for otherid in range(args.connect): otherid = (nodeid + otherid) % args.svc name = svcNodeName(otherid) config['connect'][name] = os.path.join( basedir, name, 'rc.signed') d = os.path.join(args.dir, clientNodeName(nodeid)) if not os.path.exists(d): os.mkdir(d) fp = os.path.join(d, 'daemon.ini') with open(fp, 'w') as f: config.write(f) with open(args.out, 'w') as f: f.write('''[program:svc-node] directory = {} command = {} redirect_stderr=true stdout_logfile=/dev/fd/1 stdout_logfile_maxbytes=0 process_name = svc-node-%(process_num)03d numprocs = {} '''.format(os.path.join(args.dir, 'svc-node-%(process_num)03d'), args.bin, args.svc)) f.write('''[program:client-node] directory = {} command = {} redirect_stderr=true stdout_logfile=/dev/fd/1 stdout_logfile_maxbytes=0 process_name = client-node-%(process_num)03d numprocs = {} '''.format(os.path.join(args.dir, 'client-node-%(process_num)03d'), args.bin, args.clients)) f.write('[supervisord]\ndirectory=.\n')
def parse_command_line_arguments(): from argparse import ArgumentParser as AP ap = AP() ap.add_argument('input_file', help='fcs file') return ap.parse_args()
def readFile(filename): try: file = open(filename) except IOError as e: sys.stderr.write(str(e) + "\n") sys.stderr.write("Try 'touch " + filename + "'\n") exit(1) else: try: return json.load(file) except: return [] if __name__ == "__main__": parser = AP(description="Task/Todo List Manager") group = parser.add_mutually_exclusive_group(required=True) group.add_argument("--list", help="List all task items", action="store_true") group.add_argument("--add", help="Add an item", type=str, dest="newItem", metavar="DESC") group.add_argument("--del", help="Delete an item", type=int, dest="delItem", metavar="NUM") group.add_argument("--done",
"Boolean function for determing file as binary or hex" textchars = bytearray({7, 8, 9, 10, 12, 13, 27} | set(range(0x20, 0x100)) - {0x7F}) return bool(bytes.translate(None, textchars)) # Regex patt = r"(?<!\b)CAFE" subs = "\\nCAFE" # Parser parser = AP( prog="tube_buffer_clean", description=""" Script to attempt to clean a tube data dump, if corrupt. This script only adds newlines in front of any CAFE instances that are not at the beginning of a line. """, ) parser.add_argument("file", metavar="file", help="HEX or binary file to be cleaned") args = parser.parse_args() with open(args.file, "rb") as file: if is_binary(file.read(1024)): file.seek(0) hexData = file.read().hex().upper() outFile = file.name[:-3] + "hex_cleaned" else:
#!/usr/bin/env python from argparse import ArgumentParser as AP parser = AP(description="Perform django commands in a reusable app") parser.add_argument("action", help="command (e.g. 'makemigrations', 'shell', 'test')") args = parser.parse_args() # https://stackoverflow.com/questions/30656162/migrations-in-stand-alone-django-app#answer-32379263 import sys import django from django.conf import settings from django.core.management import call_command settings.configure( DEBUG=True, INSTALLED_APPS=( 'django.contrib.contenttypes', 'django.contrib.auth', 'wk', ), ROOT_URLCONF="urls", ) #endsnippet if args.action == "test": # 'test' action requires the default database configured # Use in-memory sqlite3 import os
def give_init(function_name): if function_name == 'B1': return np.array([-20, 10]) elif function_name == 'B2': return np.array([10, -10]) elif function_name == 'B3': return np.array([-10, 10]) elif function_name == 'BL': return np.array([1, 2]) elif function_name == 'RB': return np.array([-2.1, 2.1]) p = AP() p.add_argument( '--optim', required=True, help='Optimizers: GD | CM | Adam | Adagrad | Adadelta | RMSprop') p.add_argument('--fn', required=True, help='Function name: B1 | B2 | B3 | BL | RB') p.add_argument('--iter', default=1000, type=int, help='Number of iterations to run for') p = p.parse_args() newDir = os.path.join(p.fn, p.optim) try:
for inter in n_cars_intert: streets = set(self.intersections[inter]['in']) streets = list(streets.intersection(set(n_cars_street))) random.shuffle(streets) self.lights[inter]['streets'] = streets ncs = [n_cars_street[s] for s in streets] m = max(ncs) f = math.ceil ncs = [f(max_light_duration*(n/m)) for n in ncs] self.lights[inter]['durations'] = ncs self.lights = {k:v for k, v in self.lights.items() if len(v['streets']) > 0} #print(self.lights) if __name__ == '__main__': parser = AP(description='solveproblem') parser.add_argument('-l', dest="max_light_duration", type=float, default=1, help='max duration of a light') parser.add_argument('-p', dest="problem", default='a,b,c,d,e,f', help='problem a,b,c,d,e,f') args = parser.parse_args() probs = args.problem.split(',') for p in probs: print(f'solving {p}') s = Solver(p) s.solve(args.max_light_duration) s.write_result() print('Done')