Merge pull request alexmojaki#69 from alexmojaki/parsons

Parsons problem in the solution

Author: alexmojaki

backend/main/chapters/c04_for_loops.py

@@ -402,6 +402,8 @@ class name_underlined(ExerciseStep):
 The for loop will create a variable such as `char`, but the program doesn't need to use it.
         """
 
+        parsons_solution = True
+
         def solution(self, name: str):
             line = ''
             for _ in name:
@@ -463,6 +465,8 @@ class name_box(ExerciseStep):
             """),
         ]
 
+        parsons_solution = True
+
         def solution(self, name: str):
             line = ''
             for _ in name:
@@ -544,6 +548,8 @@ class name_box_2(ExerciseStep):
 Use one loop to create a bunch of spaces, and a second loop to print a bunch of lines using the previously created spaces.
         """
 
+        parsons_solution = True
+
         def solution(self, name: str):
             line = '+' + name + '+'
             spaces = ''
@@ -615,6 +621,8 @@ class diagonal_name_bonus_challenge(ExerciseStep):
 
         # TODO automatically catch print with multiple args?
 
+        parsons_solution = True
+
         def solution(self, name: str):
             spaces = ''
             for char in name:

backend/main/chapters/c05_if_statements.py

@@ -258,6 +258,8 @@ class print_first_character(ExerciseStep):
 That means `include` should be `False` after the first iteration.
         """
 
+        parsons_solution = True
+
         def solution(self, sentence: str):
             include = True
             new_sentence = ''
@@ -387,6 +389,8 @@ class else_full_stop(ExerciseStep):
 is added to the end of the sentence instead of an exclamation mark (`!`).
         """
 
+        parsons_solution = True
+
         def solution(self, sentence: str, excited: bool):
             if excited:
                 char = '!'
@@ -420,6 +424,8 @@ class capitalise(ExerciseStep):
 In the first iteration you need an uppercase letter. In the following iterations you need a lowercase letter.
         """
 
+        parsons_solution = True
+
         def solution(self, sentence: str):
             upper = True
             new_sentence = ''
@@ -464,6 +470,8 @@ class spongebob(ExerciseStep):
 Combine that flipping `if/else` with the one that chooses an uppercase or lowercase character.
         """
 
+        parsons_solution = True
+
         def solution(self, sentence: str):
             upper = True
             new_sentence = ''
@@ -551,6 +559,8 @@ class if_equals_replacing_characters_exercise(ExerciseStep):
 You just need to add a few lines of code that are very similar to existing ones.
 """
 
+        parsons_solution = True
+
         def solution(self, name: str):
             new_name = ''
             for c in name:
@@ -649,6 +659,8 @@ class dna_example_with_else(ExerciseStep):
             "Now make the same kind of change to the code swapping G and C."
         ]
 
+        parsons_solution = True
+
         def solution(self, dna: str):
             opposite_dna = ''
             for char in dna:
@@ -853,6 +865,8 @@ class min_three_exercise(ExerciseStep):
 All you need is a few uses of `<`, `if`, and maybe `else`.
 """
 
+        parsons_solution = True
+
         def solution(self, x1: str, x2: str, x3: str):
             if x1 < x2:
                 if x1 < x3:

backend/main/chapters/c06_lists.py

@@ -135,6 +135,8 @@ class strings_sum_bonus(ExerciseStep):
 
         # TODO: MessageStep: catch the "obvious solution" where the user adds the separator after the last word?
 
+        parsons_solution = True
+
         def solution(self, words: List[str], separator: str):
             total = ''
             not_first = False
@@ -251,6 +253,8 @@ class filter_numbers(ExerciseStep):
 
         # TODO enforce not using +=
 
+        parsons_solution = True
+
         def solution(self, numbers: List[int]):
             big_numbers = []
             for number in numbers:
@@ -299,6 +303,8 @@ class list_contains_exercise(ExerciseStep):
 There is no reason to ever set the variable to `False` inside the loop.
         """
 
