Finished exam formation. No pictures though.

Samo Penic

2018-11-02 7224afe17c3a58585da08e47179a29952186177e

Finished exam formation. No pictures though.

 GenerateTests.py

@@ -1,28 +1,23 @@
from tools.BerkiParse import BerkiParse
from tools.Problem import ProblemSource, Problem
from tools.Template import TemplateEngine
from tools.Paper import Paper
from tools.Exam import Exam


if __name__ == "__main__":
    from glob import glob

    # THIS IS TO BE READ FROM THE DATABASE
    filelist = glob("testcases/*")
    naloge = []
    for i, f in enumerate(filelist):
        with open(f) as fd:
            cont = fd.read()
        naloge.append((i, cont))
    source=[]
    for nal in naloge:
        par=BerkiParse(nal[1])
        par.parseSections()
        source.append(ProblemSource(parser=par))

    problems=[]
    for src in source:
        problems.append(Problem(src))
    # from glob import glob
    #
    # # THIS IS TO BE READ FROM THE DATABASE
    # filelist = glob("testcases/*")
    # naloge = []
    # for i, f in enumerate(filelist):
    #     with open(f) as fd:
    #         cont = fd.read()
    #     naloge.append((i, cont))
    # source=[]
    # for nal in naloge:
    #     par=BerkiParse(nal[1])
    #     par.parseSections()
    #     source.append(ProblemSource(parser=par))

    settings = {
        'exam_title': "Naslov izpita",
@@ -34,9 +29,16 @@
        'start_number': 100,
        'sid_prefill': "11x0xxxx", }

    paper=Paper(problems, settings=settings)
    text=paper.generate_full()
    print(text)
    student_list=[
        ("64990162", "Samo Penic"),
    ]

    exam=Exam(settings=settings, student_list=student_list, number_of_papers=5)
    exam.loadProblemsFromDirectory("testcases/*.txt")
    exam.generatePapers()
    text=exam.exam_to_template()
    #print(text)
    exam_matrix=exam.get_answers()
    print(exam_matrix)
    with open('preverjanje.tex','w') as problem_fd:
        problem_fd.write(text)

 tools/Exam.py

New file
@@ -0,0 +1,120 @@
from tools.BerkiParse import BerkiParse
from tools.Problem import ProblemSource, Problem
from tools.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_source in self.problem_source_list:
            self.problem_list.append(Problem(problem_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 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 in self.problem_list:
            for solution in problem.problem["solutions"]:
                retval.append([i[1] for i in solution["shuffled"]])
        return retval


class Exam:
    def __init__(
        self, settings, problem_source_list=None, number_of_papers=5, student_list=None
    ):
        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_list = None
        self.template = TemplateEngine("tools/textemplates")

    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 nal in files:
            par = Parser(nal[1])
            par.parseSections()
            self.problem_source_list.append(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

 tools/Paper.py

File was deleted

 tools/Problem.py

@@ -28,9 +28,7 @@
                        self.problem["solutions"]
                    )
                except Exceptions.AnswerProximityError:
                    self.source.generateVariables()
                    self.source.generateSolutions()
                    self.problem = self.source.generateProblem()
                    self.regenerate()
                    continue
                else:
                    break
@@ -40,6 +38,11 @@
                    + self.problem["introduction"]
                )

    def regenerate(self):
        self.source.generateVariables()
        self.source.generateSolutions()
        self.problem = self.source.generateProblem()

    def shuffleAnswers(self, solList):
        shuffList = []
        for cont in solList:

 tools/Template.py

@@ -93,6 +93,8 @@

    def start_paper(self, student_id=None, student_name=None):
        if student_id is not None:
            return Template(self.template["paper"]).substitute(student_id, student_name)
            return Template(self.template["paper"]).substitute(
                {"student_id": student_id, "student_name": student_name}
            )
        else:
            return Template(self.template["paper_sid"]).substitute()