excel2moodle 0.3.1__py3-none-any.whl

excel2moodle/__init__.py

@@ -0,0 +1,113 @@
+"""This Python program helps to create Moodle questions in less time.
+
+The aim is to put alle the information for the questions into a spreadsheet file, and then parse it, to generate Moodle compliant XML-Files.
+Furthermore this program lets you create a single ``.xml``-File with a selection of questions, that then can be imported to a Moodle-Test.
+
+Concept
+=========
+The concept is, to store the different questions into categories of similar types and difficulties of questions, for each of which, a separated sheet in the Spreadsheet document should be created.
+
+There Should be a sheet called *"Kategorien"*, where an overview over the different categories is stored.
+This sheet stores The names and descriptions, for all categories. The name have to be the same as the actual sheet names with the questions.
+Furthermore the points used for grading, are set in the "Kategorien" sheet
+
+Functionality
+===============
+* Parse multiple Choice Questions, each into one XML file
+* Parse Numeric Questions, each into one XML file
+* create single XML File from a selection of questions
+"""
+from importlib.metadata import version
+try:
+    __version__ = version("excel2moodle")
+except Exception:
+    __version__ = "unknown"
+
+# from excel2moodle.core import klausurGenerator
+# from excel2moodle.core import numericMultiQ
+# from excel2moodle.core import questionWriter
+# from excel2moodle.core import questionParser
+# from excel2moodle.core import stringHelpers
+# from excel2moodle.core import globals
+#
+# from excel2moodle.ui import kGeneratorQt
+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,
+    'disable_existing_loggers': False,
+    'formatters': { 
+        'standard': { 
+            'format': '%(asctime)s [%(levelname)s] %(name)s: %(message)s'
+        },
+    },
+    'handlers': { 
+        'default': { 
+            'level': 'DEBUG',
+            'formatter': 'standard',
+            'class': 'logging.StreamHandler',
+            'stream': 'ext://sys.stdout',  # Default is stderr
+        },
+    },
+    'loggers': { 
+        '': {  # root logger
+            'handlers': ['default'],
+            'level': 'DEBUG',
+            'propagate': True
+        },
+        'excel2moodle.questionParser': { 
+            'handlers': ['default'],
+            'level': 'DEBUG',
+            'propagate': True
+        },
+        '__main__': {  # if __name__ == '__main__'
+            'handlers': ['default'],
+            'level': 'DEBUG',
+            'propagate': True
+        },
+    } 
+}
+
+class QSignaler(QObject):
+    signal = Signal(str)
+
+class LogHandler(logging.Handler):
+    def __init__(self, *args, **kwargs)->None:
+        super().__init__(*args,**kwargs)
+        self.emitter = QSignaler()
+         # Define a formatter with log level and module
+        log_format = "[%(levelname)s] %(module)s: %(message)s"
+        self.formatter = logging.Formatter(log_format)
+        self.setFormatter(self.formatter)
+        self.logLevelColors = {
+            'DEBUG': 'gray',
+            'INFO': 'green',
+            'WARNING': 'orange',
+            'ERROR': 'red',
+            'CRITICAL': 'pink'
+        }
+
+    def emit(self, record)->None:
+        log_message = self.format(record)
+        color = self.logLevelColors.get(record.levelname, 'black')
+        prettyMessage = f'<span style="color:{color};">{log_message}</span>'
+        self.emitter.signal.emit(prettyMessage)
+        return None
+
+
+settings = settings.Settings()
+
+logger = logging.getLogger(__name__)
+logging.config.dictConfig(config=loggerConfig)
+
+qSignalLogger = LogHandler()
+logger.addHandler(qSignalLogger)
+
+p = Path(__file__).parent
+dirProjectRoot = p.parent.resolve()
+dirDocumentation = (dirProjectRoot / "docs/_build/html")

excel2moodle/__main__.py