+        parsons_solution = True
+
         def solution(self, things, thing_to_find):
             found = False
             for thing in things:
@@ -646,6 +652,8 @@ class zip_longest_exercise(ExerciseStep):
 
         # TODO catch user writing string1 < string2
 
+        parsons_solution = True
+
         def solution(self, string1, string2):
             length1 = len(string1)
             length2 = len(string2)

backend/main/chapters/c07_nested_loops.py

@@ -119,6 +119,8 @@ class times_table_exercise(ExerciseStep):
 Make sure each line is in the correct loop and has the right amount of indentation.
         """
 
+        parsons_solution = True
+
         def solution(self):
             for left in range(12):
                 left += 1
@@ -577,6 +579,8 @@ class upside_down_triangle_exercise(ExerciseStep):
 What formula converts 0 into 5, 1 into 4, 2, into 3, etc?
 """
 
+        parsons_solution = True
+
         def solution(self, size: int):
             for i in range(size):
                 length = size - i

backend/main/tests.py

@@ -59,17 +59,16 @@ def test_steps(self):
                     is_message = substep in step.messages
                     if is_message:
                         self.assertEqual(response["message"], substep.text, transcript_item)
-                    elif step.hints:
-                        solution_response = api(
-                            "get_solution",
-                            page_index=page_index,
-                            step_index=step_index,
-                        )
-                        get_solution = "".join(solution_response["tokens"])
+                    elif step.get_solution:
+                        get_solution = "".join(step.get_solution["tokens"])
                         assert "def solution(" not in get_solution
                         assert "returns_stdout" not in get_solution
                         assert get_solution.strip() in program
                         transcript_item["get_solution"] = get_solution.splitlines()
+                        if step.parsons_solution:
+                            is_function = transcript_item["get_solution"][0].startswith("def ")
+                            assert len(step.get_solution["lines"]) >= 4 + is_function
+
                     self.assertEqual(
                         response["passed"],
                         not is_message,

backend/main/text.py

@@ -7,11 +7,15 @@
 from copy import deepcopy
 from functools import cached_property
 from importlib import import_module
+from io import StringIO
 from pathlib import Path
+from random import shuffle
 from textwrap import dedent, indent
+from tokenize import Untokenizer, generate_tokens
 from types import FunctionType
-from typing import Type, Union, get_type_hints, List
+from typing import Type, Union, List, get_type_hints
 
+import pygments
 from astcheck import is_ast_like
 from asttokens import ASTTokens
 from littleutils import setattrs, only
@@ -22,8 +26,8 @@
     generate_for_type,
     inputs_string,
 )
-from main.utils import no_weird_whitespace, snake, unwrapped_markdown, returns_stdout, NoMethodWrapper, bind_self, \
-    highlighted_markdown
+from main.utils import highlighted_markdown, lexer, html_formatter, shuffled_well, no_weird_whitespace, snake, \
+    unwrapped_markdown, returns_stdout, NoMethodWrapper, bind_self
 
 
 def clean_program(program, cls):
@@ -139,6 +143,54 @@ class inner_cls(inner_cls, cls):
              messages=messages,
              hints=hints)
 
+    if hints:
+        cls.get_solution = get_solution(cls)
+
+
+def get_solution(step):
+    if issubclass(step, ExerciseStep):
+        if step.solution.__name__ == "solution":
+            program, _ = clean_program(step.solution, None)
+        else:
+            program = clean_solution_function(step.solution, dedent(inspect.getsource(step.solution)))
+    else:
+        program = step.program
+
+    untokenizer = Untokenizer()
+    tokens = generate_tokens(StringIO(program).readline)
+    untokenizer.untokenize(tokens)
+    tokens = untokenizer.tokens
+
+    masked_indices = []
+    mask = [False] * len(tokens)
+    for i, token in enumerate(tokens):
+        if not token.isspace():
+            masked_indices.append(i)
+            mask[i] = True
+    shuffle(masked_indices)
+
+    if step.parsons_solution:
+        lines = shuffled_well([
+            dict(
+                id=str(i),
+                content=line,
+            )
+            for i, line in enumerate(
+                pygments.highlight(program, lexer, html_formatter)
+                    .splitlines()
+            )
+            if line.strip()
+        ])
+    else:
+        lines = None
+
+    return dict(
+        tokens=tokens,
+        maskedIndices=masked_indices,
+        mask=mask,
+        lines=lines,
+    )
+
 
 pages = {}
 page_slugs_list = []
@@ -206,6 +258,7 @@ def step_dicts(self):
                 text=text,
                 name=name,
                 hints=getattr(step, "hints", []),
+                solution=getattr(step, "get_solution", None),
             )
             for name, text, step in
             zip(self.step_names, self.step_texts, self.steps)
@@ -262,6 +315,8 @@ class Step(ABC):
     tests = {}
     expected_code_source = None
     disallowed: List[Disallowed] = []
+    parsons_solution = False
+    get_solution = None
 
     def __init__(self, *args):
         self.args = args

backend/main/utils/__init__.py

@@ -9,6 +9,8 @@
 from functools import lru_cache, partial
 from html import unescape
 from io import StringIO
+from itertools import combinations
+from random import shuffle
 from textwrap import dedent
 
 import pygments
@@ -189,3 +191,26 @@ def highlight_node(node, text):
 
 def highlighted_markdown(text):
     return markdown(text, extensions=[HighlightPythonExtension()])
+
+
+def shuffled(it):
+    result = list(it)
+    shuffle(result)
+    return result
+
+
+def shuffled_well(seq):
+    original = range(len(seq))
+    permutations = {
+        tuple(shuffled(original))
+        for _ in range(10)
+    }
+
+    def inversions(perm):
+        return sum(
+            perm[i] > perm[j]
+            for i, j in combinations(original, 2)
+        )
+
+    permutation = sorted(permutations, key=inversions)[-2]
+    return [seq[i] for i in permutation]

backend/main/views.py

@@ -1,13 +1,8 @@
-import inspect
 import json
 import logging
 import traceback
 from datetime import datetime
-from io import StringIO
 from pathlib import Path
-from random import shuffle
-from textwrap import dedent
-from tokenize import Untokenizer, generate_tokens
 from typing import get_type_hints
 from uuid import uuid4
 
@@ -26,7 +21,7 @@
 from sentry_sdk import capture_exception
 
 from main.models import CodeEntry, ListEmail, User
-from main.text import ExerciseStep, clean_program, page_slugs_list, pages, clean_solution_function
+from main.text import page_slugs_list, pages
 from main.utils import highlighted_markdown
 from main.utils.django import PlaceHolderForm
 from main.workers.master import worker_result
@@ -183,34 +178,10 @@ def set_page(self, index):
         self.user.save()
 
     def get_solution(self, page_index, step_index: int):
+        # TODO deprecated
         page = pages[page_slugs_list[page_index]]
         step = getattr(page, page.step_names[step_index])
-        if issubclass(step, ExerciseStep):
-            if step.solution.__name__ == "solution":
-                program, _ = clean_program(step.solution, None)
-            else:
-                program = clean_solution_function(step.solution, dedent(inspect.getsource(step.solution)))
-        else:
-            program = step.program
-
-        untokenizer = Untokenizer()
-        tokens = generate_tokens(StringIO(program).readline)
-        untokenizer.untokenize(tokens)
-        tokens = untokenizer.tokens
-
-        masked_indices = []
-        mask = [False] * len(tokens)
-        for i, token in enumerate(tokens):
-            if not token.isspace():
-                masked_indices.append(i)
-                mask[i] = True
-        shuffle(masked_indices)
-
-        return dict(
-            tokens=tokens,
-            maskedIndices=masked_indices,
-            mask=mask,
-        )
+        return step.get_solution
 
     def submit_feedback(self, title, description, state):
         """Create an issue on github.com using the given parameters."""