recompute.py

#!/usr/bin/python3

from common import *

from gen import generate_input_output

def recompute_tests(test_names, solution_name, verifier_name=None, timeout=None):
    print("(Re)computing:", ", ".join(test_names))
    print()

    failed_verifier = set()
    failed_solution = set()
    succeeded = set()

    for test_name in test_names:
        gen_suc, ver_suc, sol_suc = generate_input_output(test_name, solution_name=solution_name, verifier_name=verifier_name, timeout=timeout)
        print()
        
        if verifier_name is not None and not ver_suc:
            failed_verifier.add(test_name)
        elif not sol_suc:
            failed_solution.add(test_name)
        else:
            succeeded.add(test_name)
    
    
    if len(failed_verifier) > 0:
        print(f"{len(failed_verifier)}/{len(test_names)} failed verifier:", ", ".join(failed_verifier))
    
    if len(failed_solution) > 0:
        print(f"{len(failed_solution)}/{len(test_names)} threw solution error:", ", ".join(failed_solution))
    
    print(f"{len(succeeded)}/{len(test_names)} succeeded.")
    if len(succeeded)==len(test_names):
        print("All Clear!")

def recompute_re_list(re_list, solution_name, verifier_name=None, timeout=None):
    test_names = get_files_from_re_list(re_list, IN_DIR, IN_SUFFIX)

    recompute_tests(test_names, solution_name, verifier_name=verifier_name, timeout=timeout)



if __name__ == "__main__":
    from getopt import getopt, GetoptError
    import sys

    short_opts = "v:t:a"
    try:
        opts, args = getopt(sys.argv[1:], short_opts)
    except GetoptError as err:
        print(err)
        sys.exit(2)
    
    opt_dict = {opt:value for opt, value in opts}

    verifier_name = opt_dict.get("-v")
    timeout_str = opt_dict.get("-t")

    abort_on_error = "a" in opt_dict
    failure = False

    if verifier_name is not None:
        if not path.isfile(path.join(VERS_DIR, verifier_name)):
            print(f"No such verifier ({verifier_name})!")
            failure = True
    
    if timeout_str is not None:
        try:
            timeout = float(timeout_str)
            assert timeout > 0
        except (ValueError, AssertionError):
            print(f"Invalid Timeout ({timeout_str})")
            failure=True
    else:
        timeout=None

    if len(args) < 1:
        print("Missing argument <solution>")
        failure=True
    else:
        solution_name = args[0]
        if not path.isfile(path.join(SOLS_DIR, solution_name)):
            print(f"No such solution ({solution_name})!")
            failure = True

    patterns = set(args[1:])

    if len(patterns)==0:
        patterns = {".*"}
    
    re_list = get_re_list(patterns)
    if len(re_list) == 0:
        print("No Valid Patterns")
        failure=True
    elif abort_on_error and len(re_list) < len(patterns):
        failure=True
    
    if failure:
        print("Aborting.")
        sys.exit(2)
    else:
        recompute_re_list(re_list, solution_name, verifier_name=verifier_name, timeout=timeout)