def index():
# initialize form
form = ScrapeForm()
# POST method
if form.validate_on_submit():
# run scraping program with argument values from Form
filename, err, errmsg = driver.main(search_str=request.form["item"], pages=int(
request.form["page"]), site=request.form["site"])
# render hompage with errors if any
if err:
print(f"ERROR: {errmsg}")
return render_template("index.html", sites=sites, form=form)
state = {"site": request.form["site"], "item": request.form["item"]}
state["filename"] = os.path.join(ROOT_DIR, filename)
session["info"] = state
# redirect to results page if no errors occur
return redirect(url_for("result"))
# GET method return homepage
return render_template("index.html", sites=sites, form=form)
def testCreateDriverWithCompilerInstance():
source = path.join("tests", "scanner", "average_text_correct")
env = environment.empty()
env[environment.LAST_PHASE] = "scanner"
result = driver.main([source, TMP_OUT], compiler=Compiler(env))
assertEqual(0, result)
assertNoDiff(TMP_OUT, source + ".expect")
os.remove(TMP_OUT)
def main():
m_max = 25
obj_size = 1
default_radius = 5
default_num_agents = 20
default_vol_prob = 0.01
TIME_LIMIT = 1500
num_exp = 40
ms = np.linspace(10, m_max, m_max + 1 - 10, endpoint=True, dtype=int)
radii = np.linspace(1, m_max, m_max + 1, endpoint=True, dtype=int)
#num_agents = np.array([1, 3, 5, 7])
num_agents = np.linspace(1, m_max, m_max, endpoint=True, dtype=int)
probabilities = np.linspace(0, 1, 20, endpoint=False)
m = m_max
# time_results = np.zeros((radii.size, num_agents.size, num_exp))
# for i in range(radii.size):
# for j in range(num_agents.size):
# for k in range(num_exp):
# t = dr.main(m, num_agents[j], 0, radii[i], 1, 5000, default_vol_prob, TIME_LIMIT = TIME_LIMIT)
# time_results[i,j,k] = t
# print 'Time ' + str(t) + ' radius ' + str(radii[i]) + ' num_agents ' + str(num_agents[j])
# for i in range(num_exp):
# print time_results[:,:,i]
# print '~~~~~~~~~~~~~~~~~~~~~~~~~~'
# print np.mean(time_results, axis = 2)
# filename = 'objsize' + str(obj_size) + '_numexp' + str(num_exp) + '_timelimit' + str(TIME_LIMIT) + '_m' + str(m)
# np.save(filename, time_results)
probability_results = np.zeros([probabilities.size, num_exp])
for i in range(probabilities.size):
for k in range(num_exp):
t = dr.main(m,
m,
0,
4,
1,
5000,
probabilities[i],
TIME_LIMIT=TIME_LIMIT)
probability_results[i, k] = t
print 'Time ' + str(t) + ' prob ' + str(probabilities[i])
for i in range(num_exp):
print probability_results[:, i]
print '~~~~~~~~~~~~~~~~~~~~~~~~~~'
print np.mean(probability_results, axis=1)
filename = 'probability_results_objsize' + str(obj_size) + '_numexp' + str(
num_exp) + '_timelimit' + str(TIME_LIMIT) + '_m' + str(m) + '_r' + str(
4)
np.save(filename, probability_results)
def download(filename):
BUCKET_NAME = 'danielyenegeta.com' # replace with your bucket name
driver.main(filename)
KEY = filename + ".pdf" # replace with your object key
# Create an S3 client
s3 = boto3.client('s3')
s3.upload_file(KEY, BUCKET_NAME, KEY)
os.remove(KEY)
s3 = boto3.resource('s3')
try:
s3.Bucket(BUCKET_NAME).download_file(KEY, filename + 'report.pdf')
except botocore.exceptions.ClientError as e:
if e.response['Error']['Code'] == "404":
print("The object does not exist.")
else:
raise
return render_template('/home.html')
def loop():
global touched
while True:
if GPIO.input(TouchPin) == GPIO.LOW:
touched = False
else:
print("Touched")
write_lcd("take_pic")
touched = True
result = main()
write_lcd(result["status"])
sleep(2)
def run_driver(mass, sigmav):
str_mass = str(mass)
str_sigmav = str(sigmav)
f1 = "constraints/bbbar/bbbar_" + str_mass + "GeV_" + str_sigmav + "_params.ini"
contents1 = []
for s in contents0:
contents1.append(
s.replace("XXX_YYY",
str_mass + "GeV_" + str_sigmav + "cm^3sec^{-1}").replace(
"XXX", str_mass).replace("YYY", str_sigmav))
with open(f1, "w") as f:
f.writelines(contents1)
return driver.main(f1, 0)
# -*- coding: utf-8 -*-
import subprocess
from github import Github
from github.InputFileContent import InputFileContent
from credentials import CREDS
from driver import main
from driver import getlongterm
subprocess.call(["python", "driver.py"])
g = Github(CREDS['TOKEN'])
spotify_gist = g.get_gist(CREDS['GIST_ID'])
#spotify_gist_long_term = g.get_gist('20d9ea0342b543a1460fd13be64a7c60')
f = InputFileContent(main())
eggs = InputFileContent(getlongterm())
spotify_gist.edit('🎧 My music activity',
{'🎧 My music activity over the last 4 weeks': f})
#spotify_gist_long_term.edit('🎧 My music activity over the last 6 months',
# {'🎧 My music activity over the last 6 months': eggs})
spotify_gist.edit('🎧 My music activity',
{'🎧 My music activity over the last 6 months': eggs})
import sys sys.path.insert(0, './src') import driver if len(sys.argv) < 2: print 'Usage: %s dataset-dir' % sys.argv[0] else: dataset = sys.argv[1] + '/cifar-10-batches-py/'; driver.main(dataset)
import driver
global RETRIEVAL_LOW_CC, RETRIEVAL_HIGH_CC, STRATEGY_HIGH_CC, STRATEGY_LOW_CC
global INCR_RIGHT, INCR_WRONG, DECR_WRONG
global epoch, learning_rate, n_problems, strategies, ndups, DR_threshold, experiment_label
ndups = 3 # Number of replicates of each combo of params -- usually 3 unless testing.
strategies = [ADD.count_from_either_strategy, ADD.random_strategy, ADD.count_from_one_once_strategy,
ADD.count_from_one_twice_strategy, ADD.min_strategy] # ADD.random_strategy
# The settings.experiment_label is used by the analyzer to label the
# results file because we set these by exec(), this has to have an
# extra set of "\"quotes\"" around it.
scan_spec = {"settings.experiment_label": ["\"201508091017 Scanning n problems but should do some dynamic retrieval near the end\""],
"settings.n_problems": [1000,5000],
"settings.RETRIEVAL_LOW_CC": [0.9],
"settings.RETRIEVAL_HIGH_CC": [1.0],
"settings.STRATEGY_LOW_CC": [0.9],
"settings.STRATEGY_HIGH_CC": [1.0],
"settings.epoch": [10],
"settings.INCR_RIGHT": [5],
"settings.INCR_WRONG": [1],
"settings.DECR_WRONG": [0.5],
"settings.learning_rate": [0.1],
"settings.DR_threshold": [0.8]}
if __name__ == '__main__':
driver.main()
def main():
opts = []
args = sys.argv[1:]
quiet = 0
unittesting = 0
if args and args[0] == "-q":
quiet = 1
del args[0]
if args and args[0] == "-Q":
unittesting = 1
del args[0]
while args and args[0].startswith('-'):
opts.append(args[0])
del args[0]
if not args:
prefix = os.path.join("tests", "input", "test*.")
if tests.utils.skipxml:
xmlargs = []
else:
xmlargs = glob.glob(prefix + "xml")
xmlargs.sort()
htmlargs = glob.glob(prefix + "html")
htmlargs.sort()
args = xmlargs + htmlargs
if not args:
sys.stderr.write("No tests found -- please supply filenames\n")
sys.exit(1)
errors = 0
for arg in args:
locopts = []
if arg.find("metal") >= 0 and "-m" not in opts:
locopts.append("-m")
if not unittesting:
print arg,
sys.stdout.flush()
if tests.utils.skipxml and arg.endswith(".xml"):
print "SKIPPED (XML parser not available)"
continue
save = sys.stdout, sys.argv
try:
try:
sys.stdout = stdout = StringIO()
sys.argv = [""] + opts + locopts + [arg]
driver.main()
finally:
sys.stdout, sys.argv = save
except SystemExit:
raise
except:
errors = 1
if quiet:
print sys.exc_type
sys.stdout.flush()
else:
if unittesting:
print
else:
print "Failed:"
sys.stdout.flush()
traceback.print_exc()
continue
head, tail = os.path.split(arg)
outfile = os.path.join(
head.replace("input", "output"),
tail)
try:
f = open(outfile)
except IOError:
expected = None
print "(missing file %s)" % outfile,
else:
expected = f.readlines()
f.close()
stdout.seek(0)
if hasattr(stdout, "readlines"):
actual = stdout.readlines()
else:
actual = readlines(stdout)
if actual == expected:
if not unittesting:
print "OK"
else:
if unittesting:
print
else:
print "not OK"
errors = 1
if not quiet and expected is not None:
showdiff(expected, actual)
if errors:
sys.exit(1)
import driver, chordMappings maxHalfLifeInMinutes = 0.1 numberOfAtoms = 50 chordMapping = chordMappings.CMajToFMaj() driver.main(maxHalfLifeInMinutes, numberOfAtoms, chordMapping)
def viewscore(request):
stud_ans = request.POST.getlist('ans')
reload_count = request.POST.get('reload_count')
back_pressed = request.POST.get('back_pressed')
tab_switch_count = request.POST.get('tab_switch_count')
print "reload count is "
print reload_count
print "back pressed?"
print back_pressed
print "tab_switch_count"
print tab_switch_count
test_code = request.session['test_code']
test_instance = Test.objects.get(test_code=test_code)
ques_nos_string = test_instance.question_nos
ques_nos_list = ques_nos_string.split(",")
final_score_list = []
scores = []
s_email = request.session['s_email']
for i in range(len(ques_nos_list)):
train_file = QuestionBank.objects.get(id=ques_nos_list[i]).train_file
student_answer = stud_ans[i]
print "Evaluating answer no. " + str(i)
print "Training file used is " + str(train_file)
# blockPrint()
scores.append(driver.main([student_answer], train_file))
enablePrint()
print scores
score1_LSA = scores[0]['lsa']
score1_LSA = int(score1_LSA[0])
score1_IG = scores[0]['ig']
score1_IG = int(score1_IG[0])
score2_LSA = scores[1]['lsa']
score2_LSA = int(score2_LSA[0])
score2_IG = scores[1]['ig']
score2_IG = int(score2_IG[0])
final_score1 = int(math.ceil((float(score1_LSA) + float(score1_IG)) / 2))
final_score2 = int(math.ceil((float(score2_LSA) + float(score2_IG)) / 2))
# marks = str(final_score1.append(",").append(final_score2))
marks = str(final_score1) + ", " + str(final_score2)
print "Final marks are "
print marks
test_result = Test_Result.objects.create(
test=test_instance,
user_email=s_email,
test_marks=marks,
reload_count=str(reload_count),
back_pressed=str(back_pressed),
tab_switch_count=str(tab_switch_count))
template = loader.get_template('short_answer/viewscore.html')
context = {
'score1_LSA': str(score1_LSA),
'score1_IG': str(score1_IG),
'score2_LSA': str(score2_LSA),
'score2_IG': str(score2_IG)
}
return HttpResponse(template.render(context, request))
# # CoarseGrind: The automated Virginia Tech course grinding script. # (C)2013 All rights reserved. Created with love by Jonathan Ballands. # # ATTENTION: Distribution of this script via means other than GitHub is # prohibited. To download, please visit: github.com/jballands/coarsegrind # # For more information, visit jonathanballands.me./portfolio/coarsegrind.html # # coarsegrind.py # File that is run to start CoarseGrind. # import sys, driver # Start CoarseGrind driver.main(sys.argv[1:]) sys.exit(0)
def main():
try:
connect()
driver.main()
except:
main()
import os
import driver
import numpy
input_ = "sudokus_start.txt"
result_ = "sudokus_finish.txt"
# Read all the sudokus
input_file = open(input_)
in_sudokus = input_file.readlines()
result_file = open(result_)
ou_sudokus = result_file.readlines()
# Iterate over all the sudokus
for sudoku_in, sudoku_res in zip(in_sudokus, ou_sudokus):
line_in = sudoku_in[:-1]
line_ou = sudoku_res[:-1]
# Pass throught the solver
result = driver.main(line_in, "Out.txt")
if result != line_ou:
print("Sudoku solved ")
print(result)
def main():
driver.main()
