excel2moodle 0.3.4__py3-none-any.whl → 0.3.5__py3-none-any.whl

excel2moodle/core/parser.py

@@ -1,44 +1,55 @@
-import base64 as base64
-import logging as logging
-import re as re
-from pathlib import Path
+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 import settings
 from excel2moodle.core import stringHelpers
-from excel2moodle.core.exceptions import NanException, QNotParsedException
-from excel2moodle.core.globals import (DFIndex, TextElements, XMLTags,
-                                       feedbackStr, feedBElements,
-                                       parserSettings, questionTypes)
+from excel2moodle.core.exceptions import QNotParsedException
+from excel2moodle.core.globals import (
+    DFIndex,
+    TextElements,
+    XMLTags,
+    feedbackStr,
+    feedBElements,
+    parserSettings,
+)
 from excel2moodle.core.question import Picture, Question
+from excel2moodle.logger import LogAdapterQuestionID
+from excel2moodle.ui.settings import Settings, SettingsKey
 
-logger = logging.getLogger(__name__)
+loggerObj = logging.getLogger(__name__)
+
+settings = Settings()
 
 
 class QuestionParser:
-    def __init__(self, question: Question, data: dict):
+    """Setup the Parser Object.
+
+    This is the superclass which implements the general Behaviour of he Parser.
+    Important to implement the answers methods.
+    """
+
+    def __init__(self, question: Question, data: dict) -> None:
+        """Initialize the general Question parser."""
         self.question: Question = question
         self.rawInput = data
-        logger.debug(
-            f"The following Data was provided for the question {
-                self.question.id}:\n {self.rawInput=}"
+        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:
-        """Creates a ``Picture`` object inside ``question``,
-        if the question needs a pic"""
-
+        """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(
-            "core/pictureFolder",
-            default=Path("../Fragensammlung/Abbildungen_SVG").resolve(),
-        )
-        if picKey != 0 and picKey != "nan":
+        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:
@@ -56,33 +67,29 @@ class QuestionParser:
                 paragraphs.append(TextElements.PLEFT.create())
                 paragraphs[-1].text = t
         self.question.qtextParagraphs = paragraphs
-        logger.debug(
-            f"Created main Text {
-                self.question.id} with:{pcount} paragraphs"
-        )
-        return None
+        self.logger.debug("Created main Text with: %s paragraphs", pcount)
 
     def setBPoints(self) -> None:
-        """If there bulletPoints are set in the Spreadsheet it creates an unordered List-Element in ``Question.bulletList``"""
+        """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]
             try:
                 bulletList = self.formatBulletList(bps)
             except IndexError as e:
+                msg = f"konnt Bullet Liste {self.question.id} nicht generieren"
                 raise QNotParsedException(
-                    f"konnt Bullet Liste {self.question.id} nicht generieren",
+                    msg,
                     self.question.id,
                     exc_info=e,
                 )
-            logger.debug(
-                f"Generated BPoint List: \n {
-                    ET.tostring(bulletList, encoding='unicode')}"
+            self.logger.debug(
+                "Generated BPoint List: \n %s",
+                ET.tostring(bulletList, encoding="unicode"),
             )
             self.question.bulletList = bulletList
-        return None
 
     def formatBulletList(self, bps: str) -> ET.Element:
-        logger.debug("Formatting the bulletpoint list")
+        self.logger.debug("Formatting the bulletpoint list")
         li: list[str] = stringHelpers.stripWhitespace(bps.split(";"))
         name = []
         var = []
@@ -95,27 +102,36 @@ class QuestionParser:
             var.append(sc_split[1])
             quant.append(sc_split[3])
             unit.append(sc_split[4])
-        for i in range(0, len(name)):
+        for i in range(len(name)):
             if re.fullmatch(r"{\w+}", quant[i]):
-                logger.debug(f"Got an variable bulletItem")
+                self.logger.debug("Got an variable bulletItem")
                 num_s = quant[i]
             else:
-                logger.debug(f"Got a normal bulletItem")
+                self.logger.debug("Got a normal bulletItem")
                 num = quant[i].split(",")
                 if len(num) == 2:
-                    num_s = f"{str(num[0])},\\!{str(num[1])}~"
+                    num_s = f"{num[0]!s},\\!{num[1]!s}~"
                 else:
-                    num_s = f"{str(num[0])},\\!0~"
+                    num_s = f"{num[0]!s},\\!0~"
             bullet = TextElements.LISTITEM.create()
