excel2moodle 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

excel2moodle/__main__.py

@@ -2,9 +2,10 @@
 
 import logging.config as logConfig
 import signal
+import sys
 from pathlib import Path
 
-from PySide6 import QtWidgets, sys
+from PySide6.QtWidgets import QApplication
 
 import excel2moodle
 from excel2moodle import e2mMetadata, mainLogger
@@ -23,7 +24,7 @@ def main() -> None:
         logfile.replace(f"{logfile}.old")
     logConfig.dictConfig(config=loggerConfig)
     signal.signal(signal.SIGINT, signal.SIG_DFL)
-    app = QtWidgets.QApplication(sys.argv)
+    app = QApplication(sys.argv)
     settings = Settings()
     database: dataStructure.QuestionDB = dataStructure.QuestionDB(settings)
     window = ui.MainWindow(settings, database)

excel2moodle/core/category.py

@@ -5,10 +5,9 @@ from typing import TYPE_CHECKING
 import lxml.etree as ET
 import pandas as pd
 
-from excel2moodle.core.settings import Tags
-
 if TYPE_CHECKING:
     from excel2moodle.core.question import Question
+from excel2moodle.core.settings import Tags
 
 loggerObj = logging.getLogger(__name__)
 
@@ -30,7 +29,7 @@ class Category:
         self.desc = str(description)
         self.dataframe: pd.DataFrame = dataframe
         self.settings: dict[str, float | str] = settings if settings else {}
-        self.questions: dict[int, Question] = {}
+        self._questions: dict[int, Question]
         self.maxVariants: int | None = None
         loggerObj.info("initializing Category %s", self.NAME)
 
@@ -50,6 +49,18 @@ class Category:
     def id(self) -> str:
         return f"{self.n:02d}"
 
+    @property
+    def questions(self) -> dict:
+        if not hasattr(self, "_questions"):
+            msg = "Category question are not yet initialized"
+            raise ValueError(msg)
+        return self._questions
+
+    def appendQuestion(self, questionNumber: int, question) -> None:
+        if not hasattr(self, "_questions"):
+            self._questions: dict[int, Question] = {}
+        self._questions[questionNumber] = question
+
     def __hash__(self) -> int:
         return hash(self.NAME)
 
@@ -58,13 +69,20 @@ class Category:
             return self.NAME == other.NAME
         return False
 
-    def getCategoryHeader(self) -> ET.Element:
+    def getCategoryHeader(self, subCategory: str | None = None) -> 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}"
+        catStr = (
+            f"$module$/top/{self.NAME}"
+            if subCategory is None
+            else f"$module$/top/{self.NAME}/Question-{subCategory[2:]}_Variants"
+        )
+        ET.SubElement(cat, "text").text = catStr
         ET.SubElement(info, "text").text = str(self.desc)
-        ET.SubElement(header, "idnumber").text = self.id
+        ET.SubElement(header, "idnumber").text = (
+            f"cat-{self.id}" if subCategory is None else f"variants-{subCategory}"
+        )
         ET.indent(header)
         return header

excel2moodle/core/dataStructure.py

