Merge branch 'main' into refactor-tests

app.py

@@ -1023,7 +1023,9 @@ def programs_page(user):
                 program['adventure_name'] not in adventure_names:
             ids_to_fetch.append(program['adventure_name'])
 
-    all_programs = [program for program in all_programs if program.get('is_modified')]
+    # When saving a program, 'is_modified' is set to True or False
+    # But for older programs, 'is_modified' doesn't exist yet, therefore the check
+    all_programs = [program for program in all_programs if program.get('is_modified') or 'is_modified' not in program]
 
     teacher_adventures = DATABASE.batch_get_adventures(ids_to_fetch)
     for id, teacher_adventure in teacher_adventures.items():
@@ -2703,7 +2705,6 @@ def public_user_page(username):
         if user_achievements.get('achieved'):
             last_achieved = user_achievements['achieved'][-1]
         certificate_message = safe_format(gettext('see_certificate'), username=username)
-        print(user_programs)
         # Todo: TB -> In the near future: add achievement for user visiting their own profile
         next_page_url = url_for(
             'public_user_page',

hedy_translation.py

@@ -199,161 +199,194 @@ def __init__(self, input_string):
         self.rules = []
 
     def define(self, tree):
-        self.add_rule("_DEFINE", "define", tree)
+        self.add_rule_for_grammar_token("_DEFINE", "define", tree)
 
     def defs(self, tree):
-        self.add_rule("_DEF", "def", tree)
+        self.add_rule_for_grammar_token("_DEF", "def", tree)
 
     def call(self, tree):
-        self.add_rule("_CALL", "call", tree)
+        self.add_rule_for_grammar_token("_CALL", "call", tree)
 
     def withs(self, tree):
-        self.add_rule("_WITH", "with", tree)
+        self.add_rule_for_grammar_token("_WITH", "with", tree)
 
     def returns(self, tree):
-        self.add_rule("_RETURN", "return", tree)
+        self.add_rule_for_grammar_token("_RETURN", "return", tree)
 
     def print(self, tree):
-        self.add_rule("_PRINT", "print", tree)
+        self.add_rule_for_grammar_token("_PRINT", "print", tree)
 
     def print_empty_brackets(self, tree):
         self.print(tree)
 
     def ask(self, tree):
-        self.add_rule("_IS", "is", tree)
-        self.add_rule("_ASK", "ask", tree)
+        self.add_rule_for_grammar_token("_IS", "is", tree)
+        self.add_rule_for_grammar_token("_ASK", "ask", tree)
 
     def echo(self, tree):
-        self.add_rule("_ECHO", "echo", tree)
+        self.add_rule_for_grammar_token("_ECHO", "echo", tree)
 
     def color(self, tree):
-        self.add_rule("_COLOR", "color", tree)
+        self.add_rule_for_grammar_token("_COLOR", "color", tree)
 
     def forward(self, tree):
-        self.add_rule("_FORWARD", "forward", tree)
+        self.add_rule_for_grammar_token("_FORWARD", "forward", tree)
 
     def turn(self, tree):
-        self.add_rule("_TURN", "turn", tree)
+        self.add_rule_for_grammar_token("_TURN", "turn", tree)
 
     def left(self, tree):
-        # somehow for some Arabic rules (left, right, random) the parser returns separate tokens instead of one!
-        token_start = tree.children[0]
-        token_end = tree.children[-1]
-        value = ''.join(tree.children)
-        rule = Rule("left", token_start.line, token_start.column - 1, token_end.end_column - 2, value)
-        self.rules.append(rule)
+        self.add_rule_for_grammar_rule("left", tree)
 
     def right(self, tree):
-        token_start = tree.children[0]
-        token_end = tree.children[-1]
-        value = ''.join(tree.children)
-        rule = Rule("right", token_start.line, token_start.column - 1, token_end.end_column - 2, value)
-        self.rules.append(rule)
+        self.add_rule_for_grammar_rule("right", tree)
+
+    def black(self, tree):
+        self.add_rule_for_grammar_rule("black", tree)
+
+    def blue(self, tree):
+        self.add_rule_for_grammar_rule("blue", tree)
+
+    def brown(self, tree):
+        self.add_rule_for_grammar_rule("brown", tree)
+
+    def gray(self, tree):
+        self.add_rule_for_grammar_rule("gray", tree)
+
+    def green(self, tree):
+        self.add_rule_for_grammar_rule("green", tree)
+
+    def orange(self, tree):
+        self.add_rule_for_grammar_rule("orange", tree)
+
+    def pink(self, tree):
+        self.add_rule_for_grammar_rule("pink", tree)
+
+    def yellow(self, tree):
+        self.add_rule_for_grammar_rule("yellow", tree)
+
+    def purple(self, tree):
+        self.add_rule_for_grammar_rule("purple", tree)
+
+    def white(self, tree):
+        self.add_rule_for_grammar_rule("white", tree)
+
+    def red(self, tree):
+        self.add_rule_for_grammar_rule("red", tree)
+
+    def clear(self, tree):
+        self.add_rule_for_grammar_rule("clear", tree)
 
     def assign_list(self, tree):
-        self.add_rule("_IS", "is", tree)
+        self.add_rule_for_grammar_token("_IS", "is", tree)
         commas = self.get_keyword_tokens("_COMMA", tree)
         for comma in commas:
             rule = Rule("comma", comma.line, comma.column - 1, comma.end_column - 2, comma.value)
             self.rules.append(rule)
 
     def assign(self, tree):
-        self.add_rule("_IS", "is", tree)
+        self.add_rule_for_grammar_token("_IS", "is", tree)
 
     def sleep(self, tree):
-        self.add_rule("_SLEEP", "sleep", tree)
+        self.add_rule_for_grammar_token("_SLEEP", "sleep", tree)
 
     def add(self, tree):
-        self.add_rule("_ADD_LIST", "add", tree)
-        self.add_rule("_TO_LIST", "to_list", tree)
+        self.add_rule_for_grammar_token("_ADD_LIST", "add", tree)
+        self.add_rule_for_grammar_token("_TO_LIST", "to_list", tree)
 
     def remove(self, tree):
-        self.add_rule("_REMOVE", "remove", tree)
-        self.add_rule("_FROM", "from", tree)
+        self.add_rule_for_grammar_token("_REMOVE", "remove", tree)
+        self.add_rule_for_grammar_token("_FROM", "from", tree)
 
     def random(self, tree):
-        # somehow for Arabic tokens, we parse into separate tokens instead of one!
-        token_start = tree.children[0]
-        token_end = tree.children[-1]
-        value = ''.join(tree.children)
-        rule = Rule("random", token_start.line, token_start.column - 1, token_end.end_column - 2, value)
-        self.rules.append(rule)
+        self.add_rule_for_grammar_rule("random", tree)
 
     def error_ask_dep_2(self, tree):
-        self.add_rule("_ASK", "ask", tree)
+        self.add_rule_for_grammar_token("_ASK", "ask", tree)
 
     def error_echo_dep_2(self, tree):
-        self.add_rule("_ECHO", "echo", tree)
+        self.add_rule_for_grammar_token("_ECHO", "echo", tree)
 
     def ifs(self, tree):
-        self.add_rule("_IF", "if", tree)
+        self.add_rule_for_grammar_token("_IF", "if", tree)
 
     def ifelse(self, tree):
-        self.add_rule("_IF", "if", tree)
-        self.add_rule("_ELSE", "else", tree)
+        self.add_rule_for_grammar_token("_IF", "if", tree)
+        self.add_rule_for_grammar_token("_ELSE", "else", tree)
 
     def elifs(self, tree):
-        self.add_rule("_ELIF", "elif", tree)
+        self.add_rule_for_grammar_token("_ELIF", "elif", tree)
 
     def elses(self, tree):
-        self.add_rule("_ELSE", "else", tree)
+        self.add_rule_for_grammar_token("_ELSE", "else", tree)
 
     def condition_spaces(self, tree):
-        self.add_rule("_IS", "is", tree)
+        self.add_rule_for_grammar_token("_IS", "is", tree)
 
     def equality_check_is(self, tree):
         self.equality_check(tree)
 
     def equality_check(self, tree):
-        self.add_rule("_IS", "is", tree)
-        self.add_rule("_EQUALS", "=", tree)
-        self.add_rule("_DOUBLE_EQUALS", "==", tree)
+        self.add_rule_for_grammar_token("_IS", "is", tree)
+        self.add_rule_for_grammar_token("_EQUALS", "=", tree)
+        self.add_rule_for_grammar_token("_DOUBLE_EQUALS", "==", tree)
 
     def in_list_check(self, tree):
-        self.add_rule("_IN", "in", tree)
+        self.add_rule_for_grammar_token("_IN", "in", tree)
 
     def list_access(self, tree):
-        self.add_rule("_AT", "at", tree)
+        self.add_rule_for_grammar_token("_AT", "at", tree)
 
     def list_access_var(self, tree):
-        self.add_rule("_IS", "is", tree)
-        self.add_rule("_AT", "at", tree)
+        self.add_rule_for_grammar_token("_IS", "is", tree)
+        self.add_rule_for_grammar_token("_AT", "at", tree)
 
     def repeat(self, tree):
-        self.add_rule("_REPEAT", "repeat", tree)
-        self.add_rule("_TIMES", "times", tree)
+        self.add_rule_for_grammar_token("_REPEAT", "repeat", tree)
+        self.add_rule_for_grammar_token("_TIMES", "times", tree)
 
     def for_list(self, tree):
-        self.add_rule("_FOR", "for", tree)
-        self.add_rule("_IN", "in", tree)
+        self.add_rule_for_grammar_token("_FOR", "for", tree)
+        self.add_rule_for_grammar_token("_IN", "in", tree)
 
     def for_loop(self, tree):
-        self.add_rule("_FOR", "for", tree)
-        self.add_rule("_IN", "in", tree)
-        self.add_rule("_RANGE", "range", tree)
-        self.add_rule("_TO", "to", tree)
+        self.add_rule_for_grammar_token("_FOR", "for", tree)
+        self.add_rule_for_grammar_token("_IN", "in", tree)
+        self.add_rule_for_grammar_token("_RANGE", "range", tree)
+        self.add_rule_for_grammar_token("_TO", "to", tree)
 
     def while_loop(self, tree):
-        self.add_rule("_WHILE", "while", tree)
+        self.add_rule_for_grammar_token("_WHILE", "while", tree)
 
     def and_condition(self, tree):
-        self.add_rule("_AND", "and", tree)
+        self.add_rule_for_grammar_token("_AND", "and", tree)
 
     def or_condition(self, tree):
-        self.add_rule("_OR", "or", tree)
+        self.add_rule_for_grammar_token("_OR", "or", tree)
 
     def input(self, tree):
-        self.add_rule("_IS", "is", tree)
-        self.add_rule("_INPUT", "input", tree)
+        self.add_rule_for_grammar_token("_IS", "is", tree)
+        self.add_rule_for_grammar_token("_INPUT", "input", tree)
 
     def input_empty_brackets(self, tree):
-        self.add_rule("_IS", "is", tree)
-        self.add_rule("_INPUT", "input", tree)
+        self.add_rule_for_grammar_token("_IS", "is", tree)
+        self.add_rule_for_grammar_token("_INPUT", "input", tree)
 
     def pressed(self, tree):
-        self.add_rule("_PRESSED", "pressed", tree)
+        self.add_rule_for_grammar_token("_PRESSED", "pressed", tree)
+
+    def add_rule_for_grammar_rule(self, rule_name, tree):
+        """Creates a translation rule for a rule defined in the lark grammar which
+        could have multiple children tokens, e.g. left, random, red"""
+        # somehow for some Arabic rules (left, right, random) the parser returns separate tokens instead of one!
+        token_start = tree.children[0]
+        token_end = tree.children[-1]
+        value = ''.join(tree.children)
+        rule = Rule(rule_name, token_start.line, token_start.column - 1, token_end.end_column - 2, value)
+        self.rules.append(rule)
 
-    def add_rule(self, token_name, token_keyword, tree):
+    def add_rule_for_grammar_token(self, token_name, token_keyword, tree):
+        """Creates a translation rule for a token defined in the lark grammar, e.g. _DEFINE, _FOR, _TURN"""
         token = self.get_keyword_token(token_name, tree)
         if token:
             rule = Rule(

requirements.txt

@@ -3,7 +3,7 @@ Werkzeug==3.0.3
 lark==1.1.1
 gunicorn==22.0.0
 flask-compress==1.4.0
-requests==2.31.0
+requests==2.32.0
 attrs>=22.2.0
 bcrypt==3.2.0
 boto3>=1.16.50