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

excel2moodle/__init__.py

@@ -24,18 +24,24 @@ Functionality
 * 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"
 
-
+e2mMetadata: dict = {}
 if __package__ is not None:
     meta = metadata.metadata(__package__)
-    e2mMetadata: dict = {
+    e2mMetadata = {
         "version": __version__,
         "name": meta["name"],
         "description": meta["summary"],
@@ -46,91 +52,13 @@ if __package__ is not None:
         "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
-# 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
-
-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)
 
+settings = Settings()
+logfile = Path(settings.get(SettingsKey.LOGFILE)).resolve()
+e2mMetadata["logfile"] = logfile
+if logfile.exists():
+    logfile.replace(f"{logfile}.old")
 
-for k, v in e2mMetadata.items():
-    print(f"{k}: \t {v}\n")
+mainLogger = logging.getLogger(__name__)
+logConfig.dictConfig(config=loggerConfig)
+qSignalLogger = LogWindowHandler()

excel2moodle/__main__.py

@@ -1,19 +1,27 @@
-"""Main Function to make the Package executable"""
+"""Main Function to make the Package executable."""
+
+import signal
 
 from PySide6 import QtWidgets, sys
 
+from excel2moodle import e2mMetadata, mainLogger, qSignalLogger
 from excel2moodle.core import dataStructure
 from excel2moodle.ui import appUi as ui
 from excel2moodle.ui.settings import Settings
 
 
 def main() -> None:
+    mainLogger.addHandler(qSignalLogger)
+    signal.signal(signal.SIGINT, signal.SIG_DFL)
     app = QtWidgets.QApplication(sys.argv)
     settings = Settings()
     database: dataStructure.QuestionDB = dataStructure.QuestionDB(settings)
     window = ui.MainWindow(settings, database)
     database.window = window
     window.show()
+    for k, v in e2mMetadata.items():
+        msg = f"{k:^14s}:  {v}"
+        mainLogger.info(msg)
     sys.exit(app.exec())
 
 

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

@@ -10,8 +10,9 @@ from excel2moodle.core.parser import (
     QNotParsedException,
 )
 from excel2moodle.core.question import Question
+from excel2moodle.logger import LogAdapterQuestionID
 
-logger = logging.getLogger(__name__)
+loggerObj = logging.getLogger(__name__)
 
 
 class Category:
@@ -32,14 +33,14 @@ class Category:
         self.version = int(version)
         self.questions: dict[int, Question] = {}
         self.maxVariants: int | None = None
-        logger.info(f"initializing {self.NAME=}")
+        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:
@@ -56,39 +57,38 @@ class Category:
         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("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:
-                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,
-                )
-                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
-        """
+        """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")

excel2moodle/core/dataStructure.py

@@ -1,68 +1,53 @@
-"""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 typing import TYPE_CHECKING
 
-import lxml.etree as ET
+import lxml.etree as ET  # noqa: N812
 import pandas as pd
-from PySide6 import QtCore, QtWidgets
-from PySide6.QtCore import Signal
-from PySide6.QtWidgets import QMainWindow, QMessageBox, QTreeWidget
+from PySide6 import QtWidgets
 
-from excel2moodle import QSignaler
 from excel2moodle.core import stringHelpers
 from excel2moodle.core.category import Category
 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
-from excel2moodle.ui.treewidget import CategoryItem, QuestionItem
+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"""
+    """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.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
-        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 categories
+    def readSpreadsheetData(self, sheet: Path) -> None:
+        """Read the metadata and questions from the spreadsheet.
 
-        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
+        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,
@@ -71,13 +56,15 @@ 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:])
                     katDf = pd.read_excel(
-                        f, sheet_name=str(sh), index_col=0, header=None
+                        f,
+                        sheet_name=str(sh),
+                        index_col=0,
+                        header=None,
                     )
                     if not katDf.empty:
                         p = self.categoriesMetaData["Punkte"].iloc[n - 1]
@@ -92,10 +79,9 @@ class QuestionDB:
                             points=points,
                             version=version,
                         )
-        self.dataChanged.signal.emit("whoo")
-        return None
+        # self.dataChanged.signal.emit("whoo")
 
-    def parseAll(self):
+    def parseAll(self) -> None:
         self.mainTree = ET.Element("quiz")
         for c in self.categories.values():
             validator = Validator(c)
@@ -108,9 +94,8 @@ class QuestionDB:
                     try:
                         check = validator.validate()
                     except InvalidFieldException as e:
-                        logger.error(
-                            f"Question {c.id}{
-                                q:02d} is invalid.",
+                        logger.exception(
+                            f"Question {c.id}{q:02d} is invalid.",
                             exc_info=e,
                         )
                     if check:
@@ -118,13 +103,17 @@ class QuestionDB:
                         try:
                             c.parseQ(c.questions[q], validator.qdata)
                         except QNotParsedException as e:
-                            logger.error(
+                            logger.exception(
                                 f"Frage {
-                                    c.questions[q].id} konnte nicht erstellt werden",
+                                    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
+    ) -> None:
+        """Append selected question Elements to the tree."""
         tree = ET.Element("quiz")
         catdict: dict[Category, list[Question]] = {}
         for q in questions:
@@ -132,15 +121,13 @@ class QuestionDB:
             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"),
+                includeHeader=self.settings.get(SettingsKey.INCLUDEINCATS),
             )
         stringHelpers.printDom(tree, file=file)
 
