def check_keys(state, key, missing_msg=None, expand_msg=None):
"""Check whether an object (dict, DataFrame, etc) has a key.
``check_keys()`` can currently only be used when chained from ``check_object()``, the function that is
used to 'zoom in' on the object of interest.
Args:
key (str): Name of the key that the object should have.
missing_msg (str): When specified, this overrides the automatically generated
message in case the key does not exist.
expand_msg (str): If specified, this overrides any messages that are prepended by previous SCT chains.
state (State): The state that is passed in through the SCT chain (don't specify this).
:Example:
Student code and solution code::
x = {'a': 2}
SCT::
# Verify that x contains a key a
Ex().check_object('x').check_keys('a')
# Verify that x contains a key a and a is correct.
Ex().check_object('x').check_keys('a').has_equal_value()
"""
state.assert_is(["object_assignments"], "is_instance",
["check_object", "check_df"])
if missing_msg is None:
missing_msg = "There is no {{ 'column' if 'DataFrame' in parent.typestr else 'key' }} `'{{key}}'`."
if expand_msg is None:
expand_msg = "Did you correctly set the {{ 'column' if 'DataFrame' in parent.typestr else 'key' }} `'{{key}}'`? "
sol_name = state.solution_parts.get("name")
stu_name = state.student_parts.get("name")
if not isDefinedCollInProcess(sol_name, key, state.solution_process):
raise InstructorError(
"`check_keys()` couldn't find key `%s` in object `%s` in the solution process."
% (key, sol_name))
# check if key available
_msg = state.build_message(missing_msg, {"key": key})
state.do_test(
DefinedCollProcessTest(stu_name, key, state.student_process,
Feedback(_msg, state)))
def get_part(name, key, highlight):
if isinstance(key, str):
slice_val = ast.Str(s=key)
else:
slice_val = ast.parse(str(key)).body[0].value
expr = ast.Subscript(
value=ast.Name(id=name, ctx=ast.Load()),
slice=ast.Index(value=slice_val),
ctx=ast.Load(),
)
ast.fix_missing_locations(expr)
return {"node": expr, "highlight": highlight}
stu_part = get_part(stu_name, key, state.student_parts.get("highlight"))
sol_part = get_part(sol_name, key, state.solution_parts.get("highlight"))
append_message = {"msg": expand_msg, "kwargs": {"key": key}}
child = part_to_child(stu_part, sol_part, append_message, state)
return child
def check_function(
state,
name,
index=0,
missing_msg=None,
params_not_matched_msg=None,
expand_msg=None,
signature=True,
):
"""Check whether a particular function is called.
``check_function()`` is typically followed by:
- ``check_args()`` to check whether the arguments were specified.
In turn, ``check_args()`` can be followed by ``has_equal_value()`` or ``has_equal_ast()``
to assert that the arguments were correctly specified.
- ``has_equal_value()`` to check whether rerunning the function call coded by the student
gives the same result as calling the function call as in the solution.
Checking function calls is a tricky topic. Please visit the
`dedicated article <articles/checking_function_calls.html>`_ for more explanation,
edge cases and best practices.
Args:
name (str): the name of the function to be tested. When checking functions in packages, always
use the 'full path' of the function.
index (int): index of the function call to be checked. Defaults to 0.
missing_msg (str): If specified, this overrides an automatically generated feedback message in case
the student did not call the function correctly.
params_not_matched_msg (str): If specified, this overrides an automatically generated feedback message
in case the function parameters were not successfully matched.
expand_msg (str): If specified, this overrides any messages that are prepended by previous SCT chains.
signature (Signature): Normally, check_function() can figure out what the function signature is,
but it might be necessary to use ``sig_from_params()`` to manually build a signature and pass this along.
state (State): State object that is passed from the SCT Chain (don't specify this).
:Examples:
Student code and solution code::
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
np.mean(arr)
SCT::
# Verify whether arr was correctly set in np.mean
Ex().check_function('numpy.mean').check_args('a').has_equal_value()
# Verify whether np.mean(arr) produced the same result
Ex().check_function('numpy.mean').has_equal_value()
"""
append_missing = missing_msg is None
append_params_not_matched = params_not_matched_msg is None
if missing_msg is None:
missing_msg = MISSING_MSG
if expand_msg is None:
expand_msg = PREPEND_MSG
if params_not_matched_msg is None:
params_not_matched_msg = SIG_ISSUE_MSG
stu_out = state.ast_dispatcher.find("function_calls", state.student_ast)
sol_out = state.ast_dispatcher.find("function_calls", state.solution_ast)
student_mappings = state.ast_dispatcher.find("mappings", state.student_ast)
fmt_kwargs = {
"times": get_times(index + 1),
"ord": get_ord(index + 1),
"index": index,
"mapped_name": get_mapped_name(name, student_mappings),
}
# Get Parts ----
# Copy, otherwise signature binding overwrites sol_out[name][index]['args']
with debugger(state):
try:
sol_parts = {**sol_out[name][index]}
except KeyError:
state.report(
"`check_function()` couldn't find a call of `%s()` in the solution code. Make sure you get the mapping right!"
% name)
except IndexError:
state.report(
"`check_function()` couldn't find %s calls of `%s()` in your solution code."
% (index + 1, name))
try:
# Copy, otherwise signature binding overwrites stu_out[name][index]['args']
stu_parts = {**stu_out[name][index]}
except (KeyError, IndexError):
state.report(missing_msg, fmt_kwargs, append=append_missing)
# Signatures -----
if signature:
signature = None if isinstance(signature, bool) else signature
get_sig = partial(
getSignatureInProcess,
name=name,
signature=signature,
manual_sigs=state.get_manual_sigs(),
)
try:
sol_sig = get_sig(mapped_name=sol_parts["name"],
process=state.solution_process)
sol_parts["args"] = bind_args(sol_sig, sol_parts["args"])
except Exception as e:
with debugger(state):
state.report(
"`check_function()` couldn't match the %s call of `%s` to its signature:\n%s "
% (get_ord(index + 1), name, e))
try:
stu_sig = get_sig(mapped_name=stu_parts["name"],
process=state.student_process)
stu_parts["args"] = bind_args(stu_sig, stu_parts["args"])
except Exception:
state.to_child(highlight=stu_parts["node"]).report(
params_not_matched_msg,
fmt_kwargs,
append=append_params_not_matched)
# three types of parts: pos_args, keywords, args (e.g. these are bound to sig)
append_message = FeedbackComponent(expand_msg, fmt_kwargs)
child = part_to_child(stu_parts,
sol_parts,
append_message,
state,
node_name="function_calls")
return child
def check_object(state,
index,
missing_msg=None,
expand_msg=None,
typestr="variable"):
"""Check object existence (and equality)
Check whether an object is defined in the student's process, and zoom in on its value in both
student and solution process to inspect quality (with has_equal_value().
In ``pythonbackend``, both the student's submission as well as the solution code are executed, in separate processes.
``check_object()`` looks at these processes and checks if the referenced object is available in the student process.
Next, you can use ``has_equal_value()`` to check whether the objects in the student and solution process correspond.
Args:
index (str): the name of the object which value has to be checked.
missing_msg (str): feedback message when the object is not defined in the student process.
expand_msg (str): If specified, this overrides any messages that are prepended by previous SCT chains.
:Example:
Suppose you want the student to create a variable ``x``, equal to 15: ::
x = 15
The following SCT will verify this: ::
Ex().check_object("x").has_equal_value()
- ``check_object()`` will check if the variable ``x`` is defined in the student process.
- ``has_equal_value()`` will check whether the value of ``x`` in the solution process is the same as in the student process.
Note that ``has_equal_value()`` only looks at **end result** of a variable in the student process.
In the example, how the object ``x`` came about in the student's submission, does not matter.
This means that all of the following submission will also pass the above SCT: ::
x = 15
x = 12 + 3
x = 3; x += 12
:Example:
As the previous example mentioned, ``has_equal_value()`` only looks at the **end result**. If your exercise is
first initializing and object and further down the script is updating the object, you can only look at the final value!
Suppose you want the student to initialize and populate a list `my_list` as follows: ::
my_list = []
for i in range(20):
if i % 3 == 0:
my_list.append(i)
There is no robust way to verify whether `my_list = [0]` was coded correctly in a separate way.
The best SCT would look something like this: ::
msg = "Have you correctly initialized `my_list`?"
Ex().check_correct(
check_object('my_list').has_equal_value(),
multi(
# check initialization: [] or list()
check_or(
has_equal_ast(code = "[]", incorrect_msg = msg),
check_function('list')
),
check_for_loop().multi(
check_iter().has_equal_value(),
check_body().check_if_else().multi(
check_test().multi(
set_context(2).has_equal_value(),
set_context(3).has_equal_value()
),
check_body().set_context(3).\\
set_env(my_list = [0]).\\
has_equal_value(name = 'my_list')
)
)
)
)
- ``check_correct()`` is used to robustly check whether ``my_list`` was built correctly.
- If ``my_list`` is not correct, **both** the initialization and the population code are checked.
:Example:
Because checking object correctness incorrectly is such a common misconception, we're adding another example: ::
import pandas as pd
df = pd.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6]})
df['c'] = [7, 8, 9]
The following SCT would be **wrong**, as it does not factor in the possibility that the 'add column ``c``' step could've been wrong: ::
Ex().check_correct(
check_object('df').has_equal_value(),
check_function('pandas.DataFrame').check_args(0).has_equal_value()
)
The following SCT would be better, as it is specific to the steps: ::
# verify the df = pd.DataFrame(...) step
Ex().check_correct(
check_df('df').multi(
check_keys('a').has_equal_value(),
check_keys('b').has_equal_value()
),
check_function('pandas.DataFrame').check_args(0).has_equal_value()
)
# verify the df['c'] = [...] step
Ex().check_df('df').check_keys('c').has_equal_value()
:Example:
pythonwhat compares the objects in the student and solution process with the ``==`` operator.
For basic objects, this ``==`` is operator is properly implemented, so that the objects can be effectively compared.
For more complex objects that are produced by third-party packages, however, it's possible that this equality operator is not implemented in a way you'd expect.
Often, for these object types the ``==`` will compare the actual object instances: ::
# pre exercise code
class Number():
def __init__(self, n):
self.n = n
# solution
x = Number(1)
# sct that won't work
Ex().check_object().has_equal_value()
# sct
Ex().check_object().has_equal_value(expr_code = 'x.n')
# submissions that will pass this sct
x = Number(1)
x = Number(2 - 1)
The basic SCT like in the previous example will notwork here.
Notice how we used the ``expr_code`` argument to _override_ which value `has_equal_value()` is checking.
Instead of checking whether `x` corresponds between student and solution process, it's now executing the expression ``x.n``
and seeing if the result of running this expression in both student and solution process match.
"""
# Only do the assertion if PYTHONWHAT_V2_ONLY is set to '1'
if v2_only():
extra_msg = "If you want to check the value of an object in e.g. a for loop, use `has_equal_value(name = 'my_obj')` instead."
state.assert_execution_root("check_object", extra_msg=extra_msg)
if missing_msg is None:
missing_msg = "Did you define the {{typestr}} `{{index}}` without errors?"
if expand_msg is None:
expand_msg = "Did you correctly define the {{typestr}} `{{index}}`? "
if (not isDefinedInProcess(index, state.solution_process)
and state.has_different_processes()):
raise InstructorError(
"`check_object()` couldn't find object `%s` in the solution process."
% 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.ast_dispatcher.find("object_assignments",
state.student_ast).get(
index, fallback())
sol_part = state.ast_dispatcher.find("object_assignments",
state.solution_ast).get(
index, fallback())
# test object exists
_msg = state.build_message(missing_msg, append_message["kwargs"])
state.do_test(
DefinedProcessTest(index, state.student_process, Feedback(_msg)))
child = part_to_child(stu_part,
sol_part,
append_message,
state,
node_name="object_assignments")
return child
