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

excel2moodle/extra/variableGenerator.py

@@ -0,0 +1,250 @@
+import logging
+import random
+
+from asteval import Interpreter
+from PySide6.QtWidgets import (
+    QDialog,
+    QLineEdit,
+    QMainWindow,
+    QMessageBox,
+    QTableWidget,
+    QTableWidgetItem,
+)
+
+from excel2moodle.core.question import Parametrics
+from excel2moodle.ui.UI_variableGenerator import Ui_VariableGeneratorDialog
+
+logger = logging.getLogger(__name__)
+
+
+class VariableGeneratorDialog(QDialog):
+    def __init__(self, parent: QMainWindow, parametrics: Parametrics) -> None:
+        super().__init__(parent)
+        self.ui = Ui_VariableGeneratorDialog()
+        self.ui.setupUi(self)
+        self.origParametrics = parametrics
+        self._generatedParametrics: Parametrics = Parametrics(
+            parametrics.equations, parametrics._resultChecker, identifier="genr"
+        )
+        # Load existing rules
+        for rule in self.origParametrics.variableRules:
+            self.ui.listWidget_rules.addItem(rule)
+
+        self._populate_variables_table()
+        populateDataSetTable(
+            self.ui.tableWidget_existing_variables,
+            parametrics=self.origParametrics,
+        )
+        self._connect_signals()
+
+        # Initially hide the existing variables table and generated variables table
+        self.ui.tableWidget_existing_variables.hide()
+        self.ui.groupBox_generated_variables.hide()
+
+        self.aeval = Interpreter(minimal=True)  # Initialize asteval interpreter
+
+    def _populate_variables_table(self) -> None:
+        self.ui.tableWidget_variables.setRowCount(len(self.origParametrics.variables))
+        for row, (var_name, values) in enumerate(
+            self.origParametrics.variables.items()
+        ):
+            self.ui.tableWidget_variables.setItem(row, 0, QTableWidgetItem(var_name))
+            # Add QLineEdit for Min, Max, and Decimal Places
+            min_le = QLineEdit(str(min(values)) if values else "0")
+            max_le = QLineEdit(str(max(values)) if values else "100")
+            dec_le = QLineEdit("0")  # Default to 0 decimal places
+
+            self.ui.tableWidget_variables.setCellWidget(row, 1, min_le)
+            self.ui.tableWidget_variables.setCellWidget(row, 2, max_le)
+            self.ui.tableWidget_variables.setCellWidget(row, 3, dec_le)
+
+    def _connect_signals(self) -> None:
+        self.ui.pushButton_addRule.clicked.connect(self._add_rule)
+        self.ui.pushButton_removeRule.clicked.connect(self._remove_rule)
+        self.ui.pushButton_generate.clicked.connect(self.generateSets)
+        self.ui.pushButton_cancel.clicked.connect(self.reject)
+        self.ui.pushButton_save.clicked.connect(self._save_variables_and_close)
+        self.ui.groupBox_existing_variables.toggled.connect(
+            self.ui.tableWidget_existing_variables.setVisible
+        )
+
+    def _add_rule(self) -> None:
+        rule_text = self.ui.lineEdit_newRule.text().strip()
+        if rule_text:
+            self.ui.listWidget_rules.addItem(rule_text)
+            self.ui.lineEdit_newRule.clear()
+
+    def _remove_rule(self) -> None:
+        for item in self.ui.listWidget_rules.selectedItems():
+            self.ui.listWidget_rules.takeItem(self.ui.listWidget_rules.row(item))
+
+    def generateSets(self) -> None:
+        self._generatedParametrics.resetVariables()  # Clear previous generated sets
+        self._rule_error_occurred = False  # Reset error flag
+
+        varConstraints = {}
+        for row in range(self.ui.tableWidget_variables.rowCount()):
+            var_name = self.ui.tableWidget_variables.item(row, 0).text()
+            varConstraints[var_name] = {
+                "min": float(self.ui.tableWidget_variables.cellWidget(row, 1).text()),
+                "max": float(self.ui.tableWidget_variables.cellWidget(row, 2).text()),
+                "decimal_places": int(
+                    self.ui.tableWidget_variables.cellWidget(row, 3).text()
+                ),
+            }
+
+        rules = [
+            self.ui.listWidget_rules.item(i).text()
+            for i in range(self.ui.listWidget_rules.count())
+        ]
+
+        num_sets = self.ui.spinBox_numSets.value()
+
+        try:
+            generated_sets = [
+                self._findSet(varConstraints, rules) for _ in range(num_sets)
+            ]
+        except IndexError as e:
+            logger.exception("Invalid variables in Rule:")
+            QMessageBox.critical(self, "Rule Error", f"{e}")
+        except ValueError as e:
+            logger.warning("No variable set found:")
+            QMessageBox.warning(
+                self,
+                "Generation Failed",
+                f"{e} Consider relaxing your rules or increasing the number of attempts.",
+            )
+        else:
+            # convert the generated_sets list[dict[str, float]] into dict[str, list[float]]
+            # [{A:7, B:8}, {A:11, B:9}] -> {A: [7, 11], B: [8, 9]}
+            newVariables = {}
+            for var in self.origParametrics.variables:
+                newVariables[var] = [dataSet[var] for dataSet in generated_sets]
+            self._generatedParametrics.variables = newVariables
+            self.ui.groupBox_generated_variables.show()
+            populateDataSetTable(
+                self.ui.tableWidget_generated_variables,
+                parametrics=self._generatedParametrics,
+            )
+
+    def _findSet(
+        self,
+        constraints: dict[str, dict[str, float | int]],
+        rules: list[str],
+        maxAttempts: int = 1000,
+    ) -> dict[str, float]:
+        """Generate Random numbers for each variable and check if the rules apply.
+
+        Raises
+        ------
+            `IndexError`: if the evaluation of the rule returns `None`
+            `ValueError`: if fater `maxAttemps` no set is found
+
+        """
+        attempts = 0
+        while attempts < maxAttempts:
+            current_set: dict[str, float] = {}
+            # Generate initial values based on min/max constraints
+            for var_name, constr in constraints.items():
+                min_val: float = constr["min"]
+                max_val: float = constr["max"]
+                dec_places: int = constr["decimal_places"]
+
+                if dec_places == 0:
+                    current_set[var_name] = float(
+                        random.randint(int(min_val), int(max_val))
+                    )
+                else:
+                    current_set[var_name] = round(
+                        random.uniform(min_val, max_val), dec_places
+                    )
+            if self._check_rules(current_set, rules):
+                logger.info("Found matching set after %s attemps", attempts)
+                return current_set
+            attempts += 1
+        msg = f"Could not generate a valid set after {maxAttempts} attempts."
+        raise ValueError(msg)
+
+    def _check_rules(
+        self, varSet: dict[str, float], rules: list[str], show_error: bool = True
+    ) -> bool:
+        # Create a local scope for evaluating rules
+        self.aeval.symtable.update(varSet)
+
+        for rule in rules:
+            # Evaluate the rule using asteval
+            res = self.aeval(rule)
+            if res is None:
+                msg = f"Error evaluating rule '{rule}'"
+                raise IndexError(msg)
+            if res is False:
+                return False
+        return True
+
+    def _save_variables_and_close(self) -> None:
+        """Format variables set to fit `Parametrics`."""
+        logger.info("Saving new variables to the question")
+        newVars = self.origParametrics.variables.copy()
+        for varName in newVars:
+            newVars[varName].extend(self._generatedParametrics.variables[varName])
+        self.origParametrics.variableRules = [
+            self.ui.listWidget_rules.item(i).text()
+            for i in range(self.ui.listWidget_rules.count())
+        ]
+        self.origParametrics.variables = newVars
+        logger.info("Rules saved to Parametrics.")
+        self.accept()
+
+
+def populateDataSetTable(
+    tableWidget: QTableWidget,
+    parametrics: Parametrics | None = None,
+) -> None:
+    """Insert all Variables with their values into `tableWidget`."""
+    if parametrics is None:
+        return
+    variables = parametrics.variables
+    variants = parametrics.variants
+    tableWidget.setRowCount(len(variables) + len(parametrics.results))
+    tableWidget.setColumnCount(variants + 1)  # Variable Name + Variants
+    headers = ["Variable"] + [f"Set {i + 1}" for i in range(variants)]
+    tableWidget.setHorizontalHeaderLabels(headers)
+    for row, (var, values) in enumerate(variables.items()):
+        tableWidget.setItem(row, 0, QTableWidgetItem(var))
+        for col, value in enumerate(values):
+            tableWidget.setItem(row, col + 1, QTableWidgetItem(str(value)))
+    for row, results in parametrics.results.items():
+        logger.debug("adding Results to the DataSetTable: %s", results)
+        tableWidget.setItem(
+            len(variables) + row - 1, 0, QTableWidgetItem(f"Results: {row}")
+        )
+        for variant, res in enumerate(results):
+            tableWidget.setItem(
+                len(variables) + row - 1,
+                variant + 1,
+                QTableWidgetItem(str(res)),
+            )
+    tableWidget.resizeColumnsToContents()
+
+
+# This part is for testing the UI independently
+if __name__ == "__main__":
+    import sys
+
+    from PySide6.QtWidgets import QApplication
+
+    # Mock ParametricQuestion for testing
+    class MockParametricQuestion:
+        def __init__(self) -> None:
+            self.origParametrics.variables = {
+                "a": [1.0, 2.0, 3.0],
+                "b": [10, 20, 30],
+                "c": [0.5, 1.5, 2.5],
+            }
+
+    app = QApplication(sys.argv)
+    mock_question = MockParametricQuestion()
+    dialog = VariableGeneratorDialog(paramQuestion=mock_question)
+    if dialog.exec():
+        print("Generated Sets:", dialog.generatedVarSets())
+    sys.exit(app.exec())

