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

excel2moodle/__main__.py

@@ -9,7 +9,7 @@ from PySide6 import QtWidgets, sys
 import excel2moodle
 from excel2moodle import e2mMetadata, mainLogger
 from excel2moodle.core import dataStructure
-from excel2moodle.core.settings import Settings, SettingsKey
+from excel2moodle.core.settings import Settings, Tags
 from excel2moodle.logger import loggerConfig
 from excel2moodle.ui import appUi as ui
 
@@ -17,7 +17,7 @@ from excel2moodle.ui import appUi as ui
 def main() -> None:
     excel2moodle.isMain = True
     settings = Settings()
-    logfile = Path(settings.get(SettingsKey.LOGFILE)).resolve()
+    logfile = Path(settings.get(Tags.LOGFILE)).resolve()
     e2mMetadata["logfile"] = logfile
     if logfile.exists() and logfile.is_file():
         logfile.replace(f"{logfile}.old")

excel2moodle/core/__init__.py

@@ -1,11 +1 @@
 """These Modules are the heart of the excel2moodle Package."""
-
-# from pandas._config import config
-# from excel2moodle.core  import questionWriter
-# from  excel2moodle.core import stringHelpers
-# from excel2moodle.core import numericMultiQ
-# from excel2moodle.core import globals
-# from PySide6.QtCore import QObject, Signal
-# import logging as logging
-# from logging import config as logConfig
-#

excel2moodle/core/category.py

@@ -1,4 +1,5 @@
 import logging
+import re
 from typing import TYPE_CHECKING
 
 import lxml.etree as ET
@@ -15,7 +16,6 @@ class Category:
 
     def __init__(
         self,
-        n: int,
         name: str,
         description: str,
         dataframe: pd.DataFrame,
@@ -23,8 +23,9 @@ class Category:
         version: int = 0,
     ) -> None:
         """Instantiate a new Category object."""
-        self.n = n
         self.NAME = name
+        match = re.search(r"\d+$", self.NAME)
+        self.n: int = int(match.group(0)) if match else 99
         self.desc = str(description)
         self.dataframe: pd.DataFrame = dataframe
         self.points = points
@@ -56,6 +57,6 @@ class Category:
         info = ET.SubElement(header, "info", format="html")
         ET.SubElement(cat, "text").text = f"$module$/top/{self.NAME}"
         ET.SubElement(info, "text").text = str(self.desc)
-        ET.SubElement(header, "idnumber").text = str(self.n)
+        ET.SubElement(header, "idnumber").text = self.id
         ET.indent(header)
         return header

excel2moodle/core/dataStructure.py

@@ -4,6 +4,7 @@ At the heart is the class ``xmlTest``
 """
 
 import logging
+import sys
 from concurrent.futures import ProcessPoolExecutor, as_completed
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -16,12 +17,13 @@ from PySide6.QtCore import QObject, Signal
 from excel2moodle.core import stringHelpers
 from excel2moodle.core.category import Category
 from excel2moodle.core.exceptions import InvalidFieldException, QNotParsedException
-from excel2moodle.core.globals import DFIndex
+from excel2moodle.core.globals import Tags
 from excel2moodle.core.question import Question
-from excel2moodle.core.settings import Settings, SettingsKey
+from excel2moodle.core.settings import Settings
 from excel2moodle.core.validator import Validator
 from excel2moodle.logger import LogAdapterQuestionID
 from excel2moodle.question_types import QuestionTypeMapping
+from excel2moodle.question_types.cloze import ClozeQuestion, ClozeQuestionParser
 from excel2moodle.question_types.mc import MCQuestion, MCQuestionParser
 from excel2moodle.question_types.nf import NFQuestion, NFQuestionParser
 from excel2moodle.question_types.nfm import NFMQuestion, NFMQuestionParser
@@ -49,6 +51,7 @@ def processSheet(sheetPath: str, categoryName: str) -> pd.DataFrame:
         sheet_name=str(categoryName),
         index_col=0,
         header=None,
+        engine="calamine",
     )
 
 
@@ -64,6 +67,7 @@ class QuestionDB:
     nfParser: NFQuestionParser = NFQuestionParser()
     nfmParser: NFMQuestionParser = NFMQuestionParser()
     mcParser: MCQuestionParser = MCQuestionParser()
+    clozeParser: ClozeQuestionParser = ClozeQuestionParser()
 
     def __init__(self, settings: Settings) -> None:
         self.settings = settings
@@ -72,7 +76,7 @@ class QuestionDB:
         self.categoriesMetaData: pd.DataFrame
         self.categories: dict[str, Category]
 
-    def readCategoriesMetadata(self, sheetPath: Path) -> None:
+    def readCategoriesMetadata(self, sheetPath: Path) -> pd.DataFrame:
         """Read the metadata and questions from the spreadsheet.
 
         Get the category data from the spreadsheet and stores it in the
