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