OctaveCodeQuestion implementation

bin/relate

@@ -52,7 +52,8 @@ def expand_yaml(yml_file, repo_root):
 def test_code_question(page_desc, repo_root):
  if page_desc.type not in [
  "PythonCodeQuestion",
- "PythonCodeQuestionWithHumanTextFeedback"]:
+ "PythonCodeQuestionWithHumanTextFeedback",
+ "OctaveCodeQuestion"]:
  return
 
  print(75*"-")
@@ -64,11 +65,24 @@ def test_code_question(page_desc, repo_root):
 
  correct_code = getattr(page_desc, "correct_code", "")
 
- from course.page.code_run_backend import \
- substitute_correct_code_into_test_code
+ if page_desc.type in [
+ "PythonCodeQuestion",
+ "PythonCodeQuestionWithHumanTextFeedback" ]:
+ from course.page.code_run_backend_python import \
+ substitute_correct_code_into_test_code
+ elif page_desc.type in [ 
+ "OctaveCodeQuestion" ]:
+ from course.page.code_run_backend_octave import \
+ substitute_correct_code_into_test_code
  test_code = substitute_correct_code_into_test_code(test_code, correct_code)
 
- from course.page.code_run_backend import run_code, package_exception
+ if page_desc.type in [
+ "PythonCodeQuestion",
+ "PythonCodeQuestionWithHumanTextFeedback" ]:
+ from course.page.code_run_backend_python import run_code, package_exception
+ elif page_desc.type in [
+ "OctaveCodeQuestion" ]:
+ from course.page.code_run_backend_octave import run_code, package_exception
 
  data_files = {}
 

course/page/__init__.py

@@ -37,6 +37,8 @@
  ChoiceQuestion, MultipleChoiceQuestion, SurveyChoiceQuestion)
 from course.page.code import (
  PythonCodeQuestion, PythonCodeQuestionWithHumanTextFeedback)
+from course.page.code import (
+ OctaveCodeQuestion)
 from course.page.upload import FileUploadQuestion
 
 __all__ = (

course/page/code.py

@@ -110,8 +110,8 @@ def debug_print(s):
  command_path = '/opt/runcode/runcode'
  user = 'runcode'
 
- # The following is necessary because tests don't arise from a CodeQuestion
- # object, so we provide a fallback.
+ # The following is necessary because some tests don't arise from a
+ # CodeQuestion object, so we provide a fallback.
  debug_print('Image is %s.' % repr(image))
  if image is None:
  image = settings.RELATE_DOCKER_RUNPY_IMAGE
@@ -230,7 +230,7 @@ def check_timeout():
  start_time = time()
 
  debug_print("BEFPOST")
- connection.request('POST', '/run-python', json_run_req, headers)
+ connection.request('POST', '/run-code', json_run_req, headers)
  debug_print("AFTPOST")
 
  http_response = connection.getresponse()
@@ -577,6 +577,8 @@ def answer_data(self, page_context, page_data, form, files_data):
  return {"answer": form.cleaned_data["answer"].strip()}
 
  def get_test_code(self):
+ # Note to developers: this function should be replaced in daughter
+ # classes as it defaults to Python. It is required by grade() though.
  test_code = getattr(self.page_desc, "test_code", None)
  if test_code is None:
  return test_code
@@ -585,7 +587,7 @@ def get_test_code(self):
  if correct_code is None:
  correct_code = ""
 
- from .code_run_backend import substitute_correct_code_into_test_code
+ from .code_run_backend_python import substitute_correct_code_into_test_code
  return substitute_correct_code_into_test_code(test_code, correct_code)
 
  def grade(self, page_context, page_data, answer_data, grade_data):
@@ -1167,6 +1169,18 @@ def __init__(self, vctx, location, page_desc, language_mode='python'):
  super(PythonCodeQuestion, self).__init__(vctx, location, page_desc,
  language_mode)
 
+ def get_test_code(self):
+ test_code = getattr(self.page_desc, "test_code", None)
+ if test_code is None:
+ return test_code
+
+ correct_code = getattr(self.page_desc, "correct_code", None)
+ if correct_code is None:
+ correct_code = ""
+
+ from .code_run_backend_python import substitute_correct_code_into_test_code
+ return substitute_correct_code_into_test_code(test_code, correct_code)
+
 # }}}
 
 
@@ -1372,4 +1386,214 @@ def grade(self, page_context, page_data, answer_data, grade_data):
 
 # }}}
 
+
+# {{{ octave code question
+
+class OctaveCodeQuestion(CodeQuestion):
+ """
+ An auto-graded question allowing an answer consisting of Octave code.
+ All user code as well as all code specified as part of the problem
+ is in Octave 4.2+.
+
+ If you are not including the
+ :attr:`course.constants.flow_permission.change_answer`
+ permission for your entire flow, you likely want to
+ include this snippet in your question definition:
+
+ .. code-block:: yaml
+
+ access_rules:
+ add_permissions:
+ - change_answer
+
+ This will allow participants multiple attempts at getting
+ the right answer.
+
+ .. attribute:: id
+
+ |id-page-attr|
+
+ .. attribute:: type
+
+ ``OctaveCodeQuestion``
+
+ .. attribute:: is_optional_page
+
+ |is-optional-page-attr|
+
+ .. attribute:: access_rules
+
+ |access-rules-page-attr|
+
+ .. attribute:: title
+
+ |title-page-attr|
+
+ .. attribute:: value
+
+ |value-page-attr|
+
+ .. attribute:: prompt
+
+ The page's prompt, written in :ref:`markup`.
+
+ .. attribute:: timeout
+
+ A number, giving the number of seconds for which setup code,
+ the given answer code, and the test code (combined) will be
+ allowed to run.
+
+ .. attribute:: setup_code
+
+ Optional.
+ Octave code to prepare the environment for the participants
+ answer.
+
+ .. attribute:: show_setup_code
+
+ Optional. ``True`` or ``False``. If true, the :attr:`setup_code`
+ will be shown to the participant.
+
+ .. attribute:: names_for_user
+
+ Optional.
+ Symbols defined at the end of the :attr:`setup_code` that will be
+ made available to the participant's code.
+
+ A deep copy (using the standard library function :func:`copy.deepcopy`)
+ of these values is made, to prevent the user from modifying trusted
+ state of the grading code.
+
+ .. attribute:: names_from_user
+
+ Optional.
+ Symbols that the participant's code is expected to define.
+ These will be made available to the :attr:`test_code`.
+ Some remapping of types will be made between Octave and Python classes.
+
+ .. attribute:: test_code
+
+ Optional.
+ Code that will be run to determine the correctness of a
+ student-provided solution. Will have access to variables in
+ :attr:`names_from_user` (which will be *None*) if not provided. Should
+ never raise an exception.
+
+ This may contain the marker "###CORRECT_CODE###", which will
+ be replaced with the contents of :attr:`correct_code`, with
+ each line indented to the same depth as where the marker
+ is found. The line with this marker is only allowed to have
+ white space and the marker on it.
+
+ .. attribute:: show_test_code
+
+ Optional. ``True`` or ``False``. If true, the :attr:`test_code`
+ will be shown to the participant.
+
+ .. attribute:: correct_code_explanation
+
+ Optional.
+ Code that is revealed when answers are visible
+ (see :ref:`flow-permissions`). This is shown before
+ :attr:`correct_code` as an explanation.
+
+ .. attribute:: correct_code
+
+ Optional.
+ Code that is revealed when answers are visible
+ (see :ref:`flow-permissions`).
+
+ .. attribute:: initial_code
+
+ Optional.
+ Code present in the code input field when the participant first starts
+ working on their solution.
+
+ .. attribute:: data_files
+
+ Optional.
+ A list of file names in the :ref:`git-repo` whose contents will be made
+ available to :attr:`setup_code` and :attr:`test_code` through the
+ ``data_files`` dictionary. (see below)
+
+ .. attribute:: single_submission
+
+ Optional, a Boolean. If the question does not allow multiple submissions
+ based on its :attr:`access_rules` (not the ones of the flow), a warning
+ is shown. Setting this attribute to True will silence the warning.
+
+ The following symbols are available in :attr:`setup_code` and :attr:`test_code`:
+
+ * ``GradingComplete``: An exception class that can be raised to indicated
+ that the grading code has concluded.
+
+ * ``feedback``: A class instance with the following interface::
+
+ feedback.set_points(0.5) # 0<=points<=1 (usually)
+ feedback.add_feedback("This was wrong")
+
+ # combines the above two and raises GradingComplete
+ feedback.finish(0, "This was wrong")
+
+ feedback.check_numpy_array_sanity(name, num_axes, data)
+
+ feedback.check_numpy_array_features(name, ref, data, report_failure=True)
+
+ feedback.check_numpy_array_allclose(name, ref, data,
+ accuracy_critical=True, rtol=1e-5, atol=1e-8,
+ report_success=True, report_failure=True)
+ # If report_failure is True, this function will only return
+ # if *data* passes the tests. It will return *True* in this
+ # case.
+ #
+ # If report_failure is False, this function will always return,
+ # and the return value will indicate whether *data* passed the
+ # accuracy/shape/kind checks.
+
+ feedback.check_list(name, ref, data, entry_type=None)
+
+ feedback.check_scalar(name, ref, data, accuracy_critical=True,
+ rtol=1e-5, atol=1e-8, report_success=True, report_failure=True)
+ # returns True if accurate
+
+ feedback.call_user(f, *args, **kwargs)
+ # Calls a user-supplied function and prints an appropriate
+ # feedback message in case of failure.
+
+ * ``data_files``: A dictionary mapping file names from :attr:`data_files`
+ to :class:`bytes` instances with that file's contents.
+
+ * ``user_code``: The user code being tested, as a string.
+ """
+
+ @property
+ def language_mode(self):
+ return 'octave'
+
+ @property
+ def container_image(self):
+ return settings.RELATE_DOCKER_RUNOCTAVE_IMAGE
+
+ @property
+ def suffix(self):
+ return '.m'
+
+ def __init__(self, vctx, location, page_desc, language_mode='octave'):
+ super(OctaveCodeQuestion, self).__init__(vctx, location,
+ page_desc, language_mode)
+
+ def get_test_code(self):
+ test_code = getattr(self.page_desc, "test_code", None)
+ if test_code is None:
+ return test_code
+
+ correct_code = getattr(self.page_desc, "correct_code", None)
+ if correct_code is None:
+ correct_code = ""
+
+ from .code_run_backend_octave import substitute_correct_code_into_test_code
+ return substitute_correct_code_into_test_code(test_code, correct_code)
+
+# }}}
+
 # vim: foldmethod=marker