excel2moodle 0.3.6__py3-none-any.whl → 0.4.0__py3-none-any.whl

excel2moodle/core/parser.py

@@ -2,8 +2,6 @@ import logging
 import re
 
 import lxml.etree as ET
-import pandas as pd
-from asteval import Interpreter
 
 import excel2moodle.core.etHelpers as eth
 from excel2moodle.core import stringHelpers
@@ -14,16 +12,13 @@ from excel2moodle.core.globals import (
     XMLTags,
     feedbackStr,
     feedBElements,
-    parserSettings,
 )
 from excel2moodle.core.question import Picture, Question
+from excel2moodle.core.settings import Settings, SettingsKey
 from excel2moodle.logger import LogAdapterQuestionID
-from excel2moodle.ui.settings import Settings, SettingsKey
 
 loggerObj = logging.getLogger(__name__)
 
-settings = Settings()
-
 
 class QuestionParser:
     """Setup the Parser Object.
@@ -32,42 +27,42 @@ class QuestionParser:
     Important to implement the answers methods.
     """
 
-    def __init__(self, question: Question, data: dict) -> None:
+    settings = Settings()
+
+    def __init__(self) -> None:
         """Initialize the general Question parser."""
+        self.genFeedbacks: list[XMLTags] = []
+        self.logger: logging.LoggerAdapter
+
+    def setup(self, question: Question) -> None:
         self.question: Question = question
-        self.rawInput = data
+        self.rawInput = question.rawData
         self.logger = LogAdapterQuestionID(loggerObj, {"qID": self.question.id})
         self.logger.debug(
             "The following Data was provided: %s",
             self.rawInput,
         )
-        self.genFeedbacks: list[XMLTags] = []
 
     def hasPicture(self) -> bool:
         """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[DFIndex.PICTURE]
-        svgFolder = settings.get(SettingsKey.PICTUREFOLDER)
-        if picKey != 0 and pd.notna(picKey):
-            if not hasattr(self.question, "picture"):
-                self.question.picture = Picture(picKey, svgFolder, self.question)
-            if self.question.picture.ready:
-                return True
-        return False
+        picKey = self.rawInput.get(DFIndex.PICTURE, False)
+        f = self.settings.get(SettingsKey.PICTUREFOLDER)
+        svgFolder = (f / self.question.katName).resolve()
+        if not hasattr(self.question, "picture"):
+            self.question.picture = Picture(picKey, svgFolder, self.question.id)
+        return bool(self.question.picture.ready)
 
     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]
-        pcount = 0
         for t in text:
-            if not pd.isna(t):
-                pcount += 1
-                paragraphs.append(TextElements.PLEFT.create())
-                paragraphs[-1].text = t
+            paragraphs.append(TextElements.PLEFT.create())
+            paragraphs[-1].text = t
         self.question.qtextParagraphs = paragraphs
-        self.logger.debug("Created main Text with: %s paragraphs", pcount)
+        self.logger.debug("Created main Text with: %s paragraphs", len(text))
 
     def setBPoints(self) -> None:
         """If there bulletPoints are set in the Spreadsheet it creates an unordered List-Element in ``Question.bulletList``."""
@@ -75,12 +70,12 @@ class QuestionParser:
             bps: str = self.rawInput[DFIndex.BPOINTS]
             try:
                 bulletList = self.formatBulletList(bps)
-            except IndexError as e:
+            except IndexError:
                 msg = f"konnt Bullet Liste {self.question.id} nicht generieren"
                 raise QNotParsedException(
                     msg,
                     self.question.id,
-                    exc_info=e,
+                    # exc_info=e,
                 )
             self.logger.debug(
                 "Generated BPoint List: \n %s",
@@ -90,7 +85,7 @@ class QuestionParser:
 
     def formatBulletList(self, bps: str) -> ET.Element:
         self.logger.debug("Formatting the bulletpoint list")
-        li: list[str] = stringHelpers.stripWhitespace(bps.split(";"))
+        li: list[str] = stringHelpers.getListFromStr(bps)
         name = []
         var = []
         quant = []
@@ -138,24 +133,12 @@ class QuestionParser:
         elif txtEle is True:
             self.tmpEle.append(eth.getTextElement(eleName, t, **attribs))
 
-    def appendFromSettings(self, key="standards") -> None:
-        """Appends 1 to 1 mapped Elements defined in the parserSettings to the element."""
-        parser = ["Parser"]
-        if isinstance(self, MCQuestionParser):
-            parser.append("MCParser")
-        elif isinstance(self, NFQuestionParser):
-            parser.append("NFParser")
-        for p in parser:
-            try:
-                for k, v in parserSettings[p][key].items():
-                    self.appendToTmpEle(k, text=v)
-            except KeyError as e:
-                msg = f"Invalider Input aus den Einstellungen Parser: {
-                    type(p) =}"
-                self.logger.exception(msg, exc_info=e)
-                raise QNotParsedException(msg, self.question.id, exc_info=e)
+    def _appendStandardTags(self) -> None:
+        """Append the elements defined in the ``cls.standardTags``."""
+        for k, v in type(self.question).standardTags.items():
+            self.appendToTmpEle(k, text=v)
 
-    def parse(self, xmlTree: ET._Element | None = None) -> None:
+    def parse(self) -> None:
         """Parse the Question.
 
         Generates an new Question Element stored as ``self.tmpEle:ET.Element``
@@ -163,7 +146,6 @@ class QuestionParser:
         """
         self.logger.info("Starting to parse")
         self.tmpEle = ET.Element(XMLTags.QUESTION, type=self.question.moodleType)
-        # self.tmpEle.set(XMLTags.TYPE, self.question.moodleType)
         self.appendToTmpEle(XMLTags.NAME, text=DFIndex.NAME, txtEle=True)
         self.appendToTmpEle(XMLTags.ID, text=self.question.id)
         if self.hasPicture():
@@ -171,11 +153,9 @@ class QuestionParser:
         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.appendFromSettings()
+        self._appendStandardTags()
         for feedb in self.genFeedbacks:
             self.tmpEle.append(eth.getFeedBEle(feedb))
-        if xmlTree is not None:
-            xmlTree.append(self.tmpEle)
         ansList = self.setAnswers()
         self.setMainText()
         self.setBPoints()
@@ -208,7 +188,6 @@ class QuestionParser:
     def getNumericAnsElement(
         self,
         result: float,
-        tolerance: float = 0,
         fraction: float = 100,
         format: str = "moodle_auto_format",
     ) -> ET.Element:
@@ -232,164 +211,15 @@ class QuestionParser:
                 TextElements.SPANGREEN,
             ),
         )
-        tolerance = self.getTolerancePercent(tolerance)
-        tol = abs(round(result * (tolerance / 100), 3))
-        ansEle.append(eth.getElement(XMLTags.TOLERANCE, text=str(tol)))
-        return ansEle
-
-    def getTolerancePercent(self, tolerance: float) -> int:
-        """Get the correct tolerance.
-        If ``tolerance < 1``:  it is interpreted as the fraction.
-        If ``tolerance >= 1``: it is interpreted as percentage.
-        """
-        if tolerance == 0 or pd.isna(tolerance) or tolerance >= 100:
-            tolerance = settings.get(SettingsKey.PARSERNF_TOLERANCE)
+        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,
             )
-        tolerancePercent = 100 * tolerance if tolerance < 1 else tolerance
-        self.logger.debug("Using tolerance %s percent", tolerancePercent)
-        return int(tolerancePercent)
-
-
-class NFQuestionParser(QuestionParser):
-    """Subclass for parsing numeric questions."""
-
-    def __init__(self, *args) -> None:
-        super().__init__(*args)
-        self.genFeedbacks = [XMLTags.GENFEEDB]
-
-    def setAnswers(self) -> list[ET.Element]:
-        result = self.rawInput[DFIndex.RESULT]
-        ansEle: list[ET.Element] = []
-        tol = self.rawInput[DFIndex.TOLERANCE]
-        ansEle.append(self.getNumericAnsElement(result=result, tolerance=tol))
+        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)))
         return ansEle
-
-
-class NFMQuestionParser(QuestionParser):
-    def __init__(self, *args) -> None:
-        super().__init__(*args)
-        self.genFeedbacks = [XMLTags.GENFEEDB]
-        self.astEval = Interpreter()
-
-    def setAnswers(self) -> None:
-        equation = self.rawInput[DFIndex.RESULT]
-        bps = str(self.rawInput[DFIndex.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)
-            if isinstance(result, float):
-                tol = self.rawInput[DFIndex.TOLERANCE]
-                ansElementsList.append(
-                    self.getNumericAnsElement(result=round(result, 3), tolerance=tol),
-                )
-        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)
-
-    def _setupAstIntprt(self, 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]
-
-    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]."""
-        dic: dict = {}
-        num: int = 0
-        for k in keyList:
-            val = self.rawInput[k]
-            if isinstance(val, str):
-                li = stringHelpers.stripWhitespace(val.split(";"))
-                num = len(li)
-                vars: list[float] = [float(i.replace(",", ".")) for i in li]
-                dic[str(k)] = vars
-            else:
-                dic[str(k)] = [str(val)]
-                num = 1
-        return dic, num
-
-    @staticmethod
-    def _getVarsList(bps: str | list[str]) -> list:
-        """Durchsucht den bulletPoints String nach den Variablen, die als "{var}" gekennzeichnet sind."""
-        vars = []
-        if isinstance(bps, list):
-            for _p in bps:
-                vars.extend(re.findall(r"\{\w\}", str(bps)))
-        else:
-            vars = re.findall(r"\{\w\}", str(bps))
-        variablen = []
-        for v in vars:
-            variablen.append(v.strip("{}"))
-        return variablen
-
-
-class MCQuestionParser(QuestionParser):
-    def __init__(self, *args) -> None:
-        super().__init__(*args)
-        self.genFeedbacks = [
-            XMLTags.CORFEEDB,
-            XMLTags.PCORFEEDB,
-            XMLTags.INCORFEEDB,
-        ]
-
-    def getAnsElementsList(
-        self,
-        answerList: list,
-        fraction: float = 50,
-        format="html",
-    ) -> list[ET.Element]:
-        elementList: list[ET.Element] = []
-        for ans in answerList:
-            p = TextElements.PLEFT.create()
-            p.text = str(ans)
-            text = eth.getCdatTxtElement(p)
-            elementList.append(
-                ET.Element(XMLTags.ANSWER, fraction=str(fraction), format=format),
-            )
-            elementList[-1].append(text)
-            if fraction < 0:
-                elementList[-1].append(
-                    eth.getFeedBEle(
-                        XMLTags.ANSFEEDBACK,
-                        text=feedbackStr["wrong"],
-                        style=TextElements.SPANRED,
-                    ),
-                )
-            elif fraction > 0:
-                elementList[-1].append(
-                    eth.getFeedBEle(
-                        XMLTags.ANSFEEDBACK,
-                        text=feedbackStr["right"],
-                        style=TextElements.SPANGREEN,
-                    ),
-                )
-        return elementList
-
-    def setAnswers(self) -> list[ET.Element]:
-        ansStyle = self.rawInput[DFIndex.ANSTYPE]
-        true = stringHelpers.stripWhitespace(self.rawInput[DFIndex.TRUE].split(";"))
-        trueAnsList = stringHelpers.texWrapper(true, style=ansStyle)
-        self.logger.debug(f"got the following true answers \n {trueAnsList=}")
-        false = stringHelpers.stripWhitespace(self.rawInput[DFIndex.FALSE].split(";"))
-        falseAnsList = stringHelpers.texWrapper(false, style=ansStyle)
-        self.logger.debug(f"got the following false answers \n {falseAnsList=}")
-        truefrac = 1 / len(trueAnsList) * 100
-        falsefrac = 1 / len(trueAnsList) * (-100)
-        self.tmpEle.find(XMLTags.PENALTY).text = str(round(truefrac / 100, 4))
-        ansList = self.getAnsElementsList(trueAnsList, fraction=round(truefrac, 4))
-        ansList.extend(
-            self.getAnsElementsList(falseAnsList, fraction=round(falsefrac, 4)),
-        )
-        return ansList

