import collections
import csv
import os
import readline
import secrets
import sys
import json
from typing import Callable
from django.contrib.auth.models import Group, User
import util.convert
import util.processing
from core.models import Feedback, Student, Submission, SubmissionType, Test
from util.messages import *
from util.processing import EmptyTest
STUDENTS = Group.objects.get(name='Students')
TUTORS = Group.objects.get(name='Tutors')
REVIEWERS = Group.objects.get(name='Reviewers')
HISTFILE = '.importer_history'
RECORDS = '.importer'
YES = 'Y/n'
NO = 'y/N'
valid = {"yes": True, "y": True, "ye": True, "no": False, "n": False}
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):
info(f'Returning to {self.new_dir}')
os.chdir(self.old_dir)
def get_xkcd_password(k=2):
with open('/usr/share/dict/words') as words:
choose_from = list({word.strip().lower()
for word in words if 5 < len(word) < 8})
return ''.join(secrets.choice(choose_from) for _ in range(k))
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):
warn(f'The {"path" if is_path else "file"} does not exist. Please try again.')
return i(prompt, default, is_path, is_file)
return answer
def add_user(username: str, group: str, **kwargs):
""" This is a specific wrapper for the django update_or_create method of
objects.
* A new user is created and password and group are set accordingly
* If the user was there before password is NOT change but group is. A
user must only have one group.
Args:
username (str): the username is the login name
group (str): the (only) group the user should belong to
**kwargs: more attributes for user creation
Returns:
TYPE: Description
"""
user, created = User.objects.update_or_create(
username=username.strip(),
defaults=kwargs
)
if created:
password = get_xkcd_password()
user.set_password(password)
user.save()
user.groups.clear() # remove all other groups
group.user_set.add(user)
return user
def add_student(username, name, matrikel_no, email, **kwargs):
user = add_user(username, STUDENTS, email=email)
student, _ = Student.objects.update_or_create(
name=name,
defaults={'matrikel_no' : matrikel_no, 'user' : user}
)
return student
def add_submission(student_obj, code, tests, type):
submission_type = SubmissionType.objects.get(name=type)
submission_obj, _ = Submission.objects.update_or_create(
type=submission_type,
student=student_obj,
defaults={'text' : code}
)
for name, test_data in tests.items():
test_obj, created = Test.objects.update_or_create(
name=test_data['name'],
submission=submission_obj,
defaults={
'label': test_data['label'],
'annotation': test_data['annotation'],
}
)
if test_obj.name == EmptyTest.__name__ and test_obj.label == EmptyTest.label_failure:
auto_correct, _ = User.objects.update_or_create(username='auto_correct', defaults={'is_active': False})
Feedback.objects.update_or_create(
of_submission=submission_obj,
defaults={
'of_tutor' : auto_correct,
'score' : 0,
'text' : test_obj.label,
'origin' : Feedback.WAS_EMPTY,
'status' : Feedback.ACCEPTED,
}
)
def add_user_list(lst, group, **kwargs):
for name in lst:
add_user(name, group, **kwargs)
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 and not \
i(f'{func.__name__} has already been processed once. Proceed anyway?', NO):
return
func() # This executes the specified loader
with open(RECORDS, 'a') as records_f:
records_f.write(func.__name__)
records_f.write('\n')
def do_convert_xls():
info('[Executing]', sys._getframe().f_code.co_name)
ans = i('''Do you want to convert the ILIAS .xls output to .json?''', YES)
if not ans:
return
infile = i('Please provide the path to the .xls file', is_file=True)
outfile = i('Where should the output go?', 'submissons.json')
json_dict = util.convert.converter(infile)
util.convert.write_to_file(json_dict, outfile)
def do_load_submission_types():
info('[Executing] ', sys._getframe().f_code.co_name)
print('''For the following import you need three files:
1) A .csv file where the columns are: id, name, score
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
''')
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/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)]
for row in csv_rows:
tid, name, score = (col.strip() for col in row)
with \
open(os.path.join(lsg_dir, tid + '-lsg.c'), 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),
}
_, created = SubmissionType.objects.update_or_create(
name=name,
defaults=data
)
info(f'{"Created" if created else "Updated"} {name}')
def do_preprocess_submissions():
info('[Executing] ', sys._getframe().f_code.co_name)
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\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()
answer = i('Which tests do you want to run?')
if not answer or answer == 'q':
return
raise NotImplementedError
def do_load_submissions():
info('[Executing] ', sys._getframe().f_code.co_name)
file = i('Get me the file with all the submissions', 'submissions.json')
with open(file) as submission_file:
submissions = json.JSONDecoder().decode(submission_file.read())
for username, data in submissions.items():
student_obj = add_student(username, **data)
for submission_obj in data['submissions']:
add_submission(student_obj, **submission_obj)
def do_load_tutors():
info('[Executing] ', sys._getframe().f_code.co_name)
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:
add_user_list(tutors_f, TUTORS)
def do_load_reviewer():
info('[Executing] ', sys._getframe().f_code.co_name)
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:
add_user_list(reviewers_f, REVIEWERS, is_staff=True)
call_order = collections.OrderedDict({
0 : do_convert_xls,
1 : do_load_submission_types,
2 : do_preprocess_submissions,
3 : do_load_submissions,
4 : do_load_tutors,
5 : do_load_reviewer
})
def start():
if User.objects.filter(is_superuser=False) :
warn('Warning database is not clean. Aborting.')
if os.path.exists(HISTFILE):
readline.read_history_file(HISTFILE)
print('''Welcome to the Grady importer!
This script aims at making the setup of the database as easy as possible. It
at the same time serves as a documentation on how data is imported in Grady.
Let\'s dive right in.\n''')
try:
print('The following importers are available:\n')
for fid, func in call_order.items():
print(f'\t[{fid}] {func.__name__}')
print()
fid = i('Press enter for all in given order or choose a number')
if fid:
call_loader(call_order[int(fid)])
else:
for func in call_order.values():
call_loader(func)
except (EOFError, KeyboardInterrupt) as err:
return
except Exception as err:
import traceback
traceback.print_exc()
finally:
readline.write_history_file(HISTFILE)