clean up getting FunctionParser output on state, add State subclassing

Author: machow

pythonwhat/State.py

@@ -1,6 +1,7 @@
 import ast
 import inspect
 from copy import copy
+from functools import partial
 from pythonwhat.parsing import TargetVars, FunctionParser, ObjectAccessParser, parser_dict
 from pythonwhat.Reporter import Reporter
 from pythonwhat.Feedback import Feedback
@@ -120,7 +121,7 @@ def to_child_state(self, student_subtree, solution_subtree,
                              student_context=None, solution_context=None,
                              student_parts=None, solution_parts=None,
                              highlight = None,
-                             append_message=""):
+                             append_message="", node_name=""):
         """Dive into nested tree.
 
         Set the current state as a state with a subtree of this syntax tree as
@@ -154,7 +155,8 @@ def to_child_state(self, student_subtree, solution_subtree,
                                student_parts = student_parts, solution_parts = solution_parts,
                                highlight = highlight, messages = messages)
 
-        child = State(student_code = utils_ast.extract_text_from_node(self.full_student_code, student_subtree),
+        klass = State if not node_name else self.SUBCLASSES[node_name]
+        child = klass(student_code = utils_ast.extract_text_from_node(self.full_student_code, student_subtree),
                       full_student_code = self.full_student_code,
                       pre_exercise_code = self.pre_exercise_code,
                       student_context = student_context,
@@ -238,8 +240,6 @@ def parse_int(x):
 #   @property
 #   def student_withs(self): ...
 # when defining the State class.
-from functools import partial
-
 def getx(tree_name, Parser, ext_attr, self): 
     """getter for Parser outputs"""
     # return cached output if possible
@@ -249,26 +249,18 @@ def getx(tree_name, Parser, ext_attr, self):
     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)
 
-def get_func_map(tree_name, ext_attr, self):
-    """getter for FunctionParser outputs, uses pre_exercise_mappings"""
-    cache_key = tree_name + FunctionParser.__name__
-    if self._parser_cache.get(cache_key):
-        p = self._parser_cache[cache_key]
-    else:
-        p = FunctionParser()
-        p.mappings = self.pre_exercise_mappings.copy()
-        p.visit(getattr(self, tree_name))
-        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 and get_func_map
+# 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():
@@ -278,17 +270,16 @@ def get_func_map(tree_name, ext_attr, self):
     prop_oa_map = property(partial(getx, tree_name, ObjectAccessParser, 'mappings'))
     setattr(State, s+'_oa_mappings', prop_oa_map)
 
-    # Getters for FunctionParser -----
-    # calls
-    prop_calls = property(partial(get_func_map, tree_name, 'calls'))
-    setattr(State, s+'_function_calls', prop_calls)
-    # mappings
-    prop_map = property(partial(get_func_map, tree_name, 'mappings'))
+    # mappings from FunctionParser
+    prop_map = property(partial(getx, tree_name, FunctionParser, 'mappings'))
     setattr(State, s+'_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)
 
+# 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):

pythonwhat/check_funcs.py

@@ -5,7 +5,7 @@
 from functools import partial
 import copy
 
-def part_to_child(stu_part, sol_part, append_message, state):
+def part_to_child(stu_part, sol_part, append_message, state, node_name=None):
     # stu_part and sol_part will be accessible on all templates
     append_message['kwargs'].update({'stu_part': stu_part, 'sol_part': sol_part})
 
@@ -15,7 +15,7 @@ def part_to_child(stu_part, sol_part, append_message, state):
                                     stu_part.get('target_vars'), sol_part.get('target_vars'),
                                     stu_part, sol_part,
                                     highlight = stu_part.get('highlight'),
-                                    append_message = append_message)
+                                    append_message = append_message, node_name=node_name)
 
     # otherwise, assume they are just nodes
     return state.to_child_state(stu_part, sol_part, append_message = append_message)
@@ -90,7 +90,7 @@ def check_node(name, index, typestr, missing_msg=MSG_MISSING, expand_msg=MSG_PRE
                       'kwargs': fmt_kwargs
                       }
 
-    return part_to_child(stu_part, sol_part, append_message, state)
+    return part_to_child(stu_part, sol_part, append_message, state, node_name=name)
 
 
 # Part tests ------------------------------------------------------------------

pythonwhat/parsing.py

@@ -263,7 +263,7 @@ def __init__(self):
         self.gen_name = ''
         self.raw_name = ''
         self.mappings = {}
-        self.calls = {}
+        self.out = {}
         self.call_lookup_active = False
 
     def visit_BinOp(self, node):
@@ -304,11 +304,11 @@ def visit_Call(self, node):
             self.visit(node.func) # Need to visit func to start recording the current function name.
 
             if self.gen_name:
-                if (self.gen_name not in self.calls):
-                    self.calls[self.gen_name] = []
+                if (self.gen_name not in self.out):
+                    self.out[self.gen_name] = []
 
-                self.calls[self.gen_name].append(self.get_call_part(node))
-                #self.calls[self.current].append((node, node.args, node.keywords))
+                self.out[self.gen_name].append(self.get_call_part(node))
+                #self.out[self.current].append((node, node.args, node.keywords))
 
             self.gen_name = self.raw_name = ""
             self.call_lookup_active = False
@@ -832,5 +832,6 @@ def parse_handler(handler): return {
         "dict_comps": DictCompParser,
         "generator_exps": GeneratorExpParser,
         "withs": WithParser,
-        "try_excepts": TryExceptParser
+        "try_excepts": TryExceptParser,
+        "function_calls": FunctionParser
 }