excel2moodle 0.3.2__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

@@ -63,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:])
@@ -98,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)
 
@@ -120,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:
@@ -133,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,39 +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
@@ -265,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
         """
@@ -309,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(';')

excel2moodle/ui/appUi.py

@@ -8,6 +8,7 @@ from PySide6 import QtCore
 from PySide6.QtCore import Qt
 from PySide6 import QtWidgets
 from pathlib import Path
+from excel2moodle import e2mMetadata
 from excel2moodle.ui.windowMain import Ui_MoodleTestGenerator
 from .windowEquationChecker import Ui_EquationChecker
 from excel2moodle.ui import windowEquationChecker, dialogs
@@ -16,11 +17,8 @@ from excel2moodle.ui.treewidget import QuestionItem, CategoryItem
 from excel2moodle.extra import equationVerification as eqVerif
 from excel2moodle import qSignalLogger
 from excel2moodle.ui.settings import Settings
-from excel2moodle.ui.windowDoc import DocumentationWindow
 import logging as logging
 
-from excel2moodle import dirDocumentation
-
 
 logger = logging.getLogger(__name__)
 
@@ -29,25 +27,22 @@ logger = logging.getLogger(__name__)
 class MainWindow(QtWidgets.QMainWindow):
     def __init__(self, settings:Settings, testDB:QuestionDB)->None:
         super().__init__()
-        # self.questionGenerator = questionGenerator
-        # self.readSettings()
         self.settings = settings
         self.excelPath: Path|None = None
-        if self.excelPath is not None:
-            self.ui.buttonSpreadSheet.setText(self.excelPath.name)
         self.mainPath = (self.excelPath.parent if self.excelPath is not None else None)
         self.exportFile = Path()
         self.testDB = testDB
         self.ui = Ui_MoodleTestGenerator()
         self.ui.setupUi(self)
 
-        # self.ui.buttonRefresh.clicked.connect(lambda: self.refreshList(self.test))
         self.ui.treeWidget.setSelectionMode(QtWidgets.QAbstractItemView.MultiSelection)
         self.ui.treeWidget.header().setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
+        self.ui.checkBoxIncludeCategories.setChecked(self.settings.value("testGen/includeCats", type=bool))
 
         self.ui.retranslateUi(self)
         logger.info(f"Settings are stored under: {self.settings.fileName()}")
         self.ui.pointCounter.setReadOnly(True)
+        self.ui.questionCounter.setReadOnly(True)
         self.setStatus("Wählen Sie bitte eine Excel Tabelle und einen Export Ordner für die Fragen aus")
         try:
             self.resize(self.settings.value("windowSize"))
@@ -68,7 +63,7 @@ class MainWindow(QtWidgets.QMainWindow):
         self.ui.buttonSpreadSheet.clicked.connect(self.onButSpreadsheet)
         self.ui.buttonTestGen.clicked.connect(self.onButGenTest)
         self.ui.actionPreviewQ.triggered.connect(self.previewQ)
-        self.ui.actionDocumentation.triggered.connect(self.onOpenDocumentation)
+        self.ui.actionAbout.triggered.connect(self.onAbout)
         self.settings.shPathChanged.connect(self.onSheetPathChanged)
 
 
@@ -77,6 +72,7 @@ class MainWindow(QtWidgets.QMainWindow):
         logger.debug("Slot, new Spreadsheet triggered")
         self.spreadSheetPath = sheet
         self.mainPath = sheet.parent
+        self.ui.buttonSpreadSheet.setText(str(sheet.name))
 
     def updateLog(self,log)->None:
         self.ui.loggerWindow.append(log)
@@ -84,14 +80,41 @@ class MainWindow(QtWidgets.QMainWindow):
     def setIncludeCategoriesSetting(self):
         if self.ui.checkBoxIncludeCategories.isChecked():
             self.settings.set("testGen/includeCats", True)
+            logger.debug("set includeCats to True")
         else:
             self.settings.set("testGen/includeCats", False)
+            logger.debug("set includeCats to False")
 
-    @QtCore.Slot()
-    def onOpenDocumentation(self):
-        documentationWindow = DocumentationWindow(dirDocumentation, self)
-        documentationWindow.show()
 
+    @QtCore.Slot()
+    def onAbout(self):
+        aboutMessage: str = f"""
+        <h1> About {e2mMetadata['name']}</h1><br>
+        <p style="text-align:center">
+
+                <b><a href="{e2mMetadata['homepage']}">{e2mMetadata['name']}</a> - {e2mMetadata['description']}</b>
+        </p>
+        <p style="text-align:center"> 
+            The documentation can be found under <b><a href="{e2mMetadata['documentation']}">{e2mMetadata['documentation']}</a></b>
+            </br>
+            </br>
+            If you encounter any issues please report them under the <a href="{e2mMetadata['issues']}"> repositories issues page</a>
+            </br>
+        </p>
+        <p style="text-align:center">
+        This project is maintained by {e2mMetadata['author']}.
+        <br>
+        Development takes place at <a href="{e2mMetadata['homepage']}">{e2mMetadata['homepage']}</a>
+        Contributions are very welcome
+        <br>
+        </p>
+        <p style="text-align:center">
+        <i>This project is published under {e2mMetadata['license']}, you are welcome, to share, modify and reuse the code.</i>
+        </p>
+        """
+        QtWidgets.QMessageBox.information(self, 
+                                               f"About {e2mMetadata['name']}",
+                                               aboutMessage)
 
     def closeEvent(self, event):
         self.settings.setValue("windowSize", self.size())
@@ -145,8 +168,6 @@ class MainWindow(QtWidgets.QMainWindow):
                                                      selectedFilter=("*.ods"))
         self.excelPath = Path(file[0]).resolve()
         self.settings.setSpreadsheet(self.excelPath)
-        self.mainPath = self.excelPath.parent
-        self.ui.buttonSpreadSheet.setText(self.excelPath.name)
         logger.debug(f'Saved Spreadsheet Path: {self.excelPath}\n')
         self.setStatus("[OK] Excel Tabelle wurde eingelesen")
         return None

excel2moodle/ui/dialogs.py

@@ -65,9 +65,9 @@ class QuestinoPreviewDialog(QtWidgets.QDialog):
 
     def setText(self)->None:
         t = []
-        for text in self.question.qtextElements:
+        for text in self.question.qtextParagraphs:
             t.append(ET.tostring(text, encoding='unicode'))
-
+        t.append(ET.tostring(self.question.bulletList, encoding='unicode'))
         self.ui.questionText.setText("\n".join(t))
 
     def setAnswers(self)->None:

excel2moodle/ui/settings.py

@@ -5,8 +5,8 @@ class Settings(QSettings):
     shPathChanged = Signal(Path)
     def __init__(self):
         super().__init__("jbosse3", "excel2moodle")
-        if self.contains("spreadsheet"):
-            self.sheet = self.value("spreadsheet")
+        if self.contains("core/spreadsheet"):
+            self.sheet = self.value("core/spreadsheet")
             try:
                 self.sheet.resolve(strict=True)
                 if self.sheet.is_file():
@@ -20,7 +20,8 @@ class Settings(QSettings):
 
 
     def get(self, value, default=None):
-        self.value(value, default)
+        return self.value(value, default)
+
 
     def set(self, setting, value):
         self.setValue(setting, value)
@@ -28,7 +29,7 @@ class Settings(QSettings):
     def setSpreadsheet(self, sheet:Path)->None:
         if isinstance(sheet, Path):
             self.sheet = sheet.resolve(strict=True)
-            self.setValue("spreadsheet", self.sheet)
+            self.setValue("core/spreadsheet", self.sheet)
             self.shPathChanged.emit(sheet)
             return None
 

{excel2moodle-0.3.2.dist-info → excel2moodle-0.3.3.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: excel2moodle
-Version: 0.3.2
-Summary: A Package for Converting Questions input into a spreadsheet, to valid moodle-xml
+Version: 0.3.3
+Summary: A package for converting questions from a spreadsheet, to valid moodle-xml
 Author: Jakob Bosse
 License-Expression: GPL-3.0-or-later
-Project-URL: Homepage, https://gitlab.com/jbosse3/excel2moodle
-Project-URL: documentation, https://jbosse3.gitlab.io/excel2moodle
+Project-URL: Repository, https://gitlab.com/jbosse3/excel2moodle.git
+Project-URL: Documentation, https://jbosse3.gitlab.io/excel2moodle
 Keywords: moodle,XML,teaching,question,converter
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent

{excel2moodle-0.3.2.dist-info → excel2moodle-0.3.3.dist-info}/RECORD

@@ -1,31 +1,31 @@
-excel2moodle/__init__.py,sha256=nb37g9Zga4KqTA5r-GFei9_XCunoPESxww9BL8zzMBI,3841
-excel2moodle/__main__.py,sha256=yLls1C3w070wtrrRl3_HXs5TNaO8l0yRDGtIAcHmeDk,695
+excel2moodle/__init__.py,sha256=dsK3KrorPt06FUp18_dw2m4p9P8E7rFf9I0BR-4I28k,4263
+excel2moodle/__main__.py,sha256=SsulFcOSlRBF2tLTUIdFgB0EJdSLGBIQ_HO53S4Sih8,541
 excel2moodle/core/__init__.py,sha256=E7smxf7ESHlucvho4Gb5oaTHA7IsOv9J-UDIsoKwp84,399
-excel2moodle/core/category.py,sha256=6U10HgQQVi0BYO28XrsLbYFqr0GbxEN9U2-fPDTM1Ng,4149
-excel2moodle/core/dataStructure.py,sha256=8cLqGZLhHRscohrstvsYARWvKekGAfdoMV1zWuUpHCA,6200
+excel2moodle/core/category.py,sha256=rZsQW5-Ud182xCrS4R8B0vrPMrI-azwtfzlTdy89SR4,2982
+excel2moodle/core/dataStructure.py,sha256=h82r4wO2PhhHA4EqROjfkqWGUpg6UKQhkyrdjdisLxg,6343
 excel2moodle/core/etHelpers.py,sha256=_fd-fGMVNWt1l8FY7xcA2uXOBahxtq8ggYxRYm4SwdA,2354
 excel2moodle/core/exceptions.py,sha256=3OLVHMCBgETiOxSsirlsCPvlMN5UgEQcMkRDkCfrUs4,675
 excel2moodle/core/globals.py,sha256=9V9-KBSsHMdsRZWg2wGrvjAd6dc3XZG4pNPnun0AHGE,3595
 excel2moodle/core/numericMultiQ.py,sha256=InBrn-tsCCYwDb78sGR3FyFxVeN0GfIg63JGtr_tqg4,2751
-excel2moodle/core/parser.py,sha256=ruSFHKjwpXggaETrtsUBdZK1BENCe2wppmOLdpKrAAs,13455
-excel2moodle/core/question.py,sha256=4mbzy6ZodvdM5QfBZltR950BmMdXqSBe9V7HBLZMewM,4198
-excel2moodle/core/questionValidator.py,sha256=6leCAvMFOieiVJtQEYx4iihiaKuuSBlCpBkpqbzKa3M,4139
+excel2moodle/core/parser.py,sha256=0bLP_bkTFu3URw08sn1zJCvA3YCKxDAC4a6I14koHho,13408
+excel2moodle/core/question.py,sha256=zzdL_7BdWs0wUVl8-06gLkKu0Is3n0zU-2ZkaYhU504,5913
+excel2moodle/core/questionValidator.py,sha256=taOrrR6pd5mN7SGpET9eLOvb1v5NWvg_VgMj8opQlZ4,4791
 excel2moodle/core/questionWriter.py,sha256=kyUTrnjWrLEWdez5_7FPNJ0Cs_fF5d16oOQiVvHv3zA,10242
-excel2moodle/core/stringHelpers.py,sha256=c92YYFluZ6-NIM7K1k0SzN_zB82hh3huNZMH0NnlDLg,3009
+excel2moodle/core/stringHelpers.py,sha256=9BqR7yx2bL8WknVMPuNlmWz05bgi4qWjFYHsgaftpZw,3141
 excel2moodle/extra/__init__.py,sha256=e70OmuW3j7N4ErIIHlK4vkmCKcpRbitJCdJvzjego8c,339
 excel2moodle/extra/equationVerification.py,sha256=FOvVBQZ357fbA5nYkHjvvWWVP3pQpo4RK3H7vru9v3A,4278
 excel2moodle/ui/__init__.py,sha256=4EdGtpzwH3rgw4xW9E5x9kdPQYwKbo9rehHRZTNxCrQ,44
-excel2moodle/ui/appUi.py,sha256=gWLJ3vU-KcHAz0HQXrOk2hGi3LD_8SSC5aPVEpayMEA,9518
-excel2moodle/ui/dialogs.py,sha256=C58PzPLfkzglsRl-x8Y23TC08_JG03JgFCVFfEi_od8,2961
+excel2moodle/ui/appUi.py,sha256=TEqslEDExDOyYwCh7czg3YZggPdZewFiImbpzACLYLU,10533
+excel2moodle/ui/dialogs.py,sha256=5dnzRN9cwaxjJsxA7I9v1imH4k6XVzzievYi3PR32XI,3038
 excel2moodle/ui/questionPreviewDialog.py,sha256=_rJvz1GM90aNnj3P6SugEezK7JW6m74ZALgkChohWLM,4980
-excel2moodle/ui/settings.py,sha256=Zz4zxdGC55Ma6pB1HWdPdiAsN0fnqrPfgOFgSkVnKNA,1092
+excel2moodle/ui/settings.py,sha256=PB0uBMCd8DIRSFfvUAPs5hK4UEcb0y7dG9ZJ--kOvuQ,1115
 excel2moodle/ui/treewidget.py,sha256=xiYWhJeJ9o9Iubtr44HcyJas9v4m8aBsHNdokQAHi80,2357
 excel2moodle/ui/variantDialog.py,sha256=snVaF3_YAc7NWjMRg7NzbjL_PzNbOpt4eiqElkE46io,5414
 excel2moodle/ui/windowDoc.py,sha256=IciZpwrLnGzIQV1aCdKQBg6km3oufHGs8havTFzNJyU,1055
 excel2moodle/ui/windowEquationChecker.py,sha256=fLyal3sbJwpthWCAxLB5vbSFOX23JoivoYksNp3mZVY,7925
 excel2moodle/ui/windowMain.py,sha256=sB1ahkAwxFxO3EYP3X_MuB6ohgXwK5NUQHWeFo4eqrI,21062
-excel2moodle-0.3.2.dist-info/licenses/LICENSE,sha256=ywQqe6Sitymkf2lV2NRcx_aGsaC-KbSl_EfEsRXmNRw,35135
-excel2moodle-0.3.2.dist-info/METADATA,sha256=f_TnbqQEmg8wy6WuvMuYOTd8u_-h5qw4aKADlcvtzsM,2904
-excel2moodle-0.3.2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-excel2moodle-0.3.2.dist-info/top_level.txt,sha256=5V1xRUQ9o7UmOCmNoWCZPAuy5nXp3Qbzyqch8fUGT_c,13
-excel2moodle-0.3.2.dist-info/RECORD,,
+excel2moodle-0.3.3.dist-info/licenses/LICENSE,sha256=ywQqe6Sitymkf2lV2NRcx_aGsaC-KbSl_EfEsRXmNRw,35135
+excel2moodle-0.3.3.dist-info/METADATA,sha256=i7lC9k3j8ErKfWNnPAngdrnDAWIqC5V6egSB5uWivW8,2904
+excel2moodle-0.3.3.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+excel2moodle-0.3.3.dist-info/top_level.txt,sha256=5V1xRUQ9o7UmOCmNoWCZPAuy5nXp3Qbzyqch8fUGT_c,13
+excel2moodle-0.3.3.dist-info/RECORD,,

{excel2moodle-0.3.2.dist-info → excel2moodle-0.3.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (79.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any