excel2moodle/core/question.py

@@ -1,40 +1,60 @@
 import base64
 import logging
 import re
+import typing
 from pathlib import Path
 from re import Match
 
 import lxml.etree as ET
 
 from excel2moodle.core import etHelpers
+from excel2moodle.core.category import Category
 from excel2moodle.core.exceptions import QNotParsedException
 from excel2moodle.core.globals import (
+    DFIndex,
     TextElements,
     XMLTags,
     questionTypes,
 )
+from excel2moodle.core.settings import Settings, SettingsKey
 from excel2moodle.logger import LogAdapterQuestionID
 
 loggerObj = logging.getLogger(__name__)
+settings = Settings()
 
 
 class Question:
+    standardTags: typing.ClassVar[dict[str, str | float]] = {
+        "hidden": 0,
+    }
+
+    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
+
+    @classmethod
+    def addStandardTags(cls, key, value) -> None:
+        cls.standardTags[key] = value
+
     def __init__(
         self,
-        category,
-        name: str,
-        number: int,
+        category: Category,
+        rawData: dict[str, float | str | int | list[str]],
         parent=None,
-        qtype: str = "type",
         points: float = 0,
     ) -> None:
+        self.rawData = rawData
         self.category = category
         self.katName = self.category.name
-        self.name = name
-        self.number = number
+        self.name: str = self.rawData.get(DFIndex.NAME)
+        self.number: int = self.rawData.get(DFIndex.NUMBER)
         self.parent = parent