-            bullet.text = f"{name[i]}: \\( {var[i]} = {
-                num_s} \\mathrm{{ {unit[i]}  }}\\)\n"
+            bullet.text = (
+                f"{name[i]}: \\( {var[i]} = {num_s} \\mathrm{{ {unit[i]}  }}\\)\n"
+            )
             unorderedList.append(bullet)
         return unorderedList
 
     def appendToTmpEle(
-        self, eleName: str, text: str | DFIndex, txtEle=False, **attribs
-    ):
-        """Appends the text to the temporary Element"""
+        self,
+        eleName: str,
+        text: str | DFIndex,
+        txtEle=False,
+        **attribs,
+    ) -> None:
+        """Append ``text`` to the temporary Element.
+
+        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
         if txtEle is False:
             self.tmpEle.append(eth.getElement(eleName, t, **attribs))
@@ -123,7 +139,7 @@ class QuestionParser:
             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"""
+        """Appends 1 to 1 mapped Elements defined in the parserSettings to the element."""
         parser = ["Parser"]
         if isinstance(self, MCQuestionParser):
             parser.append("MCParser")
@@ -136,17 +152,16 @@ class QuestionParser:
             except KeyError as e:
                 msg = f"Invalider Input aus den Einstellungen Parser: {
                     type(p) =}"
-                logger.error(msg, exc_info=e)
+                self.logger.exception(msg, exc_info=e)
                 raise QNotParsedException(msg, self.question.id, exc_info=e)
-        return None
 
     def parse(self, xmlTree: ET._Element | None = None) -> None:
-        """Parses the Question
+        """Parse the Question.
 
         Generates an new Question Element stored as ``self.tmpEle:ET.Element``
         if no Exceptions are raised, ``self.tmpEle`` is passed to ``self.question.element``
         """
-        logger.info(f"Starting to parse {self.question.id}")
+        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)
@@ -167,9 +182,8 @@ class QuestionParser:
         if ansList is not None:
             for ele in ansList:
                 self.tmpEle.append(ele)
-        logger.info(f"Sucessfully parsed {self.question.id}")
+        self.logger.info("Sucessfully parsed")
         self.question.element = self.tmpEle
-        return None
 
     def getFeedBEle(
         self,
@@ -177,10 +191,7 @@ class QuestionParser:
         text: str | None = None,
         style: TextElements | None = None,
     ) -> ET.Element:
-        if style is None:
-            span = feedBElements[feedback]
-        else:
-            span = style.create()
+        span = feedBElements[feedback] if style is None else style.create()
         if text is None:
             text = feedbackStr[feedback]
         ele = ET.Element(feedback, format="html")
@@ -191,49 +202,60 @@ class QuestionParser:
         return ele
 
     def setAnswers(self) -> list[ET.Element] | None:
-        """Needs to be implemented in the type-specific subclasses"""
+        """Needs to be implemented in the type-specific subclasses."""
         return None
 
-    @staticmethod
     def getNumericAnsElement(
-        result: int | float,
-        tolerance: int = 0,
-        fraction: int | float = 100,
+        self,
+        result: float,
+        tolerance: float = 0,
+        fraction: float = 100,
         format: str = "moodle_auto_format",
     ) -> ET.Element:
-        """Returns an ``<answer/>`` Element specific for the numerical Question
-        The element contains those childs:
+        """Get ``<answer/>`` Element specific for the numerical Question.
+
+        The element contains those children:
             ``<text/>`` which holds the value of the answer
-            ``<tolerace/>`` with the *relative* tolerance for the result in percent
-            ``<feedback/>`` with general feedback for a true answer
+            ``<tolerance/>`` with the *relative* tolerance for the result in percent
+            ``<feedback/>`` with general feedback for a true answer.
         """
-
         ansEle: ET.Element = eth.getTextElement(
-            XMLTags.ANSWER, text=str(result), fraction=str(fraction), format=format
+            XMLTags.ANSWER,
+            text=str(result),
+            fraction=str(fraction),
+            format=format,
         )
         ansEle.append(
             eth.getFeedBEle(
                 XMLTags.ANSFEEDBACK,
                 feedbackStr["right1Percent"],
                 TextElements.SPANGREEN,
-            )
+            ),
         )
-        if tolerance == 0:
-            try:
-                tolerance = int(settings.value(
-                    "parser/nf/tolerance"))
-            except ValueError as e:
-                logger.error(
-                    f"The tolerance Setting is invalid {e} \n using 1% tolerance",
-                    exc_info=e)
-                tolerance = 1
-            logger.debug(f"using tolerance of {tolerance} %")
-        tol = abs(round(result * tolerance, 3))
+        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)
+            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]
@@ -241,12 +263,13 @@ class NFQuestionParser(QuestionParser):
     def setAnswers(self) -> list[ET.Element]:
         result = self.rawInput[DFIndex.RESULT]
         ansEle: list[ET.Element] = []
