excel2moodle 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

excel2moodle/extra/equationVerification.py

@@ -1,4 +1,4 @@
-"""Script for verifying the equations written into the ``result`` field of NFM-type Question
+"""Script for verifying the equations written into the ``result`` field of NFM-type Question.
 
 This script does two things.
 
@@ -28,16 +28,19 @@ As Script
 #. Rinse and repeat
 """
 
-import re as re
-import pandas as pd
 from pathlib import Path
+
+import pandas as pd
+
 from excel2moodle.core import numericMultiQ as nmq
 
 # Hier Bitte die Frage angeben, die getestet Werden soll:
 
-#===========================================================
-def checkResult(checkerValue:float, calculation:float, tolerance = 0.01)-> bool:
-    """Checks if the two Arguments are within the tolerance the same value
+# ===========================================================
+
+
+def checkResult(checkerValue: float, calculation: float, tolerance=0.01) -> bool:
+    """Checks if the two Arguments are within the tolerance the same value.
 
     :param checkerValue: the value the calculation is compared against
     :type checkerValue: fleat
@@ -46,21 +49,20 @@ def checkResult(checkerValue:float, calculation:float, tolerance = 0.01)-> bool:
     :param tolerance: the standart tolerance is 0.01 -> 1%
     :type tolerance: float, optional
 
-    :returns: 
+    :returns:
         True if checkerValue == calculation
         False if checkerValue != calculation
     :rtype: bool
     """
+    upper = abs(checkerValue + checkerValue * tolerance)
+    lower = abs(checkerValue - checkerValue * tolerance)
+    return bool(abs(calculation) > lower and abs(calculation) < upper)
 
-    upper = abs(checkerValue + checkerValue*tolerance)
-    lower = abs(checkerValue - checkerValue*tolerance)
-    if abs(calculation) > lower and abs(calculation) < upper:
-        return True
-    else :
-        return False
 
-def equationChecker(categoryName: str, qNumber:int, spreadsheetFile)-> tuple[list[str], list[float], float]:
-    """This Function calculates all Results an invokes the checkResult function
+def equationChecker(
+    categoryName: str, qNumber: int, spreadsheetFile
+) -> tuple[list[str], list[float], float]:
+    """This Function calculates all Results an invokes the checkResult function.
 
     Parameters
     ----------