-        self.qtype: str = qtype
-        self.moodleType = questionTypes[qtype]
+        self.qtype: str = self.rawData.get(DFIndex.TYPE)
+        self.moodleType = questionTypes[self.qtype]
         self.points = points if points != 0 else self.category.points
         self.element: ET.Element | None = None
         self.picture: Picture
@@ -45,21 +65,20 @@ class Question:
         self.variants: int | None = None
         self.variables: dict[str, list[float | int]] = {}
         self.setID()
-        self.standardTags = {"hidden": "false"}
         self.logger = LogAdapterQuestionID(loggerObj, {"qID": self.id})
         self.logger.debug("Sucess initializing")
 
     def __repr__(self) -> str:
         li: list[str] = []
-        li.append(f"Question v{self.category.version}")
-        li.append(f"{self.id=}")
+        li.append(f"Question v{self.id}")
+        li.append(f"{self.qtype}")
         li.append(f"{self.parent=}")
-        return "\n".join(li)
+        return "\t".join(li)
 
     def assemble(self, variant: int = 1) -> None:
         textElements: list[ET.Element] = []
         textElements.extend(self.qtextParagraphs)
-        self.logger.debug("Starting assembly")
+        self.logger.debug("Starting assembly, (variant %s)", variant)
         if self.element is not None:
             mainText = self.element.find(XMLTags.QTEXT)
             self.logger.debug(f"found existing Text in element {mainText=}")
@@ -78,7 +97,6 @@ class Question:
             textElements.append(self.picture.htmlTag)
             mainText.append(self.picture.element)
         mainText.append(etHelpers.getCdatTxtElement(textElements))
-        # self.element.insert(3, mainText)
         self.logger.debug("inserted MainText to element")
         if len(self.answerVariants) > 0:
             ans = self.element.find(XMLTags.ANSWER)
@@ -117,61 +135,94 @@ class Question:
 
 
 class Picture:
-    def __init__(self, picKey: str, imgFolder: Path, question: Question) -> None:
-        self.pic = picKey
+    def __init__(
+        self, picKey: str, imgFolder: Path, questionId: str, width: int = 0
+    ) -> None:
+        self.logger = LogAdapterQuestionID(loggerObj, {"qID": questionId})
+        self.picID: str
+        w: int = width if width > 0 else settings.get(SettingsKey.PICTUREWIDTH)
+        self.size: dict[str, str] = {"width": str(w)}
         self.ready: bool = False
-        self.question = question
-        self.logger = LogAdapterQuestionID(loggerObj, {"qID": self.question.id})
-        self.imgFolder = (imgFolder / question.katName).resolve()
+        self.imgFolder = imgFolder
         self.htmlTag: ET.Element
         self.path: Path
-        self._setPath()
-        if hasattr(self, "picID"):
+        self.questionId: str = questionId
+        self.logger.debug("Instantiating a new picture in %s", picKey)
+        if self.getImgId(picKey):
             self.ready = self.__getImg()
