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

excel2moodle/core/bullets.py

@@ -0,0 +1,98 @@
+import logging
+import re
+
+import lxml.etree as ET
+
+from excel2moodle.core import stringHelpers
+from excel2moodle.core.globals import TextElements
+from excel2moodle.core.question import ParametricQuestion
+from excel2moodle.logger import LogAdapterQuestionID
+
+loggerObj = logging.getLogger(__name__)
+
+
+class BulletList:
+    def __init__(self, rawBullets: list[str], qID: str) -> None:
+        self.rawBullets: list[str] = rawBullets
+        self.element: ET.Element = ET.Element("ul")
+        self.bullets: dict[str, BulletP] = {}
+        self.id = qID
+        self.logger = LogAdapterQuestionID(loggerObj, {"qID": self.id})
+        self._setupBullets(rawBullets)
+
+    def updateBullets(
+        self, variables: dict[str, list[float]], variant: int = 1
+    ) -> None:
+        for var, bullet in self.bullets.items():
+            bullet.update(value=variables[var][variant - 1])
+
+    def getVariablesDict(self, question: ParametricQuestion) -> dict[str, list[float]]:
+        """Read variabel values for vars in `question.rawData`.
+
+        Returns
+        -------
+        A dictionary containing a list of values for each variable name
+
+        """
+        keyList = self.varNames
+        dic: dict = {}
+        for k in keyList:
+            val = question.rawData[k.lower()]
+            if isinstance(val, str):
+                li = stringHelpers.getListFromStr(val)
+                variables: list[float] = [float(i.replace(",", ".")) for i in li]
+                dic[str(k)] = variables
+            else:
+                dic[str(k)] = [str(val)]
+        loggerObj.debug("The following variables were provided: %s", dic)
+        return dic
+
+    @property
+    def varNames(self) -> list[str]:
+        names = [i for i in self.bullets if isinstance(i, str)]
+        if len(names) > 0:
+            self.logger.debug("returning Var names: %s", names)
+            return names
+        msg = "Bullet variable names not given."
+        raise ValueError(msg)
+
+    def _setupBullets(self, bps: list[str]) -> ET.Element:
+        self.logger.debug("Formatting the bulletpoint list")
+        varFinder = re.compile(r"=\s*\{(\w+)\}")
+        for i, item in enumerate(bps):
+            sc_split = item.split()
+            name = sc_split[0]
+            var = sc_split[1]
+            quant = sc_split[3]
+            unit = sc_split[4]
+
+            match = re.search(varFinder, item)
+            if match is None:
+                self.logger.debug("Got a normal bulletItem")
+                num: float = float(quant.replace(",", "."))
+                bulletName: str = str(i + 1)
+            else:
+                bulletName = match.group(1)
+                num: float = 0.0
+                self.logger.debug("Got an variable bulletItem, match: %s", match)
+
+            self.bullets[bulletName] = BulletP(name=name, var=var, unit=unit, value=num)
+            self.element.append(self.bullets[bulletName].element)
+        return self.element
+
+
+class BulletP:
+    def __init__(self, name: str, var: str, unit: str, value: float = 0.0) -> None:
+        self.name: str = name
+        self.var: str = var
+        self.unit: str = unit
+        self.element: ET.Element
+        self.update(value=value)
+
+    def update(self, value: float = 1) -> None:
+        if not hasattr(self, "element"):
+            self.element = TextElements.LISTITEM.create()
+        valuestr = str(value).replace(".", r",\!")
+        self.element.text = (
+            f"{self.name} \\( {self.var} = {valuestr} \\mathrm{{ {self.unit} }} \\)"
+        )

excel2moodle/core/dataStructure.py

@@ -11,8 +11,8 @@ from typing import TYPE_CHECKING
 
 import lxml.etree as ET  # noqa: N812
 import pandas as pd
-from PySide6 import QtWidgets
 from PySide6.QtCore import QObject, Signal
+from PySide6.QtWidgets import QDialog
 
 from excel2moodle.core import stringHelpers
 from excel2moodle.core.category import Category
@@ -381,10 +381,9 @@ class QuestionDB:
             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() == QtWidgets.QDialog.Accepted:
+                    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.")
-            q.assemble(variant=variant)
-            tree.append(q.element)
+            tree.append(q.getUpdatedElement(variant=variant))

excel2moodle/core/globals.py

@@ -17,14 +17,9 @@ class TextElements(Enum):
     SPANRED = "span", "color: rgb(239, 69, 64)"
     SPANGREEN = "span", "color: rgb(152, 202, 62)"
     SPANORANGE = "span", "color: rgb(152, 100, 100)"
-    ULIST = (
-        "ul",
-        "",
-    )
-    LISTITEM = (
-        "li",
-        "text-align: left;",
-    )
+    ULIST = "ul", ""
+    LISTITEM = "li", "text-align: left;"
+    DIV = "div", ""
 
     def create(self, tag: str | None = None):
         if tag is None:

