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

excel2moodle/__init__.py

@@ -1,14 +1,20 @@
 """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.
+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.
+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
@@ -17,26 +23,33 @@ 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:
+if __package__ is not None:
     meta = metadata.metadata(__package__)
-    e2mMetadata:dict = {
+    e2mMetadata: dict = {
         "version": __version__,
-        "name": meta['name'],
-        "description": meta['summary'],
-        "author": meta['author'],
-        "license": meta['license-expression'],
+        "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],
+        "homepage": meta["project-url"].split()[1],
         "issues": "https://gitlab.com/jbosse3/excel2moodle/issues",
-    } 
+    }
+
+import logging as logging
+from logging import config as logConfig
+
+from PySide6.QtCore import QObject, Signal
 
 # from excel2moodle.core import klausurGenerator
 # from excel2moodle.core import numericMultiQ
@@ -48,67 +61,63 @@ if not __package__ == None:
 # 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
-
 loggerConfig = {
-    'version': 1,
-    'disable_existing_loggers': False,
-    'formatters': { 
-        'standard': { 
-            'format': '%(asctime)s [%(levelname)s] %(name)s: %(message)s'
-        },
+    "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
+    "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
+    "loggers": {
+        "": {  # root logger
+            "handlers": ["default"],
+            "level": "DEBUG",
+            "propagate": True,
         },
-        'excel2moodle.questionParser': { 
-            'handlers': ['default'],
-            'level': 'DEBUG',
-            'propagate': True
+        "excel2moodle.questionParser": {
+            "handlers": ["default"],
+            "level": "DEBUG",
+            "propagate": True,
         },
-        '__main__': {  # if __name__ == '__main__'
-            '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)
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
         self.emitter = QSignaler()
-         # Define a formatter with log level and module
+        # 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'
+            "DEBUG": "gray",
+            "INFO": "green",
+            "WARNING": "orange",
+            "ERROR": "red",
+            "CRITICAL": "pink",
         }
 
-    def emit(self, record)->None:
+    def emit(self, record) -> None:
         log_message = self.format(record)
-        color = self.logLevelColors.get(record.levelname, 'black')
+        color = self.logLevelColors.get(record.levelname, "black")
         prettyMessage = f'<span style="color:{color};">{log_message}</span>'
         self.emitter.signal.emit(prettyMessage)
         return None
@@ -123,5 +132,5 @@ qSignalLogger = LogHandler()
 logger.addHandler(qSignalLogger)
 
 
-for k,v in e2mMetadata.items():
+for k, v in e2mMetadata.items():
     print(f"{k}: \t {v}\n")

excel2moodle/__main__.py

@@ -2,20 +2,20 @@
 
 from PySide6 import QtWidgets, sys
 
-from  excel2moodle.core import dataStructure
+from excel2moodle.core import dataStructure
 from excel2moodle.ui import appUi as ui
 from excel2moodle.ui.settings import Settings
 
 
-def main()->None:
+def main() -> None:
     app = QtWidgets.QApplication(sys.argv)
     settings = Settings()
-    database:dataStructure.QuestionDB = dataStructure.QuestionDB(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()
 
+if __name__ == "__main__":
+    main()

excel2moodle/core/category.py

@@ -1,27 +1,38 @@
-
 import logging
-import pandas as pd
+
 import lxml.etree as ET
+import pandas as pd
 
-from excel2moodle.core.exceptions import InvalidFieldException
-from excel2moodle.core.questionValidator import Validator
-logger = logging.getLogger(__name__)
+from excel2moodle.core.parser import (
+    MCQuestionParser,
+    NFMQuestionParser,
+    NFQuestionParser,
+    QNotParsedException,
+)
 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
+logger = logging.getLogger(__name__)
+
 
-class Category():
-    def __init__(self, n:int, name:str, description:str, dataframe: pd.DataFrame, points:float=0, version:int=0)->None:
+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.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 =}")
+        self.questions: dict[int, Question] = {}
+        self.maxVariants: int | None = None
+        logger.info(f"initializing {self.NAME=}")
 
     @property
     def name(self):
@@ -39,41 +50,50 @@ class Category():
             return self.NAME == other.NAME
         return False
 
-    def parseQ(self, q:Question, questionData:dict|None=None, 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:
             if q.qtype == "NF":
-                parser = NFQuestionParser( q, questionData)
-                logger.debug(f"setup a new NF parser ")
+                parser = NFQuestionParser(q, questionData)
+                logger.debug("setup a new NF parser ")
             elif q.qtype == "MC":
-                parser = MCQuestionParser( q, questionData)
-                logger.debug(f"setup a new MC parser ")
+                parser = MCQuestionParser(q, questionData)
+                logger.debug("setup a new MC parser ")
             elif q.qtype == "NFM":
-                parser = NFMQuestionParser( q, questionData)
-                logger.debug(f"setup a new NFM parser ")
-            else: 
-                logger.error(f"ERROR, couldn't setup Parser")
+                parser = NFMQuestionParser(q, questionData)
+                logger.debug("setup a new NFM parser ")
+            else:
+                logger.error("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)
+                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)
+    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

@@ -1,87 +1,100 @@
-"""Main Module which does the heavy lifting 
+"""Main Module which does the heavy lifting
 
 At the heart is the class ``xmlTest``
 """
 
