def test3():
argv.append('1')
argv.append('2')
try: script = WC('nt')
except StartKeyError:
argv.remove('1')
argv.remove('2')
def make_dists():
prebuilt_platform_root = path.join("dtls", "prebuilt")
for platform in listdir(prebuilt_platform_root):
config = {"MANIFEST_DIR": path.join(prebuilt_platform_root, platform)}
execfile(path.join(prebuilt_platform_root, platform, "manifest.pycfg"),
config)
files = map(lambda x: "dtls/prebuilt/" + platform + "/" + x,
config["FILES"])
argv.append("--formats=" + config["FORMATS"])
invoke_setup([('dtls', files)])
del argv[-1]
for dist_format in config["FORMATS"].split(','):
source_name = path.join(DIST_DIR,
NAME + "-" + VERSION +
FORMAT_TO_SUFFIX[dist_format])
target_name = path.join(DIST_DIR,
NAME + "-" + VERSION +
".sdist_with_openssl." +
config["ARCHITECTURE"] +
FORMAT_TO_SUFFIX[dist_format])
try:
remove(target_name)
except OSError:
pass
rename(source_name, target_name)
# Finally the distribution without prebuilts
argv.append("--formats=zip,gztar")
invoke_setup()
def main():
from sys import argv as __ARGV__
__ARGV__.append('-b')
from tools import loadJson
from argparse import ArgumentParser
parser = ArgumentParser(description='List mean and RMS of histograms '+ \
'in data files')
parser.add_argument('-b', action='store_true', help='enable batch mode')
parser.add_argument('json', nargs=1, help='specify JSON file containing '+ \
'config information')
parser.add_argument('-p', '--preliminary', action='store_true', \
help='use data files with only 1/80 of data')
args = parser.parse_args()
json = loadJson(args.json[0])
bcids = [str(bx) for bx in json['bunchCrossings']]
scaling = float(json['scaling'])
offsetx = float(json['offsetx'])
offsety = float(json['offsety'])
filepath = str(json['datapath'])
filename = str(json['prefix']) + '_' + str(json['suffix'])
preliminary = args.preliminary
if preliminary:
filename += '_prel'
evaluateScaling(bcids, scaling, offsetx, offsety, filepath, filename, \
preliminary)
def make_dists():
prebuilt_platform_root = path.join("dtls", "prebuilt")
for platform in listdir(prebuilt_platform_root):
config = {"MANIFEST_DIR": path.join(prebuilt_platform_root, platform)}
execfile(path.join(prebuilt_platform_root, platform, "manifest.pycfg"),
config)
files = map(lambda x: "dtls/prebuilt/" + platform + "/" + x,
config["FILES"])
argv.append("--formats=" + config["FORMATS"])
invoke_setup([('dtls', files)])
del argv[-1]
for dist_format in config["FORMATS"].split(','):
source_name = path.join(DIST_DIR,
NAME + "-" + VERSION +
FORMAT_TO_SUFFIX[dist_format])
target_name = path.join(DIST_DIR,
NAME + "-" + VERSION +
".sdist_with_openssl." +
config["ARCHITECTURE"] +
FORMAT_TO_SUFFIX[dist_format])
try:
remove(target_name)
except OSError:
pass
rename(source_name, target_name)
def test_with_help_option(self, capsys):
argv.append("--help")
with pytest.raises(SystemExit) as e:
main()
captured = capsys.readouterr()
assert captured.out == usage
assert e.value.code == 0
def sanitise_args(pname: str, args) -> list:
global argv
if type(args) == tuple:
args = list(args)
if args == ['']:
args = []
args = flatten_list(args)
if type(args) == list and all(map(lambda a: type(a) == str, args)):
args = list(reduce(concat, map(args_from_str, args), []))
elif type(args) == list and all(map(lambda a: type(a) == dict, args)):
# If dictionaries, just unite them and return that, they cannot be further sanitised (we ignore petty issues such as the existence of files here :P)
return dict(reduce(dict_union, args, {}))
elif type(args) == str:
args = args_from_str(args)
else:
die('Unknown argument type, %s received, please use a list of (lists of) strings or just a single string'
% (str(type(args)) if type(args) == list else ', '.join(
set(filter(lambda a: type(a) != str, args)))))
# Put executable name on the front if it is absent (e.g. if called from python with only the arguments specified)
if len(args) == 0 or args[0] != argv[0]:
if len(args) == 0:
argv.append(pname)
elif not argv[0].lower().startswith('blender'):
argv[0] = pname
args = [argv[0]] + list(args)
return args
def print_machines(argv):
global htb
if len(argv) == 0:
argv.append("all")
machines = htb.get_machines()
t = PrettyTable(['ID', 'Name', 'OS', 'Points', 'Maker'])
fltr = argv.pop()
for machine in machines:
if fltr == "retired" and (machine.get("retired_date") != None):
t.add_row([
machine["id"], machine["name"], machine["os"],
machine["points"], machine["maker"]["name"]
])
elif fltr == "active" and (machine.get("retired_date") == None):
t.add_row([
machine["id"], machine["name"], machine["os"],
machine["points"], machine["maker"]["name"]
])
elif fltr == "all":
t.add_row([
machine["id"], machine["name"], machine["os"],
machine["points"], machine["maker"]["name"]
])
print(t)
def test4():
argv.append('l')
argv.append('w')
try: script = WC('nt')
except InteriorSyntaxError:
argv.remove('l')
argv.remove('w')
def load_data():
argv.append(file_path)
if len(argv) == 1:
print "too few arguments"
else:
ls = open(argv[1]).readlines()[1:]
cursor = db.cursor()
cursor.execute("SET SQL_SAFE_UPDATES = 0;")
headers =['`' + e + '`' for e in ls[0].strip().split(",")]
insert_head = "insert into " + table_name + "(" + ','.join(headers) + ")"
#print sql_head.decode('utf-8').encode('gbk')
cnt = 0
for l in ls[1:]:
#print l.decode('utf-8').encode('gbk')
cols = get_cols(l)
if len(cols) != len(headers):
print "数据格式错误", cols
continue
cnt = cnt + 1
if not is_duplicate(cols, headers, cursor):
printu("插入")
sql = insert_head + "values(" + ','.join(["''" if len(e) == 0 else '"' + e + '"' for e in cols]) + ")"
try:
printu(sql)
except Exception, e:
print e
cursor.execute(sql)
else:
update(cols, headers, cursor)
if cnt % 100 == 0:
db.commit()
def test_with_incorrect_word(self, capsys, test_input, expected):
argv.pop() # Remove --help
argv.append(test_input)
with pytest.raises(SystemExit) as e:
main()
captured = capsys.readouterr()
assert captured.out == suggestion
assert e.value.code == expected
def main() -> None:
if len(argv) == 1:
argv.append("up")
arg = argv[1].replace("start", "up").replace("stop", "down")
for action in (up, down):
if arg == action.__name__:
exit(action())
else:
print("usage: silverkube up|down")
def check_argv(argv):
if len(argv) <= 1:
argv.append('')
while argv[1] == '':
user_input = input("enter a string: ")
argv[1] = user_input
main(user_input)
else:
main(argv[1])
def test_main_with_gui_argument(self):
argv.append("-g")
pacsudoku = main()
with open(self.default_config_file) as rawfile:
actual_xml_content = rawfile.readlines()
self.assertEqual([], actual_xml_content)
argv.pop()
pacsudoku.config_file.file.close()
remove(self.default_config_file)
def test_main_with_valid_config_file(self):
argv.append("-c")
argv.append(self.my_config_file)
pacsudoku = main()
with open(self.my_config_file) as rawfile:
actual_xml_content = rawfile.readlines()
self.assertEqual(self.expected_xml_content, actual_xml_content)
argv.pop()
argv.pop()
pacsudoku.config_file_handler.file.close()
def test_g1_check_argv_with(self):
"""
Test the check_if_cmdinp() function with argv
"""
arg = "beehive"
argv.append(arg)
filename = cg.check_if_cmdinp()
self.assertEqual(filename, arg)
argv.remove(arg)
def main():
if len(argv) == 1:
print("usage: " + argv[0] + " 'number'")
print("Es wird per default n!(8) berechnet")
argv.append(8)
if int(argv[1]) > 0:
print(fakt(int(argv[1])))
else:
print("0")
def main():
if len(argv) == 1:
argv.append('-h')
opts = parse_args()
if not isfile(opts.rom):
raise OSError("File '" + opts.rom + "' does not exist")
screen_unicode = True if platform != 'win32' or opts.unicode else False
disp = Display( opts.rom, opts.frequency, 60, 60, opts.drawfix, screen_unicode, opts.audio )
disp.start()
def _parse_args(self):
# display help per default:
if len(argv) == 1:
argv.append("-h")
args = self.arg_parser.parse_args()
self.args = args
if args.verbose:
logging.getLogger().setLevel(logging.INFO)
def _parse_args(self):
# display help per default:
if len(argv) == 1:
argv.append("-h")
args = self.arg_parser.parse_args()
self.args = args
if args.verbose:
logging.getLogger().setLevel(logging.INFO)
def main():
err = "Error: commands are 'add', 'drop', 'send', 'update', 'print', or 'spider'"
from sys import argv, exit
if len(argv) < 2:
print(err)
exit(-1)
get_all_reservations()
if argv[1] == 'send':
if len(argv[2:]) < 1: argv.append('')
send(' '.join(argv[2:]))
elif argv[1] == 'add':
backup()
db = read_db()
if len(argv[2:]) < 2:
Print("Error: {} add <name> <seq> [<seq>...]".format(argv[0]))
else:
Print("Add {} seqs".format(len(argv[3:])))
add_db(db, argv[2], [int(seq.replace(',','')) for seq in argv[3:]])
write_db(db)
elif argv[1] == 'drop':
backup()
db = read_db()
if len(argv[2:]) < 2:
Print("Error: {} add <name> <seq> [<seq>...]".format(argv[0]))
else:
Print("Drop {} seqs".format(len(argv[3:])))
drop_db(db, argv[2], [int(seq.replace(',','')) for seq in argv[3:]])
write_db(db)
elif argv[1] == 'print':
write_db(read_db())
with open(resfile, 'r') as f:
for line in f:
print(line, end='') # Line newline + print newline = extra whitespace
elif argv[1] == 'update':
update()
elif argv[1] == 'spider':
try:
with open(pid_file, 'r') as f:
last_pid = int(f.read())
except FileNotFoundError:
last_pid = None
last_pid = spider(last_pid)
with open(pid_file, 'w') as f:
f.write(str(last_pid) + '\n')
else:
print(err)
exit(-1)
if email_msg:
try:
email('Reservations script warnings', email_msg)
except Exception as e:
Print('Email failed:', e)
Print('Message:\n', email_msg)
def main(argv=argv):
if len(argv) < 2:
argv.append('')
core_controller.set_default_event('help')
kvs = {}
def go(_, new):
k, v = new.split('=', maxsplit=1)
kvs[k] = v
reduce(go, argv[2:], None)
return core_controller.run_event(argv[1], **kvs)
def start():
argv = []
for i in inputEdits:
try:
argv.append(float(i.text()))
except ValueError:
QMessageBox.critical(widget, '错误', '您的输入不合法，请修正')
return
res = calc(*argv)
for i in range(len(res)):
finalEdits[i].setText(str(int(res[i] * 100) / 100))
def run():
from sys import argv
from django.core.management import execute_from_command_line
if len(argv) <= 1:
argv.append('help')
elif len(argv) > 1 and argv[1] == 'run':
argv[1] = 'runserver'
command_line = (
argv[0:2] +
['--settings', 'finitelycomputable.django_apps.settings.dev'] +
argv[2:])
execute_from_command_line(command_line)
def launch(module, includes ,files, out = None, multiple = None):
import sys
from sys import argv
from copy import copy, deepcopy
del argv[1:]
argv.extend(default_defines)
argv.extend(map(lambda include : '-I%s' % include, includes))
argv.append('--module=%s' % module)
if out == None:
out = module
argv.append('--out=%s' % out)
if multiple:
argv.append('--multiple')
argv_saved = copy(argv)
argv.extend(files)
print argv
from os import system
def makecmd():
import string
return ('python -c "from Pyste import pyste; pyste.main()" '
+ string.join(argv[1:], ' '))
system(makecmd())
argv = argv_saved
if multiple:
argv.append('--generate-main')
argv.extend(files)
print 'generating main'
system(makecmd())
def launch(module, includes, files, out=None, multiple=None):
import sys
from sys import argv
from copy import copy, deepcopy
del argv[1:]
argv.extend(default_defines)
argv.extend(map(lambda include: '-I%s' % include, includes))
argv.append('--module=%s' % module)
if out == None:
out = module
argv.append('--out=%s' % out)
if multiple:
argv.append('--multiple')
argv_saved = copy(argv)
argv.extend(files)
print argv
from os import system
def makecmd():
import string
return ('python -c "from Pyste import pyste; pyste.main()" ' +
string.join(argv[1:], ' '))
system(makecmd())
argv = argv_saved
if multiple:
argv.append('--generate-main')
argv.extend(files)
print 'generating main'
system(makecmd())
def arg_checker(argv):
# get arguments
if len(argv) <= 1:
digit = 0
while digit > 4 or digit < 1:
digit = input("enter the # of digits(1-4): ")
digit = int(digit)
argv.append(digit)
elif argv[1] > 4 or argv[1] < 1:
while digit > 4 or digit < 1:
digit = input("enter the # of digits(1-4): ")
digit = int(digit)
else:
digit = argv[1]
return digit
def main() -> int:
try:
int(argv[1])
except IndexError:
argv.append(10)
except ValueError:
usage()
r = requests.get(f"{API}/records/recent/{argv[1]}").json()
runs = (Run(run) for run in r)
print("\n".join(
f"`{run.game_name}, {run.level_name}` [{run.time}]({run.vid}) by {', '.join([player for player in run.runners])}"
for run in runs))
return EXIT_SUCCESS
def runhandler(self):
argv = [
realargv[0], self.inputchooser.filename,
self.scaletextvar.get()
]
if self.outputchooser.filename != None:
argv.append(self.outputchooser.filename)
out = imagetobraille(argv)
if out != None:
print("self.textviewer is {}".format(self.textviewer))
if self.textviewer != None:
print("kaboom")
self.textviewer.destroy()
self.textviewer = None
self.textviewer = TextViewer(self, out)
self.withdraw()
def test_loads(self):
print('{line}TESTING loads{line}'.format(line="-" * 50))
argv.append('-s')
for k, v in inputs.items():
if len(argv) == 2:
argv.append(v)
else:
argv[2] = v
try:
val = JsonParser.loads(v)
if k in specific_loads_values.keys():
self.assertEqual(specific_loads_values[k], val)
else:
self.assertEqual(inputo[k], val)
print(f'SUCCESS Tested value - {v}')
except SyntaxError as e:
print(f'FAILED with value - {v}', f'WITH ERROR - {e.msg}')
def execute_from_command_line(*args, **kwargs):
if len(argv) == 1:
argv.append('help')
cmd = argv[1]
cmd = COMMAND_ALIASES.get(cmd, cmd)
if cmd == '--version':
print_function(__version__)
return
if cmd == '--help':
print_function(MAIN_HELP_TEXT)
return
# [does the below caveat still apply without django?]
# need to set env var rather than setting otree.common.USE_TIMEOUT_WORKER because
# that module cannot be loaded yet.
if cmd in ['prodserver', 'prodserver1of2']:
os.environ['USE_TIMEOUT_WORKER'] = '1'
if cmd in [
'startproject',
'version',
'--version',
'compilemessages',
'makemessages',
'unzip',
'zip',
'zipserver',
'devserver',
]:
# skip full setup.
pass
else:
if cmd in ['devserver_inner', 'bots']:
os.environ['OTREE_IN_MEMORY'] = '1'
setup()
warning = check_update_needed(
Path('.').resolve().joinpath('requirements.txt'))
if warning:
logger.warning(warning)
from otree.cli.base import call_command
call_command(cmd, *argv[2:])
def _parse_args(self):
"""
Parses args and configures the logger according to them.
"""
debug("parsing command line arguments")
# display help per default:
if len(argv) == 1:
argv.append("-h")
self.args = self.arg_parser.parse_args()
if self.args.verbose:
getLogger().setLevel(INFO)
if self.args.debug:
getLogger().setLevel(DEBUG)
def on_sys_execve_enter(cpu, pc, fname_ptr, argv_ptr, envp):
# Log commands and arguments passed to execve unless in kernel
if panda.in_kernel(cpu):
return
try:
fname = panda.read_str(cpu, fname_ptr)
argv_ptrlist = panda.virtual_memory_read(cpu, argv_ptr, 80, fmt='ptrlist')
except ValueError: return
argv = []
for ptr in argv_ptrlist:
if ptr == 0: break
try:
argv.append(panda.read_str(cpu, ptr))
except ValueError:
argv.append(f"(error: 0x{ptr:x})")
print(get_calltree(cpu) + " => " + ' '.join(argv))
def main(argv=None):
global _is_jug_running
_is_jug_running = True
from .options import parse
if argv is None:
from sys import argv
options = parse(argv[1:])
store = None
if options.cmd not in ('status', 'execute', 'webstatus', 'test-jug'):
store, jugspace = init(options.jugfile, options.jugdir)
if options.cmd == 'execute':
execute(options)
elif options.cmd == 'count':
do_print(store, options)
elif options.cmd == 'check':
check(store, options)
elif options.cmd == 'sleep-until':
sleep_until(store, options)
elif options.cmd == 'status':
status(options)
elif options.cmd == 'invalidate':
invalidate(store, options)
elif options.cmd == 'cleanup':
cleanup(store, options)
elif options.cmd == 'shell':
shell(store, options, jugspace)
elif options.cmd == 'webstatus':
webstatus(options)
elif options.cmd == 'test-jug':
try:
import nose
except ImportError:
logging.critical('jug test requires nose library')
return
from os import path
currentdir = path.dirname(__file__)
updir = path.join(currentdir, '..')
argv = ['', '--exe', '-w', updir]
argv.append('--verbose')
return nose.run('jug', argv=argv)
else:
logging.critical('Jug: unknown command: \'%s\'' % options.cmd)
if store is not None:
store.close()
def main():
if len(argv) == 1 or len(argv) > 3:
print 'Usage: [-s] file_name'
exit()
elif len(argv) == 3 and '-s' not in argv:
print 'Usage: [-s] file_name'
exit()
else:
if len(argv) == 2:
file_name = argv[1]
else:
argv.pop(argv.index('-s'))
file_name = argv[1]
argv.append('-s')
try:
inFile = open(file_name, 'r')
except IOError as e:
print e
exit()
total = 0
ints = floats = other = 0
for line in inFile:
the_line = line.split()
for elem in the_line:
try:
temp = int(elem)
ints += 1
total += temp
except:
try:
temp = float(elem)
floats += 1
total += temp
except:
other += 1
inFile.close()
print 'Ints: %d' % ints
print 'Floats: %d' % floats
print 'Other: %d' % other
if len(argv) == 3:
print 'Sum: %.2f' % total
def create(self):
creation_tool = KoverDatasetCreationTool()
parser = argparse.ArgumentParser(usage= \
'''%(prog)s dataset create <data source> [<args>]
The two available data sources are:
from-tsv Create a Kover dataset from genomic data in a tsv format
from-contigs Create a Kover dataset from contigs''')
parser.add_argument('datasource',
help='The type of genomic data to be used.',
choices=creation_tool.available_data_sources)
# If no argument has been specified, default to help
if len(argv) == 3:
argv.append("--help")
args = parser.parse_args(argv[3:4])
args.datasource = args.datasource.replace("-", "_")
getattr(creation_tool, args.datasource)()
def dataset(self):
dataset_tool = KoverDatasetTool()
parser = argparse.ArgumentParser(usage= \
'''%(prog)s dataset <command> [<args>]
The most commonly used commands are:
create Create Kover datasets from genomic data
split Split a Kover dataset file into a training set, a testing set and optionally cross-validation folds
info Get information about the content of a Kover dataset''')
parser.add_argument('command',
help='The dataset manipulation to perform',
choices=dataset_tool.available_commands)
# If no argument has been specified, default to help
if len(argv) == 2:
argv.append("--help")
args = parser.parse_args(argv[2:3])
getattr(dataset_tool, args.command)()
def test_sudoku_argument_parser_class_with_arguments(self):
expected_config_metavar = "other.xml"
argv.append("-g")
argv.append("-c")
argv.append(expected_config_metavar)
parser = SudokuArgumentParser()
actual_arguments = parser.parse_args()
argv.pop()
argv.pop()
argv.pop()
self.assertEqual(expected_config_metavar, actual_arguments.config)
self.assertTrue(actual_arguments.gui)
#!/usr/bin/env python
import re
from sys import argv, stdout, stderr, exit
from optparse import OptionParser
# import ROOT with a fix to get batch mode (http://root.cern.ch/phpBB3/viewtopic.php?t=3198)
hasHelp = False
for X in ("-h", "-?", "--help"):
if X in argv:
hasHelp = True
argv.remove(X)
argv.append( '-b-' )
import ROOT
ROOT.gROOT.SetBatch(True)
ROOT.gSystem.Load("libHiggsAnalysisCombinedLimit.so")
argv.remove( '-b-' )
if hasHelp: argv.append("-h")
parser = OptionParser(usage="usage: %prog [options] in.root \nrun with --help to get list of options")
(options, args) = parser.parse_args()
if len(args) == 0:
parser.print_usage()
exit(1)
file = ROOT.TFile(args[0])
if file == None: raise RuntimeError, "Cannot open file %s" % args[0]
fit_s = file.Get("fit_s")
fit_b = file.Get("fit_b")
prefit = file.Get("nuisances_prefit")
if fit_s == None or fit_s.ClassName() != "RooFitResult": raise RuntimeError, "File %s does not contain the output of the signal fit 'fit_s'" % args[0]
print "LISTE: impacchettamento, spacchettamento; accessibilita', inizializzazione tramite indicizzazione"
lista0 = [1, 4, 5]
print "Se si puo' impacchettare & accedere a una lista tramite indicizzazione, qui di seguito deve comparire il numero 4: ", lista0[1]
(pippo, pluto, paperino) = lista0
print "Se si puo' spacchettare una lista, qui di seguito deve comparire la serie 1 4 5: ", pippo, pluto, paperino
lista1 =[pippo, pluto, paperino]
lista1[0] =5
print "Se si puo' inizializzare una lista tramite indicizzazione, qui di seguito deve comparire una lista: ", lista1
print "\n-----------------------------------------------------------"
print "ARGV: qui testo se vari elementi visti finora sono o meno delle tuple"
argv.append(5)
print "Se sys.argv e' una lista, allora qui di seguito deve essere mostrata una lista contenente il nome dello script seguito dagli argomenti passati allo script e infine dal numero 5", argv
print "\n-----------------------------------------------------------"
print "DICTIONARY"
dic1 = {'a':1, 2:2, 'c':'a'}
key = 'c'
elem = dic1[key]
print "\nIl valore associato alla chiave \'%s\' e': " % key, elem
print "La seguente stampa del dizionario mostra come key e value possano essere insiemi eterogenei: ", dic1
dic2={'Panda':(1, 4), 5:'Foca'}
dic1['a']=dic2
print "La seguente stampa del dizionario mostra come i dizionari possano essere annidabili: ", dic1
#!/usr/bin/env python
import re
from sys import argv, stdout, stderr, exit, modules
from optparse import OptionParser
# import ROOT with a fix to get batch mode (http://root.cern.ch/phpBB3/viewtopic.php?t=3198)
argv.append("-b-")
import ROOT
ROOT.gROOT.SetBatch(True)
argv.remove("-b-")
from HiggsAnalysis.CombinedLimit.DatacardParser import *
from HiggsAnalysis.CombinedLimit.ModelTools import *
from HiggsAnalysis.CombinedLimit.ShapeTools import *
from HiggsAnalysis.CombinedLimit.PhysicsModel import *
parser = OptionParser(usage="usage: %prog [options] datacard.txt -o output \nrun with --help to get list of options")
addDatacardParserOptions(parser)
parser.add_option(
"-P",
"--physics-model",
dest="physModel",
default="HiggsAnalysis.CombinedLimit.PhysicsModel:defaultModel",
type="string",
help="Physics model to use. It should be in the form (module name):(object name)",
)
parser.add_option(
"--PO",
"--physics-option",
dest="physOpt",
'TooFewKeywordSteps': (0,),
'TooFewTestSteps': (0,),
'TrailingBlankLines': (1,),
}
RfLint.__init__(self)
user_rules = join(expanduser('~'), '.rflint.d')
for user_rule in glob('%s/*.py' % user_rules):
if user_rule.endswith('.__init__.py'):
continue
self._load_rule_file(user_rule)
# pylint: disable=expression-not-assigned
[rule.configure(*config[rule.name]) for rule in self.all_rules
if rule.name in config.keys()]
def main(cli_args=None):
"""Lint all given Robot Framework data files."""
response = -1
try:
response = RobotLint().run(cli_args)
# pylint: disable=broad-except
except Exception, e:
stderr.write('%s\n' % str(e))
return response
if __name__ == '__main__':
if len(argv) == 1:
argv.append('--help')
exit(main(argv[1:]))
import re
from sys import argv, stdout, stderr, exit
from math import *
# import ROOT with a fix to get batch mode (http://root.cern.ch/phpBB3/viewtopic.php?t=3198)
argv.append( '-b-' )
import ROOT
ROOT.gROOT.SetBatch(True)
argv.remove( '-b-' )
if len(argv) == 0: raise RuntimeError, "Usage: mlfitNormsToText.py [ -u ] mlfit.root";
errors = False
if len(argv) > 2 and argv[1] == "-u":
errors = True
argv[1] = argv[2];
file = ROOT.TFile.Open(argv[1]);
prefit = file.Get("norm_prefit")
fit_s = file.Get("norm_fit_s")
fit_b = file.Get("norm_fit_b")
#if prefit == None: raise RuntimeError, "Missing fit_s in %s. Did you run MaxLikelihoodFit with --saveNorm?" % file;
if fit_s == None: raise RuntimeError, "Missing fit_s in %s. Did you run MaxLikelihoodFit with --saveNorm?" % file;
if fit_b == None: raise RuntimeError, "Missing fit_b in %s. Did you run MaxLikelihoodFit with --saveNorm?" % file;
iter = fit_s.createIterator()
norms={}
while True:
norm_s = iter.Next()
if norm_s == None: break;
norm_b = fit_b.find(norm_s.GetName())
norm_p = prefit.find(norm_s.GetName()) if prefit else None
samples = SupervisedDataSet(3,1)
for i in data_transformed_training:
samples.addSample(i['past'], i['next'] - i['average'])
trainer = BackpropTrainer(net, samples)
print 'Training'
trainer.trainUntilConvergence(maxEpochs= 10)
#Comparing step-------------------------------------------------------------------
print 'Naive1'
aux = map(lambda y: y['past'], data_transformed)
aux2 = map(lambda y: y['next']-y['average'], data_transformed)
compare_forecast_samples(Forecaster(predict_function = lambda x: aux2[aux.index(x)-1]), data_transformed)
print 'Network'
compare_forecast_samples(Forecaster(predict_function = net.activate), data_transformed)
print "Number of samples %d for training." %len(data_transformed_training)
if __name__ == '__main__':
from sys import argv
if len(argv) < 2:
'''Usage python %s [name_of_samples_file]''' %argv[0]
argv.append('readings_27_04_12_15h22m53s.txt')
print 'Working over', argv[1]
#from pybrain.tools.shortcuts import buildNetWork
main(argv[1])
from os import remove, removedirs, rmdir, system, path, getcwd, makedirs, rename, geteuid, execlpe, environ, execlpe, getenv
from sys import argv, stderr, exit, executable
import shutil
import re
from getpass import getuser
if __name__ == '__main__':
system('sudo -k')
USERNAME = getuser()
#check if root
if geteuid() != 0:
argv.append(USERNAME)
args = ['sudo', executable] + argv + [environ]
# the next line replaces the currently-running process with the sudo
execlpe('sudo', *args)
USERNAME = argv[len(argv) - 1]
if len(argv) <= 2:
exit('Script need new domain name and no root permissions: example python new-domain.py foo.t')
if not path.exists('/home/{0}/www/vhosts'.format(USERNAME)):
makedirs('/home/{0}/www/vhosts'.format(USERNAME))
#Run new vhost: sudo python new-domain.py new-domain.test
#require test base
HOST_LOCATION = '/etc/hosts'
HOST_LINE = '127.0.0.1\t%s'
PATH_WWW_VHOSTS = '/home/{0}/www/vhosts'.format(USERNAME)
from distutils.core import setup
from subprocess import Popen, PIPE
from sys import argv
# I would absolutely *LOVE* to be informed of a sexier way to do this,
# preferably without hard-coding Ubuntu as a special case...
try:
if 'Ubuntu\n' in Popen(('lsb_release', '-si'),
stdout=PIPE).communicate():
argv.append('--install-layout=deb')
except OSError:
pass
setup(name='ofed-le-utils',
version='1.0.3',
author='Amir Vadai',
author_email='*****@*****.**',
url='www.mellanox.co.il',
scripts=['mlnx_qos', 'tc_wrap.py', 'mlnx_perf', 'mlnx_get_vfs.pl', 'mlnx_qcn'],
py_modules=['netlink', 'dcbnetlink', 'genetlink'],
)
import json
import datetime
from sys import argv
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
if len(argv) < 2:
argv.append("config.json")
with open(argv[1]) as fp:
data = json.load(fp)
driver = webdriver.Firefox()
driver.get("https://ezlmappdc1f.adp.com/ezLaborManagerNet/Login/Login.aspx")
try:
assert "Client Login" in driver.title
elem = driver.find_element_by_id("txtClientName")
elem.send_keys(data["clientname"])
elem.send_keys(Keys.ENTER)
except AssertionError:
pass
assert "Login" in driver.title
elem = driver.find_element_by_id("txtUserID")
elem.send_keys(data["username"])
elem = driver.find_element_by_id("txtPassword")
elem.send_keys(data["password"])
elem.send_keys(Keys.ENTER)
assert "Home" in driver.title
driver.find_element_by_link_text("My Benefits").click()
elems = driver.find_elements_by_xpath('//*[@id="tableCurrentHolidays"]/tbody/tr/td[1]')
for elem in elems:
print(datetime.datetime.strptime(elem.text, "%A, %B %d, %Y").date())
yield o
def whitespace_token_boundary_gen(text):
tokens = text.split()
for o in _token_boundaries_by_alignment(tokens, text):
yield o
if __name__ == '__main__':
from sys import argv
def _text_by_offsets_gen(text, offsets):
for start, end in offsets:
yield text[start:end]
if len(argv) == 1:
argv.append('/dev/stdin')
try:
for txt_file_path in argv[1:]:
print
print '### Tokenising:', txt_file_path
with open(txt_file_path, 'r') as txt_file:
text = txt_file.read()
print text
print '# Original text:'
print text.replace('\n', '\\n')
#offsets = [o for o in jp_token_boundary_gen(text)]
#offsets = [o for o in whitespace_token_boundary_gen(text)]
offsets = [o for o in gtb_token_boundary_gen(text)]
print '# Offsets:'
print offsets
return 0
except KeyboardInterrupt:
### handle keyboard interrupt ###
return 0
except Exception as e:
if DEBUG:
raise(e)
pass
indent = len(program_name) * " "
from sys import stderr
stderr.write(program_name + ": " + repr(e) + "\n")
stderr.write(indent + " for help use --help")
return 2
pass
if __name__ == "__main__":
if DEBUG:
from sys import argv
argv.append("-n 700")
argv.append("--minimizer=Powell")
argv.append("--clf-params={'learning_rate': 0.05, 'min_child_weight': 240, 'subsample': 0.9, 'colsample_bytree': 0.67, 'max_depth': 6, 'initial_params': [0.1, -1, -2, -1, -0.8, 0.02, 0.8, 1]}")
argv.append("-f 10")
pass
from sys import exit as Exit
Exit(main())
pass
try:
import nose
except ImportError:
print >> stderr, """\
Requires Nose. Try:
$ sudo easy_install nose
Exiting. """
exit(1)
if "--with-coverage" in argv:
try:
import coverage
except ImportError:
print >> stderr, "No coverage module found, skipping code coverage."
argv.remove("--with-coverage")
else:
NOSE_ARGS += COVERAGE_EXTRA_ARGS
if True not in [a.startswith("-a") or a.startswith("--attr=") for a in argv]:
argv.append("--attr=" + ",".join(DEFAULT_ATTRS))
if not [a for a in argv[1:] if not a.startswith("-")]:
argv += DEFAULT_DIRS # since nose doesn't look here by default..
finalArgs = argv + NOSE_ARGS
print "Running nose with:", " ".join(finalArgs[1:])
nose.run_exit(argv=finalArgs)
inner_hash = myhash(s[1:])
wat = s[0]
return ((ord(wat)<<31)+(ord(wat)<<3)-(ord(wat)+1)+(inner_hash<<5)+(inner_hash>>5))&(0xffffffff)
def get_battery_level():
level = -1
try:
with open("/sys/class/power_supply/BAT0/uevent","r") as f:
uevent_contents = f.read()
property_list = [tuple(x.split("=")) for x in uevent_contents.split("\n") if len(x.split("="))==2]
properties = dict(property_list)
level = int(properties['POWER_SUPPLY_CHARGE_NOW'])*100/int(properties['POWER_SUPPLY_CHARGE_FULL'])
except Exception as e:
level = -1
return min(level,100)
if len(argv)<2:
argv.append("test")
color = (myhash(argv[1]))%16
color_upper = int(color/8)
color_lower = int(color%8)
stdout.write("\033[%d;3%dm%s"%(color_upper,color_lower,argv[1]))
if argv[1]=="clamps": # Battery monitoring on laptop
battery_level = get_battery_level()
stdout.write("(%3d"%battery_level+"%%)") # percent signs are filtered by zsh
from sys import argv, exit, stderr
try: import nose
except ImportError:
print >>stderr, """\
Requires Nose. Try:
$ sudo easy_install nose
Exiting. """; exit(1)
if '--with-coverage' in argv + NOSE_ARGS:
try: import coverage
except ImportError:
print >>stderr, "No coverage module found, skipping code coverage."
argv.remove('--with-coverage')
else:
NOSE_ARGS += COVERAGE_EXTRA_ARGS
if True not in [a.startswith('-a') or a.startswith('--attr=') for a in argv]:
argv.append('--attr=' + ','.join(DEFAULT_ATTRS))
if not [a for a in argv[1:] if not a.startswith('-')]:
argv += DEFAULT_DIRS # since nose doesn't look here by default..
finalArgs = NOSE_ARGS + argv
print "Running nose with:", " ".join(finalArgs[1:])
nose.run_exit(argv=finalArgs)
lengths[1] = max(lengths[1], len(mote.getPort()))
lengths[2] = max(lengths[2], len(mote.getName()))
# Print header
print ("{} {} {}".format("Reference".ljust(lengths[0]),
"Port".ljust(lengths[1]),
"Name".ljust(lengths[2])))
# Print seperator
print ("{} {} {}".format("".ljust(lengths[0], "-"),
"".ljust(lengths[1], "-"),
"".ljust(lengths[2], "-")))
# Print motelist
for mote in motelist:
print ("{} {} {}".format(mote.getReference().ljust(lengths[0]),
mote.getPort().ljust(lengths[1]),
mote.getName().ljust(lengths[2])))
if __name__ == '__main__':
if len(argv) == 1:
argv.append("")
if argv[1] == "-c":
for x in Motelist.getMotelist(True):
print (x.getCSVData())
elif argv[1] == "-h":
print ("Use motelist.py -c for CSV data.")
else:
Motelist.printMotelist()
def getCompressionInfo(inputText,codeMap):
''' Return a Tuple containing the original number of bits, the final number of bits, and the compression ratio.'''
codedSum=0
for char in inputText:
codedSum=codedSum+len(codeMap[char])
startSize=len(inputText)*8
endSize=codedSum
ratio=float(startSize)/endSize
return (startSize,endSize,ratio)
def printCodeInfo(inputText,codeMap):
print 'Code Map:'
printCode(codeMap)
rawSize,compressedSize,ratio=getCompressionInfo(inputText,codeMap)
print 'Original Size(bits):',rawSize,', Compressed Size(bits):',compressedSize,', Compression Ratio:',ratio
if(len(argv)>2):
print 'expecting one argument'
exit()
elif(len(argv)==1):
argv.append('InputOutput.txt')
inputFile=open(argv[1],'r')
inputText=inputFile.read()
codeMap,codeTree=huffman.getCodeFromText(inputText)
huffmanCoder=huffman.HuffmanCoder(codeMap,codeTree)
pickleFile=open('huffmanCode','w')
pickle.dump(huffmanCoder,pickleFile)
pickleFile.close()
args.out_csv_file,
args.nest,
args.njobs)
return 0
except KeyboardInterrupt:
### handle keyboard interrupt ###
return 0
except Exception as e:
if DEBUG:
raise(e)
pass
indent = len(program_name) * " "
from sys import stderr
stderr.write(program_name + ": " + repr(e) + "\n")
stderr.write(indent + " for help use --help")
return 2
pass
if __name__ == "__main__":
if DEBUG:
from sys import argv
argv.append("-h")
pass
from sys import exit as Exit
Exit(main())
pass
# help="snpEff output file", default=None)
# grab options and arguments in an usable form
#parser.add_option("-l", dest="log_file",
# help="Optional log file", default=None)
#parser.add_option("-o", dest="out_prefix",
# help="Prefix for output files", default=None)
parser.add_argument("-l", dest="log_file",
help="Optional log file", default=None)
parser.add_argument("-o", dest="out_prefix",
help="Prefix for output files", default=None)
if not argv[1:] :
argv.append('-h')
prog_name = os.path.basename(argv[0])
args = parser.parse_args()
#print options
if not args.vcf_file :
parser.error("\nvcf file missing.")
else :
if not os.access(args.vcf_file, os.R_OK):
parser.error("Unable to read vcf file %s " %args.vcf_file)
if not args.out_prefix :
out_snp = args.vcf_file[:-4]+".snp"
out_indel = args.vcf_file[:-4]+".indel"
from pyd.support import Extension
from pyd.support import setup
from pyd import patch_distutils
from sys import argv
if argv[-1] == "opt":
print("building with optimalization")
argv.pop()
argv.append("build")
argv.append("-c")
argv.append("ldc2")
argv.append("-O")
else: argv.append("build")
projName = 'dbindings'
sources = ['dbindings.d',
'ea/ea_config.d',
'ea/population.d',
'ea/individual.d',
'ea/beer_tracker_individual.d',
'ea/beer_tracker_population.d',
'flatland/flatland_agent.d',
'flatland/flatland_simulator.d',
'flatland/flatland_evolve.d',
'ann/ann.d',
'ann/matrix.d',
'ann/ann_config.d',
'ann/ctrnn.d',
invalid_xmldocs.appendChild(invalid_doc)
invalidstat[sub("[0-9:]*\s", "", errstring)] += 1
def parseFile(filename):
"""
Parse XML document by filename
"""
parser = make_parser()
parser.setContentHandler(ContentHandler())
parser.parse(filename)
# Program starts here
# Throughpass all documents in globally defined mail folder
# (=input XML docs)
if len(argv) == 1:
argv.append(get_mailfolder() + "*")
for arg in argv[1:]:
for filename in glob(arg):
# If works, document is well-formed
try:
parseFile(filename)
# If exception occurs, document is not well-formed; add to
# collection of invalid docs.
except Exception, e:
add_invalid_docs(filename, str(e))
print filename
continue
# Prepare XML file to write invalid input XML files of the
# collection into.
invalid_xml_filehandler = open(get_invalid_xml_filename(), "w", get_def_enc())
def test_times_generic(setup):
number = TEST_NUMBER
repeat = TEST_REPEAT
print("testing", repeat, "times", number, "calls of each implementation")
executionStack = {}
results = []
for func in TEST_THESE:
executionStack[func.__name__]\
= '(*values)'
for funcname, values in executionStack.items():
stmt = 'list(testrange.' + funcname + values + ')'
min_time = min(
timeit_repeat(stmt=stmt, setup=setup, number=number, repeat=repeat))
results.append((funcname, min_time * 1000))
print("%40s -- time consumption in milliseconds" % ("implementation"))
for result in sorted(results, key=lambda r: r[1]):
print("%40s -- %5.0f" % result)
def test_times():
for title, setup in SETUPS_WITH_CONDITIONS.items():
print("testing with condition", title)
test_times_generic(setup)
if __name__ == '__main__':
argv.append("--disablegui")
for _ in range(10):
test_sophisticated()
test_times()
def item_details(id_val):
data = get("https://api.guildwars2.com/v2/items/{0}".format(id_val)).json()
return { prop: data[prop] for prop in ["name", "description", "level", "rarity", "restrictions"] }
def item_prices(id_val):
data = get("https://api.guildwars2.com/v2/commerce/prices/{0}".format(id_val)).json()
return {
"lowest_sell": data["sells"]["unit_price"],
"highest_buy": data["buys"]["unit_price"]
}
def copper_to_coins(copper, as_dict = False):
coins = (copper // 10000, copper % 10000 // 100, copper % 100)
if as_dict:
return dict(zip(["gold", "silver", "copper"], coins))
else:
return coins
if __name__ == "__main__":
if len(argv) < 2:
argv.append(raw_input("Please enter an item's ID value or chat code: "))
try:
item_id = int(argv[1])
except ValueError:
item_id = chat_code_to_id(argv[1])
prices = item_prices(item_id)
print("Lowest sell: {}".format(copper_to_coins(prices["lowest_sell"])))
print("Highest buy: {}".format(copper_to_coins(prices["highest_buy"])))
self.close()
os.system("gui_interaction.py restart")
def looper(self):
while True:
time.sleep(1)
self.updateSig.emit()
def vaultlooper(self):
while True:
time.sleep(3)
self.vaultSig.emit()
if __name__ == '__main__':
argv.append("building")
app = QApplication(argv)
if "restart" not in argv and "building" not in argv:
os.system("commands\\minimize.bat")
ss = QSplashScreen(QPixmap("images/splash.png"))
ss.show()
ss.showMessage("Loading Components", alignment=Qt.AlignBottom|Qt.AlignHCenter, color=Qt.white)
mp = gui_interaction()
time.sleep(2)
ss.showMessage("Initialising Components", alignment=Qt.AlignBottom|Qt.AlignHCenter, color=Qt.white)
time.sleep(3)
ss.showMessage("Finished Loading. Welcome to MagPy.", alignment=Qt.AlignBottom|Qt.AlignHCenter, color=Qt.white)
time.sleep(1)
mp.show()
ss.hide()
else:
