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

excel2moodle/core/question.py

@@ -1,17 +1,34 @@
-import logging 
-import lxml.etree as ET
-from pathlib import Path
 import base64 as base64
+import logging
+import re as re
+from pathlib import Path
+from typing import Match
 
-from excel2moodle.core import category, etHelpers
-from excel2moodle.core.globals import XMLTags, TextElements, DFIndex, questionTypes, parserSettings
-from excel2moodle.core.exceptions import QNotParsedException
+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,
+)
 
 logger = logging.getLogger(__name__)
 
-class Question():
-    def __init__(self, category,name:str, number:int, parent=None, qtype:str="type", points:float=0):
+
+class Question:
+    def __init__(
+        self,
+        category,
+        name: str,
+        number: int,
+        parent=None,
+        qtype: str = "type",
+        points: float = 0,
+    ):
         self.category = category
         self.katName = self.category.name
         self.name = name
@@ -19,57 +36,96 @@ class Question():
         self.parent = parent
         self.qtype: str = qtype
         self.moodleType = questionTypes[qtype]
-        self.points = ( points if points is not 0 else self.category.points)
-        self.element: ET.Element|None=None
-        self.picture:Picture
-        self.id:str
-        self.qtextElements: list[ET.Element] = []
-        self.bulletList: list[ET.Element] = []
+        self.points = points if points != 0 else self.category.points
+        self.element: ET.Element | None = None
+        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.variants: int | None = None
+        self.variables: dict[str, list[float | int]] = {}
         self.setID()
-        self.standardTags = {
-            "hidden":"false"
-        }
+        self.standardTags = {"hidden": "false"}
         logger.debug(f"Question {self.id} is initialized")
 
-    def __repr__(self)->str:
-        li:list[str] = []
+    def __repr__(self) -> str:
+        li: list[str] = []
         li.append(f"Question v{self.category.version}")
-        li.append(f'{self.id=}')
-        li.append(f'{self.parent=}')
+        li.append(f"{self.id=}")
+        li.append(f"{self.parent=}")
         return "\n".join(li)
 
-    def assemble(self, variant:int=1)->None:
+    def assemble(self, variant: int = 1) -> None:
+        textElements: list[ET.Element] = []
+        textElements.extend(self.qtextParagraphs)
+        logger.debug(f"Starting assembly of {self.id}")
         if self.element is not None:
             mainText = self.element.find(XMLTags.QTEXT)
