excel2moodle 0.5.1__py3-none-any.whl → 0.6.0__py3-none-any.whl

excel2moodle/question_types/cloze.py

@@ -1,11 +1,12 @@
-"""Implementation of the cloze question type.
+"""Implementation of tde cloze question type.
 
 This question type is like the NFM but supports multiple fields of answers.
 All Answers are calculated off an equation using the same variables.
 """
 
-import math
+import logging
 import re
+from typing import Literal, overload
 
 import lxml.etree as ET
 
@@ -14,48 +15,156 @@ from excel2moodle.core.globals import (
     Tags,
     TextElements,
 )
-from excel2moodle.core.question import ParametricQuestion
+from excel2moodle.core.question import (
+    ParametricQuestion,
+    Parametrics,
+)
 from excel2moodle.core.settings import Tags
+from excel2moodle.logger import LogAdapterQuestionID
 from excel2moodle.question_types.nfm import NFMQuestionParser
 
+logger = logging.getLogger(__name__)
+
+
+class ClozePart:
+    def __init__(
+        self,
+        question: ParametricQuestion,
+        text: list[str],
+        number: int,
+    ) -> None:
+        self.question = question
+        self.text: ET.Element = self._setupText(text)
+        self.num: int = number
+        if not self.text:
+            msg = f"Answer part for cloze question {self.question.id} is invalid without partText"
+            raise ValueError(msg)
+        self.logger = LogAdapterQuestionID(
+            logger, {"qID": f"{self.question.id}-{self.num}"}
+        )
+        self._typ: Literal["NFM", "MC", "UNSET"]
+        self._element: ET.Element
+        self.result: Parametrics
+
+    @property
+    def clozeElement(self) -> ET.Element:
+        if not hasattr(self, "_clozeElement"):
+            msg = "Cloze Part has no _clozeElement"
+            raise QNotParsedException(msg, f"{self.question.id}-{self.num}")
+        return self._element
+
+    @clozeElement.setter
+    def clozeElement(self, element: ET.Element) -> None:
+        self._element = element
+
+    def updateCloze(self, variant: int = 1) -> None:
+        self.logger.info("Updating cloze to variant %s", variant)
+        if not hasattr(self, "_element"):
+            msg = "Cloze Part has no _clozeElement"
+            raise QNotParsedException(msg, f"{self.question.id}-{self.num}")
+        if self.typ == "MC":
+            self.logger.debug("MC Answer Part already up to date.")
+            return
+        if self.typ == "NFM":
+            result = self.result.getResult(variant)
+            self._element.text = ClozeQuestionParser.getNumericAnsStr(
+                result,
+                self.question.rawData.get(Tags.TOLERANCE),
+                wrongSignCount=self.question.rawData.get(Tags.WRONGSIGNPERCENT),
+                points=self.points,
+            )
+            self.logger.debug("Updated NFM cloze: %s", self._element.text)
+        return
+
+    @property
+    def typ(self) -> Literal["NFM", "MC", "UNSET"]:
+        if not hasattr(self, "_typ"):
+            self.logger.warning("Type not set")
+            return "UNSET"
+        return self._typ
+
+    @typ.setter
+    def typ(self, partType: Literal["NFM", "MC", "UNSET"]) -> None:
+        if not hasattr(self, "_typ"):
+            self._typ = partType
+            self.logger.info("Set type to: %s", self._typ)
+            if self._typ == "NFM":
+                self.result: Parametrics
+            elif self._typ == "MC":
+                self.falseAnswers: list[str] = []
+                self.trueAnswers: list[str] = []
+
+    @property
+    def id(self) -> str:
+        return f"{self.question.id}-{self.num}"
+
+    @property
+    def points(self) -> float:
+        if hasattr(self, "_points"):
+            return self._points
+        return 0.0
+        self.question.logger.error("Invalid call to points of unparsed cloze part")
+        return 0.0
+
+    @points.setter
+    def points(self, points: float) -> None:
+        self._points = points if points > 0 else 0.0
+
+    @property
+    def mcAnswerString(self) -> str:
+        if hasattr(self, "_mcAnswer"):
+            return self._mcAnswer
+        msg = "No MC Answer was set"
+        raise ValueError(msg)
+
+    @mcAnswerString.setter
+    def mcAnswerString(self, answerString: str) -> None:
+        self._mcAnswer: str = answerString
+
+    def _setupText(self, text: list[str]) -> ET.Element:
+        textItem: ET.Element = TextElements.LISTITEM.create()
+        for t in text:
+            textItem.append(TextElements.PLEFT.create())
+            textItem[-1].text = t
+        return textItem
+
+    def __repr__(self) -> str:
+        return f"Cloze Part {self.id}-{self.typ}"
+
 
 class ClozeQuestion(ParametricQuestion):
     """Cloze Question Type."""
 
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
-        self.answerVariants: dict[int, list[float]] = {}
-        self.answerStrings: dict[int, list[str]] = {}
-        self.answerTypes: dict[int, str] = {}
-        self.questionTexts: dict[int, list[ET.Element]] = {}
-        self.partsNum: int = 0
-
-    def _assembleAnswer(self, variant: int = 1) -> None:
-        for part, ans in self.answerVariants.items():
-            result = ans[variant - 1]
-            if self.answerTypes.get(part, None) == "MC":
-                ansStr = ClozeQuestionParser.getMCAnsStr(answers)
-            else:
-                ansStr = ClozeQuestionParser.getNumericAnsStr(
-                    result,
-                    self.rawData.get(Tags.TOLERANCE),
-                    wrongSignCount=self.rawData.get(Tags.WRONGSIGNPERCENT),
-                )
-            ul = TextElements.ULIST.create()
-            item = TextElements.LISTITEM.create()
-            item.text = ansStr
-            ul.append(item)
-            self.questionTexts[part].append(ul)
-            self.logger.debug("Appended Question Parts %s to main text", part)
-            self.questionTexts[part].append(ET.Element("hr"))
-
-    def _assembleText(self, variant=0) -> list[ET.Element]:
-        textParts = super()._assembleText(variant=variant)
-        self.logger.debug("Appending QuestionParts to main text")
-        for paragraphs in self.questionTexts.values():
-            for par in paragraphs:
-                textParts.append(par)
-        return textParts
+        self.questionParts: dict[int, ClozePart] = {}
+        self.questionTexts: list[ET.Element] = []
+        self.parametrics: Parametrics
+
+    @property
+    def partsNum(self) -> int:
+        return len(self.questionParts)
+
+    @property
+    def points(self) -> float:
+        pts: float = 0
+        if self.isParsed:
+            for p in self.questionParts.values():
+                pts = pts + p.points
+        else:
+            pts = self.rawData.get(Tags.POINTS)
+        return pts
+
+    def getUpdatedElement(self, variant: int = 0) -> ET.Element:
+        """Update and get the Question Elements to reflect the version.
+
+        `ClozeQuestion` Updates the text.
+        `ParametricQuestion` updates the bullet points.
+        `Question` returns the element.
+        """
+        for part in self.questionParts.values():
+            part.updateCloze(variant=variant)
+        return super().getUpdatedElement(variant=variant)
 
 
 class ClozeQuestionParser(NFMQuestionParser):
@@ -70,72 +179,128 @@ class ClozeQuestionParser(NFMQuestionParser):
         super().setup(question)
 
     def _parseAnswers(self) -> None:
+        self._setupParts()
         self._parseAnswerParts()
-        self._parseQuestionParts()
 
-    def _parseAnswerParts(self) -> None:
-        """Parse the numeric or MC result items."""
-        self.question.answerTypes: dict[int, str] = {
-            self.getPartNumber(key): self.rawInput[key]
-            for key in self.rawInput
-            if key.startswith(Tags.PARTTYPE)
-        }
-        equations: dict[int, str] = {
-            self.getPartNumber(key): self.rawInput[key]
-            for key in self.rawInput
-            if key.startswith(Tags.RESULT)
-        }
-        self.logger.debug("Got the following answers: %s", equations)
-        bps = str(self.rawInput[Tags.BPOINTS])
-        varNames: list[str] = self._getVarsList(bps)
-        numericAnswers: dict[int, list[float]] = {key: [] for key in equations}
-        self.question.variables, number = self._getVariablesDict(varNames)
-        for n in range(number):
-            self.setupAstIntprt(self.question.variables, n)
-            for ansNum, eq in equations.items():
-                result = self.astEval(eq)
-                if isinstance(result, float):
-                    firstResult = self.rawInput.get(Tags.FIRSTRESULT)
-                    if n == 0 and not math.isclose(result, firstResult, rel_tol=0.01):
-                        self.logger.warning(
-                            "The calculated result %s differs from given firstResult: %s",
-                            result,
-                            firstResult,
-                        )
-                    numericAnswers[ansNum].append(result)
+    def _setupParts(self) -> None:
+        parts: dict[int, ClozePart] = {}
+        for key in self.rawInput:
+            if key.startswith(Tags.QUESTIONPART):
+                partNumber = self.getPartNumber(key)
+                parts[partNumber] = ClozePart(
+                    self.question, self.rawInput[key], partNumber
+                )
+        partsNum = len(parts)
+        equations: dict[int, str] = self._getPartValues(Tags.RESULT)
+        trueAnsws: dict[int, list[str]] = self._getPartValues(Tags.TRUE)
+        falseAnsws: dict[int, list[str]] = self._getPartValues(Tags.FALSE)
+        points: dict[int, float] = self._getPartValues(Tags.POINTS)
+        firstResult: dict[int, float] = self._getPartValues(Tags.FIRSTRESULT)
+        for num, part in parts.items():
+            loclogger = LogAdapterQuestionID(
+                logger, {"qID": f"{self.question.id}-{num}"}
+            )
+            eq = equations.get(num)
+            trueAns = trueAnsws.get(num)
+            falseAns = falseAnsws.get(num)
+            if falseAns is not None and trueAns is not None and eq is None:
+                loclogger.info("Setting up MC answer part...")
+                part.typ = "MC"
+                part.falseAnswers = falseAns
+                part.trueAnswers = trueAns
+            elif eq is not None and falseAns is None and trueAns is None:
+                loclogger.info("Seting up NFM part..")
+                if not hasattr(self.question, "parametrics"):
+                    loclogger.info("Adding new Parametrics Object to cloze question")
+                    self.question.parametrics = Parametrics(
+                        equation=eq,
+                        firstResult=firstResult.get(num, 0.0),
+                        identifier=f"{self.question.id}-{num}",
+                    )
                 else:
-                    msg = f"The expression {eq} could not be evaluated."
-                    raise QNotParsedException(msg, self.question.id)
-
-        self.question.answerVariants = numericAnswers
-        self._setVariants(number)
+                    loclogger.info("Adding new equation to parametrics")
+                    self.question.parametrics.equations[num] = eq
+                    self.question.parametrics._resultChecker[num] = firstResult.get(
+                        num, 0.0
+                    )
+                if not hasattr(part, "result"):
+                    part.result = self.question.parametrics
+                part.typ = "NFM"
+                loclogger.info("Set up NFM answer part.")
+            else:
+                msg = f"Unclear Parts are defined. Either define `true:{num}` and `false:{num}` or `result:{num}` "
+                raise QNotParsedException(msg, self.question.id)
+        if len(points) == 0:
+            pts = round(self.rawInput.get(Tags.POINTS) / partsNum, 3)
+            for part in parts.values():
+                part.points = pts
+        elif len(points) != partsNum:
+            logger.warning(
+                "Some Answer parts are missing the points, they will get the standard points"
+            )
+            for num, part in parts.items():
+                p = points.get(num)
+                part.points = p if p is not None else self.rawInput.get(Tags.POINTS)
+        self.question.questionParts = parts
 
-    def _parseQuestionParts(self) -> None:
-        """Generate the question parts aka the clozes."""
-        parts: dict[int, list[str]] = {
+    @overload
+    def _getPartValues(self, Tag: Literal[Tags.RESULT]) -> dict[int, str]: ...
+    @overload
+    def _getPartValues(
+        self, Tag: Literal[Tags.POINTS, Tags.FIRSTRESULT]
+    ) -> dict[int, float]: ...
+    @overload
+    def _getPartValues(
+        self, Tag: Literal[Tags.TRUE, Tags.FALSE]
+    ) -> dict[int, list[str]]: ...
+    def _getPartValues(self, Tag):
+        tagValues: dict = {
             self.getPartNumber(key): self.rawInput[key]
             for key in self.rawInput
-            if key.startswith(Tags.QUESTIONPART)
+            if key.startswith(Tag)
         }
-        questionParts: dict[int, list[ET.Element]] = {}
-        for number, text in parts.items():
-            questionParts[number] = []
-            for t in text:
-                questionParts[number].append(TextElements.PLEFT.create())
-                questionParts[number][-1].text = t
-        self.logger.debug("The Question Parts are created:", questionParts)
-        self.question.questionTexts = questionParts
-        self.question.partsNum = len(questionParts)
-        self.logger.info("The Question has %s parts", self.question.partsNum)
-
-    # def setMainText(self) -> None:
-    #     super().setMainText()
-    #     self.question.qtextParagraphs
+        return tagValues
+
+    def _parseAnswerParts(self) -> None:
+        """Parse the numeric or MC result items."""
+        answersList = ET.Element("ol")
+        self.question.parametrics.variables = self.question.bulletList.getVariablesDict(
+            self.question
+        )
+        for partNum, part in self.question.questionParts.items():
+            if part.typ == "NFM":
+                result = self.question.parametrics.getResult(1, partNum)
+                ansStr = self.getNumericAnsStr(
+                    result,
+                    self.rawInput.get(Tags.TOLERANCE),
+                    wrongSignCount=self.rawInput.get(Tags.WRONGSIGNPERCENT),
+                    points=part.points,
+                )
+                self.logger.info("NF answer part: %s ", ansStr)
+                logger.debug("Appended NF part %s result", partNum)
+            elif part.typ == "MC":
+                ansStr = self.getMCAnsStr(
+                    part.trueAnswers, part.falseAnswers, points=part.points
+                )
+                part.mcAnswerString = ansStr
+                logger.debug("Appended MC part %s: %s", partNum, ansStr)
+            else:
+                msg = "Type of the answer part is invalid"
+                raise QNotParsedException(msg, self.id)
+            unorderedList = TextElements.ULIST.create()
+            answerItem = TextElements.LISTITEM.create()
+            answerItem.text = ansStr
+            part.clozeElement = answerItem
+            unorderedList.append(answerItem)
+            part.text.append(unorderedList)
+            self.logger.debug("Appended part %s %s to main text", partNum, part)
+            answersList.append(part.text)
+        self.htmlRoot.append(answersList)
 
     def getPartNumber(self, indexKey: str) -> int:
         """Return the number of the question Part.
 