@@ -3,6 +3,7 @@
 At the heart is the class ``xmlTest``
 """
 
+import datetime as dt
 import logging
 import sys
 from concurrent.futures import ProcessPoolExecutor, as_completed
@@ -11,14 +12,16 @@ from typing import TYPE_CHECKING
 
 import lxml.etree as ET  # noqa: N812
 import pandas as pd
+import yaml
 from PySide6.QtCore import QObject, Signal
 from PySide6.QtWidgets import QDialog
 
+from excel2moodle import __version__
 from excel2moodle.core import stringHelpers
 from excel2moodle.core.category import Category
 from excel2moodle.core.exceptions import InvalidFieldException, QNotParsedException
 from excel2moodle.core.globals import Tags
-from excel2moodle.core.question import Question
+from excel2moodle.core.question import ParametricQuestion, Question
 from excel2moodle.core.settings import Settings
 from excel2moodle.core.validator import Validator
 from excel2moodle.logger import LogAdapterQuestionID
@@ -72,9 +75,10 @@ class QuestionDB:
     def __init__(self, settings: Settings) -> None:
         self.settings = settings
         self.window: QMainWindow | None = None
-        self.version = None
         self.categoriesMetaData: pd.DataFrame
         self.categories: dict[str, Category]
+        self._exportedQuestions: list[Question] = []
+        self._exportedAll: bool = False
 
     @property
     def spreadsheet(self) -> Path:
@@ -94,22 +98,39 @@ class QuestionDB:
         ``categoriesMetaData`` dataframe
         Setup the categories and store them  in ``self.categories = {}``
         Pass the question data to the categories.
+
+        Raises
+        ------
+        ValueError
+            When there is no 'seetings' worksheet in the file.
+        InvalidFieldException
+            When the settings are invalid
+
+        Before raising it logges the exceptions with a meaningful message.
+
         """
         sheetPath = sheetPath if sheetPath else self.spreadsheet
         logger.info("Start Parsing the Excel Metadata Sheet\n")
-        with Path(sheetPath).open("rb") as f:
-            settingDf = pd.read_excel(
-                f,
-                sheet_name="settings",
-                index_col=0,
-                engine="calamine",
+        try:
+            with Path(sheetPath).open("rb") as f:
+                settingDf = pd.read_excel(
+                    f,
+                    sheet_name="settings",
+                    index_col=0,
+                    engine="calamine",
+                )
+        except ValueError:
+            logger.exception(
+                "Did you forget to specify a 'settings' sheet in the file?"
             )
-            logger.debug("Found the settings: \n\t%s", settingDf)
-            settingDf = self.harmonizeDFIndex(settingDf)
-            for tag, value in settingDf.iterrows():
-                val = value.iloc[0]
-                if pd.notna(val):
-                    self.settings.set(tag, val)
+            raise
+        logger.debug("Found the settings: \n\t%s", settingDf)
+        settingDf = self.harmonizeDFIndex(settingDf)
+        for tag, value in settingDf.iterrows():
+            val = value.iloc[0]
+            if pd.notna(val):
+                self.settings.set(tag, val)
+
         try:
             self._validateProjectSettings(sheetPath=sheetPath)
         except InvalidFieldException:
@@ -342,13 +363,18 @@ class QuestionDB:
         else:
             msg = "couldn't setup Parser"
             raise QNotParsedException(msg, question.id)
-        category.questions[qNumber] = question
+        category.appendQuestion(qNumber, question)
         return question
 
     def appendQuestions(
-        self, questions: list[QuestionItem], file: Path | None = None
+        self,
+        questions: list[QuestionItem],
+        file: Path | None = None,
+        pCount: int = 0,
+        qCount: int = 0,
     ) -> None:
         """Append selected question Elements to the tree."""
+        self._exportedQuestions.clear()
         tree = ET.Element("quiz")
         catdict: dict[Category, list[Question]] = {}
         for q in questions:
@@ -365,6 +391,8 @@ class QuestionDB:
                 includeHeader=self.settings.get(Tags.INCLUDEINCATS),
             )
         stringHelpers.printDom(tree, file=file)
+        if self.settings.get(Tags.GENEXPORTREPORT):
+            self.generateExportReport(file, pCount=pCount, qCount=qCount)
 
     def _appendQElements(
         self,
@@ -373,17 +401,78 @@ class QuestionDB:
         tree: ET.Element,
         includeHeader: bool = True,
     ) -> None:
-        if includeHeader:
+        variant: int = self.settings.get(Tags.QUESTIONVARIANT)
+        if includeHeader or variant == -1:
             tree.append(cat.getCategoryHeader())
             logger.debug(f"Appended a new category item {cat=}")
-        variant: int = self.settings.get(Tags.QUESTIONVARIANT)
+            self._exportedAll: bool = True
         for q in qList:
