importer.py

import csv
import json
import os
import readline
from typing import Callable

from django.db import transaction

import util.processing
from core.models import ExamType, Feedback, Submission, SubmissionType, Test
from core.models import UserAccount as User
from util.factories import GradyUserFactory
from util.messages import info, warn

WELCOME = r'''
   ______               __         ____                           __
  / ____/________ _____/ /_  __   /  _/___ ___  ____  ____  _____/ /____  _____
 / / __/ ___/ __ `/ __  / / / /   / // __ `__ \/ __ \/ __ \/ ___/ __/ _ \/ ___/
/ /_/ / /  / /_/ / /_/ / /_/ /  _/ // / / / / / /_/ / /_/ / /  / /_/  __/ /
\____/_/   \__,_/\__,_/\__, /  /___/_/ /_/ /_/ .___/\____/_/   \__/\___/_/
                      /____/                /_/
'''

HISTFILE = '.importer_history'
RECORDS = '.importer'
PASSWORDS = '.importer_passwords'

YES = 'Y/n'
NO = 'y/N'

valid = {"yes": True, "y": True, "ye": True, "no": False, "n": False}

ORIGIN_ORDER = {
    Feedback.WAS_EMPTY,
    Feedback.DID_NOT_COMPILE,
    Feedback.COULD_NOT_LINK,
    Feedback.FAILED_UNIT_TESTS,
}

TEST_ORDER = (
    util.processing.EmptyTest.__name__,
    util.processing.CompileTest.__name__,
    util.processing.LinkTest.__name__,
    util.processing.UnitTestTest.__name__,
)

FEEDBACK_MAPPER = dict(zip(TEST_ORDER, ORIGIN_ORDER))

user_factory = GradyUserFactory()


class chdir_context(object):
    """
    Step into a directory temporarily.
    """

    def __init__(self, path):
        self.old_dir = os.getcwd()
        self.new_dir = path

    def __enter__(self):
        info(f'Changing to {self.new_dir}')
        os.chdir(self.new_dir)

    def __exit__(self, *args):
        os.chdir(self.old_dir)
        info(f'Returned to {self.old_dir}')


def i(prompt: str, default: str = '', is_path: bool = False, is_file: bool = False):
    if default is YES or default is NO:
        answer = valid[input(f'[Q] {prompt} ({default}): ').lower() or (
            'y' if YES == default else 'n')]
    elif default:
        answer = input(f'[Q] {prompt} ({default}): ') or default
    else:
        answer = input(f'[Q] {prompt}: ')

    if (is_path or is_file) and \
            not os.path.exists(answer) or is_file and \
            not os.path.isfile(answer):
        path_or_type = "path" if is_path else "file"
        warn(f'The {path_or_type} does not exist. Please try again.')
        return i(prompt, default, is_path, is_file)

    return answer


def add_feedback_if_test_recommends_it(test_obj):
    available_tests = util.processing.Test.available_tests()

    if test_obj.label == available_tests[test_obj.name].label_failure \
        and not hasattr(test_obj.submission, 'feedback') \
        and (test_obj.name == util.processing.EmptyTest.__name__ or
             test_obj.name == util.processing.CompileTest.__name__):
        return Feedback.objects.update_or_create(
            of_submission=test_obj.submission,
            defaults={
                'score': 0,
                'origin': FEEDBACK_MAPPER[test_obj.name],
                'is_final': True,
            }
        )


def add_tests(submission_obj, tests):
    auto_correct, _ = User.objects.get_or_create(
        username='auto_correct',
        defaults={'is_active': False}
    )

    for name in (name for name in TEST_ORDER if name in tests):
        test_data = tests[name]
        test_obj, created = Test.objects.update_or_create(
            name=test_data['name'],
            submission=submission_obj,
            defaults={
                'label': test_data['label'],
                'annotation': test_data['annotation'],
            }
        )
        add_feedback_if_test_recommends_it(test_obj)


# submission_type is the name outputted by rust_hektor, type the one from hektor
def add_submission(student_obj, code, tests, submission_type=None, type=None):
    if submission_type is None and type is None:
        raise Exception("Submission need to contain submission_type or type")
    elif type is not None:
        submission_type = type

    submission_type_obj = SubmissionType.objects.get(name=submission_type)

    submission_obj, _ = Submission.objects.update_or_create(
        type=submission_type_obj,
        student=student_obj,
        defaults={'text': code}
    )

    if tests:
        add_tests(submission_obj, tests)


