def cmd_extract(self, argv): ''' Usage: {cmd} mobipath [outdir] Extract the contents of the MOBI file mobipath into the directory outdir, default based on the mobipath basename. Prints the outdir and the name of the top file. ''' outdirpath = None if not argv: raise GetoptError("missing mobipath") mobipath = argv.pop(0) if argv: outdirpath = argv.pop(0) if argv: raise GetoptError("extra arguments after cbzpath: %r" % (argv,)) if not existspath(mobipath): raise GetoptError("mobipath does not exist: %r" % (mobipath,)) if outdirpath is None: outdirpath, mobiext = splitext(basename(mobipath)) if existspath(outdirpath): raise GetoptError("outdir already exists: %s" % (outdirpath,)) MB = Mobi(mobipath) extdirpath, rfilepath = MB.extract(outdirpath) assert extdirpath == outdirpath print(outdirpath) print(rfilepath)
def get_args(): """Returns program options as dictionary {'option': value}""" opts_dictionary = {} try: options, args = getopt(sys.argv[1:], '', ['help', 'input=', 'output=', 'br', 'format=']) if args: # args list is not empty raise GetoptError( 'invalid program argument \'' + args[0] + '\'') opts_list = [opt[0] for opt in options] if len(opts_list) != len(set(opts_list)): raise GetoptError('cannot combine two or more same options') for arg in sys.argv[1:]: if (arg[2:] != 'help' and arg[2:] != 'br' and not re.match(r'\w+=.+', arg[2:])): raise GetoptError('bad option \'' + arg + '\'') except GetoptError as opt_error: error_print(sys.argv[0], ': ', end='', sep='') error_print(opt_error) sys.exit(exit_codes.BAD_ARGUMENTS) for opt in options: opts_dictionary[opt[0][2:]] = opt[1] return opts_dictionary
def get_parameters(argv, needed_arguments, algorithms): opts = "a:" try: optlist, args = getopt(argv[1:], opts) optlist = dict(optlist) if "-a" not in optlist: requested_algorithms = sorted(algorithms.keys()) else: if optlist["-a"].lower() not in algorithms: raise GetoptError("algorithm not found in : "+ " ".join(sorted(algorithms))) else: requested_algorithms = [optlist["-a"]] if len(args) < needed_arguments: raise GetoptError("Not enough arguments") else: inputs = list() for i in xrange(needed_arguments): try: with open(args[i], "rb") as f: inputs += [f.read()] except IOError: inputs += [args[i]] except GetoptError, error: print("Error: %s\n" % error) #print(Help) exit()
def main(argv): output = None style = 'oracle' optimizer = optimizers.get('none') flags = 'vhfDSo:s:H:O:' keywords = [ 'help', 'verbose', 'output=', 'style=', 'header=', 'optimizer=', 'fast', 'deferrable', 'sort', ] try: opts, args = getopt(argv, flags, keywords) for opt, arg in opts: if opt in ('-h', '--help'): usage() sys.exit(0) if opt in ('-v', '--verbose'): options['verbose'] = True continue if opt in ('-o', '--output'): output = arg continue if opt in ('-s', '--style'): if style in ('oracle', 'postgres'): style = arg else: raise GetoptError('style "%s, not-valid' % arg) continue if opt in ('-f', '--fast'): options['fast'] = 1 continue if opt in ('-S', '--sort'): options['sort'] = True continue if opt in ('-O', '--optimizer'): optimizer = optimizers.get(arg) if optimizer is None: raise GetoptError('optimizer "%s", not-valid' % arg) continue if opt in ('-H', '--header'): f = open(arg) options['header'] = f.read() f.close() continue if opt in ('-D', '--deferrable'): options['deferrable'] = True continue options['optimizer'] = optimizer processfiles(style, output, args) except GetoptError, e: print e usage() sys.exit(2)
def mkdir(tokens): global Remotedir cmd = 'mkdir' if len(tokens) == 1: raise GetoptError('') arg = Remotedir + tokens[1].strip() if not arg: raise GetoptError('') args = {'path': arg} return Task(no_return, cmd, args)
def cmd_attach(D, argv): ''' Attach an arbitrary Dirent to the current directory `D`. Usage: attach name dirent_spec ''' if not D.isdir: raise GetoptError("not a Dir: %s" % (D,)) if not argv: raise GetoptError("missing name") name = argv.pop() if not name or PATHSEP in name: raise GetoptError( "invalid name, may not be empty or contain the separator %r: %r" % (PATHSEP, name) ) if not argv: raise GetoptError("missing dirent_spec") dirent_spec = argv.pop() if argv: raise GetoptError("extra arguments after dirent_spec: %r" % (argv,)) try: E = parse(dirent_spec) except ValueError as e: raise GetoptError("parse failure: %r: %s" % (dirent_spec, e)) from e if not isinstance(E, _Dirent): raise GetoptError("not a Dirent specification: %r" % (dirent_spec,)) if name in D: raise GetoptError("name already exists: %r" % (name,)) D[name] = E
def cmd_ont(self, argv): ''' Usage: {cmd} type_name ''' tagger = self.options.tagger if not argv: raise GetoptError("missing type_name") type_name = argv.pop(0) with Pfx("type %r", type_name): if argv: raise GetoptError("extra arguments: %r" % (argv, )) print(type_name) for type_value in tagger.ont_values(type_name): ontkey = f"{type_name}.{type_value}" with Pfx("ontkey = %r", ontkey): print(" ", r(type_value), tagger.ont[ontkey])
def cmd_ls(self, argv): ''' Usage: {cmd} [-l] List the contents of the Calibre library. ''' long = False if argv and argv[0] == '-l': long = True argv.pop(0) if argv: raise GetoptError("extra arguments: %r" % (argv, )) options = self.options calibre = options.calibre for book in calibre: with Pfx("%d:%s", book.id, book.title): print(f"{book.title} ({book.dbid})") if long: print(" ", book.path) identifiers = book.identifiers_as_dict() if identifiers: print(" ", TagSet(identifiers)) for fmt, subpath in book.formats_as_dict().items(): with Pfx(fmt): fspath = calibre.pathto(subpath) size = pfx_call(os.stat, fspath).st_size print(" ", fmt, transcribe_bytes_geek(size), subpath)
def cmd_dbshell(self, argv): ''' Usage: {cmd} Start an interactive database prompt. ''' if argv: raise GetoptError("extra arguments: %r" % (argv, )) return self.options.calibre.dbshell()
def main(argv=None): ''' Main program: inspect or modify flags. ''' if argv is None: argv = sys.argv else: argv = list(argv) cmd = argv.pop(0) usage = FLAG_USAGE % (cmd, cmd, cmd) xit = 0 flagdir = None F = Flags(flagdir=flagdir) badopts = False try: if not argv: ks = sorted(F.keys()) for k in ks: print(k, "TRUE" if F[k] else "FALSE") else: k = argv.pop(0) if not argv: xit = 0 if F[k] else 1 else: value = argv.pop(0) if argv: raise GetoptError("unexpected values after key value: %s" % (' '.join(argv), )) F[k] = truthy(value) except GetoptError as e: print("%s: warning: %s" % (cmd, e), file=sys.stderr) badopts = True if badopts: print(usage, file=sys.stderr) return 2 return xit
def cmd_scan(self, args): ''' Scan a TVWiz directory. Usage: {cmd} recording... Scan the data structures of the supplied recordings. ''' if not args: raise GetoptError("missing tvwizdirs") for tvwizdir in args: print(tvwizdir) total = 0 chunkSize = 0 chunkOff = 0 for wizOffset, fileNum, flags, offset, size in TVWiz(tvwizdir ).trunc_records(): print(" wizOffset=%d, fileNum=%d, flags=%02x, offset=%d, size=%d" \ % ( wizOffset, fileNum, flags, offset, size ) ) total += size if chunkOff != wizOffset: skip = wizOffset - chunkOff if chunkSize == 0: print(" %d skipped" % skip) else: print(" %d skipped, after a chunk of %d" % (skip, chunkSize)) chunkOff = wizOffset chunkSize = 0 chunkOff += size chunkSize += size if chunkOff > 0: print(" final chunk of %d" % chunkSize) print(" total %d" % total) return 0
def main(argv): try: opts, args = getopt(argv, 'h', LONG_OPTIONS) length = 16 if len(args) and args[0].isdigit(): length = int(args[0]) opt_list = [] for opt, _ in opts: if opt == '-h': help() exit() else: opt_list.append(opt[2:]) options = [] for option in LONG_OPTIONS: if not option in opt_list: options.append(option[3:]) if not len(options): raise GetoptError('Can\'t generate password with no char type') except GetoptError as err: print(err) help() except: print(exc_info()) help() else: print(generate_password(length, options))
def account(tokens): cmd = 'account' args = {} start_pos = 0 while start_pos < len(tokens): if '-' in tokens[start_pos]: break start_pos += 1 if start_pos < len(tokens): opts, _ = getopt(tokens[start_pos:], 'n:p:a:', ['name=', 'pwd=', 'auth=']) tokens = tokens[:start_pos] + _ else: opts = [] if len(tokens) != 2: raise GetoptError('') args['action'] = tokens[1] for o, v in opts: if o in ('-n', '--name'): args['name'] = v elif o in ('-p', '--pwd'): args['pwd'] = v elif o in ('-a', '--auth'): args['auth'] = v else: raise GetoptError return Task(after_account, cmd, args)
def parse_args(argv): try: opts, args = getopt(argv[1:], "udm:t:r:e:", ["usage","dryrun","rootdir=","exc_module=","inc_module=","inc_testcase="]) opt_config = {} # optional flags for flag, value in opts: if flag in ("-m", "--inc_module"): opt_config[flag.replace("--","")] = value.split(",") continue elif flag in ("-t", "--inc_testcase"): opt_config[flag.replace("--","")] = value.split(",") continue elif flag in ("-e", "--exc_module"): opt_config[flag.replace("--","")] = value.split(",") continue elif flag in ("-r", "--rootdir"): pass elif flag in ("-d","--dryrun"): opt_config[flag.replace("--","")] = True continue elif flag in ("-u", "--usage"): usage() exit() else: assert GetoptError(flag + " unhandled option") opt_config[flag.replace("--","")] = value except GetoptError as err: print err usage() sys.exit(2) return opt_config
def cmd_toc(self, argv): ''' Usage: {cmd} [disc_id] Print a table of contents for the current disc. ''' disc_id = None if argv: disc_id = argv.pop(0) if argv: raise GetoptError("extra arguments: %r" % (argv,)) options = self.options MB = options.mbdb if disc_id is None: try: dev_info = discid.read(device=options.device) except discid.disc.DiscError as e: error("disc error: %s", e) return 1 disc_id = dev_info.id with Pfx("discid %s", disc_id): disc = MB.discs[disc_id] print(disc.title) print(", ".join(disc.artist_names)) for tracknum, recording in enumerate(disc.recordings(), 1): print( tracknum, recording.title, '--', ", ".join(recording.artist_names) ) return 0
def cmd_stats(argv): ''' Usage: {cmd} host:port print [columns...] Fetch the statistics from the haproxy at host:port. ''' badopts = False if not argv: warning("missing host:port") badopts = True else: host_port = argv.pop(0) with Pfx("host:port %r", host_port): try: host, port = host_port.rsplit(':', 1) port = int(port) except ValueError as e: warning("invalid: %s", e) badopts = True cols = argv if badopts: raise GetoptError("invalid arguments") S = Stats(host, port) for row in S.csvdata(): if cols: print(*[getattr(row, col) for col in cols]) else: print(*row)
def rm(tokens): global Remotedir cmd = 'delete' if len(tokens) != 2: raise GetoptError('') args = {'path': Remotedir + tokens[1]} return Task(no_return, cmd, args)
def cmd_rip(self, argv): ''' Usage: {cmd} [-n] [disc_id] Pull the audio into a subdirectory of the current directory. -n No action; recite planned actions. ''' options = self.options fstags = options.fstags dirpath = options.dirpath no_action = False disc_id = None if argv and argv[0] == '-n': no_action = True argv.pop(0) if argv: disc_id = argv.pop(0) if argv: raise GetoptError("extra arguments: %r" % (argv,)) try: rip( options.device, options.mbdb, output_dirpath=dirpath, disc_id=disc_id, fstags=fstags, no_action=no_action, ) except discid.disc.DiscError as e: error("disc error: %s", e) return 1 return 0
def getplugin(style): if style == 'oracle': from chameleon.oracle import Model as Oracle return Oracle() if style == 'postgres': from chameleon.postgres import Model as Postgres return Postgres() raise GetoptError('output style "%s" not supported' % style)
def cmd_tag(self, argv): xit = 0 if not argv: raise GetoptError('missing book-title') book_title = argv.pop(0) with Pfx(book_title): for B in self.books_by_title(book_title): for tag_op in argv: if tag_op.startswith('+'): tag_name = tag_op[1:] B.add_tag(tag_name) elif tag_op.startswith('-'): tag_name = tag_op[1:] B.remove_tag(tag_name) else: raise GetoptError('unsupported tag op %r' % (tag_op, )) return xit
def get_opts(): opts = {'max-len': 8} options, args = getopt(sys.argv[1:], 't:ed') for key, value in options: opts[key.replace('-', '')] = value if 'e' in opts.keys() and 't' not in opts.keys(): raise GetoptError('Error!! Please add -t in the righ of -e!') return opts, args
def cmd_suspend(self, argv): ''' Usage: {cmd} vmname [VBoxManage controlvm options...] Suspend the specified VM using "controlvm .. savestate". ''' if not argv: raise GetoptError("missing vmname") vmspec = argv.pop(0) return self.vbmg(['controlvm', vmspec, 'savestate'], argv)
def cmd_resume(self, argv): ''' Usage: {cmd} vmname [VBoxManage controlvm options...] Resume the specified VM using "controlvm .. resume". ''' if not argv: raise GetoptError("missing vmname") vmspec = argv.pop(0) return self.vbmg(['controlvm', vmspec, 'resume'], argv)
def cmd_start(self, argv): ''' Usage: {cmd} vmname [VBoxManage startvm options...] Start the specified VM using "startvm". ''' if not argv: raise GetoptError("missing vmname") vmspec = argv.pop(0) return self.vbmg(['startvm', vmspec], argv)
def readArgs(): try: opts, args = getopt(argv[1:], 'p:', ['process=']) if len(opts) != 1: raise GetoptError("Entered a different number of options than 1") except GetoptError as error: print(error) exit(0) return opts[0][1]
def cmd_account(self, argv): ''' Usage: {cmd} Report account state. ''' if argv: raise GetoptError("extra arguments: %r" % (argv, )) api = self.options.api for k, v in sorted(api.account().items()): print(k, pformat(v))
def cmd_gui(self, argv): ''' Usage: {cmd} pathnames... Run a GUI to tag pathnames. ''' if not argv: raise GetoptError("missing pathnames") from .gui_tk import TaggerGUI # pylint: disable=import-outside-toplevel with TaggerGUI(self.options.tagger, argv) as gui: gui.run()
def rename(tokens): global Remotedir cmd = 'rename' if len(tokens) != 3: raise GetoptError('') src = tokens[1] dst = tokens[2] args = {'path': Remotedir, 'src': src, 'dst': dst} return Task(no_return, cmd, args)
def parse_args(argv): mandatory_flags = ['--access_type', '--input_filename'] access_types = [ 'query', 'create', 'insert', 'table_exists', 'table_list', 'table_info', 'database_exists' ] try: opts, args = getopt(argv[1:], "aiorf", ["access_type=", "input_filename=","output_filename=",\ "runtime_path=","result_file="]) for flag in mandatory_flags: if flag not in dict(opts).keys(): raise GetoptError(flag, "needs to be present") man_config = {} # mandatory flaags, hold the resulting, parsed flags opt_config = {} # optional flags for flag, value in opts: if flag in ("-a", "--access_type"): if value not in access_types: raise GetoptError(flag + " value not in " + str(access_types)) elif flag in ("-i", "--input_filename") or flag in ("-r", "--runtime_path"): if os_file_exists(value) == False: raise GetoptError(flag + "cannot find file" + value) elif flag in ("-f", "--result_file"): pass else: assert GetoptError(flag + " unhandled option") if flag in mandatory_flags: man_config[flag.replace("--", "")] = value else: opt_config[flag.replace("--", "")] = value except GetoptError as err: print err usage() sys.exit(2) return man_config, opt_config
def cmd_convert(self, args): ''' Convert a recording to MP4. Usage: {cmd} [start..end]... recording [output.mp4] Convert the video content of the named recording to the named output file (typically MP4, though the ffmpeg output format chosen is based on the extension). Most metadata are preserved. start..end: Optional start and end offsets in seconds, used to crop the recording output. ''' badopts = False # parse optional start..end arguments timespans = [] while args: range_arg = args[0] with Pfx("timespan %r", range_arg): try: start, end = range_arg.split('..') start_s = float(start) end_s = float(end) except ValueError: break else: args.pop(0) if start_s > end_s: warning("start:%s > end:%s", start, end) badopts = True timespans.append((start_s, end_s)) if not args: raise GetoptError("missing recording") srcpath = args.pop(0) # collect optional dstpath if args: dstpath = args.pop(0) else: dstpath = None if args: warning("extra arguments: %s", ' '.join(args)) badopts = True if badopts: raise GetoptError("bad invocation") R = Recording(srcpath) return 0 if R.convert(dstpath, max_n=TRY_N, timespans=timespans) else 1