excel2moodle 0.3.3__py3-none-any.whl → 0.3.5__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,111 +23,47 @@ Functionality
 * Parse Numeric Questions, each into one XML file
 * create single XML File from a selection of questions
 """
+
+import logging
+import logging.config as logConfig
 from importlib import metadata
 from importlib.metadata import version
+from pathlib import Path
+
+from excel2moodle.logger import LogWindowHandler, loggerConfig
+from excel2moodle.ui.settings import Settings, SettingsKey
+
 try:
     __version__ = version("excel2moodle")
 except Exception:
     __version__ = "unknown"
 
-
-if not __package__ == None:
+e2mMetadata: dict = {}
+if __package__ is not None:
     meta = metadata.metadata(__package__)
-    e2mMetadata:dict = {
+    e2mMetadata = {
         "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",
-    } 
-
-# 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
 
-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()
+settings = Settings()
+logfile = Path(settings.get(SettingsKey.LOGFILE)).resolve()
+e2mMetadata["logfile"] = logfile
+logfile.replace(f"{logfile}.old")
 
 logger = logging.getLogger(__name__)
-logging.config.dictConfig(config=loggerConfig)
-
-qSignalLogger = LogHandler()
+logConfig.dictConfig(config=loggerConfig)
+qSignalLogger = LogWindowHandler()
 logger.addHandler(qSignalLogger)
 
 
-for k,v in e2mMetadata.items():
-    print(f"{k}: \t {v}\n")
+for k, v in e2mMetadata.items():
+    msg = f"{k:^14s}:  {v}"
+    logger.info(msg)

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/__init__.py

@@ -1,6 +1,4 @@
-"""
-These Modules are the heart of the excel2moodle Package
-"""
+"""These Modules are the heart of the excel2moodle Package."""
 
 # from pandas._config import config
 # from excel2moodle.core  import questionWriter

excel2moodle/core/category.py

@@ -1,34 +1,46 @@
-
 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.logger import LogAdapterQuestionID
 
-from excel2moodle.core.globals import XMLTags, TextElements, DFIndex, questionTypes, parserSettings
-from excel2moodle.core.parser import NFMQuestionParser, NFQuestionParser, MCQuestionParser, QNotParsedException
+loggerObj = 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
+        loggerObj.info("initializing Category %s", self.NAME)
 
     @property
-    def name(self):
+    def name(self) -> str:
         return self.NAME
 
     @property
-    def id(self):
+    def id(self) -> str:
         return f"{self.version}{self.n:02d}"
 
     def __hash__(self) -> int:
@@ -39,41 +51,49 @@ 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:
+        """Parse the given question."""
+        logger = LogAdapterQuestionID(loggerObj, {"qID": q.id})
         if q.element is not None:
-            logger.info(f"Question {q.id} is already parsed")
+            logger.info("Question already parsed")
             return True
+        if q.qtype == "NF":
+            parser = NFQuestionParser(q, questionData)
+            logger.debug("setup a new NF parser ")
+        elif q.qtype == "MC":
+            parser = MCQuestionParser(q, questionData)
+            logger.debug("setup a new MC parser ")
+        elif q.qtype == "NFM":
+            parser = NFMQuestionParser(q, questionData)
+            logger.debug("setup a new NFM parser ")
         else:
-            if q.qtype == "NF":
-                parser = NFQuestionParser( q, questionData)
-                logger.debug(f"setup a new NF parser ")
-            elif q.qtype == "MC":
-                parser = MCQuestionParser( q, questionData)
-                logger.debug(f"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")
-                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
+            logger.error("couldn't setup Parser")
+            return False
+        try:
+            parser.parse(xmlTree=xmlTree)
+            return True
+        except QNotParsedException as e:
+            logger.critical(
+                "Question 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:
+        """Insert an <question type='category'> before all Questions of this Category."""
+        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,88 +1,87 @@
-"""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
-from PySide6.QtCore import Signal
-from PySide6.QtWidgets import QMainWindow, QMessageBox, QTreeWidget
+from typing import TYPE_CHECKING
+
+import lxml.etree as ET  # noqa: N812
 import pandas as pd