def call_loader(func: Callable) -> None:
    """ This function handles if a function will be executed at all. Currently
    it just checks in the RECORDS file for the name of the function. If it is
    present the function will not be executed

    Args:
        func (Callable): the loader specified below
    """
    if os.path.exists(RECORDS):
        with open(RECORDS, 'r') as records_f:
            done = [line.strip() for line in records_f]

        if func.__name__ in done:
            warn(f'{func.__name__} has already been processed once.')
            if not i('Proceed anyway?', NO):
                return

    with transaction.atomic():
        func()  # This executes the specified loader

    with open(RECORDS, 'a') as records_f:
        records_f.write(func.__name__)
        records_f.write('\n')

    info(f'{func.__name__} is done.')


def file_suffix_to_lang_name(suffix: str) -> str:
    suffix2name = {
        'hs': 'haskell',
        's': 'mipsasm',
        'asm': 'mipsasm'
    }
    if suffix not in suffix2name:
        return suffix
    return suffix2name[suffix]


def do_load_submission_types():

    print(
        '''For the following import you need three files:

    1) A .csv file where the columns are: id, name, score, (file suffix). No
       suffix defaults to .c
       Supported suffixes: .c , .java , .hs , .s (for mips)
    2) A path to a directory where I can find sample solutions named
        <id>-lsg.c
    3) A path to a directory where I can find HTML files with an accurate
        description of the task. File name pattern has to be: <id>.html

    Example:
        $ cat submission_types.csv
        a01, Alpha Team, 10, .c
        a02, Beta Distribution, 10, .java
        a03, Gamma Ray, 20

        $ tree -L 2
        .
        ├── code-lsg
        │   ├── a01.c
        │   ├── a02.java
        │   └── a03.hs
        └── html
            ├── a01.html
            ├── a02.html
            └── a03.html
    ''')

    path = i('Where are your files located?', '.', is_path=True)

    with chdir_context(path):
        submission_types_csv = i('CSV file', 'submission_types.csv')
        lsg_dir = i('solution dir', 'code-lsg')
        desc_dir = i('descriptions dir', 'html')

        with open(submission_types_csv, encoding='utf-8') as tfile:
            csv_rows = [row for row in csv.reader(tfile) if len(row) > 0]

        for row in csv_rows:
            tid, name, score, *suffix = (col.strip() for col in row)

            if not suffix:
                suffix = '.c'
            else:
                suffix = suffix[0]

            suffix = suffix.lower().strip('.')
            lang_name = file_suffix_to_lang_name(suffix)

            with \
                open(os.path.join(lsg_dir, tid + '.' + suffix),
                     encoding='utf-8') as lsg, \
                open(os.path.join(desc_dir, tid + '.html'),
                     encoding='utf-8') as desc:
                data = {
                    'name': name,
                    'description': desc.read(),
                    'solution': lsg.read(),
                    'full_score': int(score),
                    'programming_language': lang_name
                }
            _, created = SubmissionType.objects.update_or_create(
                name=name,
                defaults=data
            )
            info(f'{"Created" if created else "Updated"} {name}')


def do_load_module_descriptions():

    print('''
    This loader imports descriptions of modules in an exam. This information
    is used to distinguish students within one instance or give information
    about the grading type.

    CSV file format: module_reference, total_score, pass_score, pass_only

    Example:
        B.Inf.1801,  90, 45, yes
        B.Mat.31415, 50, 10, no
    ''')

    module_description_csv = i(
        'Where is the file?', 'modules.csv', is_file=True)

    with open(module_description_csv, encoding='utf-8') as tfile:
        csv_rows = [row for row in csv.reader(tfile) if len(row) > 0]

    for row in csv_rows:
        data = {
            field: kind(data) for field, kind, data in zip(
                ('module_reference', 'total_score', 'pass_score', 'pass_only'),
                (str, int, int, lambda x: x == 'yes'),
                (col.strip() for col in row)
            )
        }

        _, created = ExamType.objects.update_or_create(
            module_reference=data['module_reference'],
            defaults=data,
        )

        modification = "Created" if created else "Updated"
        info(f'{modification} ExamType {data["module_reference"]}')


def _do_check_empty_submissions():
    submissions = i(
        'Please provide the student submissions', 'binf1601-anon.json',
        is_file=True)
    return (
        util.processing.process('', '', '', submissions, '', util.processing.EmptyTest.__name__),
        submissions)


def _do_preprocess_c_submissions(test_to_run):
    location = i('Where do you keep the specifications for the tests?',
                 'anon-export', is_path=True)

    with chdir_context(location):
        descfile = i(
            'Please provide usage for sample solution', 'descfile.txt',
            is_file=True)
        binaries = i(
            'Please provide executable binaries of solution', 'bin',
            is_path=True)
        objects = i(
            'Please provide object files of solution', 'objects',
            is_path=True)
        submissions = i(
            'Please provide the student submissions', 'binf1601-anon.json',
            is_file=True)
        headers = i(
            'Please provide header files if any', 'code-testing',
            is_path=True)

        info('Looks good. The tests mights take some time.')
        return util.processing.process(descfile,
                                       binaries,
                                       objects,
                                       submissions,
                                       headers,
                                       test_to_run), submissions


def do_preprocess_submissions():

    print('''
    Preprocessing might take some time depending on the amount of data
    and the complexity of the programs and the corresponding unit tests. You
    can specify what test you want to run.

    Tests do depend on each other. Therefore specifying a test will also
    result in running all its dependencies.

    The EmptyTest can be run on all submission types. The other tests are very specific
    to the c programming course.
    \n''')

    test_enum = dict(enumerate(util.processing.Test.available_tests()))

    print('The following test are available:\n')
    print('\t[q] Do nothing')
    for j, test in test_enum.items():
        print(f'\t[{j}] {test}')
    print()

    test_index = i('Which tests do you want to run?')

    if not test_index or test_index == 'q':
        return

    test_to_run = test_enum[int(test_index)]

    # processed_submissions = None
    if test_to_run == util.processing.EmptyTest.__name__:
        processed_submissions, submissions = _do_check_empty_submissions()
    else:
        processed_submissions, submissions = _do_preprocess_c_submissions(test_to_run)

    output_f = i('And everything is done. Where should I put the results?',
                 f'{submissions.rsplit(".")[0]}.processed.json')

    with open(output_f, 'w+') as outfile:
        json.dump(processed_submissions, outfile,
                  sort_keys=True, indent=4)
    info('Wrote processed data to %s' % os.path.join(os.curdir, output_f))


def do_load_submissions():

    file = i('Get me the file with all the submissions',
             'submissions.json', is_file=True)

    if not ExamType.objects.all():
        raise Exception('Modules need to be loaded before submissions.')
    else:
        exam_query_set = ExamType.objects.all()
        print('Please select the corresponding module')
        print('You have the following choices:\n')
        for j, exam_type in enumerate(exam_query_set):
            print(f'\t[{j}] {exam_type.module_reference}')
        print()

        exam_prompt_key = i('Choose wisely')
        exam_obj = {'exam': exam_query_set[int(exam_prompt_key)]}

    with open(file) as exam_data_file:
        exam_data = json.JSONDecoder().decode(exam_data_file.read())

    for student in exam_data['students']:
        student_obj = user_factory.make_student(**exam_obj,
                                                **student).student
        for submission_obj in student['submissions']:
            add_submission(student_obj, **submission_obj)


def do_load_tutors():

    print('Please import tutor users by providing one name per line')
    tutors = i('List of tutors', 'tutors', is_file=True)

    with open(tutors) as tutors_f:
        for tutor in tutors_f:
            if len(tutor.strip()) > 0:
                user_factory.make_tutor(tutor.strip(), store_pw=True)


def do_load_reviewer():

    print('Please import reviewer users by providing one name per line')
    reviewers = i('List of reviewers', 'reviewers', is_file=True)

    with open(reviewers) as reviewers_f:
        for reviewer in reviewers_f:
            user_factory.make_reviewer(reviewer.strip(),
                                       is_staff=True,
                                       store_pw=True)


call_order = (
    do_load_submission_types,
    do_load_module_descriptions,
    do_preprocess_submissions,
    do_load_submissions,
    do_load_tutors,
    do_load_reviewer
)


def start():

    if os.path.exists(HISTFILE):
        readline.read_history_file(HISTFILE)

    print(WELCOME + '''

    Welcome to the Grady import script!

    This script aims at making the setup of the database as easy as possible.
    At the same time it serves as a documentation on how data is imported into
    Grady. Let\'s dive right in.\n''')

    try:
        print('The following sub importers are available:\n')
        for fid, func in enumerate(call_order):
            print(f'\t[{fid}] {func.__name__}')
        print('\t[q] exit')
        print()

        fid = i('Choose a number or hit enter to start at the beginning')

        if not fid:
            for func in call_order:
                call_loader(func)
        elif fid in ('q', 'quit', 'exit'):
            return
        elif not 0 <= int(fid) < len(call_order):
            warn('There is no loader with this number')
        else:
            call_loader(call_order[int(fid)])

    except (EOFError, KeyboardInterrupt):
        print()
        return
    except FileNotFoundError:
        raise
    except Exception:
        import traceback
        traceback.print_exc()
    finally:
        readline.write_history_file(HISTFILE)