-            if hasattr(q, "variants") and q.variants is not None:
-                if variant == 0 or variant > q.variants:
-                    dialog = QuestionVariantDialog(self.window, q)
-                    if dialog.exec() == QDialog.Accepted:
-                        variant = dialog.variant
-                        logger.debug("Die Fragen-Variante %s wurde gewählt", variant)
-                    else:
-                        logger.warning("Keine Fragenvariante wurde gewählt.")
-            tree.append(q.getUpdatedElement(variant=variant))
+            if not isinstance(q, ParametricQuestion):
+                tree.append(q.getUpdatedElement())
+                self._exportedQuestions.append(q)
+                continue
+            if variant == -1:
+                tree.append(cat.getCategoryHeader(subCategory=q.id))
+                for var in range(q.parametrics.variants):
+                    tree.append(q.getUpdatedElement(variant=var))
+            elif variant == 0 or variant > q.parametrics.variants:
+                dialog = QuestionVariantDialog(self.window, q)
+                if dialog.exec() == QDialog.Accepted:
+                    variant = dialog.variant
+                    logger.debug("Die Fragen-Variante %s wurde gewählt", variant)
+                else:
+                    logger.warning("Keine Fragenvariante wurde gewählt.")
+                tree.append(q.getUpdatedElement(variant=variant))
+            self._exportedQuestions.append(q)
+
+    def generateExportReport(
+        self, file: Path | None = None, pCount: int = 0, qCount: int = 0
+    ) -> None:
+        """Generate a YAML report of the exported questions."""
+        if not self._exportedQuestions:
+            return
+        if file:
+            base_path = file.with_name(f"{file.stem}_export_report.yaml")
+        else:
+            base_path = self.spreadsheet.parent / "export_report.yaml"
+
+        for i in range(99):
+            report_path = base_path.with_name(f"{base_path.stem}-{i:02d}.yaml")
+            if not report_path.resolve().exists():
+                break
+
+        report_data = {
+            "export_metadata": {
+                "export_time": dt.datetime.now(tz=None).strftime("%Y-%m-%d %H:%M:%S"),
+                "excel2moodle_version": __version__,
+            },
+            "categories": {},
+        }
+        if qCount != 0:
+            report_data["export_metadata"]["question_count"] = qCount
+        if pCount != 0:
+            report_data["export_metadata"]["total_point_count"] = pCount
+
+        sorted_questions = sorted(
+            self._exportedQuestions, key=lambda q: (q.category.name, q.id)
+        )
+
+        for question in sorted_questions:
+            category_name = question.category.name
+            if category_name not in report_data["categories"]:
+                report_data["categories"][category_name] = {
+                    "description": question.category.desc,
+                    "questions": [],
+                }
+
+            question_data = {"id": question.id, "name": question.name}
+            if isinstance(question, ParametricQuestion) and question.currentVariant > 0:
+                if self._exportedAll:
+                    question_data["exported_variant"] = "all"
+                else:
+                    question_data["exported_variant"] = question.currentVariant + 1
+
+            report_data["categories"][category_name]["questions"].append(question_data)
+
+        with report_path.open("w") as f:
+            yaml.dump(report_data, f, sort_keys=False)

excel2moodle/core/etHelpers.py

@@ -5,9 +5,6 @@ This module host different functions. All of them will return an ``lxml.etree.El
 
 import lxml.etree as ET
 
-import excel2moodle.core.etHelpers as eth
-from excel2moodle.core.globals import TextElements, feedbackStr, feedBElements
-
 from .globals import Tags, XMLTags
 
 
