def checkArguments():
ynOptions = ['y', 'n', 'Y', 'N']
optparser = OptionParser()
optparser.add_option(
"-e",
"--Env",
dest="Env",
default="api",
help="Mandatory - provide the Qubole enviornment, default value is api"
)
optparser.add_option("-t",
"--Token",
dest="Token",
default="",
help="Mandatory - provide your Qubole account token")
optparser.add_option(
"-p",
"--SearchPattern",
dest="SrchPattern",
default="",
help=
"Mandatory - search multiple string or pattern seperated by ~ character, case insensitive search by default"
)
optparser.add_option("-u",
"--Users",
dest="Users",
default="",
help="Optional - comma seperated list of email ids")
optparser.add_option(
"-s",
"--CaseSensitiveSearch",
dest="CaseSensitiveSrch",
default="N",
choices=ynOptions,
help="Optional - case sensitive search , default value is N")
optparser.add_option(
"-c",
"--CommonDirectory",
dest="CommonDirectory",
default="Y",
choices=ynOptions,
help="Optional - include common directory , default value is Y")
(opts, args) = optparser.parse_args()
opts.Env = opts.Env.lower().replace(" ", "")
if opts.Env == "":
print("\nPlease specify an enviornment.")
opts.CaseSensitiveSrch = opts.CaseSensitiveSrch.upper()
opts.CommonDirectory = opts.CommonDirectory.upper()
if (opts.Token == None or opts.Token == '' or opts.SrchPattern == None
or opts.SrchPattern == ''):
argumentExit(optparser)
elif (len(opts.Users) > 0):
# remove spaces and create a list
userList = opts.Users.replace(" ", "").split(",")
#remove dups
userList = list(set(userList))
#remove empty
userList = ''.join(userList).split()
if (len(userList) > 0):
p = re.compile(r"[^@]+@[^@]+\.[^@]+")
for user in userList:
if not p.match(user):
print("\nInvalid email id - %s \n" % user)
argumentExit(optparser)
else:
print("\nEmail ids cannot be empty strings.\n")
argumentExit(optparser)
opts.Users = userList
return (opts, args)
else:
return (opts, args)
from array import array
ROOT.gROOT.SetBatch(True)
import utilities
utilities = utilities.util()
import sys
sys.path.append(os.getcwd() + "/plotUtils/")
from utility import *
if __name__ == "__main__":
ROOT.gStyle.SetOptStat(0)
from optparse import OptionParser
parser = OptionParser(usage='%prog th2.root [options] ')
parser.add_option('-o','--outdir', dest='outdir', default='', type='string', help='outdput directory to save plots')
parser.add_option( '--palette' , dest='palette', default=55, type=int, help='Set palette: use a negative number to select a built-in one, otherwise the default is 55 (kRainbow)')
parser.add_option( '--rebinEtaPt' , dest='rebinEtaPt', default=(0,0), nargs=2, type=int, help='Rebinnign factor for eta-pt distribution. Default is none, equivalent to 1,1')
(options, args) = parser.parse_args()
ROOT.TH1.SetDefaultSumw2()
if len(args) < 1:
parser.print_usage()
quit()
outdir = options.outdir
addStringToEnd(outdir,"/",notAddIfEndswithMatch=True)
createPlotDirAndCopyPhp(outdir)
def new_option_parser():
from optparse import OptionParser
result = OptionParser()
result.add_option("-N", dest="N", type="int", default=1000,
help="number of stars [1000]")
return result
See Analyzer.Write for more information.
"""
for analyzer in self._analyzers:
analyzer.write(self.setup)
self.setup.close()
if __name__ == '__main__':
import pickle
import sys
import os
from heppy.framework.heppy_loop import _heppyGlobalOptions
from optparse import OptionParser
parser = OptionParser(
usage='%prog cfgFileName compFileName [--options=optFile.json]')
parser.add_option('--options',
dest='options',
default='',
help='options json file')
(options, args) = parser.parse_args()
if options.options != '':
jsonfilename = options.options
jfile = open(jsonfilename, 'r')
opts = json.loads(jfile.readline())
for k, v in opts.iteritems():
_heppyGlobalOptions[k] = v
jfile.close()
if len(args) == 1:
def main():
sys.stdout = codecs.getwriter('utf-8')(sys.stdout)
parser = OptionParser()
parser.add_option('-s',
'--server_host',
dest='server_host',
type='string',
default='localhost',
help='server host')
parser.add_option('-p',
'--server_port',
dest='server_port',
type='int',
default=_UNDEFINED_PORT,
help='server port')
parser.add_option('-o',
'--origin',
dest='origin',
type='string',
default='http://localhost/',
help='origin')
parser.add_option('-r',
'--resource',
dest='resource',
type='string',
default='/echo',
help='resource path')
parser.add_option('-m',
'--message',
dest='message',
type='string',
help=('comma-separated messages to send excluding "%s" '
'that is always sent at the end' %
_GOODBYE_MESSAGE))
parser.add_option('-q',
'--quiet',
dest='verbose',
action='store_false',
default=True,
help='suppress messages')
parser.add_option('-t',
'--tls',
dest='use_tls',
action='store_true',
default=False,
help='use TLS (wss://)')
parser.add_option('-k',
'--socket_timeout',
dest='socket_timeout',
type='int',
default=_TIMEOUT_SEC,
help='Timeout(sec) for sockets')
(options, unused_args) = parser.parse_args()
# Default port number depends on whether TLS is used.
if options.server_port == _UNDEFINED_PORT:
if options.use_tls:
options.server_port = _DEFAULT_SECURE_PORT
else:
options.server_port = _DEFAULT_PORT
# optparse doesn't seem to handle non-ascii default values.
# Set default message here.
if not options.message:
options.message = u'Hello,\u65e5\u672c' # "Japan" in Japanese
EchoClient(options).run()
def run():
usage = "dispatch_server.py [-u][-f][-d][-p][-U]|[-c]|[-s]"
optParser = OptionParser(usage)
group = OptionGroup(optParser,"Auxiliary Funciton Options")
group.add_option("-c","--command",action = "store",type="str",dest = "cmd",
help='''status for process status
kill for kill process
clresult for clear result directory
other string for you can input cmd yourself''')
group.add_option("-s","--slice",action = "store",type="str",dest = "slicefile",nargs=2, help="file to slice")
optParser.add_option_group(group)
optParser.add_option("-d","--download",action = "store_true",dest = "downdir",help="input which directory you want to download")
optParser.add_option("-f","--file",action = "store",type="str",dest = "filename", help="file to check")
optParser.add_option("-p","--print",action = "store_true",dest = "outputinfo", help="if on, output the process infomation")
optParser.add_option("-u","--upload",action = "store_false",dest = "uploaddir", help="if update")
optParser.add_option("-U","--user",action = "store",type="str",dest = "username", default="ffff", help="username")
options, args = optParser.parse_args()
#pdb.set_trace()
username = options.username
dir = '/home/%s' %username
maclistfile ='%s/dispatch/ffff_maclistfile.txt' %dir
freelist = read_file(maclistfile)
hostname = freelist[0]
busylist = []
if options.slicefile == None:
passwd = get_passwd(username, hostname)
'''update executable program'''
if options.uploaddir != None:
for i in range(0, len(freelist)):
hostname = freelist[i].strip()
errcode, errmsg = dir_upload(username, hostname, dir, passwd)
if errcode == 0:
print errmsg
break
print '%d.%s: %s' %(i, hostname, errmsg)
print '%d host upload done' %(len(freelist))
'''dispatch file and data check'''
if options.filename != None:
if(len(freelist)) > 20:
worker = 20
else:
worker = len(freelist)
filelist = data_slice(worker, options.filename)
work_threads = []
for i in range(0, worker):
hostname = freelist[i].strip()
errcode, errmsg, todir = mk_todir(username, hostname, passwd, dir, worker)
if errcode == 0:
print errmsg
break
errcode, errmsg = file_upload(filelist[i], username, hostname, todir, passwd)
if errcode == 0:
print errmsg
break
work_thread = threading.Thread(target = work, args = (username, hostname, passwd, filelist[i]))
work_threads.append(work_thread)
print work_thread, hostname
work_thread.start()
for job in work_threads:
print str(job)+' waiting!'
job.join()
#time.sleep(10)
'''download result'''
if options.downdir != None:
for i in range(0, len(freelist)):
hostname = freelist[i].strip()
errcode, errmsg = dir_download(username, hostname, dir, passwd)
if errcode == 0:
print errmsg
break
print '%d.%s: %s' %(i, hostname, errmsg)
print '%d host download done' %(len(freelist))
'''file slicing'''
if options.slicefile != None:
filelist = data_slice(int(options.slicefile[1]), options.slicefile[0])
'''check the progress status or other command'''
if options.cmd != None:
machines_stat_det(username, freelist, passwd, options.cmd)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author: chaomy
# @Date: 2017-06-28 00:35:14
# @Last Modified by: chaomy
# @Last Modified time: 2018-07-23 15:14:07
from optparse import OptionParser
import gn_dd_data_hcp
import gn_dd_data_bcc
if __name__ == '__main__':
usage = "usage:%prog [options] arg1 [options] arg2"
parser = OptionParser(usage=usage)
parser.add_option('-t', "--mtype", action="store",
type="string", dest="mtype")
parser.add_option('-p', "--param", action="store",
type='string', dest="fargs")
(options, args) = parser.parse_args()
bcc = gn_dd_data_bcc.gn_dd_data_bcc()
drv = gn_dd_data_hcp.gn_dd_data_hcp()
dispatcher = {'hcp': drv.write_hcp_straight_data,
'hcporowan': drv.write_hcp_orawan_data,
'hcpprec': drv.inplane_hcp_beta1_prec,
'hcpten': drv.write_hcp_tensile_data,
'bccscrew': bcc.write_straight_screw_data}
dispatcher[options.mtype.lower()]()
def main():
usage = "usage: %prog <-d path> [options] <bed files> ..."
description = "Draw conservation plot for many bed files."
optparser = OptionParser(version="%prog 0.1",description=description,usage=usage,add_help_option=False)
optparser.add_option('-H','--height', dest='height',type='int',default=10, help="height of plot")
optparser.add_option('-W','--width',dest='width',type='int',default=10, help="width of plot")
optparser.add_option('-w',dest='w',type='int',default=1000, help="window width centered at middle of bed regions,default: 1000")
optparser.add_option('-t','--title',dest='title',help="title of the figure. Default: 'Average Phastcons around the Center of Sites'",default= 'Average Phastcons around the Center of Sites')
optparser.add_option('-d','--phasdb',dest='phasdb',help= 'The directory to store phastcons scores in the server')
optparser.add_option('-o','--outimg',dest='outimg',help= 'output image file prefix')
optparser.add_option("-l","--bed-label",dest="bedlabel",type="string",action="append",
help="the BED file labels in the figure. No space is allowed. This option should be used same times as -w option, and please input them in the same order as BED files. default: will use the BED file filename as labels.")
optparser.add_option("-h","--help",action="help",help="Show this help message and exit.")
(options,bedfiles) = optparser.parse_args()
options.pf_res = options.w / 100 # get 100 points to plot
options.w = options.pf_res * 100 # trim
bedfiles = map(os.path.abspath,bedfiles)
bedfilenames = map(os.path.basename,bedfiles)
bedfilenum = len(bedfiles)
if bedfilenum < 1 or not options.phasdb:
optparser.print_help()
sys.exit(1)
if options.bedlabel and len(options.bedlabel) == bedfilenum:
bedlabel = options.bedlabel
else: # or use the filename
bedlabel = map(lambda x:os.path.basename(x),bedfiles)
if options.height < 10:
error("Height can not be lower than 10!")
sys.exit(1)
if options.width < 10:
error("Width can not be smaller than 10!")
sys.exit(1)
# check the files
for f in bedfiles:
if not os.path.isfile(f):
error("%s is not valid!" % f)
sys.exit(1)
# check phastcons db
if not os.path.isdir(options.phasdb):
error("%s is not valid!" % options.phasdb)
sys.exit(1)
# change wd to phastcons db path
olddir = os.path.abspath('.')
os.chdir(options.phasdb)
phas_chrnames = []
files_phasdb = os.listdir('.')
for file_phasdb in files_phasdb:
if file_phasdb.endswith('.bw'):
name = file_phasdb.rstrip('.bw')
phas_chrnames.append(name)
if not phas_chrnames:
error("%s has no valid phastcons db bw files!" % options.phasdb)
sys.exit(1)
info("number of bed files: %d" % bedfilenum)
avgValues = []
# for each bed file
for f in bedfiles:
info("extract phastcons scores using %s" % f)
scores = extract_phastcons(f,phas_chrnames, options.w, options.pf_res)
avgValues.append(scores)
if options.w == 4000:
## 100 points for 4000, 40bp resolution
print("\t".join([str(avgValues[0][i]) for i in [12,25,38,50,62,75,88]]))
elif options.w == 400:
print("\t".join([str(avgValues[0][i]) for i in [45,48,50,52,55]]))
makeBmpFile(avgValues,olddir, options.outimg ,options.height,options.width,options.w,options.pf_res,options.title,bedlabel)
################################################################################ from __future__ import print_function import aerospike import sys from optparse import OptionParser ################################################################ # Option Parsing ################################################################ usage = "usage: %prog [options] key" optparser = OptionParser(usage=usage, add_help_option=False) optparser.add_option( "--help", dest="help", action="store_true", help="Displays this message.") optparser.add_option( "-h", "--host", dest="host", type="string", default="127.0.0.1", metavar="<ADDRESS>", help="Address of Aerospike server.") optparser.add_option( "-p", "--port", dest="port", type="int", default=3000, metavar="<PORT>", help="Port of the Aerospike server.") optparser.add_option( "-n", "--namespace", dest="namespace", type="string", default="test", metavar="<NS>",
from optparse import OptionParser
import pickle
import time
import sys
prog = 'pyRSA'
cmd = 'python3 pyrsa.py'
version = '0.1'
div = '\n------------------------------'
usage = cmd + ' -e <arquivo_em_texto_aberto> -o <saÃda_encriptada> [options]'
usage += '\n' + cmd + '-d <arquivo_encriptado> -o <saÃda_em_texto_aberto> [options].'
parser = OptionParser(prog=prog, usage=usage, version='%prog ' + version)
parser.add_option("-e", "--encrypt", dest="msg_filename", type='str',
help='arquivo aberto para ser encriptado')
parser.add_option("-d", "--decrypt", dest="encrypt_filename", type='str',
help='arquivo encriptado para ser decifrado')
parser.add_option('-o', '--output', dest='dest_filename', type='str',
help='arquivo de destino/saÃda.')
parser.add_option("-l", "--list", dest="list", action='store_true', default='False',
help='não utiliza map-reduce para encriptar/desencriptar (mais lento - desligado por padrão)')
parser.add_option("-k", "--keys", dest="genkeys", action='store_true', default='False',
help='gera um novo par de chaves')
parser.add_option("-v", "--verbose", dest="verbose", action='store_true',
default='False', help='imprime o arquivo aberto')
def main():
parser = OptionParser()
parser.add_option(
"--verbose",
action="store_true",
dest="verbose",
default=False,
help="""Default is %default.""",
)
parser.add_option(
"--from-commit",
action="store_true",
dest="from_commit",
default=False,
help="""From commit hook, do not descend into directories. Default is %default.""",
)
parser.add_option(
"--check-only",
action="store_true",
dest="check_only",
default=False,
help="""For CI testing, check if it's properly formatted. Default is %default.""",
)
parser.add_option(
"--no-progressbar",
action="store_false",
dest="progress_bar",
default=True,
help="""Disable progress bar outputs (if tqdm is installed).
Defaults to off.""",
)
options, positional_args = parser.parse_args()
if options.from_commit:
assert not positional_args
for desc in getStagedFileChangeDesc():
autoformat(desc["src_path"], git_stage=desc)
else:
if not positional_args:
positional_args = ["bin", "nuitka", "setup.py", "tests/*/run_all.py"]
my_print("Working on:", positional_args)
positional_args = sum(
(
resolveShellPatternToFilenames(positional_arg)
for positional_arg in positional_args
),
[],
)
filenames = list(
scanTargets(
positional_args,
suffixes=(".py", ".scons", ".rst", ".txt", ".j2", ".md", ".c", ".h"),
)
)
if not filenames:
tools_logger.sysexit("No files found.")
result = 0
if options.progress_bar:
enableProgressBar()
for filename in wrapWithProgressBar(
filenames, stage="Autoformat", unit="files"
):
if autoformat(filename, git_stage=False, check_only=options.check_only):
result += 1
if options.check_only and result > 0:
tools_logger.sysexit(
"""Error, bin/autoformat-nuitka-source would make changes to %d files, \
make sure to have commit hook installed."""
% result
)
elif result > 0:
tools_logger.info("autoformat: Changes to formatting of %d files" % result)
else:
tools_logger.info("autoformat: No files needed formatting changes.")
return self.freq
def set_freq(self, freq):
self.freq = freq
self.uhd_usrp_sink_0.set_center_freq(self.freq, 0)
def get_bw(self):
return self.bw
def set_bw(self, bw):
self.bw = bw
self.uhd_usrp_sink_0.set_bandwidth(self.bw, 0)
if __name__ == '__main__':
parser = OptionParser(option_class=eng_option, usage="%prog: [options]")
parser.add_option("-s",
"--samplerate",
dest="samplerate",
help="Sample Rate",
default=100000)
parser.add_option("-f",
"--freq",
dest="freq",
help="Frequency",
default=433000)
parser.add_option("-g", "--gain", dest="gain", help="Gain", default=30)
parser.add_option("-b",
"--bandwidth",
dest="bw",
help="Bandwidth",
rdOptions.put("rho", str(kwargs['eratio']))
RemoveDegeneratedTriangles(liaison, rdOptions).compute()
# Output
MeshWriter.writeObject3D(liaison.getMesh(), kwargs['out_dir'], "")
if kwargs['recordFile']:
liaison.getMesh().getTrace().finish()
if __name__ == "__main__":
"""
Clean an existing mesh: swap+valence+smooth+remove degenerated.
"""
cmd = ("clean", "<inputDir> <outputDir>", "Clean an existing mesh")
parser = OptionParser(usage="amibebatch %s [OPTIONS] %s\n\n%s" % cmd,
prog="clean")
parser.add_option(
"-a",
"--angle",
metavar="FLOAT",
default=15.0,
action="store",
type="float",
dest="coplanarityAngle",
help="angle (in degrees) between face normals to detect "
"feature edges (default: 15, superseded if -c is defined)")
parser.add_option(
"-c",
"--coplanarity",
metavar="FLOAT",
action="store",
state = self.state
self.dragpos = wx.Point(0, 0)
client_area = state.frame.GetClientSize()
self.zoom = min(float(client_area.x) / self.img.GetWidth(),
float(client_area.y) / self.img.GetHeight())
self.need_redraw = True
def full_size(self):
'''show image at full size'''
self.dragpos = wx.Point(0, 0)
self.zoom = 1.0
self.need_redraw = True
if __name__ == "__main__":
from optparse import OptionParser
parser = OptionParser("mp_image.py <file>")
parser.add_option("--zoom", action='store_true', default=False, help="allow zoom")
parser.add_option("--drag", action='store_true', default=False, help="allow drag")
parser.add_option("--autosize", action='store_true', default=False, help="auto size window")
(opts, args) = parser.parse_args()
im = MPImage(mouse_events=True,
key_events=True,
can_drag = opts.drag,
can_zoom = opts.zoom,
auto_size = opts.autosize)
img = cv.LoadImage(args[0])
im.set_image(img, bgr=True)
while im.is_alive():
for event in im.events():
cand = [1] + [product(allfactors[:i+1]) for i in range(len(allfactors))]
#return cand[-1], n/cand[-1]
best = [cand[len(cand)/2], n/cand[len(cand)/2]]
best.sort(reverse=True)
return tuple(best)
# if len(cand)%2:
# return cand[len(cand)/2], cand[len(cand)/2]
# return cand[len(cand)/2], cand[len(cand)/2 - 1]
if __name__ == '__main__':
#print __doc__
#XXX: note that 'argparse' is new as of python2.7
from optparse import OptionParser
parser = OptionParser(usage=__doc__)
parser.add_option("-i","--iter",action="store",dest="step",metavar="INT",\
default=None,help="the largest iteration to plot")
parser.add_option("-p","--param",action="store",dest="param",\
metavar="STR",default="[':']",
help="indicator string to select parameters")
parser.add_option("-l","--label",action="store",dest="label",\
metavar="STR",default="['']",
help="string to assign label to y-axis")
parser.add_option("-n","--nid",action="store",dest="id",\
metavar="INT",default=None,
help="id # of the nth simultaneous points to plot")
parser.add_option("-c","--cost",action="store_true",dest="cost",\
default=False,help="also plot the parameter cost")
parser.add_option("-g","--legend",action="store_true",dest="legend",\
default=False,help="show the legend")
def do_main():
parser = OptionParser()
parser.add_option("-s", "--scripts", dest="script_dir", default="./scripts",
help="top level test case script directory")
parser.add_option("-b", "--baselines", dest="baseline_dir", default="./baselines",
help="top level test output baseline directory")
parser.add_option("-o", "--report_file", dest="report_file",
default="./sqlcmdtest.report",
help="report output file")
parser.add_option("-r", "--refresh", dest="refresh",
action="store_true", default=False,
help="enable baseline refresh")
parser.add_option("-p", "--purge_only", dest="purge_only",
action="store_true", default=False,
help="instead of running tests, purge temp scratch files from prior runs")
# TODO add a way to pass non-default options to the VoltDB server and tweak the sqlcmd
# command line options if/when these settings effect the connection string
# (non-default ports. security, etc.)
# TODO add a way to pass sqlcmd command line options to be used with all test scripts.
(options, args) = parser.parse_args()
if options.purge_only:
purgeonly(options.script_dir)
sys.exit("The -p/--purge_only option does not run tests. It purged %d scratch files." % (purge_only_count))
# TODO Output jenkins-friendly html-formatted report artifacts as an alternative to plain text.
reportout = open(options.report_file, 'w+')
# TODO -- support different server modes -- either by explicit command line
# option or automatic-but-verbosely -- to detect and use an already running
# VoltDB server and remember to leave it running on exit.
launch_and_wait_on_voltdb(reportout)
# Except in refresh mode, any diffs change the scripts exit code to fail ant/jenkins
haddiffs = False
try:
for parent, dirs, files in os.walk(options.script_dir):
# Process each ".in" file found in the recursive directory walk.
# Ignore other files -- these may be scratch files that (FIXME) really should be
# written to a temp directory instead, or they may be backup files (like from a text editor)
# or in the future they may be other kinds of input like a ".options" file that
# could provide sqlcmd command line options to use with a corresponding ".in" file.
for inpath in files:
if not inpath.endswith(".in"):
continue
print "Running ", os.path.join(parent, inpath)
prefix = inpath[:-3]
childin = open(os.path.join(parent, inpath))
# TODO use temp scratch files instead of local files to avoid polluting the git
# workspace. Ideally they would be self-purging except in failure cases or debug
# modes when they may contain useful diagnostic detail.
childout = open(os.path.join(parent, prefix + '.out'), 'w+')
childerr = open(os.path.join(parent, prefix + '.err'), 'w+')
subprocess.call(['../../bin/sqlcmd'],
stdin=childin, stdout=childout, stderr=childerr)
# TODO launch a hard-coded script that verifies a clean database and healthy server
# ("show tables" or equivalent) after each test run to prevent cross-contamination.
# fuzz the sqlcmd output for reliable comparison
clean_output(parent, prefix + '.out')
clean_output(parent, prefix + '.err')
baseparent = replace_parent_dir_prefix(parent, options.script_dir, options.baseline_dir)
if compare_cleaned_to_baseline(parent, baseparent,
prefix + '.out', inpath,
options.refresh, reportout):
haddiffs = True;
if compare_cleaned_to_baseline(parent, baseparent,
prefix + '.err', inpath,
options.refresh, reportout):
haddiffs = True;
finally:
kill_voltdb()
print "Summary report written to file://" + os.path.abspath(options.report_file)
# Would it be useful to dump the report file content to stdout?
# Except in refresh mode, any diffs change the scripts exit code to fail ant/jenkins
if haddiffs:
sys.exit("One or more sqlcmdtest script failures or errors was detected.")
def main():
root_logger = logging.Logger("hang_analyzer", level=logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
handler.setFormatter(logging.Formatter(fmt="%(message)s"))
root_logger.addHandler(handler)
root_logger.info("Python Version: %s" % sys.version)
root_logger.info("OS: %s" % platform.platform())
try:
if _is_windows or sys.platform == "cygwin":
distro = platform.win32_ver()
root_logger.info("Windows Distribution: %s" % str(distro))
else:
distro = platform.linux_distribution()
root_logger.info("Linux Distribution: %s" % str(distro))
except AttributeError:
root_logger.warning("Cannot determine Linux distro since Python is too old")
try:
uid = os.getuid()
root_logger.info("Current User: %s" % str(uid))
current_login = os.getlogin()
root_logger.info("Current Login: %s" % current_login)
except OSError:
root_logger.warning("Cannot determine Unix Current Login")
except AttributeError:
root_logger.warning("Cannot determine Unix Current Login, not supported on Windows")
interesting_processes = ["mongo", "mongod", "mongos", "_test", "dbtest", "python", "java"]
go_processes = []
process_ids = []
parser = OptionParser(description=__doc__)
parser.add_option('-m', '--process-match',
dest='process_match',
choices=['contains', 'exact'],
default='contains',
help="Type of match for process names (-p & -g), specify 'contains', or"
" 'exact'. Note that the process name match performs the following"
" conversions: change all process names to lowecase, strip off the file"
" extension, like '.exe' on Windows. Default is 'contains'.")
parser.add_option('-p', '--process-names',
dest='process_names',
help='Comma separated list of process names to analyze')
parser.add_option('-g', '--go-process-names',
dest='go_process_names',
help='Comma separated list of go process names to analyze')
parser.add_option('-d', '--process-ids',
dest='process_ids',
default=None,
help='Comma separated list of process ids (PID) to analyze, overrides -p &'
' -g')
parser.add_option('-c', '--dump-core',
dest='dump_core',
action="store_true",
default=False,
help='Dump core file for each analyzed process')
parser.add_option('-s', '--max-core-dumps-size',
dest='max_core_dumps_size',
default=10000,
help='Maximum total size of core dumps to keep in megabytes')
parser.add_option('-o', '--debugger-output',
dest='debugger_output',
action="append",
choices=['file', 'stdout'],
default=None,
help="If 'stdout', then the debugger's output is written to the Python"
" process's stdout. If 'file', then the debugger's output is written"
" to a file named debugger_<process>_<pid>.log for each process it"
" attaches to. This option can be specified multiple times on the"
" command line to have the debugger's output written to multiple"
" locations. By default, the debugger's output is written only to the"
" Python process's stdout.")
(options, args) = parser.parse_args()
if options.debugger_output is None:
options.debugger_output = ['stdout']
if options.process_ids is not None:
# process_ids is an int list of PIDs
process_ids = [int(pid) for pid in options.process_ids.split(',')]
if options.process_names is not None:
interesting_processes = options.process_names.split(',')
if options.go_process_names is not None:
go_processes = options.go_process_names.split(',')
interesting_processes += go_processes
[ps, dbg, jstack] = get_hang_analyzers()
if ps is None or (dbg is None and jstack is None):
root_logger.warning("hang_analyzer.py: Unsupported platform: %s" % (sys.platform))
exit(1)
all_processes = ps.dump_processes(root_logger)
# Canonicalize the process names to lowercase to handle cases where the name of the Python
# process is /System/Library/.../Python on OS X and -p python is specified to hang_analyzer.py.
all_processes = [(pid, process_name.lower()) for (pid, process_name) in all_processes]
# Find all running interesting processes:
# If a list of process_ids is supplied, match on that.
# Otherwise, do a substring match on interesting_processes.
if process_ids:
processes = [(pid, pname) for (pid, pname) in all_processes
if pid in process_ids and pid != os.getpid()]
running_pids = set([pid for (pid, pname) in all_processes])
missing_pids = set(process_ids) - running_pids
if missing_pids:
root_logger.warning("The following requested process ids are not running %s" %
list(missing_pids))
else:
processes = [(pid, pname) for (pid, pname) in all_processes
if pname_match(options.process_match, pname, interesting_processes) and
pid != os.getpid()]
root_logger.info("Found %d interesting processes %s" % (len(processes), processes))
max_dump_size_bytes = int(options.max_core_dumps_size) * 1024 * 1024
# Dump all other processes including go programs, except python & java.
for (pid, process_name) in [(p, pn) for (p, pn) in processes
if not re.match("^(java|python)", pn)]:
process_logger = get_process_logger(options.debugger_output, pid, process_name)
dbg.dump_info(
root_logger,
process_logger,
pid,
process_name,
options.dump_core and check_dump_quota(max_dump_size_bytes, dbg.get_dump_ext()))
# Dump java processes using jstack.
for (pid, process_name) in [(p, pn) for (p, pn) in processes if pn.startswith("java")]:
process_logger = get_process_logger(options.debugger_output, pid, process_name)
jstack.dump_info(root_logger, process_logger, pid, process_name)
# Signal go processes to ensure they print out stack traces, and die on POSIX OSes.
# On Windows, this will simply kill the process since python emulates SIGABRT as
# TerminateProcess.
# Note: The stacktrace output may be captured elsewhere (i.e. resmoke).
for (pid, process_name) in [(p, pn) for (p, pn) in processes if pn in go_processes]:
root_logger.info("Sending signal SIGABRT to go process %s with PID %d" %
(process_name, pid))
signal_process(root_logger, pid, signal.SIGABRT)
# Dump python processes by signalling them.
for (pid, process_name) in [(p, pn) for (p, pn) in processes if pn.startswith("python")]:
# On Windows, we set up an event object to wait on a signal. For Cygwin, we register
# a signal handler to wait for the signal since it supports POSIX signals.
if _is_windows:
root_logger.info("Calling SetEvent to signal python process %s with PID %d" %
(process_name, pid))
signal_event_object(root_logger, pid)
else:
root_logger.info("Sending signal SIGUSR1 to python process %s with PID %d" %
(process_name, pid))
signal_process(root_logger, pid, signal.SIGUSR1)
root_logger.info("Done analyzing all processes for hangs")
def main(argv):
global OPTIONS
script_path = os.path.abspath(__file__)
script_dir = os.path.dirname(script_path)
# OBJDIR is a standalone SpiderMonkey build directory. This is where we
# find the SpiderMonkey shared library to link against.
#
# The [TESTS] optional arguments are paths of test files relative
# to the jit-test/tests directory.
from optparse import OptionParser
op = OptionParser(usage="%prog [options] OBJDIR [TESTS...]")
op.add_option(
"-s",
"--show-cmd",
dest="show_cmd",
action="store_true",
help="show GDB shell command run",
)
op.add_option(
"-o",
"--show-output",
dest="show_output",
action="store_true",
help="show output from GDB",
)
op.add_option(
"-x",
"--exclude",
dest="exclude",
action="append",
help="exclude given test dir or path",
)
op.add_option(
"-t",
"--timeout",
dest="timeout",
type=float,
default=150.0,
help="set test timeout in seconds",
)
op.add_option(
"-j",
"--worker-count",
dest="workercount",
type=int,
help="Run [WORKERCOUNT] tests at a time",
)
op.add_option(
"--no-progress",
dest="hide_progress",
action="store_true",
help="hide progress bar",
)
op.add_option(
"--worklist",
dest="worklist",
metavar="FILE",
help="Read tests to run from [FILE] (or run all if [FILE] not found);\n"
"write failures back to [FILE]",
)
op.add_option(
"-r",
"--read-tests",
dest="read_tests",
metavar="FILE",
help="Run test files listed in [FILE]",
)
op.add_option(
"-w",
"--write-failures",
dest="write_failures",
metavar="FILE",
help="Write failing tests to [FILE]",
)
op.add_option(
"--write-failure-output",
dest="write_failure_output",
action="store_true",
help="With --write-failures=FILE, additionally write the output of failed "
"tests to [FILE]",
)
op.add_option(
"--gdb",
dest="gdb_executable",
metavar="EXECUTABLE",
default="gdb",
help="Run tests with [EXECUTABLE], rather than plain 'gdb'.",
)
op.add_option(
"--srcdir",
dest="srcdir",
default=os.path.abspath(os.path.join(script_dir, "..")),
help="Use SpiderMonkey sources in [SRCDIR].",
)
op.add_option(
"--testdir",
dest="testdir",
default=os.path.join(script_dir, "tests"),
help="Find tests in [TESTDIR].",
)
op.add_option(
"--builddir", dest="builddir", help="Build test executable from [BUILDDIR]."
)
op.add_option("--bindir", dest="bindir", help="Run test executable from [BINDIR].")
(OPTIONS, args) = op.parse_args(argv)
if len(args) < 1:
op.error("missing OBJDIR argument")
OPTIONS.objdir = os.path.abspath(args[0])
test_args = args[1:]
if not OPTIONS.workercount:
OPTIONS.workercount = get_cpu_count()
# Compute defaults for OPTIONS.builddir and OPTIONS.bindir now, since we've
# computed OPTIONS.objdir.
if not OPTIONS.builddir:
OPTIONS.builddir = os.path.join(OPTIONS.objdir, "js", "src", "gdb")
if not OPTIONS.bindir:
OPTIONS.bindir = os.path.join(OPTIONS.objdir, "dist", "bin")
test_set = set()
# All the various sources of test names accumulate.
if test_args:
for arg in test_args:
test_set.update(find_tests(OPTIONS.testdir, arg))
if OPTIONS.worklist:
try:
with open(OPTIONS.worklist) as f:
for line in f:
test_set.update(os.path.join(OPTIONS.testdir, line.strip("\n")))
except IOError:
# With worklist, a missing file means to start the process with
# the complete list of tests.
sys.stderr.write(
"Couldn't read worklist file '%s'; running all tests\n"
% (OPTIONS.worklist,)
)
test_set = set(find_tests(OPTIONS.testdir))
if OPTIONS.read_tests:
try:
with open(OPTIONS.read_tests) as f:
for line in f:
test_set.update(os.path.join(OPTIONS.testdir, line.strip("\n")))
except IOError as err:
sys.stderr.write(
"Error trying to read test file '%s': %s\n" % (OPTIONS.read_tests, err)
)
sys.exit(1)
# If none of the above options were passed, and no tests were listed
# explicitly, use the complete set.
if not test_args and not OPTIONS.worklist and not OPTIONS.read_tests:
test_set = set(find_tests(OPTIONS.testdir))
if OPTIONS.exclude:
exclude_set = set()
for exclude in OPTIONS.exclude:
exclude_set.update(find_tests(OPTIONS.testdir, exclude))
test_set -= exclude_set
if not test_set:
sys.stderr.write("No tests found matching command line arguments.\n")
sys.exit(1)
summary = Summary(len(test_set))
test_list = [Test(_, summary) for _ in sorted(test_set)]
# Build the test executable from all the .cpp files found in the test
# directory tree.
try:
build_test_exec(OPTIONS.builddir)
except subprocess.CalledProcessError as err:
sys.stderr.write("Error building test executable: %s\n" % (err,))
sys.exit(1)
# Run the tests.
try:
summary.start()
run_tests(test_list, summary)
summary.finish()
except OSError as err:
sys.stderr.write("Error running tests: %s\n" % (err,))
sys.exit(1)
sys.exit(0)
sys.path.insert(0, LIB_DIR)
try:
from twisted.internet import epollreactor
epollreactor.install()
except ImportError:
pass
from twisted.internet import stdio, reactor, defer
from twisted.protocols.basic import LineReceiver
from carbon.routers import ConsistentHashingRouter, RelayRulesRouter
from carbon.client import CarbonClientManager
from carbon import log, events
option_parser = OptionParser(usage="%prog [options] <host:port:instance> <host:port:instance> ...")
option_parser.add_option('--debug', action='store_true', help="Log debug info to stdout")
option_parser.add_option('--keyfunc', help="Use a custom key function (path/to/module.py:myFunc)")
option_parser.add_option('--replication', type='int', default=1, help='Replication factor')
option_parser.add_option('--routing', default='consistent-hashing',
help='Routing method: "consistent-hashing" (default) or "relay"')
option_parser.add_option('--relayrules', default=default_relayrules,
help='relay-rules.conf file to use for relay routing')
options, args = option_parser.parse_args()
if not args:
print 'At least one host:port destination required\n'
option_parser.print_usage()
raise SystemExit(1)
def main() :
try:
print "Autoscale Cleanup Script started"
parser = OptionParser()
parser.add_option("-r", "--region", action="store", type="string", dest="region", help="aws region" )
parser.add_option("-a", "--autoscale_group", action="store", type="string", dest="autoscale_group", help="bigip autoscale group name" )
parser.add_option("-s", "--s3bucket", action="store", type="string", dest="s3_bucket", help="s3bucket" )
parser.add_option("--aws_access_key", action="store", type="string", dest="aws_access_key", help="aws_access_key" )
parser.add_option("--aws_secret_key", action="store", type="string", dest="aws_secret_key", help="aws_secret_key" )
parser.add_option("-l", "--debug_logging", action="store", type="string", dest="debug_logging", default=False, help="debug logging: True or False" )
(options, args) = parser.parse_args()
debug_logging = False
#setEnvironmentVariables()
if options.debug_logging == "True":
debug_logging = True
# OVERRIDE
if options.aws_access_key:
#print "AWS Keys are Passed as Args"
aws_access_key = options.aws_access_key
aws_secret_key = options.aws_secret_key
elif 'AWS_ACCESS_KEY_ID' in os.environ:
#print "Getting Keys from Environment Vars"
aws_access_key = os.environ["AWS_ACCESS_KEY_ID"]
aws_secret_key = os.environ["AWS_SECRET_ACCESS_KEY"]
else:
aws_access_key = None
aws_secret_key = None
if debug_logging == True:
print "Boto relying on credentials from default ~/.aws/credentials"
region = options.region
asg_name = options.autoscale_group
s3_bucket_name = options.s3_bucket
if aws_access_key and aws_secret_key:
# Override boto creds with ones passed in
# Create ASG client
try:
asg_client = boto3.client('autoscaling', region_name=region, aws_access_key_id=aws_access_key, aws_secret_access_key=aws_secret_key ) # Create Autoscale client
except botocore.exceptions.ClientError as e:
print e
sys.exit("Exiting...")
# Create EC2 client
try:
s3_client = boto3.client('s3', region_name=region, aws_access_key_id=aws_access_key, aws_secret_access_key=aws_secret_key ) # Create Autoscale client
except botocore.exceptions.ClientError as e:
print e
sys.exit("Exiting...")
else:
# Try using ~/.aws/credentials
# Create ASG client
try:
asg_client = boto3.client('autoscaling', region_name=region ) # Create Autoscale client
except botocore.exceptions.ClientError as e:
print e
sys.exit("Exiting...")
# Create EC2 client
try:
s3_client = boto3.client('s3', region_name=region ) # Create Autoscale client
except botocore.exceptions.ClientError as e:
print e
sys.exit("Exiting...")
#autoscaling = boto3.client('autoscaling')
#s3_client = boto3.client('s3')
s3 = boto3.resource('s3')
ec2 = boto3.resource('ec2')
instances = []
asg = ""
# Removing Scale-In protection from Master
for instance in asg_client.describe_auto_scaling_instances()['AutoScalingInstances']:
if asg_name == instance['AutoScalingGroupName']:
instances.append( instance['InstanceId'])
asg = instance['AutoScalingGroupName']
if instances:
print 'Auto Scale: Removing Scale-In protection from Master: ',instances
asg_client.set_instance_protection(
InstanceIds = instances,
AutoScalingGroupName=asg,
ProtectedFromScaleIn=False
)
# Delete S3 Bucket
buckets = s3_client.list_buckets()['Buckets']
for bucket in buckets:
if s3_bucket_name == bucket['Name']:
print 'S3: deleting S3 bucket: ',bucket['Name']
b = s3.Bucket(bucket['Name'])
b.objects.all().delete()
b.delete()
print "Autoscale Cleanup Script Finished"
except Exception, ex:
print "An exception of type " + type(ex).__name__ + \
" with message " + str(sys.exc_info()[1])
file_name.replace(
"{0}{1}{2}".format(
self.extract_dir,
"integrations-extras",
sep,
),
"https://github.com/DataDog/integrations-extras/blob/master/",
)
)
return dependencies
if __name__ == "__main__":
parser = OptionParser(
usage="usage: %prog [options] link_type"
)
parser.add_option(
"-t",
"--token",
help="github access token",
default=None,
)
parser.add_option(
"-s",
"--source",
help="location of src files",
default=curdir,
)
options, args = parser.parse_args()
def main(argv):
parser = OptionParser(usage='Usage: %prog [-v] [-i ignorepath]* [path]')
parser.add_option('-v',
'--verbose',
dest='verbose',
default=False,
action='store_true')
parser.add_option('-i',
'--ignore-path',
dest='ignored_paths',
default=[],
action='append')
options, args = parser.parse_args(argv[1:])
if len(args) == 0:
path = '.'
elif len(args) == 1:
path = args[0]
else:
print args
parser.error('No more then one path supported')
verbose = options.verbose
ignored_paths = set(abspath(p) for p in options.ignored_paths)
num = 0
out = cStringIO.StringIO()
for root, dirs, files in os.walk(path):
for vcs_dir in ['.svn', '.hg', '.git']:
if vcs_dir in dirs:
dirs.remove(vcs_dir)
if abspath(root) in ignored_paths:
del dirs[:]
continue
in_check_pkg = root.startswith('./sphinx')
for fn in files:
fn = join(root, fn)
if fn[:2] == './': fn = fn[2:]
if abspath(fn) in ignored_paths:
continue
ext = splitext(fn)[1]
checkerlist = checkers.get(ext, None)
if not checkerlist:
continue
if verbose:
print "Checking %s..." % fn
try:
f = open(fn, 'rb')
try:
lines = list(f)
finally:
f.close()
except (IOError, OSError), err:
print "%s: cannot open: %s" % (fn, err)
num += 1
continue
for checker in checkerlist:
if not in_check_pkg and checker.only_pkg:
continue
for lno, msg in checker(fn, lines):
print >> out, "%s:%d: %s" % (fn, lno, msg)
num += 1
executable="/bin/bash",
stdout=subprocess.PIPE,
stderr=subprocess.PIPE);
jobcreated.wait()
out, err = jobcreated.communicate()
errcode = jobcreated.returncode;
if(errcode != 0): #has finished but wrong code
print "Job failed "+cjob+" failed";
sys.exit(1);
return out;
parser = OptionParser("$prog [options]")
#parser.add_option("-t", "--theta", dest="theta", help="Theta, default is 20", default=20, type="float");
parser.add_option("-s", "--timesplit", dest="timesplit", help="Split time in 2N_0 generations, default is 0.1", default=0.10, type="float");
parser.add_option("-f", "--destfolder", dest="destfolder", help="Output folder", default=None, type="string");
parser.add_option("-n", "--numsim", dest="numsim", help="Number of simulations, default is 100", default=100, type="int");
parser.add_option("" , "--branchl", dest="branchlscale", help="Seq-gen branch scale, default is 0.00045", default=0.00045, type="float");
parser.add_option("" , "--chrlen", dest="lengthchr", help="Chromosome length, default is 10kb", default=10000, type="int");
parser.add_option("-c", "--numcont", dest="numcont", help="Number of present-day human contaminants, default is 2", default=2, type="int")
parser.add_option("-e", "--numendo", dest="numendo", help="Number of ancient endogenous, default is 2", default=2, type="int")
#print handle_job("which ls");
sys.stderr.write('This file cannot be loaded as a module!')
sys.exit(1)
# script directory
script_dir = os.path.dirname(__file__)
# JCEF root directory
jcef_dir = os.path.abspath(os.path.join(script_dir, os.pardir))
# parse command-line options
disc = """
This utility creates the version header file.
"""
parser = OptionParser(description=disc)
parser.add_option('--header', dest='header', metavar='FILE',
help='output version header file [required]')
parser.add_option('--cef-path', dest='cefpath',
help='path to the CEF binary distribution [required]')
parser.add_option('-q', '--quiet',
action='store_true', dest='quiet', default=False,
help='do not output detailed status information')
(options, args) = parser.parse_args()
# the header option is required
if options.header is None or options.cefpath is None:
parser.print_help(sys.stdout)
sys.exit(1)
def write_svn_header(header):
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==* """
import os
import sys
import glob
import subprocess
from optparse import OptionParser
if __name__ == '__main__':
parser = OptionParser(usage="usage: %prog [options]")
parser.add_option("-q", "--quiet", dest="verbose", default=True, action="store_false", help="Don't print status messages")
parser.add_option("-r", "--render", dest="render", default=False, action="store_true", help="Perform SVG Render to images")
parser.add_option("-p", "--package", dest="package", default=False, action="store_true", help="Perform packaging into resource container")
parser.add_option("-z", "--pngcrush", dest="pngcrush", type="string", help="Perform PNGCrush optimization on PNG resources")
parser.add_option("-b", "--brute", dest="brute", default=False, action="store_true", help="Allow brute-force optimization")
parser.add_option("-w", "--workpath", dest="workpath", default=".", help="Sets working output path for image renders")
parser.add_option("-o", "--outpath", dest="outpath", default=".", help="Sets output path for resource container")
parser.add_option("-i", "--inpath", dest="inpath", default=".", help="Sets input path for files to add to resource file")
(options, args) = parser.parse_args()
## Send output to OS's null if unwanted
if not options.verbose:
sys.stdout = open(os.devnull,"w")
sys.stderr = open(os.devnull,"w")
def main():
usage = 'usage: %prog vpc_gene_exprs_file '\
'beltran_t_test_file output_file\n'\
'Requires four input arguments:\n'\
'1) Text file of VPC cohort gene exprs\n'\
'2) Text file of Beltran cohort gene exprs\n'\
'3) Text file containing exprs of 2 samples/groups for fold change\n'\
'4) Output file.\n'
parser = OptionParser(usage=usage)
parser.add_option('--pval_colname',
dest='pval_colname',
default='pval',
help='Column name containing pvals. Default "pval".')
parser.add_option('--gene_colname',
dest='gene_colname',
default='gene',
help='Column name containing pvals. Default "gene".')
parser.add_option('--group1_colname', dest='group1_colname',
default='group1',
help='Column name containing group1 exprs values. '\
'Default "group1".')
parser.add_option('--group2_colname', dest='group2_colname',
default='group2',
help='Column name containing group2 exprs values. '\
'Default "group2".')
parser.add_option('--group1_fc_colname', dest='group1_fc_colname',
default='LTL331',
help='Column name of group1 exprs values in FC file. '\
'Default: "LTL331"')
parser.add_option('--group2_fc_colname', dest='group2_fc_colname',
default='LTL331_R',
help='Column name of group1 exprs values in FC file. '\
'Default: "LTL331_R"')
parser.add_option('--fc_gene_colname', dest='fc_gene_colname',
default='gene_name',
help='Column name of gene names in FC file. '\
'Default: "gene_name"')
(options, args) = parser.parse_args()
if len(args) < 4:
print 'Four arguments need to be specified in command line.\n'
print usage
sys.exit()
vpc_filepath = args[0]
beltran_filepath = args[1]
fold_change_filepath = args[2]
output_filepath = args[3]
group1_colname = options.group1_colname
group2_colname = options.group2_colname
pval_colname = options.pval_colname
gene_colname = options.gene_colname
group1_fc_colname = options.group1_fc_colname
group2_fc_colname = options.group2_fc_colname
gene_fc_colname = options.fc_gene_colname
# store pvals to a dic.
pval_fc_dic = {}
for cohort, filepath in zip(['vpc', 'beltran'],
[vpc_filepath, beltran_filepath]):
pval_fc_subdic = get_pvals_fc_from_file(filepath, group1_colname,
group2_colname, gene_colname,
pval_colname)
pval_fc_dic[cohort] = pval_fc_subdic
# Add fold change to dic
pval_fc_subdic = get_fc_from_file(fold_change_filepath, group1_fc_colname,
group2_fc_colname, gene_fc_colname)
pval_fc_dic['foldchange'] = pval_fc_subdic
# Write dic to file
write_outdic_to_file(pval_fc_dic, output_filepath, shape='long')
"""Returns the http url with password part replaced with '*'.
:param url: URL to upload the plugin to.
:type url: str
:param start: Position of start of password.
:type start: int
"""
start_position = url.find(':', start) + 1
end_position = url.find('@')
return "%s%s%s" % (url[:start_position], '*' *
(end_position - start_position), url[end_position:])
if __name__ == "__main__":
parser = OptionParser(usage="%prog [options] plugin.zip")
parser.add_option("-w",
"--password",
dest="password",
help="Password for plugin site",
metavar="******")
parser.add_option("-u",
"--username",
dest="username",
help="Username of plugin site",
metavar="user")
parser.add_option("-p",
"--port",
dest="port",
help="Server port to connect to",
metavar="80")
# Debug level
debugLevel = 0
# Number of option arguments.
numOpts = len(sys.argv)
# Usage message
usage = u'''`Usage: %prog [options...] [seqFile]'''
description = u'''\
Calculates statistics of protein properties.\
'''
epilog = u'''For further information about the EMBOSS pepstats web service, see
http://www.ebi.ac.uk/tools/webservices/services/seqstats/emboss_pepstats_rest.'''
version = u'98c6601'
# Process command-line options
parser = OptionParser(usage=usage, description=description, epilog=epilog, version=version)
# Tool specific options (Try to print all the commands automatically)
parser.add_option('--sequence', help='The sequence to be analysed can be entered directly into this form.\
The sequence can be in GCG, FASTA, PIR, NBRF, PHYLIP or UniProtKB/Swiss-Prot format.\
Partially formatted sequences are not accepted..\
')
parser.add_option('--termini', help='Include charges from the N-terminus and C-terminus when calculating the Isoelectric Point')
parser.add_option('--mono', help='Use weight from the most abundant (prinicpal) isotope of each amino acid when calculating molecular weights. By default this is not enabled, so the average isotope weight is used instead.')
# General options
parser.add_option('--email', help='e-mail address')
parser.add_option('--title', help='job title')
parser.add_option('--outfile', help='file name for results')
parser.add_option('--outformat', help='output format for results')
parser.add_option('--async', action='store_true', help='asynchronous mode')
import math as math
import os
import CMS_lumi, tdrstyle
gSystem.Load("%s/lib/slc6_amd64_gcc481/libHiggsAnalysisCombinedLimit.so"%os.environ["CMSSW_BASE"])
gSystem.Load("PDFs/PdfDiagonalizer_cc.so")
gSystem.Load("PDFs/Util_cxx.so")
gSystem.Load("PDFs/hyperg_2F1_c.so")
gSystem.Load("PDFs/HWWLVJRooPdfs_cxx.so")
from ROOT import draw_error_band
from ROOT import RooPoly3Pdf, RooChiSqPdf, RooErfExpPdf, RooErfPowExpPdf, RooErfPowPdf, RooErfPow2Pdf, RooExpNPdf, RooAlpha4ExpNPdf, RooExpTailPdf, RooAlpha4ExpTailPdf, Roo2ExpPdf, draw_error_band_extendPdf
gStyle.SetOptStat(0)
gStyle.SetOptTitle(0)
parser = OptionParser()
parser.add_option('--POI',dest='POI',help='parameter of interest')
parser.add_option('--pval',dest='pval',help='value of parameter')
parser.add_option('-c',action='store_true',dest='close',default=False)
(options,args) = parser.parse_args()
POI = options.POI
pval = options.pval
par_latex = {'cwww' : 'c_{WWW} / #Lambda^{2} (TeV^{-2})', 'ccw' : 'c_{W} / #Lambda^{2} (TeV^{-2})', 'cb' : 'c_{B} / #Lambda^{2} (TeV^{-2})', 'lZ' : '#lambda_{Z}', 'dg1z' : '#Deltag_{1}^{Z}', 'dkz' : '#Delta#kappa_{Z}'}
par_noUnits = {'cwww' : 'c_{WWW} / #Lambda^{2}', 'ccw' : 'c_{W} / #Lambda^{2}', 'cb' : 'c_{B} / #Lambda^{2}', 'lZ' : '#lambda_{Z}', 'dg1z' : '#Deltag_{1}^{Z}', 'dkz' : '#Delta#kappa_{Z}'}
def plots():
path = './'
wsNameExp = 'higgsCombine_%s_%s.MultiDimFit.mH120.root'%(POI,pval)
print 'Reading '+wsNameExp
else:
print 'error: syntax of line: ' + l
return modules
def get_collapsed(modules):
collapsed = networkx.MultiDiGraph()
collapsed.add_nodes_from(modules.nodes())
for e in modules.edges():
if not e in collapsed.edges():
collapsed.add_edge(e[0], e[1])
return collapsed
if __name__ == '__main__':
parser = OptionParser(usage='Usage: %prog [options] mapfile out.dot')
parser.set_defaults(exclude_modules=[])
parser.add_option(
'-x',
'--exclude-modules',
action='append',
dest='exclude_modules',
metavar='FILTER',
help=
'ignore modules that match FILTER, expressed as a regular expression.')
parser.add_option(
'-e',
'--entry',
dest='entry',
metavar='ENTRY',
help=
