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 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: