def main(): root = init_root_app() run(app=root, host=settings.SERVER_HOST, port=settings.SERVER_PORT, reloader=settings.SERVER_RELOAD, debug=settings.SERVER_DEBUG)
def main(opts): log_level = logging.CRITICAL parser = optparse.OptionParser("%prog [options]", version="%prog 0.01") parser.add_option("-W", "--screen-width", action = "store", type = "int", default = "800", dest = "width", help = "set custom screen width") parser.add_option("-H", "--screen-height", action = "store", type = "int", default = "600", dest = "height", help = "set custom screen height") group = optparse.OptionGroup(parser, "Dev Options") group.add_option("-d", "--debug", action = "store_true", dest = "debug", help = "enables debug mode") parser.add_option_group(group) (opts, args) = parser.parse_args() if opts.debug: log_level = logging.DEBUG try: core.init(log_level) core.run(opts.width, opts.height) except KeyboardInterrupt: g_logger.info("Keyboard interrupt received, shutting down...") except SystemExit: raise except error.NoImageFound, e: g_logger.critical("Failed to find image: %s" % e) return error.NO_IMAGE
def liveInput(self): MainWindow.hide() now = datetime.now() dateVar = now.strftime("%d/%m/%Y") timeVar = now.strftime("%H:%M:%S") core.run(0, dateVar, timeVar) MainWindow.show()
def main(): logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s', stream=sys.stdout) # https://news.google.com/?output=rss&hl=fr # RSS Feed does not work for Japanese/Chinese language. args = get_script_arguments() keywords = args.keywords.split(',') if args.keywords is not None else None run(keywords=keywords, language=args.language, limit=args.limit_num_links_per_keyword, retrieve_content_behind_links=args.retrieve_content_behind_links, num_threads=args.num_threads)
def cli(): global parser global DB_FILENAME parser.add_argument('--db-file', dest='db_file', action='store', default=DB_FILENAME, help='Specify SQLite DB file to be used (default: vsmt.sqlite) ') operation = parser.add_argument_group('Operations') operation.add_argument('-o', "--operation", dest='operation', action='store', help='Use operations to configure vsmt. Availabe operations: add_sensor/remove_sensor/modify_sensor/list_sensors') operation.add_argument('-Sn', "--sensor-name", dest='sensor_name', action='store', help='Sensor name') operation.add_argument('-St', "--sensor-type", dest='sensor_type', action='store', help='Sensor type. Possible values: [ping]') operation.add_argument('-Sh', "--sensor-hostname", dest='sensor_hostname', action='store', help='Sensor hostname.') operation.add_argument('-Sp', "--sensor-parameters", dest='sensor_paramneters', action='store', help='Sensor parameters in JSON format YYYY . Example: XXXXX') #TODO: move parameters name debug = parser.add_argument_group('Alternative working modes') debug.add_argument("-a", "--action", action="store", dest='action', help='Instead of runing daemon run just single action. Available actions: ping, sensor_ping') debug.add_argument("-H", "--hostname", action="store", dest='hostname', help='Host name') debug.add_argument("-st", "--sleep-time", action="store", default=1, dest='sleep_time', help='Sleep time between actions') #debug = parser.add_argument_group('Debugging arguments') #debug.add_argument("-d", "--debug", action="count", default=0, help="Turn on debug mode") args = parser.parse_args() #Handle operations if args.operation == 'add_sensor': if (args.sensor_name == None or args.sensor_type == None or args.sensor_hostname == None): print_exit("To add sensor you need to specify following attributes: sensor-name, sensor-type, sensor-hostname") elif args.sensor_type != 'ping': print_exit("Incorrect sensor type") else: db.add_sensor(args.db_file, args.sensor_name,args.sensor_type,args.sensor_hostname,args.sensor_paramneters) elif args.operation == 'remove_sensor': if (args.sensor_name == None): print_exit("To remove sensor you need to specify following attributes: sensor-name") else: db.remove_sensor(args.db_file, args.sensor_name) elif args.operation == 'list_sensors': db.list_sensors(args.db_file) #Handle actions elif args.action == 'ping': if args.hostname == None: print_exit("For 'ping' action 'hostname' is mandatory.") else: print(ping.ping(args.hostname)) elif args.action == 'sensor_ping': if args.hostname == None: print_exit("For 'ping' action 'hostname' is mandatory.") else: print(sensor.sensor_ping(args.hostname, output=True, sleep_time=float(args.sleep_time))) else: core.run(args.db_file)
def takeInput(self): videoName = self.ui.video_name.text() dateVar = self.ui.dateEdit.text() timeVar = self.ui.timeEdit.text() if not videoName: QtWidgets.QMessageBox.about( self.window, "Warning !", "<html><head/><body><p align=\"center\"><span style=\" font-size:12pt; font-weight:350; color:#ffffff;\">Please Enter Video Name</span></p></body></html>" ) return self.window.hide() core.run('./Input/' + str(videoName), dateVar, timeVar) self.window.show()
def click(): if request.method == 'POST': n = request.form['n'] if (n == 0) or (n == '') or (n.isnumeric() == False): return redirect(url_for('invalidn')) file = request.files['nm'] if file.filename == '': return redirect(url_for('nofile')) photoid = datetime.now().strftime('%Y%m-%d%H-%M%S') inputfilename = "saved" + photoid + ".jpg" filepath = os.path.join(app.config['inputt'],inputfilename) file.save(filepath) outputfilename = core.run(filepath,int(n),photoid) filepath = os.path.join(app.config['output'], outputfilename) #print(filepath) #print(photoid) return render_template("index.html", clicked = True, filelink = filepath)
def run(_celery_task, *pargs, **kwargs): kwargs['_job_manager'] = _celery_task.job_manager \ if hasattr(_celery_task, 'job_manager') else None kwargs['status'] = JobStatus.RUNNING return core.run(*pargs, **kwargs)
def processjson(self, jsonData, url, environ): if CARAVAN_DEBUG: print "jsonData ("+self.__class__.__name__+"):\n"+ str(jsonData)+"\n\n" #FIXME: CHECK INLINE IMPORT PERFORMANCES!!! runinfo = RunInfo(jsonData) if runinfo.status()==1: #running, ok #session_id = new_session_id() #RUNS[session_id] = runinfo #should we add a Lock ? theoretically unnecessary... runinfo.msg("Process started at "+time.strftime("%c")) run(runinfo) RUNS[runinfo.session_id()] = runinfo #should we add a Lock ? theoretically unnecessary... return {'session_id':runinfo.session_id(), 'scenario_id':0} else: #if CARAVAN_DEBUG: return {'error': "Run simulation error: "+str(runinfo)}
def run(self): signal.signal(signal.SIGINT, self.exit) signal.signal(signal.SIGTERM, lambda signum, stack_frame: sys.exit(1)) try: core.initialize() core.run() except KeyboardInterrupt: pass except Exception: self.log.error(traceback.format_exc()) if self.do_restart: self.log.info("Going to sleep 2 seconds and restart") time.sleep(2) self.restart()
def main(): reqs = core.getReqs() # core.downloadNke(reqs[0]) # core.unzip() # core.compile() core.run(5) core.submit(reqs[0], core.prepareOutput(reqs[0]['arquivo'])) return while 1: reqs = core.getReqs() print(type(reqs[0]['status'])) filaEspera = core.filtraReqsStatus(reqs, 'espera') for req in filaEspera: core.downloadNke(req) core.unzip() core.compile() core.run(60) core.prepareOutput(req['arquivo'])
def run(_celery_task, *pargs, **kwargs): kwargs['_job_manager'] = _celery_task.job_manager \ if hasattr(_celery_task, 'job_manager') else None kwargs['_celery_task'] = _celery_task kwargs['status'] = JobStatus.RUNNING return core.run(*pargs, **kwargs)
def main(): """Parses command line arguments and runs the LTL contract checker tool""" # initialize default command line values version = '1.0' verbose = False spec_file = 'system.spec' smv_file = 'nusmv.smv' # configure command line short-form and long-form options options, _ = getopt.getopt(sys.argv[1:], 'hvi:o:', ['verbose=', 'spec=', 'smv=']) # parse command line arguments for opt, arg in options: if opt == '-h': print 'test.py -i <specfile> -o <smvfile>' sys.exit() elif opt in ('-v', '--verbose'): verbose = True elif opt in ('-i', '--spec'): spec_file = arg elif opt in ('-o', '--smv'): smv_file = arg # print tool configurations if verbose: print 'VERSION :', version print 'VERBOSE :', verbose print 'SPEC_FILE :', spec_file print 'SMV_FILE :', smv_file # parse system specification file contracts, checks = parse(spec_file) # compile NuSMV file generate(contracts, checks, smv_file) print checks # run NuSMV file run(smv_file, checks)
def run(*pargs, **kwargs): jobInfo = kwargs.pop('jobInfo', {}) retval = 0 with JobManager(logPrint=jobInfo.get('logPrint', True), url=jobInfo.get('url'), method=jobInfo.get('method'), headers=jobInfo.get('headers'), reference=jobInfo.get('reference')) as jm: kwargs['_job_manager'] = jm kwargs['status'] = JobStatus.RUNNING retval = core.run(*pargs, **kwargs) return retval
def search(paths): global notFoundSubs for fp in paths: print('found {0}'.format(basename(fp))) if isdir(fp): print("it's directory, doing recursive search\n\n") search([abspath(fp + "/" + e) for e in listdir(fp)]) continue if fp.split(".")[-1] not in ["mp4", "avi", "mkv"]: print("it's not a video.\n\n") continue parent = dirname(fp) filename = basename(fp)[0:-(len(fp.split(".")[-1]) + 1)] if exists(parent + "/" + filename + ".smi") or exists(parent + "/" + filename + ".srt"): print("subtitle already exists!\n\n") continue print("\n\n", end="") res = core.run(filename, parent) if res is False: notFoundSubs.append(filename)
res = 0 for elem in xrange(start, start + step * count, step): res += elem return res def formula(count): return (start * 2 + step * (count - 1)) * count / 2 pow10_wrapper = lambda func: (lambda arg: func(10 ** arg)) if __name__ == '__main__': core.run( 'arith_sum', 'N elements', core.optimized(naive) + [ ('formula', formula), ], [ ('linear', None, core.linear_scale(600000, 5)), ], exec_compare=False, draw_plot=False, ) core.run( 'arith_sum', '10 ** N elements', [ ('cpm', pow10_wrapper(cpmoptimize()(naive))), ('formula', pow10_wrapper(formula)), ], [ ('exp', None, core.linear_scale(10000, 5)), ], exec_compare=False, draw_plot=False, )
def _optimal(first, count): # Returns (sum, coeff ** count) if count & 1: sub_sum, sub_pow = _optimal(first, count - 1) return first + sub_sum * coeff, sub_pow * coeff if not count: return 0, 1 sub_sum, sub_pow = _optimal(first, count >> 1) return sub_sum * (1 + sub_pow), sub_pow * sub_pow def optimal(count): """Optimal algorithm based on the idea similar to the binary exponentiation.""" return _optimal(start, count)[0] if __name__ == '__main__': core.run( 'geom_sum', None, core.optimized(naive) + [ ('optimal', optimal), ], [ (None, 'linear', core.linear_scale(10000, 15)), ], )
def main(): core.setup() core.run()
def get_output(self, packet): core.run(self, packet) return core.ctrl(self)
from core import run if __name__ == '__main__': # https://news.google.co.jp # https://news.google.com/?output=rss&hl=fr # RSS Feed does not work for Japanese language. # get_articles('プロクター・アンド・ギャンブル') run()
from core import run, send import os from datetime import date from secrets import VACANCY_LIST now = date.today() dir_name = './' + str(now.day) + str(now.strftime("%b")) + '/' filename_tail = "_" + str(now.day) + "_" + str(now.month) + "_new_vacancies.txt" i = 0 files = [] file_all = "" for vacancy in VACANCY_LIST: run(vacancy) vacancy_split = "_".join(vacancy.split()) fl = open(dir_name + f'{vacancy_split}' + f'{filename_tail}', 'r', encoding='utf-8' ) files.append(fl.read()) file_all += (vacancy.upper() + " VACANCIES:\n\n")* bool(files[i]) + files[i] * bool(files[i]) fl.close() i += 1 if file_all == "": print("Nothing to send") else: file_name = dir_name + "all" + f"{filename_tail}" f_all = open(f"{file_name}", "w+", encoding="utf-8" ) f_all.write(file_all) f_all.close() send(file_name)
import core core.run( generator=core.site.Categories['Pages with incorrectly-ordered templates'], old_pattern='{{av}}\n{{Creaturelookup/0}}', new_pattern='{{Creaturelookup/0}}\n{{av}}', summary='Fixing template order: {{Creaturelookup/0}} before {{av}}', )
def main(argv): core.run(FLAGS)
def binary_exp(n): """Binary exponentiation algorithm""" cur = base res = 1 if not n: return res while True: if n & 1: res *= cur if n == 1: return res cur *= cur n >>= 1 def built_in(n): return base ** n if __name__ == '__main__': core.run( 'power', None, core.optimized(naive) + [ ('binary', binary_exp), ('built-in', built_in), ], [ (None, 'linear', core.linear_scale(10000, 15)), ], )
def test(): cnt = Count() core.run(prange, [duplicate], cnt) print cnt._fn.count
def fast_doubling(n): """Fast doubling - implementation via matrix exponentiation with the redundant calculations removed.""" return _fast_doubling(n)[0] if __name__ == '__main__': # Test all functions on different testcases core.run( 'fib', None, core.optimized(naive) + [ ('matrices', classic_matrices), ('fast dbl', fast_doubling), ], [ ('small', 'linear', core.linear_scale(30000, 15)), ('big', 'linear', core.linear_scale(300000, 15)), ], ) # Test optimized function with different settings core.run( 'fib', None, core.optimized(naive), [('demo', 'linear', core.linear_scale(60000, 30))], ) core.run( 'fib', None, core.optimized(naive, iters_limit=10000),
# Test that allows Bender to reach the goal while testing all possible rules import core SAMPLE_INPUT_DIMS = '15 15' SAMPLE_INPUT_GRID_LINES = [ '###############', '# IXXXXX #', '# @ #', '# #', '# #', '# I #', '# B #', '# B S W#', '# B T #', '# #', '# T #', '# B #', '# $#', '# XXXX #', '###############' ] SAMPLE_EXPECTED_OUTPUT_LINES = [ 'SOUTH', 'SOUTH', 'SOUTH', 'SOUTH', 'SOUTH', 'SOUTH', 'SOUTH', 'SOUTH', 'SOUTH', 'SOUTH', 'SOUTH', 'WEST', 'WEST', 'NORTH', 'NORTH', 'NORTH', 'NORTH', 'NORTH', 'NORTH', 'NORTH', 'NORTH', 'NORTH', 'NORTH', 'NORTH', 'NORTH', 'EAST', 'EAST', 'EAST', 'EAST', 'EAST', 'EAST', 'EAST', 'EAST', 'EAST', 'EAST', 'EAST', 'EAST', 'SOUTH', 'SOUTH', 'SOUTH', 'SOUTH', 'SOUTH', 'SOUTH', 'WEST', 'WEST', 'WEST', 'WEST', 'WEST', 'WEST', 'SOUTH', 'SOUTH', 'SOUTH', 'EAST', 'EAST', 'EAST' ] h, w = core.parse_dims(SAMPLE_INPUT_DIMS) grid = core.parse_grid(SAMPLE_INPUT_GRID_LINES, w, h) core.run(grid, SAMPLE_EXPECTED_OUTPUT_LINES)
a += i res += a else: # Test "else" case res += 8943 * (res ^ 2321) # Test that local and global variables were successfully assigned # after the ending of the loop res += global_var + local_var r = 3 # Loop with unused counter for it1 in xrange(-3231, n): r = r - 33 + d * 2 q = 43 # Loop with used and modified counter for it2 in xrange(-3231, n, 4345): q = (3 + 4) * q - (it2 * 2 - 8) * 3 it2 = q + 3 - e # Empty loop for it3 in xrange(n): pass # Return ordered list with values of all local variables return tuple(sorted(locals().items(), key=lambda item: item[0])) if __name__ == "__main__": core.run("int_operations", None, core.optimized(naive), [(None, "linear", core.linear_scale(600000, 15))])
#!/usr/bin/python # -*- coding: utf-8 -* import web import core import json urls = ( '/add_task', 'add_task', '/update_cron', 'update_cron', ) class add_task: def POST(self): data = json.loads(web.data()) core.add_task(data['path'], data['data']) class update_cron: def GET(self): core.update_cron() app = web.application(urls, globals()) if __name__ == '__main__': cron, task = core.run() cron.start() task.start() app.run() cron.join() task.join()
#!/usr/bin/env python3 from core import run from gui import run_gui from sys import argv if len(argv) == 2 and argv[1] == '--help': print ("linkinator --help") print ("linkinator <source-path> <destination-path>") print ("linkinator") elif len(argv) == 3: p = argv[1:] run(p[0], p[1]) else: run_gui(run)
def test_03(): core.debug_log("Running Test 03") budgets = [100, 1, 60] c = 100 expected_output = [1, 49, 50] core.run(c, budgets, expected_output)
# Copyright (c) 2021 CyberSafe Labs, Inc. # This Software is Protected by the GPL-3.0 License # Violation of the license could lead to possible legal action import core print( "Aqua Lang v1.0.0 by Aditya Patil, Source Code released under the GPL-3.0 License. See License for more information." ) print("Shell Version: 1.0.0") print("Copyright (c) 2021 CyberSafe Labs, Inc.") while True: text = input('AquaLang > ') if text.strip() == "": continue result, error = core.run('<stdin>', text) if error: print(error.as_string()) elif result: if len(result.elements) == 1: print(repr(result.elements[0])) else: print(repr(result))
if not os.path.exists(mod_path): print "Couldnt extend path to"+mod_path+": path doesnt exist" print "Extending search path to", mod_path sys.path.append(mod_path) import localdb import core def def_params(localdb): localdb.write_once("/db", None) def init_database(): localdb_path = "./localdb.pickle" try: config_dir = os.environ['CONFIG_DIR'] localdb_path = os.path.join(config_dir, 'localdb.pickle') if not os.path.exists(config_dir): os.mkdir(config_dir) except: pass try: localdb_path = os.environ['LOCALDB_PATH'] except: pass localdb.init_localdb(localdb_path, def_params) if __name__ == "__main__" : init_database() core.run()
import core core.run( generator=core.site.Pages['Template:New in v0.42'].embeddedin(namespace='DF2014', filterredir='nonredirects'), old_pattern='{{creaturedesc}}\n{{new in v0.42}}', new_pattern='{{new in v0.42}}\n{{creaturedesc}}', summary='Fixing template order: {{new in v0.42}} before {{creaturedesc}}', )
def test_01(): core.debug_log("Running Test 01") budgets = [3, 100, 100] c = 100 expected_output = [3, 48, 49] core.run(c, budgets, expected_output)
import core PATH = '../samples/test2.txt' AVOID_DOUBLES = True UNIQUE_TESTS = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] INDEXES = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] ALGORITHMS = ['bfs', 'dfs'] core.run(PATH, AVOID_DOUBLES, UNIQUE_TESTS, INDEXES, ALGORITHMS)
def test_05(): core.debug_log("Running Test 05") budgets = [3, 3, 3] c = 3 expected_output = [1, 1, 1] core.run(c, budgets, expected_output)
self.param_value = Label(text=str(self.slider.value), font_size=20, size_hint_x=.1) self.add_widget(self.param_value) self.slider.bind(value=self.on_value) def on_value(self, slider, value): value = self.clip_value(value) # update slider text self.param_value.text = str(value) return self.callback(self.name, value, self.label) def set_value(self, value): self.slider.value = self.clip_value(value) def clip_value(self, value): # temporary solution to prevent floating point error / trailing 0s if type(self.step) == int: return round(value) else: return round(value, 1) def change_font_size(self, size): self.param_label.font_size = size self.param_value.font_size = size if __name__ == "__main__": run(ParamSlider)
def test_06(): core.debug_log("Running Test 06") budgets = [10, 100, 100] c = 100 expected_output = [10, 45, 45] core.run(c, budgets, expected_output)
import core urls = ( '/', 'visitor.welcome.index', '/earn', 'visitor.welcome.earn', '/donate', 'visitor.welcome.donate', '/signup', 'visitor.account.create', '/login', 'visitor.account.login', '/account', 'visitor.account.display', '/logout', 'visitor.account.logout', '/admin', 'admin.manage.index', '/admin/static', 'admin.manage.static', '/admin/display', 'admin.manage.display', '/admin/getData', 'admin.manage.getData', '/admin/login', 'admin.auth.login', '/admin/captcha.png', 'admin.auth.captcha' ) if __name__ == "__main__": core.run(urls)
def test_07(): core.debug_log("Running Test 07") budgets = [5, 10, 5] c = 10 expected_output = [3, 3, 4] core.run(c, budgets, expected_output)
elem *= coeff return res def _optimal(first, count): # Returns (sum, coeff ** count) if count & 1: sub_sum, sub_pow = _optimal(first, count - 1) return first + sub_sum * coeff, sub_pow * coeff if not count: return 0, 1 sub_sum, sub_pow = _optimal(first, count >> 1) return sub_sum * (1 + sub_pow), sub_pow * sub_pow def optimal(count): """Optimal algorithm based on the idea similar to the binary exponentiation.""" return _optimal(start, count)[0] if __name__ == '__main__': core.run( 'geom_sum', None, core.optimized(naive) + [ ('optimal', optimal), ], [ (None, 'linear', core.linear_scale(10000, 15)), ], )
from core import run import random if __name__ == '__main__': for i in range(1000): # Choice of hyper-parameters hyper_params = { 'lambda_value': random.random() * 100, # 'lambda_value': 70.29, 'hidden_layer_number': random.randint(3, 7), # 'hidden_layer_number': 4, 'K': random.randint(10, 100), # 'K': 39, 'D_prime': random.randint(50, 100), # 'D_prime': 66, 'hidden_unit_number': 50, 'dropout_rate': random.random() * 0.5, 'learning_rate': 1e-3, } batch_size = 128 valid_rmse, test_rmse = run(batch_size=batch_size, **hyper_params) print('\t'.join(sorted(hyper_params.keys())), valid_rmse, test_rmse) msg = '{}\t{}\t{}'.format('\t'.join( str(hyper_params[key]) for key in sorted(hyper_params.keys())), valid_rmse, test_rmse) print(msg) with open('results/ml-1m.txt', 'a') as f: f.write(msg + '\n')
import logging import core logger = logging.getLogger('main') logger.setLevel(level=logging.DEBUG) # Handler handler = logging.FileHandler('result.log') handler.setLevel(logging.INFO) formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) logger.addHandler(handler) logger.info('Main Info') logger.debug('Main Debug') logger.error('Main Error') core.run()
import itertools import pickle import core ### varying v ### ds = [1, 2, 3] trials = 20 results_list = [] segcoeffs_list = [] unhappys_list = [] trial_num = [] print "Number of trials for each v:", trials for d in ds: for t in range(trials): trial_num.append(d + t * 1. / trials) [results, segcoeffs, unhappys] = core.run(n=20, v=d) while len(unhappys) == 200: [results, segcoeffs, unhappys] = core.run(n=20, v=d) results_list.append(results) segcoeffs_list.append(segcoeffs) unhappys_list.append(unhappys) print '%.2f' % trial_num[-1] print "Number of steps until equilibrium" unhappys_len = [len(unhappys_list[i]) for i in range(len(unhappys_list))] unhappys_mean = [ np.mean(unhappys_len[trials * k:trials * (k + 1)]) for k in range(len(ds)) ] unhappys_std = [ np.std(unhappys_len[trials * k:trials * (k + 1)]) for k in range(len(ds)) ]
def test_04(): core.debug_log("Running Test 04") budgets = [20, 20, 20] c = 100 expected_output = "IMPOSSIBLE" core.run(c, budgets, expected_output)
def test1(): core.run(Range(10), [duplicate], putStrLn)
from core import run if __name__ == '__main__': print('\n======================\n' + 'Chess in Python\nVincent Piegsa © 2020\n' + '======================\n') run()
def test_02(): core.debug_log("Running Test 02") budgets = [40, 40, 40] c = 100 expected_output = [33, 33, 34] core.run(c, budgets, expected_output)