excel2moodle/question_types/cloze.py

@@ -5,7 +5,6 @@ All Answers are calculated off an equation using the same variables.
 """
 
 import logging
-import math
 import re
 from typing import Literal, overload
 
@@ -16,8 +15,12 @@ from excel2moodle.core.globals import (
     Tags,
     TextElements,
 )
-from excel2moodle.core.question import ParametricQuestion
+from excel2moodle.core.question import (
+    ParametricQuestion,
+    Parametrics,
+)
 from excel2moodle.core.settings import Tags
+from excel2moodle.logger import LogAdapterQuestionID
 from excel2moodle.question_types.nfm import NFMQuestionParser
 
 logger = logging.getLogger(__name__)
@@ -28,12 +31,72 @@ class ClozePart:
         self,
         question: ParametricQuestion,
         text: list[str],
+        number: int,
     ) -> None:
         self.question = question
-        self.text: list[ET.Element] = self._setupText(text)
+        self.text: ET.Element = self._setupText(text)
+        self.num: int = number
         if not self.text:
             msg = f"Answer part for cloze question {self.question.id} is invalid without partText"
             raise ValueError(msg)
+        self.logger = LogAdapterQuestionID(
+            logger, {"qID": f"{self.question.id}-{self.num}"}
+        )
+        self._typ: Literal["NFM", "MC", "UNSET"]
+        self._element: ET.Element
+        self.result: Parametrics
+
+    @property
+    def clozeElement(self) -> ET.Element:
+        if not hasattr(self, "_clozeElement"):
+            msg = "Cloze Part has no _clozeElement"
+            raise QNotParsedException(msg, f"{self.question.id}-{self.num}")
+        return self._element
+
+    @clozeElement.setter
+    def clozeElement(self, element: ET.Element) -> None:
+        self._element = element
+
+    def updateCloze(self, variant: int = 1) -> None:
+        self.logger.info("Updating cloze to variant %s", variant)
+        if not hasattr(self, "_element"):
+            msg = "Cloze Part has no _clozeElement"
+            raise QNotParsedException(msg, f"{self.question.id}-{self.num}")
+        if self.typ == "MC":
+            self.logger.debug("MC Answer Part already up to date.")
+            return
+        if self.typ == "NFM":
+            result = self.result.getResult(variant)
+            self._element.text = ClozeQuestionParser.getNumericAnsStr(
+                result,
+                self.question.rawData.get(Tags.TOLERANCE),
+                wrongSignCount=self.question.rawData.get(Tags.WRONGSIGNPERCENT),
+                points=self.points,
+            )
+            self.logger.debug("Updated NFM cloze: %s", self._element.text)
+        return
+
+    @property
+    def typ(self) -> Literal["NFM", "MC", "UNSET"]:
+        if not hasattr(self, "_typ"):
+            self.logger.warning("Type not set")
+            return "UNSET"
+        return self._typ
+
+    @typ.setter
+    def typ(self, partType: Literal["NFM", "MC", "UNSET"]) -> None:
+        if not hasattr(self, "_typ"):
+            self._typ = partType
+            self.logger.info("Set type to: %s", self._typ)
+            if self._typ == "NFM":
+                self.result: Parametrics
+            elif self._typ == "MC":
+                self.falseAnswers: list[str] = []
+                self.trueAnswers: list[str] = []
+
+    @property
+    def id(self) -> str:
+        return f"{self.question.id}-{self.num}"
 
     @property
     def points(self) -> float:
@@ -47,12 +110,6 @@ class ClozePart:
     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"):
@@ -65,44 +122,14 @@ class ClozePart:
         self._mcAnswer: str = answerString
 
     def _setupText(self, text: list[str]) -> ET.Element:
-        textList: list[ET.Element] = []
+        textItem: ET.Element = TextElements.LISTITEM.create()
         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
+            textItem.append(TextElements.PLEFT.create())
+            textItem[-1].text = t
+        return textItem
 
     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}'"
+        return f"Cloze Part {self.id}-{self.typ}"
 
 
 class ClozeQuestion(ParametricQuestion):
@@ -112,6 +139,7 @@ class ClozeQuestion(ParametricQuestion):
         super().__init__(*args, **kwargs)
         self.questionParts: dict[int, ClozePart] = {}
         self.questionTexts: list[ET.Element] = []
+        self.parametrics: Parametrics
 
     @property
     def partsNum(self) -> int:
@@ -127,37 +155,16 @@ class ClozeQuestion(ParametricQuestion):
             pts = self.rawData.get(Tags.POINTS)
         return pts
 
-    def _assembleAnswer(self, variant: int = 1) -> None:
-        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)
-            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 getUpdatedElement(self, variant: int = 0) -> ET.Element:
+        """Update and get the Question Elements to reflect the version.
 
