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)