excel2moodle 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

excel2moodle/__init__.py

@@ -17,12 +17,27 @@ Functionality
 * Parse Numeric Questions, each into one XML file
 * create single XML File from a selection of questions
 """
+from importlib import metadata
 from importlib.metadata import version
 try:
     __version__ = version("excel2moodle")
 except Exception:
     __version__ = "unknown"
 
+
+if not __package__ == None:
+    meta = metadata.metadata(__package__)
+    e2mMetadata:dict = {
+        "version": __version__,
+        "name": meta['name'],
+        "description": meta['summary'],
+        "author": meta['author'],
+        "license": meta['license-expression'],
+        "documentation": "https://jbosse3.gitlab.io/excel2moodle",
+        "homepage": meta['project-url'].split()[1],
+        "issues": "https://gitlab.com/jbosse3/excel2moodle/issues",
+    } 
+
 # from excel2moodle.core import klausurGenerator
 # from excel2moodle.core import numericMultiQ
 # from excel2moodle.core import questionWriter
@@ -36,7 +51,6 @@ from excel2moodle.ui import settings
 from PySide6.QtCore import QObject, Signal
 import logging as logging
 from logging import config as logConfig
-from pathlib import Path
 
 loggerConfig = {
     'version': 1,
@@ -108,6 +122,6 @@ logging.config.dictConfig(config=loggerConfig)
 qSignalLogger = LogHandler()
 logger.addHandler(qSignalLogger)
 
-p = Path(__file__).parent
-dirProjectRoot = p.parent.resolve()
-dirDocumentation = (dirProjectRoot / "docs/_build/html")
+
+for k,v in e2mMetadata.items():
+    print(f"{k}: \t {v}\n")

excel2moodle/__main__.py

@@ -1,21 +1,11 @@
 """Main Function to make the Package executable"""
 
-from pathlib import Path
-
 from PySide6 import QtWidgets, sys
-import xml.etree.ElementTree as xmlET
 
 from  excel2moodle.core import dataStructure
 from excel2moodle.ui import appUi as ui
 from excel2moodle.ui.settings import Settings
 
-import logging
-
-katOutPath = None
-excelFile = None
-
-logger = logging.getLogger(__name__)
-
 
 def main()->None:
     app = QtWidgets.QApplication(sys.argv)

excel2moodle/core/category.py

@@ -39,48 +39,19 @@ class Category():
             return self.NAME == other.NAME
         return False
 
-    def _getQuestions(self)->None:
-        self.questions:dict[int,Question] = {}
-        validator = Validator(self)
-        for q in self.dataframe.columns:
-            logger.debug(f"Starting to check Validity of {q}")
-            qdat = self.dataframe[q]
-            if isinstance(qdat, pd.Series):
-                validator.setup(qdat, q)
-                check = False
-                try:
-                    check = validator.validate()
-                except InvalidFieldException as e:
-                    logger.error(f"Frage {self.id}{q:02d} ist invalid.", exc_info=e)
-                if check: 
-                    self.questions[q]=validator.question
-                    try:
-                        self.parseQ(self.questions[q])
-                    except QNotParsedException as e:
-                        logger.error(f"Frage {self.questions[q].id} konnte nicht erstellt werden", exc_info=e)
-        return None
-
-    def parsAll(self, tree: ET.Element = None)->None:
-        if tree is None:
-            tree = ET.Element("quiz")
-        tree.append(self.getCategoryHeader())
-        for q in self.questions.values():
-            self.parseQ(q, tree)
-
-    def parseQ(self, q:Question, xmlTree:ET._Element|None=None)->bool:
+    def parseQ(self, q:Question, questionData:dict|None=None, xmlTree:ET._Element|None=None)->bool:
         if q.element is not None:
             logger.info(f"Question {q.id} is already parsed")
             return True
         else:
-            series = self.dataframe[q.number]
             if q.qtype == "NF":
-                parser = NFQuestionParser( q, series)
+                parser = NFQuestionParser( q, questionData)
                 logger.debug(f"setup a new NF parser ")
             elif q.qtype == "MC":
-                parser = MCQuestionParser( q, series)
+                parser = MCQuestionParser( q, questionData)
                 logger.debug(f"setup a new MC parser ")
             elif q.qtype == "NFM":
-                parser = NFMQuestionParser( q, series)
+                parser = NFMQuestionParser( q, questionData)
                 logger.debug(f"setup a new NFM parser ")
             else: 
                 logger.error(f"ERROR, couldn't setup Parser")

excel2moodle/core/dataStructure.py

@@ -46,6 +46,7 @@ class QuestionDB():
         self.spreadSheetPath = sheet
         self.svgFolder = (self.spreadSheetPath.parent / 'Abbildungen_SVG')
         self.retrieveCategoriesData()
+        self.parseAll()
 
     def retrieveCategoriesData(self)->None:
         """Scans through the sheet with the metadata for all the question categories
@@ -62,6 +63,7 @@ class QuestionDB():
                                                     index_col=0)
             logger.info("Sucessfully read categoriesMetaData")
             print(self.categoriesMetaData)
+            self.categories = {}
             for sh in excelFile.sheet_names:
                 if sh.startswith("KAT"):
                     n = int(sh[4:])
@@ -97,7 +99,7 @@ class QuestionDB():
                     if check: 
                         c.questions[q]=validator.question
                         try:
-                            c.parseQ(c.questions[q])
+                            c.parseQ(c.questions[q], validator.qdata)
                         except QNotParsedException as e:
                             logger.error(f"Frage {c.questions[q].id} konnte nicht erstellt werden", exc_info=e)
 
@@ -119,6 +121,7 @@ class QuestionDB():
     def appendQElements(self,cat:Category,  qList:list[Question], tree:ET.Element, includeHeader:bool=True)->None:
         if includeHeader:
             tree.append( cat.getCategoryHeader())
+            logger.debug(f"Appended a new category item {cat=}")
         sameVariant = False
         variant = 1
         for q in qList:
@@ -132,7 +135,8 @@ class QuestionDB():
                             logger.debug(f"Die Fragen-Variante {variant} wurde gewählt")
                             q.assemble(variant)
                         else: print("skipping this question")
-                q.assemble
+                else:
+                    q.assemble()
                 tree.append(q.element)
             else: logger.warning(f"Frage {q} wurde nicht erstellt")
         return None

excel2moodle/core/parser.py

@@ -1,12 +1,6 @@
-
-
-from unicodedata import category
 from asteval import Interpreter
 import lxml.etree as ET
-# import xml.etree.ElementTree as ET
-from typing import Union
 from pathlib import Path
-from numpy import isin
 import pandas as pd
 import base64 as base64
 import logging as logging
@@ -20,21 +14,27 @@ from excel2moodle.core import stringHelpers
 from excel2moodle.core.question import Picture, Question
 import re as re
 
+from excel2moodle import settings
+
 
 logger = logging.getLogger(__name__)
-svgFolder = Path("../Fragensammlung/Abbildungen_SVG/")
+f = Path("../Fragensammlung/Abbildungen_SVG/").resolve()
+settings.set("core/pictureFolder", f)
+svgFolder =  settings.get("core/pictureFolder", default=f)
+print(svgFolder)
 
 class QuestionParser():
-    def __init__(self, question:Question, dataframe:pd.Series):
+    def __init__(self, question:Question, data:dict):
         self.question:Question = question
-        self.df = dataframe
+        self.rawInput = data
+        logger.debug(f"The following Data was provided for the question {self.question.id}:\n {self.rawInput =}")
         self.genFeedbacks:list[XMLTags] = []
 
     def hasPicture(self)->bool:
         """Creates a ``Picture`` object inside ``question``, if the question needs a pic"""
 
-        picKey = self.df.get(DFIndex.PICTURE)
-        if picKey != 0 and not pd.isna(picKey):
+        picKey = self.rawInput[DFIndex.PICTURE]
+        if picKey != 0 and picKey != 'nan':
             if not hasattr(self.question, 'picture'):
                 self.question.picture = Picture(picKey, svgFolder, self.question)
             if self.question.picture.ready:
@@ -44,31 +44,32 @@ 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.df.get(DFIndex.TEXT)
+        text = self.rawInput[DFIndex.TEXT]
         pcount = 0
         for t in text:
             if not pd.isna(t):
                 pcount +=1
                 paragraphs.append(TextElements.PLEFT.create())
                 paragraphs[-1].text = t
-        self.question.qtextElements = paragraphs
+        self.question.qtextParagraphs = paragraphs
         logger.debug(f"Created main Text {self.question.id} with:{pcount} paragraphs")
         return None
-    
+ 
     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.df.index:
-            bps = self.df.get(DFIndex.BPOINTS)
+        if DFIndex.BPOINTS in self.rawInput:
+            bps:str = self.rawInput[DFIndex.BPOINTS]
             try:
                 bulletList = self.formatBulletList(bps)
             except IndexError as e:
                 raise QNotParsedException(f"konnt Bullet Liste {self.question.id} nicht generieren", self.question.id, exc_info=e)
-            self.question.bulletList.append(bulletList)
-            logger.debug(f"appendet Bullet List {bulletList = }")
+            logger.debug(f"Generated BPoint List: \n {ET.tostring(bulletList, encoding='unicode')}")
+            self.question.bulletList = bulletList
         return None
 
     def formatBulletList(self,bps:str)->ET.Element:
-        li:list[str] =stringHelpers.stripWhitespace( bps.split(';'))
+        logger.debug(f"Formatting the bulletpoint list")
+        li:list[str] = stringHelpers.stripWhitespace( bps.split(';'))
         name = []
         var = []
         quant = []
@@ -81,17 +82,23 @@ class QuestionParser():
             quant.append(sc_split[3])
             unit.append(sc_split[4])
         for i in range(0, len(name)):
-            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~"
+            if re.fullmatch(r"{\w+}", quant[i]):
+                logger.debug(f"Got an variable bulletItem")
+                num_s = quant[i]
+            else:
+                logger.debug(f"Got a normal bulletItem")
+                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~"
             bullet = TextElements.LISTITEM.create()
             bullet.text=(f"{ name[i] }: \\( {var[i]} = {num_s} \\mathrm{{ {unit[i]}  }}\\)\n")
             unorderedList.append(bullet)
         return unorderedList
 
-    def appendToQuestion(self, eleName: str, text:str|DFIndex, txtEle=False, **attribs ):
-        t = (self.df.get(text) if isinstance(text, DFIndex) else text)
+    def appendToTmpEle(self, eleName: str, text:str|DFIndex, txtEle=False, **attribs ):
+        """Appends the text to the temporary Element"""
+        t = self.rawInput[text] if isinstance(text, DFIndex) else text
         if txtEle is False:
             self.tmpEle.append(eth.getElement(eleName, t, **attribs))
         elif txtEle is True:
@@ -107,7 +114,7 @@ class QuestionParser():
         for p in parser:
             try:
                 for k, v in parserSettings[p][key].items():
-                    self.appendToQuestion(k, text=v)
+                    self.appendToTmpEle(k, text=v)
             except KeyError as e:
                 msg = f"Invalider Input aus den Einstellungen Parser: {type(p) = }"
                 logger.error(msg, exc_info=e)
