Merge pull request #389 from datacamp/jh/lazychain

[CX-1182] Feat: lazychain

Author: hermansje

pythonwhat/State.py

@@ -1,17 +1,22 @@
+import asttokens
+
 from functools import partialmethod
+from collections.abc import Mapping
+
+from protowhat.failure import debugger
+from protowhat.Feedback import FeedbackComponent
+from protowhat.selectors import DispatcherInterface
+from protowhat.State import State as ProtoState
+from protowhat.utils import parameters_attr
+from pythonwhat import signatures
+from pythonwhat.converters import get_manual_converters
+from pythonwhat.feedback import Feedback
 from pythonwhat.parsing import (
     TargetVars,
     FunctionParser,
     ObjectAccessParser,
     parser_dict,
 )
-from protowhat.State import State as ProtoState
-from protowhat.selectors import DispatcherInterface
-from protowhat.Feedback import InstructorError
-from pythonwhat import signatures
-from pythonwhat.converters import get_manual_converters
-from collections.abc import Mapping
-import asttokens
 from pythonwhat.utils_ast import wrap_in_module
 
 
@@ -35,6 +40,7 @@ def __len__(self):
         return len(self._items)
 
 
+@parameters_attr
 class State(ProtoState):
     """State of the SCT environment.
 
@@ -48,6 +54,8 @@ class State(ProtoState):
 
     """
 
