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

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,154 @@ 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()
+        textParts = self._assembleMainTextParts()
+        self.logger.debug("Starting assembly")
+        if hasattr(self, "picture") and self.picture.ready:
+            self._appendPicture(textParts, mainText)
+        self.logger.debug("inserted MainText to element")
+        self._setAnswerElement(variant=variant)
+        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.
+        """
+        textParts: list[ET.Element] = []
+        textParts.extend(self.qtextParagraphs)
+        bullets = self._getBPoints(variant=variant)
+        if bullets is not None:
+            textParts.append(bullets)
+        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 +167,40 @@ 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 _appendPicture(self, textParts: list[ET.Element], mainText: ET.Element) -> None:
+        textParts.append(self.picture.htmlTag)
+        mainText.append(self.picture.element)
+
+    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",

excel2moodle/core/settings.py

@@ -12,9 +12,10 @@ import excel2moodle
 logger = logging.getLogger(__name__)
 
 
-class SettingsKey(StrEnum):
-    """Settings Keys are needed to always acess the correct Value.
+class Tags(StrEnum):
+    """Tags and Settings Keys are needed to always acess the correct Value.
 
+    The Tags can be used to acess the settings or the QuestionData respectively.
     As the QSettings settings are accesed via strings, which could easily gotten wrong.
     Further, this Enum defines, which type a setting has to be.
     """
@@ -22,23 +23,27 @@ class SettingsKey(StrEnum):
     def __new__(
         cls,
         key: str,
-        place: str,
         typ: type,
         default: str | float | Path | bool | None,
+        place: str = "project",
     ):
         """Define new settings class."""
         obj = str.__new__(cls, key)
         obj._value_ = key
-        obj._place_ = place
-        obj._default_ = default
         obj._typ_ = typ
+        obj._default_ = default
+        obj._place_ = place
         return obj
 
     def __init__(
-        self, _, place: str, typ: type, default: str | float | Path | None
+        self,
+        _,
+        typ: type,
+        default: str | float | Path | None,
+        place: str = "project",
     ) -> None:
-        self._typ_ = typ
-        self._place_ = place
+        self._typ_: type = typ
+        self._place_: str = place
         self._default_ = default
         self._full_ = f"{self._place_}/{self._value_}"
 
@@ -56,22 +61,39 @@ class SettingsKey(StrEnum):
         return self._full_
 
     def typ(self) -> type:
-        """Get default value for the key."""
+        """Get type of the keys data."""
         return self._typ_
 
-    QUESTIONVARIANT = "defaultQuestionVariant", "testgen", int, 0
-    INCLUDEINCATS = "includeCats", "testgen", bool, False
-    TOLERANCE = "tolerance", "parser/nf", int, 1
-    PICTUREFOLDER = "pictureFolder", "core", Path, None
-    SPREADSHEETFOLDER = "spreadsheetFolder", "core", Path, None
-    LOGLEVEL = "loglevel", "core", str, "INFO"
-    LOGFILE = "logfile", "core", str, "excel2moodleLogFile.log"
-    CATEGORIESSHEET = "categoriesSheet", "core", str, "Kategorien"
-    VERSION = "version", "project", int, 1
-    POINTS = "points", "project", float, 1.0
-    PICTURESUBFOLDER = "imgFolder", "project", str, "Abbildungen"
-    PICTUREWIDTH = "imgWidth", "project", int, 500
-    ANSPICWIDTH = "answerImgWidth", "project", int, 120
+    QUESTIONVARIANT = "defaultQuestionVariant", int, 0, "testgen"
+    INCLUDEINCATS = "includeCats", bool, False, "testgen"
+    TOLERANCE = "tolerance", float, 0.01, "parser/nf"
+    PICTUREFOLDER = "pictureFolder", Path, None, "core"
+    PICTURESUBFOLDER = "imgfolder", str, "Abbildungen", "project"
+    SPREADSHEETPATH = "spreadsheetFolder", Path, None, "core"
+    LOGLEVEL = "loglevel", str, "INFO", "core"
+    LOGFILE = "logfile", str, "excel2moodleLogFile.log", "core"
+    CATEGORIESSHEET = "categoriessheet", str, "Kategorien", "core"
+
+    IMPORTMODULE = "importmodule", str, None
+    TEXT = "text", list, None
+    BPOINTS = "bulletpoint", list, None
+    TRUE = "true", list, None
+    FALSE = "false", list, None
+    TYPE = "type", str, None
+    NAME = "name", str, None
+    RESULT = "result", float, None
+    EQUATION = "formula", str, None
+    PICTURE = "picture", str, False
+    NUMBER = "number", int, None
+    ANSTYPE = "answertype", str, None
+    QUESTIONPART = "part", list, None
+    PARTTYPE = "parttype", str, None
+    VERSION = "version", int, 1
+    POINTS = "points", float, 1.0
+    PICTUREWIDTH = "imgwidth", int, 500
+    ANSPICWIDTH = "answerimgwidth", int, 120
+    WRONGSIGNPERCENT = "wrongsignpercentage", int, 50
+    FIRSTRESULT = "firstresult", float, None
 
 
 class Settings(QSettings):
@@ -85,52 +107,58 @@ class Settings(QSettings):
         super().__init__("jbosse3", "excel2moodle")
         if excel2moodle.isMainState():
             logger.info("Settings are stored under: %s", self.fileName())
-            if self.contains(SettingsKey.SPREADSHEETFOLDER.full):
-                self.sheet = self.get(SettingsKey.SPREADSHEETFOLDER)
+            if self.contains(Tags.SPREADSHEETPATH.full):
+                self.sheet = self.get(Tags.SPREADSHEETPATH)
                 if self.sheet.is_file():
                     QTimer.singleShot(300, self._emitSpreadsheetChanged)
 
     def _emitSpreadsheetChanged(self) -> None:
         self.shPathChanged.emit(self.sheet)
 
+    @overload
+    def get(
+        self,
+        key: Literal[Tags.POINTS],
+    ) -> float: ...
     @overload
     def get(
         self,
         key: Literal[
-            SettingsKey.QUESTIONVARIANT,
-            SettingsKey.TOLERANCE,
-            SettingsKey.VERSION,
-            SettingsKey.POINTS,
-            SettingsKey.PICTUREWIDTH,
-            SettingsKey.ANSPICWIDTH,
+            Tags.QUESTIONVARIANT,
+            Tags.TOLERANCE,
+            Tags.VERSION,
+            Tags.PICTUREWIDTH,
+            Tags.ANSPICWIDTH,
+            Tags.WRONGSIGNPERCENT,
         ],
     ) -> int: ...
     @overload
-    def get(self, key: Literal[SettingsKey.INCLUDEINCATS]) -> bool: ...
+    def get(self, key: Literal[Tags.INCLUDEINCATS]) -> bool: ...
     @overload
     def get(
         self,
         key: Literal[
-            SettingsKey.PICTURESUBFOLDER,
-            SettingsKey.LOGLEVEL,
-            SettingsKey.LOGFILE,
-            SettingsKey.CATEGORIESSHEET,
+            Tags.PICTURESUBFOLDER,
+            Tags.LOGLEVEL,
+            Tags.LOGFILE,
+            Tags.CATEGORIESSHEET,
+            Tags.IMPORTMODULE,
         ],
     ) -> str: ...
     @overload
     def get(
         self,
-        key: Literal[SettingsKey.PICTUREFOLDER, SettingsKey.SPREADSHEETFOLDER],
+        key: Literal[Tags.PICTUREFOLDER, Tags.SPREADSHEETPATH],
     ) -> Path: ...
 
-    def get(self, key: SettingsKey):
+    def get(self, key: Tags):
         """Get the typesafe settings value.
 
         If local Settings are stored, they are returned.
         If no setting is made, the default value is returned.
         """
-        if key in self.localSettings:
-            val = key.typ()(self.localSettings[key])
+        if key in type(self).localSettings:
+            val = key.typ()(type(self).localSettings[key])
             logger.debug("Returning project setting: %s = %s", key, val)
             return val
         if not excel2moodle.isMainState():
@@ -160,7 +188,7 @@ class Settings(QSettings):
 
     def set(
         self,
-        key: SettingsKey | str,
+        key: Tags | str,
         value: float | bool | Path | str,
         local: bool = False,
     ) -> None:
@@ -177,13 +205,13 @@ class Settings(QSettings):
         if not excel2moodle.isMainState():
             local = True
         if local:
-            if key in SettingsKey:
-                self.localSettings[key] = value
+            if key in Tags:
+                type(self).localSettings[key] = value
                 logger.info("Saved the project setting %s = %s", key, value)
             else:
                 logger.warning("got invalid local Setting %s = %s", key, value)
             return
-        if not local and isinstance(key, SettingsKey):
+        if not local and isinstance(key, Tags):
             if not isinstance(value, key.typ()):
                 logger.error("trying to save setting with wrong type not possible")
                 return
@@ -195,7 +223,7 @@ class Settings(QSettings):
         if isinstance(sheet, Path):
             self.sheet = sheet.resolve(strict=True)
             logpath = str(self.sheet.parent / "excel2moodleLogFile.log")
-            self.set(SettingsKey.LOGFILE, logpath)
-            self.set(SettingsKey.SPREADSHEETFOLDER, self.sheet)
+            self.set(Tags.LOGFILE, logpath)
+            self.set(Tags.SPREADSHEETPATH, self.sheet)
             self.shPathChanged.emit(sheet)
             return

excel2moodle/core/validator.py

@@ -10,19 +10,20 @@ which can be accessed via ``Validator.question``
 """
 
 import logging
-from typing import TYPE_CHECKING
 
 import pandas as pd
 
+from excel2moodle.core import stringHelpers
 from excel2moodle.core.exceptions import InvalidFieldException
-from excel2moodle.core.globals import DFIndex
-
-if TYPE_CHECKING:
-    from types import UnionType
-
+from excel2moodle.core.globals import QUESTION_TYPES, Tags
+from excel2moodle.core.question import QuestionData
+from excel2moodle.core.settings import Settings
+from excel2moodle.question_types import QuestionTypeMapping
 
 logger = logging.getLogger(__name__)
 
+settings = Settings()
+
 
 class Validator:
     """Validate the question data from the spreadsheet.
@@ -30,52 +31,15 @@ class Validator:
     Creates a dictionary with the data, for easier access later.
     """
 
-    def __init__(self) -> None:
-        self.allMandatory: dict[DFIndex, type | UnionType] = {
-            DFIndex.TEXT: str,
-            DFIndex.NAME: str,
-            DFIndex.TYPE: str,
-        }
-        self.allOptional: dict[DFIndex, type | UnionType] = {
-            DFIndex.PICTURE: int | str,
-        }
-        self.nfOpt: dict[DFIndex, type | UnionType] = {
-            DFIndex.BPOINTS: str,
-        }
-        self.nfMand: dict[DFIndex, type | UnionType] = {
-            DFIndex.RESULT: float | int,
-        }
-        self.nfmOpt: dict[DFIndex, type | UnionType] = {}
-        self.nfmMand: dict[DFIndex, type | UnionType] = {
-            DFIndex.RESULT: str,
-            DFIndex.BPOINTS: str,
-        }
-        self.mcOpt: dict[DFIndex, type | UnionType] = {}
-        self.mcMand: dict[DFIndex, type | UnionType] = {
-            DFIndex.TRUE: str,
-            DFIndex.FALSE: str,
-            DFIndex.ANSTYPE: str,
-        }
-
-        self.mapper: dict = {
-            "NF": (self.nfOpt, self.nfMand),
-            "MC": (self.mcOpt, self.mcMand),
-            "NFM": (self.nfmOpt, self.nfmMand),
-        }
-
     def setup(self, df: pd.Series, index: int) -> None:
         self.df = df
         self.index = index
-        self.mandatory = {}
-        self.optional = {}
-        typ = self.df.loc[DFIndex.TYPE]
-        if typ not in self.mapper:
+        typ = self.df.loc[Tags.TYPE]
+        if typ not in QUESTION_TYPES:
             msg = f"No valid question type provided. {typ} is not a known type"
-            raise InvalidFieldException(msg, "index:02d", DFIndex.TYPE)
-        self.mandatory.update(self.allMandatory)
-        self.optional.update(self.allOptional)
-        self.mandatory.update(self.mapper[typ][1])
-        self.optional.update(self.mapper[typ][0])
+            raise InvalidFieldException(msg, "index:02d", Tags.TYPE)
+        self.mandatory = QuestionTypeMapping[typ].value.mandatoryTags
+        self.optional = QuestionTypeMapping[typ].value.optionalTags
 
     def validate(self) -> None:
         qid = f"{self.index:02d}"
@@ -90,9 +54,9 @@ class Validator:
             if missing is not None:
                 raise InvalidFieldException(msg, qid, missing)
 
-    def getQuestionRawData(self) -> dict[str, str | float | list[str]]:
+    def getQuestionData(self) -> QuestionData:
         """Get the data from the spreadsheet as a dictionary."""
-        self.qdata: dict[str, str | float | int | list] = {}
+        self.qdata: dict[str, int | float | list[str] | str] = {}
         for idx, val in self.df.items():
             if not isinstance(idx, str):
                 continue
@@ -106,9 +70,26 @@ class Validator:
                     self.qdata[idx] = [existing, val]
             else:
                 self.qdata[idx] = val
-        return self.qdata
-
-    def _mandatory(self) -> tuple[bool, DFIndex | None]:
+        return self.formatQData()
+
+    def formatQData(self) -> QuestionData:
+        """Format the dictionary to The types for QuestionData."""
+        listTags = (Tags.BPOINTS, Tags.TRUE, Tags.FALSE, Tags.TEXT, Tags.QUESTIONPART)
+        for tag in listTags:
+            for key in self.qdata:
+                if key.startswith(tag) and not isinstance(self.qdata[key], list):
+                    self.qdata[key] = stringHelpers.getListFromStr(self.qdata[key])
+        tol = float(self.qdata.get(Tags.TOLERANCE, 0))
+        if tol <= 0 or tol > 99:
+            self.qdata[Tags.TOLERANCE] = settings.get(Tags.TOLERANCE)
+        else:
+            self.qdata[Tags.TOLERANCE] = tol if tol < 1 else tol / 100
+
+        if self.qdata[Tags.TYPE] == "NFM":
+            self.qdata[Tags.EQUATION] = str(self.qdata[Tags.RESULT])
+        return QuestionData(self.qdata)
+
+    def _mandatory(self) -> tuple[bool, Tags | None]:
         """Detects if all keys of mandatory are filled with values."""
         checker = pd.Series.notna(self.df)
         for k in self.mandatory:
@@ -123,8 +104,8 @@ class Validator:
                 return False, k
         return True, None
 
-    def _typeCheck(self) -> tuple[bool, list[DFIndex] | None]:
-        invalid: list[DFIndex] = []
+    def _typeCheck(self) -> tuple[bool, list[Tags] | None]:
+        invalid: list[Tags] = []
         for field, typ in self.mandatory.items():
             if field in self.df and isinstance(self.df[field], pd.Series):
                 for f in self.df[field]: