def main():
usage = 'usage: %prog [options] <host>'
parser = OptionParser(usage=usage)
parser.add_option('-d', action='store_true', dest='debug',
help='enable debug messages')
parser.add_option('-v', action='store_true', dest='verbose',
help='be more verbose')
parser.add_option('-V', action='store_true', dest='version',
help='show version')
parser.add_option('--always-check-esr', action='store_true',
dest='check_esr',
help='Check the error status register after every command')
(options, args) = parser.parse_args()
if options.version:
print 'vxi11-cli v%s' % (__version__,)
sys.exit(0)
logging.basicConfig()
if options.verbose:
logging.getLogger('vxi11').setLevel(logging.INFO)
if options.debug:
logging.getLogger('vxi11').setLevel(logging.DEBUG)
if len(args) < 1:
print parser.format_help()
sys.exit(1)
host = args[0]
v = Instrument(host)
v.open()
print "Enter command to send. Quit with 'q'."
try:
while True:
cmd = raw_input('=> ')
if cmd == 'q':
break
if cmd.startswith('%'):
process_local_command(cmd)
continue
if len(cmd) > 0:
is_query = cmd.split(' ')[0][-1] == '?'
try:
if is_query:
print v.ask(cmd)
else:
v.write(cmd)
if options.check_esr:
esr = int(v.ask('*ESR?').strip())
if esr != 0:
print 'Warning: ESR was %d' % esr
except Vxi11Exception, e:
print 'ERROR: %s' % e
except EOFError:
print 'exitting..'
v.close()
class CommandLine(object):
def run(self, argv):
self.parser = OptionParser(usage="%prog command [option]", version="%s" % (release.version))
self.parser.disable_interspersed_args()
self.parser.print_help = self._help
options, args = self.parser.parse_args(argv[1:])
if not args:
self.parser.error('incorrect number of arguments')
cmdname = args[0]
if cmdname not in COMMANDS:
self.parser.error('unknown command "%s"' % cmdname)
return COMMANDS[cmdname]().run(args[1:])
def _help(self):
print self.parser.format_help()
print "Commands:"
longest = max([len(command) for command in COMMANDS])
format = " %%-%ds %%s" % max(8, longest + 1)
commands = COMMANDS.items()
commands.sort()
for name, command in commands:
print format % (name, command.description)
def main():
"""tool main"""
parser = OptionParser(version="autopep8: %s" % __version__, description=__doc__)
parser.add_option("-v", "--verbose", action="store_true", dest="verbose", help="print to verbose result.")
parser.add_option("-d", "--diff", action="store_true", dest="diff", help="diff print of fixed source.")
parser.add_option("-p", "--pep8-passes", default=5, type="int", help="maximum number of additional pep8 passes")
opts, args = parser.parse_args()
if not len(args):
print parser.format_help()
return 1
filename = args[0]
original_filename = filename
tmp_source = open(filename).read()
fix = FixPEP8(filename, opts)
fixed_source = fix.fix()
original_source = copy.copy(fix.original_source)
for cnt in range(opts.pep8_passes):
if fixed_source == tmp_source:
break
tmp_source = copy.copy(fixed_source)
filename = tempfile.mkstemp()[1]
fp = open(filename, "w")
fp.write(fixed_source)
fp.close()
fix = FixPEP8(filename, opts)
fixed_source = fix.fix()
os.remove(filename)
if opts.diff:
new = StringIO("".join(fix.source))
new = new.readlines()
print _get_difftext(original_source, new, original_filename),
else:
print fixed_source,
def get_options():
parser = OptionParser(
description=
'Reduction script to produce metrics on an observation katfile.')
parser.add_option('-f', '--filename', help='Name of the hdf5 katfile')
parser.add_option(
'-d',
'--tempdir',
default='.',
help=
'Name of the temporary directory to use for creating output files [default: current directory]'
)
parser.add_option('-k',
'--keep',
action='store_true',
default=False,
help='Keep temporary files')
parser.add_option('--noarchive',
action='store_true',
default=False,
help='Access the file directly, do not use the archive')
opts, args = parser.parse_args()
if opts.filename is None:
print parser.format_help()
print
sys.exit(2)
return opts
def main():
parser = OptionParser()
parser.add_option("-n", "--numbers",
default=False, action="store_true",
help="change filenames to numbers, write csv")
parser.add_option("-r", "--restore",
default=False, action="store_true",
help="change filenames to text from csv")
parser.add_option("-c", "--csvfile", type="string",
default="filenames-numbers.csv",
metavar="FILENAME",
action="store",
help="change filenames to text from csv")
parser.add_option("-d", "--dirname", type="string",
default=".", metavar="DIRECTORY",
action="store",
help="directory to examine")
parser.add_option("-m", "--my_dirname", type="string",
default="numbers", metavar="DIRECTORY",
action="store",
help="directory to store numbered files")
(options, args) = parser.parse_args()
if options.numbers:
write_numbers(
options.dirname, options.csvfile, options.my_dirname)
elif options.restore:
write_names(
options.dirname, options.csvfile, options.my_dirname)
else:
print parser.format_help()
def parseArgs(self):
"""
Uses OptionParser to parse out input
Jelly.py <stage> <protocol>
"""
parser = OptionParser(USAGE)
parser.remove_option("-h")
parser.add_option("-h", "--help", action="store_true", default=False)
parser.add_option("--debug",action="store_true",default=False)
parser.add_option("-x", dest="extras", type="string", default="",
help="-x \"<options>\" are options to pass into the stage you're running")
self.options, args = parser.parse_args()
if self.options.help == True:
if len(args) == 1:
if args[0] in STAGES:
print exe(Stages.PRINT_HELPS[args[0]])[1]
sys.exit(0)
#Else, this will drop down to the next parser.error
else:
print parser.format_help()
sys.exit(0)
if len(args) != 2 or args[0] not in STAGES:
parser.error("Invalid Arguments. Expected one of\n'%s'" % "', '".join(STAGES))
sys.exit(1)
self.executeStage = args[0]
self.protocolName = os.path.abspath(args[1])
def main():
parser = OptionParser()
parser.add_option("-n", "--numbers",
default=False, action="store_true",
help="change filenames to numbers, write csv")
parser.add_option("-r", "--restore",
default=False, action="store_true",
help="change filenames to text from csv")
parser.add_option("-c", "--csvfile", type="string",
default="filenames-numbers.csv",
metavar="FILENAME",
action="store",
help="change filenames to text from csv")
parser.add_option("-d", "--dirname", type="string",
metavar="DIRECTORY",
action="store",
help="directory to examine")
parser.add_option("-m", "--my_dirname", type="string",
default="numbers", metavar="DIRECTORY",
action="store",
help="directory to store numbered files")
(options, args) = parser.parse_args()
if options.numbers:
write_numbers(
options.dirname, options.csvfile, options.my_dirname)
elif options.restore:
write_names(
options.dirname, options.csvfile, options.my_dirname)
else:
print parser.format_help()
def parseargs(argv):
parser = OptionParser(add_help_option=False)
parser.add_option("-r", "--report", dest="report", action="store_true",
default=False,
help="Report inconsistencies without making any change")
# Pygresql defaults to localhost, 5432, $USER for the following
# three options, respectively. We therefore do not need any
# defaults.
parser.add_option("-h", "--host", dest="host", action="store",
type="string", help="GPDB master hostname/IP address")
parser.add_option("-p", "--port", dest="port", action="store", type="int",
help="GPDB master port")
parser.add_option("-u", "--user", dest="user", action="store",
type="string",
help="Username to connect to GPDB. Must be superuser")
parser.add_option("-v", "--verbose", dest="verbose", action="store_true",
default=False,
help="Verbose logging/output, include table names.")
parser.add_option("--help", dest="help", action="store_true",
default=False, help="Show this help message and exit")
(options, args) = parser.parse_args(argv)
# If no args are specified, don't assume anything, print help and exit.
if options.help or len(argv) == 1:
print parser.format_help().strip()
sys.exit(0)
if options.user is not None:
options.passwd = getpass.getpass()
else:
options.passwd = None
return options
def get_options():
##### Configuration options #####
usage = """usage: %prog [options] ics_file [timezone]"""
parser = OptionParser(usage=usage, version=version)
parser.set_description(
"change_tz will convert the timezones in an ics file. ")
parser.add_option("-u",
"--only-utc",
dest="utc",
action="store_true",
default=False,
help="Only change UTC events.")
parser.add_option("-l",
"--list",
dest="list",
action="store_true",
default=False,
help="List available timezones")
(cmdline_options, args) = parser.parse_args()
if not args and not cmdline_options.list:
print "error: too few arguments given"
print
print parser.format_help()
return False, False
return cmdline_options, args
def parseArgs(self):
"""
Uses OptionParser to parse out input
Jelly.py <stage> <protocol>
"""
parser = OptionParser(USAGE)
parser.remove_option("-h")
parser.add_option("-h", "--help", action="store_true", default=False)
parser.add_option("--debug",action="store_true",default=False)
parser.add_option("-x", dest="extras", type="string", default="",
help="-x \"<options>\" are options to pass into the stage you're running")
self.options, args = parser.parse_args()
if self.options.help == True:
if len(args) == 1:
if args[0] in STAGES:
print exe(Stages.PRINT_HELPS[args[0]])[1]
sys.exit(0)
#Else, this will drop down to the next parser.error
else:
print parser.format_help()
sys.exit(0)
if len(args) != 2 or args[0] not in STAGES:
parser.error("Invalid Arguments. Expected one of\n'%s'" % "', '".join(STAGES))
sys.exit(1)
self.executeStage = args[0]
self.protocolName = os.path.abspath(args[1])
def main():
parser = OptionParser()
parser.add_option('-f', '--file', dest='file', help='Select File')
opts, args = parser.parse_args()
if not opts.file:
print parser.format_help()
exit(0)
binary_file = opts.file
hexString, binfile = GetHexStringFromFile(binary_file)
hexArray = SplitToHexArray(hexString)
print hexArray
SIZE = int(math.sqrt(len(hexArray))) + 2
img = Image.new( 'RGB', (SIZE, SIZE), "black") # create a new black image
pixels = img.load() # create the pixel map
i, j = 0,0
for hexVal in hexArray:
i+=1
if (i % img.size[0] == 0):
i = 0
j += 1
pixels[i,j] = getRGBTuple(hexVal)
img.show()
# Close the file:
binfile.close()
def parseArguments():
op = OptionParser('%prog [--token <token>] [--variable <variable>] Filename.csv [File2.csv [...]]\n\n' + '''
arguments:
Filename.csv The Hourly usage CSV datafile from PG&E (required)''', version="%s %s" % (programName, programVersion))
op.add_option('', '--token', metavar='<token>',
help='Google PowerMeter OAUTH Token'
' (default: None)')
op.add_option('', '--variable', metavar='<variable>',
help='Google PowerMeter Variable'
' (default: None)')
op.add_option('', '--service', metavar='<URI>',
help='URI prefix of the GData service to contact '
'(default: https://www.google.com/powermeter/feeds)')
op.add_option('-f','--configFile', metavar='<configFile>', help="Path and filename of configuration file (default: ~/.local/%s/config)" % programName)
op.add_option('-d','--debug', dest="isDebug", action="store_true", help="Disable upload to Google (default: false)", default=False)
op.set_defaults(service='https://www.google.com/powermeter/feeds',
unit='kW h', uncertainty=0.001, time_uncertainty=1)
# Parse and validate the command-line options.
options, args = op.parse_args()
# Check for config file, setup default otherwise
if options.configFile == None:
home = os.getenv('HOME')
config_home = os.getenv('XDG_CONFIG_HOME',"%s/.local/" % home)
config_dir = "%s%s" % (config_home,programName)
filepath = "%s/%s" % (config_dir, config_filename)
if os.path.exists(config_home):
if os.path.exists(config_dir):
if os.path.exists(filepath):
options.configFile = filepath
else:
if not os.path.exists(options.configFile):
if os.path.exists(os.getcwd() + options.configFile):
options.configFile = os.getcwd() + options.configFile
else:
sys.stderr.write("Error: Can not find config file '%s'\n" % options.configFile)
exit(2)
if options.token == None:
if checkConfigfile(options.configFile,'token'):
options.token = getConfigfile(options.configFile,'token')
else:
sys.stderr.write('Error: Missing Google Power Meter OAuth token. \nToken must be supplied via --token or in the config file.\n')
op.exit(2, op.format_help())
if options.variable == None:
if checkConfigfile(options.configFile,'variable'):
options.variable = getConfigfile(options.configFile,'variable')
else:
sys.stderr.write('Error: Missing Google Power Meter variable.\nVariable must be supplied via --variable or in the config file.\n')
op.exit(2,op.format_help())
if len(args) < 1:
sys.stderr.write('Error: No input file specified.\n')
op.exit(2, op.format_help())
return (args, options)
def main():
usage = 'usage: %prog [options] <host>'
parser = OptionParser(usage=usage)
parser.add_option('-d', action='store_true', dest='debug',
help='enable debug messages')
parser.add_option('-v', action='store_true', dest='verbose',
help='be more verbose')
parser.add_option('--always-check-esr', action='store_true',
dest='check_esr',
help='Check the error status register after every command')
(options, args) = parser.parse_args()
logging.basicConfig()
if options.verbose:
logging.getLogger('pyvxi11').setLevel(logging.INFO)
if options.debug:
logging.getLogger('pyvxi11').setLevel(logging.DEBUG)
if len(args) < 1:
print parser.format_help()
sys.exit(1)
host = args[0]
v = Vxi11(host)
v.open()
print "Enter command to send. Quit with 'q'."
try:
while True:
cmd = raw_input('=> ')
if cmd == 'q':
break
if cmd.startswith('%'):
process_local_command(cmd)
continue
if len(cmd) > 0:
is_query = cmd.split(' ')[0][-1] == '?'
try:
if is_query:
print v.ask(cmd)
else:
v.write(cmd)
if options.check_esr:
esr = int(v.ask('*ESR?').strip())
if esr != 0:
print 'Warning: ESR was %d' % esr
except Vxi11Error, e:
print 'ERROR: %s' % e
except EOFError:
print 'exitting..'
v.close()
def main(args):
parser = OptionParser('usage: %prog [options]')
parser.add_option('-g', '--gi', dest='gi', type='int',
help='gi of the genbank record to analyze.')
parser.add_option('-r', '--record', dest='record', type='string',
help='read genbank record from FILE',
metavar='FILE')
parser.add_option('-e', '--enzyme', dest='enzyme', type='string',
help='enzyme to process')
parser.add_option('-l', '--list', dest='enzymefile',
type='string', help='file of enzymes to process',
metavar='FILE')
parser.add_option('-s', '--size', dest='size', type='int',
help='size of the tag')
(options, args) = parser.parse_args(args)
if options.size:
length = options.size
else:
print >> sys.stderr, 'Usage error: must specify a length'
print >> sys.stderr, parser.format_help()
sys.exit(1)
if options.record:
record = genbank.Record(file(options.record))
elif options.gi:
record = giInfo.GiRecord(options.gi, True)
else:
print >> sys.stderr, 'Usage error: a record file (-r) or ' + \
'a gi (-g) is required'
print >> sys.stderr, parser.format_help()
sys.exit(1)
if options.enzymefile:
enzyme_reader = EnzymeFileReader(file(options.enzymefile))
for name, enzyme, originalEnzyme in enzyme_reader.enzymes():
if len(originalEnzyme or enzyme) >= length:
continue
analizer = Analizer(enzyme, record, length, originalEnzyme=originalEnzyme)
analizer.process()
analizer.saveToFile()
elif options.enzyme:
if length <= len(options.enzyme):
msg = 'Length of the tag cannot be smaller than the enzyme.'
print >> sys.stderr, msg
sys.exit(1)
analizer = Analizer(options.enzyme, record, length)
analizer.process()
analizer.saveToFile()
else:
print >> sys.stderr, 'Usage error: an enzyme (-e) or ' + \
'a file with enzymes (-l) is required'
print >> sys.stderr, parser.format_help()
sys.exit(1)
def main(argv=None):
program_name = os.path.basename(sys.argv[0])
program_version = __version__
program_build_date = "%s" % __updated__
program_version_string = '%%prog %s (%s)' % (program_version, program_build_date)
program_longdesc = '''''' # optional - give further explanation about what the program does
program_license = u"Copyright 2016 Magosányi Árpád \
Licensed under GNU GPL v3"
if argv is None:
argv = sys.argv[1:]
try:
parser = OptionParser(version=program_version_string, epilog=program_longdesc, description=program_license)
parser.add_option("-d", "--id", dest="keyid", type="string",
help="key id (mandatory!)")
parser.add_option("-m", "--module", dest="module", type="string",
help="pkcs11 module path")
parser.add_option("-p", "--pin", dest="pin", type="string",
help="pin [default: %default]")
parser.add_option("-M", "--mechanism", dest="mechanism",
help="HNAC/sign mechanism to use [default: %default]", type="string")
parser.add_option("-H", "--host", dest="host", type="string",
help="host [default: %default]")
parser.add_option("-P", "--port", dest="port", type="int",
help="port [default: %default]")
parser.add_option("-v", "--verbose", dest="verbose", action="count",
help="verbose to syslog. WARNING: logs PIN! [default: %default]")
parser.add_option("-e", "--environment", dest="environment", type="string",
help="append var=value to environment [default: %default]")
parser.set_defaults(module="/usr/lib/opensc-pkcs11.so", pin=u"0000", mechanism="SHA512-RSA-PKCS", host=u"localhost", port=9999, environment=None)
# process options
(opts, args) = parser.parse_args(argv)
if not opts.keyid:
print parser.format_help()
sys.exit(1)
if opts.environment:
(name,value) = opts.environment.split("=",2)
print (name,value)
os.environ[name]=value
syslog.openlog("cryptoserver", logoption=syslog.LOG_PID)
syslog.syslog("cryptoserver started at {0} {1}".format(opts.host,opts.port))
server.main(opts)
except:
excString = traceback.format_exc()
syslog.syslog(excString)
print excString
syslog.syslog("cryptoserver stopped at {0} {1}".format(opts.host,opts.port))
def main(argv):
parser = OptionParser()
parser.add_option("-a", "--action", dest="action", help="Action value (upstream-list, upstream-500, upstream-restart)")
parser.add_option("-u", "--url", dest="url", help="Ustats data source url")
parser.add_option("-t", "--tick", dest="tick", help="Stat tick length in seconds", type="int")
parser.add_option("-n", "--tick-num", dest="tick_num", help="Stat tick count to sum", type="int")
parser.add_option("-s", "--upstream", dest="upstream", help="Upstream to get stat data")
parser.add_option("-p", "--path", dest="path", help="Path to store temp data")
parser.add_option("-v", "--verbose", dest="verbose", help="Output more data", action="store_true")
(options, args) = parser.parse_args()
if options.url is None:
print parser.format_help()
if options.action == "upstream-500" and (options.tick < 1 or options.tick_num < 1):
print "tick and tick-num should be positive integers"
sys.exit(1)
#fetching ustats data
if options.action != "upstream-restart":
try:
response = urllib2.urlopen(options.url)
json_data = response.read()
if options.verbose:
print json_data
except urllib2.URLError as e:
print "URLError on fetching ustats data: ", e
sys.exit(1)
except:
print "Unexpected error on fetching ustats data: ", sys.exc_info()[0]
sys.exit(1)
#parsing json output
try:
ustats = json.loads(json_data)
if options.verbose:
print ustats
except:
print "Unexpected error on fetching ustats data: ", sys.exc_info()[0]
sys.exit(1)
if options.action == "upstream-list" :
upstream_list(ustats)
elif options.action == "upstream-500" :
upstream_500(ustats, options)
elif options.action == "upstream-restart" :
upstream_restart(options)
else :
print "Unrecognized action ", options.action
sys.exit(1)
def GetOptions():
"""
Supports the command-line arguments listed below.
"""
parser = OptionParser(add_help_option=False)
parser.add_option("-h",
"--host",
default="127.0.0.1",
help="remote host to connect to")
parser.add_option("-u",
"--user",
default="root",
help="User name to use when connecting to hostd")
parser.add_option("-p",
"--password",
"--pwd",
default="ca$hc0w",
help="Password to use when connecting to hostd")
parser.add_option("-v",
"--vm_name",
"--vmname",
default="CreateTest",
help="Name of the virtual machine")
parser.add_option("--datastore-name", help="Name of the datastore")
parser.add_option("-i",
"--num-iterations",
"--numiter",
default=1,
help="Number of iterations")
parser.add_option("--num-scsi-disks",
default=1,
help="Number of SCSI disks")
parser.add_option("--num-ide-disks", default=0, help="Number of IDE disks")
parser.add_option("-c",
"--num-power-cycles",
"--powercycles",
default=0,
help="Number of power cycles to perform before delete")
parser.add_option("-d",
"--dont-delete",
"--no-delete",
"--dontDelete",
default=False,
help="Don't delete created vm")
parser.add_option("-?", "--help", action="store_true", help="Help")
(options, _) = parser.parse_args()
if options.help:
print parser.format_help()
sys.exit(0)
return options
def main():
usage = 'usage: %prog [options] <host>'
parser = OptionParser(usage=usage)
parser.add_option('-a', action='store_true', dest='autoconnect', help='autoconnect to chassis')
parser.add_option('-v', action='store_false', dest='verbose', help='be more verbose')
parser.add_option('-p', dest='port', help='TCP port number', type=int, default=4555)
parser.add_option('-r', dest='rsa_id', help='RSA ID file', default=rsa_id)
(options, args) = parser.parse_args()
logging.basicConfig()
if options.verbose:
logging.getLogger().setLevel(logging.DEBUG)
else:
logging.getLogger().setLevel(logging.INFO)
if len(args) < 1:
print parser.format_help()
sys.exit(1)
host = args[0]
tcl = TclClient(logging.getLogger('ixexplorer.api'), host, options.port, options.rsa_id)
tcl.connect()
if options.autoconnect:
print tcl.connect()
print tcl.call('chassis add ' + host)
print tcl.call('chassis config -id 1')
print tcl.call('chassis set ' + host)
print "Enter command to send. Quit with 'q'."
try:
io = None
while True:
cmd = raw_input('=> ')
if cmd == 'q':
break
if len(cmd) > 0:
try:
if options.port == 8022:
res = tcl.call(cmd)
else:
(res, io) = tcl.call(cmd)
print res.strip()
if io is not None:
print io
except TclError, e:
print 'ERROR: %s' % e.result
except EOFError:
print 'exitting..'
def parseargs(argv):
parser = OptionParser(add_help_option=False)
parser.add_option("-r",
"--report",
dest="report",
action="store_true",
default=False,
help="Report inconsistencies without making any change")
# Pygresql defaults to localhost, 5432, $USER for the following
# three options, respectively. We therefore do not need any
# defaults.
parser.add_option("-h",
"--host",
dest="host",
action="store",
type="string",
help="GPDB master hostname/IP address")
parser.add_option("-p",
"--port",
dest="port",
action="store",
type="int",
help="GPDB master port")
parser.add_option("-u",
"--user",
dest="user",
action="store",
type="string",
help="Username to connect to GPDB. Must be superuser")
parser.add_option("-v",
"--verbose",
dest="verbose",
action="store_true",
default=False,
help="Verbose logging/output, include table names.")
parser.add_option("--help",
dest="help",
action="store_true",
default=False,
help="Show this help message and exit")
(options, args) = parser.parse_args(argv)
# If no args are specified, don't assume anything, print help and exit.
if options.help or len(argv) == 1:
print parser.format_help().strip()
sys.exit(0)
if options.user is not None:
options.passwd = getpass.getpass()
else:
options.passwd = None
return options
def get_argument():
parser = OptionParser()
parser.add_option('--serial',
action='store',
dest='serial_num',
help='device serial number, adb devices')
parser.add_option('--package',
action='store',
dest='package',
help='the package that monitor app')
(options, args) = parser.parse_args()
if options.package is None:
print parser.format_help()
print parser.exit(msg="Please point the package name ")
return options, args
def main():
usage = 'usage: %prog [options] <host>'
parser = OptionParser(usage=usage)
parser.add_option('-a',
action='store_true',
dest='autoconnect',
help='autoconnect to chassis')
parser.add_option('-v',
action='store_true',
dest='verbose',
help='be more verbose')
(options, args) = parser.parse_args()
logging.basicConfig()
if options.verbose:
logging.getLogger('pyixia.tclproto').setLevel(logging.DEBUG)
if len(args) < 1:
print parser.format_help()
sys.exit(1)
host = args[0]
try:
tcl = TclClient(host)
tcl.connect()
if options.autoconnect:
print tcl.call('ixConnectToChassis %s', host)[1]
print "Enter command to send. Quit with 'q'."
try:
while True:
cmd = raw_input('=> ')
if cmd == 'q':
break
if len(cmd) > 0:
try:
(res, io) = tcl.call(cmd)
print res
if io is not None:
print io.replace('\r', '\n')
except TclError, e:
print 'ERROR: %s' % e.result
except EOFError:
print 'exitting..'
except socket.error as e:
print e.strerror
def main():
parser = OptionParser()
parser.add_option('-p',
'--port',
dest='port',
help='set port to PORT',
metavar='PORT',
type='int',
default=8000)
parser.add_option(
'',
'--log',
dest='loglevel',
default='INFO',
help='set logging level (debug/info/warning/error/critical)')
(options, args) = parser.parse_args()
GronkExtensions.usage = parser.format_help() # for the {{@usage} tag
numeric_loglevel = getattr(logging, options.loglevel.upper(), None)
if not isinstance(numeric_loglevel, int):
raise ValueError('Invalid log level: %s' % options.loglevel)
# this is an ugly hack
logger = logging.getLogger("gronk")
logger.setLevel(numeric_loglevel)
print('Setting log level to %s [%s]' %
(options.loglevel.upper(), numeric_loglevel))
import sys
TornadoServer(webport=options.port).run(False)
def format_help(self, formatter=False):
options_help = OptionParser.format_help(self)
generators = thrifty.generators.find_plugin_generators()
help = options_help + '\nAvailable generators:\n\n'
for gen in generators:
help += ' %s (%s)\n' % (gen.aliases[0], gen.name)
return help
def get_options(args=None):
'''get options'''
parser = OptionParser()
parser.add_option('-v', '--version', action="store_true", dest='version', default=False, help='print version')
parser.add_option('-k', '--listkays', action="store_true", dest='listkeys', default=False, help='list all the keys')
parser.add_option('-s', '--showversions', action="store_true", dest='showversions', default=False, help='show the version of all the map type')
parser.add_option('-n', '--newtools', action="store_true", dest='newtools', default=True, help='use for ceph 10.2, default ')
# print osdmap chenge list
parser.add_option('-o', '--osdhistory', action="store_true", dest='history', default=False, help='show the history of osd map')
parser.add_option('', '--sv', action="store", dest='start_version', default="", help='start verson, for osd history')
parser.add_option('', '--ev', action="store", dest='end_version', default="", help='end verson, for osd history')
parser.add_option('', '--sd', action="store_true", dest='show_detial', default=False, help='show the detail ,not only osd up and down, for osd history')
'''common param'''
parser.add_option('', '--ldtp', action="store", dest='ldbtool_path', default="/root/yu/usr/bin/", help='the dir which have dbtools(default /root/yu/usr/bin/)')
parser.add_option('', '--dcp', action="store", dest='decode_path', default="/usr/bin/ceph-dencoder", help='the path of ceph-dencoder(default /usr/bin/ceph-dencoder)')
parser.add_option('', '--dbp', action="store", dest='mondb_path', default="/var/lib/ceph/mon/mon.a/", help='the path which include store.db(default /var/lib/ceph/mon/mon.a/)')
parser.add_option('-d', '--debugmode', action="store_true", dest='debug_mode', default=False, help='debug mode(default false)')
#parser.add_option('-o', '--outnanlyzed',action='store', dest='outdir', default='.', help='dir of analyzed file')
#parser.add_option('-c', '--threshold',action='store', dest='cost', default='0', help='microseconds, only analy the event which cost over the threshold')
#parser.add_option('-p', '--print', action="store_true", dest='print_only', default=False, help='print only through the filter')
# for real time
#parser.add_option('-r', '--realtime', action="store_true", dest='realtime', default=False, help='realtime analy')
#parser.add_option('-f', '--filter_event', action="store", dest='event', default="all", help='event name')
#parser.add_option('-t', '--print_event', action="store", dest='pevent', default="all", help='event name')
global HELP
HELP = parser.format_help().strip()
(options, argvs) = parser.parse_args(args)
#if not options.realtime and len(argvs) < 1 and not options.version:
# parser.error("Please specify the directory of the file to be processed.")
return options, argvs
def parse_args(self, argv, stdout=io2bytes(sys.stdout)):
"""
:param argv: list of str
:param stdout: binary-data stdout output
"""
parser = OptionParser(version=self.VERSION, usage=self.USAGE)
parser.add_option(
'-l', '--label', dest='label', default=b'', type='string', metavar='LABEL',
help='set label name to LABEL'
)
parser.add_option(
'-c', '--color', dest='color', default=None, type='string', metavar='COLOR',
help='set output color to COLOR (available colors: %s)' % ', '.join(sorted(COLOR_NAMES.keys()))
)
parser.add_option(
'-s', '--separator', dest='separator', default=b'|', type='string', metavar='SEPARATOR',
help='set separator string to SEPARATOR (default: "|")'
)
option, args = parser.parse_args(argv[1:])
# encode each arg string to bytes if Python3
color = COLOR_NAMES.get(option.color.lower()) if option.color else self._get_color(option.label)
if color is None:
stdout.write(arg2bytes(parser.format_help().encode('utf-8')))
stdout.write(b'\nInvalid color name: ' + arg2bytes(option.color) + b'\n')
parser.exit(2)
self.prefix = self._make_prefix(option.label, color, option.separator)
self.paths = [arg2bytes(arg) for arg in args] or [None]
return self
def main():
""" Main loop """
parser = OptionParser("%prog [options]")
parser.add_option("--verbosity",
type=int,
action="store",
dest="verbosity",
default=20,
help="verbosity of output, default is: "
"20 (INFO)")
(options, args) = parser.parse_args()
init_logger(options.verbosity)
try:
if len(args) < 1:
raise Usage("not enough arguments")
if len(args) > 1:
raise Usage("too many arguments")
cookie_read(args[0])
return 0
except Usage, err:
print >> sys.stderr, err.msg
print >> sys.stderr, parser.format_help()
return 1
def handle_input(bot, trigger_args, trigger):
parser = OptionParser(add_help_option=False,
usage='%prog [options] [user]', prog='.player',
epilog='Since there is no easy way to discern whether a page is a group or a user simply from the url, a warning may appear when attempting to parse group urls. Simply use \'.player -g <groupname>\' for details on the group.')
parser.add_option('-h', '--help', action='store_true', default=False,
help='Show this help menu')
parser.add_option('-g', '--group', action='store_true', default=False,
help='Parse input as a group (default: %default)')
parser.add_option('-b', '--bio', action='store_true', default=True,
help='Show the user/group bio (default: %default)')
parser.add_option('-l', '--list', action='store_true', default=False,
help='Show multiple search results (default: %default)')
parser.add_option('-p', '--page', type='int', default=1, metavar='num')
parser.add_option('-f', '--fav_games', action='store_true', default=False,
help='Show the user\'s favorite games (default: %default)')
opts, args = parser.parse_args(trigger_args)
if opts.help:
if not trigger.is_privmsg:
bot.reply("I am sending you a notice of the player.me module help")
for line in parser.format_help().strip().splitlines():
bot.notice(line, recipient=trigger.nick)
return
if opts.page < 1:
bot.say('[Player.me] Invalid page number')
return
if len(' '.join(args)) < 1:
args = [trigger.nick]
format_user(bot, opts, args)
def format_help(self, formatter=False):
options_help = OptionParser.format_help(self)
generators = thrifty.generators.find_plugin_generators()
help = options_help + '\nAvailable generators:\n\n'
for gen in generators:
help += ' %s (%s)\n' % (gen.aliases[0], gen.name)
return help
def ParseArgs(argv):
_CMD_OPTIONS_LIST = [
make_option("-h", "--host", dest="host", default="localhost",
help="Host name"),
make_option("-u", "--user", dest="user", default="root",
help="User name"),
make_option("-p", "--pwd", dest="pwd", default="",
help="Password"),
make_option("-n", "--vmname", dest="vmname", default="QuestionTest",
help="Virtual machine name"),
make_option("-v", "--verbose", dest="verbose", action="store_true",
default=False, help="Enable verbose logging"),
make_option("-i", "--iterations", dest="iter", type="int",
default=1, help="Number of iterations"),
make_option("-?", "--help", action="store_true", help="Help"),
]
_STR_USAGE = "%prog [options]"
# Get command line options
cmdParser = OptionParser(option_list=_CMD_OPTIONS_LIST,
usage=_STR_USAGE,
add_help_option=False)
cmdParser.allow_interspersed_args = False
usage = cmdParser.format_help()
# Parse arguments
(options, remainingOptions) = cmdParser.parse_args(argv)
cmdParser.destroy()
# Print usage
if options.help:
print(usage)
sys.exit(0)
return (options, remainingOptions)
def main():
import webbrowser
from tempfile import mkstemp
from optparse import OptionParser
import codecs
usage = "usage: %prog [options] URL1 URL2 ..."
parser = OptionParser(usage=usage)
parser.add_option(b"-b",
b"--open-browser",
action="store_true",
dest="open_browser",
default=False,
help=b"show the readable version in a web browser")
(options, args) = parser.parse_args()
if not args:
print(parser.format_help())
sys.exit(2)
for url in args:
html = urllib.urlopen(url).read().decode(DEFAULT_ENCODING)
readable_html = readable(url, html)
if options.open_browser:
fd, fn = mkstemp('readability.html')
os.close(fd)
with codecs.open(fn, 'w', encoding=DEFAULT_ENCODING) as f:
f.write(readable_html)
webbrowser.open('file://' + os.path.abspath(fn))
else:
print(readable_html)
def main():
import webbrowser
from tempfile import mkstemp
from optparse import OptionParser
import codecs
usage = "usage: %prog [options] URL1 URL2 ..."
parser = OptionParser(usage=usage)
parser.add_option(b"-b", b"--open-browser",
action="store_true", dest="open_browser", default=False,
help=b"show the readable version in a web browser")
(options, args) = parser.parse_args()
if not args:
print(parser.format_help())
sys.exit(2)
for url in args:
html = urllib.urlopen(url).read().decode(DEFAULT_ENCODING)
readable_html = readable(url, html)
if options.open_browser:
fd, fn = mkstemp('readability.html')
os.close(fd)
with codecs.open(fn, 'w', encoding=DEFAULT_ENCODING) as f:
f.write(readable_html)
webbrowser.open('file://' + os.path.abspath(fn))
else:
print(readable_html)
def main():
"""tool main"""
parser = OptionParser(version="autopep8: %s" % __version__,
description=__doc__)
parser.add_option('-v',
'--verbose',
action='store_true',
dest='verbose',
help='print to verbose result.')
parser.add_option('-d',
'--diff',
action='store_true',
dest='diff',
help='diff print of fixed source.')
parser.add_option('-p',
'--pep8-passes',
default=5,
type='int',
help='maximum number of additional pep8 passes')
opts, args = parser.parse_args()
if not len(args):
print parser.format_help()
return 1
filename = args[0]
original_filename = filename
tmp_source = open(filename).read()
fix = FixPEP8(filename, opts)
fixed_source = fix.fix()
original_source = copy.copy(fix.original_source)
for cnt in range(opts.pep8_passes):
if fixed_source == tmp_source:
break
tmp_source = copy.copy(fixed_source)
filename = tempfile.mkstemp()[1]
fp = open(filename, 'w')
fp.write(fixed_source)
fp.close()
fix = FixPEP8(filename, opts)
fixed_source = fix.fix()
os.remove(filename)
if opts.diff:
new = StringIO("".join(fix.source))
new = new.readlines()
print _get_difftext(original_source, new, original_filename),
else:
print fixed_source,
def format_help(self, *args):
msg = OptionParser.format_help(self, *args)
helptup = [
self.formatter.format_description(' '.join(s.split()))
for s in self.helpStr
]
msg = '\n'.join([msg] + helptup)
return msg
def option_setup(func):
optionParser = OptionParser(usage=usage)
optionParser.disable_interspersed_args()
for opt in option_list:
# opt is an optparse Option
optionParser.add_option(opt)
optionParser.set_usage("%s [options] %s" % (func.__name__[3:], arg_desc))
optionParser._func = func
def oUpdateOptionParser(instance):
if func.__name__.startswith('do_'):
sName = func.__name__[3:]
if hasattr(instance, 'oConfig') and sName in instance.oConfig:
oConfigSection = instance.oConfig[sName]
# iterate over optionParser
for sKey, gVal in oConfigSection.iteritems():
sOption = '--' +sKey
if optionParser.has_option(sOption):
oOption = optionParser.get_option(sOption)
# FixMe: only if the default is optparse.NO_DEFAULT?
if oOption.default is optparse.NO_DEFAULT:
# FixMe: does this set the default?
oOption.default = gVal
# FixMe: how about this?
optionParser.defaults[oOption.dest] = oOption.default
return optionParser
def new_func(instance, arg):
try:
# makebe return a list and prepend it
optionParser = oUpdateOptionParser(instance)
opts, newArgList = optionParser.parse_args(arg.split())
# Must find the remaining args in the original argument list, but
# mustn't include the command itself
#if hasattr(arg, 'parsed') and newArgList[0] == arg.parsed.command:
# newArgList = newArgList[1:]
newArgs = remaining_args(arg, newArgList)
if isinstance(arg, ParsedString):
arg = arg.with_args_replaced(newArgs)
else:
arg = newArgs
except optparse.OptParseError as e:
print (e)
optionParser.print_help()
return
if hasattr(opts, '_exit'):
return None
result = func(instance, arg, opts)
return result
func._optionParser = optionParser
if func.__doc__ is None and usage is None:
func.__doc__ = ""
elif func.__doc__ is None and usage:
func.__doc__ = usage
elif usage:
func.__doc__ = '%s\n%s' % (usage, func.__doc__, )
new_func.__doc__ = '%s\n%s' % (func.__doc__, optionParser.format_help())
return new_func
def bucket_man(bot, trigger):
"""
.bucket [options] [text...] - Create/edit bucket items, use .bucket --help for full help
"""
if not trigger.admin:
return
inp = trigger.group(2)
if not inp:
inp = ''
trigger_args = re.findall(r'(?:[^\s,"]|"(?:\\.|[^"])*")+', inp)
parser = OptionParser(add_help_option=False,
usage='%prog [options] [text..]', prog='.bucket')
parser.add_option('-h', '--help', action='store_true', default=False,
help='Show this help menu')
parser.add_option('-p', '--peek', action='store_true', default=False,
help='peek at the bucket contents')
parser.add_option('-e', '--edit', action='store_true', default=False,
help='edit the bucket contents')
parser.add_option('-r', '--remove', type='int', metavar='id',
help='remove the item at given id')
parser.add_option('-n', '--name', metavar='name',
help='name of the item to edit/create (required)')
parser.add_option('-d', '--description', metavar='desc',
help='description of the item to edit/create (required)')
parser.add_option('-i', '--id', type='int', metavar='id',
help='id of the item to edit/create')
parser.add_option('-c', '--cost', type='float', default=1.00, metavar='amount',
help='Set the cost for the item (default: %default)')
opts, args = parser.parse_args(trigger_args)
if opts.help:
if not trigger.is_privmsg:
bot.reply("I am sending you a notice of the bucket module help")
for line in parser.format_help().strip().splitlines():
bot.notice(line, recipient=trigger.nick)
return
if opts.peek:
content = bot.db.execute('SELECT * FROM bucket_items').fetchall()
template = u"{0:<6}|{1:15}|{2:25}|{3:8}" # column widths
bot.say(template.format("ItemId", "ItemName", "ItemDesc", "ItemCost")) # header
bot.say(u'------|---------------|-------------------------|--------')
for rec in content:
bot.say(format_item(*rec))
if opts.edit:
if not opts.name and not opts.id:
bot.reply('Err: Missing item name')
return
if not opts.description and not opts.id:
bot.reply('Err: Missing item description')
return
item = add_or_update_item(bot.db, opts.id, opts.name, opts.description, opts.cost)
bot.say(u'Added ' + format_item(*get_item(bot.db, item)))
elif opts.remove:
bot.say(u'Removed ' + str(remove_item(bot.db, opts.remove)))
def get_options(args=None):
"""Parse command line options and parameters."""
parser = OptionParser(add_help_option=False, usage='%prog <arg> [option]', description="")
global HELP
HELP = parser.format_help().strip()
options, args = parser.parse_args(args)
print HELP
return options, args
def getOptions():
##### Configuration options #####
usage = "usage: %prog [options] ics_file1 ics_file2"
parser = OptionParser(usage=usage, version=version)
parser.set_description("ics_diff will print a comparison of two iCalendar files ")
parser.add_option("-i", "--ignore-dtstamp", dest="ignore", action="store_true",
default=False, help="ignore DTSTAMP lines [default: False]")
(cmdline_options, args) = parser.parse_args()
if len(args) < 2:
print "error: too few arguments given"
print
print parser.format_help()
return False, False
return cmdline_options, args
def format_help(self, formatter=None):
command_help = """
The available commands are :
"""
command_help += '\n\n'.join(['%s\n%s\n%s'%(command,'-'*len(command), desc) for command,desc in command_description])
command_help += """
"""
return OptionParser.format_help(self) + ''.join(command_help)
def parse_args():
from optparse import OptionParser
parser = OptionParser("usage: %prog [options]")
for s in [["--file", "input file", "filename", "store", None],
[
"--outdir", "output directory", "outdir", "store",
"/tmp/pdfminer"
]]:
parser.add_option(s[0],
help=s[1],
dest=s[2],
action=s[3],
default=s[4])
try:
return parser.parse_args()
except:
print parser.format_help()
exit(1)
def parse_args(argv=None):
global DEBUG
if argv is None: argv = sys.argv[1:]
p = OptionParser('usage: piep [OPTIONS] PIPELINE')
p.add_option('--debug', action='store_true')
p.add_option('-j', '--join', default=' ')
p.add_option('-e', '--eval', action='append', dest='evals', default=[], metavar='EVAL', help='evaluate arbitrary code before running the script (in global scope, may be given multiple times)')
p.add_option('-m', '--import', action='append', dest='imports', default=[], metavar='MODULE', help='add a module to global scope (may be given multiple times)')
p.add_option('-f', '--file', action='append', dest='files', default=[], metavar='FILE', help='add another input stream (available as files[n])')
p.add_option('-i', '--input', dest='input', help='use a named file (instead of stdin)')
p.add_option('-p', '--path', action='append', dest='import_paths', default=[], help='add a location to the import path (the same as $PYTHONPATH / sys.path)')
p.add_option('-0', '--read0', action='store_true', dest='input_nullsep', help='read input as null-separated fields')
p.add_option('-n', '--no-input', action='store_true', help='don\'t read stdin - self-constructing pipeline')
p.add_option('--print0', action='store_true', dest='output_nullsep', help='print output as null-separated fields')
opts, args = p.parse_args(argv)
assert len(args) > 0, "Not enough arguments\n" + p.format_help()
assert len(args) == 1, "Too many arguments\n" + p.format_help()
DEBUG = opts.debug
return (opts, args)
def ParseArguments(argv):
""" Parse arguments """
from optparse import OptionParser, make_option
testHelp = """ """
# Internal cmds supported by this handler
_CMD_OPTIONS_LIST = [
make_option("-h", "--host", dest="host", default="localhost",
help="ESX host name"),
make_option("-o", "--port", dest="port", default=443, help="Port"),
make_option("-u", "--user", dest="user", default="root",
help="Host User name"),
make_option("-p", "--pwd", dest="pwd", default="",
help="Host Password"),
make_option("-k", "--key", dest="keyFile", default=None,
help="Key file path"),
make_option("-c", "--cert", dest="certFile", default=None,
help="Cert file path"),
make_option("-w", "--workers", dest="workers", type="int",
default=8, help="Num of workers"),
make_option("-s", "--waitSec", dest="waitSec", type="int",
default=8, help="Num of sec to wait"),
make_option("-n", "--numPCUpdates", dest="numWaitUpdate", type="int",
default=2, help="Num of pc wait for updates"),
make_option("-v", "--verbose", action="store_true", dest="verbose_stats",
default=False, help="Enable verbose stats"),
make_option("-?", "--help", action="store_true", help="Help"),
]
_STR_USAGE = "%prog [options]"
# Get command line options
cmdParser = OptionParser(option_list=_CMD_OPTIONS_LIST,
usage=_STR_USAGE,
add_help_option=False)
cmdParser.allow_interspersed_args = False
usage = cmdParser.format_help()
# Parse arguments
(options, remainingOptions) = cmdParser.parse_args(argv)
try:
# optparser does not have a destroy() method in older python
cmdParser.destroy()
except Exception:
pass
del cmdParser
# Print usage
if options.help:
print(usage)
print(testHelp)
sys.exit(0)
return (options, remainingOptions)
def main():
"""tool main"""
parser = OptionParser(version="autopep8: %s" % __version__,
description=__doc__)
parser.add_option('-v', '--verbose', action='store_true', dest='verbose',
help='print to verbose result.')
parser.add_option('-d', '--diff', action='store_true', dest='diff',
help='diff print of fixed source.')
parser.add_option('-p', '--pep8-passes', default=5, type='int',
help='maximum number of additional pep8 passes')
parser.add_option('--ignore', default='',
help='do not fix these errors/warnings (e.g. E4,W)')
opts, args = parser.parse_args()
if not len(args):
print parser.format_help()
return 1
filename = args[0]
original_filename = filename
tmp_source = read_from_filename(filename)
fix = FixPEP8(filename, opts, contents=tmp_source)
fixed_source = fix.fix()
original_source = copy.copy(fix.original_source)
for cnt in range(opts.pep8_passes):
if fixed_source == tmp_source:
break
tmp_source = copy.copy(fixed_source)
if not pep8:
filename = tempfile.mkstemp()[1]
print filename
fp = open(filename, 'w')
fp.write(fixed_source)
fp.close()
fix = FixPEP8(filename, opts, contents=tmp_source)
fixed_source = fix.fix()
if not pep8:
os.remove(filename)
if opts.diff:
new = StringIO("".join(fix.source))
new = new.readlines()
print _get_difftext(original_source, new, original_filename),
else:
print fixed_source,
def get_options():
##### Configuration options #####
usage = """usage: %prog [options] ics_file [timezone]"""
parser = OptionParser(usage=usage, version=version)
parser.set_description("change_tz will convert the timezones in an ics file. ")
parser.add_option(
"-u", "--only-utc", dest="utc", action="store_true", default=False, help="Only change UTC events."
)
parser.add_option("-l", "--list", dest="list", action="store_true", default=False, help="List available timezones")
(cmdline_options, args) = parser.parse_args()
if not args and not cmdline_options.list:
print "error: too few arguments given"
print
print parser.format_help()
return False, False
return cmdline_options, args
def main():
parser = OptionParser(usage="Usage: %prog [options] key=value key2=value2 ...")
parser.add_option("-e", "--endpoint", dest="endpoint", default=None, help="Messaging server URL")
parser.add_option("-q", "--queue", dest="queue", help="Queue to send message into")
parser.add_option("-n", "--name", dest="name", help="Message name")
parser.add_option("-f", "--file", dest="msgfile", help="File with message")
(options, args) = parser.parse_args()
if not options.queue or (not options.msgfile and not options.name):
print parser.format_help()
sys.exit()
init_script()
msg_service = bus.messaging_service
producer = msg_service.get_producer()
if options.endpoint:
producer.endpoint = options.endpoint
msg = msg_service.new_message()
if options.msgfile:
str = None
with open(options.msgfile, 'r') as fp:
str = fp.read()
if str:
msg.fromxml(str)
if msg.name:
msg.name = options.name
for pair in args:
k, v = pair.split("=")
msg.body[k] = v
producer.send(options.queue, msg)
print "Done"
def main():
usage = 'usage: %prog [options] <host>'
parser = OptionParser(usage=usage)
parser.add_option('-a', action='store_true', dest='autoconnect',
help='autoconnect to chassis')
parser.add_option('-v', action='store_true', dest='verbose',
help='be more verbose')
(options, args) = parser.parse_args()
logging.basicConfig()
if options.verbose:
logging.getLogger('pyixia.tclproto').setLevel(logging.DEBUG)
if len(args) < 1:
print parser.format_help()
sys.exit(1)
host = args[0]
tcl = TclClient(host)
tcl.connect()
if options.autoconnect:
print tcl.call('ixConnectToChassis %s', host)[1]
print "Enter command to send. Quit with 'q'."
try:
while True:
cmd = raw_input('=> ')
if cmd == 'q':
break
if len(cmd) > 0:
try:
(res, io) = tcl.call(cmd)
print res
if io is not None:
print io
except TclError, e:
print 'ERROR: %s' % e.result
except EOFError:
print 'exitting..'
def format_help(self, formatter=None):
command_help = """
The available commands are :
"""
command_help += '\n\n'.join(['%s\n%s\n%s'%(command,'-'*len(command), desc) for command,desc in command_description])
command_help += """
For the management of deployed Camelot applications, see camelot_manage
"""
return OptionParser.format_help(self) + ''.join(command_help)
def format_help(self, formatter=None):
command_help = """
The available commands are :
"""
command_help += '\n\n'.join(['%s\n%s\n%s'%(command,'-'*len(command), desc) for command,desc in command_description])
command_help += """
For the creation and development of Camelot projects, see camelot_admin
"""
return OptionParser.format_help(self) + ''.join(command_help)
def get_options(args=None):
'''get options'''
parser = OptionParser()
parser.add_option('', '--uuid', action="store", dest='task_uuid', default="", help='')
parser.add_option('', '--host', action="store", dest='host', default="", help='')
parser.add_option('', '--data_dev', action="store", dest='data_dev', default="", help='')
parser.add_option('', '--juuid', action="store", dest='juuid', default="", help='journal uuid')
global HELP
HELP = parser.format_help().strip()
(options, argvs) = parser.parse_args(args)
return options, argvs
def main(args):
parser = OptionParser('usage: %prog [options]')
optionsAvailable = (
('-i', '--input', 'Sequence_File_ID', 'int',
'Sequence_File_ID from MegaChip.Sequence_File table.'),
('-a', '--alignment', 'Alignment_Protocol_ID', 'int',
('Alignment_Protocol_ID from MegaChip.Alignment_Protocol '
'table.')),
('-t', '--taxonomy', 'Taxonomy_ID', 'int',
'Taxonomy_ID from MegaChipDB.Taxonomy table.'),
('-e','--expect','Alignment_Score_Limit','float',
'Score cutoff for alignment.'),
('-f', '--filter', 'Blast_Filter_Protocol_ID', 'int',
('Blast_Filter_Protocol_ID from MegaChipDB.'
'Blast_Filter_Protocol table. If None no filter will be '
'used.')),
('-l', '--likeTHD', 'templateTHD_ID','int',
'use exsiting THD as template for unspecified values'),
)
ids =[ x[2] for x in optionsAvailable if x[2] != 'templateTHD_ID' ]
for opt in optionsAvailable:
if opt[3] is None:
otype = 'string'
else:
otype = opt[3]
parser.add_option(opt[0], opt[1], dest=opt[2], type=otype,
help=opt[4])
(options, args) = parser.parse_args(args)
defined = lambda x: getattr(options, x) is not None
if options.templateTHD_ID != None:
templateTHD=THD(options.templateTHD_ID)
for opt in ids:
if not defined(opt):
setattr(options,opt,getattr(templateTHD,opt))
if not all(map(defined, ids)):
print >> sys.stderr, ('Usage error: all arguments are required, '
'or derived from template THD')
print >> sys.stderr, parser.format_help()
sys.exit(1)
thdc = THDCreator(options.Sequence_File_ID,
options.Alignment_Protocol_ID,
options.Alignment_Score_Limit,
options.Taxonomy_ID,
options.Blast_Filter_Protocol_ID)
thdc.run()
def handle_input(bot, trigger_args, trigger):
parser = OptionParser(
add_help_option=False,
usage='%prog [options] [user]',
prog='.player',
epilog=
'Since there is no easy way to discern whether a page is a group or a user simply from the url, a warning may appear when attempting to parse group urls. Simply use \'.player -g <groupname>\' for details on the group.'
)
parser.add_option('-h',
'--help',
action='store_true',
default=False,
help='Show this help menu')
parser.add_option('-g',
'--group',
action='store_true',
default=False,
help='Parse input as a group (default: %default)')
parser.add_option('-b',
'--bio',
action='store_true',
default=True,
help='Show the user/group bio (default: %default)')
parser.add_option('-l',
'--list',
action='store_true',
default=False,
help='Show multiple search results (default: %default)')
parser.add_option('-p', '--page', type='int', default=1, metavar='num')
parser.add_option(
'-f',
'--fav_games',
action='store_true',
default=False,
help='Show the user\'s favorite games (default: %default)')
opts, args = parser.parse_args(trigger_args)
if opts.help:
if not trigger.is_privmsg:
bot.reply("I am sending you a notice of the player.me module help")
for line in parser.format_help().strip().splitlines():
bot.notice(line, recipient=trigger.nick)
return
if opts.page < 1:
bot.say('[Player.me] Invalid page number')
return
if len(' '.join(args)) < 1:
args = [trigger.nick]
format_user(bot, opts, args)
def format_help(self, formatter=None):
"""Taken from https://gist.github.com/sampsyo/462717"""
# Get the original help message, to which we will append.
out = OptionParser.format_help(self, formatter)
if formatter is None:
formatter = self.formatter
# Subcommands header.
result = ["\n"]
result.append(formatter.format_heading('Commands'))
formatter.indent()
# Generate the display names (including aliases).
# Also determine the help position.
disp_names = []
help_position = 0
for subcommand in self.subcommands:
name = subcommand.name
if subcommand.aliases:
name += ' (%s)' % ', '.join(subcommand.aliases)
disp_names.append(name)
# Set the help position based on the max width.
proposed_help_position = len(name) + formatter.current_indent + 2
if proposed_help_position <= formatter.max_help_position:
help_position = max(help_position, proposed_help_position)
# Add each subcommand to the output.
for subcommand, name in zip(self.subcommands, disp_names):
# Lifted directly from optparse.py.
name_width = help_position - formatter.current_indent - 2
if len(name) > name_width:
name = "%*s%s\n" % (formatter.current_indent, "", name)
indent_first = help_position
else:
name = "%*s%-*s " % (formatter.current_indent, "", name_width,
name)
indent_first = 0
result.append(name)
help_width = formatter.width - help_position
help_lines = textwrap.wrap(subcommand.help, help_width)
result.append("%*s%s\n" % (indent_first, "", help_lines[0]))
result.extend([
"%*s%s\n" % (help_position, "", line)
for line in help_lines[1:]
])
formatter.dedent()
# Concatenate the original help message with the subcommand
# list.
return out + "".join(result)
class MyOptions(object):
def __init__(self):
usage = "usage: %s [-q] [-c|-d directory] " % sys.argv[0]
self.parser = OptionParser(usage)
self.parser.add_option("-d",
"--dir",
dest="dirname",
help="specify DATA directory ",
metavar="FILE")
self.parser.add_option("-q",
"--quiet",
action="store_false",
dest="verbose",
default=True,
help="don't print status messages to stdout")
self.parser.add_option("-c",
"--clean",
action="store_true",
dest="clean",
default=False,
help="remove all directories in DATA")
def parse(self, args):
(self.options, self.args) = self.parser.parse_args(args=args)
self.verbose = self.options.verbose
self.clean = self.options.clean
self.dirname = self.options.dirname
#import pdb; pdb.set_trace()
if not self.dirname:
if not self.clean:
print self.parser.format_help()
self.parser.error("not enough arguments.")
else:
if self.clean:
print self.parser.format_help()
self.parser.error(
"Only one options among '-c' and '-d' has to be supplied")
def format_help(self, **kwargs):
seen = set()
if self.autofmt:
for (option, group, level) in all_options(self):
if group not in seen:
try:
group.description = flense(group.description)
except AttributeError:
pass
try:
option.help = flense(option.help)
except AttributeError:
pass
return self.expand(OptionParser.format_help(self, **kwargs))
def get_options(args=None):
"""Parse command line options and parameters."""
parser = OptionParser(add_help_option=False, usage='%prog <arg> [option]', description="")
parser.add_option('-w', '--white_folder', action='store', type='string', default="M:/Users/Summer fu/13Q1-whitelist", dest='white_folder', help='whitelist folder')
parser.add_option('-s', '--sar_folder', action='store', type='string', default="D:/work/Enhanced/SAR_samsung/sar/SAR", dest='sar_folder', help='sar folder')
parser.add_option('-d', action='store', type='string', default="d:/test", dest='out_folder', help='out folder')
parser.add_option('-h', '--help', dest='help', action='store_true', default=False, help="show this doc")
parser.add_option('-f', '--file', dest='err_log', type='string', action='store', help="load err file")
global HELP
HELP = parser.format_help().strip()
options, args = parser.parse_args(args)
#print HELP
return options, args
def format_help(self, formatter=None):
class Positional(object):
def __init__(self, args):
self.option_groups = []
self.option_list = args
positional = Positional(self.positional)
formatter = IndentedHelpFormatter()
formatter.store_option_strings(positional)
output = ['\n', formatter.format_heading("Positional Arguments")]
formatter.indent()
pos_help = [formatter.format_option(opt) for opt in self.positional]
pos_help = [line.replace('--', '') for line in pos_help]
output += pos_help
return OptionParser.format_help(self, formatter) + ''.join(output)