+    feedback_cls = Feedback
+
     def __init__(
         self,
         student_code,
@@ -60,8 +68,9 @@ def __init__(
         reporter,
         force_diagnose=False,
         highlight=None,
+        highlight_offset=None,
         highlighting_disabled=None,
-        messages=None,
+        feedback_context=None,
         creator=None,
         student_ast=None,
         solution_ast=None,
@@ -75,23 +84,21 @@ def __init__(
         solution_env=Context(),
     ):
         args = locals().copy()
-        self.params = list()
+        self.debug = False
 
         for k, v in args.items():
             if k != "self":
-                self.params.append(k)
                 setattr(self, k, v)
 
-        self.messages = messages if messages else []
-
         self.ast_dispatcher = self.get_dispatcher()
 
         # Parse solution and student code
         # if possible, not done yet and wanted (ast arguments not False)
         if isinstance(self.student_code, str) and student_ast is None:
             self.student_ast = self.parse(student_code)
         if isinstance(self.solution_code, str) and solution_ast is None:
-            self.solution_ast = self.parse(solution_code, test=False)
+            with debugger(self):
+                self.solution_ast = self.parse(solution_code)
 
         if highlight is None:  # todo: check parent_state? (move check to reporting?)
             self.highlight = self.student_ast
@@ -106,26 +113,29 @@ def get_manual_sigs(self):
 
         return self.manual_sigs
 
-    def to_child(self, append_message="", node_name="", **kwargs):
+    def to_child(self, append_message=None, node_name="", **kwargs):
         """Dive into nested tree.
 
         Set the current state as a state with a subtree of this syntax tree as
         student tree and solution tree. This is necessary when testing if statements or
         for loops for example.
         """
-        bad_pars = set(kwargs) - set(self.params)
-        if bad_pars:
-            raise ValueError("Invalid init params for State: %s" % ", ".join(bad_pars))
+        bad_parameters = set(kwargs) - set(self.parameters)
+        if bad_parameters:
+            raise ValueError(
+                "Invalid init parameters for State: %s" % ", ".join(bad_parameters)
+            )
 
         base_kwargs = {
             attr: getattr(self, attr)
-            for attr in self.params
-            if attr not in ["highlight"]
+            for attr in self.parameters
+            if hasattr(self, attr) and attr not in ["ast_dispatcher", "highlight"]
         }
 
-        if not isinstance(append_message, dict):
-            append_message = {"msg": append_message, "kwargs": {}}
-        kwargs["messages"] = [*self.messages, append_message]
+        if append_message and not isinstance(append_message, FeedbackComponent):
+            append_message = FeedbackComponent(append_message)
+        kwargs["feedback_context"] = append_message
+        kwargs["creator"] = {"type": "to_child", "args": {"state": self}}
 
         def update_kwarg(name, func):
             kwargs[name] = func(kwargs[name])
@@ -162,11 +172,11 @@ def update_context(name):
         init_kwargs = {**base_kwargs, **kwargs}
         child = klass(**init_kwargs)
 
-        extra_attrs = set(vars(self)) - set(self.params)
+        extra_attrs = set(vars(self)) - set(self.parameters)
         for attr in extra_attrs:
             # don't copy attrs set on new instances in init
             # the cached manual_sigs is passed
-            if attr not in {"params", "ast_dispatcher", "converters"}:
+            if attr not in {"ast_dispatcher", "converters"}:
                 setattr(child, attr, getattr(self, attr))
 
         return child
@@ -183,27 +193,30 @@ def has_different_processes(self):
 
     def assert_execution_root(self, fun, extra_msg=""):
         if not (self.is_root or self.is_creator_type("run")):
-            raise InstructorError(
-                "`%s()` should only be called focusing on a full script, following `Ex()` or `run()`. %s"
-                % (fun, extra_msg)
-            )
+            with debugger(self):
+                self.report(
+                    "`%s()` should only be called focusing on a full script, following `Ex()` or `run()`. %s"
+                    % (fun, extra_msg)
+                )
 
     def is_creator_type(self, type):
         return self.creator and self.creator.get("type") == type
 
     def assert_is(self, klasses, fun, prev_fun):
         if self.__class__.__name__ not in klasses:
-            raise InstructorError(
-                "`%s()` can only be called on %s."
-                % (fun, " or ".join(["`%s()`" % pf for pf in prev_fun]))
-            )
+            with debugger(self):
+                self.report(
+                    "`%s()` can only be called on %s."
+                    % (fun, " or ".join(["`%s()`" % pf for pf in prev_fun]))
+                )
 
     def assert_is_not(self, klasses, fun, prev_fun):
         if self.__class__.__name__ in klasses:
-            raise InstructorError(
-                "`%s()` should not be called on %s."
-                % (fun, " or ".join(["`%s()`" % pf for pf in prev_fun]))
-            )
+            with debugger(self):
+                self.report(
+                    "`%s()` should not be called on %s."
+                    % (fun, " or ".join(["`%s()`" % pf for pf in prev_fun]))
+                )
 
     def parse_external(self, code):
         res = (None, None)
@@ -235,17 +248,17 @@ def parse_internal(self, code):
         try:
             return self.ast_dispatcher.parse(code)
         except Exception as e:
-            raise InstructorError(
+            self.report(
                 "Something went wrong when parsing the solution code: %s" % str(e)
             )
 
-    def parse(self, text, test=True):
-        if test:
-            parse_method = self.parse_external
-            token_attr = "student_ast_tokens"
-        else:
+    def parse(self, text):
+        if self.debug:
             parse_method = self.parse_internal
             token_attr = "solution_ast_tokens"
+        else:
+            parse_method = self.parse_external
+            token_attr = "student_ast_tokens"
 
         tokens, ast = parse_method(text)
         setattr(self, token_attr, tokens)
@@ -256,9 +269,8 @@ def get_dispatcher(self):
         try:
             return Dispatcher(self.pre_exercise_code)
         except Exception as e:
-            raise InstructorError(
-                "Something went wrong when parsing the PEC: %s" % str(e)
-            )
+            with debugger(self):
+                self.report("Something went wrong when parsing the PEC: %s" % str(e))
 
 
 class Dispatcher(DispatcherInterface):

pythonwhat/checks/check_funcs.py

@@ -1,8 +1,9 @@
+from protowhat.Feedback import FeedbackComponent
 from pythonwhat.checks.check_logic import multi
 from pythonwhat.checks.has_funcs import has_part
-from protowhat.Feedback import InstructorError
+from protowhat.failure import debugger
 from pythonwhat.tasks import setUpNewEnvInProcess, breakDownNewEnvInProcess
-from pythonwhat.utils import get_ord
+from protowhat.utils_messaging import get_ord
 from pythonwhat.utils_ast import assert_ast
 import ast
 from jinja2 import Template
@@ -14,7 +15,7 @@ def render(template, kwargs):
 
 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})
+    append_message.kwargs.update({"stu_part": stu_part, "sol_part": sol_part})
 
     # if the parts are dictionaries, use to deck out child state
     if all(isinstance(p, dict) for p in [stu_part, sol_part]):
@@ -51,14 +52,14 @@ def check_part(state, name, part_msg, missing_msg=None, expand_msg=None):
 
     if not part_msg:
         part_msg = name
-    append_message = {"msg": expand_msg, "kwargs": {"part": part_msg}}
+    append_message = FeedbackComponent(expand_msg, {"part": part_msg})
 
-    has_part(state, name, missing_msg, append_message["kwargs"])
+    has_part(state, name, missing_msg, append_message.kwargs)
 
     stu_part = state.student_parts[name]
     sol_part = state.solution_parts[name]
 
-    assert_ast(state, sol_part, append_message["kwargs"])
+    assert_ast(state, sol_part, append_message.kwargs)
 
     return part_to_child(stu_part, sol_part, append_message, state)
 
@@ -83,7 +84,7 @@ def check_part_index(state, name, index, part_msg, missing_msg=None, expand_msg=
     fmt_kwargs = {"index": index, "ordinal": ordinal}
     fmt_kwargs.update(part=render(part_msg, fmt_kwargs))
 
-    append_message = {"msg": expand_msg, "kwargs": fmt_kwargs}
+    append_message = FeedbackComponent(expand_msg, fmt_kwargs)
 
     # check there are enough parts for index
     has_part(state, name, missing_msg, fmt_kwargs, index)
@@ -130,14 +131,13 @@ def check_node(
     try:
         stu_out[index]
     except (KeyError, IndexError):  # TODO comment errors
-        _msg = state.build_message(missing_msg, fmt_kwargs)
-        state.report(_msg)
+        state.report(missing_msg, fmt_kwargs)
 
     # get node at index
     stu_part = stu_out[index]
     sol_part = sol_out[index]
 
-    append_message = {"msg": expand_msg, "kwargs": fmt_kwargs}
+    append_message = FeedbackComponent(expand_msg, fmt_kwargs)
 
     return part_to_child(stu_part, sol_part, append_message, state, node_name=name)
 
@@ -151,9 +151,10 @@ def with_context(state, *args, child=None):
         process=state.solution_process, context=state.solution_parts["with_items"]
     )
     if isinstance(solution_res, Exception):
-        raise InstructorError(
-            "error in the solution, running test_with(): %s" % str(solution_res)
-        )
+        with debugger(state):
+            state.report(
+                "error in the solution, running test_with(): %s" % str(solution_res)
+            )
 
     student_res = setUpNewEnvInProcess(
         process=state.student_process, context=state.student_parts["with_items"]
@@ -178,10 +179,11 @@ def with_context(state, *args, child=None):
             process=state.solution_process
         )
         if isinstance(close_solution_context, Exception):
-            raise InstructorError(
-                "error in the solution, closing the `with` fails with: %s"
-                % close_solution_context
-            )
+            with debugger(state):
+                state.report(
+                    "error in the solution, closing the `with` fails with: %s"
+                    % close_solution_context
+                )
 
         close_student_context = breakDownNewEnvInProcess(process=state.student_process)
         if isinstance(close_student_context, Exception):
@@ -205,7 +207,7 @@ def check_args(state, name, missing_msg=None):
     Args:
         name (str): the name of the argument for which you want to check if it is specified. This can also be
             a number, in which case it refers to the positional arguments. Named arguments take precedence.
-        missing_msg (str): If specified, this overrides an automatically generated feedback message in case
+        missing_msg (str): If specified, this overrides the automatically generated feedback message in case
             the student did specify the argument.
         state (State): State object that is passed from the SCT Chain (don't specify this).
 
@@ -321,7 +323,7 @@ def my_power(x):
     stu_part, _argstr = build_call(callstr, state.student_parts["node"])
     sol_part, _ = build_call(callstr, state.solution_parts["node"])
 
-    append_message = {"msg": expand_msg, "kwargs": {"argstr": argstr or _argstr}}
+    append_message = FeedbackComponent(expand_msg, {"argstr": argstr or _argstr})
     child = part_to_child(stu_part, sol_part, append_message, state)
 
     return child