def execute(argv=None, settings=None): """The entry point of command line""" if argv is None: argv = sys.argv if settings is None: settings = 'nothing' cmds = _get_commands_dict(settings) cmdname = _pop_command_name(argv) parser = optparse.OptionParser(formatter=optparse.TitledHelpFormatter(), conflict_handler='resolve') if not cmdname: _print_commands(settings) sys.exit(0) elif cmdname not in cmds: _print_unknown_command(settings, cmdname) sys.exit(2) cmd = cmds[cmdname] parser.usage = "robotx %s %s" % (cmdname, cmd.syntax()) parser.description = cmd.long_desc() cmd.add_options(parser) opts, args = parser.parse_args(args=argv[1:]) _run_print_help(parser, cmd.process_options, args, opts) _run_print_help(parser, _run_command, cmd, args, opts) sys.exit(cmd.exitcode)
def execute(argv=None): if argv is None: argv = sys.argv crawler = CrawlerProcess(settings) crawler.install() inproject = inside_project() _check_deprecated_scrapy_ctl(argv, inproject) # TODO: remove for Scrapy 0.11 cmds = _get_commands_dict(inproject) cmdname = _pop_command_name(argv) parser = optparse.OptionParser(formatter=optparse.TitledHelpFormatter(), \ conflict_handler='resolve') if not cmdname: _print_commands(inproject) sys.exit(0) elif cmdname not in cmds: _print_unknown_command(cmdname, inproject) sys.exit(2) cmd = cmds[cmdname] parser.usage = "scrapy %s %s" % (cmdname, cmd.syntax()) parser.description = cmd.long_desc() settings.defaults.update(cmd.default_settings) cmd.settings = settings cmd.add_options(parser) opts, args = parser.parse_args(args=argv[1:]) _run_print_help(parser, cmd.process_options, args, opts) cmd.set_crawler(crawler) _run_print_help(parser, _run_command, cmd, args, opts) sys.exit(cmd.exitcode)
def process_command_line(argv): """ Return a 2-tuple: (settings object, args list). `argv` is a list of arguments, or `None` for ``sys.argv[1:]``. """ if argv is None: argv = sys.argv[1:] # initialize the parser object: parser = optparse.OptionParser( formatter=optparse.TitledHelpFormatter(width=100), add_help_option=None) parser.add_option("-t", "--threshold", help="threshold of minimal reads count allowed") parser.add_option( # customized description; put --help last "-h", "--help", action="help", help="Show this help message and exit.") settings, args = parser.parse_args(argv) # check number of arguments, verify values, etc.: if args: parser.error('program takes no command-line arguments; ' '"%s" ignored.' % (args,)) # further process settings & args if necessary return settings, args
def process_command_line(argv): """ Return a 2-tuple: (settings object, args list). `argv` is a list of arguments, or `None` for ``sys.argv[1:]``. """ if argv is None: argv = sys.argv[1:] # initialize the parser object: parser = optparse.OptionParser( formatter=optparse.TitledHelpFormatter(width=78), add_help_option=None) # define options here: parser.add_option( # customized description; put --help last '-h', '--help', action='help', help='Show this help message and exit.') parser.add_option('-u', '--url', action='store', dest='link', help='Open a link.') parser.add_option('-v', '--version', action='store_true', help='Show version.') parser.add_option('-q', '--quit', action='store_false', help='Quit') settings, args = parser.parse_args(argv) # check number of arguments, verify values, etc.: if args: parser.error('program takes no command-line arguments; ' '"%s" ignored.' % (args, )) # further process settings & args if necessary return settings, args
def parse(): parser = optparse.OptionParser( formatter=optparse.TitledHelpFormatter()) parser.add_option('-v', '--verbose', action='store_true', default=DEFAULT_VERBOSE, help='verbose output') parser.add_option('--host', action='store', type='string', default=DEFAULT_HOST, help='Host, default LocalHost') parser.add_option('-p', '--port', action='store', type='int', default=DEFAULT_PORT, help='Listening port, default 1234') (options, args) = parser.parse_args() if len(args) > 0: parser.error('bad args, use --help for help') if options.port is not None: port = options.port if options.host is not None: host = options.host return host, port, options.verbose
def get_options(): p = optparse.OptionParser( description="Description: Check mapped JSON files for correct fields", formatter=optparse.TitledHelpFormatter(), prog='check_json.py', version="%prog 0.1") p.add_option('--dir', '-d', help='\nInput directory which contains the JSON files.', default=None, metavar='PATH') p.add_option('--outputdir', '-o', help='\nOutput directory for the results.', default='failed', metavar='PATH') p.add_option('--checklist', '-c', help='\nFile with orders for checking and validating', default='scripts/checklist', metavar='FILE') p.add_option('--show', '-s', help='\nShow failed files in terminal.', default=False, metavar='BOOLEAN') p.add_option('--show_limit', help='\nThe limit of showed failed files in terminal.', default=20, type='int', metavar='INTEGER') return p.parse_args()
def process_command_line(argv): """ Return a 2-tuple: (settings object, args list). Arguments: argv - list of arguments, or 'None' for "sys.argv[1:]". """ if argv is None: argv = sys.argv[1:] # Initialize the parser object: parser = optparse.OptionParser( formatter=optparse.TitledHelpFormatter(width=78), add_help_option=None) # define options here: parser.add_option( # customized description; put --help last '-h', '--help', action='help', help='Show this help message and exit.') settings, args = parser.parse_args(argv) # Check number of arguments, verify values, etc. if args: parser.error('program takes no command-line arguments: ' '"%s" ignored.' % (args, )) # Further process settings & args if necessary return settings, args
def main(): import optparse import sys usage = """%prog [options] <url> [url]...""" \ """ Examples: %prog https://10.11.41.73/1MB https://10.11.41.69/1MB -v %prog https://10.11.41.73/1MB https://10.11.41.69/1MB -s -p 2:300:-2:300""" formatter = optparse.TitledHelpFormatter(indent_increment=2, max_help_position=60) p = optparse.OptionParser(usage=usage, formatter=formatter, version="HTTP/S Traffic Generator %s" % __version__ ) p.add_option("-v", "--verbose", action="store_true", help="Debug logging") p.add_option("-s", "--stats", action="store_true", default=False, help="Show statistics when done (default: no)") p.add_option("-k", "--keepalive", action="store_true", help="Reuse HTTP/1.1 connections for subsequent requests") p.add_option("-c", "--concurrency", metavar="INTEGER", default=1, type="int", help="Number of parallel threads (default: 10)") p.add_option("-n", "--requests", metavar="INTEGER", default=-1, type="int", help="Total number of requests (default: -1/infinite)") p.add_option("-r", "--rate", metavar="INTEGER", default=1*1024*1024, type="int", help="Maximum bandwidth in bytes per sec (default: 1 Mbps)") p.add_option("-d", "--dns", metavar="ADDRESS", default=None, type="string", help="DNS server to use (required for GTM testing)") p.add_option("-p", "--pattern", metavar="STRING", default="0:10", type="string", help="[Threads delta:Sleep]... (default: 1:300:-1:300)") p.add_option("-t", "--timeout", metavar="SECONDS", type="int", default=10, help="Timeout (default: 10)") options, args = p.parse_args() if options.verbose: level = logging.DEBUG else: level = logging.INFO logging.getLogger('f5test').setLevel(logging.INFO) logging.getLogger('f5test.macros').setLevel(logging.INFO) LOG.setLevel(level) logging.basicConfig(level=level) if not args: p.print_version() p.print_help() sys.exit(2) cs = TrafficGen(options=options, urls=args) cs.run()
def process_command_line(argv): """ Return a 2-tuple: (settings object, args list). `argv` is a list of arguments, or `None` for ``sys.argv[1:]``. """ if argv is None: argv = sys.argv[1:] # initialize the parser object: parser = optparse.OptionParser( formatter=optparse.TitledHelpFormatter(width=78), add_help_option=None) # define options here: parser.add_option('-n', type='int', dest='highnum', action='store', help='Number of high samples (the rest are 0)') parser.add_option( # customized description; put --help last '-h', '--help', action='help', help='Show this help message and exit.') (options, args) = parser.parse_args(argv) # check number of arguments, verify values, etc.: if args: parser.error('program takes no command-line arguments; ' '"%s" ignored.' % (args, )) # further process settings & args if necessary return (options, args)
def process_command_line(argv): """ Return a 2-tuple: (settings object, args list). `argv` is a list of arguments, or `None` for ``sys.argv[1:]``. """ if argv is None: argv = sys.argv[1:] # initialize the parser object: parser = optparse.OptionParser( formatter=optparse.TitledHelpFormatter(width=78), add_help_option=None) parser.add_option( '-r', '--reads_file', help= 'The reads_fusion.txt file - the output of detect_fusion_point.py script' ) parser.add_option( # customized description; put --help last '-h', '--help', action='help', help='Show this help message and exit.') settings, args = parser.parse_args(argv) # check number of arguments, verify values, etc.: if args: parser.error('program takes no command-line arguments; ' '"%s" ignored.' % (args, )) # further process settings & args if necessary return settings, args
def process_command_line(argv): """ Return a 2-tuple: (settings object, args list). `argv` is a list of arguments, or `None` for ``sys.argv[1:]``. """ if argv is None: argv = sys.argv[1:] # initialize the parser object: parser = optparse.OptionParser( formatter=optparse.TitledHelpFormatter(width=78), add_help_option=None) # define options here: parser.add_option( # customized description; put --help last '-h', '--help', action='help', help='Show this help message and exit.') settings, args = parser.parse_args(argv) # check number of arguments, verify values, etc.: #if args: # parser.error('program takes no command-line arguments; ' # '"%s" ignored.' % (args,)) # further process settings & args if necessary # For future versions, use args to specify what cleaning/prettifying ops to perform on the input files return settings, args
def main(): import optparse import sys usage = """%prog [options] <emaddress>""" formatter = optparse.TitledHelpFormatter(indent_increment=2, max_help_position=60) p = optparse.OptionParser(usage=usage, formatter=formatter, version="Big3d Updater v%s" % __version__ ) p.add_option("-v", "--verbose", action="store_true", help="Debug messages") p.add_option("-u", "--admin-username", metavar="USERNAME", default=ADMIN_USERNAME, type="string", help="An user with admin rights (default: %s)" % ADMIN_USERNAME) p.add_option("-p", "--admin-password", metavar="PASSWORD", default=ADMIN_PASSWORD, type="string", help="An user with admin rights (default: %s)" % ADMIN_PASSWORD) p.add_option("-r", "--root-username", metavar="USERNAME", default=ROOT_USERNAME, type="string", help="An user with admin rights (default: %s)" % ROOT_USERNAME) p.add_option("-a", "--root-password", metavar="PASSWORD", default=ROOT_PASSWORD, type="string", help="An user with admin rights (default: %s)" % ROOT_PASSWORD) p.add_option("-d", "--devices", metavar="DEVICE", type="string", action="append", help="Include only this device(s). Multiple occurrences allowed.") p.add_option("-n", "--task-name", metavar="STRING", default='Big3d install task', type="string", help="The task name.") p.add_option("-t", "--timeout", metavar="TIMEOUT", type="int", default=60, help="Timeout. (default: 60)") options, args = p.parse_args() if options.verbose: level = logging.DEBUG else: level = logging.INFO logging.getLogger('paramiko.transport').setLevel(logging.ERROR) logging.getLogger('f5test').setLevel(logging.INFO) logging.getLogger('f5test.macros').setLevel(logging.INFO) LOG.setLevel(level) logging.basicConfig(level=level) if not args: p.print_version() p.print_help() sys.exit(2) cs = Big3dUtil(options=options, address=args[0]) cs.run()
def process_command_line(argv): if argv is None: argv = sys.argv[1:] usage = "usage: %prog [options] f_pool sam1 [sam2 ..]" parser = optparse.OptionParser( usage, formatter=optparse.TitledHelpFormatter(width=178), add_help_option=None) parser.add_option('-o', '--outfile', dest='outfile', help='outfile name[default None, to stdout]', metavar="FILE") parser.add_option('-h', '--help', action='help', help='Show this help message and exit.') (options, args) = parser.parse_args(argv) if len(args) < 2: parser.error('No required parameters') return options, args
def __init__(self, components=(), defaults=None, read_config_files=None, *args, **kwargs): """ `components` is a list of Docutils components each containing a ``.settings_spec`` attribute. `defaults` is a mapping of setting default overrides. """ self.lists = {} """Set of list-type settings.""" self.config_files = [] """List of paths of applied configuration files.""" optparse.OptionParser.__init__( self, option_class=Option, add_help_option=None, formatter=optparse.TitledHelpFormatter(width=78), *args, **kwargs) if not self.version: self.version = self.version_template # Make an instance copy (it will be modified): self.relative_path_settings = list(self.relative_path_settings) self.components = (self,) + tuple(components) self.populate_from_components(self.components) self.set_defaults_from_dict(defaults or {}) if read_config_files and not self.defaults['_disable_config']: try: config_settings = self.get_standard_config_settings() except ValueError as error: self.error(SafeString(error)) self.set_defaults_from_dict(config_settings.__dict__)
def main(): import optparse import sys usage = """%prog [options] <address>""" formatter = optparse.TitledHelpFormatter(indent_increment=2, max_help_position=60) p = optparse.OptionParser(usage=usage, formatter=formatter, version="SSH Key Exchange Tool v%s" % __version__) p.add_option("-v", "--verbose", action="store_true", help="Debug messages") p.add_option("-u", "--username", metavar="USERNAME", default=ROOT_USERNAME, type="string", help="An user with root rights (default: %s)" % ROOT_USERNAME) p.add_option("-p", "--password", metavar="PASSWORD", default=ROOT_PASSWORD, type="string", help="An user with root rights (default: %s)" % ROOT_PASSWORD) p.add_option("", "--port", metavar="INTEGER", type="int", default=22, help="SSH Port (default: 22)") p.add_option("-t", "--timeout", metavar="TIMEOUT", type="int", default=60, help="Timeout. (default: 60)") options, args = p.parse_args() if options.verbose: level = logging.DEBUG else: level = logging.INFO logging.getLogger('paramiko.transport').setLevel(logging.ERROR) logging.getLogger('f5test').setLevel(logging.ERROR) logging.getLogger('f5test.macros').setLevel(logging.INFO) LOG.setLevel(level) logging.basicConfig(level=level) if not args: p.print_version() p.print_help() sys.exit(2) cs = KeySwap(options=options, address=args[0]) cs.run()
def execute(url, project, spider, callback, **kwargs): argv = sys.argv print(argv) argv.append(url) if spider: argv.append('--spider') argv.append(spider) if callback: argv.append('--callback') argv.append(callback) print(argv) work_cwd = os.getcwd() print(work_cwd) try: os.chdir(project) settings = get_project_settings() check_deprecated_settings(settings) cmd = Parser() parser = optparse.OptionParser(formatter=optparse.TitledHelpFormatter(), conflict_handler='resolve') settings.setdict(cmd.default_settings, priority='command') cmd.settings = settings cmd.add_options(parser) opts, args = parser.parse_args(args=argv[1:]) print('opt, args', opts, args) cmd.process_options(args, opts) cmd.crawler_process = CrawlerProcess(settings) cmd.run(args, opts) finally: os.chdir(work_cwd)
def main(): ''' Parse argv for options and arguments, and start schema generation. ''' parser = optparse.OptionParser( usage="%prog [options] <model_path> [another_model_path...]", version=xtuml.version.complete_string, formatter=optparse.TitledHelpFormatter()) parser.set_description(__doc__.strip()) parser.add_option("-c", "--component", dest="component", metavar="NAME", help="export sql schema for the component named NAME", action="store", default=None) parser.add_option("-d", "--derived-attributes", dest="derived", help="include derived attributes in the schema", action="store_true", default=False) parser.add_option("-o", "--output", dest='output', metavar="PATH", help="save sql schema to PATH (required)", action="store", default=None) parser.add_option("-v", "--verbosity", dest='verbosity', action="count", help="increase debug logging level", default=2) (opts, args) = parser.parse_args() if len(args) == 0 or opts.output is None: parser.print_help() sys.exit(1) levels = { 0: logging.ERROR, 1: logging.WARNING, 2: logging.INFO, 3: logging.DEBUG, } logging.basicConfig(level=levels.get(opts.verbosity, logging.DEBUG)) loader = ooaofooa.Loader() for filename in args: loader.filename_input(filename) c = loader.build_component(opts.component, opts.derived) xtuml.persist_database(c, opts.output)
def run(argv): commands = import_command("commands") dict_command = get_command_dict(commands) parser = optparse.OptionParser(prog="Command", formatter=optparse.TitledHelpFormatter(), \ conflict_handler='resolve') """ for k, v in dict_command.items(): print("%s : %s" %(k,v)) """ print(argv) cmdname = _resovle_argv(argv) print(argv) if cmdname in dict_command: print() cmd = dict_command[cmdname] else: _print_commands(commands) parser.description = cmd.long_desc() cmd.add_options(parser) opts, argv = parser.parse_args(argv[1:]) print(opts) print(argv) cmd.process_option(argv, opts) try: cmd.process_option(argv, opts) except Exception as e: if str(e): parser.error(str(e)) parser.print_help()
def _readOptions(self): usage = "%prog [options] [-k FILE] [-r FILE] -i FILE [-o FILE]" # Build option parser. parser = optparse.OptionParser(usage=usage, formatter=optparse.TitledHelpFormatter()) parser.add_option("-V", "--version", action="store_true", dest="showVersion", default=False, help="Show version information.") parser.add_option("-i", "--input", action="store", type="string", dest="inputFilePath", default=None, metavar="PATH", help="Specify the input OTP bit settings file.") parser.add_option("-o", "--output", action="store", type="string", dest="outputFilePath", default=None, metavar="PATH", help="Write output to this file. Optional; if not provided then the output file name is generated from the input file name.") parser.add_option("-k", "--key", action="store", type="string", dest="keyFilePath", default=None, metavar="PATH", help="Specify the input crypto key file.") parser.add_option("-n", "--key-number", action="store", type="int", dest="keyIndex", default=0, metavar="NUM", help="Use key number N from the crypto key file (default 0).") parser.add_option("-r", "--srk", action="store", type="string", dest="superRootKeyPath", default=None, metavar="PATH", help="Specify the binary super root key hash file.") parser.add_option("-p", "--print-otp", action="store_true", dest="printResult", default=False, help="Print the resulting OTP registers.") parser.add_option("-e", "--elftosb", action="store_true", dest="runElftosb", default=True, help="Run elftosb to generate the .sb file (the default).") parser.add_option("-E", "--no-elftosb", action="store_false", dest="runElftosb", default=True, help="Do not run elftosb.") parser.add_option("-a", "--hab", action="store_true", dest="useHab", default=True, help="generate a HAB compatible .sb (MX28 only; default)") parser.add_option("-A", "--no-hab", action="store_false", dest="useHab", default=True, help="generate a non-HAB .sb (MX28 only)") #Retrieve agruments(list) and options(dictionary) return parser.parse_args()
def execute(argv=None, settings=None): if argv is None: argv = sys.argv if settings is None: settings = Settings() inproject = inside_project() if inproject: if not get_project_settings(settings): sys.exit(2) cmds = _get_commands_dict(settings, inproject) cmdname = _pop_command_name(argv) parser = optparse.OptionParser(formatter=optparse.TitledHelpFormatter(), conflict_handler='resolve') if not cmdname: _print_commands(settings, inproject) sys.exit(0) elif cmdname not in cmds: _print_unknown_command(settings, cmdname, inproject) sys.exit(2) cmd = cmds[cmdname] parser.usage = "devspace %s %s" % (cmdname, cmd.syntax()) parser.description = cmd.long_desc() cmd.settings = settings cmd.add_options(parser) opts, args = parser.parse_args(args=argv[1:]) _run_print_help(parser, cmd.process_options, args, opts) _run_print_help(parser, _run_command, cmd, args, opts) sys.exit(cmd.exitcode)
def do_command_line(): parser = optparse.OptionParser(formatter=optparse.TitledHelpFormatter(), \ usage=globals()['__doc__']) parser.add_option ('-l', '--lat', action='store', dest="latitude", \ type=float, help='Latitude in decimal degrees' ) parser.add_option ('-g', '--lon', action='store', dest="longitude", \ type=float, help='Longitude in decimal degrees' ) parser.add_option('-o', '--output', action="store", dest="output_file", \ default="grabba", type=str, help="Output file and directory" ) parser.add_option('-b', '--begin', action="store", dest="year_start", \ default=2003, type=int, help="Start year" ) parser.add_option('-e', '--end', action="store", dest="year_end", \ type=int, default=2014, help="End year" ) parser.add_option('-p', '--pool', action="store", dest="pool_size", \ type=int, default=10, help="Number of simultaneous threads to use" ) parser.add_option('-P', '--password', action="store", dest="password", \ type=str, help="EarthData Login password" ) parser.add_option('-U', '--user', action="store", dest="user", \ type=str, help="EarthData Login username" ) (options, args) = parser.parse_args() if 'user' not in options.__dict__: parser.error("You need to provide a username! Sgrunt!") if 'password' not in options.__dict__: parser.error("You need to provide a password! Sgrunt!") return options.user, options.password, options.latitude, \ options.longitude, options.output_file, \ options.year_start, options.year_end, options.pool_size
def __init__(self, components=(), defaults=None, read_config_files=None, *args, **kwargs): """ `components` is a list of Docutils components each containing a ``.settings_spec`` attribute. `defaults` is a mapping of setting default overrides. """ optparse.OptionParser.__init__( self, add_help_option=None, formatter=optparse.TitledHelpFormatter(width=78), *args, **kwargs) if not self.version: self.version = self.version_template # Make an instance copy (it will be modified): self.relative_path_settings = list(self.relative_path_settings) self.populate_from_components((self, ) + tuple(components)) defaults = defaults or {} if read_config_files and not self.defaults['_disable_config']: config = ConfigParser() config.read_standard_files(self) config_settings = config.get_section('options') make_paths_absolute(config_settings, self.relative_path_settings) defaults.update(config_settings) # Internal settings with no defaults from settings specifications; # initialize manually: self.set_defaults(_source=None, _destination=None, **defaults)
def process_command_line(argv): """ Return a 2-tuple: (settings object, args list). `argv` is a list of arguments, or `None` for ``sys.argv[1:]``. """ if argv is None: argv = sys.argv[1:] # initialize the parser object: parser = optparse.OptionParser( formatter=optparse.TitledHelpFormatter(width=78), add_help_option=None) parser.add_option('-g', '--gtf', help='GTF file containing the features.') parser.add_option('-s', '--samfile', help='Input sam or bam file.') parser.add_option( '-r', '--reverse', action='store_true', default=False, help='Count the genes on the reverse strand of the mapping.') parser.add_option( '-f', '--feature', default='exon', help='Name of features to count on the GTF file (column 2).') parser.add_option( '-i', '--identifier', default='gene_id', help='Name of identifier to print (in column 8 of the GTF file).') parser.add_option( '-o', '--overlap', type='int', default=5, help='Minimal required overlap between the fragment and the feature.') parser.add_option( '-t', '--strict', default=False, action='store_true', help="Assign the read to a feature only if it covers only one feature." ) parser.add_option( # customized description; put --help last '-h', '--help', action='help', help='Show this help message and exit.') settings, args = parser.parse_args(argv) # check number of arguments, verify values, etc.: if args: parser.error('program takes no command-line arguments; ' '"%s" ignored.' % (args, )) # further process settings & args if necessary return settings, args
def main(): import optparse import sys usage = """%prog [options] <address> [regex]...""" \ u""" Extract TMOS configuration recursively from existing systems. Examples: %prog 10.1.2.3 ltm virtual cgnat_http %prog 10.1.2.3 'ltm virtual cgnat_http|net vlan *' """ formatter = optparse.TitledHelpFormatter(indent_increment=2, max_help_position=60) p = optparse.OptionParser(usage=usage, formatter=formatter, version="TMOS config extractor %s" % __version__) p.add_option("-v", "--verbose", action="store_true", help="Debug logging") p.add_option("-c", "--cache", action="store_true", help="Don't remove SCF file ({}) after parsing".format(SCF_OUTPUT)) p.add_option("-s", "--sort", action="store_true", help="Sort objects alphabetically") p.add_option("-u", "--username", metavar="USERNAME", default=ROOT_USERNAME, type="string", help="Root username (default: %s)" % ROOT_USERNAME) p.add_option("-p", "--password", metavar="PASSWORD", default=ROOT_PASSWORD, type="string", help="Root password (default: %s)" % ROOT_PASSWORD) p.add_option("", "--ucs", metavar="FILE", type="string", help="UCS File to look at (Optional)") p.add_option("-t", "--timeout", metavar="SECONDS", type="int", default=60, help="Timeout (default: 60)") options, args = p.parse_args() if options.verbose: level = logging.DEBUG else: level = logging.INFO logging.getLogger('paramiko.transport').setLevel(logging.ERROR) logging.getLogger('f5test').setLevel(logging.INFO) logging.getLogger('f5test.macros').setLevel(logging.INFO) LOG.setLevel(level) logging.basicConfig(level=level) if len(args) < 2: p.print_version() p.print_help() sys.exit(2) cs = Extractor(options=options, address=args[0], params=args[1:]) print cs.run()
def setUp(self): self.command = ScrapyCommand() self.command.settings = Settings() self.parser = optparse.OptionParser( formatter=optparse.TitledHelpFormatter(), conflict_handler='resolve', ) self.command.add_options(self.parser)
def process_command_line(argv): """ Return a 2-tuple: (settings object, args list). `argv` is a list of arguments, or `None` for ``sys.argv[1:]``. """ global LOG global COMMIT_MODE if argv is None: argv = sys.argv[1:] # initialize the parser object: parser = optparse.OptionParser( formatter=optparse.TitledHelpFormatter(width=78), add_help_option=None) # define options here: parser.add_option("-v", "--verbose", dest="verbose", default=False, action='store_true', help="write debug level logs to log") parser.add_option("-L", "--log", dest="logfile", help="write log output to logfile") parser.add_option( "-C", "--commit", dest="commit", default=False, action='store_true', help= "if true, will Commit the data change; if false this script will just log what would have happened if set to true." ) parser.add_option( # customized description; put --help last '-h', '--help', action='help', help='Show this help message and exit.') options, args = parser.parse_args(argv) # set up logging log_file = None log_level = logging.INFO if options.verbose: log_level = logging.DEBUG if options.logfile: log_file = options.logfile LOG = set_logging(log_file, log_level) # Check for required arguments # Set commit_mode COMMIT_MODE = options.commit return options, args
def process_command_line(argv): """ Return an args list `argv` is a list of arguments, or `None` for ``sys.argv[1:]``. """ if argv is None: argv = sys.argv[1:] # initialize the parser object: parser = optparse.OptionParser( formatter=optparse.TitledHelpFormatter(width=78), add_help_option=None) # define options here: parser.add_option( '-w', '--workdir', help='Workdir where temporary and final files will be saved.') parser.add_option( '-a', '--assembly_file', help= 'File with a list of assemblies for which a reference genome is to be determined.' ) parser.add_option('--installation', help='Pipeline installation.') parser.add_option('--EDIRECT', help='edirect tools installation.') parser.add_option('--QUAST', help='Quast installation.') parser.add_option('--mail', help='Email for edirect.') parser.add_option('-o', '--organism', help='Organism to be searched for on NCBI Assembly.') parser.add_option('--dont_delete', action="store_true", help='Do not delete temporary files after running.') parser.add_option( '-s', '--script', default= "/home/users/yair/Documents/PhD_projects/project_B/bin/downloading_database/determine_best_genome.sh", help='Path of determine_best_genome.sh script') parser.add_option( # customized description; put --help last '-h', '--help', action='help', help='Show this help message and exit.') settings, args = parser.parse_args(argv) return settings, args
def execute(argv=None, settings=None): if argv is None: argv = sys.argv # --- backwards compatibility for scrapy.conf.settings singleton --- if settings is None and 'scrapy.conf' in sys.modules: from scrapy import conf if hasattr(conf, 'settings'): settings = conf.settings # ------------------------------------------------------------------ if settings is None: settings = get_project_settings() # set EDITOR from environment if available try: editor = os.environ['EDITOR'] except KeyError: pass else: settings['EDITOR'] = editor check_deprecated_settings(settings) # --- backwards compatibility for scrapy.conf.settings singleton --- import warnings from scrapy.exceptions import ScrapyDeprecationWarning with warnings.catch_warnings(): warnings.simplefilter("ignore", ScrapyDeprecationWarning) from scrapy import conf conf.settings = settings # ------------------------------------------------------------------ inproject = inside_project() cmds = _get_commands_dict(settings, inproject) cmdname = _pop_command_name(argv) parser = optparse.OptionParser(formatter=optparse.TitledHelpFormatter(), \ conflict_handler='resolve') if not cmdname: _print_commands(settings, inproject) sys.exit(0) elif cmdname not in cmds: _print_unknown_command(settings, cmdname, inproject) sys.exit(2) #cmds中有scrapy.commands目录下所有命令 cmd = cmds[cmdname] parser.usage = "scrapy %s %s" % (cmdname, cmd.syntax()) parser.description = cmd.long_desc() settings.setdict(cmd.default_settings, priority='command') cmd.settings = settings cmd.add_options(parser) opts, args = parser.parse_args(args=argv[1:]) _run_print_help(parser, cmd.process_options, args, opts) # 真正执行CrawlerProcess的入口在这里 cmd.crawler_process = CrawlerProcess(settings) #运行CrawlerProcess _run_print_help(parser, _run_command, cmd, args, opts) sys.exit(cmd.exitcode)
def main(args): parser = optparse.OptionParser( usage="%prog [options] <model_path> [another_model_path...]", version=xtuml.version.complete_string, formatter=optparse.TitledHelpFormatter()) parser.set_description(__doc__.strip()) parser.add_option("-c", "--component", dest="component", metavar="NAME", help="export xsd schema for the component named NAME", action="store", default=None) parser.add_option("-o", "--output", dest='output', metavar="PATH", action="store", help="save xsd schema to PATH (required)", default=None) parser.add_option("-v", "--verbosity", dest='verbosity', action="count", help="increase debug logging level", default=2) (opts, args) = parser.parse_args(args) if len(args) == 0 or None in [opts.component, opts.output]: parser.print_help() sys.exit(1) levels = { 0: logging.ERROR, 1: logging.WARNING, 2: logging.INFO, 3: logging.DEBUG, } logging.basicConfig(level=levels.get(opts.verbosity, logging.DEBUG)) m = ooaofooa.load_metamodel(args) c_c = m.select_any('C_C', lambda inst: inst.Name == opts.component) if c_c: schema = build_schema(m, c_c) with open(opts.output, 'w') as f: s = ET.tostring(schema, 'utf-8') s = prettify(s) f.write(s) else: logger.error('unable to find a component named %s' % opts.component) logger.info('available components to choose from are: %s' % ', '.join([c_c.Name for c_c in m.select_many('C_C')])) sys.exit(1)
def __init__(self, *args, **kwargs): kwargs.setdefault('formatter', optparse.TitledHelpFormatter()) self._optparse = optparse.OptionParser(*args, **kwargs) self._optparse.disable_interspersed_args() self._allopts = {} # current option group self._group = self._optparse