def test_hidden_error(self):
clear_report()
contextualize_report('import pedal')
verify()
tifa_analysis()
final = simple.resolve()
self.assertNotEqual("No errors reported.", final.message)
def test_unmessaged_tifa(self):
clear_report()
contextualize_report('import random\nrandom')
verify()
tifa_analysis()
final = simple.resolve()
self.assertEqual(SUCCESS_MESSAGE, final.title+"\n"+final.message)
def _initialize_report(self):
"""
Initialize a successful report with possible set of issues.
"""
if self.report["source"]["success"]:
std_ast = self.report['source']['ast']
self.report['cait'] = {}
self.report['cait']['std_ast'] = EasyNode(std_ast)
tifa_analysis(report=self.report)
def test_empty(self):
clear_report()
contextualize_report(' ')
verify()
tifa_analysis()
commands.run()
final = simple.resolve()
self.assertEqual(Feedback.CATEGORIES.SYNTAX, final.category)
self.assertEqual("No Source Code", final.title)
self.assertEqual("Source code file is blank.", final.message)
def test_success_suppression(self):
clear_report()
contextualize_report('a=0\na')
verify()
tifa_analysis()
set_success()
suppress(label='set_success')
final = simple.resolve()
self.assertEqual(Feedback.CATEGORIES.COMPLETE, final.category)
self.assertEqual(SUCCESS_MESSAGE, final.title+"\n"+final.message)
def test_success(self):
clear_report()
contextualize_report('a=0\na')
verify()
tifa_analysis()
set_success()
final = simple.resolve()
self.assertEqual(Feedback.CATEGORIES.COMPLETE, final.category)
self.assertEqual("Complete", final.title)
self.assertEqual("Great work!", final.message)
def test_runtime_suppression(self):
clear_report()
contextualize_report('import json\njson.loads("0")+"1"')
verify()
tifa_analysis()
commands.run()
suppress("Runtime")
final = simple.resolve()
self.assertEqual(Feedback.CATEGORIES.COMPLETE, final.category)
self.assertEqual(SUCCESS_TEXT, final.message)
def test_analyzer_suppression(self):
clear_report()
contextualize_report('1+"Hello"')
verify()
tifa_analysis()
commands.run()
suppress("analyzer")
final = simple.resolve()
self.assertEqual("runtime", final.category)
self.assertEqual("Type Error", final.title)
def __enter__(self):
clear_report(report=self.report)
contextualize_report(self.code, report=self.report)
verify(report=self.report)
if self.run_tifa:
tifa_analysis(report=self.report)
# TODO: Clean this up
self.student = get_sandbox(self.report)
self.report['sandbox']['sandbox'].tracer_style = self.tracer_style
commands.run()
return self
def to_source(source):
"""
Args:
source:
"""
MAIN_REPORT.clear()
contextualize_report(source)
verify()
parse_program()
tifa_analysis()
def __init__(self,
files=None,
main_file='answer.py',
main_code=None,
user=None,
assignment=None,
course=None,
execution=None,
instructor_file='on_run.py',
skip_tifa=False,
skip_run=False,
inputs=None,
set_success=True,
report=MAIN_REPORT,
trace=True,
threaded=True,
**kwargs):
super().__init__(files=files,
main_file=main_file,
main_code=main_code,
user=user,
assignment=assignment,
course=course,
execution=execution,
instructor_file=instructor_file,
report=report)
self.skip_run = skip_run
self.skip_tifa = skip_tifa
self.trace = trace
report.set_formatter(Formatter(report))
verify(report=self.report)
if not skip_tifa:
tifa_analysis(report=self.report)
if inputs:
set_input(inputs)
if skip_run:
student = get_sandbox(report=report)
student.threaded = threaded
else:
if trace:
start_trace()
student = run(report=report, threaded=threaded)
student.threaded = threaded
self.fields = {
'student': student,
'resolve': resolve,
'next_section': self.next_section,
'sectional_resolve': sectional_resolve,
'show_as_hidden': show_as_hidden
}
def next_section(self, name=""):
original_next_section(name=name, report=self.report)
verify(report=self.report)
if not self.skip_tifa:
tifa_analysis(report=self.report)
student = get_sandbox(report=self.report)
if self.skip_run:
student.clear()
else:
if self.trace:
start_trace()
student.clear()
student = student.run()
return student
def __init__(self,
files=None,
main_file='answer.py',
main_code=None,
user=None,
assignment=None,
course=None,
execution=None,
instructor_file='on_run.py',
skip_tifa=False,
set_success=True,
report=MAIN_REPORT):
# Possibly user passed in stuff via the command line.
if files is None and main_code is None:
(instructor_file, files, main_file, main_code, user, assignment,
course, execution) = parse_argv()
super().__init__(files=files,
main_file=main_file,
main_code=main_code,
user=user,
assignment=assignment,
course=course,
execution=execution,
instructor_file=instructor_file,
report=report)
# Then default custom stuff
verify(report=report)
self.ast = parse_program(report=report)
if skip_tifa:
self.tifa = None
else:
from pedal.tifa import tifa_analysis
self.tifa = tifa_analysis(report=report)
self.student = run(threaded=True, report=report)
self.set_success = set_success
def __init__(self,
files=None,
main_file='answer.py',
main_code=None,
user=None,
assignment=None,
course=None,
execution=None,
instructor_file='on_run.py',
skip_tifa=False,
skip_run=False,
inputs=None,
set_success=True,
report=MAIN_REPORT,
trace=True):
super().__init__(files=files,
main_file=main_file,
main_code=main_code,
user=user,
assignment=assignment,
course=course,
execution=execution,
instructor_file=instructor_file,
report=report)
report.set_formatter(HtmlFormatter(report))
verify(report=self.report)
if not skip_tifa:
tifa_analysis(report=self.report)
if inputs:
set_input(inputs)
if skip_run:
student = get_sandbox(report=report)
else:
if trace:
start_trace()
student = run(report=report)
self.fields = {
'student': student,
'resolve': resolve,
'stats_resolve': stats_resolve
}
def test_gently_vs_runtime(self):
# Runtime > Gently
clear_report()
contextualize_report('import json\njson.loads("0")+"1"')
verify()
tifa_analysis()
commands.run()
gently("I have a gentle opinion, but you don't want to hear it.")
final = simple.resolve()
print(final.label)
self.assertEqual(Feedback.CATEGORIES.RUNTIME, final.category)
# Runtime < Explain
clear_report()
contextualize_report('import json\njson.loads("0")+"1"')
verify()
tifa_analysis()
commands.run()
explain("LISTEN TO ME")
final = simple.resolve()
self.assertEqual(Feedback.CATEGORIES.INSTRUCTOR, final.category)
def test_sections_tifa(self):
contextualize_report(
dedent('''
##### Part 1
a = 0
##### Part 2
print(a)
##### Part 3
print(b)
'''))
separate_into_sections(independent=False)
# First section has an unused variable
next_section()
self.assertEqual(len(get_all_feedback()), 2)
tifa_analysis()
self.assertEqual(len(get_all_feedback()), 3)
# Second section uses said variable
next_section()
self.assertEqual(len(get_all_feedback()), 4)
tifa_analysis()
self.assertEqual(len(get_all_feedback()), 4)
# Third section has a new unused variables
next_section()
self.assertEqual(len(get_all_feedback()), 5)
tifa_analysis()
feedback = get_all_feedback()
self.assertEqual(len(get_all_feedback()), 6)
finals = sectional.resolve()
self.assertEqual(
"""FeedbackSourceSection
Feedback separated into groups
Unused Variable
The variable a was given a value on line 3, but was never used after that.
Initialization Problem
The variable b was used on line 7, but it was not given a value on a previous line. You cannot use a variable until it has been given a value.""",
"\n".join(f.title + "\n" + f.message for f in finals.values()))
def __enter__(self):
clear_report()
set_source(self.code)
tifa_analysis()
compatibility.run_student(raise_exceptions=True)
return self
print("Phase {}: {} secs".format(phase, round(diff, 2)))
stopwatch = time.time()
import pedal
click("Imported pedal")
from pedal.source import set_source
click("Imported source")
set_source("a = 0")
click("Set source")
from pedal.tifa import tifa_analysis
click("Imported Tifa")
tifa_analysis()
click("Ran Tifa")
from pedal.cait import parse_program
click("Imported cait")
ast = parse_program()
click("Parsed program")
if ast.find_all("Assign"):
print(ast.find_all("Assign"))
click("Found assignments")
from pedal.resolvers import simple
click("Imported resolver")
import pedal
click("Imported pedal")
from pedal.source import set_source
click("Imported source")
set_source("a = 0")
click("Set source")
from pedal.tifa import tifa_analysis
click("Imported Tifa")
tifa_analysis()
click("Ran Tifa")
from pedal.cait import parse_program
click("Imported cait")
ast = parse_program()
click("Parsed program")
if ast.find_all("Assign"):
print(ast.find_all("Assign"))
click("Found assignments")
from pedal.sandbox.sandbox import run
def to_source(source):
MAIN_REPORT.clear()
set_source(source)
parse_program()
tifa_analysis()
################################################################################
# BlockPy Examples
# Boiler plate code automatically prepended before execution
# Import get_output, set_success, gently, explain
from pedal.report import *
# In JS, patch `get_program`, and then imperative define the report's source
report.set_source(get_program())
# Run the tifa analysis; stuff is automatically added to the report
from pedal.tifa import tifa_analysis()
_tifa = tifa_analysis()
# Set up CAIT to know about TIFA
import pedal.cait as cait
cait.configure(tifa=_tifa)
# End of boiler plate
# Minor modifications to pathing for the instructor_* stuff
from pedal.mistakes import mistakes
mistakes.filter_group()
mistakes.append.append_group()
# But most code left unchanged
if 'text' in get_output():
gently("Hey now...")
set_success()
# Boilerplate begins again.
import pedal.feedback as feedback
_RESULT = feedback.select()
_PARTIALS = sum_partials()