@@ -48,20 +45,3 @@ def getCdatTxtElement(subEle: ET._Element | list[ET._Element]) -> ET.Element:
         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."""
-    span = feedBElements[feedback] if style is None else 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/globals.py

@@ -89,12 +89,3 @@ feedBElements = {
     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",
-}

excel2moodle/core/parser.py

@@ -9,7 +9,6 @@ from excel2moodle.core.globals import (
     Tags,
     TextElements,
     XMLTags,
-    feedbackStr,
     feedBElements,
 )
 from excel2moodle.core.question import Picture, Question
@@ -30,7 +29,6 @@ class QuestionParser:
 
     def __init__(self) -> None:
         """Initialize the general Question parser."""
-        self.genFeedbacks: list[XMLTags] = []
         self.logger: logging.LoggerAdapter
 
     def setup(self, question: Question) -> None:
@@ -84,7 +82,7 @@ class QuestionParser:
         It uses the data from ``self.rawInput`` if ``text`` is type``DFIndex``
         Otherwise the value of ``text`` will be inserted.
         """
-        t = self.rawInput[text] if isinstance(text, Tags) else text
+        t = self.rawInput.get(text) if isinstance(text, Tags) else text
         if txtEle is False:
             self.tmpEle.append(eth.getElement(eleName, t, **attribs))
         elif txtEle is True:
@@ -111,12 +109,11 @@ class QuestionParser:
         self.appendToTmpEle(XMLTags.NAME, text=Tags.NAME, txtEle=True)
         self.appendToTmpEle(XMLTags.ID, text=self.question.id)
         textRootElem = ET.Element(XMLTags.QTEXT, format="html")
-        mainTextEle = ET.SubElement(textRootElem, "text")
+        self.mainTextEle = ET.SubElement(textRootElem, "text")
         self.tmpEle.append(textRootElem)
-        self.appendToTmpEle(XMLTags.POINTS, text=str(self.question.points))
+        if self.question.qtype != "CLOZE":
+            self.appendToTmpEle(XMLTags.POINTS, text=str(self.question.points))
         self._appendStandardTags()
-        for feedb in self.genFeedbacks:
-            self.tmpEle.append(eth.getFeedBEle(feedb))
 
         self.htmlRoot = ET.Element("div")
         self.htmlRoot.append(self.getMainTextElement())
@@ -139,10 +136,17 @@ class QuestionParser:
         if ansList is not None:
             for ele in ansList:
                 self.tmpEle.append(ele)
+        self._finalizeParsing()
+
+    def _finalizeParsing(self) -> None:
+        """Pass the parsed element trees to the question.
+
+        Intended for the subclasses to do extra stuff.
+        """
         self.question._element = self.tmpEle
         self.question.htmlRoot = self.htmlRoot
         self.question.isParsed = True
-        self.question.textElement = mainTextEle
+        self.question.textElement = self.mainTextEle
         self.logger.info("Sucessfully parsed")
 
     def getFeedBEle(
@@ -153,7 +157,8 @@ class QuestionParser:
     ) -> ET.Element:
         span = feedBElements[feedback] if style is None else style.create()
         if text is None:
-            text = feedbackStr[feedback]
+            self.logger.error("Giving a feedback without providing text is nonsens")
+            text = self.rawInput.get(Tags.GENERALFB)
         ele = ET.Element(feedback, format="html")
         par = TextElements.PLEFT.create()
         span.text = text
@@ -169,6 +174,7 @@ class QuestionParser:
         self,
         result: float = 0.0,
         fraction: float = 100,
+        feedback: str | None = None,
         format: str = "moodle_auto_format",
     ) -> ET.Element:
         """Get ``<answer/>`` Element specific for the numerical Question.
@@ -184,11 +190,13 @@ class QuestionParser:
             fraction=str(fraction),
             format=format,
         )
+        if feedback is None:
+            feedback = self.rawInput.get(Tags.TRUEFB)
         ansEle.append(
-            eth.getFeedBEle(
-                XMLTags.ANSFEEDBACK,
-                feedbackStr["right1Percent"],
-                TextElements.SPANGREEN,
+            self.getFeedBEle(
+                feedback=XMLTags.ANSFEEDBACK,
+                text=feedback,
+                style=TextElements.SPANGREEN,
             ),
         )
         absTolerance = round(result * self.rawInput.get(Tags.TOLERANCE), 4)

excel2moodle/core/question.py

@@ -2,6 +2,7 @@ import base64
 import logging
 import math
 import re
+from copy import deepcopy
 from pathlib import Path
 from types import UnionType
 from typing import TYPE_CHECKING, ClassVar, Literal, overload
@@ -37,12 +38,23 @@ class QuestionData(dict):
     @overload
     def get(
         self,
-        key: Literal[Tags.NAME, Tags.ANSTYPE, Tags.PICTURE, Tags.EQUATION],
+        key: Literal[
+            Tags.NAME,
+            Tags.ANSTYPE,
+            Tags.PICTURE,
+            Tags.EQUATION,
+            Tags.TRUEFB,
+            Tags.FALSEFB,
+            Tags.GENERALFB,
+            Tags.WRONGSIGNFB,
+        ],
+        default: object = None,
     ) -> str: ...
     @overload
     def get(
         self,
         key: Literal[Tags.BPOINTS, Tags.TRUE, Tags.FALSE, Tags.QUESTIONPART, Tags.TEXT],
+        default: object = None,
     ) -> list: ...
     @overload
     def get(
@@ -53,19 +65,22 @@ class QuestionData(dict):
             Tags.ANSPICWIDTH,
             Tags.WRONGSIGNPERCENT,
         ],
+        default: object = None,
     ) -> int: ...
     @overload
     def get(
-        self, key: Literal[Tags.PARTTYPE, Tags.TYPE]
+        self, key: Literal[Tags.PARTTYPE, Tags.TYPE], default: object = None
     ) -> Literal["MC", "NFM", "CLOZE"]: ...
     @overload
     def get(
-        self, key: Literal[Tags.TOLERANCE, Tags.POINTS, Tags.FIRSTRESULT]
+        self,
+        key: Literal[Tags.TOLERANCE, Tags.POINTS, Tags.FIRSTRESULT],
+        default: object = None,
     ) -> float: ...
     @overload
-    def get(self, key: Literal[Tags.RESULT]) -> float | str: ...
+    def get(self, key: Literal[Tags.RESULT], default: object = None) -> float | str: ...
 
-    def get(self, key: Tags, default=None):
+    def get(self, key, default=None):
         """Get the value for `key` with correct type.
 
         If `key == Tags.TOLERANCE` the tolerance is checked to be a perc. fraction
@@ -172,7 +187,7 @@ class Question:
         self.textElement.text = ET.CDATA(
             ET.tostring(self.htmlRoot, encoding="unicode", pretty_print=True)
         )
-        return self._element
+        return deepcopy(self._element)
 
     def _setID(self, id=0) -> None:
         if id == 0:
@@ -186,6 +201,11 @@ class ParametricQuestion(Question):
         super().__init__(*args, **kwargs)
         self.rules: list[str] = []
         self.parametrics: Parametrics
+        self._variant: int
+
+    @property
+    def currentVariant(self) -> int:
+        return self._variant
 
     def getUpdatedElement(self, variant: int = 0) -> ET.Element:
         """Update the bulletItem.text With the values for variant.
@@ -201,6 +221,7 @@ class ParametricQuestion(Question):
         self.bulletList.updateBullets(
             variables=self.parametrics.variables, variant=variant
         )
+        self._variant = variant
         return super().getUpdatedElement(variant)
 
 
@@ -272,32 +293,31 @@ class Parametrics:
             self.results[num] = []
         for variant in range(self.variants):
             type(self).setupAstIntprt(self._variables, variant)
-            self.logger.debug("Setup The interpreter for variant: %s", variant)
+            self.logger.debug("Setup The interpreter for variant: %s", variant + 1)
             for num, eq in self.equations.items():
                 result = type(self).astEval(eq)
+                if not isinstance(result, float | int):
+                    msg = f"The expression: '{eq}'  = {result} could not be evaluated."
+                    raise QNotParsedException(msg, self.id)
                 self.logger.info(
                     "Calculated expr. %s (variant %s): %s = %.3f ",
                     num,
-                    variant,
+                    variant + 1,
                     eq,
                     result,
                 )
-                if isinstance(result, float | int):
-                    if variant == 0 and not math.isclose(
-                        result, self._resultChecker[num], rel_tol=0.01
-                    ):
-                        self.logger.warning(
-                            "The calculated result %s differs from given firstResult: %s",
-                            result,
-                            self._resultChecker,
-                        )
-                    self.logger.debug(
-                        "Calculated result %s for variant %s", result, variant
+                if variant == 0 and not math.isclose(
+                    result, self._resultChecker[num], rel_tol=0.01
+                ):
+                    self.logger.warning(
+                        "The calculated result %s differs from given firstResult: %s",
+                        result,
+                        self._resultChecker,
                     )
-                    self.results[num].append(round(result, 3))
-                else:
-                    msg = f"The expression {eq} lead to: {result=} could not be evaluated."
-                    raise QNotParsedException(msg, self.id)
+                self.logger.debug(
+                    "Calculated result %s for variant %s", result, variant
+                )
+                self.results[num].append(round(result, 3))
         return self.results
 
     def resetVariables(self) -> None:

excel2moodle/core/settings.py

@@ -60,8 +60,9 @@ class Tags(StrEnum):
         """Get type of the keys data."""
         return self._typ_
 
-    QUESTIONVARIANT = "defaultQuestionVariant", int, 1, "testgen"
-    INCLUDEINCATS = "includeCats", bool, False, "testgen"
+    QUESTIONVARIANT = "defaultquestionvariant", int, 1, "testgen"
+    INCLUDEINCATS = "includecats", bool, False, "testgen"
+    GENEXPORTREPORT = "exportreport", bool, False, "testgen"
     TOLERANCE = "tolerance", float, 0.01, "parser/nf"
     PICTUREFOLDER = "pictureFolder", Path, None, "core"
     PICTURESUBFOLDER = "imgfolder", str, "Abbildungen", "project"
@@ -87,8 +88,13 @@ class Tags(StrEnum):
     POINTS = "points", float, 1.0
     PICTUREWIDTH = "imgwidth", int, 500
     ANSPICWIDTH = "answerimgwidth", int, 120
-    WRONGSIGNPERCENT = "wrongsignpercent", int, 50
     FIRSTRESULT = "firstresult", float, 0
+    WRONGSIGNPERCENT = "wrongsignpercent", int, 50
+    WRONGSIGNFB = "wrongsignfeedback", str, "your result has the wrong sign (+-)"
+    TRUEFB = "truefeedback", str, "congratulations!!! your answer is right."
+    FALSEFB = "falsefeedback", str, "Your answer is sadly wrong, try again!!!"
+    PCORRECFB = "partialcorrectfeedback", str, "Your answer is partially right."
+    GENERALFB = "feedback", str, "You answered this question."
 
 
 class Settings:
@@ -121,7 +127,7 @@ class Settings:
     ) -> int: ...
     @overload
     @classmethod
-    def get(cls, key: Literal[Tags.INCLUDEINCATS]) -> bool: ...
+    def get(cls, key: Literal[Tags.INCLUDEINCATS, Tags.GENEXPORTREPORT]) -> bool: ...
     @overload
     @classmethod
     def get(
@@ -132,6 +138,7 @@ class Settings:
             Tags.LOGFILE,
             Tags.CATEGORIESSHEET,
             Tags.IMPORTMODULE,
+            Tags.WRONGSIGNFB,
         ],
     ) -> str: ...
     @overload

excel2moodle/extra/equationVerification.py

@@ -32,8 +32,6 @@ from pathlib import Path
 
 import pandas as pd
 
-from excel2moodle.core import numericMultiQ as nmq
-
 # Hier Bitte die Frage angeben, die getestet Werden soll:
 
 # ===========================================================