excel2moodle 0.4.1__py3-none-any.whl → 0.4.3__py3-none-any.whl

excel2moodle/question_types/cloze.py

@@ -0,0 +1,207 @@
+"""Implementation of the 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 re
+
+import lxml.etree as ET
+
+from excel2moodle.core.exceptions import QNotParsedException
+from excel2moodle.core.globals import (
+    Tags,
+    TextElements,
+)
+from excel2moodle.core.question import ParametricQuestion
+from excel2moodle.core.settings import Tags
+from excel2moodle.question_types.nfm import NFMQuestionParser
+
+
+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 _setAnswerElement(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 _assembleMainTextParts(self, variant=0) -> list[ET.Element]:
+        textParts = super()._assembleMainTextParts(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
+
+
+class ClozeQuestionParser(NFMQuestionParser):
+    """Parser for the cloze question type."""
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.question: ClozeQuestion
+
+    def setup(self, question: ClozeQuestion) -> None:
+        self.question: ClozeQuestion = question
+        super().setup(question)
+
+    def _parseAnswers(self) -> None:
+        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)
+                else:
+                    msg = f"The expression {eq} could not be evaluated."
+                    raise QNotParsedException(msg, self.question.id)
+
+        self.question.answerVariants = numericAnswers
+        self._setVariants(number)
+
+    def _parseQuestionParts(self) -> None:
+        """Generate the question parts aka the clozes."""
+        parts: dict[int, list[str]] = {
+            self.getPartNumber(key): self.rawInput[key]
+            for key in self.rawInput
+            if key.startswith(Tags.QUESTIONPART)
+        }
+        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
+
+    def getPartNumber(self, indexKey: str) -> int:
+        """Return the number of the question Part.
+
+        The number should be given after the `@` sign.
+        This is number is used, to reference the question Text
+        and the expected answer fields together.
+        """
+        try:
+            num = re.findall(r":(\d+)$", indexKey)[0]
+        except IndexError:
+            msg = f"No :i question Part value given for {indexKey}"
+            raise QNotParsedException(msg, self.question.id)
+        else:
+            return int(num)
+
+    @staticmethod
+    def getNumericAnsStr(
+        result: float,
+        tolerance: float,
+        weight: int = 1,
+        wrongSignCount: int = 50,
+        wrongSignFeedback: str = "your result has the wrong sign (+-)",
+    ) -> str:
+        """Generate the answer string from `result`.
+
+        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.
+        tolerance:
+            The relative tolerance, as fraction
+
+        """
+        absTol = f":{round(result * tolerance, 3)}"
+        answerParts: list[str | float] = [
+            "{",
+            weight,
+            ":NUMERICAL:=",
+            round(result, 3),
+            absTol,
+            "~%",
+            wrongSignCount,
+            "%",
+            round(result * (-1), 3),
+            absTol,
+            f"#{wrongSignFeedback}",
+            "}",
+        ]
+        answerPStrings = [str(part) for part in answerParts]
+        return "".join(answerPStrings)
+
+    @staticmethod
+    def getMCAnsStr(
+        true: list[str],
+        false: list[str],
+        weight: int = 1,
+    ) -> str:
+        """Generate the answer string for the MC answers."""
+        answerParts: list[str | float] = [
+            "{",
+            weight,
+            ":MC:",
+            "}",
+        ]
+        answerPStrings = [str(part) for part in answerParts]
+        return "".join(answerPString)

excel2moodle/question_types/mc.py

@@ -1,21 +1,22 @@
 """Multiple choice Question implementation."""
 
+from types import UnionType
 from typing import ClassVar
 
 import lxml.etree as ET
 
 import excel2moodle.core.etHelpers as eth
 from excel2moodle.core import stringHelpers
-from excel2moodle.core.exceptions import InvalidFieldException
+from excel2moodle.core.exceptions import InvalidFieldException, QNotParsedException
 from excel2moodle.core.globals import (
-    DFIndex,
+    Tags,
     TextElements,
     XMLTags,
     feedbackStr,
 )
 from excel2moodle.core.parser import QuestionParser
 from excel2moodle.core.question import Picture, Question
-from excel2moodle.core.settings import SettingsKey
+from excel2moodle.core.settings import Tags
 
 
 class MCQuestion(Question):
@@ -28,6 +29,12 @@ class MCQuestion(Question):
         "showstandardinstruction": "0",
         "shownumcorrect": "",
     }
+    mcOpt: ClassVar[dict[Tags, type | UnionType]] = {}
+    mcMand: ClassVar[dict[Tags, type | UnionType]] = {
+        Tags.TRUE: str,
+        Tags.FALSE: str,
+        Tags.ANSTYPE: str,
+    }
 
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
@@ -89,32 +96,35 @@ class MCQuestionParser(QuestionParser):
                     elementList[-1].append(self.trueImgs[i].element)
         return elementList
 
-    def setAnswers(self) -> list[ET.Element]:
-        self.answerType = self.rawInput[DFIndex.ANSTYPE]
-        true = stringHelpers.getListFromStr(self.rawInput[DFIndex.TRUE])
-        false = stringHelpers.getListFromStr(self.rawInput[DFIndex.FALSE])
+    def _parseAnswers(self) -> list[ET.Element]:
+        self.answerType = self.rawInput.get(Tags.ANSTYPE)
         if self.answerType not in self.question.AnsStyles:
             msg = f"The Answer style: {self.answerType} is not supported"
-            raise InvalidFieldException(msg, self.question.id, DFIndex.ANSTYPE)
+            raise InvalidFieldException(msg, self.question.id, Tags.ANSTYPE)
         if self.answerType == "picture":
-            f = self.settings.get(SettingsKey.PICTUREFOLDER)
+            f = self.settings.get(Tags.PICTUREFOLDER)
             imgFolder = (f / self.question.katName).resolve()
-            w = self.settings.get(SettingsKey.ANSPICWIDTH)
+            w = self.settings.get(Tags.ANSPICWIDTH)
             self.trueImgs: list[Picture] = [
-                Picture(t, imgFolder, self.question.id, width=w) for t in true
+                Picture(t, imgFolder, self.question.id, width=w)
+                for t in self.rawInput.get(Tags.TRUE)
             ]
             self.falseImgs: list[Picture] = [
-                Picture(t, imgFolder, self.question.id, width=w) for t in false
+                Picture(t, imgFolder, self.question.id, width=w)
+                for t in self.rawInput.get(Tags.FALSE)
             ]
-            trueAnsList: list[str] = [pic.htmlTag for pic in self.trueImgs]
-            falseAList: list[str] = [pic.htmlTag for pic in self.falseImgs]
+            trueAnsList: list[str] = [pic.htmlTag for pic in self.trueImgs if pic.ready]
+            falseAList: list[str] = [pic.htmlTag for pic in self.falseImgs if pic.ready]
+            if len(trueAnsList) == 0 or len(falseAList) == 0:
+                msg = "No Answer Pictures could be found"
+                raise QNotParsedException(msg, self.question.id)
         else:
             trueAnsList: list[str] = stringHelpers.texWrapper(
-                true, style=self.answerType
+                self.rawInput.get(Tags.TRUE), style=self.answerType
             )
             self.logger.debug(f"got the following true answers \n {trueAnsList=}")
             falseAList: list[str] = stringHelpers.texWrapper(
-                false, style=self.answerType
+                self.rawInput.get(Tags.FALSE), style=self.answerType
             )
             self.logger.debug(f"got the following false answers \n {falseAList=}")
         truefrac = 1 / len(trueAnsList) * 100

excel2moodle/question_types/nf.py

@@ -1,9 +1,12 @@
 """Numerical question implementation."""
 
+from types import UnionType
+from typing import ClassVar
+
 import lxml.etree as ET
 
 from excel2moodle.core.globals import (
-    DFIndex,
+    Tags,
     XMLTags,
 )
 from excel2moodle.core.parser import QuestionParser
@@ -14,6 +17,13 @@ class NFQuestion(Question):
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
 
+    nfOpt: ClassVar[dict[Tags, type | UnionType]] = {
+        Tags.BPOINTS: str,
+    }
+    nfMand: ClassVar[dict[Tags, type | UnionType]] = {
+        Tags.RESULT: float | int,
+    }
+
 
 class NFQuestionParser(QuestionParser):
     """Subclass for parsing numeric questions."""
@@ -22,8 +32,12 @@ class NFQuestionParser(QuestionParser):
         super().__init__()
         self.genFeedbacks = [XMLTags.GENFEEDB]
 
-    def setAnswers(self) -> list[ET.Element]:
-        result = self.rawInput[DFIndex.RESULT]
+    def setup(self, question: NFQuestion) -> None:
+        self.question: NFQuestion = question
+        super().setup(question)
+
+    def _parseAnswers(self) -> list[ET.Element]:
+        result: float = self.rawInput.get(Tags.RESULT)
         ansEle: list[ET.Element] = []
         ansEle.append(self.getNumericAnsElement(result=result))
         return ansEle

excel2moodle/question_types/nfm.py

@@ -1,51 +1,86 @@
 """Numerical question multi implementation."""
 
+import math
 import re
-from typing import TYPE_CHECKING
+from types import UnionType
+from typing import TYPE_CHECKING, ClassVar
 
-import lxml.etree as ET
 from asteval import Interpreter
 
 from excel2moodle.core import stringHelpers
+from excel2moodle.core.exceptions import QNotParsedException
 from excel2moodle.core.globals import (
-    DFIndex,
+    Tags,
     XMLTags,
 )
 from excel2moodle.core.parser import QuestionParser
-from excel2moodle.core.question import Question
+from excel2moodle.core.question import ParametricQuestion
 
 if TYPE_CHECKING:
     import lxml.etree as ET
 
 
-class NFMQuestion(Question):
+class NFMQuestion(ParametricQuestion):
+    nfmMand: ClassVar[dict[Tags, type | UnionType]] = {
+        Tags.RESULT: str,
+        Tags.BPOINTS: str,
+    }
+
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
+        self.answerVariants: list[ET.Element]
+
+    def _setAnswerElement(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])
 
 
 class NFMQuestionParser(QuestionParser):
+    astEval = Interpreter(with_import=True)
+
     def __init__(self) -> None:
         super().__init__()
         self.genFeedbacks = [XMLTags.GENFEEDB]
-        self.astEval = Interpreter()
+        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 setAnswers(self) -> None:
-        equation = self.rawInput[DFIndex.RESULT]
-        bps = str(self.rawInput[DFIndex.BPOINTS])
+    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):
-            self._setupAstIntprt(self.question.variables, n)
-            result = self.astEval(equation)
+            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))
+        self._setVariants(len(ansElementsList))
 
-    def setVariants(self, number: int) -> None:
+    def _setVariants(self, number: int) -> None:
         self.question.variants = number
         mvar = self.question.category.maxVariants
         if mvar is None:
@@ -53,17 +88,25 @@ class NFMQuestionParser(QuestionParser):
         else:
             self.question.category.maxVariants = min(number, mvar)
 
-    def _setupAstIntprt(self, var: dict[str, list[float | int]], index: int) -> None:
+    @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():
-            self.astEval.symtable[name] = value[index]
+            cls.astEval.symtable[name] = value[index]
 
     def _getVariablesDict(self, keyList: list) -> tuple[dict[str, list[float]], int]:
-        """Liest alle Variablen-Listen deren Name in ``keyList`` ist aus dem DataFrame im Column[index]."""
+        """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]
+            val = self.rawInput[k.lower()]
             if isinstance(val, str):
                 li = stringHelpers.getListFromStr(val)
                 num = len(li)