-        ansEle.append(self.getNumericAnsElement(result=result))
+        tol = self.rawInput[DFIndex.TOLERANCE]
+        ansEle.append(self.getNumericAnsElement(result=result, tolerance=tol))
         return ansEle
 
 
 class NFMQuestionParser(QuestionParser):
-    def __init__(self, *args):
+    def __init__(self, *args) -> None:
         super().__init__(*args)
         self.genFeedbacks = [XMLTags.GENFEEDB]
         self.astEval = Interpreter()
@@ -261,32 +284,28 @@ class NFMQuestionParser(QuestionParser):
             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))
+                    self.getNumericAnsElement(result=round(result, 3), tolerance=tol),
                 )
         self.question.answerVariants = ansElementsList
         self.setVariants(len(ansElementsList))
-        return None
 
-    def setVariants(self, number: int):
+    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 = number if number <= mvar else mvar
+            self.question.category.maxVariants = min(number, mvar)
 
     def _setupAstIntprt(self, var: dict[str, list[float | int]], index: int) -> None:
-        """Ubergibt die Parameter mit entsprechenden Variablen-Namen an den asteval-Interpreter.
-
-        Dann kann dieser die equation lesen.
-        """
+        """Setup the asteval Interpreter with the variables."""
         for name, value in var.items():
             self.astEval.symtable[name] = value[index]