@@ -120,15 +127,16 @@ class QuestionParser():
         Generates an new Question Element stored as ``self.tmpEle:ET.Element``
         if no Exceptions are raised, ``self.tmpEle`` is passed to ``self.question.element``
         """
+        logger.info(f"Starting to parse {self.question.id}")
         self.tmpEle = ET.Element(XMLTags.QUESTION, type = self.question.moodleType)
         # self.tmpEle.set(XMLTags.TYPE, self.question.moodleType)
-        self.appendToQuestion(XMLTags.NAME, text=DFIndex.NAME, txtEle=True)
-        self.appendToQuestion(XMLTags.ID, text=self.question.id)
+        self.appendToTmpEle(XMLTags.NAME, text=DFIndex.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.appendToQuestion(XMLTags.POINTS, text=str(self.question.points))
-        self.appendToQuestion(XMLTags.PENALTY, text="0.3333")
+        self.appendToTmpEle(XMLTags.POINTS, text=str(self.question.points))
+        self.appendToTmpEle(XMLTags.PENALTY, text="0.3333")
         self.appendFromSettings()
         for feedb in self.genFeedbacks:
             self.tmpEle.append(eth.getFeedBEle(feedb))
@@ -186,34 +194,30 @@ class NFQuestionParser(QuestionParser):
         self.genFeedbacks=[XMLTags.GENFEEDB]
 
     def setAnswers(self)->list[ET.Element]:
-        result = self.df.get(DFIndex.RESULT)
+        result = self.rawInput[DFIndex.RESULT]
         ansEle:list[ET.Element]=[]
         ansEle.append(self.getNumericAnsElement( result = result ))
         return ansEle
 
 class NFMQuestionParser(QuestionParser):
-    def __init__(self, question: Question, dataframe: pd.Series):
-        super().__init__(question, dataframe)
+    def __init__(self, *args):
+        super().__init__(*args)
         self.genFeedbacks=[XMLTags.GENFEEDB]
         self.astEval = Interpreter()
 
     def setAnswers(self)->None:
-        equation = self.df.get(DFIndex.RESULT)
-        bps = self.df.get(DFIndex.BPOINTS)
+        equation = self.rawInput[DFIndex.RESULT]
+        bps = str( self.rawInput[DFIndex.BPOINTS] )
         ansElementsList:list[ET.Element]=[]
-        varNames:list[str]= self.getVarsList(bps)
-        varsDict, number = self.getVariablesDict(varNames)
-        bulletPoints:list[ET.Element] = []
+        varNames:list[str]= self._getVarsList(bps)
+        self.question.variables, number = self._getVariablesDict(varNames)
         for n in range(number):
-            self._setupAstIntprt(varsDict, n)
+            self._setupAstIntprt(self.question.variables, n)
             result = self.astEval(equation)
             if isinstance(result, float):
                 ansElementsList.append(self.getNumericAnsElement( result = round(result,3) ))
-            bpli = self.insertVariablesToBPoints(varsDict, bps, n)
-            bulletPoints.append(self.formatBulletList(bpli))
         self.question.answerVariants = ansElementsList
-        self.question.bulletList = bulletPoints
-        self.setVariants(len(bulletPoints))
+        self.setVariants(len(ansElementsList))
         return None
 
     def setVariants(self, number:int):
@@ -225,38 +229,26 @@ class NFMQuestionParser(QuestionParser):
             self.question.category.maxVariants = number if number <= mvar else mvar
 
 
-    @staticmethod
-    def insertVariablesToBPoints(varDict: dict, bulletPoints: str, index: int)-> str:
-        """
-        Für jeden Eintrag im varDict, wird im bulletPoints String der Substring "{key}" durch value[index] ersetzt
-        """
-        for k, v in varDict.items():
-            s = r"{" + str(k) + r"}"
-            matcher = re.compile(s)
-            bulletPoints = matcher.sub(str(v[index]), bulletPoints)
-        return bulletPoints
-
-    def _setupAstIntprt(self, var:dict[str, list[str]], index:int)->None:
+    def _setupAstIntprt(self, var:dict[str, list[float|int]], index:int)->None:
         """Ubergibt die Parameter mit entsprechenden Variablen-Namen an den asteval-Interpreter.
 
         Dann kann dieser die equation lesen.
         """
-        for k,v in var.items():
-            comma = re.compile(r",")
-            value = comma.sub(".",v[index])
-            self.astEval.symtable[k] = float(value)
+        for name,value in var.items():
+            self.astEval.symtable[name] = value[index]
         return None
 
-    def getVariablesDict(self, keyList: list)-> tuple[dict[str,list[str]],int]:
+    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.df.get(k)
+            val = self.rawInput[k]
             if isinstance(val, str)  :
-                li = val.split(";")
+                li =  stringHelpers.stripWhitespace(val.split(";"))
                 num = len(li)
-                dic[str(k)] = li
+                vars:list[float] =  [ float(i.replace(",",".")) for i in li ]
+                dic[str(k)] = vars
             else: 
                 dic[str(k)] = [str(val)]
                 num = 1
@@ -264,7 +256,7 @@ class NFMQuestionParser(QuestionParser):
         return dic, num
 
     @staticmethod
-    def getVarsList(bps: str|list[str])->list:
+    def _getVarsList(bps: str|list[str])->list:
         """
         Durchsucht den bulletPoints String nach den Variablen, die als "{var}" gekennzeichnet sind
         """
@@ -308,10 +300,10 @@ class MCQuestionParser(QuestionParser):
 
 
     def setAnswers(self)->list[ET.Element]:
-        ansStyle = self.df.get(DFIndex.ANSTYPE)
-        true = stringHelpers.stripWhitespace(self.df.get(DFIndex.TRUE).split(';'))
+        ansStyle = self.rawInput[DFIndex.ANSTYPE]
+        true = stringHelpers.stripWhitespace(self.rawInput[DFIndex.TRUE].split(';'))
         trueAnsList = stringHelpers.texWrapper(true, style=ansStyle)
-        false = stringHelpers.stripWhitespace(self.df.get(DFIndex.FALSE).split(';'))
+        false = stringHelpers.stripWhitespace(self.rawInput[DFIndex.FALSE].split(';'))
         falseAnsList= stringHelpers.texWrapper(false, style=ansStyle)
         truefrac = 1/len(trueAnsList)*100
         falsefrac = 1/len(trueAnsList)*(-100)

excel2moodle/core/question.py

@@ -6,6 +6,8 @@ import base64 as base64
 from excel2moodle.core import category, etHelpers
 from excel2moodle.core.globals import XMLTags, TextElements, DFIndex, questionTypes, parserSettings
 from excel2moodle.core.exceptions import QNotParsedException
+from typing import Match
+import re as re
 
 
 logger = logging.getLogger(__name__)
@@ -19,14 +21,15 @@ 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.points = ( points if points != 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.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.standardTags = {
             "hidden":"false"
@@ -41,17 +44,32 @@ class Question():
         return "\n".join(li)
 
     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)
+            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 len(self.bulletList)>0:
-            self.qtextElements.append(self.bulletList[variant-1])
+        if self.variants is not None:
+            textElements.append(self.getBPointVariant(variant-1))
+        else:
+            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)
+        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
 
@@ -60,6 +78,28 @@ class Question():
             self.id: str = f"{self.category.id}{self.number:02d}"
         else: self.id:str = str(id)
 
+    def getBPointVariant(self, variant:int)->ET.Element:
+        if self.bulletList is None:
+            return None
+        varPlaceholder = re.compile(r"{(\w+)}")  # matches {a}, {some_var}, etc.
+
+        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
+
+        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

excel2moodle/core/questionValidator.py

@@ -17,6 +17,8 @@ from excel2moodle.core.exceptions  import InvalidFieldException, NanException
 import pandas as pd
 import logging
 
+logger = logging.getLogger(__name__)
+
 
 class Validator():
     def __init__(self, category) -> None:
@@ -76,8 +78,24 @@ class Validator():
             if missing is not None:
                 raise InvalidFieldException(msg, id, missing)
         self._getQuestion()
+        self._getData()
         return True
 
+    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)

excel2moodle/core/stringHelpers.py

@@ -8,9 +8,16 @@ 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(';')