-
-    def _setPath(self) -> None:
-        if self.pic == 1:
-            self.picID = self.question.id
         else:
-            selectedPic = self.pic[2:]
-            self.logger.debug("Got the picture key: %s", selectedPic)
-            try:
-                self.picID = f"{self.question.category.id}{int(selectedPic):02d}"
-            except ValueError as e:
-                self.logger.warning(
-                    msg=f"Bild-ID konnte aus dem Key: {self.pic} nicht festgestellt werden",
-                    exc_info=e,
-                )
-
-    def __getBase64Img(self, imgPath):
-        with open(imgPath, "rb") as img:
-            return base64.b64encode(img.read()).decode("utf-8")
+            self.ready = False
+
+    def getImgId(self, imgKey: str) -> bool:
+        """Get the image ID and width based on the given key.
+        The key should either be the full ID (as the question) or only the question Num.
+        If only the number is given, the category.id is prepended.
+        The width should be specified by `ID:width:XX`. where xx is the px value.
+        """
+        width = re.findall(r"\:width\:(\d+)", str(imgKey))
+        height = re.findall(r"\:height\:(\d+)", str(imgKey))
+        if len(width) > 0 and width[0]:
+            self.size["width"] = width[0]
+        elif len(height) > 0 and height[0]:
+            self.size["height"] = height[0]
+            self.size.pop("width")
+        self.logger.debug("Size of picture is %s", self.size)
+        if imgKey in ("true", "True", "yes"):
+            self.picID = self.questionId
+            return True
+        num: list[int | str] = re.findall(r"^\d+", str(imgKey))
+        app: list[int | str] = re.findall(r"^\d+([A-Za-z_\-]+)", str(imgKey))
+        if imgKey in ("false", "nan", False) or len(num) == 0:
+            return False
+        imgID: int = int(num[0])
+        if imgID < 10:
+            picID = f"{self.questionId[:3]}{imgID:02d}"
+        elif imgID < 10000:
+            picID = f"{self.questionId[:1]}{imgID:04d}"
+        elif imgID <= 100000:
+            picID = str(imgID)
+        if len(app) > 0 and app[0]:
+            self.picID = f"{picID}{app[0]}"
+        else:
+            self.picID = str(picID)
+        self.logger.debug("Evaluated the imgID %s from %s", self.picID, imgKey)
+        return True
 
-    def __setImgElement(self, dir: Path, picID: int) -> None:
-        """Gibt das Bild im dirPath mit dir qID als base64 encodiert mit den entsprechenden XML-Tags zurück."""
-        self.path: Path = (dir / str(picID)).with_suffix(".svg")
-        self.element: ET.Element = ET.Element(
-            "file",
-            name=f"{self.path.name}",
-            path="/",
-            encoding="base64",
-        )
-        self.element.text = self.__getBase64Img(self.path)
+    def _getBase64Img(self, imgPath: Path):
+        with imgPath.open("rb") as img:
+            return base64.b64encode(img.read()).decode("utf-8")
 
     def __getImg(self) -> bool:
+        suffixes = ["png", "svg", "jpeg", "jpg"]
+        paths = [
+            path
+            for suf in suffixes
+            for path in self.imgFolder.glob(f"{self.picID}.{suf}")
+        ]
+        self.logger.debug("Found the following paths %s", paths)
         try:
-            self.__setImgElement(self.imgFolder, int(self.picID))
-            self.htmlTag = ET.Element(
-                "img",
-                src=f"@@PLUGINFILE@@/{self.path.name}",
-                alt=f"Bild {self.path.name}",
-                width="500",
-            )
-            return True
-        except FileNotFoundError as e:
+            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,
             )
             self.element = None
             return False
+        base64Img = self._getBase64Img(self.path)
+        self.element: ET.Element = ET.Element(
+            "file",
+            name=f"{self.path.name}",
+            path="/",
+            encoding="base64",
+        )
+        self.element.text = base64Img
+        self.htmlTag = ET.Element(
+            "img",
+            src=f"@@PLUGINFILE@@/{self.path.name}",
+            alt=f"Bild {self.path.name}",
+            **self.size,
+        )
+        return True