@@ -0,0 +1,31 @@
+"""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)
+    settings = Settings()
+    database:dataStructure.QuestionDB = dataStructure.QuestionDB(settings)
+    window = ui.MainWindow(settings, database)
+    database.window = window
+    window.show()
+    sys.exit(app.exec())
+
+if __name__ =="__main__":
+    main()
+

excel2moodle/core/__init__.py

@@ -0,0 +1,13 @@
+"""
+These Modules are the heart of the excel2moodle Package
+"""
+
+# from pandas._config import config
+# from excel2moodle.core  import questionWriter
+# from  excel2moodle.core import stringHelpers
+# from excel2moodle.core import numericMultiQ
+# from excel2moodle.core import globals
+# from PySide6.QtCore import QObject, Signal
+# import logging as logging
+# from logging import config as logConfig
+#

excel2moodle/core/category.py

@@ -0,0 +1,108 @@
+
+import logging
+import pandas as pd
+import lxml.etree as ET
+
+from excel2moodle.core.exceptions import InvalidFieldException
+from excel2moodle.core.questionValidator import Validator
+logger = logging.getLogger(__name__)
+from excel2moodle.core.question import Question
+
+from excel2moodle.core.globals import XMLTags, TextElements, DFIndex, questionTypes, parserSettings
+from excel2moodle.core.parser import NFMQuestionParser, NFQuestionParser, MCQuestionParser, QNotParsedException
+
+class Category():
+    def __init__(self, n:int, name:str, description:str, dataframe: pd.DataFrame, points:float=0, version:int=0)->None:
+        self.n = n
+        self.NAME = name
+        self.desc = str(description)
+        self.dataframe:pd.DataFrame = dataframe
+        self.points = points
+        self.version = int(version)
+        self.questions:dict[int,Question] = {}
+        self.maxVariants:int|None = None
+        logger.info(f"initializing {self.NAME =}")
+
+    @property
+    def name(self):
+        return self.NAME
+
+    @property
+    def id(self):
+        return f"{self.version}{self.n:02d}"
+
+    def __hash__(self) -> int:
+        return hash(self.NAME)
+
+    def __eq__(self, other: object, /) -> bool:
+        if isinstance(other, 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:
+        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)
+                logger.debug(f"setup a new NF parser ")
+            elif q.qtype == "MC":
+                parser = MCQuestionParser( q, series)
+                logger.debug(f"setup a new MC parser ")
+            elif q.qtype == "NFM":
+                parser = NFMQuestionParser( q, series)
+                logger.debug(f"setup a new NFM parser ")
+            else: 
+                logger.error(f"ERROR, couldn't setup Parser")
+                return False
+            try:
+                parser.parse(xmlTree=xmlTree)
+                return True
+            except QNotParsedException as e:
+                logger.critical(f"The Question {q.id} couldn't be parsed", exc_info=e, stack_info=True)
+                return False
+            finally:
+                del parser
+
+    def getCategoryHeader(self)->ET.Element:
+        """vor den Fragen einer Kategorie wird ein <question type='category'> eingefügt mit Name und Beschreibung"""
+        header = ET.Element('question', type='category')
+        cat = ET.SubElement(header,"category")
+        info = ET.SubElement(header,"info", format='html')
+        ET.SubElement(cat,"text").text = f"$module$/top/{self.NAME}"
+        ET.SubElement(info,"text").text = str(self.desc)
+        ET.SubElement(header,"idnumber").text = str(self.n)
+        ET.indent(header)
+        return header
+
+

excel2moodle/core/dataStructure.py

@@ -0,0 +1,140 @@
+"""Main Module which does the heavy lifting 
+
+At the heart is the class ``xmlTest``
+"""
+
+from pathlib import Path
+from PySide6 import QtCore
+from PySide6 import QtWidgets
+from PySide6.QtCore import Signal
+from PySide6.QtWidgets import QMainWindow, QMessageBox, QTreeWidget
+import pandas as pd
+import lxml.etree as ET
+import logging
+
+from excel2moodle import QSignaler
+from excel2moodle.core import stringHelpers
+from excel2moodle.core.category import Category
+from excel2moodle.ui.dialogs import QuestionVariantDialog
+from excel2moodle.ui.treewidget import QuestionItem, CategoryItem
+from excel2moodle.core.questionValidator import Validator
+from excel2moodle.ui.settings import Settings
+from excel2moodle.core.question import Question
+from excel2moodle.core.exceptions import InvalidFieldException, QNotParsedException
+
+
+logger = logging.getLogger(__name__)
+
+
+class QuestionDB():
+    """oberste Klasse für den Test"""
+    dataChanged = QSignaler()
+
+    def __init__(self, settings:Settings):
+        self.settings = settings
+        self.spreadSheetPath = Path()
+        self.mainPath = Path()
+        self.window:QMainWindow|None = None
+        self.version = None
+        self.categoriesMetaData = pd.DataFrame()
+        self.categories:dict[str,Category]={}
+        self.settings.shPathChanged.connect(self.onSheetPathChanged)
+
+    @QtCore.Slot(Path)
+    def onSheetPathChanged(self, sheet:Path)->None:
+        logger.debug("Slot, new Spreadsheet triggered")
+        self.spreadSheetPath = sheet
+        self.svgFolder = (self.spreadSheetPath.parent / 'Abbildungen_SVG')
+        self.retrieveCategoriesData()
+
+    def retrieveCategoriesData(self)->None:
+        """Scans through the sheet with the metadata for all the question categories
+
+        The information that will be shown in the UI like description and points is retrieved from one spreadsheet sheet.
+        This method gathers this information and stores it in the ``categoriesMetaData`` dataframe
+        """
+
+        logger.info("Start Parsing the Excel Metadata Sheet\n")
+        with open(self.spreadSheetPath, 'rb') as f:
+            excelFile = pd.ExcelFile(f)
+            self.categoriesMetaData = pd.read_excel(f, sheet_name="Kategorien", 
+                                                    usecols=["Kategorie", "Beschreibung", "Punkte", "Version"],
+                                                    index_col=0)
+            logger.info("Sucessfully read categoriesMetaData")
+            print(self.categoriesMetaData)
+            for sh in excelFile.sheet_names:
+                if sh.startswith("KAT"):
+                    n = int(sh[4:])
+                    katDf = pd.read_excel(f, sheet_name=str(sh), index_col=0, header=None)
+                    if not katDf.empty:
+                        p = self.categoriesMetaData["Punkte"].iloc[n-1]
+                        points = (p if not pd.isna(p) else 1)
+                        v = self.categoriesMetaData["Version"].iloc[n-1]
+                        version = (v if not pd.isna(v) else 0)
+                        self.categories[sh] = Category(n,sh, 
+                                                       self.categoriesMetaData["Beschreibung"].iloc[n-1],
+                                                       dataframe=katDf, 
+                                                       points=points,
+                                                       version=version)
+        self.dataChanged.signal.emit("whoo")
+        return None
+
+
+    def parseAll(self):
+        self.mainTree = ET.Element("quiz")
+        for c in self.categories.values():
+            validator = Validator(c)
+            for q in c.dataframe.columns:
+                logger.debug(f"Starting to check Validity of {q}")
+                qdat = c.dataframe[q]
+                if isinstance(qdat, pd.Series):
+                    validator.setup(qdat, q)
+                    check = False
+                    try:
+                        check = validator.validate()
+                    except InvalidFieldException as e:
+                        logger.error(f"Question {c.id}{q:02d} is invalid.", exc_info=e)
+                    if check: 
+                        c.questions[q]=validator.question
+                        try:
+                            c.parseQ(c.questions[q])
+                        except QNotParsedException as e:
+                            logger.error(f"Frage {c.questions[q].id} konnte nicht erstellt werden", exc_info=e)
+
+    def appendQuestions(self, questions:list[QuestionItem], file:Path|None=None):
+        tree = ET.Element("quiz")
+        catdict:dict[Category,list[Question]]={}
+        for q in questions:
+            logger.debug(f"got a question to append {q=}")
+            cat = q.parent().getCategory()
+            if cat not in catdict:
+                catdict[cat] = []
+            print(f"Category is parent of Q {cat=}")
+            catdict[cat].append(q.getQuestion())
+        for cat, qlist in catdict.items():
+            print(f"{cat = }, mit fragen {qlist = }")
+            self.appendQElements(cat, qlist, tree=tree, includeHeader=self.settings.value("testGen/includeCats"))
+        stringHelpers.printDom(tree, file=file)
+
+    def appendQElements(self,cat:Category,  qList:list[Question], tree:ET.Element, includeHeader:bool=True)->None:
+        if includeHeader:
+            tree.append( cat.getCategoryHeader())
+        sameVariant = False
+        variant = 1
+        for q in qList:
+            if cat.parseQ(q):
+                if q.variants is not None:
+                    if sameVariant is False:
+                        dialog = QuestionVariantDialog(self.window, q)
+                        if dialog.exec() == QtWidgets.QDialog.Accepted:
+                            variant = dialog.variant
+                            sameVariant = dialog.categoryWide
+                            logger.debug(f"Die Fragen-Variante {variant} wurde gewählt")
+                            q.assemble(variant)
+                        else: print("skipping this question")
+                q.assemble
+                tree.append(q.element)
+            else: logger.warning(f"Frage {q} wurde nicht erstellt")
+        return None
+
+

excel2moodle/core/etHelpers.py

@@ -0,0 +1,67 @@
+"""Helper Module which aids in creating XML-Elements for the Questions
+
+This module host different functions. All of them will return an ``lxml.etree.Element``
+"""
+
+import lxml.etree as ET
+from .globals import DFIndex, XMLTags
+import pandas as pd
+from excel2moodle.core.globals import feedbackStr, TextElements, feedBElements
+import excel2moodle.core.etHelpers as eth
+
+def getElement( eleName : str, text: str, **attribs)->ET.Element:
+    """Creates an XML-Element with text
+    
+    If ``type(text)``is a ``QuestionFields``, the specific field is directly read.
+    Otherwise it will include whatever is ``text`` as a string
+    :param **kwargs: are treated as attributes for the Element
+    raises: 
+        NanException if the spreadsheet cell of text:QuestionFields is ``nan``
+    """
+
+    toEle = ET.Element(eleName)
+    toEle.text = str(text)
+    for k, v in attribs.items():
+        toEle.set(k,v)
+    return toEle
+
+
+def getTextElement( eleName:str, text:str|DFIndex, **attribs)->ET.Element:
+    """Creates two nested elements: ``eleName`` with child ``text`` which holds the text"""
+
+    toEle = ET.Element(eleName, **attribs)
+    child = getElement("text", text)
+    toEle.append(child)
+    return toEle
+
+def getCdatTxtElement(subEle: ET._Element|list[ET._Element])->ET.Element:
+    """Puts all ``subEle`` as ``str`` into a ``<text><![CDATA[...subEle...]]</text>`` element"""
+
+    textEle = ET.Element(XMLTags.TEXT)
+    if isinstance(subEle, list):
+        elementString : list= []
+        for i in subEle:
+            elementString.append(ET.tostring(i, encoding="unicode", pretty_print=True))
+        textEle.text = ET.CDATA("".join(elementString))
+        return textEle
+    else:
+        textEle.text = ET.CDATA(ET.tostring(subEle, encoding="unicode", pretty_print=True))
+        return  textEle
+
+
+def getFeedBEle(feedback:XMLTags, 
+                text:str|None=None, style: TextElements | None = None
+                )->ET.Element:
+    """Gets ET Elements with the feedback for the question."""
+    if style is None:
+        span = feedBElements[feedback]
+    else: 
+        span = style.create()
+    if text is None:
+        text = feedbackStr[feedback]
+    ele = ET.Element(feedback, format="html")
+    par = TextElements.PLEFT.create()
+    span.text = text
+    par.append(span)
+    ele.append(eth.getCdatTxtElement(par))
+    return ele

excel2moodle/core/exceptions.py

@@ -0,0 +1,20 @@
+
+from excel2moodle.core.globals import DFIndex
+
+
+class QNotParsedException(Exception):
+    def __init__(self, message:str, qID:str|int, *args, **kwargs)->None:
+        super().__init__(message, *args, **kwargs)
+        self.qID = qID
+
+class NanException(QNotParsedException):
+    def __init__(self, message, qID, field, *args, **kwargs):
+        super().__init__(message, qID, *args, **kwargs)
+        self.field = field
+
+class InvalidFieldException(Exception):
+    def __init__(self, message:str,  qID:str, field:DFIndex|list[DFIndex], *args: object, **kwargs) -> None:
+        super().__init__(message, *args, **kwargs)
+        self.field = field
+        self.index = qID
+

excel2moodle/core/globals.py

@@ -0,0 +1,128 @@
+from enum import Enum, StrEnum
+import lxml.etree as ET
+
+questionTypes = {
+    "NF": "numerical",
+    "NFM": "numerical",
+    "MC": "multichoice",
+}
+
+class DFIndex(StrEnum):
+    """This Enum holds the identifier string for for the spreadsheet and the string for the xml-tag
+    
+    Each enum corresponds to a list of two values.
+    The first Value is the index in the spreadsheet, the second is the name of the xml-tag
+    """
+
+    TEXT  = "text"
+    BPOINTS = "bulletPoints"
+    TRUE = "true"
+    FALSE = "false"
+    TYPE = "type"
+    NAME = "name"
+    RESULT = "result"
+    PICTURE = "picture"
+    NUMBER = "number"
+    ANSTYPE = "answerType"
+
+class TextElements(Enum):
+    PLEFT ="p","text-align: left;"
+    SPANRED = "span", "color: rgb(239, 69, 64)"
+    SPANGREEN = "span", "color: rgb(152, 202, 62)"
+    SPANORANGE = "span","color: rgb(152, 100, 100)"
+    ULIST = "ul", "",
+    LISTITEM = "li", "text-align: left;",
+
+    def create(self, tag:str|None=None):
+        if tag is None:
+            tag, style = self.value
+        else: style = self.value[1]
+        return ET.Element(tag, dir="ltr", style=style)
+
+    @property
+    def style(self,)->str:
+        return self.value[1]
+
+class XMLTags(StrEnum):
+    def __new__(cls, value:str, dfkey: DFIndex|None = None):
+        obj = str.__new__(cls, value)
+        obj._value_ = value
+        if dfkey is not None:
+            obj._dfkey_ = dfkey
+        return obj
+
+    def __init__(self,_:str, dfkey:DFIndex|None =None, getEle=None )->None:
+        if isinstance(dfkey, DFIndex):
+            self._dfkey_:str=dfkey
+        if getEle:
+            self._getEle_:object=getEle
+
+    @property
+    def dfkey(self)->str:
+        return self._dfkey_
+
+    def set(self,getEle)->None:
+        self._getEle_ = getEle
+
+    def __repr__(self) -> str:
+        msg = []
+        msg.append(f"XML Tag {self.value = }")
+        if hasattr(self, "_dfkey_"):
+            msg.append(f"Df Key {self.dfkey =}")
+        return "\n".join(msg)
+
+    NAME = "name", DFIndex.NAME
+    QTEXT = "questiontext", DFIndex.TEXT
+    QUESTION = "question"
+    TEXT = "text"
+    PICTURE = "file", DFIndex.PICTURE
+    GENFEEDB = "generalfeedback"
+    CORFEEDB = "correctfeedback"
+    PCORFEEDB = "partialcorrectfeedback"
+    INCORFEEDB = "incorrectfeedback"
+    ANSFEEDBACK = "feedback"
+    POINTS = "defaultgrade"
+    PENALTY = "penalty"
+    HIDE = "hidden"
+    ID = "idnumber"
+    TYPE = "type"
+    ANSWER = "answer"
+    TOLERANCE = "tolerance"
+
+feedBElements = {
+    XMLTags.CORFEEDB:TextElements.SPANGREEN.create(),
+    XMLTags.PCORFEEDB: TextElements.SPANORANGE.create(),
+    XMLTags.INCORFEEDB: TextElements.SPANRED.create(),
+    XMLTags.ANSFEEDBACK: TextElements.SPANGREEN.create(),
+    XMLTags.GENFEEDB: TextElements.SPANGREEN.create(),
+}
+feedbackStr = {
+    XMLTags.CORFEEDB:"Die Frage wurde richtig beantwortet",
+    XMLTags.PCORFEEDB: "Die Frage wurde teilweise richtig beantwortet",
+    XMLTags.INCORFEEDB: "Die Frage wurde Falsch beantwortet",
+    XMLTags.GENFEEDB: "Sie haben eine Antwort abgegeben",
+    "right": "richtig",
+    "wrong": "falsch",
+    "right1Percent": "Gratultaion, die Frage wurde im Rahmen der Toleranz richtig beantwortet"
+}
+
+parserSettings = {
+    "Parser" : {
+            "standards": {
+                "hidden": 0,
+            },
+        },
+    "MCParser" : {
+        "standards" : {
+            "single": "false",
+            "shuffleanswers": "true",
+            "answernumbering": "abc",
+            "showstandardinstruction": "0",
+            "shownumcorrect": "",
+        },
+    },
+    "NFParser" : {
+        "standards": {},
+    },
+}
+