def attach(self, sched):
util.i("%s <r: %s" % (str(sched).lower(), self.__class__.__name__.lower()))
self._sched = sched._enroll(self)
self._flag = not self._sched is None
if not isinstance(self, threading.Thread):
return
self.setDaemon(True)
self.start()
async def admin_command(msg: discord.Message, args: list, prefix: str):
if i(args, 0) == 'eval' and len(args) > 1:
try:
script = compile(msg.content[len(prefix) + 5:], "<string>",
"eval") # compile script first
script_start = time.perf_counter()
raw_eval = eval(script)
script_duration = time.perf_counter() - script_start
ev = repr(raw_eval).replace('```',
'\u200e`\u200e`\u200e`\u200e')
if len(ev) + 6 > 2048:
await sendEmbed(
msg.channel,
f'Return output (code executed in {formatTime(script_duration)}):',
'```' + ev[:2038] + ' ...```')
else:
await sendEmbed(
msg.channel,
f'Return output (code executed in {formatTime(script_duration)}):',
'```' + ev + '```')
except Exception as e:
exp = type(e).__name__.replace(
"```", "\u200e`\u200e`\u200e`\u200e") + ': ' + ", ".join([
str(t) for t in e.args
]).replace("```", "\u200e`\u200e`\u200e`\u200e")
if len(exp) + 6 > 2048:
await sendEmbed(msg.channel, 'An exception occured!',
'```' + exp[:2038] + ' ...```')
else:
await sendEmbed(msg.channel, 'An exception occured!',
'```' + exp + '```')
elif i(args, 0) == 'sudo' and len(args) > 1:
await msg.channel.send(msg.content[len(prefix) + 5:])
await msg.delete()
elif i(args, 0) == 'heap' and len(args) == 1:
mem = process.memory_info().rss
await sendEmbed(msg.channel, 'Total memory used:',
f"**{formatByte(mem, 4)}**\n({mem} B)")
elif i(args, 0) == 'stop' and len(args) == 1:
await sendEmbed(msg.channel, 'Stopping bot...',
'Change da world,\nMy final message,\nGoodbye.')
sys.exit(1)
else:
await user_command(msg, args, prefix, True, True)
def languages_del(lang_id):
"""
Deletes a language
Params:
lang_id (int): the language to delete
Returns:
a redirect to the language view page
"""
lang = model.Language.query.filter_by(id=util.i(lang_id)).scalar()
if lang is None:
error = "Failed to delete language \'{}\' as it does not exist.".format(
lang_id)
current_app.logger.info(error)
flash(error, "danger")
return redirect(url_for("languages.languages_view"))
try:
db_session.delete(lang)
db_session.commit()
flash("Deleted language \'{}\'".format(lang.name), "warning")
except IntegrityError:
db_session.rollback()
error = "Failed to delete language \'{}\' as it's referenced in another DB element".format(
lang_id)
current_app.logger.info(error)
flash(error, "danger")
return redirect(url_for("languages.languages_view"))
def add_user():
"""
Adds or edits a user
Note:
must be called from within a request context
Returns:
a redirect to the user view page
"""
user_id = request.form.get("user_id")
email = request.form.get("email")
name = request.form.get("name")
username = request.form.get("username")
password = request.form.get("password")
confirm_password = request.form.get("confirm_password")
misc_data = request.form.get("misc_data")
contest_ids = request.form.get("contest_ids")
user_role_ids = request.form.get("user_role_ids")
if password != confirm_password:
error = "Failed to add/edit \'{}\' due to password mismatch.".format(
email)
current_app.logger.info(error)
flash(error, "danger")
return redirect(url_for("users.users_view"))
if user_id: # edit
user = model.User.query.filter_by(id=util.i(user_id)).one()
user.email = email
user.name = name
user.username = username
if password != "":
user.hashed_password = util.hash_password(password)
user.misc_data = misc_data
user.contests = retrieve_by_ids(contest_ids.split(), model.Contest)
user.user_roles = retrieve_by_names(user_role_ids.split(),
model.UserRole)
else: # add
if is_dup_user_email(email):
error = "Failed to add user \'{}\' as user already exists.".format(
email)
current_app.logger.info(error)
flash(error, "danger")
return redirect(url_for("users.users_view"))
user = model.User(email=email,
name=name,
password=password,
misc_data=misc_data,
contests=retrieve_by_ids(contest_ids.split(),
model.Contest),
user_roles=retrieve_by_names(user_role_ids.split(),
model.UserRole),
username=username)
db_session.add(user)
db_session.commit()
return redirect(url_for("users.users_view"))
def display_user_add_form(user_id):
"""
Displays the user add template
Params:
user_id (int): user_id
Returns:
a rendered user add/edit template
"""
if user_id is None: # add
return render_template("users/add_edit.html",
action_label="Add",
user=None)
else: # edit
user = model.User.query.filter_by(id=util.i(user_id)).scalar()
if user is None:
error = "Failed to edit user '{}' as user doesn't exist.".format(
user_id)
current_app.logger.info(error)
flash(error, "danger")
return redirect(url_for("users.users_view"))
return render_template("users/add_edit.html",
action_label="Edit",
user=user)
def update_user_metadata():
current_user_id = get_jwt_identity()
curr_user = model.User.query.get(util.i(current_user_id))
if not curr_user:
return make_response(jsonify({"error": "Not logged in"}), 400)
if "judge" not in curr_user.user_roles and "operator" not in curr_user.user_roles:
return make_response(jsonify({"error": "Unauthorized access"}), 401)
user_username = request.json.get("user_username")
user_misc_metadata = request.json.get("misc_metadata")
if not all([user_username, user_misc_metadata]):
return make_response(jsonify({"error": "Invalid request, missing field"}), 400)
if not isinstance(user_misc_metadata, dict):
return make_response(
jsonify({"error": "Invalid request, misc_metadata must be a dict"}), 400
)
matching_user = model.User.query.filter_by(username=user_username).scalar()
if not matching_user:
return make_response(
jsonify({"error": "Invalid request, Couldn't find user"}), 400
)
matching_user.merge_metadata(user_misc_metadata)
db_session.commit()
return make_response(jsonify({"status": "Success"}), 200)
def display_contest_add_form(contest_id):
"""
Displays the contest add template
Params:
contest_id (int): contest_id
Returns:
a rendered contest add/edit template
"""
if contest_id is None: # add
return render_template(
"contests/add_edit.html",
action_label="Add",
contest=None,
user_usernames=[user.username for user in model.User.query.all()],
problem_slugs=[a.slug for a in model.Problem.query.all()],
)
else: # edit
contest = model.Contest.query.filter_by(id=util.i(contest_id)).scalar()
if contest is None:
error = "Failed to edit contest '{}' as contest doesn't exist.".format(
contest_id)
current_app.logger.info(error)
flash(error, "danger")
return redirect(url_for("contests.contests_view"))
return render_template(
"contests/add_edit.html",
action_label="Edit",
contest=contest,
user_usernames=[user.username for user in model.User.query.all()],
problem_slugs=[a.slug for a in model.Problem.query.all()],
)
def get_current_user():
current_user_id = get_jwt_identity()
curr_user = model.User.query.get(util.i(current_user_id))
resp = None
if curr_user:
resp = curr_user.get_output_dict()
return make_response(jsonify(resp), 200)
def signout_user(username):
matching_user = model.User.query.filter_by(username=username).scalar()
if not matching_user:
return make_response(
jsonify({"error": "Invalid request, couldn't find user"}), 400
)
matching_user.merge_metadata({"signout": util.i(time.time())})
db_session.commit()
return make_response(jsonify({"status": "Success"}), 200)
def make_user():
"""
To test manually:
- get auth token: curl -H "Content-Type: application/json" --data '{"username": "******", "password": "******"}' http://localhost:9191/api/login
- make request: curl -H "Authorization: Bearer *token_goes_here*" -H "Content-Type: application/json" --data '{"name": "Ben", "username": "******", "password": "******"}' http://localhost:9191/api/make-defendant-user
"""
current_user_id = get_jwt_identity()
curr_user = model.User.query.get(util.i(current_user_id))
if not curr_user:
return make_response(jsonify({"error": "Not logged in"}), 400)
if "judge" not in curr_user.user_roles and "operator" not in curr_user.user_roles:
return make_response(jsonify({"error": "Unauthorized access"}), 401)
username = request.json.get("username")
name = request.json.get("name")
password = request.json.get("password")
username = request.json.get("username")
contest_name = request.json.get("contest_name")
if not all([username, name, password, username, contest_name]):
return make_response(jsonify({"error": "Invalid request, missing fields"}), 400)
existing_user = model.User.query.filter_by(username=username).scalar()
if existing_user:
return make_response(
jsonify({"error": "Invalid request, user already exists"}), 400
)
defedant_role = model.UserRole.query.filter_by(name="defendant").scalar()
new_user = model.User(
username=username, name=name, password=password, user_roles=[defedant_role]
)
db_session.add(new_user)
db_session.commit()
contest = model.Contest.query.filter_by(name=contest_name).scalar()
if not contest:
return make_response(jsonify({"error": "Invalid contest name"}), 400)
new_user.contests.append(contest)
db_session.commit()
return make_response(jsonify({"status": "Success"}), 200)
def si(self):
"""
Формирование столбца свободных членов
:return:
"""
result = np.zeros([(2 * self.K + 1) * (self.M + 1) + self.M + 1], complex)
for q in xrange(0, 2 * self.K + 2):
for n in xrange(0, self.M + 1):
if q == 0:
result[q * (self.M + 1) + n] = - i(n)
else:
if q == 1:
result[q * (self.M + 1) + n] = - self.ii(n)
else:
result[q * (self.M + 1) + n] = 0
return result
def get_contest_info():
current_user_id = get_jwt_identity()
curr_user = model.User.query.get(util.i(current_user_id))
if not curr_user:
return make_response(jsonify({"error": "Not logged in"}), 400)
contests = curr_user.contests
if len(contests) > 1:
return make_response(jsonify({"error": "User has multiple contests"}), 500)
if len(contests) < 1:
return make_response(jsonify({"error": "User has no contests"}), 400)
contest = contests[0]
return make_response(jsonify(contest.get_output_dict()))
def retrieve_by_ids(ids, table):
"""
Retrieves a list of rows from the given table
Params:
ids (list): the ids of tuples to retrieve
table : the table to retrieve rows from
Returns:
list: the rows from the database
"""
rows = []
for id in ids:
row = table.query.filter_by(id=util.i(id)).scalar()
if row:
rows.append(row)
return rows
def return_without_run(run_id):
"""Allows for executors to return a writ without running if they are
experiencing errors or are shutting down
"""
run = model.Run.query.get(util.i(run_id))
if not run:
current_app.logger.debug("Received writ without valid run, id: %s", run_id)
abort(404)
if run.finished_execing_time:
current_app.logger.warning(
"Received return for already returned writ, id: %s", run_id
)
abort(400)
run.started_execing_time = None
db_session.commit()
return "Good"
def get_all_problems(user_id=None):
current_user_id = get_jwt_identity()
curr_user = model.User.query.get(util.i(current_user_id))
problems = model.Problem.query.filter_by(is_enabled=True).all()
runs = model.Run.query.filter_by(user=curr_user).all()
if len(curr_user.contests) == 0:
return make_response(jsonify({"error": "User has no contests"}), 400)
problems = (p for p in problems if curr_user.contests[0] in p.contests)
resp = {}
for problem in problems:
problem_run_dicts = [x.get_output_dict() for x in runs if x.problem == problem]
problem_dict = problem.get_output_dict()
problem_dict["runs"] = problem_run_dicts
resp[problem.slug] = problem_dict
return make_response(jsonify(resp), 200)
def users_del(user_id):
"""
Deletes a user
Params:
user_id (int): the user to delete
Returns:
a redirect to the user view page
"""
user = model.User.query.filter_by(id=util.i(user_id)).scalar()
if user is None:
error = "Failed to delete user '{}' as it does not exist.".format(
user_id)
current_app.logger.info(error)
flash(error, "danger")
return redirect(url_for("users.users_view"))
if current_user.id == user.id:
error = "Failed to delete user '{}' because user cannot delete itself.".format(
user_id)
current_app.logger.info(error)
flash(error, "danger")
return redirect(url_for("users.users_view"))
try:
db_session.delete(user)
db_session.commit()
flash("Deleted user '{}'".format(user.username), "warning")
except IntegrityError:
db_session.rollback()
error = "Failed to delete user '{}' as it's referenced in another DB element".format(
user_id)
current_app.logger.info(error)
flash(error, "danger")
return redirect(url_for("users.users_view"))
def submit_run():
current_user_id = get_jwt_identity()
user = model.User.query.get(util.i(current_user_id))
MAX_RUNS = util.get_configuration("max_user_submissions")
TIME_LIMIT = util.get_configuration("user_submission_time_limit")
over_limit_runs_query = model.Run.submit_time > (
datetime.datetime.utcnow() - datetime.timedelta(minutes=TIME_LIMIT)
)
run_count = (
model.Run.query.filter_by(user_id=user.id).filter(over_limit_runs_query).count()
)
if run_count > MAX_RUNS:
return make_response(jsonify({"error": "Submission rate limit exceeded"}), 400)
contest = user.contests[0]
lang_name = request.json.get("lang", None)
problem_slug = request.json.get("problem_slug", None)
source_code = request.json.get("source_code", None)
is_submission = request.json.get("is_submission", False)
user_test_input = request.json.get("user_test_input", None)
if lang_name is None or problem_slug is None or source_code is None:
return make_response(
jsonify({"error": "Invalid submission, missing input"}), 400
)
lang = model.Language.query.filter_by(name=lang_name).scalar()
if not lang:
return make_response(jsonify({"error": "Invalid language"}), 400)
problem = model.Problem.query.filter_by(slug=problem_slug).scalar()
if not problem:
return make_response(jsonify({"error": "Invalid problem slug"}), 400)
run_input = None
correct_output = None
if is_submission:
run_input = problem.secret_input
correct_output = problem.secret_output
else:
if user_test_input:
run_input = user_test_input
else:
run_input = problem.sample_input
correct_output = problem.sample_output
run = model.Run(
user,
contest,
lang,
problem,
datetime.datetime.utcnow(),
source_code,
run_input,
correct_output,
is_submission,
local_submit_time=datetime.datetime.now(),
)
run.state = model.RunState.JUDGING
resp = None
if datetime.datetime.utcnow() < contest.start_time:
run.state = model.RunState.CONTEST_HAS_NOT_BEGUN
run.started_execing_time = datetime.datetime.utcnow()
run.finished_execing_time = datetime.datetime.utcnow()
resp = make_response(jsonify({"error": "Contest has not begun"}), 400)
else:
resp = make_response(jsonify({"status": "good"}), 200)
db_session.add(run)
db_session.commit()
util.invalidate_cache_item(util.RUN_CACHE_NAME, run.user_id)
return resp
def submit_writ(run_id):
"""endpoint for executioners to submit runs
Looking for the format:
{
"output": "..."
}
"""
run = model.Run.query.get(util.i(run_id))
if not run:
current_app.logger.debug("Received writ without valid run, id: %s", run_id)
abort(404)
if run.finished_execing_time:
current_app.logger.warning(
"Received writ submission for already submitted run, id: %s", run_id
)
abort(400)
if not request.json:
current_app.logger.debug("Received writ without json")
abort(400)
if "output" not in request.json or not isinstance(
request.json["output"], six.string_types
):
current_app.logger.debug("Received writ without the output field")
abort(400)
run.run_output = request.json.get("output")
run.state = request.json.get("state") or run.state
run.finished_execing_time = datetime.datetime.utcnow()
if run.is_submission:
run.is_passed = clean_output_string(run.run_output) == clean_output_string(
run.correct_output
)
if run.state == model.RunState.EXECUTED:
if run.submit_time > run.contest.end_time:
run.is_passed = None
if run.is_passed:
run.state = model.RunState.CONTEST_ENDED_PASSED
else:
run.state = model.RunState.CONTEST_ENDED_FAILED
else:
if run.is_passed:
run.state = model.RunState.SUCCESSFUL
else:
run.state = model.RunState.FAILED
if run.is_passed:
util.invalidate_cache_item(util.SCORE_CACHE_NAME, run.contest.id)
if run.user.username == "exec":
util.add_versions(run.run_output)
db_session.delete(run)
version_contest = model.Contest.query.filter_by(name="version_contest").first()
db_session.delete(version_contest)
db_session.commit()
util.invalidate_cache_item(util.RUN_CACHE_NAME, run.user_id)
return "Good"
async def user_command(msg: discord.Message,
args: list,
prefix: str,
is_priv=False,
is_admin=False):
global last_pet, pet_anger
if i(args, 0) == 'doc' and len(args) == 2:
splits = args[1].split('.')
if i(splits, 0) not in doc_modules:
await sendEmbed(
msg.channel, f'Unknown module!',
f'No such module is available for its documentation')
return
objs = doc_modules
obj = None
for part in splits:
try:
obj = objs[part]
try:
objs = vars(obj)
except:
objs = {}
except:
await sendEmbed(
msg.channel, f'Class/function/sub-module not found!',
f'There\'s no such thing here named `{args[1]}`')
return
messg = str(obj.__doc__).replace('```',
'\u200e`\u200e`\u200e`\u200e')
if len(messg) + 6 > 2048:
await sendEmbed(msg.channel, f'Documentation for {args[1]}',
'```' + messg[:2038] + ' ...```')
return
else:
messg = '```' + messg + '```\n\n'
if i(splits, 0) == 'pygame':
doclink = "https://www.pygame.org/docs"
if len(splits) > 1:
doclink += '/ref/' + i(splits, 1).lower() + ".html"
doclink += "#"
doclink += "".join([s + "." for s in splits])[:-1]
messg = 'Online documentation: ' + doclink + '\n' + messg
for ob in objs.keys():
if ob.startswith('__'):
continue
if type(objs[ob]).__name__ not in ('module', 'type', 'function',
'method_descriptor',
'builtin_function_or_method'):
continue
messg += '**' + type(
objs[ob]).__name__.upper() + '** `' + ob + '`\n'
if len(messg) > 2048:
await sendEmbed(msg.channel, f'Documentation for {args[1]}',
messg[:2044] + ' ...')
else:
await sendEmbed(msg.channel, f'Documentation for {args[1]}', messg)
elif i(args, 0) == 'exec' and len(args) > 1:
code = msg.content[len(prefix) + 5:]
ret = ''
for x in range(len(code)):
if code[x] in [' ', '`', '\n']:
ret = code[x + 1:]
else:
break
code = ret
for x in reversed(range(len(code))):
if code[x] in [' ', '`', '\n']:
ret = code[:x]
else:
break
if ret.startswith('py\n'):
ret = ret[3:]
start = time.time()
returned = await execSandbox(ret, 5 if is_priv else 2)
duration = returned.duration # the execution time of the script alone
if not returned.exc:
if type(returned.img) is pygame.Surface:
pygame.image.save(returned.img, f'temp{start}.png')
if os.path.getsize(f'temp{start}.png') < 2**22:
await msg.channel.send(
file=discord.File(f'temp{start}.png'))
else:
await sendEmbed(msg.channel, 'Image cannot be sent',
'The image file size is >4MiB')
os.remove(f'temp{start}.png')
str_repr = str(returned.text).replace(
"```", "\u200e`\u200e`\u200e`\u200e")
if str_repr == '':
str_repr = ' '
if len(str_repr) + 6 > 2048:
await sendEmbed(
msg.channel,
f'Returned text (code executed in {formatTime(duration)}):',
'```' + str_repr[:2038] + ' ...```')
else:
await sendEmbed(
msg.channel,
f'Returned text (code executed in {formatTime(duration)}):',
'```' + str_repr + '```')
else:
exp = type(returned.exc).__name__.replace(
"```", "\u200e`\u200e`\u200e`\u200e") + ': ' + ", ".join([
str(t) for t in returned.exc.args
]).replace("```", "\u200e`\u200e`\u200e`\u200e")
if len(exp) + 6 > 2048:
await sendEmbed(msg.channel, 'An exception occured!',
'```' + exp[:2038] + ' ...```')
else:
await sendEmbed(msg.channel, 'An exception occured!',
'```' + exp + '```')
elif i(args, 0) == 'pet' and len(args) == 1:
pet_anger -= (time.time() - last_pet - pet_interval) * (
pet_anger / jumpscare_threshold) - pet_cost
if pet_anger < pet_cost:
pet_anger = pet_cost
last_pet = time.time()
if pet_anger > jumpscare_threshold:
await msg.channel.send(file=discord.File('save/die.gif'))
else:
await msg.channel.send(file=discord.File('save/pet.gif'))
elif i(args, 0) == 'vibecheck' and len(args) == 1:
await sendEmbed(
msg.channel, 'Vibe Check, snek?',
f'Previous petting anger: {pet_anger:.2f}/{jumpscare_threshold:.2f}\nIt was last pet {time.time() - last_pet:.2f} second(s) ago'
)
def test_i(self):
"""test the i function"""
x = "12"
value = util.i(x)
self.assertEqual(int(x), value)
def add_contest():
"""
Adds or edits a contest
Note:
must be called from within a request context
Returns:
a redirect to the contest view page
"""
name = request.form.get("name")
activate_date = request.form.get("activate_date")
activate_time = request.form.get("activate_time")
start_date = request.form.get("start_date")
start_time = request.form.get("start_time")
freeze_date = request.form.get("freeze_date")
freeze_time = request.form.get("freeze_time")
end_date = request.form.get("end_date")
end_time = request.form.get("end_time")
deactivate_date = request.form.get("deactivate_date")
deactivate_time = request.form.get("deactivate_time")
is_public = request.form.get("is_public")
user_usernames = request.form.get("users")
problem_slugs = request.form.get("problems")
if activate_date is not "" and activate_time is not "":
activate_date_time = util.strs_to_dt(activate_date, activate_time)
else:
activate_date_time = None
if freeze_date is not "" and freeze_time is not "":
freeze_date_time = util.strs_to_dt(freeze_date, freeze_time)
else:
freeze_date_time = None
if deactivate_date is not "" and deactivate_time is not "":
deactivate_date_time = util.strs_to_dt(deactivate_date,
deactivate_time)
else:
deactivate_date_time = None
if name is None:
error = "Failed to add contest due to undefined contest name."
current_app.logger.info(error)
flash(error, "danger")
return redirect(url_for("contests.contests_view"))
# convert is_public to a bool
is_public_bool = util.checkbox_result_to_bool(is_public)
if is_public_bool is None:
error = "Failed to add contest '{}' due to invalid is_public check.".format(
name)
current_app.logger.info(error)
flash(error, "danger")
return redirect(url_for("contests.contests_view"))
contest_id = util.i(request.form.get("contest_id"))
if contest_id: # edit
contest = model.Contest.query.filter_by(id=int(contest_id)).one()
contest.name = name
contest.is_public = is_public_bool
contest.activate_time = activate_date_time
contest.start_time = util.strs_to_dt(start_date, start_time)
contest.freeze_time = freeze_date_time
contest.end_time = util.strs_to_dt(end_date, end_time)
contest.deactivate_time = deactivate_date_time
contest.users = users_from_usernames(user_usernames.split(), model)
contest.problems = problems_from_slugs(problem_slugs.split(), model)
else: # add
if is_dup_contest_name(name):
error = "Failed to add contest '{}' as contest already exists.".format(
name)
current_app.logger.info(error)
flash(error, "danger")
return redirect(url_for("contests.contests_view"))
contest = model.Contest(
name=name,
is_public=is_public_bool,
activate_time=activate_date_time,
start_time=util.strs_to_dt(start_date, start_time),
freeze_time=freeze_date_time,
end_time=util.strs_to_dt(end_date, end_time),
deactivate_time=deactivate_date_time,
users=users_from_usernames(user_usernames.split(), model),
problems=problems_from_slugs(problem_slugs.split(), model),
)
db_session.add(contest)
db_session.commit()
# If a problem is added to a contest, the cached runs will be
# inaccurate. Clear the run cache to fix this.
util.invalidate_cache(util.RUN_CACHE_NAME)
return redirect(url_for("contests.contests_view"))
def announce(self, obj):
util.i("%s >t: %s@%s" % (self.__class__.__name__.lower(), id(obj), str(obj.type)))
util.v(str(obj))
if not self._sched:
return
self._sched._drop(obj)
def handle(self, obj):
util.i("%s <h: %s@%s" % (self.__class__.__name__.lower(), id(obj), str(obj.type)))
util.v(str(obj))
def load_test():
existing_user = model.User.query.filter_by(username="******").scalar()
contest = model.Contest.query.first()
defendants = (
model.User.query.filter(model.User.user_roles.any(name="defendant"))
.filter(model.User.contests.any(id=contest.id))
.all()
)
problems = (
model.Problem.query.filter(model.Problem.contests.any(id=contest.id))
.filter(model.Problem.is_enabled)
.all()
)
user_points = []
for user in defendants:
problem_states = {}
penalty = 0
for problem in problems:
is_passed = 0 < len(
model.Run.query.filter_by(
is_submission=True,
is_passed=True,
user=user,
contest=contest,
problem=problem,
).all()
)
problem_states[problem.slug] = is_passed
failed_subs = model.Run.query.filter_by(
is_submission=True,
is_passed=False,
user=user,
contest=contest,
problem=problem,
).all()
for sub in failed_subs:
penalty += 1 # TODO we may want to use the time submitted instead of 1
# to match ICPC scoring
user_points.append(
{
"user": user.get_output_dict(),
"num_solved": len([x for x in problem_states.values() if x]),
"penalty": penalty,
"problem_states": problem_states,
}
)
user_points.sort(key=lambda x: (x["num_solved"], -x["penalty"]), reverse=True)
user = model.User.query.filter_by(username="******").scalar()
if not user or not user.verify_password("test"):
pass
user = model.User.query.filter_by(username="******").scalar()
if not user or not user.verify_password("password"):
pass
langs = model.Language.query.all()
filter_langs = [x.get_output_dict() for x in langs if x.is_enabled]
curr_user = model.User.query.filter_by(id=util.i(5)).scalar()
contests = curr_user.contests
resp = None
if curr_user:
resp = curr_user.get_output_dict()
over_limit_runs_query = model.Run.submit_time > (
datetime.datetime.utcnow() - datetime.timedelta(minutes=5)
)
run_count = (
model.Run.query.filter_by(user_id=curr_user.id)
.filter(over_limit_runs_query)
.count()
)
matching_user = model.User.query.filter_by(username="******").scalar()
current_user_id = 5
user = model.User.query.filter_by(id=util.i(current_user_id)).scalar()
MAX_RUNS = util.get_configuration("max_user_submissions")
TIME_LIMIT = util.get_configuration("user_submission_time_limit")
over_limit_runs_query = model.Run.submit_time > (
datetime.datetime.utcnow() - datetime.timedelta(minutes=TIME_LIMIT)
)
run_count = (
model.Run.query.filter_by(user_id=user.id).filter(over_limit_runs_query).count()
)
contest = user.contests[0]
lang_name = "python"
problem_slug = "fizzbuzz"
source_code = "asjdnsadjkasd" * 10000
is_submission = False
user_test_input = "asdkamdlkamdklas" * 10000
lang = model.Language.query.filter_by(name=lang_name).one()
problem = model.Problem.query.filter_by(slug=problem_slug).scalar()
run_input = None
run_output = None
if is_submission:
run_input = problem.secret_input
run_output = problem.secret_output
else:
if user_test_input:
run_input = user_test_input
else:
run_input = problem.sample_input
run_output = problem.sample_output
return "good"
def add_lang():
"""
Adds or edits a language
Note:
must be called from within a request context
Returns:
a redirect to the language view page
"""
name = request.form.get("name")
syntax_mode = request.form.get("syntax_mode")
is_enabled = request.form.get("is_enabled")
run_script = request.form.get("run_script", "").replace('\r\n', '\n')
default_template = request.form.get("default_template",
"").replace('\r\n', '\n')
if name is None:
error = "Failed to add language due to undefined language name."
current_app.logger.info(error)
flash(error, "danger")
return redirect(url_for("languages.languages_view"))
if syntax_mode is None:
error = "Failed to add language due to undefined syntax_mode."
current_app.logger.info(error)
flash(error, "danger")
return redirect(url_for("languages.languages_view"))
# convert is_enabled to a bool
is_enabled_bool = util.checkbox_result_to_bool(is_enabled)
if is_enabled_bool is None:
error = "Failed to add language \'{}\' due to invalid is_enabled check.".format(
name)
current_app.logger.info(error)
flash(error, "danger")
return redirect(url_for("languages.languages_view"))
lang_id = util.i(request.form.get('lang_id'))
if lang_id: # edit
lang = model.Language.query.filter_by(id=lang_id).one()
lang.name = name
lang.syntax_mode = syntax_mode
lang.is_enabled = is_enabled_bool
lang.run_script = run_script
lang.default_template = default_template
else: # add
if is_dup_lang_name(name):
error = "Failed to add language \'{}\' as language already exists.".format(
name)
current_app.logger.info(error)
flash(error, "danger")
return redirect(url_for("languages.languages_view"))
lang = model.Language(name, syntax_mode, is_enabled_bool, run_script,
default_template)
db_session.add(lang)
db_session.commit()
return redirect(url_for("languages.languages_view"))