-        The number should be given after the `@` sign.
+        The number should be given after the `:` colon.
         This is number is used, to reference the question Text
         and the expected answer fields together.
         """
@@ -151,7 +316,7 @@ class ClozeQuestionParser(NFMQuestionParser):
     def getNumericAnsStr(
         result: float,
         tolerance: float,
-        weight: int = 1,
+        points: float = 1,
         wrongSignCount: int = 50,
         wrongSignFeedback: str = "your result has the wrong sign (+-)",
     ) -> str:
@@ -159,12 +324,6 @@ class ClozeQuestionParser(NFMQuestionParser):
 
         Parameters.
         ----------
-        weight:
-            The weight of the answer relative to the other answer elements.
-            Of one answer has `weight=2` and two other answers `weight=1`,
-            this answer will be counted as 50% of the questions points.
-            The other two will counted as 25% of the questions points.
-
         wrongSignCount:
             If the wrong sign `+` or `-` is given, how much of the points should be given.
             Interpreted as percent.
@@ -175,7 +334,7 @@ class ClozeQuestionParser(NFMQuestionParser):
         absTol = f":{round(result * tolerance, 3)}"
         answerParts: list[str | float] = [
             "{",
-            weight,
+            points,
             ":NUMERICAL:=",
             round(result, 3),
             absTol,
@@ -194,14 +353,21 @@ class ClozeQuestionParser(NFMQuestionParser):
     def getMCAnsStr(
         true: list[str],
         false: list[str],
-        weight: int = 1,
+        points: float = 1,
     ) -> str:
         """Generate the answer string for the MC answers."""
+        truePercent: float = round(100 / len(true), 1)
+        falsePercent: float = round(100 / len(false), 1)
+        falseList: list[str] = [f"~%-{falsePercent}%{ans}" for ans in false]
+        trueList: list[str] = [f"~%{truePercent}%{ans}" for ans in true]
         answerParts: list[str | float] = [
             "{",
-            weight,
-            ":MC:",
-            "}",
+            points,
+            ":MULTIRESPONSE:",
         ]
+        answerParts.extend(trueList)
+        answerParts.extend(falseList)
+        answerParts.append("}")
+
         answerPStrings = [str(part) for part in answerParts]
-        return "".join(answerPString)
+        return "".join(answerPStrings)

excel2moodle/question_types/nfm.py

@@ -1,23 +1,16 @@
 """Numerical question multi implementation."""
 
-import math
-import re
 from types import UnionType
-from typing import TYPE_CHECKING, ClassVar
+from typing import ClassVar
 
-from asteval import Interpreter
+import lxml.etree as ET
 
-from excel2moodle.core import stringHelpers
-from excel2moodle.core.exceptions import QNotParsedException
 from excel2moodle.core.globals import (
     Tags,
     XMLTags,
 )
 from excel2moodle.core.parser import QuestionParser
-from excel2moodle.core.question import ParametricQuestion
-
-if TYPE_CHECKING:
-    import lxml.etree as ET
+from excel2moodle.core.question import ParametricQuestion, Parametrics
 
 
 class NFMQuestion(ParametricQuestion):
@@ -28,107 +21,53 @@ class NFMQuestion(ParametricQuestion):
 
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
-        self.answerVariants: list[ET.Element]
+        self.answerElement: ET.Element
+
+    def getUpdatedElement(self, variant: int = 1) -> ET.Element:
+        """Update and get the Question Elements to reflect the version.
 