@@ -154,23 +141,20 @@ class QuestionDB:
         if includeHeader:
             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")
+                            pass
                 else:
                     q.assemble()
                 tree.append(q.element)
             else:
                 logger.warning(f"Frage {q} wurde nicht erstellt")
-        return None

excel2moodle/core/etHelpers.py

@@ -1,4 +1,4 @@
-"""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``
 """
@@ -12,7 +12,7 @@ from .globals import DFIndex, XMLTags
 
 
 def getElement(eleName: str, text: str, **attribs) -> ET.Element:
-    """Creates an XML-Element with text
+    """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
@@ -20,7 +20,6 @@ def getElement(eleName: str, text: str, **attribs) -> ET.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():
@@ -29,8 +28,7 @@ def getElement(eleName: str, text: str, **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"""
-
+    """Creates two nested elements: ``eleName`` with child ``text`` which holds the text."""
     toEle = ET.Element(eleName, **attribs)
     child = getElement("text", text)
     toEle.append(child)
@@ -38,8 +36,7 @@ def getTextElement(eleName: str, text: str | DFIndex, **attribs) -> ET.Element:
 
 
 def getCdatTxtElement(subEle: ET._Element | list[ET._Element]) -> ET.Element:
-    """Puts all ``subEle`` as ``str`` into a ``<text><![CDATA[...subEle...]]</text>`` element"""
-
+    """Puts all ``subEle`` as ``str`` into a ``<text><![CDATA[...subEle...]]</text>`` element."""
     textEle = ET.Element(XMLTags.TEXT)
     if isinstance(subEle, list):
         elementString: list = []
@@ -47,21 +44,19 @@ def getCdatTxtElement(subEle: ET._Element | list[ET._Element]) -> ET.Element:
             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
+    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")

excel2moodle/core/exceptions.py

@@ -8,7 +8,7 @@ class QNotParsedException(Exception):
 
 
 class NanException(QNotParsedException):
-    def __init__(self, message, qID, field, *args, **kwargs):
+    def __init__(self, message, qID, field, *args, **kwargs) -> None:
         super().__init__(message, qID, *args, **kwargs)
         self.field = field
 

excel2moodle/core/globals.py

@@ -10,7 +10,7 @@ questionTypes = {
 
 
 class DFIndex(StrEnum):
-    """This Enum holds the identifier string for for the spreadsheet and the string for the xml-tag
+    """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
@@ -26,6 +26,7 @@ class DFIndex(StrEnum):
     PICTURE = "picture"
     NUMBER = "number"
     ANSTYPE = "answerType"
+    TOLERANCE = "tolerance"
 
 
 class TextElements(Enum):

excel2moodle/core/numericMultiQ.py

@@ -1,11 +1,11 @@
-"""Numeric Multi Questions Module to calculate results from a formula
+"""Numeric Multi Questions Module to calculate results from a formula.
 
 This module calculates a series of results from al matrix of variables.
 For each column in the matrix there will be one result.
 As well it returns a bullet points string that shows the numerical values corresponding to the set of variables
 """
 
-import re as re
+import re
 
 import pandas as pd
 from asteval import Interpreter
@@ -14,7 +14,7 @@ astEval = Interpreter()
 
 
 def getVariablesDict(df: pd.DataFrame, keyList: list, index: int) -> dict:
-    """Liest alle Variablen-Listen deren Name in ``keyList`` ist aus dem DataFrame im Column[index]"""
+    """Liest alle Variablen-Listen deren Name in ``keyList`` ist aus dem DataFrame im Column[index]."""
     dic = {}
     for k in keyList:
         val = df.loc[str(k)][index]
@@ -23,7 +23,6 @@ def getVariablesDict(df: pd.DataFrame, keyList: list, index: int) -> dict:
             dic[str(k)] = li
         else:
             dic[str(k)] = [str(val)]
-    print(f"Folgende Variablen wurden gefunden:\n{dic}\n")
     return dic
 
 
@@ -36,12 +35,11 @@ def setParameters(parameters: dict, index: int) -> None:
         comma = re.compile(r",")
         value = comma.sub(".", v[index])
         astEval.symtable[k] = float(value)
-    return None
 
 
 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
+    """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"}"
@@ -51,9 +49,7 @@ def insertVariablesToBPoints(varDict: dict, bulletPoints: str, index: int) -> st
 
 
 def getVarsList(bps: str) -> list:
-    """
-    Durchsucht den bulletPoints String nach den Variablen, die als "{var}" gekennzeichnet sind
-    """
+    """Durchsucht den bulletPoints String nach den Variablen `{var}`."""
     vars = re.findall(r"\{\w\}", str(bps))
     variablen = []
     for v in vars:
@@ -62,9 +58,12 @@ def getVarsList(bps: str) -> list:
 
 
 def parseNumericMultiQuestion(
-    datFrame: pd.DataFrame, bulletPoints: str, equation: str, questionIndex: int
+    datFrame: pd.DataFrame,
+    bulletPoints: str,
+    equation: str,
+    questionIndex: int,
 ) -> tuple[list[str], list[float]]:
-    """Berechnet die Ergebnisse anhand der Variablen in *bulletPoints*
+    """Berechnet die Ergebnisse anhand der Variablen in *bulletPoints*.
 
     Gibt eine Liste mit allen Ergebnissen zurück
     und eine Liste mit den bulletPoints-Strings, die die Numerischen Variablen enthalten