from aoi_gen.BerkiParse import BerkiParse
|
from aoi_gen.Problem import ProblemSource, Problem
|
from aoi_gen.Template import TemplateEngine
|
from random import shuffle
|
from glob import glob
|
|
|
class Paper:
|
def __init__(
|
self, problem_source_list, paper_id=None, student_id=None, template=None
|
):
|
self.problem_source_list = problem_source_list
|
self.problem_list = []
|
self.paper_id = paper_id
|
self.student_id = student_id
|
self.template = template
|
self.generate_problems()
|
|
def generate_problems(self, reorder=True):
|
for problem in self.problem_source_list:
|
shuffle(problem['problems'])
|
for i in range(0,problem['amount']):
|
self.problem_list.append((problem['problems'][i]['id'], Problem(problem['problems'][i]['parsed_source'])))
|
if reorder:
|
shuffle(self.problem_list)
|
|
def to_template(self):
|
if self.student_id is None:
|
text = self.template.start_paper()
|
else:
|
text = self.template.start_paper(self.student_id[0], self.student_id[1])
|
|
for i, (problem_id, problem) in enumerate(self.problem_list):
|
text += self.template.put_problem_into_template(
|
problem.problem, problem_number=i + 1
|
)
|
text += "\\vfill\\break"
|
return text
|
|
def get_answer_matrix(self):
|
retval = []
|
for (problem_id,problem) in self.problem_list:
|
for solution in problem.problem["solutions"]:
|
retval.append([i[1] for i in solution["shuffled"]])
|
return retval
|
|
def get_problem_ids(self):
|
retval = []
|
for (problem_id,problem) in self.problem_list:
|
retval.append(problem_id)
|
return retval
|
|
class Exam:
|
def __init__(
|
self, settings, problem_source_list=None, number_of_papers=5, student_list=None, template="aoi_gen/textemplates"
|
):
|
self.settings = settings
|
self.problem_source_list = problem_source_list
|
self.paper_list = []
|
self.student_list = student_list
|
self.paper_start = settings["start_number"]
|
self.number_of_papers = number_of_papers
|
|
if student_list is not None:
|
self.student_iterator = iter(self.student_list)
|
else:
|
self.student_iterator = None
|
self.template = TemplateEngine(template)
|
|
def loadProblemsFromDirectory(self, dir, Parser=None):
|
if Parser is None:
|
Parser = BerkiParse
|
self.problem_source_list = []
|
filelist = glob(dir)
|
files = []
|
for i, f in enumerate(filelist):
|
with open(f) as fd:
|
cont = fd.read()
|
files.append((i, cont))
|
self.problem_source_list = []
|
for i,nal in enumerate(files):
|
par = Parser(nal[1])
|
par.parseSections()
|
self.problem_source_list.append(
|
{
|
'amount': 1,
|
'problems':
|
[
|
{
|
'id': i,
|
'parsed_source': ProblemSource(parser=par)
|
},
|
]
|
})
|
|
def generatePapers(self):
|
for i in range(self.paper_start, self.paper_start + self.number_of_papers):
|
try:
|
student_id = next(self.student_iterator)
|
except (StopIteration, TypeError):
|
student_id = None
|
self.paper_list.append(
|
Paper(
|
self.problem_source_list,
|
paper_id=i,
|
student_id=student_id,
|
template=self.template,
|
)
|
)
|
|
def paper_to_template(self):
|
text = ""
|
for paper in self.paper_list:
|
text += paper.to_template()
|
text += "\\vfill\\break"
|
return text
|
|
def head_to_template(self):
|
return self.template.head(settings=self.settings)
|
|
def tail_to_template(self):
|
return self.template.tail()
|
|
def exam_to_template(self):
|
text = self.head_to_template()
|
text += self.paper_to_template()
|
text += self.tail_to_template()
|
self.text = text
|
return text
|
|
def get_answers(self):
|
retval=[]
|
for paper in self.paper_list:
|
paper_matrix=paper.get_answer_matrix()
|
retval.append(paper_matrix)
|
|
return retval
|
|
def get_problem_ids(self):
|
retval=[]
|
for paper in self.paper_list:
|
paper_ids=paper.get_problem_ids()
|
retval.append(paper_ids)
|
return retval
|
