excel2moodle 0.5.1__py3-none-any.whl → 0.5.2__py3-none-any.whl

excel2moodle/core/dataStructure.py

@@ -131,7 +131,7 @@ class QuestionDB:
         if Tags.IMPORTMODULE in self.settings:
             logger.warning(
                 "Appending: %s to sys.path. All names defined by it will be usable",
-                sheetPath,
+                sheetPath.parent,
             )
             sys.path.append(str(sheetPath.parent))
         if Tags.PICTURESUBFOLDER not in self.settings:
@@ -286,7 +286,7 @@ class QuestionDB:
         self.signals.categoryQuestionsReady.emit(category)
 
     @classmethod
-    def setupAndParseQuestion(cls, category: Category, qNumber: int) -> Question | None:
+    def setupAndParseQuestion(cls, category: Category, qNumber: int) -> Question:
         """Check if the Question Data is valid. Then parse it.
 
         The Question data is accessed from  `category.dataframe` via its number
@@ -322,7 +322,7 @@ class QuestionDB:
         question = QuestionTypeMapping[qtype].create(category, validData)
         if question.isParsed:
             locallogger.info("Question already parsed")
-            return None
+            return question
         if isinstance(question, NFQuestion):
             cls.nfParser.setup(question)
             locallogger.debug("setup a new NF parser ")

excel2moodle/core/question.py

@@ -161,7 +161,7 @@ class Question:
     def assemble(self, variant=0) -> None:
         """Assemble the question to the valid xml Tree."""
         mainText = self._getTextElement()
-        self.logger.debug("Starting assembly")
+        self.logger.info("Starting assembly variant: %s", variant)
         self._assembleAnswer(variant=variant)
         textParts = self._assembleText(variant=variant)
         if hasattr(self, "picture") and self.picture.ready:

excel2moodle/question_types/cloze.py

@@ -1,11 +1,13 @@
-"""Implementation of the cloze question type.
+"""Implementation of tde cloze question type.
 
 This question type is like the NFM but supports multiple fields of answers.
 All Answers are calculated off an equation using the same variables.
 """
 
+import logging
 import math
 import re
+from typing import Literal, overload
 
 import lxml.etree as ET
 
@@ -18,43 +20,143 @@ from excel2moodle.core.question import ParametricQuestion
 from excel2moodle.core.settings import Tags
 from excel2moodle.question_types.nfm import NFMQuestionParser
 
