Merge pull request #165 from datacamp/spec-expose-check-object

move check_funcs all into test_object, expose to SCT creators

Author: Filip Schouwenaars

pythonwhat/check_object.py

@@ -0,0 +1,82 @@
+from pythonwhat.parsing import ObjectAssignmentParser
+from pythonwhat.Test import DefinedProcessTest, InstanceProcessTest, DefinedCollProcessTest, EqualValueProcessTest
+from pythonwhat.Reporter import Reporter
+from pythonwhat.Feedback import Feedback
+from pythonwhat.tasks import isDefinedInProcess, isInstanceInProcess, getValueInProcess, isDefinedCollInProcess, ReprFail
+from pythonwhat.check_funcs import part_to_child, has_equal_value
+
+
+MSG_PREPEND = "FMT:Check the variable `{index}`. "
+MSG_UNDEFINED = "FMT:Are you sure you defined the {typestr}, `{index}`?"
+MSG_INCORRECT_VAL = """FMT: Have you specified the correct value for "{key}" inside `{parent[sol_part][name]}`?"""
+MSG_KEY_MISSING = "__JINJA__:There is no {{ 'column' if 'DataFrame' in parent.typestr else 'key' }} inside {{parent.index}}."
+
+def check_object(index, missing_msg=MSG_UNDEFINED, expand_msg=MSG_PREPEND, state=None, typestr="variable"):
+    rep = Reporter.active_reporter
+
+    if not isDefinedInProcess(index, state.solution_process):
+        raise NameError("%r not in solution environment " % index)
+
+    append_message = {'msg': expand_msg, 'kwargs': {'index': index, 'typestr': typestr}}
+
+    # 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())
+    
+    # test object exists
+    _msg = state.build_message(missing_msg, append_message['kwargs'])
+    rep.do_test(DefinedProcessTest(index, state.student_process, Feedback(_msg)))
+
+    child = part_to_child(stu_part, sol_part, append_message, state)
+
+    return child
+
+def is_instance(inst, not_instance_msg="FMT:Is it a {inst.__name__}?", name=None, state=None):
+    rep = Reporter.active_reporter
+
+    sol_name = name or state.solution_parts.get('name')
+    stu_name = name or state.student_parts.get('name')
+
+    if not isInstanceInProcess(sol_name, inst, state.solution_process):
+        raise ValueError("%r is not a %s in the solution environment" % (sol_name, type(inst)))
+
+    _msg = state.build_message(not_instance_msg, {'inst': inst})
+    feedback = Feedback(_msg, state.highlight)
+    rep.do_test(InstanceProcessTest(stu_name, inst, state.student_process, feedback))
+
+    return state
+
+def has_key(key, key_missing_msg=MSG_KEY_MISSING, name = None, state=None):
+    rep = Reporter.active_reporter
+
+    sol_name = name or state.solution_parts.get('name')
+    stu_name = name or state.student_parts.get('name')
+
+    if not isDefinedCollInProcess(sol_name, key, state.solution_process):
+        raise NameError("Not all keys you specified are actually keys in %s in the solution process" % sol_name)
+
+    # check if key available
+    _msg = state.build_message(key_missing_msg, {'key': key})
+    rep.do_test(DefinedCollProcessTest(stu_name, key, state.student_process, 
+                                       Feedback(_msg, state.highlight)))
+
+    return state
+
+def has_equal_key(key, incorrect_value_msg=MSG_INCORRECT_VAL, key_missing_msg=MSG_KEY_MISSING, name=None, state=None):
+    rep = Reporter.active_reporter
+
+    sol_name = name or state.solution_parts.get('name')
+    stu_name = name or state.student_parts.get('name')
+
+    has_key(key, key_missing_msg, state=state)
+
+    sol_value, sol_str = getValueInProcess(sol_name, key, state.solution_process)
+    if isinstance(sol_value, ReprFail):
+        raise NameError("Value from %r can't be fetched from the solution process: %s" % c(sol_name, sol_value.info))
+
+    # check if value ok
+    _msg = state.build_message(incorrect_value_msg, {'key': key})
+    rep.do_test(EqualValueProcessTest(stu_name, key, state.student_process, sol_value, Feedback(_msg, state.highlight)))
+
+    return state

pythonwhat/check_wrappers.py

@@ -1,5 +1,8 @@
 from pythonwhat.check_funcs import check_part, check_part_index, check_node, has_equal_part
-from pythonwhat import check_funcs
+from pythonwhat import check_funcs, check_object
+from pythonwhat.test_funcs.test_data_frame import check_df
+from pythonwhat.test_funcs.test_dictionary import check_dict
+from pythonwhat import test_funcs
 from functools import partial
 import inspect
 #from jinja2 import Template
@@ -40,6 +43,7 @@
 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.")
 
+# include rest of wrappers
 for k, v in __PART_WRAPPERS__.items():
     scts['check_'+k] = partial(check_part, k, v)
 
@@ -57,3 +61,12 @@
           'check_args',
           'has_equal_part']:
     scts[k] = getattr(check_funcs, k)
+
+# include check_object and friends ------
+for k in ['check_object', 'is_instance', 'has_equal_key', 'has_key']:
+    scts[k] = getattr(check_object, k)
+
+scts['check_df'] = check_df
+scts['check_dict'] = check_dict
+
+

pythonwhat/test_funcs/test_data_frame.py

@@ -1,15 +1,14 @@
 from pythonwhat.Reporter import Reporter
 from pythonwhat.tasks import getColumnsInProcess
-from .test_object import check_object
-from .test_dictionary import is_instance, test_key, has_key
+from pythonwhat.check_object import check_object, is_instance, has_equal_key, has_key
 
-import pandas as pd
-
-MSG_UNDEFINED = "FMT:Are you sure you defined the pandas DataFrame: `{parent[sol_part][name]}`?"
+MSG_UNDEFINED = "FMT:Are you sure you defined the pandas DataFrame: `{index}`?"
 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."
 
+import pandas as pd
+
 def test_data_frame(name,
                     columns=None,
                     undefined_msg=None,
@@ -23,7 +22,8 @@ def test_data_frame(name,
     rep = Reporter.active_reporter
     rep.set_tag("fun", "test_data_frame")
 
-    child = check_df(name, undefined_msg or MSG_UNDEFINED, not_data_frame_msg or MSG_NOT_INSTANCE, state=state)
+    child = check_object(name, undefined_msg or MSG_UNDEFINED, expand_msg="", state=state, typestr="pandas DataFrame")
+    is_instance(pd.DataFrame, not_data_frame_msg or MSG_NOT_INSTANCE, state=child)  # test instance
 
     sol_cols = getColumnsInProcess(name, child.solution_process)
     if sol_cols is None:
@@ -34,13 +34,14 @@ def test_data_frame(name,
 
     for col in columns:
         # check if column available
-        test_key(name, col, incorrect_msg or MSG_INCORRECT_VAL, undefined_cols_msg or MSG_KEY_MISSING, state=child)
+        has_equal_key(col, incorrect_msg or MSG_INCORRECT_VAL, undefined_cols_msg or MSG_KEY_MISSING, state=child)
 
-# Check functions -------------------------------------------------------------
 
 def check_df(name, undefined_msg=MSG_UNDEFINED, not_instance_msg=MSG_NOT_INSTANCE, state=None):
 
-    child = check_object(name, undefined_msg, state=state)          # test defined
-    is_instance(name, pd.DataFrame, not_instance_msg, state=child)  # test instance
+    # test defined
+    child = check_object(name, undefined_msg, state=state, typestr="pandas DataFrame")
+    is_instance(pd.DataFrame, not_instance_msg, state=child)  # test instance
 
     return child
+

pythonwhat/test_funcs/test_dictionary.py

@@ -1,76 +1,42 @@
 from pythonwhat.Reporter import Reporter
-from pythonwhat.Test import InstanceProcessTest, DefinedCollProcessTest, EqualValueProcessTest
-from pythonwhat.Feedback import Feedback
-from pythonwhat.tasks import isInstanceInProcess, getKeysInProcess, getValueInProcess, isDefinedCollInProcess, ReprFail
-from .test_object import check_object
+from pythonwhat.tasks import getKeysInProcess
+from pythonwhat.check_object import check_object, is_instance, has_equal_key, has_key
 
-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]}`?"
+MSG_UNDEFINED = "FMT:Are you sure you defined the dictionary `{index}`?"
+MSG_NOT_INSTANCE = "FMT:`{parent[index]}` is not a dictionary."
+MSG_KEY_MISSING = "FMT:Have you specified a key `{key}` inside `{parent[index]}`?"
+MSG_INCORRECT_VAL = "FMT:Have you specified the correct value for the key `{key}` inside `{parent[index]}`?"
 
 def test_dictionary(name,
                     keys=None,
-                    undefined_msg=MSG_UNDEFINED,
-                    not_dictionary_msg=MSG_NOT_INSTANCE,
-                    key_missing_msg=MSG_KEY_MISSING,
-                    incorrect_value_msg=MSG_INCORRECT_VAL,
+                    undefined_msg=None,
+                    not_dictionary_msg=None,
+                    key_missing_msg=None,
+                    incorrect_value_msg=None,
                     state=None):
     """Test the contents of a dictionary.
     """
 
     rep = Reporter.active_reporter
     rep.set_tag("fun", "test_dictionary")
 
-    child = check_dict(name, undefined_msg or MSG_UNDEFINED, not_dictionary_msg or MSG_NOT_INSTANCE, state=state)
+    child = check_object(name, undefined_msg or MSG_UNDEFINED, expand_msg = "", state=state, typestr="dictionary")
+    is_instance(dict, not_dictionary_msg or MSG_NOT_INSTANCE, state=child)   # test instance
 
     # set keys or check if manual keys are valid
     if not keys: 
         keys = getKeysInProcess(name, state.solution_process)
 
     for key in keys:
         # check if key in dictionary
-        test_key(name, key, incorrect_value_msg or MSG_INCORRECT_VAL, key_missing_msg or MSG_KEY_MISSING, state=child)
+        has_equal_key(key, incorrect_value_msg or MSG_INCORRECT_VAL, key_missing_msg or MSG_KEY_MISSING, state=child)
 
-# Check functions -------------------------------------------------------------
 
-def check_dict(name, undefined_msg=MSG_UNDEFINED, not_instance_msg=MSG_NOT_INSTANCE, state=None):
+def check_dict(name, undefined_msg=MSG_UNDEFINED, not_instance_msg=MSG_NOT_INSTANCE, expand_msg="", state=None):
 
-    child = check_object(name, undefined_msg, state=state)   # test defined
-    is_instance(name, dict, not_instance_msg, state=child)   # test instance
+    # test defined
+    child = check_object(name, undefined_msg, state=state, typestr="dictionary")
+    is_instance(dict, not_instance_msg, state=child)   # test instance
 
     return child
 
-def is_instance(name, inst, not_instance_msg, state=None):
-    rep = Reporter.active_reporter
-
-    if not isInstanceInProcess(name, inst, state.solution_process):
-        raise ValueError("%r is not a %s in the solution environment" % (name, type(inst)))
-
-    _msg = state.build_message(not_instance_msg)
-    feedback = Feedback(_msg, state.highlight)
-    rep.do_test(InstanceProcessTest(name, inst, state.student_process, feedback))
-
-def has_key(name, key, key_missing_msg, state=None):
-    rep = Reporter.active_reporter
-
-    if not isDefinedCollInProcess(name, key, state.solution_process):
-        raise NameError("Not all keys you specified are actually keys in %s in the solution process" % name)
-
-    # check if key available
-    _msg = state.build_message(key_missing_msg, {'key': key})
-    rep.do_test(DefinedCollProcessTest(name, key, state.student_process, 
-                                       Feedback(_msg, state.highlight)))
-
-def test_key(name, key, incorrect_value_msg, key_missing_msg, state=None):
-    rep = Reporter.active_reporter
-
-    has_key(name, key, key_missing_msg, state=state)
-
-    sol_value, sol_str = getValueInProcess(name, key, state.solution_process)
-    if isinstance(sol_value, ReprFail):
-        raise NameError("Value from %r can't be fetched from the solution process: %s" % c(name, sol_value.info))
-
-    # check if value ok
-    _msg = state.build_message(incorrect_value_msg, {'key': key})
-    rep.do_test(EqualValueProcessTest(name, key, state.student_process, sol_value, Feedback(_msg, state.highlight)))

pythonwhat/test_funcs/test_object.py

@@ -1,13 +1,9 @@
-import ast
-from pythonwhat.parsing import ObjectAssignmentParser
-from pythonwhat.Test import DefinedProcessTest, EqualProcessTest
 from pythonwhat.Reporter import Reporter
-from pythonwhat.Feedback import Feedback
-from pythonwhat.tasks import isDefinedInProcess, getRepresentation
 from pythonwhat.check_funcs import part_to_child, has_equal_value
+from pythonwhat.check_object import check_object, MSG_UNDEFINED
 
-MSG_UNDEFINED = "FMT:Have you defined `{parent[sol_part][name]}`?"
-MSG_INCORRECT = "FMT:The contents of `{parent[sol_part][name]}` aren't correct."
+MSG_UNDEFINED = "FMT:Have you defined `{index}`?"
+MSG_INCORRECT = "FMT:The contents of `{parent[index]}` aren't correct."
 
 def test_object(name,
                 eq_condition="equal",
@@ -57,36 +53,8 @@ def test_object(name,
     rep = Reporter.active_reporter
     rep.set_tag("fun", "test_object")
 
-    child = check_object(name, undefined_msg or MSG_UNDEFINED, state=state)
+    child = check_object(name, undefined_msg or MSG_UNDEFINED, expand_msg = "", state=state)
 
     if do_eval:
 
         has_equal_value(incorrect_msg or MSG_INCORRECT, state=child)
-
-def get_assignment_node(obj_ass, name):
-    nodes = obj_ass[name] if name in obj_ass else None
-    
-    # found a single case of assigning name
-    if nodes and len(nodes) == 1: 
-        return nodes[0]
-
-# Check functions -------------------------------------------------------------
-
-def check_object(name, undefined_msg=MSG_UNDEFINED, state=None):
-    rep = Reporter.active_reporter
-
-    if not isDefinedInProcess(name, state.solution_process):
-        raise NameError("%r not in solution environment " % name)
-
-    # create child state, using either parser output, or create part from name
-    fallback = lambda: ObjectAssignmentParser.get_part(name)
-    stu_part = state.student_object_assignments.get(name, fallback())
-    sol_part = state.solution_object_assignments.get(name, fallback())
-    
-    child = part_to_child(stu_part, sol_part, {'msg': '', 'kwargs': {}}, state)
-
-    # test object exists
-    _msg = child.build_message(undefined_msg)
-    rep.do_test(DefinedProcessTest(name, child.student_process, Feedback(_msg)))
-
-    return child

pythonwhat/test_funcs/test_object_after_expression.py

@@ -1,5 +1,4 @@
 from pythonwhat.check_funcs import has_equal_value, check_part
-from .test_object import get_assignment_node
 
 def test_object_after_expression(name,
                                  extra_env=None,

tests/test_test_data_frame.py

@@ -30,6 +30,14 @@ def test_Pass1(self):
         sct_payload = helper.run(self.data)
         self.assertTrue(sct_payload['correct'])
 
+    def test_Pass1_spec2(self):
+        self.data["DC_SCT"] = "Ex().check_df('df').has_equal_value()"
+        self.test_Pass1()
+
+    def test_Pass1_spec2_manual(self):
+        self.data["DC_SCT"] = "Ex().check_df('df').multi([has_equal_key(i) for i in ['a', 'b', 'c']])"
+        self.test_Pass1()
+
     def test_Pass2(self):
         self.data["DC_SCT"] = "test_data_frame('df', columns=['b','c'])"
         self.data["DC_CODE"] = '''
@@ -79,6 +87,30 @@ def test_Fail1(self):
         self.assertFalse(sct_payload['correct'])
         self.assertEqual(sct_payload['message'], 'Column <code>a</code> of your pandas DataFrame, <code>df</code>, is not correct.')
 
+    def test_Fail1_spec2_manual(self):
+        self.data["DC_CODE"] = '''
+df = pd.DataFrame({
+    'a': [1, 2, 2],
+    'b': ['x', 'y', 'z'],
+    'c': [True, False, True]
+})
+        '''
+        self.data["DC_SCT"] = "Ex().check_df('df').has_equal_key('a')"
+        sct_payload = helper.run(self.data)
+        self.assertFalse(sct_payload['correct'])
+
+    def test_Fail1_spec2_auto(self):
+        self.data["DC_CODE"] = '''
+df = pd.DataFrame({
+    'a': [1, 2, 2],
+    'b': ['x', 'y', 'z'],
+    'c': [True, False, True]
+})
+        '''
+        self.data["DC_SCT"] = "Ex().check_df('df').has_equal_value()"
+        sct_payload = helper.run(self.data)
+        self.assertFalse(sct_payload['correct'])
+
     def test_Fail2(self):
         self.data["DC_CODE"] = '''
 df = pd.DataFrame({