-        else: raise QNotParsedException("Cant assamble, if element is none", self.id)
-        if len(self.bulletList)>0:
-            self.qtextElements.append(self.bulletList[variant-1])
+            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")
+        else:
+            raise QNotParsedException("Cant assamble, if element is none", 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:
-            self.qtextElements.append(self.picture.htmlTag)
+            textElements.append(self.picture.htmlTag)
             mainText.append(self.picture.element)
-        mainText.append(etHelpers.getCdatTxtElement(self.qtextElements))
-        self.element.insert(3, mainText)
-        if len( self.answerVariants ) > 0:
-            self.element.insert(5, self.answerVariants[variant-1])
+        mainText.append(etHelpers.getCdatTxtElement(textElements))
+        # self.element.insert(3, mainText)
+        logger.debug(f"inserted MainText to question 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.element.insert(5, self.answerVariants[variant - 1])
         return None
 
-    def setID(self, id = 0)->None:
+    def setID(self, id=0) -> None:
         if id == 0:
             self.id: str = f"{self.category.id}{self.number:02d}"
-        else: self.id:str = str(id)
+        else:
+            self.id: str = str(id)
+
+    def getBPointVariant(self, variant: int) -> ET.Element:
+        if self.bulletList is None:
+            return None
+        # matches {a}, {some_var}, etc.
+        varPlaceholder = re.compile(r"{(\w+)}")
+
+        def replaceMatch(match: Match[str]) -> str | int | float:
+            key = match.group(1)
+            if key in self.variables:
+                value = self.variables[key][variant]
+                return f"{value}".replace(".", ",\\!")
+            return match.group(0)  # keep original if no match
 
-class Picture():
-    def __init__(self, picKey:str, imgFolder:Path, question:Question):
+        unorderedList = TextElements.ULIST.create()
+        for li in self.bulletList:
+            listItemText = li.text or ""
+            bullet = TextElements.LISTITEM.create()
+            bullet.text = varPlaceholder.sub(replaceMatch, listItemText)
+            logger.debug(f"Inserted Variables into List: {bullet}")
+            unorderedList.append(bullet)
+        return unorderedList
+
+
+class Picture:
+    def __init__(self, picKey: str, imgFolder: Path, question: Question):
         self.pic = picKey
-        self.ready:bool = False
+        self.ready: bool = False
         self.question = question
         self.imgFolder = (imgFolder / question.katName).resolve()
-        self.htmlTag:ET.Element
-        self.path:Path
+        self.htmlTag: ET.Element
+        self.path: Path
         self._setPath()
-        if hasattr(self, 'picID'):
+        if hasattr(self, "picID"):
             self.ready = self.__getImg()
 
     def _setPath(self):
@@ -77,30 +133,43 @@ class Picture():
             self.picID = self.question.id
         else:
             selectedPic = self.pic[2:]
-            logger.debug(f"got a picture key {selectedPic =}")
+            logger.debug(f"got a picture key {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", exc_info=e)
+                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')
+        with open(imgPath, "rb") as img:
+            img64 = base64.b64encode(img.read()).decode("utf-8")
         return img64
 
-    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("file", name=f'{self.path.name}', path='/', encoding='base64')
+        self.path: Path = (dir / str(picID)).with_suffix(".svg")
+        self.element: ET.Element = ET.Element(
+            "file", name=f"{self.path.name}", path="/", encoding="base64"
+        )
         self.element.text = self.__getBase64Img(self.path)
 
-
-    def __getImg(self)->bool:
+    def __getImg(self) -> bool:
         try:
             self.__setImgElement(self.imgFolder, int(self.picID))
-            self.htmlTag = ET.Element("img", src=f"@@PLUGINFILE@@/{self.path.name}", alt=f"Bild {self.path.name}", width="500")
+            self.htmlTag = ET.Element(
+                "img",
+                src=f"@@PLUGINFILE@@/{self.path.name}",
+                alt=f"Bild {self.path.name}",
+                width="500",
+            )
             return True
         except FileNotFoundError as e:
-            logger.warning(msg=f"Bild {self.picID} konnte nicht gefunden werden ", exc_info=e)
+            logger.warning(
+                msg=f"Bild {self.picID} konnte nicht gefunden werden ", exc_info=e
+            )
             self.element = None
             return False

excel2moodle/core/questionValidator.py

@@ -8,42 +8,40 @@ Those things are considered:
 If Those checks pass, a question is created, which can be accessed via ``Validator.question``
 """
 
+import logging
 from types import UnionType
 
-from pandas.core.series import notna
-from excel2moodle.core.question import Question
-from excel2moodle.core.globals import DFIndex
-from excel2moodle.core.exceptions  import InvalidFieldException, NanException
 import pandas as pd
-import logging
 
+from excel2moodle.core.exceptions import InvalidFieldException
+from excel2moodle.core.globals import DFIndex
+from excel2moodle.core.question import Question
+
+logger = logging.getLogger(__name__)
 
-class Validator():
+
+class Validator:
     def __init__(self, category) -> None:
-        self.question:Question
+        self.question: Question
         self.category = category
-        self.mandatory: dict[DFIndex, type|UnionType] = {
+        self.mandatory: dict[DFIndex, type | UnionType] = {
             DFIndex.TEXT: str,
             DFIndex.NAME: str,
             DFIndex.TYPE: str,
         }
-        self.optional: dict[DFIndex, type|UnionType] = {
-            DFIndex.BPOINTS : str,
+        self.optional: dict[DFIndex, type | UnionType] = {
+            DFIndex.BPOINTS: str,
             DFIndex.NAME: str,
-            DFIndex.PICTURE: int|str,
-        }
-        self.nfOpt: dict[DFIndex, type|UnionType] = {
-            DFIndex.RESULT: float|int,
+            DFIndex.PICTURE: int | str,
         }
-        self.nfMand: dict[DFIndex, type|UnionType] = {
+        self.nfOpt: dict[DFIndex, type | UnionType] = {
+            DFIndex.RESULT: float | int,
         }
-        self.nfmOpt: dict[DFIndex, type|UnionType] = {
-        }
-        self.nfmMand: dict[DFIndex, type|UnionType] = {
-        }
-        self.mcOpt: dict[DFIndex, type|UnionType] = {
-        }
-        self.mcMand: dict[DFIndex, type|UnionType] = {
+        self.nfMand: dict[DFIndex, type | UnionType] = {}
+        self.nfmOpt: dict[DFIndex, type | UnionType] = {}
+        self.nfmMand: dict[DFIndex, type | UnionType] = {}
+        self.mcOpt: dict[DFIndex, type | UnionType] = {}
+        self.mcMand: dict[DFIndex, type | UnionType] = {
             DFIndex.TRUE: str,
             DFIndex.FALSE: str,
             DFIndex.ANSTYPE: str,
@@ -55,15 +53,15 @@ class Validator():
             "NFM": (self.nfmOpt, self.nfmMand),
         }
 
-    def setup(self, df:pd.Series, index:int)->bool:
+    def setup(self, df: pd.Series, index: int) -> bool:
         self.df = df
         self.index = index
         typ = self.df.loc[DFIndex.TYPE]
         self.mandatory.update(self.mapper[typ][1])
         self.optional.update(self.mapper[typ][0])
         return True
-        
-    def validate(self )->bool:
+
+    def validate(self) -> bool:
         id = f"{self.category.id}{self.index:02d}"
         checker, missing = self._mandatory()
         if not checker:
@@ -76,9 +74,25 @@ class Validator():
             if missing is not None:
                 raise InvalidFieldException(msg, id, missing)
         self._getQuestion()
+        self._getData()
         return True
 
-    def _mandatory(self)->tuple[bool,DFIndex|None]:
+    def _getData(self) -> None:
+        self.qdata: dict[str, str | float | int | list] = {}
+        for idx, val in self.df.items():
+            if not isinstance(idx, str):
+                logger.debug(f"Got a non String key in the spreadsheet, skipping it")
+                continue
+            if idx in self.qdata:
+                if isinstance(self.qdata[idx], list):
+                    self.qdata[idx].append(val)
+                else:
+                    existing = self.qdata[idx]
+                    self.qdata[idx] = [existing, val]
+            else:
+                self.qdata[idx] = val
+
+    def _mandatory(self) -> tuple[bool, DFIndex | None]:
         """detects if all keys of mandatory are filled with values"""
         checker = pd.Series.notna(self.df)
         for k in self.mandatory.keys():
@@ -90,11 +104,11 @@ class Validator():
                 if not c.any():
                     return False, k
             elif not c:
-                return False, k,
+                return False, k
         return True, None
 
-    def _typeCheck(self)->tuple[bool, list[DFIndex]|None]:
-        invalid:list[DFIndex] = []
+    def _typeCheck(self) -> tuple[bool, list[DFIndex] | None]:
+        invalid: list[DFIndex] = []
         for field, typ in self.mandatory.items():
             if isinstance(self.df[field], pd.Series):
                 for f in self.df[field]:
@@ -109,16 +123,13 @@ class Validator():
                     invalid.append(field)
         if len(invalid) == 0:
             return True, None
-        else: 
+        else:
             return False, invalid
 
-
-    def _getQuestion(self)->None:
+    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))
+        self.question = Question(
+            self.category, name=str(name), number=self.index, qtype=str(qtype)
+        )
         return None
-

excel2moodle/core/stringHelpers.py

@@ -1,19 +1,28 @@
-"""This Module holds small Helperfunctions related to string manipulation
-"""
+"""This Module holds small Helperfunctions related to string manipulation"""
 
+import base64 as base64
 from pathlib import Path
+
 import lxml.etree as ET
-import base64 as base64
+
 
 def stripWhitespace(stringList):
     stripped = []
     for i in stringList:
-        stripped.append(i.strip())
+        s = i.strip()
+        if s:
+            stripped.append(s)
     return stripped
 
+
+def stringToFloat(string: str) -> float:
+    string.replace(",", ".")
+    return float(string)
+
+
 def get_bullet_string(s):
     """Formatiert die Angaben zum Statischen System hübsch"""
-    split = s.split(';')
+    split = s.split(";")
     s_spl = stripWhitespace(split)
     name = []
     var = []
@@ -27,20 +36,26 @@ def get_bullet_string(s):
         unit.append(sc_split[4])
     bulletString = ['</p><ul dir="ltr">']
     for i in range(0, len(s_spl)):
-        num = quant[i].split(',')
-        if len(num)==2:
+        num = quant[i].split(",")
+        if len(num) == 2:
             num_s = f"{str(num[0])},\\!{str(num[1])}~"
-        else: num_s = f"{str(num[0])},\\!0~"
+        else:
+            num_s = f"{str(num[0])},\\!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>')
+        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:
-        img64 = base64.b64encode(img.read()).decode('utf-8')
+    with open(imgPath, "rb") as img:
+        img64 = base64.b64encode(img.read()).decode("utf-8")
     return img64
 
+
 def getUnitsElementAsString(unit):
 
     def __getUnitEle__(name, multipl):
@@ -51,34 +66,37 @@ def getUnitsElementAsString(unit):
 
     unitsEle = ET.Element("units")
 
-def printDom(xmlElement:ET.Element, file:Path|None=None  )->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"""
     documentTree = ET.ElementTree(xmlElement)
     if file is not None:
         if file.parent.exists():
-                documentTree.write(file, xml_declaration=True, encoding="utf-8", pretty_print=True)
+            documentTree.write(
+                file, xml_declaration=True, encoding="utf-8", pretty_print=True
+            )
     else:
-        msg =f" No output File specified, here is the Element:"
-        print(f'\n{ msg :=^80}')
-        print( ET.tostring(xmlElement, encoding="utf-8", pretty_print=True))
+        msg = "No output File specified, here is the Element:"
+        print(f"\n{msg:=^80}")
+        print(ET.tostring(xmlElement, encoding="utf-8", pretty_print=True))
         print(f'{" End of Element ":=^80}')
 
 
-def texWrapper(text:str|list[str], style:str)->list[str]:
+def texWrapper(text: str | list[str], style: str) -> list[str]:
     """Puts the strings inside ``text`` into a LaTex environment
 
     if ``style == unit``: inside ``\\mathrm{}``
-    if ``style == math``: inside ``\\( \\)`` 
+    if ``style == math``: inside ``\\( \\)``
     """
 
-    answers:list[str]=[]
-    begin =""
+    answers: list[str] = []
+    begin = ""
     end = ""
     if style == "math":
-        begin ="\\("
+        begin = "\\("
         end = "\\)"
     elif style == "unit":
-        begin ="\\(\\mathrm{"
+        begin = "\\(\\mathrm{"
         end = "}\\)"
     if isinstance(text, str):
         li = [begin]

excel2moodle/extra/__init__.py

@@ -2,8 +2,6 @@
 
 The modules inside *extra* can be run standalone, but are planned to be available from the main Window as well
 
-To run a script execute the following: ``python -m excel2moodle.extra.SCRIPT`` 
+To run a script execute the following: ``python -m excel2moodle.extra.SCRIPT``
 Note that there is no ``.py`` at the end!!
 """
-
-from excel2moodle.core import numericMultiQ

excel2moodle/extra/equationVerification.py

@@ -28,15 +28,18 @@ As Script
 #. Rinse and repeat
 """
 
-import re as re
-import pandas as pd
 from pathlib import Path
+
+import pandas as pd
+
 from excel2moodle.core import numericMultiQ as nmq
 
 # Hier Bitte die Frage angeben, die getestet Werden soll:
 
-#===========================================================
-def checkResult(checkerValue:float, calculation:float, tolerance = 0.01)-> bool:
+# ===========================================================
+
+
+def checkResult(checkerValue: float, calculation: float, tolerance=0.01) -> bool:
     """Checks if the two Arguments are within the tolerance the same value
 
     :param checkerValue: the value the calculation is compared against
@@ -46,20 +49,23 @@ def checkResult(checkerValue:float, calculation:float, tolerance = 0.01)-> bool:
     :param tolerance: the standart tolerance is 0.01 -> 1%
     :type tolerance: float, optional
 
-    :returns: 
+    :returns:
         True if checkerValue == calculation
         False if checkerValue != calculation
     :rtype: bool
     """
 
-    upper = abs(checkerValue + checkerValue*tolerance)
-    lower = abs(checkerValue - checkerValue*tolerance)
+    upper = abs(checkerValue + checkerValue * tolerance)
+    lower = abs(checkerValue - checkerValue * tolerance)
     if abs(calculation) > lower and abs(calculation) < upper:
         return True
-    else :
+    else:
         return False
 
-def equationChecker(categoryName: str, qNumber:int, spreadsheetFile)-> tuple[list[str], list[float], float]:
+
+def equationChecker(
+    categoryName: str, qNumber: int, spreadsheetFile
+) -> tuple[list[str], list[float], float]:
     """This Function calculates all Results an invokes the checkResult function
 
     Parameters
@@ -91,34 +97,46 @@ def equationChecker(categoryName: str, qNumber:int, spreadsheetFile)-> tuple[lis
     except Exception:
         print(f"Es ist kein 'firstResult' gegeben, kann nichts überprüfen")
         res = 0
-    bps, calcs = nmq.parseNumericMultiQuestion(df,bps,eq, qNumber)
+    bps, calcs = nmq.parseNumericMultiQuestion(df, bps, eq, qNumber)
     return bps, calcs, res
 
 
-def main(spreadsheetFile= Path("../Fragensammlung/Main_question_all.xlsx"), catN = None, qNumber = None)-> None:
-    """Takes the Spreadsheet, and asks for a category and a question number
-
-    """
+def main(
+    spreadsheetFile=Path("../Fragensammlung/Main_question_all.xlsx"),
+    catN=None,
+    qNumber=None,
+) -> None:
+    """Takes the Spreadsheet, and asks for a category and a question number"""
     if catN == None:
         catN = input("Geben Sie die Kategorie an: KAT_")
     categoryName = f"KAT_{catN}"
     if qNumber == None:
         qNumber = int(input("Geben Sie die Fragennummer an: "))
-    bullets, results, firstResult = equationChecker(categoryName, qNumber, spreadsheetFile=spreadsheetFile)
+    bullets, results, firstResult = equationChecker(
+        categoryName, qNumber, spreadsheetFile=spreadsheetFile
+    )
     check = False
 
     for i, calculation in enumerate(results):
-        if i == 0 and firstResult !=0:
-           check = checkResult(firstResult, calculation)
-        print(f"Ergebnis {i+1}: \t{calculation}\n\tMit den Werten: \n{bullets[i]}\n")
+        if i == 0 and firstResult != 0:
+            check = checkResult(firstResult, calculation)
+        print(
+            f"Ergebnis {
+              i+1}: \t{calculation}\n\tMit den Werten: \n{bullets[i]}\n"
+        )
 
     if check == True:
-        print(f"Das erste berechnete Ergebnis stimmt mit dem Wert in 'firstResult' überein\n")
+        print(
+            f"Das erste berechnete Ergebnis stimmt mit dem Wert in 'firstResult' überein\n"
+        )
     else:
-        print(f"WARNUNG: Das erste berechnete Ergebnis weicht von dem Wert  {firstResult = } ab.\n")
+        print(
+            f"WARNUNG: Das erste berechnete Ergebnis weicht von dem Wert  {
+              firstResult=} ab.\n"
+        )
 
 
-if __name__ =="__main__":
-    spreadsheet =input(f"Geben Sie den Pfad zu dem spreadsheet an:")
+if __name__ == "__main__":
+    spreadsheet = input(f"Geben Sie den Pfad zu dem spreadsheet an:")
     while True:
         main(Path(spreadsheet))