-        return None
 
     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]"""
+        """Liest alle Variablen-Listen deren Name in ``keyList`` ist aus dem DataFrame im Column[index]."""
         dic: dict = {}
         num: int = 0
         for k in keyList:
@@ -299,17 +318,14 @@ class NFMQuestionParser(QuestionParser):
             else:
                 dic[str(k)] = [str(val)]
                 num = 1
-        print(f"Folgende Variablen wurden gefunden:\n{dic}\n")
         return dic, num
 
     @staticmethod
     def _getVarsList(bps: str | list[str]) -> list:
-        """
-        Durchsucht den bulletPoints String nach den Variablen, die als "{var}" gekennzeichnet sind
-        """
+        """Durchsucht den bulletPoints String nach den Variablen, die als "{var}" gekennzeichnet sind."""
         vars = []
         if isinstance(bps, list):
-            for p in bps:
+            for _p in bps:
                 vars.extend(re.findall(r"\{\w\}", str(bps)))
         else:
             vars = re.findall(r"\{\w\}", str(bps))
@@ -329,7 +345,10 @@ class MCQuestionParser(QuestionParser):
         ]
 
     def getAnsElementsList(
-        self, answerList: list, fraction: float = 50, format="html"
+        self,
+        answerList: list,
+        fraction: float = 50,
+        format="html",
     ) -> list[ET.Element]:
         elementList: list[ET.Element] = []
         for ans in answerList:
@@ -337,7 +356,7 @@ class MCQuestionParser(QuestionParser):
             p.text = str(ans)
             text = eth.getCdatTxtElement(p)
             elementList.append(
-                ET.Element(XMLTags.ANSWER, fraction=str(fraction), format=format)
+                ET.Element(XMLTags.ANSWER, fraction=str(fraction), format=format),
             )
             elementList[-1].append(text)
             if fraction < 0:
@@ -346,7 +365,7 @@ class MCQuestionParser(QuestionParser):
                         XMLTags.ANSFEEDBACK,
                         text=feedbackStr["wrong"],
                         style=TextElements.SPANRED,
-                    )
+                    ),
                 )
             elif fraction > 0:
                 elementList[-1].append(
@@ -354,7 +373,7 @@ class MCQuestionParser(QuestionParser):
                         XMLTags.ANSFEEDBACK,
                         text=feedbackStr["right"],
                         style=TextElements.SPANGREEN,
-                    )
+                    ),
                 )
         return elementList
 
@@ -362,15 +381,15 @@ class MCQuestionParser(QuestionParser):
         ansStyle = self.rawInput[DFIndex.ANSTYPE]
         true = stringHelpers.stripWhitespace(self.rawInput[DFIndex.TRUE].split(";"))
         trueAnsList = stringHelpers.texWrapper(true, style=ansStyle)
-        logger.debug(f"got the following true answers \n {trueAnsList=}")
+        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)
-        logger.debug(f"got the following false answers \n {falseAnsList=}")
+        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))
+            self.getAnsElementsList(falseAnsList, fraction=round(falsefrac, 4)),
         )
         return ansList

excel2moodle/core/question.py

@@ -1,22 +1,21 @@
-import base64 as base64
+import base64
 import logging
-import re as re
+import re
 from pathlib import Path
-from typing import Match
+from re import Match
 
 import lxml.etree as ET
 
 from excel2moodle.core import etHelpers
 from excel2moodle.core.exceptions import QNotParsedException
 from excel2moodle.core.globals import (
-    DFIndex,
     TextElements,
     XMLTags,
-    parserSettings,
     questionTypes,
 )
+from excel2moodle.logger import LogAdapterQuestionID
 
-logger = logging.getLogger(__name__)
+loggerObj = logging.getLogger(__name__)
 
 
 class Question:
@@ -28,7 +27,7 @@ class Question:
         parent=None,
         qtype: str = "type",
         points: float = 0,
-    ):
+    ) -> None:
         self.category = category
         self.katName = self.category.name
         self.name = name
@@ -47,7 +46,8 @@ class Question:
         self.variables: dict[str, list[float | int]] = {}
         self.setID()
         self.standardTags = {"hidden": "false"}
-        logger.debug(f"Question {self.id} is initialized")
+        self.logger = LogAdapterQuestionID(loggerObj, {"qID": self.id})
+        self.logger.debug("Sucess initializing")
 
     def __repr__(self) -> str:
         li: list[str] = []
@@ -59,16 +59,17 @@ class Question:
     def assemble(self, variant: int = 1) -> None:
         textElements: list[ET.Element] = []
         textElements.extend(self.qtextParagraphs)
-        logger.debug(f"Starting assembly of {self.id}")
+        self.logger.debug("Starting assembly")
         if self.element is not None:
             mainText = self.element.find(XMLTags.QTEXT)
-            logger.debug(f"found existing Text in element {mainText=}")
+            self.logger.debug(f"found existing Text in element {mainText=}")
             txtele = mainText.find("text")
             if txtele is not None:
                 mainText.remove(txtele)
-                logger.debug(f"removed prevously existing questiontext")
+                self.logger.debug("removed previously existing questiontext")
         else:
-            raise QNotParsedException("Cant assamble, if element is none", self.id)
+            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:
@@ -78,14 +79,13 @@ class Question:
             mainText.append(self.picture.element)
         mainText.append(etHelpers.getCdatTxtElement(textElements))
         # self.element.insert(3, mainText)
-        logger.debug(f"inserted MainText to question element")
+        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)
-                logger.debug("removed previous answer element")
+                self.logger.debug("removed previous answer element")
             self.element.insert(5, self.answerVariants[variant - 1])
-        return None
 
     def setID(self, id=0) -> None:
         if id == 0:
@@ -111,16 +111,17 @@ class Question:
             listItemText = li.text or ""
             bullet = TextElements.LISTITEM.create()
             bullet.text = varPlaceholder.sub(replaceMatch, listItemText)
-            logger.debug(f"Inserted Variables into List: {bullet}")
+            self.logger.debug(f"Inserted Variables into List: {bullet}")
             unorderedList.append(bullet)
         return unorderedList
 
 
 class Picture:
-    def __init__(self, picKey: str, imgFolder: Path, question: Question):
+    def __init__(self, picKey: str, imgFolder: Path, question: Question) -> None:
         self.pic = picKey
         self.ready: bool = False
         self.question = question
+        self.logger = LogAdapterQuestionID(loggerObj, {"qID": self.question.id})
         self.imgFolder = (imgFolder / question.katName).resolve()
         self.htmlTag: ET.Element
         self.path: Path
@@ -128,32 +129,32 @@ class Picture:
         if hasattr(self, "picID"):
             self.ready = self.__getImg()
 
-    def _setPath(self):
+    def _setPath(self) -> None:
         if self.pic == 1:
             self.picID = self.question.id
         else:
             selectedPic = self.pic[2:]
-            logger.debug(f"got a picture key {selectedPic=}")
+            self.logger.debug("Got the picture key: %s", selectedPic)
             try:
-                self.picID = f"{self.question.category.id}{
-                    int(selectedPic):02d}"
+                self.picID = f"{self.question.category.id}{int(selectedPic):02d}"
             except ValueError as e:
-                logger.warning(
-                    msg=f"Bild-ID konnte aus dem Key: {
-                        self.pic=}nicht festgestellt werden",
+                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:
-            img64 = base64.b64encode(img.read()).decode("utf-8")
-        return img64
+            return base64.b64encode(img.read()).decode("utf-8")
 
     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"""
+        """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"
+            "file",
+            name=f"{self.path.name}",
+            path="/",
+            encoding="base64",
         )
         self.element.text = self.__getBase64Img(self.path)
 
@@ -168,8 +169,9 @@ class Picture:
             )
             return True
         except FileNotFoundError as e:
-            logger.warning(
-                msg=f"Bild {self.picID} konnte nicht gefunden werden ", exc_info=e
+            self.logger.warning(
+                msg=f"Bild {self.picID} konnte nicht gefunden werden ",
+                exc_info=e,
             )
             self.element = None
             return False