Handle parsing in dispatcher

- similar to protowhat
- easier to find parsing in code by searching for ast_dispatcher

Author: hermansje

pythonwhat/State.py

@@ -2,7 +2,7 @@
 import inspect
 import string
 from copy import copy
-from functools import partial
+from functools import partialmethod
 from pythonwhat.parsing import (
     TargetVars,
     FunctionParser,
@@ -89,6 +89,8 @@ def __init__(
         if not hasattr(self, "pre_exercise_tree"):
             _, self.pre_exercise_tree = self.parse(self.pre_exercise_code, test=False)
 
+        self.ast_dispatcher = Dispatcher(self.pre_exercise_tree)
+
         if not hasattr(self, "parent_state"):
             self.parent_state = None
 
@@ -286,12 +288,10 @@ def assert_is_not(self, klasses, fun, prev_fun):
                 % (fun, " or ".join(["`%s()`" % pf for pf in prev_fun]))
             )
 
-    def parse_external(self, x):
+    def parse_external(self, code):
         res = (None, None)
         try:
-            res = asttokens.ASTTokens(x, parse=True)
-            return (res, res.tree)
-
+            return Dispatcher.parse(code)
         except IndentationError as e:
             e.filename = "script.py"
             # no line info for now
@@ -326,10 +326,9 @@ def parse_external(self, x):
         return res
 
     @staticmethod
-    def parse_internal(x):
+    def parse_internal(code):
         try:
-            res = asttokens.ASTTokens(x, parse=True)
-            return (res, res._tree)
+            return Dispatcher.parse(code)
         except Exception as e:
             raise InstructorError(
                 "Something went wrong when parsing PEC or solution code: %s" % str(e)
@@ -344,55 +343,61 @@ def parse(self, text, test=True):
         return parse_method(text)
 
 
-# add property methods for retrieving parser outputs --------------------------
-# note that this code is an alternative means of using something like..
-#   @property
-#   def student_withs(self): ...
-# when defining the State class.
-def getx(tree_name, Parser, ext_attr, self):
-    """getter for Parser outputs"""
-    # return cached output if possible
-    cache_key = tree_name + Parser.__name__
-    if self._parser_cache.get(cache_key):
-        p = self._parser_cache[cache_key]
-    else:
-        # otherwise, run parser over tree
-        p = Parser()
-        # set mappings for parsers that inspect attribute access
-        if ext_attr != "mappings" and Parser in [FunctionParser, ObjectAccessParser]:
-            p.mappings = self.pre_exercise_mappings.copy()
-        # run parser
-        p.visit(getattr(self, tree_name))
-        # cache
-        self._parser_cache[cache_key] = p
-    return getattr(p, ext_attr)
-
-
-# put a property getter on state for each parsed ast tree output.
-# since the getter takes only one argument, self, partial functions
-# are used to set all other arguments on getx
-for s in ["student", "solution"]:
-    tree_name = s + "_tree"
-    for k, Parser in parser_dict.items():
-        setattr(State, s + "_" + k, property(partial(getx, tree_name, Parser, "out")))
-
-    # mappings from ObjectAccessParser
-    prop_oa_map = property(partial(getx, tree_name, ObjectAccessParser, "mappings"))
-    setattr(State, s + "_oa_mappings", prop_oa_map)
-
-    # mappings from FunctionParser
-    prop_map = property(partial(getx, tree_name, FunctionParser, "mappings"))
-    setattr(State, s + "_mappings", prop_map)
+class Dispatcher:
+    def __init__(self, pre_exercise_tree):
+        self._parser_cache = dict()
+        self.pre_exercise_mappings = self._getx(FunctionParser, "mappings", pre_exercise_tree)
+
+    def __call__(self, name, node):
+        return getattr(self, name)(node)
+
+    @staticmethod
+    def parse(code):
+        res = asttokens.ASTTokens(code, parse=True)
+        return res, res.tree
+
+    # add methods for retrieving parser outputs --------------------------
+    def _getx(self, Parser, ext_attr, tree):
+        """getter for Parser outputs"""
+        # return cached output if possible
+        cache_key = Parser.__name__ + str(hash(tree))
+        if self._parser_cache.get(cache_key):
+            p = self._parser_cache[cache_key]
+        else:
+            # otherwise, run parser over tree
+            p = Parser()
+            # set mappings for parsers that inspect attribute access
+            if ext_attr != "mappings" and Parser in [FunctionParser, ObjectAccessParser]:
+                p.mappings = self.pre_exercise_mappings.copy()
+            # run parser
+            p.visit(tree)
+            # cache
+            self._parser_cache[cache_key] = p
+        return getattr(p, ext_attr)
+
+
+# put a function on the dispatcher
+for k, Parser in parser_dict.items():
+    setattr(Dispatcher, k, partialmethod(Dispatcher._getx, Parser, "out"))
+
+# mappings from ObjectAccessParser
+prop_oa_map = partialmethod(Dispatcher._getx, ObjectAccessParser, "mappings")
+setattr(Dispatcher, "oa_mappings", prop_oa_map)
+
+# mappings from FunctionParser
+prop_map = partialmethod(Dispatcher._getx, FunctionParser, "mappings")
+setattr(Dispatcher, "mappings", prop_map)
 
 # mappings for pre exercise code from FunctionParser
-pec_prop_map = property(partial(getx, "pre_exercise_tree", FunctionParser, "mappings"))
-setattr(State, "pre_exercise_mappings", pec_prop_map)
+pec_prop_map = partialmethod(Dispatcher._getx, FunctionParser, "mappings")
+setattr(Dispatcher, "pre_exercise_mappings", pec_prop_map)
 
 # State subclasses based on parsed output -------------------------------------
 State.SUBCLASSES = {
     node_name: type(node_name, (State,), {}) for node_name in parser_dict
 }
 
+
 # global setters on State -----------------------------------------------------
 def set_converter(key, fundef):
     # note that root state is set on the State class in test_exercise

pythonwhat/checks/check_funcs.py

@@ -123,8 +123,8 @@ def check_node(
     if expand_msg is None:
         expand_msg = "Check the {{typestr}}. "
 
-    stu_out = getattr(state, "student_" + name)
-    sol_out = getattr(state, "solution_" + name)
+    stu_out = state.ast_dispatcher(name, state.student_tree)
+    sol_out = state.ast_dispatcher(name, state.solution_tree)
 
     # check if there are enough nodes for index
     fmt_kwargs = {

pythonwhat/checks/check_function.py

@@ -99,10 +99,10 @@ def check_function(
     if params_not_matched_msg is None:
         params_not_matched_msg = SIG_ISSUE_MSG
 
-    stu_out = state.student_function_calls
-    sol_out = state.solution_function_calls
+    stu_out = state.ast_dispatcher("function_calls", state.student_tree)
+    sol_out = state.ast_dispatcher("function_calls", state.solution_tree)
 
-    student_mappings = state.student_mappings
+    student_mappings = state.ast_dispatcher("mappings", state.student_tree)
 
     fmt_kwargs = {
         "times": get_times(index + 1),

pythonwhat/checks/check_object.py

@@ -182,8 +182,8 @@ def __init__(self, n):
 
     # create child state, using either parser output, or create part from name
     fallback = lambda: ObjectAssignmentParser.get_part(index)
-    stu_part = state.student_object_assignments.get(index, fallback())
-    sol_part = state.solution_object_assignments.get(index, fallback())
+    stu_part = state.ast_dispatcher("object_assignments", state.student_tree).get(index, fallback())
+    sol_part = state.ast_dispatcher("object_assignments", state.solution_tree).get(index, fallback())
 
     # test object exists
     _msg = state.build_message(missing_msg, append_message["kwargs"])

pythonwhat/checks/has_funcs.py

@@ -511,8 +511,8 @@ def has_import(
             import matplotlib.pyplot as pltttt
 
     """
-    student_imports = state.student_imports
-    solution_imports = state.solution_imports
+    student_imports = state.ast_dispatcher("imports", state.student_tree)
+    solution_imports = state.ast_dispatcher("imports", state.solution_tree)
 
     if name not in solution_imports:
         raise InstructorError(
@@ -660,7 +660,7 @@ def has_printout(
         )
 
     try:
-        sol_call_ast = state.solution_function_calls["print"][index]["node"]
+        sol_call_ast = state.ast_dispatcher("function_calls", state.solution_tree)["print"][index]["node"]
     except (KeyError, IndexError):
         raise InstructorError(
             "`has_printout({})` couldn't find the {} print call in your solution.".format(

pythonwhat/test_funcs/test_compound_statement.py

@@ -439,7 +439,7 @@ def test_object_after_expression(
     pre_code=None,
     **kwargs
 ):
-    state.highlight = state.student_object_assignments.get(name, {}).get("highlight")
+    state.highlight = state.ast_dispatcher("object_assignments", state.student_tree).get(name, {}).get("highlight")
     has_equal_value(
         state,
         incorrect_msg=incorrect_msg,

pythonwhat/test_funcs/test_object_accessed.py

@@ -34,8 +34,8 @@ def test_object_accessed(state, name, times=1, not_accessed_msg=None):
         | ``test_object_accessed("arr.shape")``: pass.
         | ``test_object_accessed("arr.dtype")``: fail.
     """
-    student_object_accesses = state.student_object_accesses
-    student_mappings = state.student_oa_mappings
+    student_object_accesses = state.ast_dispatcher("object_accesses", state.student_tree)
+    student_mappings = state.ast_dispatcher("oa_mappings", state.student_tree)
 
     if not not_accessed_msg:
         stud_name = name

tests/test_check_function.py

@@ -86,7 +86,7 @@ def test_bind_args():
 
     pec = "def my_fun(a, b, *args, **kwargs): pass"
     s = setup_state(pec=pec, stu_code="my_fun(1, 2, 3, 4, c = 5)")
-    args = s._state.student_function_calls["my_fun"][0]["args"]
+    args = s._state.ast_dispatcher("function_calls", s._state.student_tree)["my_fun"][0]["args"]
     sig = signature(s._state.student_process.shell.user_ns["my_fun"])
     binded_args = bind_args(sig, args)
     assert binded_args["a"]["node"].n == 1