Refactoring

Samo Penic

2018-10-26 6c22453d5ac25fc5243e07e82dcb143efe7ea5fd

Refactoring

 GenerateTests.py

@@ -1,5 +1,5 @@
from tools.BerkiParse import BerkiParse
from tools.Problem import Problem
from tools.Problem import ProblemSource, Problem


if __name__ == "__main__":
@@ -15,10 +15,10 @@

    parser=BerkiParse(naloge[0][1])
    parser.parseSections()
    n = Problem(parser=parser)
    n = ProblemSource(parser=parser)

    print(n.parsedVariables)
    print(n.parsedSolutions)
#    print(n.parsedVariables)
#    print(n.parsedSolutions)
#    for i in range(0,5):
#        print(next(n.variableGenerator['d']))
    """
@@ -27,4 +27,7 @@
        for var in n.varDict.values():
            print( var )
    """
    print(n.generate_tex())

    for i in range(0,5):
        p= Problem(n)
        print(p.problem)

 tools/Problem.py

@@ -1,10 +1,20 @@
from .BerkiParse import BerkiParse
from .Formatter import Variable
from .Variable import Variable
import re
from math import *


class Problem:
    def __init__(self, source=None):
        self.source=source
        self.source.generateVariables()
        self.source.generateSolutions()
        self.problem=self.source.generateProblem()

    def toTexFormatterDict(self):
        pass


class ProblemSource:
    def __init__(self, parser=None):
        self.introduction = None
        self.subproblems = None
@@ -16,7 +26,7 @@
            self.introduction, self.subproblems, self.parsedVariables, self.parsedSolutions, self.variableGenerator = (
                parser.get_parsed_sections()
            )
            self.generateVariables()
            #self.generateVariables()

    def generateVariables(self):
        for key in self.parsedVariables:
@@ -25,7 +35,34 @@
            )

    def generateSolutions(self):
        pass
        # a dirty one but it has to be like this ;)
        __retsol = []

        # define variables
        for __varname, __var in self.varDict.items():
            exec(__varname + "=" + str(__var.get_formatted_value()))
        for __s in self.parsedSolutions:
            __ps = {}
            __ps["correct"] = []
            __ps["wrong"] = []
            for __corr in __s["correct"]:
                for __corrsplit in __corr.split(";"):
                    if __corrsplit.find("=") >= 0:
                        exec(self.substitute_octave(__corrsplit))
                    else:
                        __result = eval(self.substitute_octave(__corrsplit))
                __ps["correct"].append(Variable(__result, formatting=__s["type"]))
            for __corr in __s["wrong"]:
                for __corrsplit in __corr.split(";"):
                    if __corrsplit.find("=") >= 0:
                        exec(self.substitute_octave(__corrsplit))
                    else:
                        __result = eval(self.substitute_octave(__corrsplit))
                __ps["wrong"].append(Variable(__result, formatting=__s["type"]))
            __ps['glyph']=__s['glyph']
            __ps['unit']=__s['unit']
            __retsol.append(__ps)
        return __retsol

    def isMultiProblem(self):
        if len(self.subproblems) > 0:
@@ -43,46 +80,17 @@
        text = re.sub(";", "\n", text)
        return text

    def solve(self):
        # a dirty one but it has to be like this ;)
        __retsol = []

        # define variables
        for __varname, __var in self.varDict.items():
            exec(__varname + "=" + str(__var.get_formatted_value()))
        for __s in self.parsedSolutions:
            __ps = {}
            __ps["correct"] = []
            __ps["wrong"] = []
            # for __s in self.parsedSolutions:
            for __corr in __s["correct"]:
                for __corrsplit in __corr.split(";"):
                    if __corrsplit.find("=") >= 0:
                        exec(self.substitute_octave(__corrsplit))
                    else:
                        __result = eval(self.substitute_octave(__corrsplit))
                __ps["correct"].append(Variable(__result, formatting=__s["type"]))
            for __corr in __s["wrong"]:
                for __corrsplit in __corr.split(";"):
                    if __corrsplit.find("=") >= 0:
                        exec(self.substitute_octave(__corrsplit))
                    else:
                        __result = eval(self.substitute_octave(__corrsplit))
                __ps["wrong"].append(Variable(__result, formatting=__s["type"]))
            __retsol.append(__ps)
        return __retsol

    def generate_tex(self, shuffle=True):
    def generateProblem(self, shuffle=True):
        intro = self.substitute_variables(self.introduction)
        sp = []
        for p in self.subproblems:
            sp.append(self.substitute_variables(p))
        sol = self.solve()
        sol = self.generateSolutions()
        soltex = []
        for s in sol:
            entry = {
                "correct": [i.format_as_tex() for i in s["correct"]],
                "wrong": [i.format_as_tex() for i in s["wrong"]],
                "correct": [("${}={}\mathrm{{{}}}$").format(s['glyph'], i.format_as_tex(), s['unit']) for i in s["correct"]],
                "wrong": [("${}={}\mathrm{{{}}}$").format(s['glyph'], i.format_as_tex(), s['unit']) for i in s["wrong"]],
            }
            soltex.append(entry)
        return intro, sp, soltex

 tools/Variable.py

 tools/tests/formatter_test.py

@@ -1,5 +1,5 @@
import unittest
from tools import Formatter
from tools import Variable


class FormatTest(unittest.TestCase):
@@ -7,7 +7,7 @@
        exception_cases = [None, "hello"]
        exception_results = [ValueError, ValueError]

        sci2 = Formatter.FormatterFactory().get_formatter("sci 2")
        sci2 = Variable.FormatterFactory().get_formatter("sci 2")
        for case, result in zip(exception_cases, exception_results):
            with self.assertRaises(result):
                sci2.toFormat(case)
@@ -55,11 +55,11 @@
            "0.00 \cdot 10^{0}",
        ]

        sci2 = Formatter.FormatterFactory().get_formatter("sci 2")
        sci2 = Variable.FormatterFactory().get_formatter("sci 2")
        for case, result in zip(testcases, sci2_solutions):
            self.assertEqual(result, sci2.toFormat(case))

        sci3 = Formatter.FormatterFactory().get_formatter("sci 3")
        sci3 = Variable.FormatterFactory().get_formatter("sci 3")
        for case, result in zip(testcases, sci3_solutions):
            self.assertEqual(result, sci3.toFormat(case))

@@ -119,10 +119,10 @@
            0
        ]
        for case, result in zip(testcases, sci2_solutions):
            self.assertEqual(result, Formatter.Variable(case, "sci 2").format_as_tex())
            self.assertEqual(result, Variable.Variable(case, "sci 2").format_as_tex())

        for case, result in zip(testcases, sci3_solutions):
            self.assertEqual(result, Formatter.Variable(case, "sci 3").format_as_tex())
            self.assertEqual(result, Variable.Variable(case, "sci 3").format_as_tex())

        for case, result in zip(testcases, sci2_rounded):
            self.assertEqual(result, Formatter.Variable(case, 'sci 2').get_formatted_value())
            self.assertEqual(result, Variable.Variable(case, 'sci 2').get_formatted_value())