def post(self, dataset_id):
fallback_page = self.url("dataset", dataset_id, "managers", "add")
dataset = self.safe_get_item(Dataset, dataset_id)
task = dataset.task
manager = self.request.files["manager"][0]
task_name = task.name
self.sql_session.close()
try:
digest = self.application.service.file_cacher.put_file_content(
manager["body"], "Task manager for %s" % task_name)
except Exception as error:
self.application.service.add_notification(
make_datetime(), "Manager storage failed", repr(error))
self.redirect(fallback_page)
return
self.sql_session = Session()
dataset = self.safe_get_item(Dataset, dataset_id)
task = dataset.task
manager = Manager(manager["filename"], digest, dataset=dataset)
self.sql_session.add(manager)
if self.try_commit():
self.redirect(self.url("task", task.id))
else:
self.redirect(fallback_page)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.timestamp = make_datetime()
self.sql_session = Session()
self.r_params = None
self.contest = None
self.url = None
def post(self, task_id):
fallback_page = self.url("task", task_id, "attachments", "add")
task = self.safe_get_item(Task, task_id)
attachment = self.request.files["attachment"][0]
task_name = task.name
self.sql_session.close()
try:
digest = self.service.file_cacher.put_file_content(
attachment["body"], "Task attachment for %s" % task_name)
except Exception as error:
self.service.add_notification(make_datetime(),
"Attachment storage failed",
repr(error))
self.redirect(fallback_page)
return
# TODO verify that there's no other Attachment with that filename
# otherwise we'd trigger an IntegrityError for constraint violation
self.sql_session = Session()
task = self.safe_get_item(Task, task_id)
attachment = Attachment(attachment["filename"], digest, task=task)
self.sql_session.add(attachment)
if self.try_commit():
self.redirect(self.url("task", task_id))
else:
self.redirect(fallback_page)
def prepare(self):
"""This method is executed at the beginning of each request.
"""
super(CommonRequestHandler, self).prepare()
self.timestamp = make_datetime()
self.set_header("Cache-Control", "no-cache, must-revalidate")
self.sql_session = Session()
self.sql_session.expire_all()
def post(self, task_id):
fallback_page = self.url("task", task_id, "statements", "add")
task = self.safe_get_item(Task, task_id)
language = self.get_argument("language", "")
if len(language) == 0:
self.service.add_notification(
make_datetime(),
"No language code specified",
"The language code can be any string.")
self.redirect(fallback_page)
return
statement = self.request.files["statement"][0]
# check statement type
statement_type = get_statement_type(statement["filename"])
if statement_type is None:
valid_types = "|".join(get_valid_statement_types())
self.service.add_notification(
make_datetime(),
"Invalid task statement",
"The task statement must be of a supported file type (" + valid_types + ").")
self.redirect(fallback_page)
return
task_name = task.name
self.sql_session.close()
try:
digest = self.service.file_cacher.put_file_content(
statement["body"],
"Statement for task %s (lang: %s)" % (task_name, language))
except Exception as error:
self.service.add_notification(
make_datetime(),
"Task statement storage failed",
repr(error))
self.redirect(fallback_page)
return
# TODO verify that there's no other Statement with that language
# otherwise we'd trigger an IntegrityError for constraint violation
self.sql_session = Session()
task = self.safe_get_item(Task, task_id)
self.contest = task.contest
statement = Statement(language, statement_type=statement_type, digest=digest, task=task)
self.sql_session.add(statement)
if self.try_commit():
self.redirect(self.url("task", task_id))
else:
self.redirect(fallback_page)
def post(self, dataset_id):
fallback_page = self.url("dataset", dataset_id, "testcases", "add")
dataset = self.safe_get_item(Dataset, dataset_id)
task = dataset.task
codename = self.get_argument("codename")
try:
input_ = self.request.files["input"][0]
output = self.request.files["output"][0]
except KeyError:
self.service.add_notification(
make_datetime(), "Invalid data",
"Please fill both input and output.")
self.redirect(fallback_page)
return
public = self.get_argument("public", None) is not None
task_name = task.name
self.sql_session.close()
try:
input_digest = \
self.service.file_cacher.put_file_content(
input_["body"],
"Testcase input for task %s" % task_name)
output_digest = \
self.service.file_cacher.put_file_content(
output["body"],
"Testcase output for task %s" % task_name)
except Exception as error:
self.service.add_notification(make_datetime(),
"Testcase storage failed",
repr(error))
self.redirect(fallback_page)
return
self.sql_session = Session()
dataset = self.safe_get_item(Dataset, dataset_id)
task = dataset.task
testcase = Testcase(codename,
public,
input_digest,
output_digest,
dataset=dataset)
self.sql_session.add(testcase)
if self.try_commit():
# max_score and/or extra_headers might have changed.
self.service.proxy_service.reinitialize()
self.redirect(self.url("task", task.id))
else:
self.redirect(fallback_page)
def __init__(self, *args, **kwargs):
super(CommonRequestHandler, self).__init__(*args, **kwargs)
self.timestamp = make_datetime()
self.sql_session = Session()
self.r_params = None
self.contest = None
self.url = None
self.redis_conn = None
if config.redis_url:
self.redis_conn = redis.StrictRedis.from_url(config.redis_url)
def prepare(self):
"""This method is executed at the beginning of each request.
"""
# Attempt to update the contest and all its references
# If this fails, the request terminates.
self.set_header("Cache-Control", "no-cache, must-revalidate")
self.sql_session = Session()
self.sql_session.expire_all()
self.contest = None
def prepare(self):
"""This method is executed at the beginning of each request.
"""
self.timestamp = make_datetime()
self.set_header("Cache-Control", "no-cache, must-revalidate")
self.sql_session = Session()
self.contest = Contest.get_from_id(self.application.service.contest,
self.sql_session)
self._ = self.locale.translate
self.r_params = self.render_params()
def post(self, task_id):
fallback_page = "/task/%s/statements/add" % task_id
task = self.safe_get_item(Task, task_id)
language = self.get_argument("language", None)
if language is None:
self.application.service.add_notification(
make_datetime(), "No language code specified",
"The language code can be any string.")
self.redirect(fallback_page)
return
statement = self.request.files["statement"][0]
if not statement["filename"].endswith(".pdf"):
self.application.service.add_notification(
make_datetime(), "Invalid task statement",
"The task statement must be a .pdf file.")
self.redirect(fallback_page)
return
task_name = task.name
self.sql_session.close()
try:
digest = self.application.service.file_cacher.put_file_content(
statement["body"],
"Statement for task %s (lang: %s)" % (task_name, language))
except Exception as error:
self.application.service.add_notification(
make_datetime(), "Task statement storage failed", repr(error))
self.redirect(fallback_page)
return
# TODO verify that there's no other Statement with that language
# otherwise we'd trigger an IntegrityError for constraint violation
self.sql_session = Session()
task = self.safe_get_item(Task, task_id)
self.contest = task.contest
statement = Statement(language, digest, task=task)
self.sql_session.add(statement)
if self.try_commit():
self.redirect("/task/%s" % task_id)
else:
self.redirect(fallback_page)
def test_import_with_drop(self):
"""Test importing everything, but dropping existing data."""
self.write_dump(TestDumpImporter.DUMP)
self.write_files(TestDumpImporter.FILES)
# Need to close the session and reopen it, otherwise the drop hangs.
self.session.close()
self.assertTrue(self.do_import(drop=True))
self.session = Session()
self.assertContestInDb("contestname", "contest description 你好",
[("taskname", "task title")],
[("username", "Last Name")])
self.assertContestNotInDb(self.other_contest_name)
self.assertFileInDb(TestDumpImporter.GENERATED_FILE_DIGEST, "desc",
b"content")
self.assertFileInDb(TestDumpImporter.NOT_GENERATED_FILE_DIGEST,
"subsource", b"source")
def setUp(self):
super(DatabaseMixin, self).setUp()
self.session = Session()
def setUp(self):
super().setUp()
self.session = Session()
def post(self, dataset_id):
fallback_page = "/dataset/%s/testcases/add_multiple" % dataset_id
# TODO: this method is quite long, some splitting is needed.
dataset = self.safe_get_item(Dataset, dataset_id)
task = dataset.task
try:
archive = self.request.files["archive"][0]
except KeyError:
self.application.service.add_notification(
make_datetime(), "Invalid data",
"Please choose tests archive.")
self.redirect(fallback_page)
return
public = self.get_argument("public", None) is not None
overwrite = self.get_argument("overwrite", None) is not None
# Get input/output file names templates, or use default ones.
input_template = self.get_argument("input_template", None)
if not input_template:
input_template = "input.*"
output_template = self.get_argument("output_template", None)
if not output_template:
output_template = "output.*"
input_re = re.compile(
re.escape(input_template).replace("\\*", "(.*)") + "$")
output_re = re.compile(
re.escape(output_template).replace("\\*", "(.*)") + "$")
task_name = task.name
self.sql_session.close()
fp = StringIO(archive["body"])
try:
with zipfile.ZipFile(fp, "r") as archive_zfp:
tests = dict()
# Match input/output file names to testcases' codenames.
for filename in archive_zfp.namelist():
match = input_re.match(filename)
if match:
codename = match.group(1)
if codename not in tests:
tests[codename] = [None, None]
tests[codename][0] = filename
else:
match = output_re.match(filename)
if match:
codename = match.group(1)
if codename not in tests:
tests[codename] = [None, None]
tests[codename][1] = filename
skipped_tc = []
overwritten_tc = []
added_tc = []
for codename, testdata in tests.iteritems():
# If input or output file isn't found, skip it.
if not testdata[0] or not testdata[1]:
continue
self.sql_session = Session()
# Check, whether current testcase already exists.
dataset = self.safe_get_item(Dataset, dataset_id)
task = dataset.task
if codename in dataset.testcases:
# If we are allowed, remove existing testcase.
# If not - skip this testcase.
if overwrite:
testcase = dataset.testcases[codename]
self.sql_session.delete(testcase)
if not self.try_commit():
skipped_tc.append(codename)
continue
overwritten_tc.append(codename)
else:
skipped_tc.append(codename)
continue
# Add current testcase.
try:
input_ = archive_zfp.read(testdata[0])
output = archive_zfp.read(testdata[1])
except Exception as error:
self.application.service.add_notification(
make_datetime(),
"Reading testcase %s failed" % codename,
repr(error))
self.redirect(fallback_page)
return
try:
input_digest = self.application.service\
.file_cacher.put_file_content(
input_,
"Testcase input for task %s" % task_name)
output_digest = self.application.service\
.file_cacher.put_file_content(
output,
"Testcase output for task %s" % task_name)
except Exception as error:
self.application.service.add_notification(
make_datetime(), "Testcase storage failed",
repr(error))
self.redirect(fallback_page)
return
testcase = Testcase(codename,
public,
input_digest,
output_digest,
dataset=dataset)
self.sql_session.add(testcase)
if not self.try_commit():
self.application.service.add_notification(
make_datetime(), "Couldn't add test %s" % codename,
"")
self.redirect(fallback_page)
return
if codename not in overwritten_tc:
added_tc.append(codename)
except zipfile.BadZipfile:
self.application.service.add_notification(
make_datetime(), "The selected file is not a zip file.",
"Please select a valid zip file.")
self.redirect(fallback_page)
return
self.application.service.add_notification(
make_datetime(),
"Successfully added %d and overwritten %d testcase(s)" %
(len(added_tc), len(overwritten_tc)),
"Added: %s; overwritten: %s; skipped: %s" %
(", ".join(added_tc) if added_tc else "none",
", ".join(overwritten_tc) if overwritten_tc else "none",
", ".join(skipped_tc) if skipped_tc else "none"))
self.application.service.proxy_service.reinitialize()
self.redirect("/task/%s" % task.id)
def setUp(self):
self.session = Session()
return l[0], "\n".join(l[1:])
def bold(s):
return "*" + s + "*"
def italic(s):
return "_" + s + "_"
def escape(s):
return "".join("\\" + c if ord(c) > 32 and ord(c) < 127 else c for c in s)
def code(s):
linebreak = "" if len(s) > 0 and s[-1] == "\n" else "\n"
return "```\n" + s + linebreak + "```\n"
_session = Session()
class WithDatabaseAccess(object):
""" Base class for database access
"""
def __init__(self, sql_session):
self.sql_session = sql_session
def _commit(self):
self.sql_session.commit()
class MyQuestion(WithDatabaseAccess):
""" Thin wrapper around question
"""