excel2moodle/core/parser.py

@@ -1,9 +1,9 @@
 import logging
-import re
 
 import lxml.etree as ET
 
 import excel2moodle.core.etHelpers as eth
+from excel2moodle.core.bullets import BulletList
 from excel2moodle.core.exceptions import QNotParsedException
 from excel2moodle.core.globals import (
     Tags,
@@ -58,65 +58,19 @@ class QuestionParser:
             )
         return bool(self.question.picture.ready)
 
-    def setMainText(self) -> None:
-        paragraphs: list[ET._Element] = [TextElements.PLEFT.create()]
-        ET.SubElement(paragraphs[0], "b").text = f"ID {self.question.id}"
+    def getMainTextElement(self) -> ET.Element:
+        """Get the root question Text with the question paragraphs."""
+        textHTMLroot: ET._Element = ET.Element("div")
+        ET.SubElement(
+            ET.SubElement(textHTMLroot, "p"), "b"
+        ).text = f"ID {self.question.id}"
         text = self.rawInput[Tags.TEXT]
         for t in text:
-            paragraphs.append(TextElements.PLEFT.create())
-            paragraphs[-1].text = t
-        self.question.qtextParagraphs = paragraphs
+            par = TextElements.PLEFT.create()
+            par.text = t
+            textHTMLroot.append(par)
         self.logger.debug("Created main Text with: %s paragraphs", len(text))
-
-    def setBPoints(self) -> None:
-        """If there bulletPoints are set in the Spreadsheet it creates an unordered List-Element in ``Question.bulletList``."""
-        if Tags.BPOINTS in self.rawInput:
-            bps: list[str] = self.rawInput[Tags.BPOINTS]
-            try:
-                bulletList = self.formatBulletList(bps)
-            except IndexError:
-                msg = f"konnt Bullet Liste {self.question.id} nicht generieren"
-                raise QNotParsedException(
-                    msg,
-                    self.question.id,
-                    # exc_info=e,
-                )
-            self.logger.debug(
-                "Generated BPoint List: \n %s",
-                ET.tostring(bulletList, encoding="unicode"),
-            )
-            self.question.bulletList = bulletList
-
-    def formatBulletList(self, bps: list[str]) -> ET.Element:
-        self.logger.debug("Formatting the bulletpoint list")
-        name = []
-        var = []
-        quant = []
-        unit = []
-        unorderedList = TextElements.ULIST.create()
-        for item in bps:
-            sc_split = item.split()
-            name.append(sc_split[0])
-            var.append(sc_split[1])
-            quant.append(sc_split[3])
-            unit.append(sc_split[4])
-        for i in range(len(name)):
-            if re.fullmatch(r"{\w+}", quant[i]):
-                self.logger.debug("Got an variable bulletItem")
-                num_s = quant[i]
-            else:
-                self.logger.debug("Got a normal bulletItem")
-                num = quant[i].split(",")
-                if len(num) == 2:
-                    num_s = f"{num[0]!s},\\!{num[1]!s}~"
-                else:
-                    num_s = f"{num[0]!s},\\!0~"
-            bullet = TextElements.LISTITEM.create()
-            bullet.text = (
-                f"{name[i]}: \\( {var[i]} = {num_s} \\mathrm{{ {unit[i]}  }}\\)\n"
-            )
-            unorderedList.append(bullet)
-        return unorderedList
+        return textHTMLroot
 
     def appendToTmpEle(
         self,
@@ -148,7 +102,7 @@ class QuestionParser:
         """Parse the Question.
 
         Generates an new Question Element stored as ``self.tmpEle:ET.Element``
-        if no Exceptions are raised, ``self.tmpEle`` is passed to ``self.question.element``
+        if no Exceptions are raised, ``self.tmpEle`` is passed to ``question.element``
         """
         self.logger.info("Starting to parse")
         self.tmpEle: ET.Elemnt = ET.Element(
@@ -156,21 +110,39 @@ class QuestionParser:
         )
         self.appendToTmpEle(XMLTags.NAME, text=Tags.NAME, txtEle=True)
         self.appendToTmpEle(XMLTags.ID, text=self.question.id)
-        if self.hasPicture():
-            self.tmpEle.append(self.question.picture.element)
-        self.tmpEle.append(ET.Element(XMLTags.QTEXT, format="html"))
+        textRootElem = ET.Element(XMLTags.QTEXT, format="html")
+        mainTextEle = ET.SubElement(textRootElem, "text")
+        self.tmpEle.append(textRootElem)
         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())
