def main():
import sys
import os
h = 6.6260689633e-34
c = 299792458
electron = 1.60217653141e-19
def toenergy(wave):
energy = (h*c)/(float(wave)*1e-10*electron)
return energy
def towave(energy):
wave = (h*c)/(float(energy)*electron)
return wave
from optparse import OptionParser
parser = OptionParser()
parser.add_option("--energy","-e",dest="energy",metavar="energy ev",help="Energy in ev")
parser.add_option("--wave","-w",dest="wave",metavar="wave A",help="wavelenbth in Angstrom")
(options,spillover) = parser.parse_args()
if options.energy is not None:
energy = options.energy
wave = towave(energy)
print "The input %s energy in ev corresponds to %s wavelength" % ( energy , wave)
elif options.wave is not None:
wave = sys.argv[2]
energy = toenergy(wave)
print "The input %s wavelength corressponds to %s ev " % (wave,energy)
else:
parser.print_help()
exit()
def parseOptions():
#setup command line parser
'''This is out of date, needs to be updated to reflect new additions'''
parser = op.OptionParser(
usage="Usage: %prog [options] XMLFILE",
version="%prog 1.0",
description=r"Reads in the XMLFILE which specifies " +
"how the light curve is to be made. see light_curve_reference.xml for a "
+
"template xml file to be used with this script. Found in the SPHERLS "
+ "directory docs/templateXML.")
parser.add_option(
"--write-diagnostics",
dest="writeDiagnostics",
action="store_true",
help=
"If set it will write out Logg,g,accel,T_eff,BC to the output file in"
+
" that order in addition to the time and mag in the first and second "
+ "columns",
default=False)
parser.add_option(
"-d",
dest="double",
action="store_true",
help="If set it will double the data in the light curve for easier " +
"viewing of the light curve shape.",
default=False)
make_profiles.addParserOptions(parser)
#parse command line options
return parser.parse_args()
def main():
parser = optparse.OptionParser(usage='Usage: %prog [options] filename')
parser.add_option('-s', '--source', dest='source', default=DEFAULT_SOURCE,
help='Source path. Default: ' + DEFAULT_SOURCE)
parser.add_option('-d', '--destination', dest='destination',
default=DEFAULT_DESTINATION,
help='Destination path. Default: ' + DEFAULT_DESTINATION)
(options, args) = parser.parse_args()
process(options.source, options.destination)
def options(self, parser, env):
super(FreshenNosePlugin, self).options(parser, env)
parser.add_option('--tags', action='store',
dest='tags',
default=env.get('NOSE_FRESHEN_TAGS'),
help="Run only those scenarios and features which "
"match the given tags. Should be a comma-separated "
"list. Each tag can be prefixed with a ~ to negate "
"[NOSE_FRESHEN_TAGS]")
def main():
global verbose
global ssl_location
global revocation
if int(os.getuid()) > 0:
print "[-] You need to be root for this."
sys.exit(1)
# command line options
parser = OptionParser()
parser.add_option("-a",
help="Adapter to sniff on",
action="store",
default="eth0",
dest="adapter")
parser.add_option('-v',
help="Dump certificate information",
action="store_true",
default=False,
dest="verbose")
parser.add_option('-s',
help="Specify a different SSL cert location",
action="store",
default='/etc/ssl/certs',
dest='certFile')
parser.add_option('-p',
help="Specify a port (default: 443)",
action="store",
default=443,
dest="port")
parser.add_option('-r',
help="Specify a CRL file for lookup; give full path",
action="store",
default=None,
dest="revocation")
(options, args) = parser.parse_args()
adapter = options.adapter
verbose = options.verbose
port = options.port
revocation = options.revocation
# validate the ssl cert folder
if os.path.isdir(options.certFile):
ssl_location = options.certFile
else:
ssl_location = '/etc/ssl/certs/'
try:
print "[+] Beginning sniffer on adapter '{0}' port {1}".format(
adapter, port)
sniff(filter="tcp and port %s" % port, iface=adapter, prn=validate)
except KeyboardInterrupt, k:
print "\n[!] Closing down..."
def read_option():
usage = "launch gp_job"
parser = optparse.OptionParser(usage=usage)
parser.add_option("--rep",
"-r",
dest="rep",
help="dir input/output",
default=100)
option, args = parser.parse_args()
return option
def option():
usage = "usage: %prog [options] arg"
parser = OptionParser(usage)
parser.add_option("-f",
"--file",
dest="filename",
help="file with download links")
parser.add_option("-t",
"--thread",
dest="thread_number",
help="How much files download in one time",
default=2)
parser.add_option("-k", "--key", dest="key", help="Key for premka")
parser.add_option("-d",
"--no-delete",
action="store_false",
dest="no_delete",
help="Dont delete exists links on premka",
default=True)
(options, args) = parser.parse_args()
if not options.filename:
parser.error('File name option is required')
if not options.key:
parser.error('Premka key is required')
return options
def read_option():
usage = "launch mcmc for shear fitting of des y1"
parser = optparse.OptionParser(usage=usage)
parser.add_option("--rep", "-r", dest="rep", help="dir output", default='')
parser.add_option("--nwalkers",
"-w",
dest="nwalkers",
help="number of walkers",
default='33')
parser.add_option("--nsteps",
"-n",
dest="nsteps",
help="number of steps",
default='2')
parser.add_option("--seed",
"-s",
dest="seed",
help="seed of the generator",
default='42')
option, args = parser.parse_args()
return option
def handle_user_params():
"""
Handles user parameters using python's built-in optparse module.
@rtype: dict
@return: The dictionary of the user parameters with the below elements,
- 'errorFile', default value is 'errors.json'
- 'inputFile', default value is 'quipsim.txt'
"""
parser = OptionParser('Usage: mcchp.py [options]')
parser.add_option("-e", "--error", dest="errorFile", default='sample_errors.json',
help="Specify a json file wit error rates (default = sample_errors.json)", metavar="FILE")
parser.add_option("-i", "--input", dest="inputFile", default='sample_input.txt',
help="Specify a QUIPSIM output file for the input circuit (default = sample_input.txt)",
metavar="FILE")
(options, args) = parser.parse_args()
return options
def parse_args():
"""parse_args parses sys.argv for wiki2centrality."""
# Help Menu
parser = optparse.OptionParser(usage='%prog [options] title')
parser.add_option('-r', '--remove',
action='store_false', dest='remove', default=True,
help='remove mass deletions')
parser.add_option('-c', '--centrality',
type='str', dest='ctype', default='closeness',
help='type of centrality: closeness, out_degree, betweenness',
metavar='CTYPE')
(opts, args) = parser.parse_args()
# Parser Errors
if len(args) != 1:
parser.error('incorrect number of arguments')
wiki2centrality(args[0], remove=opts.remove, ctype=opts.ctype)
def parseOptions():
#setup command line parser
parser = op.OptionParser(
usage="Usage: %prog [options] XMLFILE",
version="%prog 1.0",
description=r"Creates one or more HDF files. XMLFILE " +
"gives all the settings needed. For an example of a configuration file see"
+ " make_hdf_reference.xml under docs/templateXML.")
parser.add_option("-k",
"--keep",
action="store_true",
dest="keep",
help="Keeps distributed binary files [default].",
default=True)
parser.add_option("-r",
"--remove",
action="store_false",
dest="keep",
help="Removes distributed binary files")
parser.add_option(
"--remake-bins",
action="store_true",
dest="remakeBins",
help="Will remake binaries even if they already exist. [not default].",
default=False)
#parse command line options
(options, args) = parser.parse_args()
if len(args) == 0:
raise Exception("must supply an xml configure file")
return (options, args)
def main():
global verbose
global ssl_location
global revocation
if int(os.getuid()) > 0:
print "[-] You need to be root for this."
sys.exit(1)
# command line options
parser = OptionParser()
parser.add_option("-a", help="Adapter to sniff on", action="store", default="eth0", dest="adapter")
parser.add_option("-v", help="Dump certificate information", action="store_true", default=False, dest="verbose")
parser.add_option(
"-s", help="Specify a different SSL cert location", action="store", default="/etc/ssl/certs", dest="certFile"
)
parser.add_option("-p", help="Specify a port (default: 443)", action="store", default=443, dest="port")
parser.add_option(
"-r", help="Specify a CRL file for lookup; give full path", action="store", default=None, dest="revocation"
)
(options, args) = parser.parse_args()
adapter = options.adapter
verbose = options.verbose
port = options.port
revocation = options.revocation
# validate the ssl cert folder
if os.path.isdir(options.certFile):
ssl_location = options.certFile
else:
ssl_location = "/etc/ssl/certs/"
try:
print "[+] Beginning sniffer on adapter '{0}' port {1}".format(adapter, port)
sniff(filter="tcp and port %s" % port, iface=adapter, prn=validate)
except KeyboardInterrupt, k:
print "\n[!] Closing down..."
def main():
parser = OptionParser()
parser.set_usage(parser.get_usage().rstrip())
parser.add_option("-l", "-L", "--load", action="append_const", const="LOAD", dest="oper", help = "load data")
parser.add_option("-r", "-R", "--run", action="append_const", const="RUN", dest="oper", help = "run test")
parser.add_option("-c", "--configure-file", dest="configFile", type="string", default='run_blogbench.cfg'
, help = "path of configure file, default is 'run_blogbench.cfg'")
(options, args) = parser.parse_args()
testWorker = Tester()
testWorker.run(options.configFile, options.oper)
def _parse_args():
"""
Parses the command line arguments.
@return: Tuple with options and (positional) arguments.
@rtype: tuple
"""
parser = optparse.OptionParser(usage="", description="")
parser.add_option("-o", dest="outfile", default=None, help="File to write to")
parser.add_option("-w", dest="write_format", default="pidgin", help="Write format. [default: %default]")
parser.add_option("-r", dest="read_format", default="adium", help="Read format. [default: %default]")
return parser.parse_args()
if pn is None or not os.path.exists(pn):
return 0
return os.stat(pn).st_size
for fs in fsop.get_all_fs():
one = _get_merged_file(fs)
fss = _get_fss_file(fs)
print "%-10s %10s B %10s B" % (fs, _get_size(one), _get_size(fss))
if __name__ == '__main__':
utils.install_pdb()
parser = optparse.OptionParser()
parser.add_option("--linux", help="Linux kernel", default=LINUX)
parser.add_option("--clang", help="Clang path", default=CLANG)
parser.add_option("--outdir", help="Clang output dir", default="/tmp")
(opts, args) = parser.parse_args()
def __print_usage(note):
print(note)
for (cmd, func) in get_all_cmds():
print("> %-20s: %s" % (cmd, func.__doc__))
exit(0)
if len(args) == 0:
__print_usage("Need to specify a command")
cmd = args[0]
if get_cmd(cmd) is None:
import optparse
import parser
import zipfile
from threading import Thread
def extract_zip(zfile, password):
try:
zfile.extractall(pwd=password)
print("[+] Password found: " + password + '\n')
except:
pass
if __name__ == '__main__':
parser = optparse.OptionParser("usage %prog " + \
"-f <zipfile> -d <dicctionary>")
parser.add_option('-f', dest='zname', type='string', \
help='specify zip file')
parser.add_option('-d', dest='dname', type='string', \
help='specify dictionary file')
(options, arg) = parser.parse_args()
print('ell')
if (options.zname is None) or (options.dname is None):
print(parser.usage)
exit(0)
else:
zname = options.zname
dname = options.dname
def generate_parser():
usage = "%prog [options] source [dest]"
parser = OptionParser(usage=usage)
parser.add_option("-c", "--print-context", dest="p_context",
action="store_true", default=False,
help='print the outcome of the context analysis')
parser.add_option('--heapsize', dest="heapsize", action='store',
type='int', default=100, metavar='LONGWORDS',
help='set the size of the heap to x LONGWORDS (4 Byte)')
parser.add_option('--stacksize', dest='stacksize', action='store',
type='int', default=50, metavar='LONGWORDS',
help='set the size of the stack to x LONDWORDS (4 Byte)')
parser.add_option('-i', '--print-identifier', dest='p_identifier',
action='store_true', default=False, help='print the '
'identifier map')
parser.add_option('-I', '--print-lexical', dest='p_lexical',
action='store_true', default=False,
help='print the outcome of the lexical analysis')
parser.add_option('-s', '--print-syntax', dest='p_syntax',
action='store_true', default=False,
help='print the outcome of the syntax analysis')
return parser
def main():
import os
import json
import pickle
import re
from optparse import OptionParser
parser = OptionParser()
parser.add_option('-q',
'--ip-api',
dest='ip_api',
default='http://127.0.0.1:8080',
help='HTTP API to retrieve IP info.')
parser.add_option('-f',
'--file',
default='route.pickle',
help='Use the pickled routes')
parser.add_option('-u',
'--update',
action="store_true",
default=False,
help='Update routes')
parser.add_option('--source-network',
dest='source_network',
action='append',
help='Regex of source network pattern')
parser.add_option('--target-network',
dest='target_network',
action='append',
help='Regex of target network pattern')
(options, args) = parser.parse_args()
logging.basicConfig(
level=logging.INFO,
format=
'[%(levelname)1.1s %(asctime)s %(module)s:%(lineno)d] %(message)s')
if not args:
import explore
args = explore.targets
ip_parser = lambda ip: parse_ip(options.ip_api, ip)
source_network = []
for pattern in options.source_network:
logging.info('Using source pattern: ' + pattern)
source_network.append(re.compile(pattern, re.IGNORECASE))
target_network = []
for pattern in options.target_network:
logging.info('Using target pattern: ' + pattern)
target_network.append(re.compile(pattern, re.IGNORECASE))
routes = []
if not options.update:
try:
routes = pickle.load(open(options.file, 'rb'))
except Exception as e:
logging.error(e, exc_info=True)
if not routes:
logging.info("Fetching routes.")
for ip in args:
for route in get_routes(ip, ip_parser):
routes.append(route)
logging.info('Dumping routes into {}'.format(options.file))
tmp_filename = options.file + '.tmp'
tmp = open(tmp_filename, 'wb')
pickle.dump(routes, tmp, protocol=2)
os.rename(tmp_filename, options.file)
geo_json = GeoJSON()
for route in routes:
if not match(source_network, route[1]) or not match(
target_network, route[3]):
continue
geo_json.add_route(*route)
print(json.dumps(geo_json.to_object()))
import parser
from scorer import scorer
from collections import Counter
from sklearn.svm import SVC
from sklearn import cross_validation
from sklearn import grid_search
from stacking_create_training_set import stacking_create_training_set
import xml.etree.ElementTree as ET
#defining the options of the script
#INPUTS: -i duke_config.xml, -N number_of_configurations, -a amplitude_of_perturbation, -g gold_standard_name
parser = optparse.OptionParser()
parser.add_option('-i','--input', dest = 'file_name', help = 'file_name')
parser.add_option('-N','--number', dest = 'N', help = 'number of classifiers',type = int)
parser.add_option('-a','--amplitude', dest = 'a', help = 'amplitude of perturbation',type = float)
parser.add_option('-g','--gold', dest = 'gold_standard_name', help = 'gold_standard_name')
(options, args) = parser.parse_args()
if options.file_name is None:
options.file_name = raw_input('Enter file name:')
if options.N is None:
options.N = raw_input('Enter number of classifiers:')
if options.a is None:
options.a = 0.05 #default to 0.05
# Summe == 28 d.h. alle Kapitel haben Text
if sum == 28:
cmd = "update `%s`.`%s` " % (databaseList, table)
cmd += "set Apg = 1 where ms = %s " % (ms[0])
else:
cmd = "update `%s`.`%s` " % (databaseList, table)
cmd += "set Apg = 0 where ms = %s " % (ms[0])
cursor.execute(cmd)
cursor.close()
dba.close()
if __name__ == "__main__":
import sys
from optparse import OptionParser
parser = OptionParser()
parser.add_option("-r", "--recreate", dest="recreate", action="store_true", help="Recreate ECM_Acts_Mss.ActsMsList_2")
parser.add_option("-d", "--database", dest="database", help="Database containing systematic lacunae list")
parser.add_option("-t", "--table", dest="table", help="Giving name systematic lacunae list")
parser.add_option("-v", "--verbose", dest="verbose", action="store_true", help="Verbose mode")
(opts, args) = parser.parse_args()
parser.destroy()
if opts.database is None:
print "Error: Database name is missing!"
print "See python %s -h" % sys.argv[0]
sys.exit(1)
if opts.table is None:
print "Error: Table name is missing!"
print "See python %s -h" % sys.argv[0]
sys.exit(1)
if opts.recreate is None:
main_8(opts.database, opts.table, opts.verbose)
def main(name, version, datatype):
log.info("------------- %s %s -----------------", name, version)
usage = """usage: python %prog [options] <foldername>
PartitionFinder and PartitionFinderProtein are designed to discover optimal
partitioning schemes for nucleotide and amino acid sequence alignments.
They are also useful for finding the best model of sequence evolution for datasets.
The Input: <foldername>: the full path to a folder containing:
- A configuration file (partition_finder.cfg)
- A nucleotide/aa alignment in Phylip format
Take a look at the included 'example' folder for more details.
The Output: A file in the same directory as the .cfg file, named
'analysis' This file contains information on the best
partitioning scheme, and the best model for each partiiton
Usage Examples:
>python %prog example
Analyse what is in the 'example' sub-folder in the current folder.
>python %prog -v example
Analyse what is in the 'example' sub-folder in the current folder, but
show all the debug output
>python %prog -c ~/data/frogs
Check the configuration files in the folder data/frogs in the current
user's home folder.
>python %prog --force-restart ~/data/frogs
Deletes any data produced by the previous runs (which is in
~/data/frogs/output) and starts afresh
"""
parser = OptionParser(usage)
parser.add_option(
"-v", "--verbose",
action="store_true", dest="verbose",
help="show verbose (debug) output")
parser.add_option(
"-c", "--check-only",
action="store_true", dest="check_only",
help="just check the configuration files, don't do any processing")
parser.add_option(
"--force-restart",
action="store_true", dest="force_restart",
help="delete all previous output and start afresh (!)")
parser.add_option(
"-p", "--processes",
type="int", dest="processes", default=-1, metavar="N",
help="Number of concurrent processes to use."
" Use -1 to match the number of cpus on the machine."
" The default is to use -1.")
parser.add_option(
"--show-python-exceptions",
action="store_true", dest="show_python_exceptions",
help="If errors occur, print the python exceptions")
parser.add_option(
"--save-phyml",
action="store_true", dest="save_phyml",
help="save all of the phyml output. This can take a lot of space(!)")
parser.add_option(
"--dump-results",
action="store_true", dest="dump_results",
help="Dump all results to a binary file. "
"This is only of use for testing purposes.")
parser.add_option(
"--compare-results",
action="store_true", dest="compare_results",
help="Compare the results to previously dumped binary results. "
"This is only of use for testing purposes.")
options, args = parser.parse_args()
# Error checking
if options.dump_results and options.compare_results:
log.error("You can't dump and compare results in one run!")
log.error("Please select just one of these")
# We should have one argument: the folder to read the configuration from
if not args:
# Otherwise exit, printing the help
parser.print_help()
return 2
#before we start, let's check the python version is above 2.7 but lower than 3.0
python_version = float("%d.%d" %(sys.version_info[0], sys.version_info[1]))
log.info("You have Python version %.1f" %python_version)
if python_version<2.7:
log.error("Your Python version is %.1f, but this program requires Python 2.7. "
"Please upgrade to version 2.7 by visiting www.python.org/getit, or by following"
" the instructions in the PartitionFinder manual." % python_version)
return 0
if python_version>3.0:
log.warning("Your Python version is %.1f. This program was not built to run with "
"version 3 or higher. To guarantee success, please use Python 2.7.x" % python_version)
# Load, using the first argument as the folder
try:
cfg = config.Configuration(datatype)
cfg.load_base_path(args[0])
if options.check_only:
log.info("Exiting without processing (because of the -c/--check-only option ...")
else:
# For now, we just turn on debugging for the analysis section
# For finer grain, see the logging.cfg file
if options.verbose:
logging.getLogger('analysis').setLevel(logging.DEBUG)
logging.getLogger('analysis_method').setLevel(logging.DEBUG)
# Now try processing everything....
method = analysis_method.choose_method(cfg.search)
rpt = reporter.TextReporter(cfg)
anal = method(cfg, rpt,
options.force_restart,
options.save_phyml,
options.processes)
results = anal.analyse()
if options.dump_results:
results.dump(cfg)
elif options.compare_results:
results.compare(cfg)
# Successful exit
log.info("Processing complete.")
return 0
except util.PartitionFinderError:
log.error("Failed to run. See previous errors.")
if options.show_python_exceptions:
raise
except KeyboardInterrupt:
log.error("User interrupted the Program")
return 1
def parse_options(args=sys.argv):
parser = optparse.OptionParser()
#
# Global options.
#
parser.add_option('-l', '--loglevel', action='store', default='WARNING',
choices=['DEBUG', 'INFO', 'WARNING', 'ERROR'],
help="""Logging level. Choices: DEBUG, INFO, WARNING, ERROR.
[default: WARNING]""")
#
# Options for compilation (joosc).
#
stage_opts = [
'scanner',
'parser',
'weeder',
'ast',
'hierarchy',
'name',
'typecheck',
'reachability',
'codegen',
'asm',
'end'
]
parser.add_option('-s', '--stage', action='store', dest='stage',
default='end', choices=stage_opts,
help="Stage of compiler to run \"up to\" before terminating.")
parser.add_option('-i', '--include_stdlib', action='store_true',
default=False,
dest='include_stdlib', help="Include all stdlib files in compilation")
parser.add_option('--print_stdlib', action='store_true',
dest='print_stdlib',
help="""Override default hiding of output printout for stdlib files.
Only has any effect if -s and -i are specified.""")
parser.add_option('-d', '--directory_crawl', action='store_true',
dest='directory_crawl', default=True,
help="Recursively crawl directories for compilation units")
parser.add_option('-c', '--clean_output', action='store_true',
dest='clean_output', default=False,
help="Clean the output directory before codegen.")
#
# Options for testing.
#
parser.add_option('-t', '--test', action='store', dest='test',
help="Run tests under the specified directory under assignment_testcases.")
parser.add_option('--show_errors', action='store_true',
dest='show_errors',
help="Disable stderr printout suppression. Only usable during tests.")
return parser.parse_args()
if pn is None or not os.path.exists(pn):
return 0
return os.stat(pn).st_size
for fs in fsop.get_all_fs():
one = _get_merged_file(fs)
fss = _get_fss_file(fs)
print "%-10s %10s B %10s B" % (fs, _get_size(one), _get_size(fss))
if __name__ == '__main__':
utils.install_pdb()
parser = optparse.OptionParser()
parser.add_option("--linux", help="Linux kernel", default=LINUX)
parser.add_option("--clang", help="Clang path", default=CLANG)
parser.add_option("--outdir", help="Clang output dir", default="/tmp")
parser.add_option("--type", help="Juxta's analysis type: fs, ieee80211 ...etc", default=TYPE)
(opts, args) = parser.parse_args()
def __print_usage(note):
print(note)
for (cmd, func) in get_all_cmds():
print("> %-20s: %s" % (cmd, func.__doc__))
exit(0)
if len(args) == 0:
__print_usage("Need to specify a command")
extensions = {
'writer': '.ast',
'pascal': '.pas',
'java': '.java',
'python': '.py',
'scheme': '.scm',
'ada': '.ada',
}
usage = 'usage: %prog [options] ccfiles'
version = '%prog 1.0'
parser = optparse.OptionParser(usage=usage, version=version)
parser.add_option('-w',
'--writer',
action='store_true',
dest='writer',
default=False,
help='write the AST')
parser.add_option('-p',
'--pascal',
action='store_true',
dest='pascal',
default=False,
help='compile to Pascal')
parser.add_option('-j',
'--java',
action='store_true',
dest='java',
default=False,
help='compile to Java')
parser.add_option('-y',
interactive
game
on
a
smaller
board, zoomed in
"""
import parser
parser = OptionParser(usageStr)
parser.add_option('-n',
'--numGames',
dest='numGames',
type='int',
help=default('the number of GAMES to play'),
metavar='GAMES',
default=1)
parser.add_option(
'-l',
'--layout',
dest='layout',
help=default('the LAYOUT_FILE from which to load the map layout'),
metavar='LAYOUT_FILE',
default='mediumClassic')
parser.add_option(
'-p',
'--pacman',
dest='pacman',
help=default('the agent TYPE in the pacmanAgents module to use'),
from dirScan import *
from CIPscan import *
from optparse import OptionParser
if __name__ == '__main__':
print('''
By cteen Ver:1.0
__ __ _ __
/ / /\ \ \___| |__ / _\ ___ __ _ _ __ _ __ ___ _ __
\ \/ \/ / _ \ '_ \\ \ / __/ _` | '_ \| '_ \ / _ \ '__|
\ /\ / __/ |_) |\ \ (_| (_| | | | | | | | __/ |
\/ \/ \___|_.__/\__/\___\__,_|_| |_|_| |_|\___|_|
''')
parser = OptionParser()
parser.add_option("-u", "--url", dest="url", help="target url for scan")
parser.add_option("-f", "--file", dest="ext", help="target url ext")
parser.add_option("-i", "--ip", dest="ip", help="target ip for scan C")
parser.add_option("-t",
"--thread",
dest="count",
type="int",
default=1,
help="count of scan thread")
parser.add_option("-d",
"--domain",
dest="domain",
help="target domain for scan")
(option, args) = parser.parse_args()
if option.url and option.ext:
print("[+]Scan for %s will start ! Filetype is %s..." %
actions = {
'parseprint' : printParseTreeFromFile,
'astprint' : printAstFromFile,
'interp' : interpretFile
}
from optparse import OptionParser
parser = OptionParser(
usage="""
python %prog action [-o outputfile] pl0sourcefile
Action is one of
parseprint - parse and print the parse tree,
astprint - parse, generate the AST then print the AST,
interp - parse, generate the AST then interpret the AST""")
parser.add_option('-o', '--outputfile',
action='store',
dest='outputfile',
help='Output file.')
(options, args) = parser.parse_args()
if len(args) != 2:
parser.error('wrong number of arguments.')
action = args[0]
infile = args[1]
if action in ('parseprint', 'astprint', 'interp') and len(args) == 2:
if action == 'x86asm' or action == 'c--':
# check -o option
if hasattr(options, 'outputfile') and options.outputfile:
actions[action](infile, options.outputfile)
else:
parser.error('Missing -o option.')
def start_server():
parser = OptionParser(usage="usage: %prog [options]", version="%prog 1.0")
parser.add_option("--host",
default='',
type='string',
action="store",
dest="host",
help="hostname (localhost)")
parser.add_option("--port",
default=9001,
type='int',
action="store",
dest="port",
help="port (9001)")
parser.add_option("--example",
default='echo',
type='string',
action="store",
dest="example",
help="echo, chat")
parser.add_option("--ssl",
default=0,
type='int',
action="store",
dest="ssl",
help="ssl (1: on, 0: off (default))")
parser.add_option("--cert",
default='./cert.pem',
type='string',
action="store",
dest="cert",
help="cert (./cert.pem)")
parser.add_option("--ver",
default=ssl.PROTOCOL_TLSv1,
type=int,
action="store",
dest="ver",
help="ssl version")
(options, args) = parser.parse_args()
os.system("rm ./unix_socket")
cls = SimpleEcho
if options.example == 'chat':
cls = SimpleChat
if options.ssl == 1:
server = SimpleSSLWebSocketServer(options.host,
options.port,
cls,
options.cert,
options.cert,
version=options.ver)
else:
server = SimpleWebSocketServer(options.host, options.port, cls)
# def close_sig_handler(signal, frame):
# server.close()
# sys.exit()
# serverThread = threading.Thread(target=other_thread)
# serverThread.daemon = True
# serverThread.start()
#signal.signal(signal.SIGINT, close_sig_handler)
server.serveforever()
from optparse import OptionParser
usage = """Usage: %prog roiName obsID ccdColour sample line
[target codes]"""
descript = """Utility to 1. calculate ground coordinates for a given
sample/line pair for a given obsID. 2. find all mosaic data cubes on the hirise
server with the same target code (optional: 2nd additional target code)
as the given obsID, that also have this point inside (negative results mean
outside, positive might still lie in black part of map-projected mosaic).
The roiName that is required will be used for the resulting csv data file.
The created data file will contain calculated sample/line pairs for the
found data cube mosaics"""
parser = OptionParser(usage=usage, description=descript)
parser.add_option("-t", "--target", dest="extraTargetCode",
help="optional 2nd targetcode to search")
parser.add_option("-n", "--testing", action='store_true',
dest="testing", default=False,
help="test functionality without providing parameters")
(options, args) = parser.parse_args()
# create my parameter container
params = roi.ROI_Data()
params.extraTargetCode = options.extraTargetCode
if options.testing:
params.roiName = 'IncaCity'
params.obsID = 'PSP_003092_0985'
params.ccdColour = 'RED'
def parse():
parser.add_option('-i',
type="string",
help='The path of SQL Parser package ',
dest='input_path')
base = core.Core()
# base.banner()
base.cmd_option()
result = base.parse_log(core.burp_suite_log)
for item in result:
if base.gerequestinfo(item, "Host") == core.target_domain:
headers = {}
sp = item.split('\n\n', 1)
if len(sp) > 1:
head = sp[0]
body = sp[1]
else:
head = sp[0]
body = ""
c1 = head.split('\n', head.count('\n'))
method = c1[0].split(' ', 2)[0]
path = c1[0].split(' ', 2)[1]
for i in range(1, head.count('\n') + 1):
slice1 = c1[i].split(': ', 1)
if slice1[0] != "":
headers[slice1[0]] = slice1[1]
session = requests.session()
if method == 'GET':
url = base.gerequestinfo(item, "Host") + path
domain = url.split("?")[0]
queries = urlparse(url).query.split("&")
if not any(queries):
print('skip')
else:
for i in range(len(queries)):
input = queries[i].split('=')[1]
output, payload = generator(input)
queries[i] = queries[i].split('=')[0] + '=' + payload
website = domain + "?" + ("&".join(
[param for param in queries]))
print(website)
session.get(url=website)
with open(input_path, 'r') as f:
sqltext = f.readline()
if SQLInjection.isInjected(sqltext):
with open('./output.txt', 'a') as f:
f.write(website + '\n')
elif method == 'POST':
print(body)
queries = urlparse(body).query.split("&")
if not any(queries):
print('skip')
else:
for i in range(len(queries)):
input = queries[i].split('=')[1]
output = generator(input)
queries[i] = queries[i].split('=')[0] + '=' + output
website = domain + "?" + ("&".join(
[param for param in queries]))
print(website)
session.get(url=website)
with open(input_path, 'r') as f:
sqltext = f.readline()
if SQLInjection.isInjected(sqltext):
with open('./output.txt', 'a') as f:
f.write(website + '\n')
import parser
import select
import time
import urllib.request, urllib.parse, urllib.error
from this import s
from gzip import GzipFile
from optparse import OptionParser
if __name__ == "__main__":
usage = "usage: %prog [options] drk-file step "
parser = OptionParser(usage)
parser.add_option("-o", "--out", dest="out",
default="-",
help="input file (default %default)")
(options, args) = parser.parse_args()
if len(args) < 2:
parser.print_usage()
sys.exit(1)
fd = GzipFile(args[0], 'r')
#aux buffer for new modified file
output=""
#aux dict with keys src_dst combination and its corresponding line of the file as value.
src_dst_dic={}
#aux boolean dict with keys src_dst combination. 0=no response from DST yet, 1=response from DST for the last src_dst message.
response={}
def main():
global mongod_executable, mongod_port, shell_executable, continue_on_failure, small_oplog, no_journal, no_preallocj, auth, keyFile, smoke_db_prefix, test_path
parser = OptionParser(usage="usage: smoke.py [OPTIONS] ARGS*")
parser.add_option(
"--mode",
dest="mode",
default="suite",
help='If "files", ARGS are filenames; if "suite", ARGS are sets of tests (%default)',
)
# Some of our tests hard-code pathnames e.g., to execute, so until
# that changes we don't have the freedom to run from anyplace.
# parser.add_option('--mongo-repo', dest='mongo_repo', default=None,
parser.add_option(
"--test-path",
dest="test_path",
default=None,
help="Path to the test executables to run, " "currently only used for 'client' (%default)",
)
parser.add_option(
"--mongod",
dest="mongod_executable",
default=os.path.join(mongo_repo, "mongod"),
help="Path to mongod to run (%default)",
)
parser.add_option("--port", dest="mongod_port", default="27999", help="Port the mongod will bind to (%default)")
parser.add_option(
"--mongo",
dest="shell_executable",
default=os.path.join(mongo_repo, "mongo"),
help="Path to mongo, for .js test files (%default)",
)
parser.add_option(
"--continue-on-failure",
dest="continue_on_failure",
action="store_true",
default=False,
help="If supplied, continue testing even after a test fails",
)
parser.add_option(
"--from-file", dest="File", help="Run tests/suites named in FILE, one test per line, '-' means stdin"
)
parser.add_option(
"--smoke-db-prefix",
dest="smoke_db_prefix",
default=smoke_db_prefix,
help="Prefix to use for the mongods' dbpaths ('%default')",
)
parser.add_option(
"--small-oplog",
dest="small_oplog",
default=False,
action="store_true",
help="Run tests with master/slave replication & use a small oplog",
)
parser.add_option(
"--small-oplog-rs",
dest="small_oplog_rs",
default=False,
action="store_true",
help="Run tests with replica set replication & use a small oplog",
)
parser.add_option(
"--nojournal", dest="no_journal", default=False, action="store_true", help="Do not turn on journaling in tests"
)
parser.add_option(
"--nopreallocj",
dest="no_preallocj",
default=False,
action="store_true",
help="Do not preallocate journal files in tests",
)
parser.add_option(
"--auth",
dest="auth",
default=False,
action="store_true",
help="Run standalone mongods in tests with authentication enabled",
)
parser.add_option(
"--authMechanism",
dest="authMechanism",
default="MONGO-CR",
help="Use the given authentication mechanism, when --auth is used.",
)
parser.add_option(
"--keyFile",
dest="keyFile",
default=None,
help="Path to keyFile to use to run replSet and sharding tests with authentication enabled",
)
parser.add_option("--ignore", dest="ignore_files", default=None, help="Pattern of files to ignore in tests")
parser.add_option(
"--only-old-fails",
dest="only_old_fails",
default=False,
action="store_true",
help="Check the failfile and only run all tests that failed last time",
)
parser.add_option(
"--reset-old-fails",
dest="reset_old_fails",
default=False,
action="store_true",
help="Clear the failfile. Do this if all tests pass",
)
parser.add_option(
"--with-cleanbb",
dest="with_cleanbb",
default=False,
action="store_true",
help="Clear database files from previous smoke.py runs",
)
parser.add_option(
"--dont-start-mongod",
dest="start_mongod",
default=True,
action="store_false",
help="Do not start mongod before commencing test running",
)
parser.add_option(
"--use-ssl",
dest="use_ssl",
default=False,
action="store_true",
help="Run mongo shell and mongod instances with SSL encryption",
)
# Buildlogger invocation from command line
parser.add_option(
"--buildlogger-builder",
dest="buildlogger_builder",
default=None,
action="store",
help='Set the "builder name" for buildlogger',
)
parser.add_option(
"--buildlogger-buildnum",
dest="buildlogger_buildnum",
default=None,
action="store",
help='Set the "build number" for buildlogger',
)
parser.add_option(
"--buildlogger-credentials",
dest="buildlogger_credentials",
default=None,
action="store",
help="Path to Python file containing buildlogger credentials",
)
parser.add_option(
"--buildlogger-phase",
dest="buildlogger_phase",
default=None,
action="store",
help='Set the "phase" for buildlogger (e.g. "core", "auth") for display in the webapp (optional)',
)
global tests
(options, tests) = parser.parse_args()
set_globals(options, tests)
buildlogger_opts = (options.buildlogger_builder, options.buildlogger_buildnum, options.buildlogger_credentials)
if all(buildlogger_opts):
os.environ["MONGO_USE_BUILDLOGGER"] = "true"
os.environ["MONGO_BUILDER_NAME"] = options.buildlogger_builder
os.environ["MONGO_BUILD_NUMBER"] = options.buildlogger_buildnum
os.environ["BUILDLOGGER_CREDENTIALS"] = options.buildlogger_credentials
if options.buildlogger_phase:
os.environ["MONGO_PHASE"] = options.buildlogger_phase
elif any(buildlogger_opts):
# some but not all of the required options were sete
raise Exception("you must set all of --buildlogger-builder, --buildlogger-buildnum, --buildlogger-credentials")
if options.File:
if options.File == "-":
tests = sys.stdin.readlines()
else:
f = open(options.File)
tests = f.readlines()
tests = [t.rstrip("\n") for t in tests]
if options.only_old_fails:
run_old_fails()
return
elif options.reset_old_fails:
clear_failfile()
return
# If we're in suite mode, tests is a list of names of sets of tests.
if options.mode == "suite":
tests = expand_suites(tests)
elif options.mode == "files":
tests = [(os.path.abspath(test), start_mongod) for test in tests]
if options.ignore_files != None:
ignore_patt = re.compile(options.ignore_files)
print "Ignoring files with pattern: ", ignore_patt
def ignore_test(test):
if ignore_patt.search(test[0]) != None:
print "Ignoring test ", test[0]
return False
else:
return True
tests = filter(ignore_test, tests)
if not tests:
print "warning: no tests specified"
return
if options.with_cleanbb:
dbroot = os.path.join(options.smoke_db_prefix, "data", "db")
call([utils.find_python(), "buildscripts/cleanbb.py", "--nokill", dbroot])
try:
run_tests(tests)
finally:
add_to_failfile(fails, options)
f = open("smoke-last.json", "wb")
f.write(json.dumps({"results": all_test_results}))
f.close()
report()
def build_option_parser(self):
parser = optparse.OptionParser()
parser.add_option('--expression', action='append', default=[])
parser.add_option('--program', action='append', default=[])
parser.add_option('--file', action='append', default=[])
parser.add_option('--filter', action='store_true', default=False)
parser.add_option('--base64', action='store_true', default=False)
parser.add_option('--disass', action='store_true', default=False)
parser.add_option('--out', default=None)
parser.add_option('--compile', action='callback', type='string', callback=parse_plankton_option)
return parser
def parseOptions():
#note: newlines are not respected in the optparse description string :(, maybe someday will use
#argparse, which does allow for raw formating (repects indents, newlines etc.)
#setup command line parser
'''This is out of date, needs to be updated to reflect new additions'''
parser=op.OptionParser(usage="Usage: %prog [options] XMLFILE"
,version="%prog 1.0",description=r"Reads in the XMLFILE which specifies how the plot is to be "
+"made and generates the plot of plots accordingly.")
#these options apply globaly
parser.add_option("-o","--outputFile",dest="outputFile",default="out"
,help="Specifies the OUTPUTFILE. [default: %default]"
,metavar="OUTPUTFILE", type="string")
parser.add_option("-f","--format",dest="format",default="png", type="choice",
help="Sets the FMT of the OUTPUTFILE, availble formats are 'png', 'pdf', 'ps', 'eps', and 'svg'."
+"[default: %default]", metavar="FMT",choices=('png','pdf','ps','eps','svg'))
parser.add_option("-s","--show",dest="show",action="store_true",default=False
,help="Display plot to x11 display rather than saving to a file.")
parser.add_option("--dpi",dest="dpi",type="float",default=100
,help="Sets the dots per inch of the figure [default: %default]")
parser.add_option("--space-axis-evenly",action="store_true",dest="spaceAxisEvenly"
,help="Will give the same amount of space per x-axis, instead of per plot. [not default]."
,default=False)
#should likely be per plot, at the momement they are across all plots
parser.add_option("--fig-width",dest="figWidth",type="float",default=15
,help="Set the width of the figure [default: %default]")
parser.add_option("--fig-height",dest="figHeight",type="float",default=9
,help="Set the height of the figure [default: %default]")
#parse command line options
return parser.parse_args()
def start_server():
parser = OptionParser(usage="usage: %prog [options]", version="%prog 1.0")
parser.add_option("--host", default='', type='string', action="store", dest="host", help="hostname (localhost)")
parser.add_option("--port", default=9001, type='int', action="store", dest="port", help="port (9001)")
parser.add_option("--example", default='echo', type='string', action="store", dest="example", help="echo, chat")
parser.add_option("--ssl", default=0, type='int', action="store", dest="ssl", help="ssl (1: on, 0: off (default))")
parser.add_option("--cert", default='./cert.pem', type='string', action="store", dest="cert", help="cert (./cert.pem)")
parser.add_option("--ver", default=ssl.PROTOCOL_TLSv1, type=int, action="store", dest="ver", help="ssl version")
(options, args) = parser.parse_args()
os.system("rm ./unix_socket")
cls = SimpleEcho
if options.example == 'chat':
cls = SimpleChat
if options.ssl == 1:
server = SimpleSSLWebSocketServer(options.host, options.port, cls, options.cert, options.cert, version=options.ver)
else:
server = SimpleWebSocketServer(options.host, options.port, cls)
# def close_sig_handler(signal, frame):
# server.close()
# sys.exit()
# serverThread = threading.Thread(target=other_thread)
# serverThread.daemon = True
# serverThread.start()
#signal.signal(signal.SIGINT, close_sig_handler)
server.serveforever()
def Main():
parser = optparse.OptionParser()
parser.add_option("-p", "--publishToRepo",
help='Publish binaries to specified dist repo.',
default=None)
(options, args) = parser.parse_args()
userhome = os.path.expanduser("~")
platformid = platform.system()
env = os.environ.copy()
if platformid == "Linux":
env["ORACLE_OCI_HOME"] = "%s/Downloads/instantclient_11_2/sdk" % userhome
env["ORACLE_OCCI_LIB_HOME"] = "%s/Downloads/instantclient_11_2" % userhome
buildCommand = ['make', '-j', '8', 'BUILDTYPE=ReleaseIA32']
extensionlibrary = "out/ReleaseIA32/lib.target/liboracledart_extension.so"
elif platformid == "Darwin":
ORACLE_OCCI_LIB_HOME = "%s/Downloads/instantclient_11_2-2" % userhome
subprocess.call(
["ln",
"%s/libocci.dylib.11.1" % ORACLE_OCCI_LIB_HOME,
"%s/libocci.dylib" % ORACLE_OCCI_LIB_HOME])
subprocess.call(
["ln",
"%s/ORACLE_OCCI_LIB_HOME/libclntsh.dylib.11.1" % ORACLE_OCCI_LIB_HOME,
"%s/libclntsh.dylib" % ORACLE_OCCI_LIB_HOME])
env["ORACLE_OCI_HOME"] = "%s/Downloads/instantclient_11_2/sdk" % userhome
env["ORACLE_OCCI_LIB_HOME"] = ORACLE_OCCI_LIB_HOME
buildCommand = ['xcodebuild',
'-project', 'oracledart.xcodeproj',
'-configuration', 'ReleaseIA32',
'SYMROOT=%s/../dart/xcodebuild' % os.getcwd()]
extensionlibrary = (
"../dart/xcodebuild/ReleaseIA32/liboracledart_extension.dylib")
elif platformid == "Windows" or platformid == "Microsoft":
if not "JAVA_HOME" in env:
print "JAVA_HOME is not set up"
return 3
os.system("mklink /J third_party ..\\dart\\third_party")
env["ORACLE_OCI_HOME"] = (
"%s\\downloads\\instantclient-sdk-nt-12.1.0.1.0\\instantclient_12_1\\sdk" %
userhome)
buildCommand = ['devenv.com',
'oracledart.sln',
'/build',
'ReleaseIA32']
extensionlibrary = (
"build\\ReleaseIA32\\oracledart_extension.dll")
else:
print "Unsupported platform"
return 1
print " ".join(buildCommand)
process = subprocess.Popen(buildCommand, stdin=None, env=env)
process.wait()
print "Completed with %d" % (process.returncode)
if process.returncode == 0:
if platformid == "Linux" or platformid == "Darwin":
subprocess.call("cp %s lib" % (extensionlibrary), shell=True)
else:
subprocess.call(["copy", extensionlibrary, "lib"], shell=True)
if (options.publishToRepo != None):
subprocess.call(
["python", "./tools/deploy.py", "-p", options.publishToRepo, "-f", extensionlibrary])
return process.returncode
if pn is None or not os.path.exists(pn):
return 0
return os.stat(pn).st_size
for fs in fsop.get_all_fs():
one = _get_merged_file(fs)
fss = _get_fss_file(fs)
print "%-10s %10s B %10s B" % (fs, _get_size(one), _get_size(fss))
if __name__ == '__main__':
utils.install_pdb()
parser = optparse.OptionParser()
parser.add_option("--linux", help="Linux kernel", default=LINUX)
parser.add_option("--clang", help="Clang path", default=CLANG)
parser.add_option("--outdir", help="Clang output dir", default="/tmp")
(opts, args) = parser.parse_args()
def __print_usage(note):
print(note)
for (cmd, func) in get_all_cmds():
print("> %-20s: %s" % (cmd, func.__doc__))
exit(0)
if len(args) == 0:
__print_usage("Need to specify a command")
cmd = args[0]
if get_cmd(cmd) is None:
def parseOptions():
#note: newlines are not respected in the optparse description string :(, maybe someday will use
#argparse, which does allow for raw formating (repects indents, newlines etc.)
#setup command line parser
'''This is out of date, needs to be updated to reflect new additions'''
parser=op.OptionParser(usage="Usage: %prog [options] XMLFILE"
,version="%prog 1.0",description=r"Reads in the XMLFILE which specifies how the plot is to be "
+"made and generates the plot of plots accordingly.")
#these options apply globaly
parser.add_option("-s","--show",dest="show",action="store_true",default=False
,help="Display plot to x11 display rather than saving to a file.")
parser.add_option("-f","--file",dest="file",action="store_true",default=False
,help="Instead of plotting the data will be written to an ascii file.")
parser.add_option("--dpi",dest="dpi",type="float",default=100
,help="Sets the dots per inch of the figure [default: %default]")
parser.add_option("--space-axis-evenly",action="store_true",dest="spaceAxisEvenly"
,help="Will give the same amount of space per x-axis, instead of per plot. [not default]."
,default=False)
#should likely be per plot, at the momement they are across all plots
parser.add_option("--zone-index-from-center",dest="zoneIndexFromCenter",
help="Specifies the radial zone at which to plot the desired column should starts with the "
"center zone equal to zero and the zone number increasing towards the surface"
,action="store_true",default=False)
parser.add_option("--fig-width",dest="figWidth",type="float",default=15
,help="Set the width of the figure [default: %default]")
parser.add_option("--fig-height",dest="figHeight",type="float",default=9
,help="Set the height of the figure [default: %default]")
make_profiles.addParserOptions(parser)
#parse command line options
return parser.parse_args()
def runBatch():
parser = OptionParser()
parser.set_usage(parser.get_usage().rstrip() + " {create | start | stop | clean | drop}")
parser.add_option("-t", "--tables", dest="tables", type="string", default="test: Blog"
, help = "format: \"dbname1: table1 table2;dbname2: table3;\"")
parser.add_option("-m", "--home", dest="mysqlhome", type="string", default="/usr"
, help = "mysql home directory")
parser.add_option("-H", "--host", dest="mysqlhost", type="string", default="127.0.0.1"
, help = "mysql server address")
parser.add_option("-P", "--port", dest="mysqlport", type="int", default = 3306
, help = "mysql server port")
parser.add_option("-u", "--user", dest="mysqluser", type="string", default = "root"
, help = "mysql server user name")
parser.add_option("-p", "--password", dest="mysqlpassword", type="string", default=""
, help = "mysql server password")
parser.add_option("-e", "--engine", dest="engine", type="string", default="innodb"
, help = "mysql storage engine")
parser.add_option("-i", "--iteration", dest="iteration", type=int
, help = "the iteration times of query information_schemation database")
parser.add_option("-o", "--output", dest="output", type="string", default="./"
, help = "output directory for result")
(options, args) = parser.parse_args()
tables = []
if options.tables != None:
options.tables.strip(";")
for dbtabs in options.tables.split(";"):
str = dbtabs.split(":")
print str
tables.append((str[0], str[1].split()))
if len(args) <= 0:
parser.print_usage()
return
if args[0] == "create":
StatisticianRunner.createTest(options.output, MysqlConfig(options.mysqlhome, options.mysqlhost
, options.mysqlport, options.mysqluser, options.mysqlpassword), options.engine, tables)
elif args[0] == "start":
if options.iteration == None:
parser.print_usage()
return
StatisticianRunner.start(options.output, options.iteration)
elif args[0] == "stop":
StatisticianRunner.stop(options.output)
elif args[0] == "clean":
StatisticianRunner.clean(options.output)
elif args[0] == "drop":
StatisticianRunner.drop(options.output)
else:
parser.print_usage()
return
def _parse_args():
'''Parse the command-line arguments.'''
parser = OptionParser(usage='%prog [Options] <device>', version='%prog 0.5')
parser.add_option('-p', '--purge',
dest='purge',
help='purge the tracklog memory on the device',
action='store_true',
default=False)
parser.add_option('-d', '--download',
dest='download',
help='download tracklogs from device',
action='store_true',
default=False)
parser.add_option('-t', '--target-dir',
dest='target_dir',
help='target directory for downloaded tracklogs [default: %default]',
default='%s/mainnav-tracklogs/' % os.environ.get('HOME', tempfile.gettempdir()))
parser.add_option('-u', '--utc',
dest='utc_offset',
help='generate GPX time entry in UTC by declaring the offset (your timezone, e.g. -5 or +9.5)',
type='float',
default=False)
parser.add_option('-r', '--raw',
dest='raw',
help='store the raw binary data in the target directory (must be combined with the download option)',
action='store_true',
default=False)
parser.add_option('-m', '--memory',
dest='memory',
help='show the amount of memory in use',
action='store_true',
default=False)
parser.add_option('-v', '--verbose',
dest='verbose',
help='be verbose',
action='store_true',
default=False)
(options, args) = parser.parse_args()
try:
options.device = args[0]
except IndexError:
options.device = ''
if not options.device:
parser.error('please specify device path, for example \'/dev/ttyUSB0\'')
if options.download and options.purge:
parser.error('options -d and -p are mutually exclusive')
if options.download and options.memory:
parser.error('options -d and -m are mutually exclusive')
if options.memory and options.purge:
parser.error('options -m and -p are mutually exclusive')
return options
import parser
import os
import os.path
import glob
from tempfile import mkstemp
from subprocess import Popen
from optparse import OptionParser
parser = OptionParser(usage="usage: %prog [options] <SQL scripts path>", add_help_option=False)
parser.add_option("--help", action="store_true", dest="help", default=False)
parser.add_option("--mysql", dest="mysql", default="mysql", help="Default mysql binary")
parser.add_option("--browser-db", dest="browser_db", default=None, metavar="NAME", help="Browser database name")
parser.add_option("--biomart-db", dest="biomart_db", default=None, metavar="NAME", help="Biomart database name")
parser.add_option("--start", dest="start_file", default=None, metavar="NAME", help="SQL file to start with. Optional")
parser.add_option("-h", "--host", dest="db_host", default=None, metavar="HOST", help="host")
parser.add_option("-P", "--port", dest="db_port", default=None, metavar="PORT", help="port")
parser.add_option("-u", "--user", dest="db_user", default=None, metavar="NAME", help="user name")
parser.add_option("-p", "--passwd", dest="db_passwd", default=None, metavar="PASSWD", help="password")
(options, args) = parser.parse_args()
if options.help:
parser.print_help()
import parser
import select
import time
import urllib
from this import s
from gzip import GzipFile
from optparse import OptionParser
if __name__ == "__main__":
usage = "usage: %prog [options] drk-file step "
parser = OptionParser(usage)
parser.add_option("-o", "--out", dest="out",
default="-",
help="input file (default %default)")
(options, args) = parser.parse_args()
if len(args) < 2:
parser.print_usage()
sys.exit(1)
fd = GzipFile(args[0], 'r')
#aux buffer for new modified file
output=""
#aux dict with keys src_dst combination and its corresponding line of the file as value.
src_dst_dic={}
#aux boolean dict with keys src_dst combination. 0=no response from DST yet, 1=response from DST for the last src_dst message.
response={}
def main():
global mongod_executable, mongod_port, shell_executable, continue_on_failure, small_oplog, no_journal, set_parameters, no_preallocj, auth, keyFile, smoke_db_prefix, test_path
parser = OptionParser(usage="usage: smoke.py [OPTIONS] ARGS*")
parser.add_option('--mode', dest='mode', default='suite',
help='If "files", ARGS are filenames; if "suite", ARGS are sets of tests (%default)')
# Some of our tests hard-code pathnames e.g., to execute, so until
# that changes we don't have the freedom to run from anyplace.
# parser.add_option('--mongo-repo', dest='mongo_repo', default=None,
parser.add_option('--test-path', dest='test_path', default=None,
help="Path to the test executables to run, "
"currently only used for 'client' (%default)")
parser.add_option('--mongod', dest='mongod_executable', default=os.path.join(mongo_repo, 'mongod'),
help='Path to mongod to run (%default)')
parser.add_option('--port', dest='mongod_port', default="27999",
help='Port the mongod will bind to (%default)')
parser.add_option('--mongo', dest='shell_executable', default=os.path.join(mongo_repo, 'mongo'),
help='Path to mongo, for .js test files (%default)')
parser.add_option('--continue-on-failure', dest='continue_on_failure',
action="store_true", default=False,
help='If supplied, continue testing even after a test fails')
parser.add_option('--from-file', dest='File',
help="Run tests/suites named in FILE, one test per line, '-' means stdin")
parser.add_option('--smoke-db-prefix', dest='smoke_db_prefix', default=smoke_db_prefix,
help="Prefix to use for the mongods' dbpaths ('%default')")
parser.add_option('--small-oplog', dest='small_oplog', default=False,
action="store_true",
help='Run tests with master/slave replication & use a small oplog')
parser.add_option('--small-oplog-rs', dest='small_oplog_rs', default=False,
action="store_true",
help='Run tests with replica set replication & use a small oplog')
parser.add_option('--nojournal', dest='no_journal', default=False,
action="store_true",
help='Do not turn on journaling in tests')
parser.add_option('--nopreallocj', dest='no_preallocj', default=False,
action="store_true",
help='Do not preallocate journal files in tests')
parser.add_option('--auth', dest='auth', default=False,
action="store_true",
help='Run standalone mongods in tests with authentication enabled')
parser.add_option('--authMechanism', dest='authMechanism', default='MONGODB-CR',
help='Use the given authentication mechanism, when --auth is used.')
parser.add_option('--keyFile', dest='keyFile', default=None,
help='Path to keyFile to use to run replSet and sharding tests with authentication enabled')
parser.add_option('--ignore', dest='ignore_files', default=None,
help='Pattern of files to ignore in tests')
parser.add_option('--only-old-fails', dest='only_old_fails', default=False,
action="store_true",
help='Check the failfile and only run all tests that failed last time')
parser.add_option('--reset-old-fails', dest='reset_old_fails', default=False,
action="store_true",
help='Clear the failfile. Do this if all tests pass')
parser.add_option('--with-cleanbb', dest='with_cleanbb', default=False,
action="store_true",
help='Clear database files from previous smoke.py runs')
parser.add_option('--dont-start-mongod', dest='start_mongod', default=True,
action='store_false',
help='Do not start mongod before commencing test running')
parser.add_option('--use-ssl', dest='use_ssl', default=False,
action='store_true',
help='Run mongo shell and mongod instances with SSL encryption')
parser.add_option('--set-parameters', dest='set_parameters', default="",
help='Adds --setParameter for each passed in items in the csv list - ex. "param1=1,param2=foo" ')
# Buildlogger invocation from command line
parser.add_option('--buildlogger-builder', dest='buildlogger_builder', default=None,
action="store", help='Set the "builder name" for buildlogger')
parser.add_option('--buildlogger-buildnum', dest='buildlogger_buildnum', default=None,
action="store", help='Set the "build number" for buildlogger')
parser.add_option('--buildlogger-credentials', dest='buildlogger_credentials', default=None,
action="store", help='Path to Python file containing buildlogger credentials')
parser.add_option('--buildlogger-phase', dest='buildlogger_phase', default=None,
action="store", help='Set the "phase" for buildlogger (e.g. "core", "auth") for display in the webapp (optional)')
parser.add_option('--report-file', dest='report_file', default=None,
action='store',
help='Path to generate detailed json report containing all test details')
global tests
(options, tests) = parser.parse_args()
set_globals(options, tests)
buildlogger_opts = (options.buildlogger_builder, options.buildlogger_buildnum, options.buildlogger_credentials)
if all(buildlogger_opts):
os.environ['MONGO_USE_BUILDLOGGER'] = 'true'
os.environ['MONGO_BUILDER_NAME'] = options.buildlogger_builder
os.environ['MONGO_BUILD_NUMBER'] = options.buildlogger_buildnum
os.environ['BUILDLOGGER_CREDENTIALS'] = options.buildlogger_credentials
if options.buildlogger_phase:
os.environ['MONGO_PHASE'] = options.buildlogger_phase
elif any(buildlogger_opts):
# some but not all of the required options were sete
raise Exception("you must set all of --buildlogger-builder, --buildlogger-buildnum, --buildlogger-credentials")
if options.File:
if options.File == '-':
tests = sys.stdin.readlines()
else:
f = open(options.File)
tests = f.readlines()
tests = [t.rstrip('\n') for t in tests]
if options.only_old_fails:
run_old_fails()
return
elif options.reset_old_fails:
clear_failfile()
return
# If we're in suite mode, tests is a list of names of sets of tests.
if options.mode == 'suite':
tests = expand_suites(tests)
elif options.mode == 'files':
tests = [(os.path.abspath(test), start_mongod) for test in tests]
if options.ignore_files != None :
ignore_patt = re.compile( options.ignore_files )
print "Ignoring files with pattern: ", ignore_patt
def ignore_test( test ):
if ignore_patt.search( test[0] ) != None:
print "Ignoring test ", test[0]
return False
else:
return True
tests = filter( ignore_test, tests )
if not tests:
print "warning: no tests specified"
return
if options.with_cleanbb:
dbroot = os.path.join(options.smoke_db_prefix, 'data', 'db')
call([utils.find_python(), "buildscripts/cleanbb.py", "--nokill", dbroot])
test_report["start"] = time.time()
try:
run_tests(tests)
finally:
add_to_failfile(fails, options)
test_report["end"] = time.time()
test_report["elapsed"] = test_report["end"] - test_report["start"]
test_report["failures"] = len(losers.keys())
if report_file:
f = open( report_file, "wb" )
f.write( json.dumps( test_report ) )
f.close()
report()
def __init__(self):
QtGui.QDialog.__init__(self)
# Set up the user interface from Designer.
self.ui = Ui_WaterForm()
self.ui.setupUi(self)"""
)
compliestring = Template("pyuic4 -o ui_$py.py $ui")
if __name__ == "__main__":
"""
Helper to create the form folder structure with the correct layer and files
"""
parser = OptionParser()
parser.add_option("-f", "--folder", dest="foldername", help="Overwrite folder name for form folder", metavar="NAME")
(options, args) = parser.parse_args()
if not len(args) == 3:
parser.error("incorrect number of arguments")
filename = args[0]
layer = args[1]
name = args[2]
if not filename[-3:] == ".ui":
parser.error("incorrect number of arguments")
newfilename = filename.replace(" ", "")
print filename
foldername = "form%s" % (options.foldername or newfilename[:-3])
def main():
global mongod_executable, mongod_port, shell_executable, continue_on_failure, small_oplog, no_journal, set_parameters, no_preallocj, auth, keyFile, smoke_db_prefix, test_path
parser = OptionParser(usage="usage: smoke.py [OPTIONS] ARGS*")
parser.add_option(
'--mode',
dest='mode',
default='suite',
help=
'If "files", ARGS are filenames; if "suite", ARGS are sets of tests (%default)'
)
# Some of our tests hard-code pathnames e.g., to execute, so until
# that changes we don't have the freedom to run from anyplace.
# parser.add_option('--mongo-repo', dest='mongo_repo', default=None,
parser.add_option('--test-path',
dest='test_path',
default=None,
help="Path to the test executables to run, "
"currently only used for 'client' (%default)")
parser.add_option('--mongod',
dest='mongod_executable',
default=os.path.join(mongo_repo, 'mongod'),
help='Path to mongod to run (%default)')
parser.add_option('--port',
dest='mongod_port',
default="27999",
help='Port the mongod will bind to (%default)')
parser.add_option('--mongo',
dest='shell_executable',
default=os.path.join(mongo_repo, 'mongo'),
help='Path to mongo, for .js test files (%default)')
parser.add_option(
'--continue-on-failure',
dest='continue_on_failure',
action="store_true",
default=False,
help='If supplied, continue testing even after a test fails')
parser.add_option(
'--from-file',
dest='File',
help=
"Run tests/suites named in FILE, one test per line, '-' means stdin")
parser.add_option(
'--smoke-db-prefix',
dest='smoke_db_prefix',
default=smoke_db_prefix,
help="Prefix to use for the mongods' dbpaths ('%default')")
parser.add_option(
'--small-oplog',
dest='small_oplog',
default=False,
action="store_true",
help='Run tests with master/slave replication & use a small oplog')
parser.add_option(
'--small-oplog-rs',
dest='small_oplog_rs',
default=False,
action="store_true",
help='Run tests with replica set replication & use a small oplog')
parser.add_option('--nojournal',
dest='no_journal',
default=False,
action="store_true",
help='Do not turn on journaling in tests')
parser.add_option('--nopreallocj',
dest='no_preallocj',
default=False,
action="store_true",
help='Do not preallocate journal files in tests')
parser.add_option(
'--auth',
dest='auth',
default=False,
action="store_true",
help='Run standalone mongods in tests with authentication enabled')
parser.add_option(
'--authMechanism',
dest='authMechanism',
default='MONGODB-CR',
help='Use the given authentication mechanism, when --auth is used.')
parser.add_option(
'--keyFile',
dest='keyFile',
default=None,
help=
'Path to keyFile to use to run replSet and sharding tests with authentication enabled'
)
parser.add_option('--ignore',
dest='ignore_files',
default=None,
help='Pattern of files to ignore in tests')
parser.add_option(
'--only-old-fails',
dest='only_old_fails',
default=False,
action="store_true",
help='Check the failfile and only run all tests that failed last time')
parser.add_option('--reset-old-fails',
dest='reset_old_fails',
default=False,
action="store_true",
help='Clear the failfile. Do this if all tests pass')
parser.add_option('--with-cleanbb',
dest='with_cleanbb',
default=False,
action="store_true",
help='Clear database files from previous smoke.py runs')
parser.add_option(
'--dont-start-mongod',
dest='start_mongod',
default=True,
action='store_false',
help='Do not start mongod before commencing test running')
parser.add_option(
'--use-ssl',
dest='use_ssl',
default=False,
action='store_true',
help='Run mongo shell and mongod instances with SSL encryption')
parser.add_option(
'--set-parameters',
dest='set_parameters',
default="",
help=
'Adds --setParameter for each passed in items in the csv list - ex. "param1=1,param2=foo" '
)
# Buildlogger invocation from command line
parser.add_option('--buildlogger-builder',
dest='buildlogger_builder',
default=None,
action="store",
help='Set the "builder name" for buildlogger')
parser.add_option('--buildlogger-buildnum',
dest='buildlogger_buildnum',
default=None,
action="store",
help='Set the "build number" for buildlogger')
parser.add_option(
'--buildlogger-credentials',
dest='buildlogger_credentials',
default=None,
action="store",
help='Path to Python file containing buildlogger credentials')
parser.add_option(
'--buildlogger-phase',
dest='buildlogger_phase',
default=None,
action="store",
help=
'Set the "phase" for buildlogger (e.g. "core", "auth") for display in the webapp (optional)'
)
global tests
(options, tests) = parser.parse_args()
set_globals(options, tests)
buildlogger_opts = (options.buildlogger_builder,
options.buildlogger_buildnum,
options.buildlogger_credentials)
if all(buildlogger_opts):
os.environ['MONGO_USE_BUILDLOGGER'] = 'true'
os.environ['MONGO_BUILDER_NAME'] = options.buildlogger_builder
os.environ['MONGO_BUILD_NUMBER'] = options.buildlogger_buildnum
os.environ['BUILDLOGGER_CREDENTIALS'] = options.buildlogger_credentials
if options.buildlogger_phase:
os.environ['MONGO_PHASE'] = options.buildlogger_phase
elif any(buildlogger_opts):
# some but not all of the required options were sete
raise Exception(
"you must set all of --buildlogger-builder, --buildlogger-buildnum, --buildlogger-credentials"
)
if options.File:
if options.File == '-':
tests = sys.stdin.readlines()
else:
f = open(options.File)
tests = f.readlines()
tests = [t.rstrip('\n') for t in tests]
if options.only_old_fails:
run_old_fails()
return
elif options.reset_old_fails:
clear_failfile()
return
# If we're in suite mode, tests is a list of names of sets of tests.
if options.mode == 'suite':
tests = expand_suites(tests)
elif options.mode == 'files':
tests = [(os.path.abspath(test), start_mongod) for test in tests]
if options.ignore_files != None:
ignore_patt = re.compile(options.ignore_files)
print "Ignoring files with pattern: ", ignore_patt
def ignore_test(test):
if ignore_patt.search(test[0]) != None:
print "Ignoring test ", test[0]
return False
else:
return True
tests = filter(ignore_test, tests)
if not tests:
print "warning: no tests specified"
return
if options.with_cleanbb:
dbroot = os.path.join(options.smoke_db_prefix, 'data', 'db')
call([
utils.find_python(), "buildscripts/cleanbb.py", "--nokill", dbroot
])
try:
run_tests(tests)
finally:
add_to_failfile(fails, options)
f = open("smoke-last.json", "wb")
f.write(json.dumps({"results": all_test_results}))
f.close()
report()
def main():
global mongod_executable, mongod_port, shell_executable, continue_on_failure, small_oplog, no_journal, no_preallocj, auth, keyFile, smoke_db_prefix, smoke_server_opts, test_path
parser = OptionParser(usage="usage: smoke.py [OPTIONS] ARGS*")
parser.add_option('--mode', dest='mode', default='suite',
help='If "files", ARGS are filenames; if "suite", ARGS are sets of tests (%default)')
# Some of our tests hard-code pathnames e.g., to execute, so until
# that changes we don't have the freedom to run from anyplace.
# parser.add_option('--mongo-repo', dest='mongo_repo', default=None,
parser.add_option('--test-path', dest='test_path', default=None,
help="Path to the test executables to run, "
"currently only used for 'client' (%default)")
parser.add_option('--mongod', dest='mongod_executable', default=os.path.join(mongo_repo, 'mongod'),
help='Path to mongod to run (%default)')
parser.add_option('--port', dest='mongod_port', default="27999",
help='Port the mongod will bind to (%default)')
parser.add_option('--mongo', dest='shell_executable', default=os.path.join(mongo_repo, 'mongo'),
help='Path to mongo, for .js test files (%default)')
parser.add_option('--continue-on-failure', dest='continue_on_failure',
action="store_true", default=False,
help='If supplied, continue testing even after a test fails')
parser.add_option('--from-file', dest='File',
help="Run tests/suites named in FILE, one test per line, '-' means stdin")
parser.add_option('--smoke-db-prefix', dest='smoke_db_prefix', default=smoke_db_prefix,
help="Prefix to use for the mongods' dbpaths ('%default')")
parser.add_option('--smoke-server-opts', dest='smoke_server_opts', default=smoke_server_opts,
help="Additional options for the mongod server ('%default')")
parser.add_option('--small-oplog', dest='small_oplog', default=False,
action="store_true",
help='Run tests with master/slave replication & use a small oplog')
parser.add_option('--small-oplog-rs', dest='small_oplog_rs', default=False,
action="store_true",
help='Run tests with replica set replication & use a small oplog')
parser.add_option('--nojournal', dest='no_journal', default=False,
action="store_true",
help='Do not turn on journaling in tests')
parser.add_option('--nopreallocj', dest='no_preallocj', default=False,
action="store_true",
help='Do not preallocate journal files in tests')
parser.add_option('--auth', dest='auth', default=False,
action="store_true",
help='Run standalone mongods in tests with authentication enabled')
parser.add_option('--keyFile', dest='keyFile', default=None,
help='Path to keyFile to use to run replSet and sharding tests with authentication enabled')
parser.add_option('--ignore', dest='ignore_files', default=None,
help='Pattern of files to ignore in tests')
parser.add_option('--only-old-fails', dest='only_old_fails', default=False,
action="store_true",
help='Check the failfile and only run all tests that failed last time')
parser.add_option('--reset-old-fails', dest='reset_old_fails', default=False,
action="store_true",
help='Clear the failfile. Do this if all tests pass')
parser.add_option('--with-cleanbb', dest='with_cleanbb', default=False,
action="store_true",
help='Clear database files from previous smoke.py runs')
parser.add_option('--server-log', dest='server_log_file', default=server_log_file,
help="Log file for the mongod server ('%default')")
parser.add_option('--tests-log', dest='tests_log_file', default='',
help="Log file for the tests ('%default')")
parser.add_option('--quiet', dest='quiet', default=False,
action="store_true",
help='Generate a quieter report (use with --tests-log)')
parser.add_option('--shuffle', dest='shuffle', default=False,
action="store_true",
help='Shuffle tests instead of running them in alphabetical order')
# Buildlogger invocation from command line
parser.add_option('--buildlogger-builder', dest='buildlogger_builder', default=None,
action="store", help='Set the "builder name" for buildlogger')
parser.add_option('--buildlogger-buildnum', dest='buildlogger_buildnum', default=None,
action="store", help='Set the "build number" for buildlogger')
parser.add_option('--buildlogger-credentials', dest='buildlogger_credentials', default=None,
action="store", help='Path to Python file containing buildlogger credentials')
parser.add_option('--buildlogger-phase', dest='buildlogger_phase', default=None,
action="store", help='Set the "phase" for buildlogger (e.g. "core", "auth") for display in the webapp (optional)')
global tests
(options, tests) = parser.parse_args()
set_globals(options, tests)
buildlogger_opts = (options.buildlogger_builder, options.buildlogger_buildnum, options.buildlogger_credentials)
if all(buildlogger_opts):
os.environ['MONGO_USE_BUILDLOGGER'] = 'true'
os.environ['MONGO_BUILDER_NAME'] = options.buildlogger_builder
os.environ['MONGO_BUILD_NUMBER'] = options.buildlogger_buildnum
os.environ['BUILDLOGGER_CREDENTIALS'] = options.buildlogger_credentials
if options.buildlogger_phase:
os.environ['MONGO_PHASE'] = options.buildlogger_phase
elif any(buildlogger_opts):
# some but not all of the required options were sete
raise Exception("you must set all of --buildlogger-builder, --buildlogger-buildnum, --buildlogger-credentials")
if options.File:
if options.File == '-':
tests = sys.stdin.readlines()
else:
f = open(options.File)
tests = f.readlines()
tests = [t.rstrip('\n') for t in tests]
if options.only_old_fails:
run_old_fails()
return
elif options.reset_old_fails:
clear_failfile()
return
# If we're in suite mode, tests is a list of names of sets of tests.
if options.mode == 'suite':
tests = expand_suites(tests)
elif options.mode == 'files':
tests = [(os.path.abspath(test), True) for test in tests]
if options.ignore_files != None :
ignore_patt = re.compile( options.ignore_files )
tests = filter( lambda x : ignore_patt.search( x[0] ) == None, tests )
if not tests:
print "warning: no tests specified"
return
if options.with_cleanbb:
dbroot = os.path.join(options.smoke_db_prefix, 'data', 'db')
if options.quiet:
f = open(server_log_file, "a")
try:
call([utils.find_python(), "buildscripts/cleanbb.py", "--nokill", dbroot], stdout=f)
finally:
f.close()
else:
call([utils.find_python(), "buildscripts/cleanbb.py", "--nokill", dbroot])
if options.shuffle:
import random
random.shuffle(tests)
try:
run_tests(tests)
finally:
add_to_failfile(fails, options)
report()
