Merge branch 'fix-safe-templating' into spec-messages

Author: machow

pythonwhat/State.py

@@ -1,5 +1,6 @@
 import ast
 import inspect
+import string
 from copy import copy
 from functools import partial
 from pythonwhat.parsing import TargetVars, FunctionParser, ObjectAccessParser, parser_dict
@@ -10,6 +11,7 @@
 from pythonwhat.converters import get_manual_converters
 from collections.abc import Mapping
 from itertools import chain
+from jinja2 import Template
 
 class Context(Mapping):
     def __init__(self, context=None, prev=None):
@@ -32,6 +34,37 @@ def __len__(self):
         return len(self._items)
 
 
+#class MsgFormatter(string.Formatter):
+#    def vformat(self, format_string, args, kwargs):
+#        """Restricted vformat, which does not format entries with converters or format specs"""
+#        used_args = set()
+#        result = []
+#        for chunk in string._string.formatter_parser(format_string):
+#            orig = self._orig_from_chunk(*chunk)
+#            # return original string if there are converters or format specs,
+#            # otherwise, parse as normal
+#            if chunk[1] and any(chunk[2:]):
+#                result.append(orig)
+#            elif chunk[0] and not any(chunk[1:]):
+#                result.append(chunk[0])
+#            else:
+#                res, _ = self._vformat(orig, args, kwargs, used_args, 1)
+#                result.append(res)
+#        return "".join(result)
+#
+#    def get_field(self, field_name, args, kwargs):
+#        try:
+#            return super().get_field(field_name, args, kwargs)
+#        except (KeyError, AttributeError):
+#            return "{"+field_name+"}", "NA"
+#
+#    @staticmethod
+#    def _orig_from_chunk(literal_text, field_name, format_spec, conversion):
+#        # of form, literal_str {var_name!conversion:format_spec}
+#        conversion = '!' + conversion if conversion else ""
+#        format_spec = ":" + format_spec if format_spec else ""
+#        return "%s{%s%s%s}"%(literal_text, field_name, conversion, format_spec)
+
 class State(object):
     """State of the SCT environment.
 
@@ -109,10 +142,17 @@ def build_message(self, tail="", fmt_kwargs=None):
         msgs = self.messages[:] + [{'msg': tail or "", 'kwargs':fmt_kwargs}]
         # format messages in list, by iterating over previous, current, and next message
         for prev_d, d, next_d in zip([{}, *msgs[:-1]], msgs, [*msgs[1:], {}]):
-            out = d['msg'].format(parent = prev_d.get('kwargs'),
-                                  child = next_d.get('kwargs'),
-                                  this = d['kwargs'],
-                                  **d['kwargs'])
+            tmp_kwargs = {'parent': prev_d.get('kwargs'), 
+                          'child': next_d.get('kwargs'), 
+                          'this': d['kwargs'], 
+                          **d['kwargs']}
+            if d['msg'].startswith('FMT:'):
+                out = d['msg'].replace('FMT:', "").format(**tmp_kwargs)
+            elif d['msg'].startswith('__JINJA__:'):
+                out = Template(d['msg'].replace('__JINJA__:', "")).render(**tmp_kwargs)
+            else:
+                out = d['msg']
+
             out_list.append(out)
 
         return "".join(out_list)

pythonwhat/check_funcs.py

@@ -64,8 +64,8 @@ def check_part_index(name, index, part_msg,
     # return child state from part
     return part_to_child(stu_part, sol_part, append_message, state)
 
-MSG_MISSING = "The system wants to check the {typestr} you defined but hasn't found it."
-MSG_PREPEND = "Check your code in the {child[part]} of the {typestr}. "
+MSG_MISSING = "FMT:The system wants to check the {typestr} you defined but hasn't found it."
+MSG_PREPEND = "__JINJA__:Check your code in the {{child['part']+ ' of the' if child['part']}} {{typestr}}. "
 def check_node(name, index, typestr, missing_msg=MSG_MISSING, expand_msg=MSG_PREPEND, state=None):
     rep = Reporter.active_reporter
     stu_out = getattr(state, 'student_'+name)
@@ -226,7 +226,7 @@ def set_context(*args, state=None, **kwargs):
                                 student_context = out_stu, solution_context = out_sol)
 
 
-def check_args(name, missing_msg='check the argument `{part}`, ', state=None):
+def check_args(name, missing_msg='FMT:check the argument `{part}`, ', state=None):
     if name in ['*args', '**kwargs']:
         return check_part(name, name, state=state, missing_msg = missing_msg)
     else: 
@@ -286,8 +286,8 @@ def run_call(args, node, process, get_func, **kwargs):
         return get_func(process = process, tree=func_expr, call = fmt_args, **kwargs)
 
 
-MSG_CALL_INCORRECT = "Calling it should result in {str_sol}, instead got {str_sol}"
-MSG_CALL_ERROR     = "Calling it should result in {str_sol}, instead got an error"
+MSG_CALL_INCORRECT = "FMT:Calling it should result in {str_sol}, instead got {str_sol}"
+MSG_CALL_ERROR     = "FMT:Calling it should result in {str_sol}, instead got an error"
 def call(args, 
          test='value', 
          incorrect_msg=MSG_CALL_INCORRECT, 
@@ -304,11 +304,14 @@ def call(args,
     eval_sol, str_sol = run_call(args, state.solution_parts['node'], state.solution_process, get_func, **kwargs)
 
     if (test == 'error') ^ isinstance(str_sol, Exception):
-        _msg_prefix = "Calling %s for arguments %s " % (argstr, args)
-        raise ValueError(_msg_prefix + call_warnings[test])
+        _msg = state.build_message("FMT:Calling for arguments {args} resulted in an error (or not an error if testing for one).",
+                                   dict(args=args))
+        raise ValueError(_msg)
 
     if isinstance(eval_sol, ReprFail):
-        raise ValueError("Can't get the result of calling %s for arguments %s: %s" % (argstr, args, eval_sol.info))
+        _msg = state.build_message("FMT:Can't get the result of calling it for arguments {args}: {eval_sol.info}",
+                                   dict(args = args, eval_sol=eval_sol))
+        raise ValueError(_msg)
 
     # Run for Submission ------------------------------------------------------
     eval_stu, str_stu = run_call(args, state.student_parts['node'], state.student_process, get_func, **kwargs)
@@ -329,9 +332,9 @@ def call(args,
 # Expression tests ------------------------------------------------------------
 from pythonwhat.tasks import ReprFail, UndefinedValue
 from pythonwhat import utils
-def has_expr(incorrect_msg="Unexpected expression: expected `{sol_eval}`, got `{stu_eval}` with values{extra_env}.",
+def has_expr(incorrect_msg="FMT:Unexpected expression {test}: expected `{sol_eval}`, got `{stu_eval}` with values{extra_env}.",
              error_msg="Running an expression in the student process caused an issue",
-             undefined_msg="Have you defined `{name}` without errors?",
+             undefined_msg="FMT:Have you defined `{name}` without errors?",
              extra_env=None,
              context_vals=None,
              expr_code=None,
@@ -372,7 +375,8 @@ def has_expr(incorrect_msg="Unexpected expression: expected `{sol_eval}`, got `{
                                  context = state.student_context)
 
     # kwargs ---
-    fmt_kwargs = {'stu_part': state.student_parts, 'sol_part': state.solution_parts, 'name': name,
+    fmt_kwargs = {'stu_part': state.student_parts, 'sol_part': state.solution_parts, 
+                  'name': name, 'test': test,
                   'extra_env': " "+str(extra_env or ""), 'context_vals': context_vals}
     fmt_kwargs['stu_eval'] = utils.shorten_str(str(eval_stu))
     fmt_kwargs['sol_eval'] = utils.shorten_str(str(eval_sol))

pythonwhat/check_wrappers.py

@@ -1,7 +1,8 @@
-from pythonwhat.check_funcs import check_part, check_part_index, check_node
+from pythonwhat.check_funcs import check_part, check_part_index, check_node, has_equal_part
 from pythonwhat import check_funcs
 from functools import partial
 import inspect
+#from jinja2 import Template
 
 __PART_WRAPPERS__ = {
         'iter': 'iterable part',
@@ -15,7 +16,7 @@
 __PART_INDEX_WRAPPERS__ = {
         'ifs': '{ordinal} if',
         'handlers': '{index} `except` block',
-        'context': 'context'
+        'context': '{ordinal} context'
         }
 
 __NODE_WRAPPERS__ = {
@@ -34,6 +35,11 @@
 
 scts = {}
 
+# make has_equal_part wrappers
+
+scts['has_equal_name'] = partial(has_equal_part, 'name', msg='Make sure to use the correct {name}, was expecting {sol_part[name]}, instead got {stu_part[name]}.')
+scts['is_default'] = partial(has_equal_part, 'is_default', msg="__JINJA__:Make sure it {{ 'has' if sol_part.is_default else 'does not have'}} a default argument.")
+
 for k, v in __PART_WRAPPERS__.items():
     scts['check_'+k] = partial(check_part, k, v)
 
@@ -51,4 +57,3 @@
           'check_args',
           'has_equal_part']:
     scts[k] = getattr(check_funcs, k)
-

pythonwhat/test_funcs/test_comp.py

@@ -4,12 +4,12 @@
 from pythonwhat.utils import get_ord
 from pythonwhat.check_funcs import check_node, check_part, check_part_index, multi, has_equal_part_len
 
-MSG_NOT_CALLED = "The system wants to check the {ordinal} {typestr} you defined but hasn't found it."
-MSG_PREPEND = "Check your code in the {child[part]} of the {ordinal} {typestr}. "
+MSG_NOT_CALLED = "FMT:The system wants to check the {ordinal} {typestr} you defined but hasn't found it."
+MSG_PREPEND = "FMT:Check your code in the {child[part]} of the {ordinal} {typestr}. "
 
-MSG_INCORRECT_ITER_VARS = "Have you used the correct iterator variables in the {parent[ordinal]} {parent[typestr]}? Make sure you use the correct names!"
-MSG_INCORRECT_NUM_ITER_VARS = "Have you used {num_vars} iterator variables in the {parent[ordinal]} {parent[typestr]}?"
-MSG_INSUFFICIENT_IFS = "Have you used {sol_len} ifs inside the {parent[ordinal]} {parent[typestr]}?"
+MSG_INCORRECT_ITER_VARS = "FMT:Have you used the correct iterator variables in the {parent[ordinal]} {parent[typestr]}? Make sure you use the correct names!"
+MSG_INCORRECT_NUM_ITER_VARS = "FMT:Have you used {num_vars} iterator variables in the {parent[ordinal]} {parent[typestr]}?"
+MSG_INSUFFICIENT_IFS = "FMT:Have you used {sol_len} ifs inside the {parent[ordinal]} {parent[typestr]}?"
 
 def test_list_comp(index=1,
                    not_called_msg=None,

pythonwhat/test_funcs/test_data_frame.py

@@ -5,10 +5,10 @@
 
 import pandas as pd
 
-MSG_UNDEFINED = "Are you sure you defined the pandas DataFrame: `{parent[sol_part][name]}`?"
-MSG_NOT_INSTANCE = "`{parent[sol_part][name]}` is not a pandas DataFrame."
-MSG_KEY_MISSING = "There is no column `{key}` inside `{parent[sol_part][name]}`."
-MSG_INCORRECT_VAL = "Column `{key}` of your pandas DataFrame, `{parent[sol_part][name]}`, is not correct."
+MSG_UNDEFINED = "FMT:Are you sure you defined the pandas DataFrame: `{parent[sol_part][name]}`?"
+MSG_NOT_INSTANCE = "FMT:`{parent[sol_part][name]}` is not a pandas DataFrame."
+MSG_KEY_MISSING = "FMT:There is no column `{key}` inside `{parent[sol_part][name]}`."
+MSG_INCORRECT_VAL = "FMT:Column `{key}` of your pandas DataFrame, `{parent[sol_part][name]}`, is not correct."
 
 def test_data_frame(name,
                     columns=None,

pythonwhat/test_funcs/test_dictionary.py

@@ -4,10 +4,10 @@
 from pythonwhat.tasks import isInstanceInProcess, getKeysInProcess, getValueInProcess, isDefinedCollInProcess, ReprFail
 from .test_object import check_object
 
-MSG_UNDEFINED = "Are you sure you defined the dictionary `{parent[sol_part][name]}`?"
-MSG_NOT_INSTANCE = "`{parent[sol_part][name]}` is not a dictionary."
-MSG_KEY_MISSING = "Have you specified a key `{key}` inside `{parent[sol_part][name]}`?"
-MSG_INCORRECT_VAL = "Have you specified the correct value for the key `{key}` inside `{parent[sol_part][name]}`?"
+MSG_UNDEFINED = "FMT:Are you sure you defined the dictionary `{parent[sol_part][name]}`?"
+MSG_NOT_INSTANCE = "FMT:`{parent[sol_part][name]}` is not a dictionary."
+MSG_KEY_MISSING = "FMT:Have you specified a key `{key}` inside `{parent[sol_part][name]}`?"
+MSG_INCORRECT_VAL = "FMT:Have you specified the correct value for the key `{key}` inside `{parent[sol_part][name]}`?"
 
 def test_dictionary(name,
                     keys=None,

pythonwhat/test_funcs/test_expression_output.py

@@ -66,9 +66,9 @@ def test_expression_output(extra_env=None,
         feedback_msg = incorrect_msg
     else:
         if expr_code is not None:
-            prestring = "When running %s e" % expr_code
+            prestring = "FMT:When running %s e" % expr_code
         else:
-            prestring = "E"
+            prestring = "FMT:E"
         feedback_msg = "%sxpected output `{sol_eval}`, instead got `{stu_eval}`" % (prestring)
         if extra_env:
             # need double brackets to not screw up string formatting

pythonwhat/test_funcs/test_expression_result.py

@@ -80,7 +80,7 @@ def test_expression_result(extra_env=None,
     else:
         # need to double bracket extra_env, so doesn't mess up str templating
         feedback_msg = (
-                "Unexpected expression: expected `{sol_eval}`, got `{stu_eval}` with values{extra_env}."
+                "FMT:Unexpected expression: expected `{sol_eval}`, got `{stu_eval}` with values{extra_env}."
                 )
 
     has_equal_value(feedback_msg,

pythonwhat/test_funcs/test_for_loop.py

@@ -3,8 +3,8 @@
 
 from functools import partial
 
-MSG_MISSING = "Define more {typestr}."
-MSG_PREPEND = "Check your code in the {child[part]} of the {ordinal} for loop. "
+MSG_MISSING = "FMT:Define more {typestr}."
+MSG_PREPEND = "FMT:Check your code in the {child[part]} of the {ordinal} for loop. "
 
 def test_for_loop(index=1,
                   for_iter=None,

pythonwhat/test_funcs/test_function_definition.py

@@ -3,28 +3,28 @@
 
 from functools import partial
 
-MSG_MISSING = "You didn't define the following function: {typestr}."
-MSG_PREPEND = "Check your definition of {typestr}. "
+MSG_MISSING = "FMT:You didn't define the following function: {typestr}."
+MSG_PREPEND = "FMT:Check your definition of {typestr}. "
 
-MSG_NUM_ARGS = "You should define {parent[typestr]} with {sol_len} arguments, instead got {stu_len}."
+MSG_NUM_ARGS = "FMT:You should define {parent[typestr]} with {sol_len} arguments, instead got {stu_len}."
 
-MSG_PREPEND_ARG = "In your definition of {typestr}, " 
-MSG_BAD_ARG_NAME = "the {parent[ordinal]} {parent[part]} should be called `{sol_part[name]}`, instead got `{stu_part[name]}`."
-MSG_BAD_DEFAULT = "the {parent[part]} `{stu_part[name]}` should have no default."
-MSG_INC_DEFAULT = "the {parent[part]} `{stu_part[name]}` does not have the correct default."
+MSG_PREPEND_ARG = "FMT:In your definition of {typestr}, " 
+MSG_BAD_ARG_NAME = "FMT:the {parent[ordinal]} {parent[part]} should be called `{sol_part[name]}`, instead got `{stu_part[name]}`."
+MSG_BAD_DEFAULT = "FMT:the {parent[part]} `{stu_part[name]}` should have no default."
+MSG_INC_DEFAULT = "FMT:the {parent[part]} `{stu_part[name]}` does not have the correct default."
 
-MSG_NO_VARARG = "have you specified an argument to take a `*` argument and named it `{sol_part[*args][name]}`?"
-MSG_NO_KWARGS = "have you specified an argument to take a `**` argument and named it `{sol_part[**kwargs][name]}`?"
-MSG_VARARG_NAME = "have you specified an argument to take a `*` argument and named it `{sol_part[name]}`?"
-MSG_KWARG_NAME = "have you specified an argument to take a `**` argument and named it `{sol_part[name]}`?"
+MSG_NO_VARARG = "FMT:have you specified an argument to take a `*` argument and named it `{sol_part[*args][name]}`?"
+MSG_NO_KWARGS = "FMT:have you specified an argument to take a `**` argument and named it `{sol_part[**kwargs][name]}`?"
+MSG_VARARG_NAME = "FMT:have you specified an argument to take a `*` argument and named it `{sol_part[name]}`?"
+MSG_KWARG_NAME = "FMT:have you specified an argument to take a `**` argument and named it `{sol_part[name]}`?"
 
 # TODO some need to reference the eval rather than str
-MSG_RES_ERROR = "Calling `{argstr}` should result in `{str_sol}`, instead got an error."
-MSG_RES_INCORRECT = "Calling `{argstr}` should result in `{str_sol}`, instead got `{str_stu}`."
-MSG_ERR_NONE = "Calling `{argstr}` doesn't result in an error, but it should!"
-MSG_ERR_INCORRECT = "Calling `{argstr}` should result in a `{str_sol.__class__.__name__}`, instead got a `{str_stu.__class__.__name__}`."
-MSG_OUT_ERROR = "Calling `{argstr}` should output {str_sol}, instead got an error."
-MSG_OUT_INCORRECT = "Calling `{argstr}` should output `{str_sol}`, instead got {str_stu}."
+MSG_RES_ERROR = "FMT:Calling `{argstr}` should result in `{str_sol}`, instead got an error."
+MSG_RES_INCORRECT = "FMT:Calling `{argstr}` should result in `{str_sol}`, instead got `{str_stu}`."
+MSG_ERR_NONE = "FMT:Calling `{argstr}` doesn't result in an error, but it should!"
+MSG_ERR_INCORRECT = "FMT:Calling `{argstr}` should result in a `{str_sol.__class__.__name__}`, instead got a `{str_stu.__class__.__name__}`."
+MSG_OUT_ERROR = "FMT:Calling `{argstr}` should output {str_sol}, instead got an error."
+MSG_OUT_INCORRECT = "FMT:Calling `{argstr}` should output `{str_sol}`, instead got {str_stu}."
 
 def test_function_definition(name,
                              arg_names=True,