def test_custom_page_types_deprecate(self):
deadline = datetime(2039, 1, 1, 0, 0, 0, 0)
with override_settings(
RELATE_CUSTOM_PAGE_TYPES_REMOVED_DEADLINE=deadline):
resp = self.post_update_course_content(
commit_sha=self.commit_sha_deprecated)
self.assertEqual(resp.status_code, 200)
if datetime.now() <= self.force_deadline:
expected_message = (
self.deprecate_warning_message_pattern
% {"page_type": self.custom_page_type,
"date_time": format_datetime_local(self.force_deadline)}
)
self.assertEqual(
self.get_course_commit_sha(self.instructor_participation),
self.commit_sha_deprecated)
else:
expected_message = (
self.expired_error_message_pattern
% {"page_type": self.custom_page_type,
"date_time": format_datetime_local(self.force_deadline)}
)
self.assertEqual(
self.get_course_commit_sha(self.instructor_participation),
self.current_commit_sha)
self.assertResponseMessagesContains(resp, expected_message, loose=True)
def test_custom_page_types_deprecate(self):
deadline = datetime(2039, 1, 1, 0, 0, 0, 0)
with override_settings(
RELATE_CUSTOM_PAGE_TYPES_REMOVED_DEADLINE=deadline):
resp = self.post_update_course_content(
commit_sha=self.commit_sha_deprecated)
self.assertEqual(resp.status_code, 200)
if datetime.now() <= self.force_deadline:
expected_message = (
self.deprecate_warning_message_pattern % {
"page_type": self.custom_page_type,
"date_time": format_datetime_local(self.force_deadline)
})
self.assertEqual(
self.get_course_commit_sha(self.instructor_participation),
self.commit_sha_deprecated)
else:
expected_message = (
self.expired_error_message_pattern % {
"page_type": self.custom_page_type,
"date_time": format_datetime_local(self.force_deadline)
})
self.assertEqual(
self.get_course_commit_sha(self.instructor_participation),
self.current_commit_sha)
self.assertResponseMessagesContains(resp,
expected_message,
loose=True)
def view_reopen_session(pctx, flow_session_id, opportunity_id):
if pctx.role not in [
participation_role.instructor,
participation_role.teaching_assistant
]:
raise PermissionDenied()
request = pctx.request
session = get_object_or_404(FlowSession, id=int(flow_session_id))
from course.content import get_flow_desc
try:
flow_desc = get_flow_desc(pctx.repo, pctx.course, session.flow_id,
pctx.course_commit_sha)
except ObjectDoesNotExist:
raise http.Http404()
if request.method == "POST":
form = ReopenSessionForm(flow_desc, session.access_rules_tag,
request.POST, request.FILES)
if form.is_valid():
new_access_rules_tag = form.cleaned_data["set_access_rules_tag"]
if new_access_rules_tag == NONE_SESSION_TAG:
new_access_rules_tag = None
session.access_rules_tag = new_access_rules_tag
from relate.utils import (local_now, as_local_time,
format_datetime_local)
session.append_comment(
ugettext("Session reopened at %(now)s by %(user)s, "
"previous completion time was '%(completion_time)s': "
"%(comment)s.") % {
"now":
format_datetime_local(local_now()),
"user":
pctx.request.user,
"completion_time":
format_datetime_local(
as_local_time(session.completion_time)),
"comment":
form.cleaned_data["comment"]
})
session.save()
from course.flow import reopen_session
reopen_session(session, suppress_log=True)
return redirect("relate-view_single_grade", pctx.course.identifier,
session.participation.id, opportunity_id)
else:
form = ReopenSessionForm(flow_desc, session.access_rules_tag)
return render(request, "generic-form.html", {
"form": form,
"form_description": _("Reopen session")
})
def serialize(obj):
return {
"id": obj.id,
"visit_time": (
format_datetime_local(as_local_time(obj.visit.visit_time))),
"grade_time": format_datetime_local(as_local_time(obj.grade_time)),
"value": obj.value(),
}
def view_reopen_session(pctx, flow_session_id, opportunity_id):
if pctx.role not in [
participation_role.instructor,
participation_role.teaching_assistant]:
raise PermissionDenied()
request = pctx.request
session = get_object_or_404(FlowSession, id=int(flow_session_id))
from course.content import get_flow_desc
try:
flow_desc = get_flow_desc(pctx.repo, pctx.course, session.flow_id,
pctx.course_commit_sha)
except ObjectDoesNotExist:
raise http.Http404()
if request.method == "POST":
form = ReopenSessionForm(flow_desc, session.access_rules_tag,
request.POST, request.FILES)
if form.is_valid():
new_access_rules_tag = form.cleaned_data["set_access_rules_tag"]
if new_access_rules_tag == NONE_SESSION_TAG:
new_access_rules_tag = None
session.access_rules_tag = new_access_rules_tag
from relate.utils import (
local_now, as_local_time,
format_datetime_local)
session.append_comment(
ugettext("Session reopened at %(now)s by %(user)s, "
"previous completion time was '%(completion_time)s': "
"%(comment)s.") % {
"now": format_datetime_local(local_now()),
"user": pctx.request.user,
"completion_time": format_datetime_local(
as_local_time(session.completion_time)),
"comment": form.cleaned_data["comment"]
})
session.save()
from course.flow import reopen_session
reopen_session(session, suppress_log=True)
return redirect("relate-view_single_grade",
pctx.course.identifier,
session.participation.id,
opportunity_id)
else:
form = ReopenSessionForm(flow_desc, session.access_rules_tag)
return render(request, "generic-form.html", {
"form": form,
"form_description": _("Reopen session")
})
def test_attribute_error1(self):
dtime = datetime.datetime(2019, 1, 1)
with mock.patch(
"django.utils.formats.date_format") as mock_date_format:
mock_date_format.side_effect = date_format_side_effect
result = format_datetime_local(dtime, format="foo")
self.assertEqual(result, date_format(dtime, format="foo"))
def test_attribute_error1(self):
dtime = datetime.datetime(2019, 1, 1)
with mock.patch("django.utils.formats.date_format") as mock_date_format:
mock_date_format.side_effect = date_format_side_effect
result = format_datetime_local(
dtime, format="foo")
self.assertEqual(
result, date_format(dtime, format="foo"))
def test_attribute_error2(self):
dtime = datetime.datetime(2019, 1, 1)
with mock.patch("django.utils.formats.date_format"
) as mock_date_format, mock.patch(
"django.utils.dateformat.format") as mock_format:
mock_date_format.side_effect = date_format_side_effect
mock_format.side_effect = format_side_effectformat
result = format_datetime_local(dtime, format="foo")
self.assertEqual(
result, date_format(dtime, format=get_format("DATETIME_FORMAT")))
def strify_session_for_exception(session):
from relate.utils import as_local_time, format_datetime_local
# Translators: %s is the string of the start time of a session.
result = (_("started at %s") %
format_datetime_local(as_local_time(session.start_time)))
if session.access_rules_tag:
result += " tagged '%s'" % session.access_rules_tag
return result
def strify_session_for_exception(session):
from relate.utils import as_local_time, format_datetime_local
# Translators: %s is the string of the start time of a session.
result = (_("started at %s") % format_datetime_local(
as_local_time(session.start_time)))
if session.access_rules_tag:
result += " tagged '%s'" % session.access_rules_tag
return result
def reopen_session(session, force=False, suppress_log=False):
if session.in_progress:
raise RuntimeError(_("Can't reopen a session that's already in progress"))
if session.participation is None:
raise RuntimeError(_("Can't reopen anonymous sessions"))
session.in_progress = True
session.points = None
session.max_points = None
if not suppress_log:
session.append_comment(
_("Session reopened at %(now)s, previous completion time " "was '%(complete_time)s'.")
% {
"now": format_datetime_local(local_now()),
"complete_time": format_datetime_local(as_local_time(session.completion_time)),
}
)
session.completion_time = None
session.save()
def test_attribute_error2(self):
dtime = datetime.datetime(2019, 1, 1)
with mock.patch(
"django.utils.formats.date_format"
) as mock_date_format, mock.patch(
"django.utils.dateformat.format"
) as mock_format:
mock_date_format.side_effect = date_format_side_effect
mock_format.side_effect = format_side_effectformat
result = format_datetime_local(
dtime, format="foo")
self.assertEqual(
result, date_format(dtime, format=get_format("DATETIME_FORMAT")))
def recalculate_session_grade(repo, course, session):
"""Only redoes the final grade determination without regrading
individual pages.
"""
if session.in_progress:
raise RuntimeError(_("cannot recalculate grade on in-progress session"))
prev_completion_time = session.completion_time
session.append_comment(_("Session grade recomputed at %(time)s.") % {"time": format_datetime_local(local_now())})
session.save()
reopen_session(session, force=True, suppress_log=True)
finish_flow_session_standalone(repo, course, session, force_regrade=False, now_datetime=prev_completion_time)
def regrade_session(repo, course, session):
if session.in_progress:
fctx = FlowContext(repo, course, session.flow_id, flow_session=session)
answer_visits = assemble_answer_visits(session)
for i in range(len(answer_visits)):
answer_visit = answer_visits[i]
if answer_visit is not None and answer_visit.get_most_recent_grade():
# Only make a new grade if there already is one.
grade_page_visit(answer_visit, graded_at_git_commit_sha=fctx.course_commit_sha)
else:
prev_completion_time = session.completion_time
session.append_comment(_("Session regraded at %(time)s.") % {"time": format_datetime_local(local_now())})
session.save()
reopen_session(session, force=True, suppress_log=True)
finish_flow_session_standalone(repo, course, session, force_regrade=True, now_datetime=prev_completion_time)
def test_success(self):
dtime = datetime.datetime(2019, 1, 1)
format_str = "SHORT_DATETIME_FORMAT"
self.assertEqual(format_datetime_local(dtime, format=format_str),
date_format(dtime, format=format_str))
def test_success(self):
dtime = datetime.datetime(2019, 1, 1)
format_str = "SHORT_DATETIME_FORMAT"
self.assertEqual(
format_datetime_local(dtime, format=format_str),
date_format(dtime, format=format_str))
def grade(self, page_context, page_data, answer_data, grade_data):
if answer_data is None:
return AnswerFeedback(correctness=0,
feedback=_("No answer provided."))
user_code = answer_data["answer"]
# {{{ request run
run_req = {"compile_only": False, "user_code": user_code}
def transfer_attr(name):
if hasattr(self.page_desc, name):
run_req[name] = getattr(self.page_desc, name)
transfer_attr("setup_code")
transfer_attr("names_for_user")
transfer_attr("names_from_user")
run_req["test_code"] = self.get_test_code()
if hasattr(self.page_desc, "data_files"):
run_req["data_files"] = {}
from course.content import get_repo_blob
for data_file in self.page_desc.data_files:
from base64 import b64encode
run_req["data_files"][data_file] = \
b64encode(
get_repo_blob(
page_context.repo, data_file,
page_context.commit_sha).data).decode()
try:
response_dict = request_run_with_retries(
run_req,
run_timeout=self.page_desc.timeout,
image=self.container_image)
except Exception:
from traceback import format_exc
response_dict = {
"result": "uncaught_error",
"message": "Error connecting to container",
"traceback": "".join(format_exc()),
}
# }}}
feedback_bits = []
correctness = None
if "points" in response_dict:
correctness = response_dict["points"]
try:
feedback_bits.append("<p><b>%s</b></p>" %
_(get_auto_feedback(correctness)))
except Exception as e:
correctness = None
response_dict["result"] = "setup_error"
response_dict["message"] = ("%s: %s" %
(type(e).__name__, str(e)))
# {{{ send email if the grading code broke
if response_dict["result"] in [
"uncaught_error", "setup_compile_error", "setup_error",
"test_compile_error", "test_error"
]:
error_msg_parts = ["RESULT: %s" % response_dict["result"]]
for key, val in sorted(response_dict.items()):
if (key not in ["result", "figures"] and val
and isinstance(val, str)):
error_msg_parts.append(
"-------------------------------------")
error_msg_parts.append(key)
error_msg_parts.append(
"-------------------------------------")
error_msg_parts.append(val)
error_msg_parts.append("-------------------------------------")
error_msg_parts.append("user code")
error_msg_parts.append("-------------------------------------")
error_msg_parts.append(user_code)
error_msg_parts.append("-------------------------------------")
error_msg = "\n".join(error_msg_parts)
from relate.utils import local_now, format_datetime_local
from course.utils import LanguageOverride
with LanguageOverride(page_context.course):
from relate.utils import render_email_template
message = render_email_template(
"course/broken-code-question-email.txt", {
"site": getattr(settings, "RELATE_BASE_URL"),
"page_id": self.page_desc.id,
"course": page_context.course,
"error_message": error_msg,
"review_uri": page_context.page_uri,
"time": format_datetime_local(local_now())
})
if (not page_context.in_sandbox
and not is_nuisance_failure(response_dict)):
try:
from django.core.mail import EmailMessage
msg = EmailMessage(
"".join([
"[%s:%s] ",
_("code question execution failed")
]) % (page_context.course.identifier,
page_context.flow_session.flow_id
if page_context.flow_session is not None else
_("<unknown flow>")), message,
settings.ROBOT_EMAIL_FROM,
[page_context.course.notify_email])
from relate.utils import get_outbound_mail_connection
msg.connection = get_outbound_mail_connection("robot")
msg.send()
except Exception:
from traceback import format_exc
feedback_bits.append(
str(
string_concat(
"<p>",
_("Both the grading code and the attempt to "
"notify course staff about the issue failed. "
"Please contact the course or site staff and "
"inform them of this issue, mentioning this "
"entire error message:"), "</p>", "<p>",
_("Sending an email to the course staff about the "
"following failure failed with "
"the following error message:"), "<pre>",
"".join(format_exc()), "</pre>",
_("The original failure message follows:"),
"</p>")))
# }}}
if hasattr(self.page_desc, "correct_code"):
def normalize_code(s):
return (s.replace(" ", "").replace("\r", "").replace(
"\n", "").replace("\t", ""))
if (normalize_code(user_code) == normalize_code(
self.page_desc.correct_code)):
feedback_bits.append(
"<p><b>%s</b></p>" %
_("It looks like you submitted code that is identical to "
"the reference solution. This is not allowed."))
from relate.utils import dict_to_struct
response = dict_to_struct(response_dict)
bulk_feedback_bits = []
if response.result == "success":
pass
elif response.result in [
"uncaught_error", "setup_compile_error", "setup_error",
"test_compile_error", "test_error"
]:
feedback_bits.append("".join([
"<p>",
_("The grading code failed. Sorry about that. "
"The staff has been informed, and if this problem is "
"due to an issue with the grading code, "
"it will be fixed as soon as possible. "
"In the meantime, you'll see a traceback "
"below that may help you figure out what went wrong."),
"</p>"
]))
elif response.result == "timeout":
feedback_bits.append("".join([
"<p>",
_("Your code took too long to execute. The problem "
"specifies that your code may take at most %s seconds "
"to run. "
"It took longer than that and was aborted."), "</p>"
]) % self.page_desc.timeout)
correctness = 0
elif response.result == "user_compile_error":
feedback_bits.append("".join([
"<p>",
_("Your code failed to compile. An error message is "
"below."), "</p>"
]))
correctness = 0
elif response.result == "user_error":
feedback_bits.append("".join([
"<p>",
_("Your code failed with an exception. "
"A traceback is below."), "</p>"
]))
correctness = 0
else:
raise RuntimeError("invalid run result: %s" % response.result)
if hasattr(response, "feedback") and response.feedback:
def sanitize(s):
import bleach
return bleach.clean(s, tags=["p", "pre"])
feedback_bits.append("".join([
"<p>",
_("Here is some feedback on your code"), ":"
"<ul>%s</ul></p>"
]) % "".join("<li>%s</li>" % sanitize(fb_item)
for fb_item in response.feedback))
if hasattr(response, "traceback") and response.traceback:
feedback_bits.append("".join([
"<p>",
_("This is the exception traceback"), ":"
"<pre>%s</pre></p>"
]) % escape(response.traceback))
if hasattr(response,
"exec_host") and response.exec_host != "localhost":
import socket
try:
exec_host_name, dummy, dummy = socket.gethostbyaddr(
response.exec_host)
except socket.error:
exec_host_name = response.exec_host
feedback_bits.append("".join(
["<p>",
_("Your code ran on %s.") % exec_host_name, "</p>"]))
if hasattr(response, "stdout") and response.stdout:
bulk_feedback_bits.append("".join([
"<p>",
_("Your code printed the following output"), ":"
"<pre>%s</pre></p>"
]) % escape(response.stdout))
if hasattr(response, "stderr") and response.stderr:
bulk_feedback_bits.append("".join([
"<p>",
_("Your code printed the following error messages"), ":"
"<pre>%s</pre></p>"
]) % escape(response.stderr))
if hasattr(response, "figures") and response.figures:
fig_lines = [
"".join([
"<p>",
_("Your code produced the following plots"), ":</p>"
]),
'<dl class="result-figure-list">',
]
for nr, mime_type, b64data in response.figures:
if mime_type in ["image/jpeg", "image/png"]:
fig_lines.extend([
"".join(["<dt>", _("Figure"), "%d<dt>"]) % nr,
'<dd><img alt="Figure %d" src="data:%s;base64,%s"></dd>'
% (nr, mime_type, b64data)
])
fig_lines.append("</dl>")
bulk_feedback_bits.extend(fig_lines)
# {{{ html output / santization
if hasattr(response, "html") and response.html:
def is_allowed_data_uri(allowed_mimetypes, uri):
import re
m = re.match(r"^data:([-a-z0-9]+/[-a-z0-9]+);base64,", uri)
if not m:
return False
mimetype = m.group(1)
return mimetype in allowed_mimetypes
def sanitize(s):
import bleach
def filter_audio_attributes(tag, name, value):
if name in ["controls"]:
return True
else:
return False
def filter_source_attributes(tag, name, value):
if name in ["type"]:
return True
elif name == "src":
if is_allowed_data_uri([
"audio/wav",
], value):
return bleach.sanitizer.VALUE_SAFE
else:
return False
else:
return False
def filter_img_attributes(tag, name, value):
if name in ["alt", "title"]:
return True
elif name == "src":
return is_allowed_data_uri([
"image/png",
"image/jpeg",
], value)
else:
return False
if not isinstance(s, str):
return _("(Non-string in 'HTML' output filtered out)")
return bleach.clean(s,
tags=bleach.ALLOWED_TAGS +
["audio", "video", "source"],
attributes={
"audio": filter_audio_attributes,
"source": filter_source_attributes,
"img": filter_img_attributes,
})
bulk_feedback_bits.extend(
sanitize(snippet) for snippet in response.html)
# }}}
return AnswerFeedback(correctness=correctness,
feedback="\n".join(feedback_bits),
bulk_feedback="\n".join(bulk_feedback_bits))
def grade(self, page_context, page_data, answer_data, grade_data):
if answer_data is None:
return AnswerFeedback(correctness=0,
feedback=_("No answer provided."))
user_code = answer_data["answer"]
# {{{ request run
run_req = {"compile_only": False, "user_code": user_code}
def transfer_attr(name):
if hasattr(self.page_desc, name):
run_req[name] = getattr(self.page_desc, name)
transfer_attr("setup_code")
transfer_attr("names_for_user")
transfer_attr("names_from_user")
run_req["test_code"] = self.get_test_code()
if hasattr(self.page_desc, "data_files"):
run_req["data_files"] = {}
from course.content import get_repo_blob
for data_file in self.page_desc.data_files:
from base64 import b64encode
run_req["data_files"][data_file] = \
b64encode(
get_repo_blob(
page_context.repo, data_file,
page_context.commit_sha).data).decode()
try:
response_dict = request_python_run_with_retries(run_req,
run_timeout=self.page_desc.timeout)
except Exception:
from traceback import format_exc
response_dict = {
"result": "uncaught_error",
"message": "Error connecting to container",
"traceback": "".join(format_exc()),
}
# }}}
feedback_bits = []
correctness = None
if "points" in response_dict:
correctness = response_dict["points"]
try:
feedback_bits.append(
"<p><b>%s</b></p>"
% _(get_auto_feedback(correctness)))
except Exception as e:
correctness = None
response_dict["result"] = "setup_error"
response_dict["message"] = (
"%s: %s" % (type(e).__name__, str(e))
)
# {{{ send email if the grading code broke
if response_dict["result"] in [
"uncaught_error",
"setup_compile_error",
"setup_error",
"test_compile_error",
"test_error"]:
error_msg_parts = ["RESULT: %s" % response_dict["result"]]
for key, val in sorted(response_dict.items()):
if (key not in ["result", "figures"]
and val
and isinstance(val, six.string_types)):
error_msg_parts.append("-------------------------------------")
error_msg_parts.append(key)
error_msg_parts.append("-------------------------------------")
error_msg_parts.append(val)
error_msg_parts.append("-------------------------------------")
error_msg_parts.append("user code")
error_msg_parts.append("-------------------------------------")
error_msg_parts.append(user_code)
error_msg_parts.append("-------------------------------------")
error_msg = "\n".join(error_msg_parts)
from relate.utils import local_now, format_datetime_local
from course.utils import LanguageOverride
with LanguageOverride(page_context.course):
from relate.utils import render_email_template
message = render_email_template(
"course/broken-code-question-email.txt", {
"site": getattr(settings, "RELATE_BASE_URL"),
"page_id": self.page_desc.id,
"course": page_context.course,
"error_message": error_msg,
"review_uri": page_context.page_uri,
"time": format_datetime_local(local_now())
})
if (
not page_context.in_sandbox
and not is_nuisance_failure(response_dict)):
try:
from django.core.mail import EmailMessage
msg = EmailMessage("".join(["[%s:%s] ",
_("code question execution failed")])
% (
page_context.course.identifier,
page_context.flow_session.flow_id
if page_context.flow_session is not None
else _("<unknown flow>")),
message,
settings.ROBOT_EMAIL_FROM,
[page_context.course.notify_email])
from relate.utils import get_outbound_mail_connection
msg.connection = get_outbound_mail_connection("robot")
msg.send()
except Exception:
from traceback import format_exc
feedback_bits.append(
six.text_type(string_concat(
"<p>",
_(
"Both the grading code and the attempt to "
"notify course staff about the issue failed. "
"Please contact the course or site staff and "
"inform them of this issue, mentioning this "
"entire error message:"),
"</p>",
"<p>",
_(
"Sending an email to the course staff about the "
"following failure failed with "
"the following error message:"),
"<pre>",
"".join(format_exc()),
"</pre>",
_("The original failure message follows:"),
"</p>")))
# }}}
if hasattr(self.page_desc, "correct_code"):
def normalize_code(s):
return (s
.replace(" ", "")
.replace("\r", "")
.replace("\n", "")
.replace("\t", ""))
if (normalize_code(user_code)
== normalize_code(self.page_desc.correct_code)):
feedback_bits.append(
"<p><b>%s</b></p>"
% _("It looks like you submitted code that is identical to "
"the reference solution. This is not allowed."))
from relate.utils import dict_to_struct
response = dict_to_struct(response_dict)
bulk_feedback_bits = []
if response.result == "success":
pass
elif response.result in [
"uncaught_error",
"setup_compile_error",
"setup_error",
"test_compile_error",
"test_error"]:
feedback_bits.append("".join([
"<p>",
_(
"The grading code failed. Sorry about that. "
"The staff has been informed, and if this problem is "
"due to an issue with the grading code, "
"it will be fixed as soon as possible. "
"In the meantime, you'll see a traceback "
"below that may help you figure out what went wrong."
),
"</p>"]))
elif response.result == "timeout":
feedback_bits.append("".join([
"<p>",
_(
"Your code took too long to execute. The problem "
"specifies that your code may take at most %s seconds "
"to run. "
"It took longer than that and was aborted."
),
"</p>"])
% self.page_desc.timeout)
correctness = 0
elif response.result == "user_compile_error":
feedback_bits.append("".join([
"<p>",
_("Your code failed to compile. An error message is "
"below."),
"</p>"]))
correctness = 0
elif response.result == "user_error":
feedback_bits.append("".join([
"<p>",
_("Your code failed with an exception. "
"A traceback is below."),
"</p>"]))
correctness = 0
else:
raise RuntimeError("invalid runpy result: %s" % response.result)
if hasattr(response, "feedback") and response.feedback:
def sanitize(s):
import bleach
return bleach.clean(s, tags=["p", "pre"])
feedback_bits.append("".join([
"<p>",
_("Here is some feedback on your code"),
":"
"<ul>%s</ul></p>"]) %
"".join(
"<li>%s</li>" % sanitize(fb_item)
for fb_item in response.feedback))
if hasattr(response, "traceback") and response.traceback:
feedback_bits.append("".join([
"<p>",
_("This is the exception traceback"),
":"
"<pre>%s</pre></p>"]) % escape(response.traceback))
if hasattr(response, "exec_host") and response.exec_host != "localhost":
import socket
try:
exec_host_name, dummy, dummy = socket.gethostbyaddr(
response.exec_host)
except socket.error:
exec_host_name = response.exec_host
feedback_bits.append("".join([
"<p>",
_("Your code ran on %s.") % exec_host_name,
"</p>"]))
if hasattr(response, "stdout") and response.stdout:
bulk_feedback_bits.append("".join([
"<p>",
_("Your code printed the following output"),
":"
"<pre>%s</pre></p>"])
% escape(response.stdout))
if hasattr(response, "stderr") and response.stderr:
bulk_feedback_bits.append("".join([
"<p>",
_("Your code printed the following error messages"),
":"
"<pre>%s</pre></p>"]) % escape(response.stderr))
if hasattr(response, "figures") and response.figures:
fig_lines = ["".join([
"<p>",
_("Your code produced the following plots"),
":</p>"]),
'<dl class="result-figure-list">',
]
for nr, mime_type, b64data in response.figures:
if mime_type in ["image/jpeg", "image/png"]:
fig_lines.extend([
"".join([
"<dt>",
_("Figure"), "%d<dt>"]) % nr,
'<dd><img alt="Figure %d" src="data:%s;base64,%s"></dd>'
% (nr, mime_type, b64data)])
fig_lines.append("</dl>")
bulk_feedback_bits.extend(fig_lines)
# {{{ html output / santization
if hasattr(response, "html") and response.html:
def is_allowed_data_uri(allowed_mimetypes, uri):
import re
m = re.match(r"^data:([-a-z0-9]+/[-a-z0-9]+);base64,", uri)
if not m:
return False
mimetype = m.group(1)
return mimetype in allowed_mimetypes
def sanitize(s):
import bleach
def filter_audio_attributes(tag, name, value):
if name in ["controls"]:
return True
else:
return False
def filter_source_attributes(tag, name, value):
if name in ["type"]:
return True
elif name == "src":
if is_allowed_data_uri([
"audio/wav",
], value):
return bleach.sanitizer.VALUE_SAFE
else:
return False
else:
return False
def filter_img_attributes(tag, name, value):
if name in ["alt", "title"]:
return True
elif name == "src":
return is_allowed_data_uri([
"image/png",
"image/jpeg",
], value)
else:
return False
if not isinstance(s, six.text_type):
return _("(Non-string in 'HTML' output filtered out)")
return bleach.clean(s,
tags=bleach.ALLOWED_TAGS + ["audio", "video", "source"],
attributes={
"audio": filter_audio_attributes,
"source": filter_source_attributes,
"img": filter_img_attributes,
})
bulk_feedback_bits.extend(
sanitize(snippet) for snippet in response.html)
# }}}
return AnswerFeedback(
correctness=correctness,
feedback="\n".join(feedback_bits),
bulk_feedback="\n".join(bulk_feedback_bits))