def print_goals(name, goals, detailed):
print('Goals for {}'.format(as_red(name)))
print(' {}'.format(as_pink('-------')))
print_g = lambda idx, goal: print_goal(idx, goal, detailed)
util.starmap_now(print_g, enumerate(goals))
print(' {}'.format(as_pink('-------')))
print()
def print_uppgift_details(rule):
problems = rule.points['uppgift']['problems']
if 'deadline' in rule.points['uppgift']:
deadline = rule.points['uppgift']['deadline']
else:
deadline = '01-01-2117 08:00'
print_detail = lambda idx, problem: print_problem_detail(
idx, problem, deadline)
util.starmap_now(print_detail, enumerate(problems))
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 add_builtin_functions(context):
# Set up data for reducer functions
def count_operand(values):
return sum(map(bool, values))
reducer_functions = [
('+', operator.add),
('-', operator.sub),
('*', operator.mul),
('/', operator.truediv),
]
numeric_iterable_functions = [('MAX', max), ('MIN', min),
('COUNT', count_operand)]
bool_iterable_functions = [('AND', all), ('OR', any)]
numeric_functions = [('positive', lambda x: x > 0),
('negative', lambda x: x < 0),
('zero', lambda x: x == 0)]
comparison_functions = [('<', operator.lt), ('<=', operator.le),
('=', operator.eq), ('!=', operator.ne),
('>=', operator.ge), ('>', operator.gt)]
handler_makers = [(make_reduction_handler, reducer_functions),
(make_numeric_iterable_handler,
numeric_iterable_functions),
(make_bool_iterable_handler, bool_iterable_functions),
(make_numeric_handler, numeric_functions),
(make_comparison_handler, comparison_functions)]
def add_handler(handler, provided_functions):
def adder(string, oper):
context_add_handler(context, handler(string, oper))
util.starmap_now(adder, provided_functions)
context_add_handler(context, make_get_handler())
util.starmap_now(add_handler, handler_makers)
context_add_handler(context, make_type_handler(bool))
context_add_handler(context, make_type_handler(int))
def make_rule_from_json(json):
def crash_get(key):
return json[key]
def get_or_default(key, default):
return json.get(key, default)
mandatory = ['towards']
nonmandatory = [('deadline', ''), ('name', ''), ('late', ''),
('needs', True), ('points', 1)]
towards = crash_get(mandatory[0])
deadline, name, late, needs, points = util.starmap_now(
get_or_default, nonmandatory)
return make_rule(needs, towards, points, deadline, name, late)
def print_student_result(student_result, detailed):
student, ruleset, kattis, context, result = student_result
print()
print()
print(student.name)
print('-' * 42)
print()
def get_problem_id(problem):
return util.crossroad(lambda: isinstance(problem, str),
lambda: problem, lambda: problem['id'])
def get_problem_points(problem):
return util.crossroad(lambda: isinstance(problem, str), lambda: 1,
lambda: problem['points'])
def get_status_row(problem_id, points, deadline):
no_subs = len(kattis.attempts_for(problem_id)) == 0
if no_subs:
return '[ - ]'
AC = len(kattis.solutions_for(problem_id)) > 0
WA_3 = len(kattis.WA_for(problem_id)) >= 3
before_deadline = kattis.solved_before(problem_id, deadline)
C = lambda b: util.cond([(lambda: b, lambda: check),
(lambda: not b, lambda: cross)])()
if not AC:
points = 0
if not before_deadline:
points /= 2.0
pts = as_green(points) if points > 0 else as_red(int(points))
a = '{:16}'.format(pts)
b = '{}'.format(C(AC))
c = '{}'.format(C(WA_3))
d = '{}'.format(C(before_deadline))
message = '[ Pts? {} AC? {} +3WA? {} Before Deadline? {} ]'
return message.format(a, b, c, d)
def print_problem_detail(idx, problem, deadline):
indent = ' '
if idx % 4 == 0 and idx > 0:
print('{} {}'.format(indent, as_pink('---')))
problem_id = get_problem_id(problem)
points = get_problem_points(problem)
status_row = get_status_row(problem_id, points, deadline)
print('{} {:46} {}'.format(indent,
as_blue(problem_id) + ':', status_row))
def print_uppgift_details(rule):
problems = rule.points['uppgift']['problems']
if 'deadline' in rule.points['uppgift']:
deadline = rule.points['uppgift']['deadline']
else:
deadline = '01-01-2117 08:00'
print_detail = lambda idx, problem: print_problem_detail(
idx, problem, deadline)
util.starmap_now(print_detail, enumerate(problems))
def is_uppgift(rule):
return isinstance(rule.points, dict) and 'uppgift' in rule.points
def print_rule_resolution(rule, points):
if verbose_print:
indent = ' '
rule_name = as_purple(rule.name or 'Unnamed Rule')
print('{}Rule: "{}" gave {} pts'.format(indent, rule_name,
as_green(points)))
util.cond([(is_uppgift, print_uppgift_details)])(rule)
def print_goal_resolutions(goal):
util.starmap_now(print_rule_resolution, goal.resolved_rules)
def print_goal(idx, goal, detailed):
if idx % 4 == 0 and idx > 0:
print(' {}'.format(as_pink('---')))
name = '{:50}'.format(as_purple(goal.name))
p = goal.points
if int(p) == goal.points:
p = int(p)
points = '{:3}'.format(as_green(p))
print(name, points)
if detailed:
print_goal_resolutions(goal)
is_upg1 = lambda goal: goal.name.startswith('UPG1')
is_lab1 = lambda goal: goal.name.startswith('LAB1')
is_individual = lambda goal: goal.name.startswith('individual-session')
is_group = lambda goal: goal.name.startswith('group-session')
upg1_goals = util.filter_now(is_upg1, result.goals)
lab1_goals = util.filter_now(is_lab1, result.goals)
individual_goals = util.filter_now(is_individual, result.goals)
group_goals = util.filter_now(is_group, result.goals)
def print_goals(name, goals, detailed):
print('Goals for {}'.format(as_red(name)))
print(' {}'.format(as_pink('-------')))
print_g = lambda idx, goal: print_goal(idx, goal, detailed)
util.starmap_now(print_g, enumerate(goals))
print(' {}'.format(as_pink('-------')))
print()
all_goals = [('Individual Sessions', individual_goals, False),
('Group Sessions', group_goals, False),
('UPG1', upg1_goals, True), ('LAB1', lab1_goals, True)]
util.starmap_now(print_goals, all_goals)
def get_id(goal):
return goal.id
def is_rest(goal):
return goal.id not in map(get_id, upg1_goals) and \
goal.id not in map(get_id, lab1_goals) and \
goal.id not in map(get_id, individual_goals) and \
goal.id not in map(get_id, group_goals)
rest_goals = util.filter_now(is_rest, result.goals)
def print_goal_resolutions(goal):
util.starmap_now(print_rule_resolution, goal.resolved_rules)
def topological_order(rules):
# 1. Find each rule and the goals that it depends on
# 2. Create a dependency tree where each rule depends
# on all rules that go towards what they depend on
# 3. Solve dependency with toposort
goal_dependencies = collections.defaultdict(set)
def find_and_add_goals(index, rule):
get_need = find_expressions('get', rule.needs)
get_point = find_expressions('get', rule.points)
all_goals = get_need + get_point
add_goal = lambda expr: goal_dependencies[index].add(expr['get'])
util.map_now(add_goal, all_goals)
util.starmap_now(find_and_add_goals, enumerate(rules))
def is_dependency_rule(index, original_idx):
return rules[index].towards in goal_dependencies[original_idx]
def find_rule_dependency(index):
indices = range(len(rules))
# Note: also include self, because we can have the case that a user writes
# a rule that depends on itself being completed...
indexes_to_add = filter(lambda idx: is_dependency_rule(idx, index),
indices)
return list(indexes_to_add)
rule_dependency = util.map_now(find_rule_dependency, range(len(rules)))
rule_rev_dependency = [[] for _ in range(len(rules))]
def add_rev_dependency(key, values):
util.map_now(lambda val: rule_rev_dependency[val].append(key), values)
util.starmap_now(add_rev_dependency, enumerate(rule_dependency))
connection_count = [len(x) for x in rule_dependency]
# rule_rev_dependency is our dependency mapping and connection_count count
# how many unsolved we depend on
def should_add_to_queue(index):
return connection_count[index] == 0
def add_to_queue(index):
queue.append(index)
def process_item(index):
connection_count[index] -= 1
util.cond([(should_add_to_queue, add_to_queue)])(index)
queue = list(filter(should_add_to_queue, range(len(rules))))
idx = 0
# We need to continuously evaluate the length of the queue so we
# need to run with a while loop -.-
while idx < len(queue):
item = queue[idx]
util.map_now(process_item, rule_rev_dependency[item])
idx += 1
return queue
def add_handler(handler, provided_functions):
def adder(string, oper):
context_add_handler(context, handler(string, oper))
util.starmap_now(adder, provided_functions)
def resolve_for_result(kattis, ruleset):
context = resolver.make_context()
plugins = kattis.get_plugins()
func = lambda c, h: resolver.context_add_plugin(context, c, h)
util.starmap_now(func, plugins)
return resolver.resolve(ruleset, context)