-    def _assembleAnswer(self, variant: int = 1) -> None:
-        prevAnsElement = self.element.find(XMLTags.ANSWER)
-        if prevAnsElement is not None:
-            self.element.remove(prevAnsElement)
-            self.logger.debug("removed previous answer element")
-        self.element.insert(5, self.answerVariants[variant - 1])
+        `NFMQuestion` updates the answer Elements.
+        `ParametricQuestion` updates the bullet points.
+        `Question` returns the Element.
+        """
+        result = self.parametrics.getResult(variant)
+        tolerance = round(self.rawData.get(Tags.TOLERANCE) * result, 3)
+        self.answerElement.find(XMLTags.TEXT).text = str(result)
+        self.answerElement.find(XMLTags.TOLERANCE).text = str(tolerance)
+        return super().getUpdatedElement(variant)
 
 
 class NFMQuestionParser(QuestionParser):
-    astEval = Interpreter(with_import=True)
-
     def __init__(self) -> None:
         super().__init__()
         self.genFeedbacks = [XMLTags.GENFEEDB]
         self.question: NFMQuestion
-        module = self.settings.get(Tags.IMPORTMODULE)
-        if module and not type(self).astEval.symtable.get(module):
-            type(self).astEval(f"import {module}")
-            self.logger.warning("Imported '%s' to Asteval symtable", module)
 
     def setup(self, question: NFMQuestion) -> None:
         self.question: NFMQuestion = question
         super().setup(question)
-
-    def _parseAnswers(self) -> None:
-        equation = self.rawInput.get(Tags.EQUATION)
-        bps = self.rawInput.get(Tags.BPOINTS)
-        ansElementsList: list[ET.Element] = []
-        varNames: list[str] = self._getVarsList(bps)
-        self.question.variables, number = self._getVariablesDict(varNames)
-        for n in range(number):
-            type(self).setupAstIntprt(self.question.variables, n)
-            result = type(self).astEval(equation)
-            if isinstance(result, float):
-                firstResult = self.rawInput.get(Tags.FIRSTRESULT)
-                if n == 0 and not math.isclose(result, firstResult, rel_tol=0.01):
-                    self.logger.warning(
-                        "The calculated result %s differs from given firstResult: %s",
-                        result,
-                        firstResult,
-                    )
-                ansElementsList.append(
-                    self.getNumericAnsElement(result=round(result, 3)),
-                )
-            else:
-                msg = f"The expression {equation} could not be evaluated."
-                raise QNotParsedException(msg, self.question.id)
-        self.question.answerVariants = ansElementsList
-        self._setVariants(len(ansElementsList))
-
-    def _setVariants(self, number: int) -> None:
-        self.question.variants = number
-        mvar = self.question.category.maxVariants
-        if mvar is None:
-            self.question.category.maxVariants = number
-        else:
-            self.question.category.maxVariants = min(number, mvar)
-
-    @classmethod
-    def setupAstIntprt(cls, var: dict[str, list[float | int]], index: int) -> None:
-        """Setup the asteval Interpreter with the variables."""
-        for name, value in var.items():
-            cls.astEval.symtable[name] = value[index]
-
-    def _getVariablesDict(self, keyList: list) -> tuple[dict[str, list[float]], int]:
-        """Read variabel values for vars in `keyList` from `question.rawData`.
-
-        Returns
-        -------
-        A dictionary containing a list of values for each variable
-        The number of values for each variable
-
-        """
-        dic: dict = {}
-        num: int = 0
-        for k in keyList:
-            val = self.rawInput[k.lower()]
-            if isinstance(val, str):
-                li = stringHelpers.getListFromStr(val)
-                num = len(li)
-                variables: list[float] = [float(i.replace(",", ".")) for i in li]
-                dic[str(k)] = variables
-            else:
-                dic[str(k)] = [str(val)]
-                num = 1
-        self.logger.debug("The following variables were provided: %s", dic)
-        return dic, num
-
-    @staticmethod
-    def _getVarsList(bps: str | list[str]) -> list:
-        """Durchsucht den bulletPoints String nach den Variablen ``{var}``.
-
-        It only finds variables after the ``=`` sign, to not catch LaTex.
-        """
-        varNames = []
-        regexFinder = re.compile(r"=\s*\{(\w+)\}")
-        if isinstance(bps, list):
-            for _p in bps:
-                varNames.extend(regexFinder.findall(str(_p)))
-        else:
-            varNames = regexFinder.findall(str(bps))
-        return varNames
+        module = self.settings.get(Tags.IMPORTMODULE)
+        if module and Parametrics.astEval.symtable.get(module, None) is None:
+            Parametrics.astEval(f"import {module}")
+            imported = Parametrics.astEval.symtable.get(module)
+            self.logger.warning("Imported '%s' to Asteval symtable.", module)
+
+    def _parseAnswers(self) -> list[ET.Element]:
+        variables = self.question.bulletList.getVariablesDict(self.question)
+        self.question.parametrics = Parametrics(
+            self.rawInput.get(Tags.EQUATION),
+            self.rawInput.get(Tags.FIRSTRESULT),
+            self.question.id,
+        )
+        self.question.parametrics.variables = variables
+        self.question.answerElement = self.getNumericAnsElement()
+        return [self.question.answerElement]
+
+    # TODO: @jbosse3: Implement a new _setVariants() method, to show in treewidget
+    # def _setVariants(self, number: int) -> None:
+    #     self.question.variants = number
+    #     mvar = self.question.category.maxVariants
+    #     if mvar is None:
+    #         self.question.category.maxVariants = number
+    #     else:
+    #         self.question.category.maxVariants = min(number, mvar)