+logger = logging.getLogger(__name__)
+
+
+class ClozePart:
+    def __init__(
+        self,
+        question: ParametricQuestion,
+        text: list[str],
+    ) -> None:
+        self.question = question
+        self.text: list[ET.Element] = self._setupText(text)
+        if not self.text:
+            msg = f"Answer part for cloze question {self.question.id} is invalid without partText"
+            raise ValueError(msg)
+
+    @property
+    def points(self) -> float:
+        if hasattr(self, "_points"):
+            return self._points
+        return 0.0
+        self.question.logger.error("Invalid call to points of unparsed cloze part")
+        return 0.0
+
+    @points.setter
+    def points(self, points: float) -> None:
+        self._points = points if points > 0 else 0.0
+
+    @property
+    def typ(self) -> Literal["MC", "NFM"] | None:
+        if hasattr(self, "_typ"):
+            return self._typ
+        return None
+
+    @property
+    def mcAnswerString(self) -> str:
+        if hasattr(self, "_mcAnswer"):
+            return self._mcAnswer
+        msg = "No MC Answer was set"
+        raise ValueError(msg)
+
+    @mcAnswerString.setter
+    def mcAnswerString(self, answerString: str) -> None:
+        self._mcAnswer: str = answerString
+
+    def _setupText(self, text: list[str]) -> ET.Element:
+        textList: list[ET.Element] = []
+        for t in text:
+            textList.append(TextElements.PLEFT.create())
+            textList[-1].text = t
+        return textList
+
+    def setAnswer(
+        self,
+        equation: str | None = None,
+        trueAns: list[str] | None = None,
+        falseAns: list[str] | None = None,
+    ) -> bool:
+        if falseAns is not None:
+            self.falseAnswers: list[str] = falseAns
+        if trueAns is not None:
+            self.trueAnswers: list[str] = trueAns
+        if equation is not None:
+            self.equation: str = equation
+        check = False
+        t = hasattr(self, "trueAnswers")
+        f = hasattr(self, "falseAnswers")
+        eq = hasattr(self, "equation")
+        if t and f and not eq:
+            self._typ: Literal["MC", "NFM"] = "MC"
+            return True
+        if eq and not t and not f:
+            self._typ: Literal["MC", "NFM"] = "NFM"
+            self.nfResults: list[float] = []
+            return True
+        return False
+
+    def __repr__(self) -> str:
+        answers: str = (
+            self.equation
+            if self.typ == "NFM"
+            else f"{self.trueAnswers}\n {self.falseAnswers}"
+        )
+        return f"Cloze Part {self.typ}\n Answers: '{answers}'"
+
 
 class ClozeQuestion(ParametricQuestion):
     """Cloze Question Type."""
 
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
-        self.answerVariants: dict[int, list[float]] = {}
-        self.answerStrings: dict[int, list[str]] = {}
-        self.answerTypes: dict[int, str] = {}
-        self.questionTexts: dict[int, list[ET.Element]] = {}
-        self.partsNum: int = 0
+        self.questionParts: dict[int, ClozePart] = {}
+        self.questionTexts: list[ET.Element] = []
+
+    @property
+    def partsNum(self) -> int:
+        return len(self.questionParts)
+
+    @property
+    def points(self) -> float:
+        pts: float = 0
+        if self.isParsed:
+            for p in self.questionParts.values():
+                pts = pts + p.points
+        else:
+            pts = self.rawData.get(Tags.POINTS)
+        return pts
 
     def _assembleAnswer(self, variant: int = 1) -> None:
-        for part, ans in self.answerVariants.items():
-            result = ans[variant - 1]
-            if self.answerTypes.get(part, None) == "MC":
-                ansStr = ClozeQuestionParser.getMCAnsStr(answers)
-            else:
+        for partNum, part in self.questionParts.items():
+            if part.typ == "MC":
+                ansStr = part.mcAnswerString
+                self.logger.info("MC answer part: %s ", ansStr)
+            elif part.typ == "NFM":
+                result = part.nfResults[variant - 1]
                 ansStr = ClozeQuestionParser.getNumericAnsStr(
                     result,
                     self.rawData.get(Tags.TOLERANCE),
                     wrongSignCount=self.rawData.get(Tags.WRONGSIGNPERCENT),
+                    points=part.points,
                 )
+                self.logger.info("NF answer part: %s ", ansStr)
+            else:
+                msg = "Type of the answer part is invalid"
+                raise QNotParsedException(msg, self.id)
             ul = TextElements.ULIST.create()
             item = TextElements.LISTITEM.create()
             item.text = ansStr
             ul.append(item)
-            self.questionTexts[part].append(ul)
-            self.logger.debug("Appended Question Parts %s to main text", part)
-            self.questionTexts[part].append(ET.Element("hr"))
+            part.text.append(ul)
+            self.logger.debug("Appended part %s %s to main text", partNum, part)
+            part.text.append(ET.Element("hr"))
+            self.questionTexts.extend(part.text)
 
     def _assembleText(self, variant=0) -> list[ET.Element]:
         textParts = super()._assembleText(variant=variant)
         self.logger.debug("Appending QuestionParts to main text")
-        for paragraphs in self.questionTexts.values():
-            for par in paragraphs:
-                textParts.append(par)
+        textParts.extend(self.questionTexts)
         return textParts
 
 
@@ -70,67 +172,99 @@ class ClozeQuestionParser(NFMQuestionParser):
         super().setup(question)
 
     def _parseAnswers(self) -> None:
+        self._setupParts()
         self._parseAnswerParts()
-        self._parseQuestionParts()
 
