def test(req):
p = None
if req.method == 'POST':
wait = True
form = testform(req.POST)
if form.is_valid():
ind = form.cleaned_data['ind']
oj = form.cleaned_data['oj']
try:
p = Problem.objects.get(oj=oj, problem_id=ind)
except:
p = Problem(oj=oj, problem_id=ind, judge_type=1)
p.save()
c = Connect()
c.download_problem(oj, ind, p.id)
else:
if p.defunct <= 0:
c = Connect()
c.download_problem(oj, ind, p.id)
else:
wait = False
return render_to_response('problem_test.html', {
'form': form,
'path': req.path,
'wait': wait,
'p': p,
}, context_instance=RequestContext(req))
else:
form = testform()
return render_to_response('problem_test.html', {
'form': form,
'path': req.path,
'wait': True,
'p': p,
}, context_instance=RequestContext(req))
def admin_addproblem():
form = ProblemForm()
error = None
if request.method == 'POST' and form.validate():
inputfile = request.files['inputfile']
outputfile = request.files['outputfile']
problem = Problem(form.title.data, form.description.data,
form.pinput.data, form.poutput.data,
form.sinput.data, form.soutput.data, form.hint.data,
form.time_limit.data, form.memory_limit.data)
problem.save()
inputfile.save(
os.path.join(app.config['UPLOAD_FOLDER'],
'.'.join([str(problem.pid), 'in'])))
outputfile.save(
os.path.join(app.config['UPLOAD_FOLDER'],
'.'.join([str(problem.pid), 'out'])))
print 'upload successfully!'
return redirect(url_for('admin_problemset'))
error = get_error(form)
if error:
flash(error)
return render_template('admin_addproblem.html', form=form)
def remote_judge_add_remote_problem(data: dict):
"""
客户端发送添加题目请求
"""
import datetime
from flask import request
oj, remoteProblemID = data["oj"], data["remoteProblemID"]
if oj not in config.REMOTE_JUDGE_OJS:
return make_response(-1, message="不合法的OJ")
if not permission_manager.has_permission(session.get("uid"),
"problem.create"):
emit("server_response", {
"message": "你没有权限这样做",
"ok": False
},
room=request.sid)
return
problem = Problem(create_time=datetime.datetime.now())
problem.uploader_id = int(session.get("uid"))
db.session.add(problem)
db.session.commit()
print("Fetching: ", [oj, remoteProblemID, str(problem.id), request.sid])
remote_judge_queue.send_task(
"judgers.remote.fetch_problem",
[oj, remoteProblemID,
str(problem.id), request.sid])
emit("message", {"message": "正在爬取"}, room=request.sid)
def get_problem_info(req, oj, problem_id, index):
problem_id = int(problem_id)
data = {
'pid': 0,
'title': '',
'index': index,
'new': 0,
}
try:
pinfo = Problem.objects.get(oj=oj, problem_id=problem_id)
except:
if oj != 'neau':
c = Connect()
title = c.test_problem(oj, problem_id).decode('UTF-8')
if len(title):
p = Problem(oj=oj, problem_id=problem_id, judge_type=1)
p.save()
c = Connect()
c.download_problem(oj, problem_id, p.id)
data['pid'] = p.id
data['title'] = title
data['new'] = 1
else:
data = {
'pid': pinfo.id,
'title': pinfo.title,
'index': index,
'new': 0
}
return JsonResponse(data)
def add_problem(request, patient_id):
role = UserProfile.objects.get(user=request.user).role
authenticated = True if (role == 'physician' or role == 'admin') else False
if 'problem_name' in request.POST:
problem = Problem(patient=User.objects.get(id=patient_id), problem_name=request.POST['problem_name'], concept_id=request.POST['concept_id'], authenticated=authenticated)
problem.save()
elif 'goal' in request.POST:
goal = Goal(patient=User.objects.get(id=patient_id), goal=request.POST['goal'])
goal.save()
elif 'todo' in request.POST:
print 'todo'
print request.POST
todo = ToDo(patient=User.objects.get(id=patient_id), todo=request.POST['todo'])
todo.save()
return HttpResponse('added')
def create_problem():
if not request.json:
abort(400)
new_problem = Problem.db_create_problem(conn, request.json)
set_uri_problems(new_problem)
return jsonify(new_problem), 201
def create_problem(id_=None):
if id_:
pass
form = ProblemForm()
if request.method == 'POST':
title = request.form['title']
level = request.form.get('level', '')
category_id = request.form.get('category', None)
if not category_id:
category = Category(title='Unknown category')
category_id = category.id
text = request.form['text']
knowledge = request.form.get('knowledge', None)
answer = request.form.get('answer', None)
# NotBug: i specialy do not use here try except so user can find problem. we got here prototype any way
problem_ = Problem(title=title, level=level, category_id=category_id, text=text, knowledge=knowledge, answer=answer)
db.session.add(problem_)
db.session.commit()
return redirect(url_for('problem', id_=problem_.id))
context = {
'form': form
}
context.update(get_common_data())
return render_template('create_problem.html', context=context)
async def display_problem(self, user, problem_code):
if Problem(None, problem_code) in self.contest.problems:
info = {
'bot':
self.bot,
'channel':
self.channel,
'user':
user,
'content': [problem_code],
'description':
"Details on problem `{0}` in the `{1}` contest".format(
problem_code, self.contest.name),
}
await handlers.Problem().view(info, in_contest=True)
else:
em = Embed(title="Problems List",
description="Problems in the `{}` contest.".format(
self.contest.name),
color=BOT_COLOUR)
em.add_field(name="Problem Number",
value="\n".join(
map(str, range(1,
len(self.contest.problems) + 1))))
em.add_field(name="Problem Code",
value="\n".join(x.code
for x in self.contest.problems))
em.add_field(name="Problem Name",
value="\n".join(x.name
for x in self.contest.problems))
await self.bot.send_message(self.channel, embed=em)
def parse(filename):
with open(filename) as f:
r = lambda: f.readline().strip()
rows, cols, drones, deadline, max_payload = map(int, r().split())
n_products = int(r())
Products = map(int, r().split())
assert n_products == len(Products)
n_warehouses = int(r())
warehouses = []
for w in range(n_warehouses):
row, col = map(int, r().split())
products = map(int, r().split())
warehouses.append(Warehouse(w, row, col, products))
n_orders = int(r())
orders = []
for i in range(n_orders):
row, col = map(int, r().split())
_ = int(r())
products = map(int, r().split())
orders.append(Order(i, row, col, products))
return Problem(Products, warehouses, orders, rows, cols, drones,
deadline, max_payload)
async def load(bot):
global loading
loading = True
global problem_list
global discord_users_list
global users
global judgeserver
global judges
global locks
global db
db = pymysql.connect(MYSQL_HOST, MYSQL_USER, MYSQL_PASSWD, MYSQL_DATABASE)
locks["problem"] = defaultdict(lambda: asyncio.Lock())
locks["submissions"] = defaultdict(lambda: asyncio.Lock())
locks["judge"] = defaultdict(lambda: asyncio.Lock())
locks["user"] = defaultdict(lambda: asyncio.Lock())
locks["contest"] = defaultdict(lambda: asyncio.Lock())
locks["db"] = defaultdict(lambda: threading.RLock())
from bridge import JudgeHandler, JudgeServer
from models import Problem, Player
judgeserver = JudgeServer(BRIDGED_IP_ADDRESS, JudgeHandler)
threading.Thread(target=judgeserver.serve_forever).start()
for x in db_select("dmob_problem"):
problem_list[x[2]] = Problem(*x)
for x in db_select("dmob_user"):
discord_users_list[x[0]] = await bot.get_user_info(x[0])
users[x[0]] = Player(*x)
loading = False
def create_profile(sender, **kw):
user = kw["instance"]
base = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
if kw["created"]:
os.mkdir(os.path.join(base + '/documents/', user.username))
os.mkdir(os.path.join(base + '/documents/' + user.username, 'models'))
os.mkdir(os.path.join(base + '/documents/' + user.username, 'logs'))
os.mkdir(os.path.join(base + '/documents/' + user.username, 'data'))
profile = UserProfile(user=user)
profile.save()
problem = Problem(title='Problema_' + user.username,
status=Problem.EXPECTING_TRAINING_FILE)
problem.save()
profile.problem = problem
profile.save()
def create_problems(request):
group = False
if request.method == 'POST':
# загружаем данные POST из запроса в объект формы
form = ProblemsForm(request.POST)
# проверяем правильность загруженных данных
if not form.is_valid(): # если данные не верны возвращаем форму с сообщением об ошибке
return render_to_response("create_problems.html", { 'form': form })
# извлекаем из формы данные в объекты
name = form.cleaned_data["name"]
engines = form.cleaned_data["engines"]
groups = form.cleaned_data["groups"]
# формируем список студентов по указанным в форме группам
users = [profile.user for group in groups for profile in group.userprofile_set.all()]
# равномерно расределяем задачи между студентами
engine_names = [engine for engine in islice(cycle(engines), None, len(users))]
# если имя группы заданий не задано, то будет использовано значение по умолчанию
if not name: name = u"Без названия"
# создаем объект группы и сохраняем его
problems_group = ProblemGroup(name = name)
problems_group.save()
print users
for user, engine_name in imap(None, users, engine_names):
print user, engine_name
# извлекаем заданный движок задачи и инстанцируем его
ProblemEngine = settings.EngineManager.get_engine(engine_name)
engine = ProblemEngine()
# генерируем исходные данные задачи и выполняем их корректировку
while True:
try:
engine.randomize_in_params()
engine.adjust()
engine.calculate()
except Exception:
pass
else:
break
# создаем объект задания и передаем ему все необходимые данные
problem = Problem(user = user, problem_engine = engine_name,
problem_in_params = engine.get_store_str(), # передаем в задание исходные данные
group = problems_group)
problem.save()
group = problems_group
return render_to_response("create_problems.html", {'form': ProblemsForm(), 'group': group })
def allProblems(request):
problems = Problem.objects.all().order_by('-publishedDate')
count = problems.count()
solvedProblems = set()
if request.user.is_authenticated():
solvedProblems = Problem.getSolvedProblems(request.user)
return render(request, 'problems.html', {'problems':problems, 'count':count,
'solvedProblems':solvedProblems})
def update_problem(id):
if not request.json:
abort(400)
updated_problem = Problem.db_update_problem(conn, id, request.json)
if updated_problem is None:
return abort(404)
set_uri_problems(updated_problem)
return jsonify(updated_problem)
def create_problems(problem_group, engines, groups):
# создаем ссылки на объекты логера и запроса
request = create_problems.request
log = create_problems.get_logger()
# присваием группе id задания выполняеющего работу
problem_group.task_id = request.id
problem_group.save()
# формируем список студентов по указанным в форме группам
users = [profile.user for group in groups for profile in group.userprofile_set.all()]
# равномерно расределяем задачи между студентами
engine_names = [engine for engine in islice(cycle(engines), None, len(users))]
# словарь уникальности заданий
uniq_hash = {}
for i, (user, engine_name) in enumerate(imap(None, users, engine_names)):
# извлекаем заданный движок задачи и инстанцируем его
ProblemEngine = settings.EngineManager.get_engine(engine_name)
engine = ProblemEngine()
# генерируем исходные данные задачи и выполняем их корректировку
while True:
try:
engine.randomize_in_params()
engine.adjust()
engine.calculate()
except Exception:
log.debug("Error while createing problem for %s engine." % ProblemEngine.short_name)
else:
if uniq_hash.get("%s_%s" % (ProblemEngine.short_name, engine.get_store_str()), False):
continue
else:
uniq_hash["%s_%s" % (ProblemEngine.short_name, engine.get_store_str())] = engine.get_store_str()
log.debug(u"Сгенерирована задача: %d" % i)
break
# создаем объект задания и передаем ему все необходимые данные
problem = Problem(user = user, problem_engine = engine_name,
problem_in_params = engine.get_store_str(), # передаем в задание исходные данные
group = problem_group)
problem.save()
# обновляем состояние задания
create_problems.update_state(state = "PROGRESS", meta = {"current": i, "total": len(users) })
problem_group.created = True
problem_group.save()
return True
def add_problem(request, patient_id):
role = UserProfile.objects.get(user=request.user).role
authenticated = True if (role == 'physician' or role == 'admin') else False
if 'problem_name' in request.POST:
problem = Problem(patient=User.objects.get(id=patient_id),
problem_name=request.POST['problem_name'],
concept_id=request.POST['concept_id'],
authenticated=authenticated)
problem.save()
elif 'goal' in request.POST:
goal = Goal(patient=User.objects.get(id=patient_id),
goal=request.POST['goal'])
goal.save()
elif 'todo' in request.POST:
# print 'todo'
# print request.POST
todo = ToDo(patient=User.objects.get(id=patient_id),
todo=request.POST['todo'])
todo.save()
return HttpResponse('added')
def new_problem():
# current_user = Account.query.first() #debug
if current_user.permLevel > 1:
return redirect(url_for('index'))
form = EditProblemForm()
if form.validate_on_submit():
# tag
appen_tag = []
tags = form.tags.data.split(';')
for t in tags:
db_tag = Tag.query.filter_by(tag_name=t).first()
if db_tag:
appen_tag.append(db_tag)
# info
info = {
'description': '',
'input_format': '',
'output_format': '',
'sample_input': '',
'sample_output': '',
'hint': '',
'source': '',
'td_description': '',
'td_num': 2
}
info['description'] = form.description.data
info['input_format'] = form.input_format.data
info['output_format'] = form.output_format.data
info['sample_input'] = form.sample_input.data
info['sample_output'] = form.sample_output.data
new_prob = Problem(problemName=form.problem_name.data,
uid=current_user.uid,
info=json.dumps(info))
new_prob.problem_tag = appen_tag
db.session.add(new_prob)
db.session.commit()
flash('新增成功', 'success')
return render_template('problem_edit.html',
form=form,
form_action=url_for('.new_problem'))
def allProblems(request):
problems = Problem.objects.all().order_by('-publishedDate')
count = problems.count()
solvedProblems = set()
if request.user.is_authenticated():
solvedProblems = Problem.getSolvedProblems(request.user)
return render(request, 'coderunner/problems.html', {
'problems': problems,
'count': count,
'solvedProblems': solvedProblems
})
def admin_addproblem():
form = ProblemForm()
error = None
if request.method == 'POST' and form.validate():
inputfile = request.files['inputfile']
outputfile = request.files['outputfile']
problem = Problem(form.title.data, form.description.data, form.pinput.data, form.poutput.data, form.sinput.data, form.soutput.data, form.hint.data, form.time_limit.data, form.memory_limit.data)
problem.save()
inputfile.save(os.path.join(app.config['UPLOAD_FOLDER'], '.'.join([str(problem.pid),'in'])))
outputfile.save(os.path.join(app.config['UPLOAD_FOLDER'], '.'.join([str(problem.pid),'out'])))
print 'upload successfully!'
return redirect(url_for('admin_problemset'))
error = get_error(form)
if error:
flash(error)
return render_template('admin_addproblem.html',form = form)
def index():
if request.form.has_key("changeCat") or request.form.has_key("changeProb"):
myObj = None
for node in roots:
if (node.nodeType() == "Category" and node.payload.name == request.form['selectedCat']) or node.nodeType() == "Problem":
myObj = node
break
if myObj!=None:
del roots[:]
for thing in myObj.returnRootChildren():
roots.append(thing)
#else
elif len(roots) == 0:
metaData=Tree.query()
if len(metaData.fetch(None))==0:
r1 = Node(storeCat("Lawn Equipment"))
roots.append(r1)
lm = r1.addSubNode(storeCat("Lawn Mower"))
we = r1.addSubNode(storeCat("Weed Eater"))
r1.addSubNode(storeCat("Edger"))
r2 = Node(storeCat("Mobile Phone"))
rr2 = r2.addSubNode(storeProb("Are you having a problem?", None))
roots.append(r2);
gp = rr2.addSubNode(storeProb("Does the lawn mower have gas?", None))
rr2.addSubNode(storeProb("Is the lawn mower making noises?", None))
gp.addSubNode(storeProb(None, "You don't have any gas!"))
we.addSubNode(storeCat("Torro"))
honda = lm.addSubNode(storeCat("Honda"))
bd = lm.addSubNode(storeCat("B&D"))
honda.addSubNode(storeProb("WOW",None))
bd.addSubNode(storeCat("itWORKS!"))
r1.printTree()
treeDict = r1.convertTree()
Tree(str(r1.convertTree())).put()
Tree(str(r2.convertTree())).put()
r1Prime = Node(treeDict)
r1Prime.printTree()
else:
for probsol in Problem.query(): config.probList.append(probsol)
for cat in Category.query(): config.catList.append(cat)
trees = Tree.query() # get item list
for tree in trees: # find correct item
roots.append(Node(ast.literal_eval(tree.tree)))
return render_template("testindex.html",
roots=roots)
def __judge(self):
try:
self.__submission = Submission.get(id=self.task_id)
self.__problem = Problem.get(id=self.__submission.problem_id)
except:
return None
self.__load_problem_information()
self.__write_judge_file()
# _judger.run()
sleep(10)
self.__clean()
return True
def add(req):
if req.POST:
post = req.POST
new = Problem()
new.title = post['title']
new.key = post['key']
if req.FILES:
uf = ImgForm(post,req.FILES)
if uf.is_valid():
if uf.cleaned_data['qimg']:
new.qimg = uf.cleaned_data['qimg']
if uf.cleaned_data['aimg']:
new.aimg = uf.cleaned_data['aimg']
new.save()
return render_to_response('success.html',{},context_instance = RequestContext(req))
else:
return render_to_response('add.html',{},context_instance = RequestContext(req))
def claim(self):
r = self.api_call(self.base_url + "/jobs")
print("text:", repr(r.text))
if not r.text:
return None
required_fields = [
"id", "language", "source", "pid", "test_cases", "time_limit",
"memory_limit", "generator_code", "grader_code",
"source_verifier_code"
]
# create job object
obj = r.json()
if not all(field in obj for field in required_fields):
return None
problem = Problem(obj["pid"], obj["test_cases"], obj["time_limit"],
obj["memory_limit"], obj["generator_code"], Python3,
obj["grader_code"], Python3,
obj["source_verifier_code"], Python3)
language = languages.get(obj["language"])
if not language:
return None # TODO: should definitely not do this
return Job(obj["id"], problem, obj["source"], language)
def parse_problem_page(page_soup):
for row in page_soup.table.tbody.find_all('tr'):
cols = row.find_all('td')
if len(cols) != 11:
raise ValueError('Unexpected number of columns')
problem_id, problem_name = parse_title_cell(cols[0])
total_submissions = int(cols[1].string)
accepted_submissions = int(cols[2].string)
submissions_ratio = (int(cols[3].string.replace('%', '')) /
100) if '--' not in cols[3].string else None
fastest_submission = float(
cols[4].string) if '--' not in cols[4].string else None
total_users = int(cols[5].string)
accepted_users = int(cols[6].string)
users_ratio = (int(cols[7].string.replace('%', '')) /
100) if '--' not in cols[3].string else None
min_difficulty, max_difficulty = parse_difficulty_cell(cols[8])
yield Problem(problem_id, problem_name, total_submissions,
accepted_submissions, submissions_ratio,
fastest_submission, total_users, accepted_users,
users_ratio, min_difficulty, max_difficulty)
def admin_add_problem():
'''后台添加题目页面'''
form = ProblemForm()
if request.method == 'GET':
return render_template('admin_addproblem.html', form=form)
else:
inputfile = request.files['inputfile']
outputfile = request.files['outputfile']
problem_count = Problem.query.count()
inputfile.save(
os.path.join(app.config['DATA_FOLDER'],
'.'.join([str(problem_count + 1001), 'in'])))
outputfile.save(
os.path.join(app.config['DATA_FOLDER'],
'.'.join([str(problem_count + 1001), 'out'])))
problem = Problem(title = form.title.data, desc = form.desc.data, pinput = form.pinput.data, \
poutput = form.poutput.data, sinput = form.sinput.data, soutput = form.soutput.data, \
hint = form.hint.data, time_limit = int(form.time_limit.data), memory_limit = int(form.memory_limit.data))
db.session.add(problem)
db.session.commit()
flash(UPLOAD_SUCCESS)
return redirect('/admin/problemset')
def delete_problem(id):
if Problem.db_delete_problem(conn, id):
return jsonify({"success": True})
return abort(404)
def storeProb(myProb, myAns, url=""):
if myProb == None: myProb = ""
if myAns == None: myAns = ""
myProb2 = Problem(problem=myProb, solution=myAns, url=url)
myProb2.put()
return myProb2
def add_problem(request, patient_id):
role = UserProfile.objects.get(user=request.user).role
authenticated = True if (role == 'physician' or role == 'admin') else False
problem = Problem(patient=User.objects.get(id=patient_id), problem_name=request.POST['problem_name'], concept_id=request.POST['concept_id'], authenticated=authenticated)
problem.save()
return HttpResponse('added')
import re
from models import Assignment, Problem
file = open("management/commands/sample.tex", "r")
data = file.read()
m = re.search(r"assignment{(.*)}", data)
name = m.group(1)
m = re.search(r"duedate{(.*)}", data)
due_date = m.group(1)
asgt = Assignment(name=name, due_date=due_date)
asgt.save()
problems = []
problem_locs = [m.end() for m in re.finditer("begin{problem}", data)]
for loc in problem_locs:
p = Problem()
m = re.search(r"\[(.*)\]", data[loc:])
p.name = m.group(1)
n = re.search(r"\[(.*)\]", data[loc+m.end():])
p.points = n.group(1)
o = re.search(r"([^]]*)\\end{problem}", data[loc + m.end() + n.end():])
p.solution = o.group(1)
p.save()
asgt.problems.add(p)
def index():
if request.form.has_key("changeCat") or request.form.has_key("changeProb"):
myObj = None
for node in roots:
if (node.nodeType() == "Category"
and node.payload.name == request.form['selectedCat']
) or node.nodeType() == "Problem":
myObj = node
break
if myObj != None:
del roots[:]
del problems[:]
del models[:]
roots.append(myObj)
for thing in myObj.returnRootChildren():
items.append(thing)
elif request.form.has_key("changeItem"):
myObj = None
for node in items:
if (node.nodeType() == "Category"
and node.payload.name == request.form['selectedItem']):
myObj = node
break
if myObj != None:
del items[:]
items.append(myObj)
for thing in myObj.returnRootChildren():
models.append(thing)
elif request.form.has_key("changeModelParts"):
myObj = None
for node in models:
if (node.nodeType() == "Category"
and node.payload.name == request.form['selectedModel']):
myObj = node
break
if myObj != None:
del models[:]
models.append(myObj)
for thing in myObj.returnRootChildren():
if thing.nodeType() == "Category":
parts.append(thing)
return render_template("parts.html", models=models, parts=parts)
elif request.form.has_key("Parts"):
return render_template("parts.html", models=models, parts=parts)
elif request.form.has_key("Part"):
myObj = None
for node in parts:
if node.nodeType(
) == "Category" and node.payload.name == request.form[
'selectedPart']:
myObj = node
break
if myObj != None:
del roots[:]
del items[:]
del models[:]
del parts[:]
part = myObj
return render_template("partSelectedDiv.html", part=part)
elif request.form.has_key("changeModelProblems"):
myObj = None
for node in models:
if (node.nodeType() == "Category"
and node.payload.name == request.form['selectedModel']):
myObj = node
break
if myObj != None:
del models[:]
models.append(myObj)
for thing in myObj.returnRootChildren():
if thing.nodeType() == "Problem":
problems.append(thing)
return render_template("problems.html",
models=models,
problems=problems)
elif request.form.has_key("Problems"):
return render_template("problems.html",
models=models,
problems=problems)
elif request.form.has_key("Problem") and request.form['yesProbs']:
myObj = None
for node in problems:
if (node.nodeType() == "Problem" and
(node.payload.problem == request.form['selectedThing']
or node.payload.solution == request.form['selectedThing'])):
myObj = node
break
if myObj != None:
del roots[:]
del items[:]
del parts[:]
del problems[:]
problems.append(myObj)
for thing in myObj.returnRootChildren():
if thing.payload.problem:
problems.append(thing)
else:
answer = thing.payload.solution
return render_template("problems.html",
models=models,
problems=problems,
answer=answer)
#Needs to be pushed to github
#else
elif len(roots) == 0:
metaData = Tree.query()
if len(metaData.fetch(None)) == 0:
r1 = Node(storeCat("Lawn Equipment"))
roots.append(r1)
lm = r1.addSubNode(storeCat("Lawn Mower"))
we = r1.addSubNode(storeCat("Weed Eater"))
ed = r1.addSubNode(storeCat("Edger"))
r2 = Node(storeCat("Mobile Phone"))
att = r2.addSubNode(storeCat("AT&T"))
verizon = r2.addSubNode(storeCat("Verizon"))
sprint = r2.addSubNode(storeCat("Sprint"))
nexs = sprint.addSubNode(storeCat("Nexus"))
iphones = sprint.addSubNode(storeCat("iPhone 7"))
galaxys = sprint.addSubNode(storeCat("Galaxy 7S"))
nexa = att.addSubNode(storeCat("Nexus"))
iphonea = att.addSubNode(storeCat("iPhone 7"))
galaxya = att.addSubNode(storeCat("Galaxy 7S"))
nexv = verizon.addSubNode(storeCat("Nexus"))
iphonev = verizon.addSubNode(storeCat("iPhone 7"))
galaxyv = verizon.addSubNode(storeCat("Galaxy 7S"))
nexsprobone = nexs.addSubNode(storeProb("Broken Screen?", None))
nexsprobtwo = nexs.addSubNode(
storeProb("Broken home button?", None))
nexsprobthree = nexs.addSubNode(
storeProb("Phone doesn't turn on?", None))
nexsprobone.addSubNode(storeProb(None, "You need a new screen!"))
nexsprobtwo.addSubNode(
storeProb(None, "You need a new home button!"))
nexsprobthree.addSubNode(storeProb(None,
"You need a new battery!"))
nexaprobone = nexa.addSubNode(storeProb("Broken Screen?", None))
nexaprobtwo = nexa.addSubNode(
storeProb("Broken home button?", None))
nexaprobthree = nexa.addSubNode(
storeProb("Phone doesn't turn on?", None))
nexaprobone.addSubNode(storeProb(None, "You need a new screen!"))
nexaprobtwo.addSubNode(
storeProb(None, "You need a new home button!"))
nexaprobthree.addSubNode(storeProb(None,
"You need a new battery!"))
nexvprobone = nexv.addSubNode(storeProb("Broken Screen?", None))
nexvprobtwo = nexv.addSubNode(
storeProb("Broken home button?", None))
nexvprobthree = nexv.addSubNode(
storeProb("Phone doesn't turn on?", None))
nexvprobone.addSubNode(storeProb(None, "You need a new screen!"))
nexvprobtwo.addSubNode(
storeProb(None, "You need a new home button!"))
nexvprobthree.addSubNode(storeProb(None,
"You need a new battery!"))
iphonesprobone = iphones.addSubNode(
storeProb("Broken Screen?", None))
iphonesprobtwo = iphones.addSubNode(
storeProb("Broken home button?", None))
iphonesprobthree = iphones.addSubNode(
storeProb("Phone doesn't turn on?", None))
iphonesprobone.addSubNode(storeProb(None,
"You need a new screen!"))
iphonesprobtwo.addSubNode(
storeProb(None, "You need a new home button!"))
iphonesprobthree.addSubNode(
storeProb(None, "You need a new battery!"))
iphoneaprobone = iphonea.addSubNode(
storeProb("Broken Screen?", None))
iphoneaprobtwo = iphonea.addSubNode(
storeProb("Broken home button?", None))
iphoneaprobthree = iphonea.addSubNode(
storeProb("Phone doesn't turn on?", None))
iphoneaprobone.addSubNode(storeProb(None,
"You need a new screen!"))
iphoneaprobtwo.addSubNode(
storeProb(None, "You need a new home button!"))
iphoneaprobthree.addSubNode(
storeProb(None, "You need a new battery!"))
iphonevprobone = iphonev.addSubNode(
storeProb("Broken Screen?", None))
iphonevprobtwo = iphonev.addSubNode(
storeProb("Broken home button?", None))
iphonevprobthree = iphonev.addSubNode(
storeProb("Phone doesn't turn on?", None))
iphonevprobone.addSubNode(storeProb(None,
"You need a new screen!"))
iphonevprobtwo.addSubNode(
storeProb(None, "You need a new home button!"))
iphonevprobthree.addSubNode(
storeProb(None, "You need a new battery!"))
galaxysprobone = galaxys.addSubNode(
storeProb("Broken Screen?", None))
galaxysprobtwo = galaxys.addSubNode(
storeProb("Broken home button?", None))
galaxysprobthree = galaxys.addSubNode(
storeProb("Phone doesn't turn on?", None))
galaxysprobone.addSubNode(storeProb(None,
"You need a new screen!"))
galaxysprobtwo.addSubNode(
storeProb(None, "You need a new home button!"))
galaxysprobthree.addSubNode(
storeProb(None, "You need a new battery!"))
galaxyaprobone = galaxya.addSubNode(
storeProb("Broken Screen?", None))
galaxyaprobtwo = galaxya.addSubNode(
storeProb("Broken home button?", None))
galaxyaprobthree = galaxya.addSubNode(
storeProb("Phone doesn't turn on?", None))
galaxyaprobone.addSubNode(storeProb(None,
"You need a new screen!"))
galaxyaprobtwo.addSubNode(
storeProb(None, "You need a new home button!"))
galaxyaprobthree.addSubNode(
storeProb(None, "You need a new battery!"))
galaxyvprobone = galaxyv.addSubNode(
storeProb("Broken Screen?", None))
galaxyvprobtwo = galaxyv.addSubNode(
storeProb("Broken home button?", None))
galaxyvprobthree = galaxyv.addSubNode(
storeProb("Phone doesn't turn on?", None))
galaxyvprobone.addSubNode(storeProb(None,
"You need a new screen!"))
galaxyvprobtwo.addSubNode(
storeProb(None, "You need a new home button!"))
galaxyvprobthree.addSubNode(
storeProb(None, "You need a new battery!"))
nexs.addSubNode(storeCat("Screen"))
nexs.addSubNode(storeCat("Home Button"))
nexs.addSubNode(storeCat("Battery"))
nexa.addSubNode(storeCat("Screen"))
nexa.addSubNode(storeCat("Home Button"))
nexa.addSubNode(storeCat("Battery"))
nexv.addSubNode(storeCat("Screen"))
nexv.addSubNode(storeCat("Home Button"))
nexv.addSubNode(storeCat("Battery"))
iphones.addSubNode(storeCat("Screen"))
iphones.addSubNode(storeCat("Home Button"))
iphones.addSubNode(storeCat("Battery"))
iphonea.addSubNode(storeCat("Screen"))
iphonea.addSubNode(storeCat("Home Button"))
iphonea.addSubNode(storeCat("Battery"))
iphonev.addSubNode(storeCat("Screen"))
iphonev.addSubNode(storeCat("Home Button"))
iphonev.addSubNode(storeCat("Battery"))
galaxys.addSubNode(storeCat("Screen"))
galaxys.addSubNode(storeCat("Home Button"))
galaxys.addSubNode(storeCat("Battery"))
galaxya.addSubNode(storeCat("Screen"))
galaxya.addSubNode(storeCat("Home Button"))
galaxya.addSubNode(storeCat("Battery"))
galaxyv.addSubNode(storeCat("Screen"))
galaxyv.addSubNode(storeCat("Home Button"))
galaxyv.addSubNode(storeCat("Battery"))
roots.append(r2)
torro = we.addSubNode(storeCat("Torro"))
torro.addSubNode(storeCat("Gas Tank"))
torro.addSubNode(storeCat("Pull String"))
torro.addSubNode(storeCat("Spark Plugs"))
craftsmen = we.addSubNode(storeCat("Craftsmen"))
craftsmen.addSubNode(storeCat("Gas Tank"))
craftsmen.addSubNode(storeCat("Nylon String"))
honda = lm.addSubNode(storeCat("Honda"))
honda.addSubNode(storeCat("Gas Tank"))
honda.addSubNode(storeCat("Blades"))
honda.addSubNode(storeCat("Spark Plugs"))
bd = lm.addSubNode(storeCat("B&D"))
bd.addSubNode(storeCat("Wheels"))
bd.addSubNode(storeCat("Bearings"))
torro2 = ed.addSubNode(storeCat("Torro"))
torro2.addSubNode(storeCat("Handles"))
torro2.addSubNode(storeCat("Screws"))
torroprobone = torro.addSubNode(storeProb("Do you have gas?",
None))
torroprobtwo = torro.addSubNode(
storeProb("Is your pull string tangled?", None))
torroprobone.addSubNode(storeProb(None, "You have no gas!"))
torroprobtwo.addSubNode(
storeProb(None, "You need to untangle your pull string!"))
craftsmenprobone = craftsmen.addSubNode(
storeProb("Do you have gas?", None))
craftsmenprobtwo = craftsmen.addSubNode(
storeProb("Is your pull string tangled?", None))
craftsmenprobone.addSubNode(storeProb(None, "You have no gas!"))
craftsmenprobtwo.addSubNode(
storeProb(None, "You need to untangle your pull string!"))
hondaprobone = honda.addSubNode(storeProb("Do you have gas?",
None))
hondaprobtwo = honda.addSubNode(
storeProb("Are the blades dull?", None))
hondaprobone.addSubNode(storeProb(None, "You have no gas!"))
hondaprobtwo.addSubNode(storeProb(None, "Your blades are dull!"))
bdprobone = bd.addSubNode(
storeProb("Are your wheels wobbling?", None))
bdprobtwo = bd.addSubNode(
storeProb("Are you hearing a squeaking noise as you mow?",
None))
bdprobone.addSubNode(
storeProb(None, "You need to tighten the wheels!"))
bdprobtwo.addSubNode(
storeProb(
None,
"You need to put some damn WD-40 on those bearings!!!"))
torro2probone = torro2.addSubNode(
storeProb("Are you handles wobbling off as you cut?", None))
torro2probtwo = torro2.addSubNode(
storeProb("Are your handles rusty?", None))
torro2probone.addSubNode(
storeProb(None, "You need to tighten the screws!"))
torro2probtwo.addSubNode(
storeProb(None, "You definitely need some new handles!"))
r1.printTree()
#treeDict = r1.convertTree()
Tree(str(r1.convertTree())).put()
Tree(str(r2.convertTree())).put()
#r1Prime = Node(treeDict)
#r1Prime.printTree()
else:
for probsol in Problem.query():
config.probList.append(probsol)
for cat in Category.query():
config.catList.append(cat)
trees = Tree.query() # get item list
for tree in trees: # find correct item
roots.append(Node(ast.literal_eval(tree.tree)))
return render_template("testindex.html", roots=roots, items=items)
def parse():
logger = logging.getLogger('parser_logger')
logger.info('Starting Parsing')
try:
# List of problems to store parsed Problems
problems = list()
with open('robots.mat') as input_text:
for line in input_text:
# Remove whitespaces
line = line.replace(' ','').replace('\n', '')
try:
question_number = int(line[:line.index(':')])
problem = Problem(question_number=question_number)
# logger.info('Parsing question : %i' % problem.question_number)
except ValueError as e:
logger.critical('ValueError %s' % (str(e)))
sys.exit(1)
# Remove the question number part
line = line[line.index(':')+1:]
try:
i = line.index('#')
except ValueError:
i = -1
if i > 0:
# If it has obstacles, parse the robots and obstacles
robots = line[:i].split('),')
# Obstacles (still in string)
obstacles = line[i + 1:].split(';')
problem_obstacles = list()
# Parse the tuples
for obstacle in obstacles:
coordinates = obstacle.split('),')
# Parse the string list
coordinates[:] = [coordinate.strip('()') for coordinate in coordinates]
coordinates[:] = [coordinate.split(',') for coordinate in coordinates]
vertices = list()
for coordinate in coordinates:
try:
x = float(coordinate[0])
y = float(coordinate[1])
vert = (x, y)
vertices.append(vert)
except ValueError as e:
logger.critical('ValueError %s' % str(e))
sys.exit(1)
problem_obstacles.append(Obstacle(vertices=vertices, problem=problem))
problem.obstacles = problem_obstacles
# logger.info('There are %i obstacles' % len(problem.obstacles))
else: # There is no obstacle
robots = line.split('),')
robots[:] = [rob.strip('()') for rob in robots]
robots[:] = [rob.split(',') for rob in robots]
problem_robots = list()
for rob in robots:
try:
x = float(rob[0])
y = float(rob[1])
vertex = (x, y)
rb = Robot(vertex=vertex, problem=problem)
except ValueError as e:
logger.critical('ValueError %s' % str(e))
sys.exit(1)
problem_robots.append(rb)
problem.robots = problem_robots
# logger.info('There are %i robots' % len(problem.robots))
logger.info('Successfully parsed Question number : %i' % problem.question_number)
problems.append(problem)
logger.info('Parse Successful')
return problems
except IOError as e:
logger.critical('IOError %i: %s' % (e.errno, e.strerror))
sys.exit(1)
def setupTree():
if len(roots) == 0:
metaData = Tree.query()
if len(metaData.fetch(None)) == 0:
root1 = Node(storeCat("Lawn Equipment"))
roots.append(root1)
lawnmower = root1.addSubNode(storeCat("Lawn Mower"))
weedeater = root1.addSubNode(storeCat("Weed Eater"))
edger = root1.addSubNode(storeCat("Edger"))
wontStart = lawnmower.addSubNode(
storeProb("Lawn mower won't start", None))
ws1 = wontStart.addSubNode(
storeProb("Is there gas in the tank?",
"Put gas in the mower!"))
ws2 = ws1.addSubNode(
storeProb("Will the mower jump start?",
"Replace the battery!"))
ws3 = ws2.addSubNode(
storeProb("Do the spark plugs appear clean?",
"Clear or replace the plugs!",
url="https://goo.gl/FJneX0"))
wontCut = lawnmower.addSubNode(
storeProb("Mower isn't cutting the grass well", None))
wc1 = wontCut.addSubNode(
storeProb("Is the grass a reasonable height?",
"Raise the cutting height on your lawn mower"))
wc2 = wc1.addSubNode(
storeProb("Does the blade appear to be sharp?",
"Replace or sharpen the blade",
"https://goo.gl/ANuuah"))
toro = lawnmower.addSubNode(storeCat("Toro", type='part'))
honda = lawnmower.addSubNode(storeCat("Honda", type='part'))
craftsman = lawnmower.addSubNode(storeCat("Craftsman",
type='part'))
honda.addSubNode(
storeCat("Spark Plug",
type='part',
url="https://goo.gl/4988HT"))
honda.addSubNode(
storeCat("Blade", type='part', url="https://goo.gl/6IzHDH"))
honda.addSubNode(
storeCat("Battery", type='part', url="https://goo.gl/j32Qs0"))
toro.addSubNode(
storeCat("Spark Plug",
type='part',
url="https://goo.gl/iSq3IM"))
toro.addSubNode(
storeCat("Blade", type='part', url="https://goo.gl/awrF4W"))
toro.addSubNode(
storeCat("Battery", type='part', url="https://goo.gl/hxFbMM"))
craftsman.addSubNode(
storeCat("Spark Plug",
type='part',
url="https://goo.gl/uMbjzb"))
craftsman.addSubNode(
storeCat("Blade", type='part', url="https://goo.gl/6mcSAe"))
craftsman.addSubNode(
storeCat("Battery", type='part', url="https://goo.gl/Txykkp"))
root2 = Node(storeCat("Smartphone"))
roots.append(root2)
android = root2.addSubNode(storeCat("Google Android"))
apple = root2.addSubNode(storeCat("Apple iOS"))
slow = android.addSubNode(storeProb("My phone is slow", None))
sl1 = slow.addSubNode(
storeProb("Has the phone been restarted recently?",
"Reboot the phone"))
sl2 = sl1.addSubNode(
storeProb("Are there only a few apps open?",
"Close the apps you aren't actively using"))
sl3 = sl2.addSubNode(
storeProb("Is atleast 90% of the phone storage free?",
"Removed unused apps or upgrade the storage"))
app = android.addSubNode(
storeProb("I want to develop an app", "Follow a tutorial",
None))
app.addSubNode(
storeProb(
"Have you tried following a tutorial?",
"Use an online tutorial",
url=
"https://developer.android.com/training/basics/firstapp/index.html"
))
slow = apple.addSubNode(storeProb("My phone is slow", None))
sl1 = slow.addSubNode(
storeProb("Has the phone been restarted recently?",
"Reboot the phone"))
sl2 = sl1.addSubNode(
storeProb("Are there only a few apps open?",
"Close the apps you aren't actively using"))
sl3 = sl2.addSubNode(
storeProb("Is atleast 90% of the phone storage free?",
"Removed unused apps or upgrade the storage"))
app = apple.addSubNode(
storeProb("I want to develop an app", "Follow a tutorial",
None))
app.addSubNode(
storeProb(
"Have you tried following a tutorial?",
"Use an online tutorial",
url=
"https://developer.apple.com/library/content/referencelibrary/GettingStarted/DevelopiOSAppsSwift/"
))
moto = android.addSubNode(storeCat("Motorola", type='part'))
samsung = android.addSubNode(storeCat("Samsung", type='part'))
huawei = android.addSubNode(storeCat("Huawei", type='part'))
moto.addSubNode(
storeCat("Case", type='part', url="https://goo.gl/aSNG2U"))
samsung.addSubNode(
storeCat("Case", type='part', url="https://goo.gl/T10QPU"))
huawei.addSubNode(
storeCat("Case", type='part', url="https://goo.gl/frSgRq"))
apple.addSubNode(
storeCat("Case", type='part', url="https://goo.gl/6vclg7"))
root1.printTree()
root2.printTree()
testTree = str(root1.convertTree())
print testTree
# treeDict = root1.convertTree()
Tree(tree=testTree).put()
Tree(tree=str(root2.convertTree())).put()
# r1Prime = Node(treeDict)
# print r1Prime
print root1
print root2
else:
for probsol in Problem.query():
probList.append(probsol)
for cat in Category.query():
catList.append(cat)
trees = Tree.query() # get item list
for tree in trees: # find correct item
roots.append(Node(ast.literal_eval(tree.tree)))
for root in roots:
root.printTree()
print "Length of probList is " + str(len(probList))
print "Length of catList is " + str(len(catList))
def storeProb(myProb, myAns):
myProb2 = Problem(myProb, myAns)
myProb2.put()
return myProb2
def get_problem(id):
problem = Problem.db_get_problem(conn, id)
if problem is None:
return abort(404)
set_uri_problems(problem)
return jsonify(problem)
def problem_from_data ( data ) :
return Problem(data["contestId"], data["index"], data["name"], str(data["tags"]), data.get("points", 0))
import re
from models import Assignment, Problem
file = open("management/commands/sample.tex", "r")
data = file.read()
m = re.search(r"assignment{(.*)}", data)
name = m.group(1)
m = re.search(r"duedate{(.*)}", data)
due_date = m.group(1)
asgt = Assignment(name=name, due_date=due_date)
asgt.save()
problems = []
problem_locs = [m.end() for m in re.finditer("begin{problem}", data)]
for loc in problem_locs:
p = Problem()
m = re.search(r"\[(.*)\]", data[loc:])
p.name = m.group(1)
n = re.search(r"\[(.*)\]", data[loc + m.end():])
p.points = n.group(1)
o = re.search(r"([^]]*)\\end{problem}", data[loc + m.end() + n.end():])
p.solution = o.group(1)
p.save()
asgt.problems.add(p)
print()
continue
problems = j['problems']
rows = j['rows']
data = []
for p in problems:
data.append(
dict(
name=p['name'],
contest_start_time=c.start_time,
rating=p.get('rating'),
tags=p['tags'],
))
rc = Problem.insert_many(data).on_conflict_ignore().execute()
print(rc, 'problems')
data = []
for p in problems:
data.append(
dict(
contest=c,
problem=Problem.get(
Problem.name == p['name'],
Problem.contest_start_time == c.start_time),
index=p['index'],
))
rc = ContestProblem.insert_many(data).execute()
print(rc, 'contest problems')
def create_subcat():
newObj = {}
print "The args of createSubcat are " + str(request.args)
if request.args.get("type")=='Subcategory' or request.args.get("type")=='Part' or \
request.args.get("type")=='Problem' or request.args.get("type")=='Solution':
print "I will make a node!"
print "Looking up " + str(request.args.get("parentId"))
for tree in roots:
baseNode = tree.lookup(str(request.args.get("parentId")))
if baseNode != None:
newCat = None
if request.args.get("type") == 'Part':
print "There were " + str(len(
Category.query().fetch(None))) + " category entries."
newCat = storeCat(request.args.get("name"),
type='part',
url=request.args.get("url"))
newObj = {
'id': newCat.id,
'name': newCat.name,
'type': newCat.type,
'url': newCat.url
}
print "Now there are " + str(
len(Category.query().fetch(
None))) + " category entries."
elif request.args.get("type") == 'Problem' or request.args.get(
"type") == 'Solution':
print "There were " + str(len(
Problem.query().fetch(None))) + " problem entries."
# if len(request.args.get("solution"))>0:
# newCat = storeProb(request.args.get("problem"),request.args.get("solution"),
# url=request.args.get("url"))
# newObj = {'id': newCat.id, 'name': newCat.problem, 'type': 'solution', 'url': newCat.url}
# else:
# newCat = storeProb(request.args.get("problem"),None)
# newObj = {'id': newCat.id, 'name': newCat.problem, 'type': 'problem', 'url': newCat.url}
newCat = storeProb(request.args.get("problem"),
request.args.get("solution"),
url=request.args.get("url"))
newObj = {
'id': newCat.id,
'name': newCat.problem,
'solution': newCat.solution,
'type': 'problem',
'url': newCat.url
}
print "Now there are " + str(
len(Problem.query().fetch(None))) + " problem entries."
else:
print "There were " + str(len(
Category.query().fetch(None))) + " category entries."
newCat = storeCat(request.args.get("name"))
newObj = {
'id': newCat.id,
'name': newCat.name,
'type': newCat.type,
'url': newCat.url
}
print "Now there are " + str(
len(Category.query().fetch(
None))) + " category entries."
baseNode.addSubNode(newCat)
trees = Tree.query()
for mytree in trees:
treeDict = ast.literal_eval(mytree.tree)
if str(treeDict['node']) == str(tree.payload.id):
print "Found match!"
mytree.tree = str(tree.convertTree())
mytree.put()
break
print "Now there are " + str(len(
Tree.query().fetch(None))) + " tree entries."
break
else:
print "Parent node could not be found!"
return jsonify(newObj)
def remote_judge_submit(data):
"""
客户端提交代码
{
"problemID":hj2题目ID,
"remoteAccountID":"远程用户ID",
"code":"用户代码",
"language":"用户选择的语言",
"loginCaptcha":"登录验证码",
"submitCaptcha":"提交验证码",
"contestID":"提交为某场比赛,-1设置为不提交比赛",
"contestProblemID":"比赛题目ID"
}
"""
if not permission_manager.has_permission(session.get("uid"),
"remote_judge.use"):
emit("server_response", {
"ok": False,
"message": "你没有权限这样做"
},
room=request.sid)
return
problem: Problem = Problem.by_id(data["problemID"])
contest_id = data["contestID"]
if contest_id != -1:
contest: Contest = db.session.query(Contest).filter(
Contest.id == contest_id).one_or_none()
if not contest:
emit("server_response", {
"ok": False,
"message": "非法比赛ID"
},
room=request.sid)
return
if len(contest.problems) <= data["contestProblemID"]:
emit("server_response", {
"ok": False,
"message": "非法比赛题目ID"
},
room=request.sid)
return
if not contest.running():
emit("server_response", {
"ok": False,
"message": "比赛未在进行"
},
room=request.sid)
return
problem: Problem = Problem.by_id(
contest.problems[data["contestProblemID"]]["id"])
else:
if not problem.public and int(
session.get("uid")
) != problem.uploader_id and not permission_manager.has_permission(
session.get("uid"), "problem.manage"):
emit("server_response", {
"ok": False,
"message": "你没有权限使用此题目"
},
room=request.sid)
return
if len(data["code"]) > config.MAX_CODE_LENGTH:
emit("server_response", {
"ok": False,
"message": "代码过长"
},
room=request.sid)
return
remote_account: RemoteAccount = db.session.query(RemoteAccount).filter(
RemoteAccount.account_id == data["remoteAccountID"]).one_or_none()
if not remote_account or remote_account.uid != int(session.get("uid")):
emit("server_response", {
"ok": False,
"message": "非法账户ID"
},
room=request.sid)
return
if data["language"] not in config.REMOTE_JUDGE_OJS[
problem.remote_judge_oj]["availableLanguages"]:
emit("server_response", {
"ok": False,
"message": "非法语言"
},
room=request.sid)
return
remote_judge_queue.send_task("judgers.remote.submit", [
problem.remote_judge_oj,
decode_json(remote_account.session), remote_account.account_id,
problem.remote_problem_id, data["language"], data["code"],
data["loginCaptcha"], data["submitCaptcha"], request.sid,
remote_account.username, remote_account.password, problem.id,
int(session.get("uid")), problem.public,
list(reversed(config.TRACK_DELAY_INTERVAL)), data["contestID"],
data["contestProblemID"]
])
emit("message", {"message": "提交中..."}, room=request.sid)
def get_problems():
problems = Problem.db_get_problems(conn)
for problem in problems:
set_uri_problems(problem)
return jsonify(problems)
