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