@@ -80,8 +82,8 @@ def equationChecker(categoryName: str, qNumber:int, spreadsheetFile)-> tuple[lis
         The list with the calculated results
     checkerValue : float
         The value taken from the ``firstResult`` field
-    """
 
+    """
     spreadsheetFile.resolve()
     df = pd.read_excel(spreadsheetFile, sheet_name=categoryName, index_col=0)
     eq = df.loc["result"][qNumber]
@@ -89,36 +91,38 @@ def equationChecker(categoryName: str, qNumber:int, spreadsheetFile)-> tuple[lis
     try:
         res = float(df.loc["firstResult"][qNumber])
     except Exception:
-        print(f"Es ist kein 'firstResult' gegeben, kann nichts überprüfen")
         res = 0
-    bps, calcs = nmq.parseNumericMultiQuestion(df,bps,eq, qNumber)
+    bps, calcs = nmq.parseNumericMultiQuestion(df, bps, eq, qNumber)
     return bps, calcs, res
 
 
-def main(spreadsheetFile= Path("../Fragensammlung/Main_question_all.xlsx"), catN = None, qNumber = None)-> None:
-    """Takes the Spreadsheet, and asks for a category and a question number
-
-    """
-    if catN == None:
+def main(
+    spreadsheetFile=Path("../Fragensammlung/Main_question_all.xlsx"),
+    catN=None,
+    qNumber=None,
+) -> None:
+    """Takes the Spreadsheet, and asks for a category and a question number."""
+    if catN is None:
         catN = input("Geben Sie die Kategorie an: KAT_")
     categoryName = f"KAT_{catN}"
-    if qNumber == None:
+    if qNumber is None:
         qNumber = int(input("Geben Sie die Fragennummer an: "))
-    bullets, results, firstResult = equationChecker(categoryName, qNumber, spreadsheetFile=spreadsheetFile)
+    bullets, results, firstResult = equationChecker(
+        categoryName, qNumber, spreadsheetFile=spreadsheetFile
+    )
     check = False
 
     for i, calculation in enumerate(results):
-        if i == 0 and firstResult !=0:
-           check = checkResult(firstResult, calculation)
-        print(f"Ergebnis {i+1}: \t{calculation}\n\tMit den Werten: \n{bullets[i]}\n")
+        if i == 0 and firstResult != 0:
+            check = checkResult(firstResult, calculation)
 
-    if check == True:
-        print(f"Das erste berechnete Ergebnis stimmt mit dem Wert in 'firstResult' überein\n")
+    if check:
+        pass
     else:
-        print(f"WARNUNG: Das erste berechnete Ergebnis weicht von dem Wert  {firstResult = } ab.\n")
+        pass
 
 
-if __name__ =="__main__":
-    spreadsheet =input(f"Geben Sie den Pfad zu dem spreadsheet an:")
+if __name__ == "__main__":
+    spreadsheet = input("Geben Sie den Pfad zu dem spreadsheet an:")
     while True:
         main(Path(spreadsheet))

excel2moodle/logger.py

@@ -0,0 +1,102 @@
+"""Logging Setup for Excel2moodle.
+
+Mainly this sets up the general configuration.
+This includes emitting the signals for the main Window, to fast forward all logs.
+"""
+
+import logging
+
+from PySide6.QtCore import QObject, Signal
+
+from excel2moodle.ui.settings import Settings, SettingsKey
+
+settings = Settings()
+
+loggerConfig = {
+    "version": 1,
+    "disable_existing_loggers": False,
+    "formatters": {
+        "standard": {
+            "format": "[{levelname:^8s}] {module:.^14s}:  {message}",
+            "style": "{",
+        },
+        "file": {
+            "format": "%(asctime)s [%(levelname)-5s] %(name)12s: %(message)s",
+        },
+    },
+    "handlers": {
+        "default": {
+            "level": "DEBUG",
+            "formatter": "standard",
+            "class": "logging.StreamHandler",
+            "stream": "ext://sys.stdout",  # Default is stderr
+        },
+        "file": {
+            "level": "DEBUG",
+            "formatter": "file",
+            "class": "logging.FileHandler",
+            # "class": "logging.handlers.TimedRotatingFileHandler",
+            "filename": settings.get(SettingsKey.LOGFILE),
+            # "when": "M",
+            # "interval": 1,
+            # "backupCount": "3",
+            "delay": "true",
+        },
+    },
+    "loggers": {
+        "": {  # root logger
+            "handlers": ["default", "file"],
+            "level": "DEBUG",
+            "propagate": True,
+        },
+        "excel2moodle.questionParser": {
+            "handlers": ["default"],
+            "level": "DEBUG",
+            "propagate": True,
+        },
+        "__main__": {  # if __name__ == '__main__'
+            "handlers": ["default"],
+            "level": "DEBUG",
+            "propagate": True,
+        },
+    },
+}
+
+
+class QSignaler(QObject):
+    signal = Signal(str)
+
+
+class LogWindowHandler(logging.Handler):
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.emitter = QSignaler()
+        # Define a formatter with log level and module
+        log_format = "[%(levelname)s] %(module)s: %(message)s"
+        self.formatter = logging.Formatter(log_format)
+        self.setFormatter(self.formatter)
+        loglevel = settings.get(SettingsKey.LOGLEVEL)
+        self.setLevel(loglevel)
+        self.logLevelColors = {
+            "DEBUG": "gray",
+            "INFO": "green",
+            "WARNING": "orange",
+            "ERROR": "red",
+            "CRITICAL": "pink",
+        }
+
+    def emit(self, record: logging.LogRecord) -> None:
+        """Emit the signal, with a new logging message."""
+        log_message = self.format(record)
+        color = self.logLevelColors.get(record.levelname, "black")
+        prettyMessage = f'<span style="color:{color};">{log_message}</span>'
+        print("emitting new log signal")  # noqa:T201
+        self.emitter.signal.emit(prettyMessage)
+
+
+class LogAdapterQuestionID(logging.LoggerAdapter):
+    """Prepend the Question ID to the logging messages."""
+
+    def process(self, msg, kwargs):
+        """Append the Question ID to the log Message."""
+        return "[{}]: {}".format(self.extra["qID"], msg), kwargs

excel2moodle/ui/appUi.py

@@ -1,49 +1,56 @@
-"""This Module holds the extended  class mainWindow() and any other main Windows
+"""AppUi holds the extended  class mainWindow() and any other main Windows.
 
-It needs to be seperated from ``windowMain.py`` because that file will be changed by tho ``pyside6-uic`` command,
-which generates the python code from the ``.ui`` file
+It needs to be seperated from ``windowMain.py`` because that file will be changed by the
+``pyside6-uic`` command, which generates the python code from the ``.ui`` file
 """
 
-from PySide6 import QtCore
-from PySide6.QtCore import Qt
-from PySide6 import QtWidgets
+import logging
 from pathlib import Path
-from excel2moodle import e2mMetadata
-from excel2moodle.ui.windowMain import Ui_MoodleTestGenerator
-from .windowEquationChecker import Ui_EquationChecker
-from excel2moodle.ui import windowEquationChecker, dialogs
+
+from PySide6 import QtCore, QtWidgets
+from PySide6.QtCore import Qt
+
+from excel2moodle import qSignalLogger
+
+# from excel2moodle.logger import LogWindowHandler
 from excel2moodle.core.dataStructure import QuestionDB
-from excel2moodle.ui.treewidget import QuestionItem, CategoryItem
 from excel2moodle.extra import equationVerification as eqVerif
-from excel2moodle import qSignalLogger
-from excel2moodle.ui.settings import Settings
-import logging as logging
+from excel2moodle.ui import dialogs
+from excel2moodle.ui.settings import Settings, SettingsKey
+from excel2moodle.ui.treewidget import CategoryItem, QuestionItem
+from excel2moodle.ui.windowMain import Ui_MoodleTestGenerator
 
+from .windowEquationChecker import Ui_EquationChecker
 
 logger = logging.getLogger(__name__)
 
 
-
 class MainWindow(QtWidgets.QMainWindow):
-    def __init__(self, settings:Settings, testDB:QuestionDB)->None:
+    def __init__(self, settings: Settings, testDB: QuestionDB) -> None:
         super().__init__()
         self.settings = settings
-        self.excelPath: Path|None = None
-        self.mainPath = (self.excelPath.parent if self.excelPath is not None else None)
+        self.excelPath: Path | None = None
+        self.mainPath = self.excelPath.parent if self.excelPath is not None else None
         self.exportFile = Path()
         self.testDB = testDB
         self.ui = Ui_MoodleTestGenerator()
         self.ui.setupUi(self)
 
         self.ui.treeWidget.setSelectionMode(QtWidgets.QAbstractItemView.MultiSelection)
-        self.ui.treeWidget.header().setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
-        self.ui.checkBoxIncludeCategories.setChecked(self.settings.value("testGen/includeCats", type=bool))
+        self.ui.treeWidget.header().setSectionResizeMode(
+            QtWidgets.QHeaderView.ResizeToContents,
+        )
+        self.ui.checkBoxIncludeCategories.setChecked(
+            self.settings.get(SettingsKey.INCLUDEINCATS),
+        )
 
         self.ui.retranslateUi(self)
-        logger.info(f"Settings are stored under: {self.settings.fileName()}")
+        logger.info("Settings are stored under: %s", self.settings.fileName())
         self.ui.pointCounter.setReadOnly(True)
         self.ui.questionCounter.setReadOnly(True)
-        self.setStatus("Wählen Sie bitte eine Excel Tabelle und einen Export Ordner für die Fragen aus")
+        self.setStatus(
+            "Wählen Sie bitte eine Excel Tabelle und einen Export Ordner für die Fragen aus",
+        )
         try:
             self.resize(self.settings.value("windowSize"))
             self.move(self.settings.value("windowPosition"))
@@ -51,79 +58,58 @@ class MainWindow(QtWidgets.QMainWindow):
             pass
         self.connectEvents()
 
-    def connectEvents(self)->None:
+    def connectEvents(self) -> None:
         self.ui.treeWidget.itemClicked.connect(self.onSelectionChanged)
-        self.ui.checkBoxQuestionListSelectAll.checkStateChanged.connect(self.toggleQuestionSelectionState)
+        self.ui.checkBoxQuestionListSelectAll.checkStateChanged.connect(
+            self.toggleQuestionSelectionState,
+        )
         qSignalLogger.emitter.signal.connect(self.updateLog)
-        self.ui.actionEquationChecker.triggered.connect(self.onButOpenEqChecker)
-        self.ui.checkBoxIncludeCategories.checkStateChanged.connect(self.setIncludeCategoriesSetting)
-        # self.ui.buttonRefresh.clicked.connect(self.refreshList)
-        self.ui.actionParseAll.triggered.connect(self.onParseAll )
-        self.testDB.dataChanged.signal.connect(self.onParseAll)
+        self.ui.actionEquationChecker.triggered.connect(self.openEqCheckerDlg)
+        self.ui.checkBoxIncludeCategories.checkStateChanged.connect(
+            self.setIncludeCategoriesSetting,
+        )
+        self.ui.actionParseAll.triggered.connect(self.onParseAll)
+        self.testDB.dataChanged.signal.connect(self.refreshList)
         self.ui.buttonSpreadSheet.clicked.connect(self.onButSpreadsheet)
         self.ui.buttonTestGen.clicked.connect(self.onButGenTest)
-        self.ui.actionPreviewQ.triggered.connect(self.previewQ)
-        self.ui.actionAbout.triggered.connect(self.onAbout)
+        self.ui.actionPreviewQ.triggered.connect(self.openPreviewQuestionDlg)
+        self.ui.actionAbout.triggered.connect(self.openAboutDlg)
         self.settings.shPathChanged.connect(self.onSheetPathChanged)
+        self.ui.spinBoxDefaultQVariant.valueChanged.connect(self.setQVariantDefault)
 
+    @QtCore.Slot()
+    def setQVariantDefault(self, value: int) -> None:
+        self.settings.set(SettingsKey.QUESTIONVARIANT, value)
 
     @QtCore.Slot(Path)
-    def onSheetPathChanged(self, sheet:Path)->None:
+    def onSheetPathChanged(self, sheet: Path) -> None:
         logger.debug("Slot, new Spreadsheet triggered")
         self.spreadSheetPath = sheet
         self.mainPath = sheet.parent
+        svgFolder = self.mainPath / self.settings.get(SettingsKey.PICTURESUBFOLDER)
+        svgFolder.resolve()
+        self.settings.set(SettingsKey.PICTUREFOLDER, svgFolder)
         self.ui.buttonSpreadSheet.setText(str(sheet.name))
+        self.testDB.readSpreadsheetData(self.spreadSheetPath)
+        self.testDB.parseAll()
+        self.refreshList()
 
-    def updateLog(self,log)->None:
+    def updateLog(self, log) -> None:
         self.ui.loggerWindow.append(log)
 
-    def setIncludeCategoriesSetting(self):
+    def setIncludeCategoriesSetting(self) -> None:
         if self.ui.checkBoxIncludeCategories.isChecked():
-            self.settings.set("testGen/includeCats", True)
-            logger.debug("set includeCats to True")
+            self.settings.set(SettingsKey.INCLUDEINCATS, True)
         else:
-            self.settings.set("testGen/includeCats", False)
-            logger.debug("set includeCats to False")
-
-
-    @QtCore.Slot()
-    def onAbout(self):
-        aboutMessage: str = f"""
-        <h1> About {e2mMetadata['name']}</h1><br>
-        <p style="text-align:center">
-
-                <b><a href="{e2mMetadata['homepage']}">{e2mMetadata['name']}</a> - {e2mMetadata['description']}</b>
-        </p>
-        <p style="text-align:center"> 
-            The documentation can be found under <b><a href="{e2mMetadata['documentation']}">{e2mMetadata['documentation']}</a></b>
-            </br>
-            </br>
-            If you encounter any issues please report them under the <a href="{e2mMetadata['issues']}"> repositories issues page</a>
-            </br>
-        </p>
-        <p style="text-align:center">
-        This project is maintained by {e2mMetadata['author']}.
-        <br>
-        Development takes place at <a href="{e2mMetadata['homepage']}">{e2mMetadata['homepage']}</a>
-        Contributions are very welcome
-        <br>
-        </p>
-        <p style="text-align:center">
-        <i>This project is published under {e2mMetadata['license']}, you are welcome, to share, modify and reuse the code.</i>
-        </p>
-        """
-        QtWidgets.QMessageBox.information(self, 
-                                               f"About {e2mMetadata['name']}",
-                                               aboutMessage)
+            self.settings.set(SettingsKey.INCLUDEINCATS, False)
 
-    def closeEvent(self, event):
+    def closeEvent(self, event) -> None:
         self.settings.setValue("windowSize", self.size())
         self.settings.setValue("windowPosition", self.pos())
 
     @QtCore.Slot()
-    def onSelectionChanged(self, item, col):
-        """Whenever the selection changes the total of selected points needs to be recalculated"""
-
+    def onSelectionChanged(self, **args) -> None:
+        """Whenever the selection changes the total of selected points needs to be recalculated."""
         count: int = 0
         questions: int = 0
         selection = self.ui.treeWidget.selectedItems()
@@ -131,16 +117,13 @@ class MainWindow(QtWidgets.QMainWindow):
             questions += 1
             count += q.getQuestion().points
 
-        logger.info(f'{questions} questions are selected with {count} points')
+        logger.info("%s questions are selected with %s points", questions, count)
         self.ui.pointCounter.setValue(count)
         self.ui.questionCounter.setValue(questions)
-        return None
 
     @QtCore.Slot()
-    def toggleQuestionSelectionState(self, state):
-        if state == Qt.Checked:
-            setter = True
-        else: setter = False
+    def toggleQuestionSelectionState(self, state) -> None:
+        setter = state == Qt.Checked
         root = self.ui.treeWidget.invisibleRootItem()
         childN = root.childCount()
         for i in range(childN):
@@ -149,98 +132,123 @@ class MainWindow(QtWidgets.QMainWindow):
                 root.child(i).child(q).setSelected(setter)
 
     @QtCore.Slot()
-    def onButGenTest(self)->None:
-        path = QtWidgets.QFileDialog.getSaveFileName(self, "Select Output File", 
-                                                     dir=f"{self.mainPath/"Testfile.xml"}", 
-                                                     filter="xml Files (*.xml)")
+    def onButGenTest(self) -> None:
+        """Open a file Dialog so the export file may be choosen."""
+        path = QtWidgets.QFileDialog.getSaveFileName(
+            self,
+            "Select Output File",
+            dir=f"{self.mainPath / 'Testfile.xml'}",
+            filter="xml Files (*.xml)",
+        )
         self.exportFile = Path(path[0])
-        logger.info(f"New Export File is set{self.exportFile=}")
-        selection:list[QuestionItem] = self.ui.treeWidget.selectedItems()
+        logger.info("New Export File is set %s", self.exportFile)
+        selection: list[QuestionItem] = self.ui.treeWidget.selectedItems()
         self.testDB.appendQuestions(selection, self.exportFile)
-        return None
 
     @QtCore.Slot()
-    def onButSpreadsheet(self):
-        file = QtWidgets.QFileDialog.getOpenFileName(self, 
-                                                     self.tr("Open Spreadsheet"),
-                                                     dir = str(self.mainPath),
-                                                     filter=self.tr("Spreadsheet(*.xlsx *.ods)"),
-                                                     selectedFilter=("*.ods"))
+    def onButSpreadsheet(self) -> None:
+        file = QtWidgets.QFileDialog.getOpenFileName(
+            self,
+            self.tr("Open Spreadsheet"),
+            dir=str(self.mainPath),
+            filter=self.tr("Spreadsheet(*.xlsx *.ods)"),
+            selectedFilter=("*.ods"),
+        )
         self.excelPath = Path(file[0]).resolve()
         self.settings.setSpreadsheet(self.excelPath)
-        logger.debug(f'Saved Spreadsheet Path: {self.excelPath}\n')
+        logger.debug(f"Saved Spreadsheet Path: {self.excelPath}\n")
         self.setStatus("[OK] Excel Tabelle wurde eingelesen")
-        return None
-
 
     @QtCore.Slot()
-    def onParseAll (self)->None:
-        """Event triggered by the *Tools/Parse all Questions* Event
+    def onParseAll(self) -> None:
+        """Event triggered by the *Tools/Parse all Questions* Event.
 
-        It parses all the Questions found in the spreadsheet and then refreshes the list of questions.
+        It parses all the Questions found in the spreadsheet
+        and then refreshes the list of questions.
         If successful it prints out a list of all exported Questions
         """
-        self.ui.buttonTestGen.setEnabled(True)
+        self.testDB.readSpreadsheetData(self.spreadSheetPath)
         self.testDB.parseAll()
         self.setStatus("[OK] Alle Fragen wurden erfolgreich in XML-Dateien umgewandelt")
-        # below is former refres method
+        self.refreshList()
+
+    def refreshList(self) -> None:
+        """Refresh the question overview in the main window.
+
+        Enable the export Button afterwards.
+        """
         logger.info("starting List refresh")
-        cats =  self.testDB.categories
+        cats = self.testDB.categories
         self.ui.treeWidget.clear()
         for cat in cats.values():
-            catItem = CategoryItem(self.ui.treeWidget,cat)
+            catItem = CategoryItem(self.ui.treeWidget, cat)
             catItem.setFlags(catItem.flags() & ~Qt.ItemIsSelectable)
             for q in cat.questions.values():
-                QuestionItem(catItem,q)
+                QuestionItem(catItem, q)
         self.setStatus("[OK] Fragen Liste wurde aktualisiert")
-        return None
+        self.ui.buttonTestGen.setEnabled(True)
 
     @QtCore.Slot()
-    def previewQ(self)->None:
+    def openPreviewQuestionDlg(self) -> None:
         item = self.ui.treeWidget.currentItem()
         if isinstance(item, QuestionItem):
             dialog = dialogs.QuestinoPreviewDialog(self, item.getQuestion())
             dialog.show()
-        else: logger.info(f"current Item is not a Question, can't preview")
+        else:
+            logger.info("current Item is not a Question, can't preview")
 
-    def setStatus(self, status):
+    def setStatus(self, status) -> None:
         self.ui.statusbar.clearMessage()
         self.ui.statusbar.showMessage(self.tr(status))
 
     @QtCore.Slot()
-    def onButOpenEqChecker(self):
-        logger.debug(f"opening wEquationChecker \n")
+    def openEqCheckerDlg(self) -> None:
+        logger.debug("opening wEquationChecker \n")
         self.uiEqChecker = EqCheckerWindow()
         self.uiEqChecker.excelFile = self.excelPath
         self.uiEqChecker.show()
 
+    @QtCore.Slot()
+    def openAboutDlg(self) -> None:
+        about = dialogs.AboutDialog(self)
+        about.exec()
+
 
 class EqCheckerWindow(QtWidgets.QWidget):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
         self.excelFile = Path()
         self.ui = Ui_EquationChecker()
         self.ui.setupUi(self)
-        self.ui.buttonRunCheck.clicked.connect(lambda: self.onButRunCheck(self.ui.catNumber.value(), self.ui.qNumber.value()))
-
-    def onButRunCheck(self, catN:int, qN:int)->None:
-        """
-        Is Triggered by the ``Run Check now`` Button and runs the Equation Check
-        """
-        
+        self.ui.buttonRunCheck.clicked.connect(
+            lambda: self.onButRunCheck(
+                self.ui.catNumber.value(),
+                self.ui.qNumber.value(),
+            ),
+        )
+
+    def onButRunCheck(self, catN: int, qN: int) -> None:
+        """Is Triggered by the ``Run Check now`` Button and runs the Equation Check."""
         self.ui.textResultsOutput.clear()
-        bullets, results, firstResult = eqVerif.equationChecker(f'KAT_{catN}',qN, self.excelFile)
+        bullets, results, firstResult = eqVerif.equationChecker(
+            f"KAT_{catN}",
+            qN,
+            self.excelFile,
+        )
         check = False
-        self.ui.lineFirstResult.setText(f'{firstResult}')
+        self.ui.lineFirstResult.setText(f"{firstResult}")
         for i, calculation in enumerate(results):
-            if i == 0 and firstResult !=0:
+            if i == 0 and firstResult != 0:
                 check = eqVerif.checkResult(firstResult, calculation)
-                self.ui.lineCalculatedRes.setText(f'{calculation}')
-            self.ui.textResultsOutput.append(f"Ergebnis {i+1}: \t{calculation}\n\tMit den Werten: \n{bullets[i]}\n")
+                self.ui.lineCalculatedRes.setText(f"{calculation}")
+            self.ui.textResultsOutput.append(
+                f"Ergebnis {i + 1}: \t{calculation}\n\tMit den Werten: \n{bullets[i]}\n",
+            )
 
-        if check == True:
+        if check:
             self.ui.lineCheckResult.setText("[OK]")
-            logger.info(f"Das erste berechnete Ergebnis stimmt mit dem Wert in 'firstResult' überein\n")
+            logger.info(
+                "Das erste berechnete Ergebnis stimmt mit dem Wert in 'firstResult' überein\n",
+            )
         else:
             self.ui.lineCheckResult.setText("[ERROR]")
-