@@ -86,22 +90,35 @@ class QuestionDB:
                 f,
                 sheet_name="settings",
                 index_col=0,
+                engine="calamine",
             )
             logger.debug("Found the settings: \n\t%s", settingDf)
-            self._setProjectSettings(settingDf)
+            self._setProjectSettings(settingDf, mainPath=sheetPath.parent)
         with Path(sheetPath).open("rb") as f:
             self.categoriesMetaData = pd.read_excel(
                 f,
-                sheet_name=self.settings.get(SettingsKey.CATEGORIESSHEET),
+                sheet_name=self.settings.get(Tags.CATEGORIESSHEET),
                 index_col=0,
+                engine="calamine",
             )
             logger.info(
                 "Sucessfully read categoriesMetaData \n %s", self.categoriesMetaData
             )
+        return self.categoriesMetaData
 
-    def _setProjectSettings(self, settings: pd.DataFrame) -> None:
+    def _setProjectSettings(
+        self, settings: pd.DataFrame, mainPath: Path | None = None
+    ) -> None:
+        settings = self.harmonizeDFIndex(settings)
         for tag, value in settings.iterrows():
             self.settings.set(tag, value.iloc[0], local=True)
+        extraModule = self.settings.get(Tags.IMPORTMODULE)
+        if extraModule:
+            logger.warning(
+                "Appending: %s to sys.path. All names defined by it will be usable",
+                mainPath,
+            )
+            sys.path.append(str(mainPath))
 
     def initAllCategories(self, sheetPath: Path) -> None:
         """Read all category sheets and initialize all Categories."""
@@ -112,11 +129,10 @@ class QuestionDB:
             self.categories.clear()
         else:
             self.categories: dict[str, Category] = {}
-        with Path(sheetPath).open("rb") as f:
-            excelFile = pd.ExcelFile(f)
+        with pd.ExcelFile(sheetPath, engine="calamine") as excelFile:
             for categoryName in excelFile.sheet_names:
                 logger.debug("Starting to read category %s", categoryName)
-                if categoryName.startswith("KAT"):
+                if categoryName in self.categoriesMetaData.index:
                     self.initCategory(sheetPath, categoryName)
 
     def asyncInitAllCategories(self, sheetPath: Path) -> None:
@@ -132,71 +148,83 @@ class QuestionDB:
             self.categories.clear()
         else:
             self.categories: dict[str, Category] = {}
-        sheet_names = []
-        with Path(sheetPath).open("rb") as f:
-            excel_file = pd.ExcelFile(f)
-            sheet_names = [
-                name for name in excel_file.sheet_names if name.startswith("KAT_")
+        sheetNames = []
+        with pd.ExcelFile(sheetPath, engine="calamine") as excelFile:
+            sheetNames = [
+                name
+                for name in excelFile.sheet_names
+                if name in self.categoriesMetaData.index
             ]
-        logger.debug("found those caetegory sheets: \n %s ", sheet_names)
+        logger.debug("found those category sheets: \n %s ", sheetNames)
         with ProcessPoolExecutor() as executor:
             futures = {
                 executor.submit(processSheet, str(sheetPath), sheet): sheet
-                for sheet in sheet_names
+                for sheet in sheetNames
             }
             for future in as_completed(futures):
                 categoryName = futures[future]
                 try:
                     categoryDataF = future.result()
-                    categoryNumber = int(categoryName[4:])
-                    self._setupCategory(categoryDataF, categoryName, categoryNumber)
+                    self._setupCategory(categoryDataF, categoryName)
                     logger.debug("Finished processing %s", categoryName)
                 except Exception as e:
                     logger.exception("Error processing sheet %s: %s", categoryName, e)
                     logger.debug("Future exception: %s", future.exception())
 
-    def initCategory(self, sheetPath: Path, categoryName: str) -> None:
-        """Read `categoryName` from the file ``sheetPath`` and initialize the category."""
-        categoryNumber = int(categoryName[4:])
+    def initCategory(self, sheetPath: Path, categoryName: str) -> bool | Category:
+        """Read `categoryName` from the ``sheetPath`` and initialize the category.
+        Returns the Category and appends it to `self.categories`.
+        """
         katDf = pd.read_excel(
             sheetPath,
             sheet_name=str(categoryName),
             index_col=0,
             header=None,
+            engine="calamine",
         )
         if not katDf.empty:
             logger.debug("Sucessfully read the Dataframe for cat %s", categoryName)
-            self._setupCategory(katDf, categoryName, categoryNumber)
-
-    def _setupCategory(
-        self, categoryDf: pd.DataFrame, categoryName: str, categoryNumber: int
-    ) -> None:
+            return self._setupCategory(katDf, categoryName)
+        return False
+
+    @staticmethod
+    def harmonizeDFIndex(dataframe: pd.DataFrame) -> pd.DataFrame:
+        """Convert the index strings to lowercase without whitespace."""
+        index = dataframe.index.str.lower()
+        harmonizedIdx = ["".join(i.split()) if pd.notna(i) else i for i in index]
+        dataframe.index = pd.Index(harmonizedIdx)
+        return dataframe
+
+    def _setupCategory(self, categoryDf: pd.DataFrame, categoryName: str) -> Category:
         """Setup the category from the ``dataframe``.
+
         :emits: categoryReady(self) Signal.
-        """  # noqa: D401
+        """
+        categoryDf = self.harmonizeDFIndex(categoryDf)
         points = (
-            self.categoriesMetaData["points"].iloc[categoryNumber - 1]
+            self.categoriesMetaData["points"].loc[categoryName]
             if "points" in self.categoriesMetaData
-            and not pd.isna(self.categoriesMetaData["points"]).iloc[categoryNumber - 1]
-            else self.settings.get(SettingsKey.POINTS)
+            and not pd.isna(self.categoriesMetaData["points"]).loc[categoryName]
+            else self.settings.get(Tags.POINTS)
         )
         version = (
-            self.categoriesMetaData["version"].iloc[categoryNumber - 1]
+            self.categoriesMetaData["version"].loc[categoryName]
             if "version" in self.categoriesMetaData
-            and not pd.isna(self.categoriesMetaData["version"].iloc[categoryNumber - 1])
-            else self.settings.get(SettingsKey.VERSION)
+            and not pd.isna(self.categoriesMetaData["version"].loc[categoryName])
+            else self.settings.get(Tags.VERSION)
         )
         category = Category(
-            categoryNumber,
             categoryName,
-            self.categoriesMetaData["description"].iloc[categoryNumber - 1],
+            self.categoriesMetaData["description"].loc[categoryName],
             dataframe=categoryDf,
             points=points,
             version=version,
         )
-        self.categories[categoryName] = category
+        if hasattr(self, "categories"):
+            self.categories[categoryName] = category
+            self.signals.categoryReady.emit(category)
         logger.debug("Category %s is initialized", categoryName)
-        self.signals.categoryReady.emit(category)
+        return category
 
     def parseAllQuestions(self) -> None:
         """Parse all question from all categories.
@@ -214,13 +242,12 @@ class QuestionDB:
         for qNum in category.dataframe.columns:
             try:
                 self.setupAndParseQuestion(category, qNum)
-            except (InvalidFieldException, QNotParsedException, ValueError) as e:
+            except (InvalidFieldException, QNotParsedException):
                 logger.exception(
                     "Question %s%02d couldn't be parsed. The Question Data: \n %s",
                     category.id,
                     qNum,
                     category.dataframe[qNum],
-                    exc_info=e,
                 )
         self.signals.categoryQuestionsReady.emit(category)
 
@@ -255,30 +282,33 @@ class QuestionDB:
             raise QNotParsedException(msg, f"{category.id}{qNumber}")
         cls.validator.setup(qdat, qNumber)
         cls.validator.validate()
-        validData = cls.validator.getQuestionRawData()
-        qtype: str = str(validData.get(DFIndex.TYPE))
-        category.questions[qNumber] = QuestionTypeMapping[qtype].create(
-            category, validData
-        )
-        question = category.questions[qNumber]
-        if question.element is not None:
+        validData = cls.validator.getQuestionData()
+        qtype: str = validData.get(Tags.TYPE)
+        logger.debug("Question type is: %s", qtype)
+        question = QuestionTypeMapping[qtype].create(category, validData)
+        if question.isParsed:
             locallogger.info("Question already parsed")
             return
         if isinstance(question, NFQuestion):
             cls.nfParser.setup(question)
-            cls.nfParser.parse()
             locallogger.debug("setup a new NF parser ")
+            cls.nfParser.parse()
         elif isinstance(question, MCQuestion):
             cls.mcParser.setup(question)
-            cls.mcParser.parse()
             locallogger.debug("setup a new MC parser ")
+            cls.mcParser.parse()
         elif isinstance(question, NFMQuestion):
             cls.nfmParser.setup(question)
-            cls.nfmParser.parse()
             locallogger.debug("setup a new NFM parser ")
+            cls.nfmParser.parse()
+        elif isinstance(question, ClozeQuestion):
+            cls.clozeParser.setup(question)
+            locallogger.debug("setup a new CLOZE parser")
+            cls.clozeParser.parse()
         else:
             msg = "couldn't setup Parser"
             raise QNotParsedException(msg, question.id)
+        category.questions[qNumber] = question
 
     def appendQuestions(
         self, questions: list[QuestionItem], file: Path | None = None
@@ -293,15 +323,15 @@ class QuestionDB:
                 catdict[cat] = []
             catdict[cat].append(q.getQuestion())
         for cat, qlist in catdict.items():
-            self.appendQElements(
+            self._appendQElements(
                 cat,
                 qlist,
                 tree=tree,
-                includeHeader=self.settings.get(SettingsKey.INCLUDEINCATS),
+                includeHeader=self.settings.get(Tags.INCLUDEINCATS),
             )
         stringHelpers.printDom(tree, file=file)
 
-    def appendQElements(
+    def _appendQElements(
         self,
         cat: Category,
         qList: list[Question],
@@ -311,9 +341,9 @@ class QuestionDB:
         if includeHeader:
             tree.append(cat.getCategoryHeader())
             logger.debug(f"Appended a new category item {cat=}")
-        variant: int = self.settings.get(SettingsKey.QUESTIONVARIANT)
+        variant: int = self.settings.get(Tags.QUESTIONVARIANT)
         for q in qList:
-            if q.variants is not None:
+            if hasattr(q, "variants") and q.variants is not None:
                 if variant == 0 or variant > q.variants:
                     dialog = QuestionVariantDialog(self.window, q)
                     if dialog.exec() == QtWidgets.QDialog.Accepted:
@@ -321,7 +351,5 @@ class QuestionDB:
                         logger.debug("Die Fragen-Variante %s wurde gewählt", variant)
                     else:
                         logger.warning("Keine Fragenvariante wurde gewählt.")
-                q.assemble(variant)
-            else:
-                q.assemble()
+            q.assemble(variant=variant)
             tree.append(q.element)

excel2moodle/core/etHelpers.py

@@ -8,7 +8,7 @@ import lxml.etree as ET
 import excel2moodle.core.etHelpers as eth
 from excel2moodle.core.globals import TextElements, feedbackStr, feedBElements
 
-from .globals import DFIndex, XMLTags
+from .globals import Tags, XMLTags
 
 
 def getElement(eleName: str, text: str, **attribs) -> ET.Element:
@@ -27,7 +27,7 @@ def getElement(eleName: str, text: str, **attribs) -> ET.Element:
     return toEle
 
 
-def getTextElement(eleName: str, text: str | DFIndex, **attribs) -> ET.Element:
+def getTextElement(eleName: str, text: str | Tags, **attribs) -> ET.Element:
     """Creates two nested elements: ``eleName`` with child ``text`` which holds the text."""
     toEle = ET.Element(eleName, **attribs)
     child = getElement("text", text)

excel2moodle/core/exceptions.py

@@ -1,4 +1,4 @@
-from excel2moodle.core.globals import DFIndex
+from excel2moodle.core.globals import Tags
 
 
 class QNotParsedException(Exception):
@@ -18,7 +18,7 @@ class InvalidFieldException(Exception):
         self,
         message: str,
         qID: str,
-        field: DFIndex | list[DFIndex],
+        field: Tags | list[Tags],
         *args: object,
         **kwargs,
     ) -> None:

excel2moodle/core/globals.py

@@ -2,33 +2,16 @@ from enum import Enum, StrEnum
 
 import lxml.etree as ET
 
-questionTypes = {
+from excel2moodle.core.settings import Tags
+
+QUESTION_TYPES = {
     "NF": "numerical",
     "NFM": "numerical",
     "MC": "multichoice",
+    "CLOZE": "cloze",
 }
 
 
-class DFIndex(StrEnum):
-    """The identifier string for for the spreadsheet and the string for the xml-tag.
-
-    Each enum corresponds to a list of two values.
-    The first Value is the index in the spreadsheet, the second is the name of the xml-tag
-    """
-
-    TEXT = "text"
-    BPOINTS = "bulletPoint"
-    TRUE = "true"
-    FALSE = "false"
-    TYPE = "type"
-    NAME = "name"
-    RESULT = "result"
-    PICTURE = "picture"
-    NUMBER = "number"
-    ANSTYPE = "answerType"
-    TOLERANCE = "tolerance"
-
-
 class TextElements(Enum):
     PLEFT = "p", "text-align: left;"
     SPANRED = "span", "color: rgb(239, 69, 64)"
@@ -58,15 +41,15 @@ class TextElements(Enum):
 
 
 class XMLTags(StrEnum):
-    def __new__(cls, value: str, dfkey: DFIndex | None = None):
+    def __new__(cls, value: str, dfkey: Tags | None = None):
         obj = str.__new__(cls, value)
         obj._value_ = value
         if dfkey is not None:
             obj._dfkey_ = dfkey
         return obj
 
-    def __init__(self, _: str, dfkey: DFIndex | None = None, getEle=None) -> None:
-        if isinstance(dfkey, DFIndex):
+    def __init__(self, _: str, dfkey: Tags | None = None, getEle=None) -> None:
+        if isinstance(dfkey, Tags):
             self._dfkey_: str = dfkey
         if getEle:
             self._getEle_: object = getEle
@@ -85,11 +68,11 @@ class XMLTags(StrEnum):
             msg.append(f"Df Key {self.dfkey=}")
         return "\n".join(msg)
 
-    NAME = "name", DFIndex.NAME
-    QTEXT = "questiontext", DFIndex.TEXT
+    NAME = "name", Tags.NAME
+    QTEXT = "questiontext", Tags.TEXT
     QUESTION = "question"
     TEXT = "text"
-    PICTURE = "file", DFIndex.PICTURE
+    PICTURE = "file", Tags.PICTURE
     GENFEEDB = "generalfeedback"
     CORFEEDB = "correctfeedback"
     PCORFEEDB = "partialcorrectfeedback"

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