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

excel2moodle/core/parser.py

@@ -4,17 +4,16 @@ import re
 import lxml.etree as ET
 
 import excel2moodle.core.etHelpers as eth
-from excel2moodle.core import stringHelpers
 from excel2moodle.core.exceptions import QNotParsedException
 from excel2moodle.core.globals import (
-    DFIndex,
+    Tags,
     TextElements,
     XMLTags,
     feedbackStr,
     feedBElements,
 )
 from excel2moodle.core.question import Picture, Question
-from excel2moodle.core.settings import Settings, SettingsKey
+from excel2moodle.core.settings import Settings, Tags
 from excel2moodle.logger import LogAdapterQuestionID
 
 loggerObj = logging.getLogger(__name__)
@@ -47,8 +46,8 @@ class QuestionParser:
         """Create a ``Picture`` object ``question``if the question needs a pic."""
         if hasattr(self, "picture") and self.question.picture.ready:
             return True
-        picKey = self.rawInput.get(DFIndex.PICTURE, False)
-        f = self.settings.get(SettingsKey.PICTUREFOLDER)
+        picKey = self.rawInput.get(Tags.PICTURE)
+        f = self.settings.get(Tags.PICTUREFOLDER)
         svgFolder = (f / self.question.katName).resolve()
         if not hasattr(self.question, "picture"):
             self.question.picture = Picture(picKey, svgFolder, self.question.id)
@@ -57,7 +56,7 @@ class QuestionParser:
     def setMainText(self) -> None:
         paragraphs: list[ET._Element] = [TextElements.PLEFT.create()]
         ET.SubElement(paragraphs[0], "b").text = f"ID {self.question.id}"
-        text = self.rawInput[DFIndex.TEXT]
+        text = self.rawInput[Tags.TEXT]
         for t in text:
             paragraphs.append(TextElements.PLEFT.create())
             paragraphs[-1].text = t
@@ -66,8 +65,8 @@ class QuestionParser:
 
     def setBPoints(self) -> None:
         """If there bulletPoints are set in the Spreadsheet it creates an unordered List-Element in ``Question.bulletList``."""
-        if DFIndex.BPOINTS in self.rawInput:
-            bps: str = self.rawInput[DFIndex.BPOINTS]
+        if Tags.BPOINTS in self.rawInput:
+            bps: list[str] = self.rawInput[Tags.BPOINTS]
             try:
                 bulletList = self.formatBulletList(bps)
             except IndexError:
@@ -83,15 +82,14 @@ class QuestionParser:
             )
             self.question.bulletList = bulletList
 
-    def formatBulletList(self, bps: str) -> ET.Element:
+    def formatBulletList(self, bps: list[str]) -> ET.Element:
         self.logger.debug("Formatting the bulletpoint list")
-        li: list[str] = stringHelpers.getListFromStr(bps)
         name = []
         var = []
         quant = []
         unit = []
         unorderedList = TextElements.ULIST.create()
-        for item in li:
+        for item in bps:
             sc_split = item.split()
             name.append(sc_split[0])
             var.append(sc_split[1])
@@ -118,7 +116,7 @@ class QuestionParser:
     def appendToTmpEle(
         self,
         eleName: str,
-        text: str | DFIndex,
+        text: str | Tags,
         txtEle=False,
         **attribs,
     ) -> None:
@@ -127,7 +125,7 @@ class QuestionParser:
         It uses the data from ``self.rawInput`` if ``text`` is type``DFIndex``
         Otherwise the value of ``text`` will be inserted.
         """
-        t = self.rawInput[text] if isinstance(text, DFIndex) else text
+        t = self.rawInput[text] if isinstance(text, Tags) else text
         if txtEle is False:
             self.tmpEle.append(eth.getElement(eleName, t, **attribs))
         elif txtEle is True:
@@ -135,6 +133,9 @@ class QuestionParser:
 
     def _appendStandardTags(self) -> None:
         """Append the elements defined in the ``cls.standardTags``."""
+        self.logger.debug(
+            "Appending the Standard Tags %s", type(self.question).standardTags.items()
+        )
         for k, v in type(self.question).standardTags.items():
             self.appendToTmpEle(k, text=v)
 
@@ -145,25 +146,27 @@ class QuestionParser:
         if no Exceptions are raised, ``self.tmpEle`` is passed to ``self.question.element``
         """
         self.logger.info("Starting to parse")
-        self.tmpEle = ET.Element(XMLTags.QUESTION, type=self.question.moodleType)
-        self.appendToTmpEle(XMLTags.NAME, text=DFIndex.NAME, txtEle=True)
+        self.tmpEle: ET.Elemnt = ET.Element(
+            XMLTags.QUESTION, type=self.question.moodleType
+        )
+        self.appendToTmpEle(XMLTags.NAME, text=Tags.NAME, txtEle=True)
         self.appendToTmpEle(XMLTags.ID, text=self.question.id)
         if self.hasPicture():
             self.tmpEle.append(self.question.picture.element)
         self.tmpEle.append(ET.Element(XMLTags.QTEXT, format="html"))
         self.appendToTmpEle(XMLTags.POINTS, text=str(self.question.points))
-        self.appendToTmpEle(XMLTags.PENALTY, text="0.3333")
         self._appendStandardTags()
         for feedb in self.genFeedbacks:
             self.tmpEle.append(eth.getFeedBEle(feedb))
-        ansList = self.setAnswers()
+        ansList = self._parseAnswers()
         self.setMainText()
         self.setBPoints()
         if ansList is not None:
             for ele in ansList:
                 self.tmpEle.append(ele)
-        self.logger.info("Sucessfully parsed")
         self.question.element = self.tmpEle
+        self.question.isParsed = True
+        self.logger.info("Sucessfully parsed")
 
     def getFeedBEle(
         self,
@@ -181,7 +184,7 @@ class QuestionParser:
         ele.append(eth.getCdatTxtElement(par))
         return ele
 
-    def setAnswers(self) -> list[ET.Element] | None:
+    def _parseAnswers(self) -> list[ET.Element] | None:
         """Needs to be implemented in the type-specific subclasses."""
         return None
 
@@ -211,15 +214,6 @@ class QuestionParser:
                 TextElements.SPANGREEN,
             ),
         )
-        tolerance = float(self.rawInput.get(DFIndex.TOLERANCE, 0))
-        if tolerance == 0 or tolerance >= 100:
-            tolerance = self.settings.get(SettingsKey.TOLERANCE)
-            self.logger.info(
-                "Using default tolerance %s percent from settings",
-                tolerance,
-            )
-        tolPercent = 100 * tolerance if tolerance < 1 else tolerance
-        self.logger.debug("Using tolerance %s percent", tolPercent)
-        relTolerance = abs(round(result * (tolerance / 100), 3))
-        ansEle.append(eth.getElement(XMLTags.TOLERANCE, text=str(relTolerance)))
+        absTolerance = round(result * self.rawInput.get(Tags.TOLERANCE), 4)
+        ansEle.append(eth.getElement(XMLTags.TOLERANCE, text=str(absTolerance)))
         return ansEle

excel2moodle/core/question.py

@@ -1,9 +1,10 @@
 import base64
 import logging
 import re
-import typing
 from pathlib import Path
 from re import Match
+from types import UnionType
+from typing import ClassVar, Literal, overload
 
 import lxml.etree as ET
 
@@ -11,74 +12,158 @@ from excel2moodle.core import etHelpers
 from excel2moodle.core.category import Category
 from excel2moodle.core.exceptions import QNotParsedException
 from excel2moodle.core.globals import (
-    DFIndex,
+    QUESTION_TYPES,
+    Tags,
     TextElements,
     XMLTags,
-    questionTypes,
 )
-from excel2moodle.core.settings import Settings, SettingsKey
+from excel2moodle.core.settings import Settings, Tags
 from excel2moodle.logger import LogAdapterQuestionID
 
 loggerObj = logging.getLogger(__name__)
 settings = Settings()
 
 
+class QuestionData(dict):
+    @overload
+    def get(
+        self,
+        key: Literal[Tags.NAME, Tags.ANSTYPE, Tags.PICTURE, Tags.EQUATION],
+    ) -> str: ...
+    @overload
+    def get(
+        self,
+        key: Literal[Tags.BPOINTS, Tags.TRUE, Tags.FALSE, Tags.QUESTIONPART, Tags.TEXT],
+    ) -> list: ...
+    @overload
+    def get(
+        self,
+        key: Literal[
+            Tags.VERSION,
+            Tags.NUMBER,
+            Tags.PICTUREWIDTH,
+            Tags.ANSPICWIDTH,
+            Tags.WRONGSIGNPERCENT,
+        ],
+    ) -> int: ...
+    @overload
+    def get(
+        self, key: Literal[Tags.PARTTYPE, Tags.TYPE]
+    ) -> Literal["MC", "NFM", "CLOZE"]: ...
+    @overload
+    def get(
+        self, key: Literal[Tags.TOLERANCE, Tags.POINTS, Tags.FIRSTRESULT]
+    ) -> float: ...
+    @overload
+    def get(self, key: Literal[Tags.RESULT]) -> float | str: ...
+
+    def get(self, key: Tags, default=None):
+        if key in self:
+            val = self[key]
+            try:
+                typed = key.typ()(val)
+            except ValueError:
+                return None
+            return typed
+        return settings.get(key)
+
+
 class Question:
-    standardTags: typing.ClassVar[dict[str, str | float]] = {
+    standardTags: ClassVar[dict[str, str | float]] = {
         "hidden": 0,
+        "penalty": 0.33333,
+    }
+    mandatoryTags: ClassVar[dict[Tags, type | UnionType]] = {
+        Tags.TEXT: str,
+        Tags.NAME: str,
+        Tags.TYPE: str,
+    }
+    optionalTags: ClassVar[dict[Tags, type | UnionType]] = {
+        Tags.PICTURE: int | str,
     }
 
     def __init_subclass__(cls, **kwargs) -> None:
         super().__init_subclass__(**kwargs)
-        subclassTags = getattr(cls, "standartTags", {})
-        superclassTags = super(cls, cls).standardTags
-        mergedTags = superclassTags.copy()
-        mergedTags.update(subclassTags)
-        cls.standardTags = mergedTags
+        dictionaries = ("standardTags", "mandatoryTags", "optionalTags")
+        for dic in dictionaries:
+            cls._mergeDicts(dic)
 
     @classmethod
-    def addStandardTags(cls, key, value) -> None:
+    def _mergeDicts(cls, dictName) -> None:
+        superDict = getattr(super(cls, cls), dictName)
+        subDict = getattr(cls, dictName, {})
+        mergedDict = superDict.copy()
+        mergedDict.update(subDict)
+        setattr(cls, dictName, mergedDict)
+
+    @classmethod
+    def addStandardTag(cls, key, value) -> None:
         cls.standardTags[key] = value
 
     def __init__(
         self,
         category: Category,
-        rawData: dict[str, float | str | int | list[str]],
+        rawData: QuestionData,
         parent=None,
         points: float = 0,
     ) -> None:
-        self.rawData = rawData
+        self.rawData: QuestionData = rawData
         self.category = category
         self.katName = self.category.name
-        self.name: str = self.rawData.get(DFIndex.NAME)
-        self.number: int = self.rawData.get(DFIndex.NUMBER)
-        self.parent = parent
-        self.qtype: str = self.rawData.get(DFIndex.TYPE)
-        self.moodleType = questionTypes[self.qtype]
+        self.moodleType = QUESTION_TYPES[self.qtype]
         self.points = points if points != 0 else self.category.points
-        self.element: ET.Element | None = None
+        self.element: ET.Element = None
+        self.isParsed: bool = False
         self.picture: Picture
         self.id: str
         self.qtextParagraphs: list[ET.Element] = []
-        self.bulletList: ET.Element | None = None
-        self.answerVariants: list[ET.Element] = []
-        self.variants: int | None = None
-        self.variables: dict[str, list[float | int]] = {}
-        self.setID()
+        self.bulletList: ET.Element = None
+        self._setID()
         self.logger = LogAdapterQuestionID(loggerObj, {"qID": self.id})
         self.logger.debug("Sucess initializing")
 
+    @property
+    def name(self) -> str:
+        return self.rawData.get(Tags.NAME)
+
+    @property
+    def qtype(self) -> str:
+        return self.rawData.get(Tags.TYPE)
+
     def __repr__(self) -> str:
         li: list[str] = []
         li.append(f"Question v{self.id}")
         li.append(f"{self.qtype}")
-        li.append(f"{self.parent=}")
         return "\t".join(li)
 
-    def assemble(self, variant: int = 1) -> None:
-        textElements: list[ET.Element] = []
-        textElements.extend(self.qtextParagraphs)
-        self.logger.debug("Starting assembly, (variant %s)", variant)
+    def assemble(self, variant=0) -> None:
+        """Assemble the question to the valid xml Tree."""
+        mainText = self._getTextElement()
+        self.logger.debug("Starting assembly")
+        self._setAnswerElement(variant=variant)
+        textParts = self._assembleMainTextParts()
+        if hasattr(self, "picture") and self.picture.ready:
+            mainText.append(self.picture.element)
+            self.logger.debug("Appended Picture element to text")
+        mainText.append(etHelpers.getCdatTxtElement(textParts))
+
+    def _assembleMainTextParts(self, variant=0) -> list[ET.Element]:
+        """Assemble the Question Text.
+
+        Intended for the cloze question, where the answers parts are part of the text.
+        """
+        self.logger.debug("inserting MainText to element")
+        textParts: list[ET.Element] = []
+        textParts.extend(self.qtextParagraphs)
+        bullets = self._getBPoints(variant=variant)
+        if bullets is not None:
+            textParts.append(bullets)
+        if hasattr(self, "picture") and self.picture.ready:
+            textParts.append(self.picture.htmlTag)
+            self.logger.debug("Appended Picture html to text")
+        return textParts
+
+    def _getTextElement(self) -> ET.Element:
         if self.element is not None:
             mainText = self.element.find(XMLTags.QTEXT)
             self.logger.debug(f"found existing Text in element {mainText=}")
@@ -86,34 +171,36 @@ class Question:
             if txtele is not None:
                 mainText.remove(txtele)
                 self.logger.debug("removed previously existing questiontext")
-        else:
-            msg = "Cant assamble, if element is none"
-            raise QNotParsedException(msg, self.id)
-        if self.variants is not None:
-            textElements.append(self.getBPointVariant(variant - 1))
-        elif self.bulletList is not None:
-            textElements.append(self.bulletList)
-        if hasattr(self, "picture") and self.picture.ready:
-            textElements.append(self.picture.htmlTag)
-            mainText.append(self.picture.element)
-        mainText.append(etHelpers.getCdatTxtElement(textElements))
-        self.logger.debug("inserted MainText to element")
-        if len(self.answerVariants) > 0:
-            ans = self.element.find(XMLTags.ANSWER)
-            if ans is not None:
-                self.element.remove(ans)
-                self.logger.debug("removed previous answer element")
-            self.element.insert(5, self.answerVariants[variant - 1])
-
-    def setID(self, id=0) -> None:
+            return mainText
+        msg = "Cant assamble, if element is none"
+        raise QNotParsedException(msg, self.id)
+
+    def _getBPoints(self, variant: int = 0) -> ET.Element:
+        if hasattr(self, "bulletList"):
+            return self.bulletList
+        return None
+
+    def _setAnswerElement(self, variant: int = 0) -> None:
+        pass
+
+    def _setID(self, id=0) -> None:
         if id == 0:
-            self.id: str = f"{self.category.id}{self.number:02d}"
+            self.id: str = f"{self.category.id}{self.rawData.get(Tags.NUMBER):02d}"
         else:
             self.id: str = str(id)
 
-    def getBPointVariant(self, variant: int) -> ET.Element:
+
+class ParametricQuestion(Question):
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.variants: int = 0
+        self.variables: dict[str, list[float | int]] = {}
+
+    def _getBPoints(self, variant: int = 1) -> ET.Element:
+        """Get the bullet points with the variable set for `variant`."""
         if self.bulletList is None:
-            return None
+            msg = "Can't assemble a parametric question, without the bulletPoints variables"
+            raise QNotParsedException(msg, self.id)
         # matches {a}, {some_var}, etc.
         varPlaceholder = re.compile(r"{(\w+)}")
 
@@ -129,8 +216,8 @@ class Question:
             listItemText = li.text or ""
             bullet = TextElements.LISTITEM.create()
             bullet.text = varPlaceholder.sub(replaceMatch, listItemText)
-            self.logger.debug(f"Inserted Variables into List: {bullet}")
             unorderedList.append(bullet)
+            self.logger.debug("Inserted Variables into List: %s", bullet.text)
         return unorderedList
 
 
@@ -140,7 +227,7 @@ class Picture:
     ) -> None:
         self.logger = LogAdapterQuestionID(loggerObj, {"qID": questionId})
         self.picID: str
-        w: int = width if width > 0 else settings.get(SettingsKey.PICTUREWIDTH)
+        w: int = width if width > 0 else settings.get(Tags.PICTUREWIDTH)
         self.size: dict[str, str] = {"width": str(w)}
         self.ready: bool = False
         self.imgFolder = imgFolder
@@ -149,7 +236,7 @@ class Picture:
         self.questionId: str = questionId
         self.logger.debug("Instantiating a new picture in %s", picKey)
         if self.getImgId(picKey):
-            self.ready = self.__getImg()
+            self.ready = self._getImg()
         else:
             self.ready = False
 
@@ -192,7 +279,7 @@ class Picture:
         with imgPath.open("rb") as img:
             return base64.b64encode(img.read()).decode("utf-8")
 
-    def __getImg(self) -> bool:
+    def _getImg(self) -> bool:
         suffixes = ["png", "svg", "jpeg", "jpg"]
         paths = [
             path
@@ -202,15 +289,12 @@ class Picture:
         self.logger.debug("Found the following paths %s", paths)
         try:
             self.path = paths[0]
-        except IndexError as e:
-            msg = f"The Picture from key {self.picID} is not found"
-            # raise InvalidFieldException(msg, self.questionId, DFIndex.PICTURE)
-            self.logger.warning(
-                msg=f"Bild {self.picID} konnte nicht gefunden werden ",
-                exc_info=e,
-            )
+        except IndexError:
+            msg = f"The Picture {self.imgFolder}/{self.picID} is not found"
+            self.logger.warning(msg=msg)
             self.element = None
             return False
+            # raise FileNotFoundError(msg)
         base64Img = self._getBase64Img(self.path)
         self.element: ET.Element = ET.Element(
             "file",