def pack(self):
try:
original_package = OriginalPackage.objects.get(
problem=self.problem)
if original_package.problem_package.package_file:
return stream_file(original_package.
problem_package.package_file)
except OriginalPackage.DoesNotExist:
pass
# If the original package is not available, produce the most basic
# output: tests, statements, model solutions.
fd, tmp_filename = tempfile.mkstemp()
try:
self.zip = zipfile.ZipFile(os.fdopen(fd, 'wb'), 'w',
zipfile.ZIP_DEFLATED)
self._pack_statement()
self._pack_tests()
self._pack_model_solutions()
self.zip.close()
zip_filename = '%s.zip' % self.short_name
return stream_file(File(open(tmp_filename, 'rb'),
name=zip_filename))
finally:
os.unlink(tmp_filename)
def problem_attachment_view(request, attachment_id):
attachment = get_object_or_404(ProblemAttachment, id=attachment_id)
problem_instances = visible_problem_instances(request)
problem_ids = [pi.problem_id for pi in problem_instances]
if attachment.problem_id not in problem_ids:
raise PermissionDenied
return stream_file(attachment.content, attachment.download_name)
def problem_statement_view(request, problem_instance):
controller = request.contest.controller
pi = get_object_or_404(ProblemInstance, round__contest=request.contest,
short_name=problem_instance)
if not controller.can_see_problem(request, pi) or \
not controller.can_see_statement(request, pi):
raise PermissionDenied
if not pi.problem.controller.supports_problem_statement():
# if the problem doesn't support having a problem statement,
# redirect to submission
return redirect('submit', problem_instance_id=pi.id)
statement = query_statement(pi.problem)
if not statement:
return TemplateResponse(request, 'contests/no_problem_statement.html',
{'problem_instance': pi})
if statement.extension == '.zip':
return redirect('problem_statement_zip_index',
contest_id=request.contest.id,
problem_instance=problem_instance, statement_id=statement.id)
return stream_file(statement.content, statement.download_name)
def problem_site_external_statement_view(request, site_key):
problem = get_object_or_404(Problem, problemsite__url_key=site_key)
statement = query_statement(problem.id)
if statement.extension == '.zip' \
and not can_admin_problem(request, problem):
raise PermissionDenied
return stream_file(statement.content, statement.download_name)
def contest_attachment_view(request, contest_id, attachment_id):
attachment = get_object_or_404(ContestAttachment,
contest_id=contest_id,
id=attachment_id)
if attachment.round and attachment.round not in visible_rounds(request):
raise PermissionDenied
return stream_file(attachment.content)
def problem_statement_view(request, problem_instance):
controller = request.contest.controller
pi = get_object_or_404(ProblemInstance,
round__contest=request.contest,
short_name=problem_instance)
if not controller.can_see_problem(request, pi) or \
not controller.can_see_statement(request, pi):
raise PermissionDenied
if not pi.problem.controller.supports_problem_statement():
# if the problem doesn't support having a problem statement,
# redirect to submission
return redirect('submit', problem_instance_id=pi.id)
statement = query_statement(pi.problem)
if not statement:
return TemplateResponse(request, 'contests/no_problem_statement.html',
{'problem_instance': pi})
if statement.extension == '.zip':
return redirect('problem_statement_zip_index',
contest_id=request.contest.id,
problem_instance=problem_instance,
statement_id=statement.id)
return stream_file(statement.content, statement.download_name)
def generate_pdfreport(request, report_form):
report = _report_text(request, 'oireports/pdfreport.tex', report_form)
# Create temporary file and folder
tmp_folder = mkdtemp()
try:
tex_file, tex_filename = mkstemp(dir=tmp_folder)
# Pass the TeX template through Django templating engine
# and into the temp file
os.write(tex_file, report.encode('utf-8'))
os.close(tex_file)
# Compile the TeX file with PDFLaTeX
# \write18 is disabled by default, so no LaTeX injection should happen
for i in xrange(3):
p = subprocess.Popen([
'pdflatex',
'-output-directory=' + tmp_folder,
tex_filename
],
stdin=open('/dev/null'),
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
stdout, stderr = p.communicate()
if p.returncode:
raise RuntimeError('pdflatex failed: ' + stdout)
# Get PDF file contents
pdf_file = open(tex_filename + '.pdf', 'r')
filename = '%s-%s-%s.pdf' % (request.contest.id,
report_form.cleaned_data['report_round'],
report_form.cleaned_data['report_region'])
return stream_file(File(pdf_file), filename)
finally:
shutil.rmtree(tmp_folder)
def download_user_all_output_view(request, submission_report_id):
submission_report = get_object_or_404(SubmissionReport,
id=submission_report_id)
_check_generate_out_permission(request, submission_report)
testreports = TestReport.objects.filter(
submission_report=submission_report)
if not all(bool(report.output_file) for report in testreports):
raise Http404
if not is_contest_basicadmin(request):
for report in testreports:
_check_generated_out_visibility_for_user(report)
zipfd, tmp_zip_filename = tempfile.mkstemp()
with zipfile.ZipFile(os.fdopen(zipfd, 'wb'), 'w') as zip:
for report in testreports:
arcname = _userout_filename(report)
testfd, tmp_test_filename = tempfile.mkstemp()
fileobj = os.fdopen(testfd, 'wb')
try:
shutil.copyfileobj(report.output_file, fileobj)
fileobj.close()
zip.write(tmp_test_filename, arcname)
finally:
os.unlink(tmp_test_filename)
name = submission_report.submission.problem_instance.problem.short_name
return stream_file(
File(
open(tmp_zip_filename, 'rb'),
name=name + '_' + str(submission_report.submission.user) +
'_' + str(submission_report.id) + '_user_outs.zip',
))
def test_view(request, package_id):
tp = get_object_or_404(TestsPackage, id=package_id)
if not is_contest_admin(request) and not tp.is_visible(request.timestamp):
raise PermissionDenied
file_name = '%s.zip' % tp.name
file_name = file_name.encode('utf-8')
return stream_file(tp.package, name=file_name)
def download_user_all_output_view(request, submission_report_id):
submission_report = get_object_or_404(SubmissionReport,
id=submission_report_id)
_check_generate_out_permission(request, submission_report)
testreports = TestReport.objects.filter(
submission_report=submission_report)
if not all(bool(report.output_file) for report in testreports):
raise Http404
if not is_contest_admin(request):
for report in testreports:
_check_generated_out_visibility_for_user(report)
zipfd, tmp_zip_filename = tempfile.mkstemp()
with zipfile.ZipFile(os.fdopen(zipfd, 'wb'), 'w') as zip:
for report in testreports:
arcname = _userout_filename(report)
testfd, tmp_test_filename = tempfile.mkstemp()
fileobj = os.fdopen(testfd, 'wb')
try:
shutil.copyfileobj(report.output_file, fileobj)
fileobj.close()
zip.write(tmp_test_filename, arcname)
finally:
os.unlink(tmp_test_filename)
name = submission_report.submission.problem_instance.problem.short_name
return stream_file(File(open(tmp_zip_filename, 'rb'),
name=name + '_' + str(submission_report.submission.user) +
'_' + str(submission_report.id) + '_user_outs.zip'))
def problem_attachment_view(request, contest_id, attachment_id):
attachment = get_object_or_404(ProblemAttachment, id=attachment_id)
problem_instances = visible_problem_instances(request)
problem_ids = [pi.problem_id for pi in problem_instances]
if attachment.problem_id not in problem_ids:
raise PermissionDenied
return stream_file(attachment.content)
def download_checker_exe_view(request, checker_id):
checker = get_object_or_404(OutputChecker, id=checker_id)
if not can_admin_problem_instance(request, checker.problem):
raise PermissionDenied
if not checker.exe_file:
raise Http404
return stream_file(checker.exe_file)
def problem_statement_view(request, contest_id, problem_instance):
controller = request.contest.controller
pi = get_object_or_404(ProblemInstance, round__contest=request.contest,
short_name=problem_instance)
if not controller.can_see_problem(request, pi):
raise PermissionDenied
statements = ProblemStatement.objects.filter(problem=pi.problem)
if not statements:
return TemplateResponse(request, 'contests/no_problem_statement.html',
{'problem_instance': pi})
lang_prefs = [translation.get_language()] + ['', None] + \
[l[0] for l in settings.LANGUAGES]
ext_prefs = ['.pdf', '.ps', '.html', '.txt']
def sort_key(statement):
try:
lang_pref = lang_prefs.index(statement.language)
except ValueError:
lang_pref = sys.maxint
try:
ext_pref = (ext_prefs.index(statement.extension), '')
except ValueError:
ext_pref = (sys.maxint, statement.extension)
return lang_pref, ext_pref
statement = sorted(statements, key=sort_key)[0]
return stream_file(statement.content)
def download_checker_exe_view(request, checker_id):
checker = get_object_or_404(OutputChecker, id=checker_id)
if not request.user.has_perm("problems.problem_admin", checker.problem):
raise PermissionDenied
if not checker.exe_file:
raise Http404
return stream_file(checker.exe_file)
def download_input_file_view(request, test_id):
test = get_object_or_404(Test, id=test_id)
if not can_admin_instance_of_problem(request, test.problem):
raise PermissionDenied
return stream_file(test.input_file,
strip_num_or_hash(test.input_file.name))
def generate_xmlreport(request, report_form):
report = _report_text(request, 'oireports/xmlreport.xml', report_form)
filename = '%s-%s-%s.xml' % (
request.contest.id,
report_form.cleaned_data['report_round'],
report_form.cleaned_data['report_region'],
)
return stream_file(ContentFile(report.encode('utf-8')), filename)
def download_checker_exe_view(request, checker_id):
checker = get_object_or_404(OutputChecker, id=checker_id)
if not can_admin_instance_of_problem(request, checker.problem):
raise PermissionDenied
if not checker.exe_file:
raise Http404
return stream_file(checker.exe_file,
strip_num_or_hash(checker.exe_file.name))
def download_checker_exe_view(request, checker_id):
checker = get_object_or_404(OutputChecker, id=checker_id)
if not test.problem_instance.controller.can_see_checker_exe(request, test):
raise PermissionDenied
if not checker.exe_file:
raise Http404
return stream_file(checker.exe_file,
strip_num_or_hash(checker.exe_file.name))
def download_package_traceback_view(request, package_id):
package = _get_package(request, package_id, 'contests.contest_basicadmin')
if not package.traceback:
raise Http404
return stream_file(
package.traceback,
'package_%s_%d_traceback.txt' % (package.problem_name, package.id),
)
def download_output_file_view(request,
contest_id,
submission_id,
testrun_report_id=None):
submission = get_submission_or_error(request, contest_id, submission_id,
TestRunProgramSubmission)
result = get_testrun_report_or_404(request, submission, testrun_report_id)
return stream_file(result.output_file, name='output.out')
def problem_site_external_statement_view(request, site_key):
problem = get_object_or_404(Problem, problemsite__url_key=site_key)
statement = query_statement(problem.id)
if not statement:
raise Http404
if statement.extension == '.zip' \
and not can_admin_problem(request, problem):
raise PermissionDenied
return stream_file(statement.content, statement.download_name)
def _resolve_streamed_files(file, ext):
if isinstance(file, six.string_types) or hasattr(
file, 'seek') or hasattr(file, 'tell'):
return file, False
lookup_filename = file.name + ext
base, tail_ext = os.path.splitext(lookup_filename.lower())
f = tempfile.NamedTemporaryFile(suffix=tail_ext, delete=False)
f.writelines(stream_file(file, file.name).streaming_content)
f.close()
return f.name, True
def pack(self):
try:
original_package = OriginalPackage.objects.get(
problem=self.problem)
return stream_file(original_package.package_file)
except OriginalPackage.DoesNotExist:
# If the original package is not available, produce the most basic
# output: tests, statements, model solutions.
fd, tmp_filename = tempfile.mkstemp()
try:
self.zip = zipfile.ZipFile(os.fdopen(fd, 'wb'), 'w')
self._pack_statement()
self._pack_tests()
self._pack_model_solutions()
self.zip.close()
zip_filename = '%s.zip' % (self.short_name, )
return stream_file(
File(open(tmp_filename, 'rb'), name=zip_filename))
finally:
os.unlink(tmp_filename)
def contest_attachment_view(request, attachment_id):
attachment = get_object_or_404(ContestAttachment,
contest_id=request.contest.id, id=attachment_id)
if (attachment.round and
attachment.round not in visible_rounds(request)) or \
(not is_contest_admin(request) and
attachment.pub_date and attachment.pub_date > request.timestamp):
raise PermissionDenied
return stream_file(attachment.content, attachment.download_name)
def contest_attachment_view(request, attachment_id):
attachment = get_object_or_404(ContestAttachment,
contest_id=request.contest.id, id=attachment_id)
if (attachment.round and
attachment.round not in visible_rounds(request)) or \
(not is_contest_basicadmin(request) and
attachment.pub_date and attachment.pub_date > request.timestamp):
raise PermissionDenied
return stream_file(attachment.content, attachment.download_name)
def download_problem_package_file_view(request, package_id, file_name):
package = _get_package(request, package_id, 'contests.contest_admin')
archive = Archive(package.package_file)
dir_path = tempfile.mkdtemp(dir=tempfile.gettempdir())
try:
archive.extract(to_path=dir_path)
filepath = os.path.join(dir_path, file_name)
if os.path.isfile(filepath):
return stream_file(File(open(filepath)),
os.path.basename(os.path.normpath(file_name)))
finally:
shutil.rmtree(dir_path)
def picture_view(request, mode, picture_id):
modes = {
'a': QuizAnswerPicture,
'q': QuizQuestionPicture,
}
if mode not in modes:
return HttpResponseNotFound()
picture = get_object_or_404(modes[mode], id=picture_id)
if not any([pi.controller.can_submit(request, pi) or can_admin_problem_instance(request, pi) \
for pi in picture.quiz.probleminstance_set.filter(contest=request.contest)]):
raise PermissionDenied
return stream_file(picture.file)
def download_user_one_output_view(request, testreport_id):
testreport = get_object_or_404(TestReport, id=testreport_id)
if not is_contest_admin(request):
_check_generated_out_visibility_for_user(testreport)
submission_report = testreport.submission_report
_check_generate_out_permission(request, submission_report)
if not bool(testreport.output_file):
raise Http404
return stream_file(testreport.output_file, _userout_filename(testreport))
def download_user_one_output_view(request, testreport_id):
testreport = get_object_or_404(TestReport, id=testreport_id)
if not is_contest_admin(request):
_check_generated_out_visibility_for_user(testreport)
submission_report = testreport.submission_report
_check_generate_out_permission(request, submission_report)
if not bool(testreport.output_file):
raise Http404
return stream_file(testreport.output_file, _userout_filename(testreport))
def download_output_file_view(request, submission_id,
testrun_report_id=None):
submission = get_submission_or_error(request, submission_id,
ZeusTestRunProgramSubmission)
result = get_testrun_report_or_404(request, submission, testrun_report_id,
ZeusTestRunReport)
if result.output_file.size != result.full_out_size:
zeus_server = get_zeus_server(
submission.problem_instance.problem.zeusproblemdata.zeus_id)
file = zeus_server.download_output(int(result.full_out_handle))
result.output_file.save('full_out', ContentFile(file))
return stream_file(result.output_file, name='output.out')
def pack(self):
""":returns: Archive from original package if such file exists,
otherwise new archive with test, statements and model solutions.
"""
try:
original_package = OriginalPackage.objects.get(
problem=self.problem)
if original_package.problem_package.package_file:
return stream_file(
original_package.problem_package.package_file)
except OriginalPackage.DoesNotExist:
pass
return self._create_basic_archive()
def pack(self):
""":returns: Archive from original package if such file exists,
otherwise new archive with test, statements and model solutions.
"""
try:
original_package = OriginalPackage.objects.get(
problem=self.problem)
if original_package.problem_package.package_file:
return stream_file(original_package.
problem_package.package_file)
except OriginalPackage.DoesNotExist:
pass
return self._create_basic_archive()
def _create_basic_archive(self):
"""Produce the most basic output: tests, statements, model solutions."""
fd, tmp_filename = tempfile.mkstemp()
try:
self.zip = zipfile.ZipFile(os.fdopen(fd, 'wb'), 'w',
zipfile.ZIP_DEFLATED)
self._pack_statement()
self._pack_tests()
self._pack_model_solutions()
self.zip.close()
zip_filename = '%s.zip' % self.short_name
return stream_file(
File(open(tmp_filename, 'rb'), name=zip_filename))
finally:
os.unlink(tmp_filename)
def _create_basic_archive(self):
"""Produce the most basic output: tests, statements, model solutions.
"""
fd, tmp_filename = tempfile.mkstemp()
try:
self.zip = zipfile.ZipFile(os.fdopen(fd, 'wb'), 'w',
zipfile.ZIP_DEFLATED)
self._pack_statement()
self._pack_tests()
self._pack_model_solutions()
self.zip.close()
zip_filename = '%s.zip' % self.short_name
return stream_file(File(open(tmp_filename, 'rb'),
name=zip_filename))
finally:
os.unlink(tmp_filename)
def download_output_file_view(request,
contest_id,
submission_id,
testrun_report_id=None):
submission = get_submission_or_error(request, contest_id, submission_id,
ZeusTestRunProgramSubmission)
result = get_testrun_report_or_404(request, submission, testrun_report_id,
ZeusTestRunReport)
if result.output_file.size != result.full_out_size:
zeus_server = get_zeus_server(
submission.problem_instance.problem.zeusproblemdata.zeus_id)
file = zeus_server.download_output(int(result.full_out_handle))
result.output_file.save('full_out', ContentFile(file))
return stream_file(result.output_file, name='output.out')
def problem_statement_view(request, problem_instance):
controller = request.contest.controller
pi = get_object_or_404(ProblemInstance, round__contest=request.contest,
short_name=problem_instance)
if not controller.can_see_problem(request, pi) or \
not controller.can_see_statement(request, pi):
raise PermissionDenied
statement = query_statement(pi.problem)
if not statement:
return TemplateResponse(request, 'contests/no_problem_statement.html',
{'problem_instance': pi})
if statement.extension == '.zip':
return redirect('problem_statement_zip_index',
contest_id=request.contest.id,
problem_instance=problem_instance, statement_id=statement.id)
return stream_file(statement.content)
def generate_pdf(tex_code, filename, extra_args=[], num_passes=3):
# Create temporary file and folder
tmp_folder = tempfile.mkdtemp()
try:
tex_filename = 'doc.tex'
tex_path = os.path.join(tmp_folder, tex_filename)
with codecs.open(tex_path, 'w', 'utf-8') as f:
f.write(tex_code)
command = ['pdflatex']
command.extend(extra_args)
command.append(tex_filename)
for _i in xrange(num_passes):
execute(command, cwd=tmp_folder)
# Get PDF file contents
pdf_file = open(os.path.splitext(tex_path)[0] + '.pdf')
return stream_file(File(pdf_file), filename)
finally:
shutil.rmtree(tmp_folder)
def generate_pdf(tex_code, filename, extra_args=[], num_passes=3):
# Create temporary file and folder
tmp_folder = tempfile.mkdtemp()
try:
tex_filename = 'doc.tex'
tex_path = os.path.join(tmp_folder, tex_filename)
with codecs.open(tex_path, 'w', 'utf-8') as f:
f.write(tex_code)
command = ['pdflatex']
command.extend(extra_args)
command.append(tex_filename)
for _i in range(num_passes):
execute(command, cwd=tmp_folder)
# Get PDF file contents
pdf_file = open(os.path.splitext(tex_path)[0] + '.pdf')
return stream_file(File(pdf_file), filename)
finally:
shutil.rmtree(tmp_folder)
def problem_statement_view(request, contest_id, problem_instance):
controller = request.contest.controller
pi = get_object_or_404(ProblemInstance,
round__contest=request.contest,
short_name=problem_instance)
if not controller.can_see_problem(request, pi):
raise PermissionDenied
statements = ProblemStatement.objects.filter(problem=pi.problem)
if not statements:
return TemplateResponse(request, 'contests/no_problem_statement.html',
{'problem_instance': pi})
lang_prefs = [translation.get_language()] + ['', None] + \
[l[0] for l in settings.LANGUAGES]
ext_prefs = ['.zip', '.pdf', '.ps', '.html', '.txt']
def sort_key(statement):
try:
lang_pref = lang_prefs.index(statement.language)
except ValueError:
lang_pref = sys.maxint
try:
ext_pref = (ext_prefs.index(statement.extension), '')
except ValueError:
ext_pref = (sys.maxint, statement.extension)
return lang_pref, ext_pref
statement = sorted(statements, key=sort_key)[0]
if statement.extension == '.zip':
return redirect('problem_statement_zip_index',
contest_id=contest_id,
problem_instance=problem_instance,
statement_id=statement.id)
return stream_file(statement.content)
def download_output_file_view(request, test_id):
test = get_object_or_404(Test, id=test_id)
if not request.user.has_perm('problems.problem_admin', test.problem):
raise PermissionDenied
return stream_file(test.output_file)
def download_submission_source_view(request, contest_id, submission_id):
submission = get_object_or_404(ProgramSubmission, id=submission_id)
if contest_id != submission.problem_instance.contest_id:
raise Http404
check_submission_access(request, submission)
return stream_file(submission.source_file)
def show_problem_attachment_view(request, attachment_id):
attachment = get_object_or_404(ProblemAttachment, id=attachment_id)
if not can_admin_instance_of_problem(request, attachment.problem):
raise PermissionDenied
return stream_file(attachment.content, attachment.download_name)
def show_statement_view(request, statement_id):
statement = get_object_or_404(ProblemStatement, id=statement_id)
if not can_admin_instance_of_problem(request, statement.problem):
raise PermissionDenied
return stream_file(statement.content, statement.download_name)
def problem_site_external_attachment_view(request, site_key, attachment_id):
problem = get_object_or_404(Problem, problemsite__url_key=site_key)
attachment = get_object_or_404(ProblemAttachment, id=attachment_id)
if attachment.problem.id != problem.id:
raise PermissionDenied
return stream_file(attachment.content, attachment.download_name)
def contest_attachment_view(request, contest_id, attachment_id):
attachment = get_object_or_404(ContestAttachment, contest_id=contest_id,
id=attachment_id)
return stream_file(attachment.content)
def download_submission_source_view(request, contest_id, submission_id):
submission = get_submission_or_404(request, contest_id, submission_id,
ProgramSubmission)
return stream_file(submission.source_file)
def download_input_file_view(request, submission_id):
submission = get_submission_or_error(request, submission_id,
TestRunProgramSubmission)
return stream_file(submission.input_file, name='input.in')
def download_input_file_view(request, contest_id, submission_id):
submission = get_submission_or_404(request, contest_id, submission_id,
TestRunProgramSubmission)
return stream_file(submission.input_file, name='input.in')
def download_output_file_view(request, test_id):
test = get_object_or_404(Test, id=test_id)
if not can_admin_instance_of_problem(request, test.problem):
raise PermissionDenied
return stream_file(test.output_file,
strip_num_or_hash(test.output_file.name))
def download_submission_source_view(request, submission_id):
source_file = get_submission_source_file_or_error(request, submission_id)
return stream_file(source_file)
def download_report_view(request, pg_id):
pg = get_object_or_404(PrizeGiving, id=pg_id)
if not pg.report:
raise Http404
return stream_file(pg.report, name="prizes_report.csv")
def show_statement_view(request, statement_id):
statement = get_object_or_404(ProblemStatement, id=statement_id)
if not request.user.has_perm('problems.problem_admin', statement.problem):
raise PermissionDenied
return stream_file(statement.content)
def download_package_traceback_view(request, package_id):
package = _get_package(request, package_id)
if not package.traceback:
raise Http404
return stream_file(package.traceback, 'package_%s_%d_traceback.txt' % (
package.problem_name, package.id))
def generate_xmlreport(request, report_form):
report = _report_text(request, 'oireports/xmlreport.xml', report_form)
filename = '%s-%s-%s.xml' % (request.contest.id,
report_form.cleaned_data['report_round'],
report_form.cleaned_data['report_region'])
return stream_file(ContentFile(report.encode('utf-8')), filename)
def show_problem_attachment_view(request, attachment_id):
attachment = get_object_or_404(ProblemAttachment, id=attachment_id)
if not can_admin_instance_of_problem(request, attachment.problem):
raise PermissionDenied
return stream_file(attachment.content, attachment.download_name)
def download_output_file_view(request, contest_id, submission_id,
testrun_report_id=None):
submission = get_submission_or_404(request, contest_id, submission_id,
TestRunProgramSubmission)
result = get_testrun_report_or_404(request, submission, testrun_report_id)
return stream_file(result.output_file, name='output.out')
def download_problem_package_view(request, package_id):
package = _get_package(request, package_id)
return stream_file(package.package_file, package.download_name)
def stream_if_changed(request, image_object):
return stream_file(image_object.image)
def show_statement_view(request, statement_id):
statement = get_object_or_404(ProblemStatement, id=statement_id)
if not request.user.has_perm('problems.problem_admin', statement.problem):
raise PermissionDenied
return stream_file(statement.content)