-    def _assembleText(self, variant=0) -> list[ET.Element]:
-        textParts = super()._assembleText(variant=variant)
-        self.logger.debug("Appending QuestionParts to main text")
-        textParts.extend(self.questionTexts)
-        return textParts
+        `ClozeQuestion` Updates the text.
+        `ParametricQuestion` updates the bullet points.
+        `Question` returns the element.
+        """
+        for part in self.questionParts.values():
+            part.updateCloze(variant=variant)
+        return super().getUpdatedElement(variant=variant)
 
 
 class ClozeQuestionParser(NFMQuestionParser):
@@ -176,21 +183,53 @@ class ClozeQuestionParser(NFMQuestionParser):
         self._parseAnswerParts()
 
     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.QUESTIONPART)
-        }
+        parts: dict[int, ClozePart] = {}
+        for key in self.rawInput:
+            if key.startswith(Tags.QUESTIONPART):
+                partNumber = self.getPartNumber(key)
+                parts[partNumber] = ClozePart(
+                    self.question, self.rawInput[key], partNumber
+                )
         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)
+        firstResult: dict[int, float] = self._getPartValues(Tags.FIRSTRESULT)
         for num, part in parts.items():
+            loclogger = LogAdapterQuestionID(
+                logger, {"qID": f"{self.question.id}-{num}"}
+            )
             eq = equations.get(num)
-            true = trueAnsws.get(num)
-            false = falseAnsws.get(num)
-            part.setAnswer(equation=eq, trueAns=true, falseAns=false)
+            trueAns = trueAnsws.get(num)
+            falseAns = falseAnsws.get(num)
+            if falseAns is not None and trueAns is not None and eq is None:
+                loclogger.info("Setting up MC answer part...")
+                part.typ = "MC"
+                part.falseAnswers = falseAns
+                part.trueAnswers = trueAns
+            elif eq is not None and falseAns is None and trueAns is None:
+                loclogger.info("Seting up NFM part..")
+                if not hasattr(self.question, "parametrics"):
+                    loclogger.info("Adding new Parametrics Object to cloze question")
+                    self.question.parametrics = Parametrics(
+                        equation=eq,
+                        firstResult=firstResult.get(num, 0.0),
+                        identifier=f"{self.question.id}-{num}",
+                    )
+                else:
+                    loclogger.info("Adding new equation to parametrics")
+                    self.question.parametrics.equations[num] = eq
+                    self.question.parametrics._resultChecker[num] = firstResult.get(
+                        num, 0.0
+                    )
+                if not hasattr(part, "result"):
+                    part.result = self.question.parametrics
+                part.typ = "NFM"
+                loclogger.info("Set up NFM answer part.")
+            else:
+                msg = f"Unclear Parts are defined. Either define `true:{num}` and `false:{num}` or `result:{num}` "
+                raise QNotParsedException(msg, self.question.id)
         if len(points) == 0:
             pts = round(self.rawInput.get(Tags.POINTS) / partsNum, 3)
             for part in parts.values():
@@ -202,13 +241,14 @@ class ClozeQuestionParser(NFMQuestionParser):
             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]: ...
+    def _getPartValues(
+        self, Tag: Literal[Tags.POINTS, Tags.FIRSTRESULT]
+    ) -> dict[int, float]: ...
     @overload
     def _getPartValues(
         self, Tag: Literal[Tags.TRUE, Tags.FALSE]
@@ -219,57 +259,48 @@ class ClozeQuestionParser(NFMQuestionParser):
             for key in self.rawInput
             if key.startswith(Tag)
         }
-        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 _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",
+        answersList = ET.Element("ol")
+        self.question.parametrics.variables = self.question.bulletList.getVariablesDict(
+            self.question
+        )
+        for partNum, part in self.question.questionParts.items():
+            if part.typ == "NFM":
+                result = self.question.parametrics.getResult(1, partNum)
+                ansStr = self.getNumericAnsStr(
                     result,
-                    firstResult,
+                    self.rawInput.get(Tags.TOLERANCE),
+                    wrongSignCount=self.rawInput.get(Tags.WRONGSIGNPERCENT),
+                    points=part.points,
+                )
+                self.logger.info("NF answer part: %s ", ansStr)
+                logger.debug("Appended NF part %s result", partNum)
+            elif part.typ == "MC":
+                ansStr = self.getMCAnsStr(
+                    part.trueAnswers, part.falseAnswers, points=part.points
                 )
-            return result
-        msg = f"The expression {part.equation} could not be evaluated."
-        raise QNotParsedException(msg, self.question.id)
+                part.mcAnswerString = ansStr
+                logger.debug("Appended MC part %s: %s", partNum, ansStr)
+            else:
+                msg = "Type of the answer part is invalid"
+                raise QNotParsedException(msg, self.id)
+            unorderedList = TextElements.ULIST.create()
+            answerItem = TextElements.LISTITEM.create()
+            answerItem.text = ansStr
+            part.clozeElement = answerItem
+            unorderedList.append(answerItem)
+            part.text.append(unorderedList)
+            self.logger.debug("Appended part %s %s to main text", partNum, part)
+            answersList.append(part.text)
+        self.htmlRoot.append(answersList)
 
     def getPartNumber(self, indexKey: str) -> int:
         """Return the number of the question Part.
 
-        The number should be given after the `@` sign.
+        The number should be given after the `:` colon.
         This is number is used, to reference the question Text
         and the expected answer fields together.
         """