+        if Tags.BPOINTS in self.rawInput:
+            bps: list[str] = self.rawInput[Tags.BPOINTS]
+            try:
+                bullets: BulletList = BulletList(bps, self.question.id)
+            except IndexError:
+                msg = f"konnt Bullet Liste {self.question.id} nicht generieren"
+                raise QNotParsedException(
+                    msg,
+                    self.question.id,
+                )
+            self.htmlRoot.append(bullets.element)
+            self.question.bulletList = bullets
+        if self.hasPicture():
+            self.htmlRoot.append(self.question.picture.htmlTag)
+            textRootElem.append(self.question.picture.element)
         ansList = self._parseAnswers()
-        self.setMainText()
-        self.setBPoints()
         if ansList is not None:
             for ele in ansList:
                 self.tmpEle.append(ele)
-        self.question.element = self.tmpEle
+        self.question._element = self.tmpEle
+        self.question.htmlRoot = self.htmlRoot
         self.question.isParsed = True
+        self.question.textElement = mainTextEle
         self.logger.info("Sucessfully parsed")
 
     def getFeedBEle(
@@ -195,7 +167,7 @@ class QuestionParser:
 
     def getNumericAnsElement(
         self,
-        result: float,
+        result: float = 0.0,
         fraction: float = 100,
         format: str = "moodle_auto_format",
     ) -> ET.Element:

excel2moodle/core/question.py

@@ -1,25 +1,26 @@
 import base64
 import logging
+import math
 import re
 from pathlib import Path
-from re import Match
 from types import UnionType
-from typing import ClassVar, Literal, overload
+from typing import TYPE_CHECKING, ClassVar, Literal, overload
 
 import lxml.etree as ET
+from asteval import Interpreter
 
-from excel2moodle.core import etHelpers
 from excel2moodle.core.category import Category
 from excel2moodle.core.exceptions import QNotParsedException
 from excel2moodle.core.globals import (
     QUESTION_TYPES,
     Tags,
-    TextElements,
-    XMLTags,
 )
 from excel2moodle.core.settings import Settings, Tags
 from excel2moodle.logger import LogAdapterQuestionID
 
+if TYPE_CHECKING:
+    from excel2moodle.core.bullets import BulletList
+
 loggerObj = logging.getLogger(__name__)
 settings = Settings()
 
@@ -130,12 +131,13 @@ class Question:
         self.category = category
         self.katName = self.category.name
         self.moodleType = QUESTION_TYPES[self.qtype]
-        self.element: ET.Element = None
+        self._element: ET.Element = None
         self.isParsed: bool = False
         self.picture: Picture
         self.id: str
-        self.qtextParagraphs: list[ET.Element] = []
-        self.bulletList: ET.Element = None
+        self.htmlRoot: ET.Element
+        self.bulletList: BulletList
+        self.textElement: ET.Element
         self._setID()
         self.logger = LogAdapterQuestionID(loggerObj, {"qID": self.id})
         self.logger.debug("Sucess initializing")
@@ -158,52 +160,19 @@ class Question:
         li.append(f"{self.qtype}")
         return "\t".join(li)
 
-    def assemble(self, variant=0) -> None:
-        """Assemble the question to the valid xml Tree."""
-        mainText = self._getTextElement()
-        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:
-            mainText.append(self.picture.element)
-            self.logger.debug("Appended Picture element to text")
-        mainText.append(etHelpers.getCdatTxtElement(textParts))
-
-    def _assembleText(self, variant=0) -> list[ET.Element]:
-        """Assemble the Question Text.
-
-        Intended for the cloze question, where the answers parts are part of the text.
+    def getUpdatedElement(self, variant: int = 0) -> ET.Element:
+        """Update and get the Question Elements to reflect the version.
+
+        Each Subclass needs to implement its specific logic.
+        Things needed to be considered:
+            Question Text
+            Bullet Points
+            Answers
         """
-        self.logger.debug("inserting MainText to element")
-        textParts: list[ET.Element] = []
-        textParts.extend(self.qtextParagraphs)
-        bullets = self._getBPoints(variant=variant)
-        if bullets is not None:
-            textParts.append(bullets)
-        if hasattr(self, "picture") and self.picture.ready:
-            textParts.append(self.picture.htmlTag)
-            self.logger.debug("Appended Picture html to text")
-        return textParts
-
-    def _getTextElement(self) -> ET.Element:
-        if self.element is not None:
-            mainText = self.element.find(XMLTags.QTEXT)
-            self.logger.debug(f"found existing Text in element {mainText=}")
-            txtele = mainText.find("text")
-            if txtele is not None:
-                mainText.remove(txtele)
-                self.logger.debug("removed previously existing questiontext")
-            return mainText
-        msg = "Cant assamble, if element is none"
-        raise QNotParsedException(msg, self.id)
-
-    def _getBPoints(self, variant: int = 0) -> ET.Element:
-        if hasattr(self, "bulletList"):
-            return self.bulletList
-        return None
-
-    def _assembleAnswer(self, variant: int = 0) -> None:
-        pass
+        self.textElement.text = ET.CDATA(
+            ET.tostring(self.htmlRoot, encoding="unicode", pretty_print=True)
+        )
+        return self._element
 
     def _setID(self, id=0) -> None:
         if id == 0:
@@ -215,32 +184,131 @@ class Question:
 class ParametricQuestion(Question):
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
-        self.variants: int = 0
-        self.variables: dict[str, list[float | int]] = {}
+        self.rules: list[str] = []
+        self.parametrics: Parametrics
+
+    def getUpdatedElement(self, variant: int = 0) -> ET.Element:
+        """Update the bulletItem.text With the values for variant.
 
-    def _getBPoints(self, variant: int = 1) -> ET.Element:
-        """Get the bullet points with the variable set for `variant`."""
-        if self.bulletList is None:
+        `ParametricQuestion` updates the bullet points.
+        `Question` returns the Element.
+
+        """
+        if not hasattr(self, "bulletList"):
             msg = "Can't assemble a parametric question, without the bulletPoints variables"
             raise QNotParsedException(msg, self.id)
-        # matches {a}, {some_var}, etc.
-        varPlaceholder = re.compile(r"{(\w+)}")
-
-        def replaceMatch(match: Match[str]) -> str | int | float:
-            key = match.group(1)
-            if key in self.variables:
-                value = self.variables[key][variant - 1]
-                return f"{value}".replace(".", ",\\!")
-            return match.group(0)  # keep original if no match
-
-        unorderedList = TextElements.ULIST.create()
-        for li in self.bulletList:
-            listItemText = li.text or ""
-            bullet = TextElements.LISTITEM.create()
-            bullet.text = varPlaceholder.sub(replaceMatch, listItemText)
-            unorderedList.append(bullet)
-            self.logger.debug("Inserted Variables into List: %s", bullet.text)
-        return unorderedList
+
+        self.bulletList.updateBullets(
+            variables=self.parametrics.variables, variant=variant
+        )
+        return super().getUpdatedElement(variant)
+
+
+class Parametrics:
+    """Object for parametrizing the numeric Questions.
+
+    Equation storing the variables, equation, and results.
+    """
+
+    astEval = Interpreter(with_import=True)
+
+    def __init__(
+        self,
+        equation: str | dict[int, str],
+        firstResult: float | dict[int, float] = 0.0,
+        identifier: str = "0000",
+    ) -> None:
+        self.equations: dict[int, str] = (
+            equation if isinstance(equation, dict) else {1: equation}
+        )
+        self._resultChecker: dict[int, float] = (
+            firstResult if isinstance(firstResult, dict) else {1: firstResult}
+        )
+        self.id = identifier
+        self._variables: dict[str, list[float | int]] = {}
+        self.results: dict[int, list[float]] = {}
+        self.logger = LogAdapterQuestionID(loggerObj, {"qID": self.id})
+
+    @property
+    def variants(self) -> int:
+        number = 1000
+        for li in self._variables.values():
+            number = min(number, len(li))
+        return number
+
+    @property
+    def variableRules(self) -> list[str]:
+        if hasattr(self, "_rules"):
+            return self._rules
+        return []
+
+    @variableRules.setter
+    def variableRules(self, rules: list[str]) -> None:
+        self._rules = rules
+
+    def getResult(self, number: int = 1, equation: int = 1) -> float:
+        """Get the result for the variant `number` from the `equation` number."""
+        self.logger.debug(
+            "Returning result %s, variant: %s",
+            self.results[equation][number - 1],
+            number,
+        )
+        return self.results[equation][number - 1]
+
+    @property
+    def variables(self) -> dict[str, list[float | int]]:
+        return self._variables
+
+    @variables.setter
+    def variables(self, variables: dict[str, list[float | int]]) -> None:
+        self._variables: dict[str, list[float | int]] = variables
+        self._calculateResults()
+        self.logger.info("Updated parameters and results")
+
+    def _calculateResults(self) -> dict[int, list[float]]:
+        self.logger.info("Updating Results for new variables")
+        for num in self.equations:
+            # reset the old results, and set a list for each equation
+            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)
+            for num, eq in self.equations.items():
+                result = type(self).astEval(eq)
+                self.logger.info(
+                    "Calculated expr. %s (variant %s): %s = %.3f ",
+                    num,
+                    variant,
+                    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
+                    )
+                    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)
+        return self.results
+
+    def resetVariables(self) -> None:
+        self._variables = {}
+        self.logger.info("Reset the variables")
+
+    @classmethod
+    def setupAstIntprt(cls, var: dict[str, list[float | int]], index: int) -> None:
+        """Setup the asteval Interpreter with the variables."""
+        for name, value in var.items():
+            cls.astEval.symtable[name] = value[index]
 
 
 class Picture: