def main(rulepath,
datapath,
detailed=False,
name_filter=None,
is_student=False):
ruleset = rules.parse_file(rulepath)
exported = aaps.read_exported_kattis_file(datapath)
def handle_student(student):
kattis = aaps.KattisResult()
if is_student:
kattis.resolve_sessions_with_input()
add_sub = lambda sub: kattis.add_submission(sub)
util.map_now(add_sub, student.submissions)
context = resolver.make_context()
plugins = kattis.get_plugins()
add_plugin = lambda c, r: resolver.context_add_plugin(context, c, r)
util.starmap_now(add_plugin, plugins)
result = resolver.resolve(ruleset, context)
return make_student_result(student, ruleset, kattis, context, result)
def name_match(student):
return name_filter.lower() in student.name or \
name_filter.lower() in student.username
students = util.filter_now(name_match, exported.students)
student_results = util.map_now(handle_student, students)
print_result = lambda result: print_student_result(result, detailed)
util.map_now(print_result, student_results)
def test_resolve_with_ordering():
rule_path = get_rule_file('test_resolve_with_ordering.json')
ruleset = rules.parse_file(rule_path.as_posix())
assert len(ruleset.rules) == 5
context = resolver.make_context()
result = resolver.resolve(ruleset, context)
assert len(result.goals) == 5
assert all(goal.points == 1 for goal in result.goals)
def test_only_towards_necessary():
rule_path = get_rule_file('test_only_towards_necessary.json')
ruleset = rules.parse_file(rule_path.as_posix())
assert len(ruleset.rules) == 1
rule = ruleset.rules[0]
assert rule.towards == 'only-towards-necessary'
assert rule.points
assert rule.needs
def test_resolve_basic():
rule_path = get_rule_file('test_resolve_basic.json')
ruleset = rules.parse_file(rule_path.as_posix())
assert len(ruleset.rules) == 1
context = resolver.make_context()
result = resolver.resolve(ruleset, context)
assert any(goal.name == 'resolve-basic-goal' and goal.points == 1
for goal in result.goals)
assert len(result.goals) == 1
def test_resolve_two_to_same():
rule_path = get_rule_file('test_resolve_two_to_same.json')
ruleset = rules.parse_file(rule_path.as_posix())
assert len(ruleset.rules) == 2
context = resolver.make_context()
result = resolver.resolve(ruleset, context)
assert len(result.goals) == 1
goal = result.goals[0]
assert goal.name == 'resolve-two-of-same' and goal.points == 2 and \
len(goal.resolved_rules) == 2 and len(goal.non_resolved_rules) == 0
def test_inspect_simple_rule():
rule_path = get_rule_file('test_inspect_simple_rule.json')
ruleset = rules.parse_file(rule_path.as_posix())
assert len(ruleset.rules) == 1
rule = ruleset.rules[0]
assert rule.needs == "inspect-need"
assert rule.towards == "inspect-towards"
assert rule.points == 1
assert rule.deadline == "01-01-2017 08:00"
assert rule.name == "Inspect Rule"
assert rule.late == "halved"
def test_custom_plugin():
def checker(context, tree):
return isinstance(tree, dict) and 'identity' in tree
def handler(context, tree):
return tree['identity']
rule_path = get_rule_file('test_custom_plugin.json')
ruleset = rules.parse_file(rule_path.as_posix())
assert len(ruleset.rules) == 1
context = resolver.make_context()
resolver.context_add_plugin(context, checker, handler)
result = resolver.resolve(ruleset, context)
assert len(result.goals) == 1
assert all(goal.points == 42 for goal in result.goals)
def test_inspect_complex_rule():
rule_path = get_rule_file('test_inspect_complex_rule.json')
ruleset = rules.parse_file(rule_path.as_posix())
assert len(ruleset.rules) == 1
need_expression = {
"OR": [
False, {
"positive": {
"get": "some-other-goal"
}
}, {
">": {
"lhs": 4,
"rhs": 2
}
}
]
}
value_expression = {
"+": [
1, 2, 3, {
"*": [4, 2]
}, {
"-": [4, 3, 1]
}, {
"/": [42, 21]
}, {
"get": "another-goal"
}, {
"MAX": [1, 2, 1]
}
]
}
rule = ruleset.rules[0]
assert rule.needs == need_expression
assert rule.towards == "inspect-complex-towards"
assert rule.points == value_expression
def before(self, node, rule):
lbl = self.labels[node.idx]
if len(lbl) == 0:
lbl = '{}: '.format(node.op)
if not lbl.endswith(': '):
lbl += ' + '
lbl += '{}#{}'.format(rule.lhs, rule.idx)
self.labels[node.idx] = lbl
def after(self, node, rule):
pass
return Helper(self)
if __name__ == '__main__':
rs = rules.parse_file(os.path.join(os.path.dirname(__file__), '../config/rules.txt'))
print('Rules:')
print(rs)
tb = TableBuilder(rs)
tb.build()
t = optree.parse_file(sys.argv[1])
matcher = Matcher(tb, t)
matcher.match()
graphivz.show_obj(matcher.all_matches())
graphivz.show_obj(matcher.apply_matches())
def get_ruleset_from_file(fpath):
rule_path = get_rule_file(fpath)
return rules.parse_file(rule_path.as_posix())
def test_circular_include():
rule_path = get_rule_file('test_load_circular_import_1.json')
ruleset = rules.parse_file(rule_path.as_posix())
assert len(ruleset.rules) == 2
def test_load_json_with_include():
rule_path = get_rule_file('test_load_json_with_include_rules_1.json')
ruleset = rules.parse_file(rule_path.as_posix())
assert len(ruleset.rules) == 1
def test_load_json_from_file():
rule_path = get_rule_file('test_load_json_from_file_rules.json')
ruleset = rules.parse_file(rule_path.as_posix())
assert len(ruleset.rules) == 1