+import logging
 from pathlib import Path
-from PySide6 import QtCore
-from PySide6 import QtWidgets
+
+import lxml.etree as ET
+import pandas as pd
+from PySide6 import QtCore, 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.exceptions import InvalidFieldException, QNotParsedException
+from excel2moodle.core.question import Question
 from excel2moodle.core.questionValidator import Validator
+from excel2moodle.ui.dialogs import QuestionVariantDialog
 from excel2moodle.ui.settings import Settings
-from excel2moodle.core.question import Question
-from excel2moodle.core.exceptions import InvalidFieldException, QNotParsedException
-
+from excel2moodle.ui.treewidget import CategoryItem, QuestionItem
 
 logger = logging.getLogger(__name__)
 
 
-class QuestionDB():
+class QuestionDB:
     """oberste Klasse für den Test"""
+
     dataChanged = QSignaler()
 
-    def __init__(self, settings:Settings):
+    def __init__(self, settings: Settings):
         self.settings = settings
         self.spreadSheetPath = Path()
         self.mainPath = Path()
-        self.window:QMainWindow|None = None
+        self.window: QMainWindow | None = None
         self.version = None
         self.categoriesMetaData = pd.DataFrame()
-        self.categories:dict[str,Category]={}
+        self.categories: dict[str, Category] = {}
         self.settings.shPathChanged.connect(self.onSheetPathChanged)
 
     @QtCore.Slot(Path)
-    def onSheetPathChanged(self, sheet:Path)->None:
+    def onSheetPathChanged(self, sheet: Path) -> None:
         logger.debug("Slot, new Spreadsheet triggered")
         self.spreadSheetPath = sheet
-        self.svgFolder = (self.spreadSheetPath.parent / 'Abbildungen_SVG')
+        svgFolder = self.spreadSheetPath.parent / str(
+            self.settings.get("core/pictureSubFolder", default="Abbildungen_SVG")
+        )
+        svgFolder.resolve()
+        self.settings.set("core/pictureFolder", svgFolder)
         self.retrieveCategoriesData()
         self.parseAll()
 
-    def retrieveCategoriesData(self)->None:
-        """Scans through the sheet with the metadata for all the question categories
+    def retrieveCategoriesData(self) -> None:
+        """Scans through the sheet with the metadata for all 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
+        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:
+        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)
+            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)
             self.categories = {}
             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)
+                    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)
+                        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():
@@ -95,17 +108,25 @@ class QuestionDB():
                     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
+                        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], validator.qdata)
                         except QNotParsedException as e:
-                            logger.error(f"Frage {c.questions[q].id} konnte nicht erstellt werden", exc_info=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):
+    def appendQuestions(self, questions: list[QuestionItem], file: Path | None = None):
         tree = ET.Element("quiz")
-        catdict:dict[Category,list[Question]]={}
+        catdict: dict[Category, list[Question]] = {}
         for q in questions:
             logger.debug(f"got a question to append {q=}")
             cat = q.parent().getCategory()
@@ -114,13 +135,24 @@ class QuestionDB():
             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"))
+            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:
+    def appendQElements(
+        self,
+        cat: Category,
+        qList: list[Question],
+        tree: ET.Element,
+        includeHeader: bool = True,
+    ) -> None:
         if includeHeader:
-            tree.append( cat.getCategoryHeader())
+            tree.append(cat.getCategoryHeader())
             logger.debug(f"Appended a new category item {cat=}")
         sameVariant = False
         variant = 1
@@ -134,11 +166,11 @@ class QuestionDB():
                             sameVariant = dialog.categoryWide
                             logger.debug(f"Die Fragen-Variante {variant} wurde gewählt")
                             q.assemble(variant)
-                        else: print("skipping this question")
+                        else:
+                            print("skipping this question")
                 else:
                     q.assemble()
                 tree.append(q.element)
-            else: logger.warning(f"Frage {q} wurde nicht erstellt")
+            else:
+                logger.warning(f"Frage {q} wurde nicht erstellt")
         return None
-
-

excel2moodle/core/etHelpers.py

@@ -4,29 +4,31 @@ This module host different functions. All of them will return an ``lxml.etree.El
 """
 
 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
+from excel2moodle.core.globals import TextElements, feedbackStr, feedBElements
+
+from .globals import DFIndex, XMLTags
+
 
-def getElement( eleName : str, text: str, **attribs)->ET.Element:
+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: 
+    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)
+        toEle.set(k, v)
     return toEle
 
 
-def getTextElement( eleName:str, text:str|DFIndex, **attribs)->ET.Element:
+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)
@@ -34,28 +36,31 @@ def getTextElement( eleName:str, text:str|DFIndex, **attribs)->ET.Element:
     toEle.append(child)
     return toEle
 
-def getCdatTxtElement(subEle: ET._Element|list[ET._Element])->ET.Element:
+
+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= []
+        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
+        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:
+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: 
+    else:
         span = style.create()
     if text is None:
         text = feedbackStr[feedback]

excel2moodle/core/exceptions.py

@@ -1,20 +1,27 @@
-
 from excel2moodle.core.globals import DFIndex
 
 
 class QNotParsedException(Exception):
-    def __init__(self, message:str, qID:str|int, *args, **kwargs)->None:
+    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:
+    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
-