excel2moodle 0.3.4__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.
 
@@ -40,7 +40,7 @@ from excel2moodle.core import numericMultiQ as nmq
 
 
 def checkResult(checkerValue: float, calculation: float, tolerance=0.01) -> bool:
-    """Checks if the two Arguments are within the tolerance the same value
+    """Checks if the two Arguments are within the tolerance the same value.
 
     :param checkerValue: the value the calculation is compared against
     :type checkerValue: fleat
@@ -54,19 +54,15 @@ def checkResult(checkerValue: float, calculation: float, tolerance=0.01) -> bool
         False if checkerValue != calculation
     :rtype: bool
     """
-
     upper = abs(checkerValue + checkerValue * tolerance)
     lower = abs(checkerValue - checkerValue * tolerance)
-    if abs(calculation) > lower and abs(calculation) < upper:
-        return True
-    else:
-        return False
+    return bool(abs(calculation) > lower and abs(calculation) < upper)
 
 
 def equationChecker(
     categoryName: str, qNumber: int, spreadsheetFile
 ) -> tuple[list[str], list[float], float]:
-    """This Function calculates all Results an invokes the checkResult function
+    """This Function calculates all Results an invokes the checkResult function.
 
     Parameters
     ----------
@@ -86,8 +82,8 @@ def equationChecker(
         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]
@@ -95,7 +91,6 @@ def equationChecker(
     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)
     return bps, calcs, res
@@ -106,11 +101,11 @@ def main(
     catN=None,
     qNumber=None,
 ) -> None:
-    """Takes the Spreadsheet, and asks for a category and a question number"""
-    if catN == 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
@@ -120,23 +115,14 @@ def main(
     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 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:")
+    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,20 +1,22 @@
-"""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
 """
 
-import logging as logging
+import logging
 from pathlib import Path
 
 from PySide6 import QtCore, QtWidgets
 from PySide6.QtCore import Qt
 
-from excel2moodle import e2mMetadata, qSignalLogger
+from excel2moodle import qSignalLogger
+
+# from excel2moodle.logger import LogWindowHandler
 from excel2moodle.core.dataStructure import QuestionDB
 from excel2moodle.extra import equationVerification as eqVerif
-from excel2moodle.ui import dialogs, windowEquationChecker
-from excel2moodle.ui.settings import Settings
+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
 
@@ -36,18 +38,18 @@ class MainWindow(QtWidgets.QMainWindow):
 
         self.ui.treeWidget.setSelectionMode(QtWidgets.QAbstractItemView.MultiSelection)
         self.ui.treeWidget.header().setSectionResizeMode(
-            QtWidgets.QHeaderView.ResizeToContents
+            QtWidgets.QHeaderView.ResizeToContents,
         )
         self.ui.checkBoxIncludeCategories.setChecked(
-            self.settings.value("testGen/includeCats", type=bool)
+            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"
+            "Wählen Sie bitte eine Excel Tabelle und einen Export Ordner für die Fragen aus",
         )
         try:
             self.resize(self.settings.value("windowSize"))
@@ -59,78 +61,55 @@ class MainWindow(QtWidgets.QMainWindow):
     def connectEvents(self) -> None:
         self.ui.treeWidget.itemClicked.connect(self.onSelectionChanged)
         self.ui.checkBoxQuestionListSelectAll.checkStateChanged.connect(
-            self.toggleQuestionSelectionState
+            self.toggleQuestionSelectionState,
         )
         qSignalLogger.emitter.signal.connect(self.updateLog)
-        self.ui.actionEquationChecker.triggered.connect(self.onButOpenEqChecker)
+        self.ui.actionEquationChecker.triggered.connect(self.openEqCheckerDlg)
         self.ui.checkBoxIncludeCategories.checkStateChanged.connect(
-            self.setIncludeCategoriesSetting
+            self.setIncludeCategoriesSetting,
         )
-        # self.ui.buttonRefresh.clicked.connect(self.refreshList)
         self.ui.actionParseAll.triggered.connect(self.onParseAll)
-        self.testDB.dataChanged.signal.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:
         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:
         self.ui.loggerWindow.append(log)
 
-    def setIncludeCategoriesSetting(self):
+    def setIncludeCategoriesSetting(self) -> None:
         if self.ui.checkBoxIncludeCategories.isChecked():
-            self.settings.testgenSet("includeCats", True)
-            logger.debug("set includeCats to True")
+            self.settings.set(SettingsKey.INCLUDEINCATS, True)
         else:
-            self.settings.testgenSet("includeCats", False)
-            logger.debug("set includeCats to False")
+            self.settings.set(SettingsKey.INCLUDEINCATS, 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>
-        </p>
-        <p style="text-align:center">
-        This project is maintained by {e2mMetadata['author']}.
-        <br>
-        Development takes place at <a href="{e2mMetadata['homepage']}"> GitLab: {e2mMetadata['homepage']}</a>
-        contributions are very welcome
-        </br>
-        If you encounter any issues please report them under the repositories issues page.
-        </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
-        )
-
-    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()
@@ -138,17 +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):
@@ -158,21 +133,20 @@ class MainWindow(QtWidgets.QMainWindow):
 
     @QtCore.Slot()
     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"}",
+            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=}")
+        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):
+    def onButSpreadsheet(self) -> None:
         file = QtWidgets.QFileDialog.getOpenFileName(
             self,
             self.tr("Open Spreadsheet"),
@@ -184,19 +158,25 @@ class MainWindow(QtWidgets.QMainWindow):
         self.settings.setSpreadsheet(self.excelPath)
         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
+        """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
         self.ui.treeWidget.clear()
@@ -206,49 +186,54 @@ class MainWindow(QtWidgets.QMainWindow):
             for q in cat.questions.values():
                 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")
+            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()
-            )
+                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
-        """
-
+        """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
+            f"KAT_{catN}",
+            qN,
+            self.excelFile,
         )
         check = False
         self.ui.lineFirstResult.setText(f"{firstResult}")
@@ -257,13 +242,13 @@ class EqCheckerWindow(QtWidgets.QWidget):
                 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"
+                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"
+                "Das erste berechnete Ergebnis stimmt mit dem Wert in 'firstResult' überein\n",
             )
         else:
             self.ui.lineCheckResult.setText("[ERROR]")

excel2moodle/ui/dialogs.py

@@ -1,9 +1,10 @@
-"""This Module hosts the various Dialog Classes, that can be shown from main Window"""
+"""This Module hosts the various Dialog Classes, that can be shown from main Window."""
 
 import lxml.etree as ET
 from PySide6 import QtGui, QtWidgets
 from PySide6.QtSvgWidgets import QGraphicsSvgItem
 
+from excel2moodle import e2mMetadata
 from excel2moodle.core.globals import XMLTags
 from excel2moodle.core.question import Question
 from excel2moodle.ui.questionPreviewDialog import Ui_QuestionPrevDialog
@@ -11,7 +12,7 @@ from excel2moodle.ui.variantDialog import Ui_Dialog
 
 
 class QuestionVariantDialog(QtWidgets.QDialog):
-    def __init__(self, parent, question: Question):
+    def __init__(self, parent, question: Question) -> None:
         super().__init__(parent)
         self.setWindowTitle("Question Variant Dialog")
         self.maxVal = question.variants
@@ -37,6 +38,7 @@ class QuestinoPreviewDialog(QtWidgets.QDialog):
         self.question = question
         self.ui = Ui_QuestionPrevDialog()
         self.ui.setupUi(self)
+        self.setModal(True)
         self.setWindowTitle(f"Question - {question.id} - Preview")
         self.setupQuestion()
 
@@ -81,13 +83,13 @@ class QuestinoPreviewDialog(QtWidgets.QDialog):
             for i, ans in enumerate(self.question.answerVariants):
                 a = ans.find("text").text
                 text = QtWidgets.QLineEdit(a, self)
-                self.ui.answersFormLayout.addRow(f"Answer {i+1}", text)
+                self.ui.answersFormLayout.addRow(f"Answer {i + 1}", text)
 
         elif self.question.qtype == "NF":
             ans = self.question.element.find(XMLTags.ANSWER)
             a = ans.find("text").text
             text = QtWidgets.QLineEdit(a, self)
-            self.ui.answersFormLayout.addRow(f"Result", text)
+            self.ui.answersFormLayout.addRow("Result", text)
 
         elif self.question.qtype == "MC":
             for i, ans in enumerate(self.question.element.findall(XMLTags.ANSWER)):
@@ -95,3 +97,37 @@ class QuestinoPreviewDialog(QtWidgets.QDialog):
                 frac = ans.get("fraction")
                 text = QtWidgets.QLineEdit(a, self)
                 self.ui.answersFormLayout.addRow(f"Fraction: {frac}", text)
+
+
+class AboutDialog(QtWidgets.QMessageBox):
+    def __init__(self, parent: QtWidgets.QWidget) -> None:
+        super().__init__(parent)
+        self.setWindowTitle(f"About {e2mMetadata['name']}")
+        self.setIcon(QtWidgets.QMessageBox.Information)
+        self.setStandardButtons(QtWidgets.QMessageBox.StandardButton.Close)
+
+        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>
+        </p>
+        <p style="text-align:center">
+        This project is maintained by {e2mMetadata["author"]}.
+        <br>
+        Development takes place at <a href="{e2mMetadata["homepage"]}"> GitLab: {e2mMetadata["homepage"]}</a>
+        contributions are very welcome
+        </br>
+        If you encounter any issues please report them under the repositories issues page.
+        </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>
+        """
+        self.setText(self.aboutMessage)