-import lxml.etree as ET
-import logging
+from PySide6 import QtWidgets
 
-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
+from excel2moodle.core.question import Question
+from excel2moodle.core.questionValidator import Validator
+from excel2moodle.logger import QSignaler
+from excel2moodle.ui.dialogs import QuestionVariantDialog
+from excel2moodle.ui.settings import Settings, SettingsKey
+from excel2moodle.ui.treewidget import QuestionItem
 
+if TYPE_CHECKING:
+    from PySide6.QtWidgets import QMainWindow
 
 logger = logging.getLogger(__name__)
 
 
-class QuestionDB():
-    """oberste Klasse für den Test"""
+class QuestionDB:
+    """oberste Klasse für den Test."""
+
     dataChanged = QSignaler()
 
-    def __init__(self, settings:Settings):
+    def __init__(self, settings: Settings) -> None:
         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.settings.shPathChanged.connect(self.onSheetPathChanged)
+        self.categories: dict[str, Category] = {}
 
-    @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()
-        self.parseAll()
+    def readSpreadsheetData(self, sheet: Path) -> None:
+        """Read the metadata and questions from the spreadsheet.
 
-    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
+        This method gathers this information and stores it in the
+        ``categoriesMetaData`` dataframe
+        It also reads the question data and stores it in ``self.categories = {}``
         """
-
         logger.info("Start Parsing the Excel Metadata Sheet\n")
-        with open(self.spreadSheetPath, 'rb') as f:
+        with Path(sheet).open("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):
+    def parseAll(self) -> None:
         self.mainTree = ET.Element("quiz")
         for c in self.categories.values():
             validator = Validator(c)
@@ -95,50 +94,67 @@ 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.exception(
+                            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)
-
-    def appendQuestions(self, questions:list[QuestionItem], file:Path|None=None):
+                            logger.exception(
+                                f"Frage {
+                                    c.questions[q].id
+                                } konnte nicht erstellt werden",
+                                exc_info=e,
+                            )
+
+    def appendQuestions(
+        self, questions: list[QuestionItem], file: Path | None = None
+    ) -> None:
+        """Append selected question Elements to the tree."""
         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()
             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"))
+            self.appendQElements(
+                cat,
+                qlist,
+                tree=tree,
+                includeHeader=self.settings.get(SettingsKey.INCLUDEINCATS),
+            )
         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
+        variant: int = self.settings.get(SettingsKey.QUESTIONVARIANT)
         for q in qList:
             if cat.parseQ(q):
                 if q.variants is not None:
-                    if sameVariant is False:
+                    if variant == 0 or variant > q.variants:
                         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")
+                        else:
+                            pass
                 else:
                     q.assemble()
                 tree.append(q.element)
-            else: logger.warning(f"Frage {q} wurde nicht erstellt")
-        return None
-
-
+            else:
+                logger.warning(f"Frage {q} wurde nicht erstellt")

excel2moodle/core/etHelpers.py

@@ -1,62 +1,62 @@
-"""Helper Module which aids in creating XML-Elements for the Questions
+"""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
+from excel2moodle.core.globals import TextElements, feedbackStr, feedBElements
+
+from .globals import DFIndex, XMLTags
+
+
+def getElement(eleName: str, text: str, **attribs) -> ET.Element:
+    """Creates an XML-Element with text.
 
-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:
-    """Creates two nested elements: ``eleName`` with child ``text`` which holds the text"""
-
+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"""
 
+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: 
-        span = style.create()
+    span = feedBElements[feedback] if style is None else style.create()
     if text is None:
         text = feedbackStr[feedback]
     ele = ET.Element(feedback, format="html")