Paper generation without correct answers.

Samo Penic

2018-10-31 5aa5bb4eeb6509cb6b6a08a4e35f0ab6357ddc96

Paper generation without correct answers.

 GenerateTests.py

@@ -1,7 +1,8 @@
from tools.BerkiParse import BerkiParse
from tools.Problem import ProblemSource, Problem
import pprint
from tools.Template import TemplateEngine
from tools.Paper import Paper


if __name__ == "__main__":
    from glob import glob
@@ -19,29 +20,23 @@
        par.parseSections()
        source.append(ProblemSource(parser=par))

    #parser = BerkiParse(naloge[1][1])
    #parser.parseSections()
    #n = ProblemSource(parser=parser)
    t = TemplateEngine("tools/textemplates")

    problems=[]
    for src in source:
        problems.append(Problem(src))
    #   pprint.pprint(p.problem)

    text=""
    text+=t.head(
            exam_title="Naslov izpita",
            date="27.10.2018",
            faculty_name="Fakulteta test",
            sid_prefill="11x0xxxx",
        )
    settings = {
        'exam_title': "Naslov izpita",
        'date': "27.10.2018",
        'faculty_name': "Fakulteta test",
        'faculty_id': 0,
        'exam_id': 0,
        'last_line': "Empty line",
        'start_number': 100,
        'sid_prefill': "11x0xxxx", }

    text+=t.start_paper()
    for p in problems:
        text+=t.put_problem_into_template(p.problem)
    text+=t.tail()

    paper=Paper(problems, settings=settings)
    text=paper.generate_full()
    print(text)

    with open('preverjanje.tex','w') as problem_fd:
        problem_fd.write(text)

 tools/Paper.py

New file
@@ -0,0 +1,60 @@
from tools.BerkiParse import BerkiParse
from tools.Problem import ProblemSource, Problem
from tools.Template import TemplateEngine


class Paper:
    def __init__(self, problem_list, settings, number_of_papers=5, student_list=None):
        self.settings = settings
        self.problem_list = problem_list
        self.student_list = student_list
        self.paper_start = settings["start_number"]
        self.number_of_papers = number_of_papers
        self.paper_iterator = iter(
            range(self.paper_start, self.paper_start + self.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 generate_head(self):
        return self.template.head(settings=self.settings)

    def generate_tail(self):
        return self.template.tail()

    def generate_paper(self):

        try:
            paper_id = next(self.paper_iterator)
        except StopIteration:
            return None

        try:
            student_id = next(self.student_list)
        except (StopIteration, TypeError):
            text = self.template.start_paper()
        else:
            text = self.template.start_paper(student_id[0], 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 generate_full(self):
        text = self.generate_head()
        while True:
            paper = self.generate_paper()
            if paper is None:
                break
            text += paper
        text += self.generate_tail()

        self.text=text
        return text

 tools/README

@@ -58,3 +58,16 @@

4. Znotraj naloge se deklarirane vrednosti pri enem podproblemu lahko uporabijo v naslednjem!



Settings za Paper:
==================
settings={
            'exam_title':"Naslov izpita",
            'date':"27.10.2018",
            'faculty_name':"Fakulteta test",
            'faculty_id':0,
            'exam_id':0,
            'last_line':"Empty line",
            'start_number':100,
            'sid_prefill':"11x0xxxx",}

 tools/Template.py

@@ -27,11 +27,11 @@
            template = fd.read()
        return template

    def put_problem_into_template(self, problem_dict):
    def put_problem_into_template(self, problem_dict, problem_number=0):
        retstr = ""
        if len(problem_dict["solutions"]) > 1:
            retstr += Template(self.template["problem_intro"]).substitute(
                {"problem_number": 0, "text": problem_dict["introduction"]}
                {"problem_number": problem_number, "text": problem_dict["introduction"]}
            )
            for sp, sol in zip(problem_dict["subproblems"], problem_dict["solutions"]):
                retstr += Template(self.template["subproblem"]).substitute(
@@ -55,7 +55,7 @@
        else:
            retstr += Template(self.template["problem"]).substitute(
                {
                    "problem_number": 0,
                    "problem_number": problem_number,
                    "text": problem_dict["introduction"],
                    "ans1": problem_dict["solutions"][0]["shuffled"][0][
                        0
@@ -85,29 +85,8 @@
            )
        return retstr

    def head(
        self,
        faculty_id=0,
        faculty_name="",
        exam_id=0,
        exam_title="Exam",
        date="",
        last_line="",
        sid_prefill="11x0xxxx",
        start_number=0,
    ):
        return Template(self.template["head"]).substitute(
            {
                "faculty_id": faculty_id,
                "exam_id": exam_id,
                "faculty_name": faculty_name,
                "exam_title": exam_title,
                "date": date,
                "last_line": last_line,
                "sid_prefill": sid_prefill,
                "start_number": start_number,
            }
        )
    def head(self, settings):
        return Template(self.template["head"]).substitute(settings)

    def tail(self):
        return """\end{document}"""