-    def _parseAnswerParts(self) -> None:
-        """Parse the numeric or MC result items."""
-        self.question.answerTypes: dict[int, str] = {
-            self.getPartNumber(key): self.rawInput[key]
+    def _setupParts(self) -> None:
+        parts: dict[int, ClozePart] = {
+            self.getPartNumber(key): ClozePart(self.question, self.rawInput[key])
             for key in self.rawInput
-            if key.startswith(Tags.PARTTYPE)
+            if key.startswith(Tags.QUESTIONPART)
         }
-        equations: dict[int, str] = {
+        partsNum = len(parts)
+        equations: dict[int, str] = self._getPartValues(Tags.RESULT)
+        trueAnsws: dict[int, list[str]] = self._getPartValues(Tags.TRUE)
+        falseAnsws: dict[int, list[str]] = self._getPartValues(Tags.FALSE)
+        points: dict[int, float] = self._getPartValues(Tags.POINTS)
+        for num, part in parts.items():
+            eq = equations.get(num)
+            true = trueAnsws.get(num)
+            false = falseAnsws.get(num)
+            part.setAnswer(equation=eq, trueAns=true, falseAns=false)
+        if len(points) == 0:
+            pts = round(self.rawInput.get(Tags.POINTS) / partsNum, 3)
+            for part in parts.values():
+                part.points = pts
+        elif len(points) != partsNum:
+            logger.warning(
+                "Some Answer parts are missing the points, they will get the standard points"
+            )
+            for num, part in parts.items():
+                p = points.get(num)
+                part.points = p if p is not None else self.rawInput.get(Tags.POINTS)
+
+        self.question.questionParts = parts
+
+    @overload
+    def _getPartValues(self, Tag: Literal[Tags.RESULT]) -> dict[int, str]: ...
+    @overload
+    def _getPartValues(self, Tag: Literal[Tags.POINTS]) -> dict[int, float]: ...
+    @overload
+    def _getPartValues(
+        self, Tag: Literal[Tags.TRUE, Tags.FALSE]
+    ) -> dict[int, list[str]]: ...
+    def _getPartValues(self, Tag):
+        tagValues: dict = {
             self.getPartNumber(key): self.rawInput[key]
             for key in self.rawInput
-            if key.startswith(Tags.RESULT)
+            if key.startswith(Tag)
         }
-        self.logger.debug("Got the following answers: %s", equations)
-        bps = str(self.rawInput[Tags.BPOINTS])
-        varNames: list[str] = self._getVarsList(bps)
-        numericAnswers: dict[int, list[float]] = {key: [] for key in equations}
-        self.question.variables, number = self._getVariablesDict(varNames)
-        for n in range(number):
-            self.setupAstIntprt(self.question.variables, n)
-            for ansNum, eq in equations.items():
-                result = self.astEval(eq)
-                if isinstance(result, float):
-                    firstResult = self.rawInput.get(Tags.FIRSTRESULT)
-                    if n == 0 and not math.isclose(result, firstResult, rel_tol=0.01):
-                        self.logger.warning(
-                            "The calculated result %s differs from given firstResult: %s",
-                            result,
-                            firstResult,
-                        )
-                    numericAnswers[ansNum].append(result)
-                else:
-                    msg = f"The expression {eq} could not be evaluated."
-                    raise QNotParsedException(msg, self.question.id)
-
-        self.question.answerVariants = numericAnswers
+        self.logger.warning("Found part data %s:  %s", Tag, tagValues)
+        return tagValues
+
+    def _parseAnswerParts(self) -> None:
+        """Parse the numeric or MC result items."""
+        try:
+            bps = str(self.rawInput[Tags.BPOINTS])
+        except KeyError:
+            bps = None
+            number = 1
+        else:
+            varNames: list[str] = self._getVarsList(bps)
+            self.question.variables, number = self._getVariablesDict(varNames)
+        for variant in range(number):
+            self.setupAstIntprt(self.question.variables, variant)
+            for partNum, part in self.question.questionParts.items():
+                if part.typ == "NFM":
+                    result = self._calculateNFMPartResult(part, partNum, variant)
+                    part.nfResults.append(result)
+                    logger.debug("Appended NF part %s result: %s", partNum, result)
+                elif part.typ == "MC":
+                    ansStr = self.getMCAnsStr(
+                        part.trueAnswers, part.falseAnswers, points=part.points
+                    )
+                    part.mcAnswerString = ansStr
+                    logger.debug("Appended MC part %s: %s", partNum, ansStr)
         self._setVariants(number)
 
-    def _parseQuestionParts(self) -> None:
-        """Generate the question parts aka the clozes."""
-        parts: dict[int, list[str]] = {
-            self.getPartNumber(key): self.rawInput[key]
-            for key in self.rawInput
-            if key.startswith(Tags.QUESTIONPART)
-        }
-        questionParts: dict[int, list[ET.Element]] = {}
-        for number, text in parts.items():
-            questionParts[number] = []
-            for t in text:
-                questionParts[number].append(TextElements.PLEFT.create())
-                questionParts[number][-1].text = t
-        self.logger.debug("The Question Parts are created:", questionParts)
-        self.question.questionTexts = questionParts
-        self.question.partsNum = len(questionParts)
-        self.logger.info("The Question has %s parts", self.question.partsNum)
-
-    # def setMainText(self) -> None:
-    #     super().setMainText()
-    #     self.question.qtextParagraphs
+    def _calculateNFMPartResult(
+        self, part: ClozePart, partNum: int, variant: int
+    ) -> float:
+        result = self.astEval(part.equation)
+        if isinstance(result, float):
+            try:
+                firstResult = self.rawInput[f"{Tags.FIRSTRESULT}:{partNum}"]
+            except KeyError:
+                firstResult = 0.0
+            if variant == 0 and not math.isclose(result, firstResult, rel_tol=0.002):
+                self.logger.warning(
+                    "The calculated result %s differs from given firstResult: %s",
+                    result,
+                    firstResult,
+                )
+            return result
+        msg = f"The expression {part.equation} could not be evaluated."
+        raise QNotParsedException(msg, self.question.id)
 
     def getPartNumber(self, indexKey: str) -> int:
         """Return the number of the question Part.
@@ -151,7 +285,7 @@ class ClozeQuestionParser(NFMQuestionParser):
     def getNumericAnsStr(
         result: float,
         tolerance: float,
-        weight: int = 1,
+        points: float = 1,
         wrongSignCount: int = 50,
         wrongSignFeedback: str = "your result has the wrong sign (+-)",
     ) -> str:
@@ -159,12 +293,6 @@ class ClozeQuestionParser(NFMQuestionParser):
 
         Parameters.
         ----------
-        weight:
-            The weight of the answer relative to the other answer elements.
-            Of one answer has `weight=2` and two other answers `weight=1`,
-            this answer will be counted as 50% of the questions points.
-            The other two will counted as 25% of the questions points.
-
         wrongSignCount:
             If the wrong sign `+` or `-` is given, how much of the points should be given.
             Interpreted as percent.
@@ -175,7 +303,7 @@ class ClozeQuestionParser(NFMQuestionParser):
         absTol = f":{round(result * tolerance, 3)}"
         answerParts: list[str | float] = [
             "{",
-            weight,
+            points,
             ":NUMERICAL:=",
             round(result, 3),
             absTol,
@@ -194,14 +322,21 @@ class ClozeQuestionParser(NFMQuestionParser):
     def getMCAnsStr(
         true: list[str],
         false: list[str],
-        weight: int = 1,
+        points: float = 1,
     ) -> str:
         """Generate the answer string for the MC answers."""
+        truePercent: float = round(100 / len(true), 1)
+        falsePercent: float = round(100 / len(false), 1)
+        falseList: list[str] = [f"~%-{falsePercent}%{ans}" for ans in false]
+        trueList: list[str] = [f"~%{truePercent}%{ans}" for ans in true]
         answerParts: list[str | float] = [
             "{",
-            weight,
-            ":MC:",
-            "}",
+            points,
+            ":MULTIRESPONSE:",
         ]
+        answerParts.extend(trueList)
+        answerParts.extend(falseList)
+        answerParts.append("}")
+
         answerPStrings = [str(part) for part in answerParts]
-        return "".join(answerPString)
+        return "".join(answerPStrings)

excel2moodle/question_types/nfm.py

@@ -45,14 +45,15 @@ class NFMQuestionParser(QuestionParser):
         super().__init__()
         self.genFeedbacks = [XMLTags.GENFEEDB]
         self.question: NFMQuestion
-        module = self.settings.get(Tags.IMPORTMODULE)
-        if module and not type(self).astEval.symtable.get(module):
-            type(self).astEval(f"import {module}")
-            self.logger.warning("Imported '%s' to Asteval symtable", module)
 
     def setup(self, question: NFMQuestion) -> None:
         self.question: NFMQuestion = question
         super().setup(question)
+        module = self.settings.get(Tags.IMPORTMODULE)
+        if module and type(self).astEval.symtable.get(module, None) is None:
+            type(self).astEval(f"import {module}")
+            imported = type(self).astEval.symtable.get(module)
+            self.logger.warning("Imported '%s' to Asteval symtable.", module)
 
     def _parseAnswers(self) -> None:
         equation = self.rawInput.get(Tags.EQUATION)

excel2moodle/ui/appUi.py

@@ -51,23 +51,27 @@ class MainWindow(QtWidgets.QMainWindow):
         self.ui.treeWidget.header().setSectionResizeMode(
             QtWidgets.QHeaderView.ResizeToContents,
         )
+        self.ui.pointCounter.setReadOnly(True)
+        self.ui.questionCounter.setReadOnly(True)
+        self.setStatus(
+            "Wählen Sie eine Excel Tabelle mit den Fragen aus",
+        )
+        self.threadPool = QThreadPool()
+        self._restoreSettings()
+
+    def _restoreSettings(self) -> None:
+        """Restore the settings from the last session, if they exist."""
         self.exportDialog.ui.checkBoxIncludeCategories.setChecked(
             self.qSettings.value(Tags.INCLUDEINCATS, defaultValue=True, type=bool)
         )
         self.exportDialog.ui.spinBoxDefaultQVariant.setValue(
             self.qSettings.value(Tags.QUESTIONVARIANT, defaultValue=1, type=int)
         )
-        self.ui.pointCounter.setReadOnly(True)
-        self.ui.questionCounter.setReadOnly(True)
-        self.setStatus(
-            "Wählen Sie eine Excel Tabelle mit den Fragen aus",
-        )
         try:
             self.resize(self.qSettings.value("windowSize"))
             self.move(self.qSettings.value("windowPosition"))
         except Exception:
             pass
-        self.threadPool = QThreadPool()
         if self.qSettings.contains(Tags.SPREADSHEETPATH.full):
             sheet = self.qSettings.value(Tags.SPREADSHEETPATH.full)
             self.setSheetPath(sheet)
@@ -79,9 +83,6 @@ class MainWindow(QtWidgets.QMainWindow):
         )
         loggerSignal.emitter.signal.connect(self.updateLog)
         self.ui.actionEquationChecker.triggered.connect(self.openEqCheckerDlg)
-        self.exportDialog.ui.checkBoxIncludeCategories.checkStateChanged.connect(
-            self.setIncludeCategoriesSetting,
-        )
         self.ui.actionParseAll.triggered.connect(self.parseSpreadsheetAll)
         self.testDB.signals.categoryQuestionsReady.connect(self.treeRefreshCategory)
         self.ui.actionSpreadsheet.triggered.connect(self.actionSpreadsheet)
@@ -91,13 +92,6 @@ class MainWindow(QtWidgets.QMainWindow):
         self.ui.treeWidget.itemClicked.connect(self.updateQuestionPreview)
         self.ui.actionAbout.triggered.connect(self.openAboutDlg)
         self.ui.actionDocumentation.triggered.connect(self.openDocumentation)
-        self.exportDialog.ui.spinBoxDefaultQVariant.valueChanged.connect(
-            self.setQVariantDefault
-        )
-
-    @QtCore.Slot()
-    def setQVariantDefault(self, value: int) -> None:
-        self.settings.set(Tags.QUESTIONVARIANT, value)
 
     @QtCore.Slot()
     def parseSpreadsheetAll(self) -> None:
@@ -128,12 +122,6 @@ class MainWindow(QtWidgets.QMainWindow):
     def updateLog(self, log) -> None:
         self.ui.loggerWindow.append(log)
 
-    def setIncludeCategoriesSetting(self) -> None:
-        if self.exportDialog.ui.checkBoxIncludeCategories.isChecked():
-            self.settings.set(Tags.INCLUDEINCATS, True)
-        else:
-            self.settings.set(Tags.INCLUDEINCATS, False)
-
     def closeEvent(self, event) -> None:
         logger.info("Closing. Saving window stats.")
         self.qSettings.setValue("windowSize", self.size())
@@ -179,6 +167,14 @@ class MainWindow(QtWidgets.QMainWindow):
         self.exportDialog.ui.pointCount.setValue(self.ui.pointCounter.value())
         if self.exportDialog.exec():
             self.exportFile = self.exportDialog.exportFile
+            self.settings.set(
+                Tags.INCLUDEINCATS,
+                self.exportDialog.ui.checkBoxIncludeCategories.isChecked(),
+            )
+            self.settings.set(
+                Tags.QUESTIONVARIANT,
+                self.exportDialog.ui.spinBoxDefaultQVariant.value(),
+            )
             logger.info("New Export File is set %s", self.exportFile)
             self.testDB.appendQuestions(selection, self.exportFile)
         else:

{excel2moodle-0.5.1.dist-info → excel2moodle-0.5.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: excel2moodle
-Version: 0.5.1
+Version: 0.5.2
 Summary: A package for converting questions from a spreadsheet, to valid moodle-xml
 Author: Jakob Bosse
 License-Expression: GPL-3.0-or-later
@@ -81,6 +81,46 @@ If You want to support my work as well, you can by me a [coffee](https://ko-fi.c
 
 # Changelogs
 
+## 0.5.2 (2025-06-30)
+Extended Documentation and bugfix for import Module
+
+### bugfix (2 changes)
+
+- [Default question variant saved and reused.](https://gitlab.com/jbosse3/excel2moodle/-/commit/097705ba83727463a9b27cd76e99814a7ecf28df)
+- [bugfix: Import module working again](https://gitlab.com/jbosse3/excel2moodle/-/commit/5f293970bcdac3858911cdcc102b72714af057bd)
+
+### documentation (1 change)
+
+- [documentation: Added how to build question database](https://gitlab.com/jbosse3/excel2moodle/-/commit/71ceb122aa37e8bf2735b659359ae37d81017599)
+
+### feature (1 change)
+
+- [Implemented MC question string method](https://gitlab.com/jbosse3/excel2moodle/-/commit/c4f2081d0000ee60322fe8eec8468fa3317ce7be)
+
+### improvement (1 change)
+
+- [Implemented ClozePart object](https://gitlab.com/jbosse3/excel2moodle/-/commit/878f90f45e37421384c4f8f602115e7596b4ceb9)
+
+## 0.5.2 (2025-06-30)
+Extended Documentation and bugfix for import Module
+
+### bugfix (2 changes)
+
+- [Default question variant saved and reused.](https://gitlab.com/jbosse3/excel2moodle/-/commit/097705ba83727463a9b27cd76e99814a7ecf28df)
+- [bugfix: Import module working again](https://gitlab.com/jbosse3/excel2moodle/-/commit/5f293970bcdac3858911cdcc102b72714af057bd)
+
+### documentation (1 change)
+
+- [documentation: Added how to build question database](https://gitlab.com/jbosse3/excel2moodle/-/commit/71ceb122aa37e8bf2735b659359ae37d81017599)
+
+### feature (1 change)
+
+- [Implemented MC question string method](https://gitlab.com/jbosse3/excel2moodle/-/commit/c4f2081d0000ee60322fe8eec8468fa3317ce7be)
+
+### improvement (1 change)
+
+- [Implemented ClozePart object](https://gitlab.com/jbosse3/excel2moodle/-/commit/878f90f45e37421384c4f8f602115e7596b4ceb9)
+
 ## 0.5.1 (2025-06-24)
 Minor docs improvement and question variant bugfix
 

{excel2moodle-0.5.1.dist-info → excel2moodle-0.5.2.dist-info}/RECORD

@@ -3,36 +3,36 @@ excel2moodle/__main__.py,sha256=sG4ygwfVFskLQorBn-v98SvasNcPmwl_vLYpruT5Hk8,1175
 excel2moodle/logger.py,sha256=fq8ZOkCI1wj38v8IyrZsUlpt16onlSH_phqbVvYUwBQ,3725
 excel2moodle/core/__init__.py,sha256=87BwhtZse72Tk17Ib-V9X2k9wkhmtVnEj2ZmJ9JBAnI,63
 excel2moodle/core/category.py,sha256=wLzpbweQbzaItdbp2NCPI_Zmk94fy1EDOwEEN8zPvkU,2123
-excel2moodle/core/dataStructure.py,sha256=sDdum2I0EZRuXTgbVSsLX4aBINfzkmNXBCHzUVBhxH8,16022
+excel2moodle/core/dataStructure.py,sha256=0XVu6NqKKNrjL0B9UVD9di-uqriGIdF-57lwx0ckeDI,16026
 excel2moodle/core/etHelpers.py,sha256=G37qplp8tPJxqHNCBrf2Wo0jJZ0aDbxE9slQavqYqd8,2293
 excel2moodle/core/exceptions.py,sha256=9xfsaIcm6Yej6QAZga0d3DK3jLQejdfgJARuAaG-uZY,739
 excel2moodle/core/globals.py,sha256=Zm1wcrzQTRnhjrkwgBvo7VjKCFdPMjh-VLSSI5_QCO8,2837
 excel2moodle/core/numericMultiQ.py,sha256=vr-gYogu2sf2a_Bhvhnu1ZSZFZXM32MfhJesjTkoOQM,2618
 excel2moodle/core/parser.py,sha256=y0BXXt5j-4gRZO8otmEZ1Rmb0DW7hziesUoZ2kVpo9Y,8235
-excel2moodle/core/question.py,sha256=vtrYq0J5D7PivkVo4eMUx_5l5jCyunmjThij38QopyY,11706
+excel2moodle/core/question.py,sha256=_BSaMdDB269Q4Ag7izegMiExjYRTYOuhYe-qo92EAAg,11726
 excel2moodle/core/settings.py,sha256=27D-P44rYk-DMrwI1dNpxHcznpFQf1W3XZrOc8e6rX4,5855
 excel2moodle/core/stringHelpers.py,sha256=OzFZ6Eu3PeBLKb61K-aeVfUZmVuBerr9KfyOsuNRd7Y,2403
 excel2moodle/core/validator.py,sha256=ssgkyUwrR-0AGPX1cUqvRwZsGja13J7HQ2W72ltqN-Y,4683
 excel2moodle/extra/__init__.py,sha256=PM-id60HD21A3IcGC_fCYFihS8osBGZMIJCcN-ZRsIM,293
 excel2moodle/extra/equationVerification.py,sha256=GLJl1r90d8AAiNy0H2hooZrg3D6aEwNfifYKAe3aGxM,3921
 excel2moodle/question_types/__init__.py,sha256=81mss0g7SVtnlb-WkydE28G_dEAAf6oT1uB8lpK2-II,1041
-excel2moodle/question_types/cloze.py,sha256=N-0fDSWfpxYN0YZmPQPEaNHpxqW1OOC32WNseYmy6zM,7657
+excel2moodle/question_types/cloze.py,sha256=-F2CozuNHRvTDQM69DgkKXTvw9wMLXfipkdhfTNWSSs,11969
 excel2moodle/question_types/mc.py,sha256=2kn6dPjFVg97H8SlUBFbcPjzDk84vgDGCMOtSABseu0,5225
 excel2moodle/question_types/nf.py,sha256=bMP4IXrhnXmAI0NmjEc7DtX4xGaUbxzLicE2LjeaUho,1150
-excel2moodle/question_types/nfm.py,sha256=03-aihk9HtzRCgpCGz_5WOR4JOqdJlkafyKprgLrosI,4948
+excel2moodle/question_types/nfm.py,sha256=LTQ60qrhYUqKXoZW4AKz352rD4pgN0wAX_tm5FLFbV0,5022
 excel2moodle/ui/UI_equationChecker.py,sha256=evQDlqCHeooJcAnYjhFCyjlPhfknr7ULGKQwMmqQeJ4,8947
 excel2moodle/ui/UI_exportSettingsDialog.py,sha256=71xxXEqtewN0ReMfJ5t4gbrX_Bf0VEuxJ_DIV7ZtH94,6045
 excel2moodle/ui/UI_mainWindow.py,sha256=asWUmKIYqufKUvRuCuA1JoMyv4qfRXyoR70F0331lww,19291
 excel2moodle/ui/UI_variantDialog.py,sha256=snVaF3_YAc7NWjMRg7NzbjL_PzNbOpt4eiqElkE46io,5414
 excel2moodle/ui/__init__.py,sha256=4EdGtpzwH3rgw4xW9E5x9kdPQYwKbo9rehHRZTNxCrQ,44
-excel2moodle/ui/appUi.py,sha256=88WODtEWqX1oQJebbPhlQChKM5N_9BH0ZuOpKVYrKm0,10863
+excel2moodle/ui/appUi.py,sha256=caNdBb4_C2Ptl0He2iCQqoxw6Tm0wmJL9eOoKfjMah8,10681
 excel2moodle/ui/dialogs.py,sha256=0h6aD4tguph1P07dorkn1A5B7_Z5SJZQ2_8xBYWK6MU,7689
 excel2moodle/ui/equationChecker.py,sha256=ANpN7S0llkp6pGL1sKHII1Jc8YUvgDR458UnGVnZZOo,2702
 excel2moodle/ui/treewidget.py,sha256=az64swVj1yQUsioeaZys32AauvQDdC4EKcqdbbWgL6s,2489
 excel2moodle/ui/windowDoc.py,sha256=WvzHj6F4JvHP82WlTsyFeOXW024Xq3BUqtp--T4twuI,661
-excel2moodle-0.5.1.dist-info/licenses/LICENSE,sha256=ywQqe6Sitymkf2lV2NRcx_aGsaC-KbSl_EfEsRXmNRw,35135
-excel2moodle-0.5.1.dist-info/METADATA,sha256=H0kM9fFOx63yWYuKrq6ffdZglqWWCxdrxpKNdop3C0E,4614
-excel2moodle-0.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-excel2moodle-0.5.1.dist-info/entry_points.txt,sha256=myfMLDThuGgWHMJDPPfILiZqo_7D3fhmDdJGqWOAjPw,60
-excel2moodle-0.5.1.dist-info/top_level.txt,sha256=5V1xRUQ9o7UmOCmNoWCZPAuy5nXp3Qbzyqch8fUGT_c,13
-excel2moodle-0.5.1.dist-info/RECORD,,
+excel2moodle-0.5.2.dist-info/licenses/LICENSE,sha256=ywQqe6Sitymkf2lV2NRcx_aGsaC-KbSl_EfEsRXmNRw,35135
+excel2moodle-0.5.2.dist-info/METADATA,sha256=pskuhRVnt-PEmvxVxvPUvN03gHmilnZqeFluoPOkPrk,6330
+excel2moodle-0.5.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+excel2moodle-0.5.2.dist-info/entry_points.txt,sha256=myfMLDThuGgWHMJDPPfILiZqo_7D3fhmDdJGqWOAjPw,60
+excel2moodle-0.5.2.dist-info/top_level.txt,sha256=5V1xRUQ9o7UmOCmNoWCZPAuy5nXp3Qbzyqch8fUGT_c,13
+excel2moodle-0.5.2.dist-info/RECORD,,