excel2moodle 0.6.1__py3-none-any.whl → 0.6.3__py3-none-any.whl

excel2moodle/__init__.py

@@ -45,6 +45,8 @@ if __package__ is not None:
         "documentation": "https://jbosse3.gitlab.io/excel2moodle",
         "homepage": meta["project-url"].split()[1],
         "issues": "https://gitlab.com/jbosse3/excel2moodle/issues",
+        "funding": "https://ko-fi.com/jbosse3",
+        "API_id": "jbosse3%2Fexcel2moodle",
     }
 
 

excel2moodle/__main__.py

@@ -5,17 +5,20 @@ import signal
 import sys
 from pathlib import Path
 
+from PySide6.QtCore import QTimer
 from PySide6.QtWidgets import QApplication
 
 import excel2moodle
-from excel2moodle import e2mMetadata, mainLogger
+from excel2moodle import __version__, e2mMetadata, mainLogger
 from excel2moodle.core import dataStructure
 from excel2moodle.core.settings import Settings, Tags
+from excel2moodle.extra import updateQuery
 from excel2moodle.logger import loggerConfig
 from excel2moodle.ui import appUi as ui
 
 
 def main() -> None:
+    app = QApplication(sys.argv)
     excel2moodle.isMain = True
     settings = Settings()
     logfile = Path(settings.get(Tags.LOGFILE)).resolve()
@@ -24,12 +27,24 @@ def main() -> None:
         logfile.replace(f"{logfile}.old")
     logConfig.dictConfig(config=loggerConfig)
     signal.signal(signal.SIGINT, signal.SIG_DFL)
-    app = QApplication(sys.argv)
-    settings = Settings()
     database: dataStructure.QuestionDB = dataStructure.QuestionDB(settings)
     window = ui.MainWindow(settings, database)
     database.window = window
     window.show()
+    # Update check
+    latestTag = updateQuery.get_latest_tag(e2mMetadata.get("API_id"))
+    if latestTag is None:
+        mainLogger.warning(
+            "Couldn't check for Updates, maybe there is  no internet connection"
+        )
+    if latestTag is not None and latestTag.strip("v") != __version__:
+        mainLogger.warning(
+            "A new Update is available: %s --> %s ", __version__, latestTag
+        )
+        changelog = updateQuery.get_changelog(e2mMetadata.get("API_id"))
+        # Delay showing the update dialog slightly
+        QTimer.singleShot(100, lambda: window.showUpdateDialog(changelog, latestTag))
+
     for k, v in e2mMetadata.items():
         msg = f"{k:^14s}:  {v}"
         mainLogger.info(msg)

excel2moodle/core/bullets.py

@@ -15,7 +15,7 @@ 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.bullets: dict[str | int, BulletP] = {}
         self.id = qID
         self.logger = LogAdapterQuestionID(loggerObj, {"qID": self.id})
         self._setupBullets(rawBullets)
@@ -70,7 +70,7 @@ class BulletList:
             if match is None:
                 self.logger.debug("Got a normal bulletItem")
                 num: float = float(quant.replace(",", "."))
-                bulletName: str = str(i + 1)
+                bulletName = i + 1
             else:
                 bulletName = match.group(1)
                 num: float = 0.0

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__)
 
@@ -25,12 +24,13 @@ class Category:
     ) -> None:
         """Instantiate a new Category object."""
         self.NAME = name
-        match = re.search(r"\d+$", str(self.NAME))
-        self.n: int = int(match.group(0)) if match else 99
+        match = re.search(r"\d+", str(self.NAME))
+        n = int(match.group(0)) if match else 99
+        self.n: int = n if n <= 99 and n >= 0 else 99
         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 +50,18 @@ class Category:
     def id(self) -> str:
         return f"{self.n:02d}"
 
+    @property
+    def questions(self) -> dict:
+        if not hasattr(self, "_questions"):
+            msg = f"Category {self.id} doesn't contain any valid questions."
+            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 +70,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,6 +98,17 @@ 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
+            Or When the categories Sheet doesn't provide the necessary keys.
+
+        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")
@@ -104,19 +119,14 @@ class QuestionDB:
                 index_col=0,
                 engine="calamine",
             )
-            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:
-            logger.exception(
-                "Can not create the database with invalid project settings."
-            )
-            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)
+
+        self._validateProjectSettings(sheetPath=sheetPath)
         with Path(sheetPath).open("rb") as f:
             self.categoriesMetaData = pd.read_excel(
                 f,
@@ -124,10 +134,20 @@ class QuestionDB:
                 index_col=0,
                 engine="calamine",
             )
-            logger.info("Sucessfully read categoriesMetaData")
+        if "description" not in self.categoriesMetaData.columns:
+            msg = f"You need to specify the 'description' tag for each category in the sheet '{self.settings.get(Tags.CATEGORIESSHEET)}'."
+            raise InvalidFieldException(msg, "0000", "description")
+        logger.info("Sucessfully read categoriesMetaData")
         return self.categoriesMetaData
 
     def _validateProjectSettings(self, sheetPath: Path) -> None:
+        if Tags.LOGLEVEL in self.settings:
+            level: str = self.settings.get(Tags.LOGLEVEL)
+            if level.upper() not in ("DEBUG", "INFO", "WARNING", "ERROR"):
+                self.settings.pop(Tags.LOGLEVEL)
+                logger.warning("You specified an unsupported Loglevel: %s", level)
+        if self.window is not None:
+            self.window.logHandler.setLevel(self.settings.get(Tags.LOGLEVEL).upper())
         if Tags.IMPORTMODULE in self.settings:
             logger.warning(
                 "Appending: %s to sys.path. All names defined by it will be usable",
@@ -276,7 +296,7 @@ class QuestionDB:
         for qNum in category.dataframe.columns:
             try:
                 self.setupAndParseQuestion(category, qNum)
-            except (InvalidFieldException, QNotParsedException):
+            except (InvalidFieldException, QNotParsedException, AttributeError):
                 logger.exception(
                     "Question %s%02d couldn't be parsed. The Question Data: \n %s",
                     category.id,
@@ -342,21 +362,26 @@ 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:
             logger.debug(f"got a question to append {q=}")
-            cat = q.parent().getCategory()
+            cat = q.parent().category
             if cat not in catdict:
                 catdict[cat] = []
-            catdict[cat].append(q.getQuestion())
+            catdict[cat].append(q.question)
         for cat, qlist in catdict.items():
             self._appendQElements(
                 cat,
@@ -365,6 +390,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 +400,80 @@ 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))
+            else:
+                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: