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

excel2moodle/core/parser.py

@@ -3,7 +3,6 @@ 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,7 +13,6 @@ from excel2moodle.core.globals import (
     XMLTags,
     feedbackStr,
     feedBElements,
-    parserSettings,
 )
 from excel2moodle.core.question import Picture, Question
 from excel2moodle.logger import LogAdapterQuestionID
@@ -32,16 +30,19 @@ class QuestionParser:
     Important to implement the answers methods.
     """
 
-    def __init__(self, question: Question, data: dict) -> None:
+    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."""
@@ -75,12 +76,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 +91,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 +139,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 +152,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 +159,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()
@@ -251,145 +237,3 @@ class QuestionParser:
         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))
-        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,14 +1,17 @@
 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,
@@ -19,22 +22,37 @@ loggerObj = logging.getLogger(__name__)
 
 
 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,7 +63,6 @@ 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")
 
@@ -143,11 +160,11 @@ class Picture:
                     exc_info=e,
                 )
 
-    def __getBase64Img(self, imgPath):
+    def _getBase64Img(self, imgPath):
         with open(imgPath, "rb") as img:
             return base64.b64encode(img.read()).decode("utf-8")
 
-    def __setImgElement(self, dir: Path, picID: int) -> None:
+    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(
@@ -156,11 +173,11 @@ class Picture:
             path="/",
             encoding="base64",
         )
-        self.element.text = self.__getBase64Img(self.path)
+        self.element.text = self._getBase64Img(self.path)
 
     def __getImg(self) -> bool:
         try:
-            self.__setImgElement(self.imgFolder, int(self.picID))
+            self._setImgElement(self.imgFolder, int(self.picID))
             self.htmlTag = ET.Element(
                 "img",
                 src=f"@@PLUGINFILE@@/{self.path.name}",

excel2moodle/core/stringHelpers.py

@@ -6,9 +6,11 @@ from pathlib import Path
 import lxml.etree as ET
 
 
-def stripWhitespace(stringList):
-    stripped = []
-    for i in stringList:
+def getListFromStr(stringList: str) -> list[str]:
+    """Get a python List of strings from a semi-colon separated string."""
+    stripped: list[str] = []
+    li = stringList.split(";")
+    for i in li:
         s = i.strip()
         if s:
             stripped.append(s)
@@ -20,32 +22,6 @@ def stringToFloat(string: str) -> float:
     return float(string)
 
 
-def get_bullet_string(s):
-    """Formatiert die Angaben zum Statischen System hübsch."""
-    split = s.split(";")
-    s_spl = stripWhitespace(split)
-    name = []
-    var = []
-    quant = []
-    unit = []
-    for sc in s_spl:
-        sc_split = sc.split()
-        name.append(sc_split[0])
-        var.append(sc_split[1])
-        quant.append(sc_split[3])
-        unit.append(sc_split[4])
-    bulletString = ['</p><ul dir="ltr">']
-    for i in range(len(s_spl)):
-        num = quant[i].split(",")
-        num_s = f"{num[0]!s},\\!{num[1]!s}~" if len(num) == 2 else f"{num[0]!s},\\!0~"
-        bulletString.append('<li style="text-align: left;">')
-        bulletString.append(
-            f"{name[i]}: \\( {var[i]} = {num_s} \\mathrm{{ {unit[i]}  }}\\) </li>\n",
-        )
-    bulletString.append("<br></ul>")
-    return "\n".join(bulletString)
-
-
 def getBase64Img(imgPath):
     with open(imgPath, "rb") as img:
         return base64.b64encode(img.read()).decode("utf-8")
@@ -62,7 +38,7 @@ def getUnitsElementAsString(unit) -> None:
 
 
 def printDom(xmlElement: ET.Element, file: Path | None = None) -> None:
-    """Prints the document tree of ``xmlTree`` to the ``file``, if specified, else dumps to stdout."""
+    """Prints the document tree of ``xmlTree`` to ``file``, if specified, else dumps to stdout."""
     documentTree = ET.ElementTree(xmlElement)
     if file is not None:
         if file.parent.exists():
@@ -73,11 +49,11 @@ def printDom(xmlElement: ET.Element, file: Path | None = None) -> None:
                 pretty_print=True,
             )
     else:
-        pass
+        print(xmlElement.tostring())  # noqa: T201
 
 
 def texWrapper(text: str | list[str], style: str) -> list[str]:
-    r"""Puts the strings inside ``text`` into a LaTex environment.
+    r"""Put the strings inside ``text`` into a LaTex environment.
 
     if ``style == unit``: inside ``\\mathrm{}``
     if ``style == math``: inside ``\\( \\)``

excel2moodle/core/{questionValidator.py → validator.py}

@@ -16,11 +16,11 @@ import pandas as pd
 
 from excel2moodle.core.exceptions import InvalidFieldException
 from excel2moodle.core.globals import DFIndex
-from excel2moodle.core.question import Question
 
 if TYPE_CHECKING:
     from types import UnionType
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -30,25 +30,25 @@ class Validator:
     Creates a dictionary with the data, for easier access later.
     """
 
-    def __init__(self, category) -> None:
-        self.question: Question
-        self.category = category
-        self.mandatory: dict[DFIndex, type | UnionType] = {
+    def __init__(self) -> None:
+        self.allMandatory: dict[DFIndex, type | UnionType] = {
             DFIndex.TEXT: str,
             DFIndex.NAME: str,
             DFIndex.TYPE: str,
         }
-        self.optional: dict[DFIndex, type | UnionType] = {
-            DFIndex.BPOINTS: str,
+        self.allOptional: dict[DFIndex, type | UnionType] = {
             DFIndex.PICTURE: int | str,
         }
-        self.nfOpt: dict[DFIndex, type | UnionType] = {}
+        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] = {
@@ -63,31 +63,35 @@ class Validator:
             "NFM": (self.nfmOpt, self.nfmMand),
         }
 
-    def setup(self, df: pd.Series, index: int) -> bool:
+    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:
+            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])
-        return True
 
-    def validate(self) -> bool:
-        id = f"{self.category.id}{self.index:02d}"
+    def validate(self) -> None:
+        qid = f"{self.index:02d}"
         checker, missing = self._mandatory()
         if not checker:
-            msg = f"Question {id} misses the key {missing}"
+            msg = f"Question {qid} misses the key {missing}"
             if missing is not None:
-                raise InvalidFieldException(msg, id, missing)
+                raise InvalidFieldException(msg, qid, missing)
         checker, missing = self._typeCheck()
         if not checker:
-            msg = f"Question {id} has wrong typed data {missing}"
+            msg = f"Question {qid} has wrong typed data {missing}"
             if missing is not None:
-                raise InvalidFieldException(msg, id, missing)
-        self._getQuestion()
-        self._getData()
-        return True
+                raise InvalidFieldException(msg, qid, missing)
 
-    def _getData(self) -> None:
+    def getQuestionRawData(self) -> dict[str, str | float | list[str]]:
+        """Get the data from the spreadsheet as a dictionary."""
         self.qdata: dict[str, str | float | int | list] = {}
         for idx, val in self.df.items():
             if not isinstance(idx, str):
@@ -100,6 +104,7 @@ class Validator:
                     self.qdata[idx] = [existing, val]
             else:
                 self.qdata[idx] = val
+        return self.qdata
 
     def _mandatory(self) -> tuple[bool, DFIndex | None]:
         """Detects if all keys of mandatory are filled with values."""
@@ -127,18 +132,8 @@ class Validator:
                 invalid.append(field)
         for field, typ in self.optional.items():
             if field in self.df:
-                if not isinstance(self.df[field], typ) and pd.notna(self.df[field]):
+                if pd.notna(self.df[field]) and not isinstance(self.df[field], typ):
                     invalid.append(field)
         if len(invalid) == 0:
             return True, None
         return False, invalid
-
-    def _getQuestion(self) -> None:
-        name = self.df[DFIndex.NAME]
-        qtype = self.df[DFIndex.TYPE]
-        self.question = Question(
-            self.category,
-            name=str(name),
-            number=self.index,
-            qtype=str(qtype),
-        )

excel2moodle/logger.py

@@ -90,7 +90,6 @@ class LogWindowHandler(logging.Handler):
         log_message = self.format(record)
         color = self.logLevelColors.get(record.levelname, "black")
         prettyMessage = f'<span style="color:{color};">{log_message}</span>'
-        print("emitting new log signal")  # noqa:T201
         self.emitter.signal.emit(prettyMessage)
 
 

excel2moodle/question_types/__init__.py

@@ -0,0 +1,33 @@
+"""Implementations of all different question types.
+
+For each question type supported by excel2moodle here are the implementations.
+Two classes need to be defined for each type:
+
+* The Question class subclassing core.Question()
+* The Parser class subclassing core.Parser()
+
+Both go into a module named ``excel2moodle.question_types.type.py``
+"""
+
+from enum import Enum
+
+from excel2moodle.core.category import Category
+from excel2moodle.question_types.mc import MCQuestion
+from excel2moodle.question_types.nf import NFQuestion
+from excel2moodle.question_types.nfm import NFMQuestion
+
+
+class QuestionTypeMapping(Enum):
+    """The Mapping between question-types name and the classes."""
+
+    MC = MCQuestion
+    NF = NFQuestion
+    NFM = NFMQuestion
+
+    def create(
+        self,
+        category: Category,
+        questionData: dict[str, str | int | float | list[str]],
+        **kwargs,
+    ):
+        return self.value(category, questionData, **kwargs)

excel2moodle/question_types/mc.py

@@ -0,0 +1,93 @@
+"""Multiple choice Question implementation."""
+
+from typing import ClassVar
+
+import lxml.etree as ET
+
+import excel2moodle.core.etHelpers as eth
+from excel2moodle.core import stringHelpers
+from excel2moodle.core.globals import (
+    DFIndex,
+    TextElements,
+    XMLTags,
+    feedbackStr,
+)
+from excel2moodle.core.parser import QuestionParser
+from excel2moodle.core.question import Question
+
+
+class MCQuestion(Question):
+    """Multiple-choice Question Implementation."""
+
+    standardTags: ClassVar[dict[str, str | float]] = {
+        "single": "false",
+        "shuffleanswers": "true",
+        "answernumbering": "abc",
+        "showstandardinstruction": "0",
+        "shownumcorrect": "",
+    }
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+
+
+class MCQuestionParser(QuestionParser):
+    """Parser for the multiple choice Question."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        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.getListFromStr(self.rawInput[DFIndex.TRUE])
+        trueAnsList = stringHelpers.texWrapper(true, style=ansStyle)
+        self.logger.debug(f"got the following true answers \n {trueAnsList=}")
+        false = stringHelpers.getListFromStr(self.rawInput[DFIndex.FALSE])
+        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