OctaveCodeQuestion redux

.github/workflows/ci.yml

@@ -99,6 +99,7 @@ jobs:
           DEBIAN_FRONTEND: noninteractive
         run: |
           sudo apt-get install gettext
+          docker pull davis68/relate-octave
       - name: Run test suite
         env:
           RL_CI_TEST: ${{ matrix.suite }}

.gitignore

@@ -38,3 +38,7 @@ bulk-storage
 /coverage.xml
 /.vscode/
 /.venv/
+
+my-relate-venv
+package-lock.json
+.gitignore

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__ = (
@@ -51,6 +53,7 @@
 
         "ChoiceQuestion", "SurveyChoiceQuestion", "MultipleChoiceQuestion",
         "PythonCodeQuestion", "PythonCodeQuestionWithHumanTextFeedback",
+        "OctaveCodeQuestion",
         "FileUploadQuestion",
         )
 

course/page/code.py

@@ -245,8 +245,10 @@ def debug_print(s):
 
         if container_id is not None:
             docker_cnx.start(container_id)
+            print(docker_cnx)
 
             container_props = docker_cnx.inspect_container(container_id)
+            print(container_props)
             (port_info,) = (container_props
                     ["NetworkSettings"]["Ports"]["%d/tcp" %
                     CODE_QUESTION_CONTAINER_PORT])
@@ -259,6 +261,8 @@ def debug_print(s):
         else:
             port = CODE_QUESTION_CONTAINER_PORT
 
+        #print(container_id,CODE_QUESTION_CONTAINER_PORT)
+
         from time import time, sleep
         start_time = time()
 
@@ -281,8 +285,9 @@ def check_timeout():
         while True:
             try:
                 connection = http_client.HTTPConnection(connect_host_ip, port)
+                print("attempting connection", connect_host_ip, port)
 
-                connection.request("GET", "/ping")
+                connection.request("GET", "/ping")  # XXX here's the trouble
 
                 response = connection.getresponse()
                 response_data = response.read().decode()
@@ -323,7 +328,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()
@@ -349,6 +354,7 @@ def check_timeout():
                     "exec_host": connect_host_ip,
                     }
     finally:
+        print(container_id)
         if container_id is not None:
             debug_print("-----------BEGIN DOCKER LOGS for %s" % container_id)
             debug_print(docker_cnx.logs(container_id))
@@ -484,6 +490,7 @@ class CodeQuestion(PageBaseWithTitle, PageBaseWithValue):
         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
 
@@ -543,7 +550,7 @@ class CodeQuestion(PageBaseWithTitle, PageBaseWithValue):
         answer.  This overrides the image set in the `local_settings.py`
         configuration.  The Docker image should provide two files; these are
         supplied in RELATE's standard Python Docker image by `course/page/
-        code_run_backend_python.py` and `course/page/code_feedback.py`, for
+        code_run_backend_py.py` and `course/page/code_feedback.py`, for
         instance.  Consult `docker-image-run-py/docker-build.sh` for one
         example of a local build.  The Docker image should already be loaded
         on the system (RELATE does not pull the image automatically).
@@ -716,7 +723,14 @@ def get_test_code(self):
         if correct_code is None:
             correct_code = ""
 
-        from .code_run_backend import substitute_correct_code_into_test_code
+        if self.page_desc.type in [
+                "OctaveCodeQuestion"]:
+            from .code_run_backend_octave \
+                import substitute_correct_code_into_test_code
+        else:
+            from .code_run_backend_py \
+                import substitute_correct_code_into_test_code
+
         return substitute_correct_code_into_test_code(test_code, correct_code)
 
     @staticmethod
@@ -1503,4 +1517,201 @@ 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 or higher.
+
+    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`.
+
+    .. 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_RUNOC_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)
+
+# }}}
+
 # vim: foldmethod=marker