excel2moodle 0.3.6__py3-none-any.whl → 0.4.0__py3-none-any.whl

excel2moodle/question_types/nfm.py

@@ -0,0 +1,91 @@
+"""Numerical question multi implementation."""
+
+import re
+from typing import TYPE_CHECKING
+
+import lxml.etree as ET
+from asteval import Interpreter
+
+from excel2moodle.core import stringHelpers
+from excel2moodle.core.globals import (
+    DFIndex,
+    XMLTags,
+)
+from excel2moodle.core.parser import QuestionParser
+from excel2moodle.core.question import Question
+
+if TYPE_CHECKING:
+    import lxml.etree as ET
+
+
+class NFMQuestion(Question):
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+
+
+class NFMQuestionParser(QuestionParser):
+    def __init__(self) -> None:
+        super().__init__()
+        self.genFeedbacks = [XMLTags.GENFEEDB]
+        self.astEval = Interpreter()
+
+    def setAnswers(self) -> None:
+        equation = self.rawInput[DFIndex.RESULT]
+        bps = str(self.rawInput[DFIndex.BPOINTS])
+        ansElementsList: list[ET.Element] = []
+        varNames: list[str] = self._getVarsList(bps)
+        self.question.variables, number = self._getVariablesDict(varNames)
+        for n in range(number):
+            self._setupAstIntprt(self.question.variables, n)
+            result = self.astEval(equation)
+            if isinstance(result, float):
+                ansElementsList.append(
+                    self.getNumericAnsElement(result=round(result, 3)),
+                )
+        self.question.answerVariants = ansElementsList
+        self.setVariants(len(ansElementsList))
+
+    def setVariants(self, number: int) -> None:
+        self.question.variants = number
+        mvar = self.question.category.maxVariants
+        if mvar is None:
+            self.question.category.maxVariants = number
+        else:
+            self.question.category.maxVariants = min(number, mvar)
+
+    def _setupAstIntprt(self, var: dict[str, list[float | int]], index: int) -> None:
+        """Setup the asteval Interpreter with the variables."""
+        for name, value in var.items():
+            self.astEval.symtable[name] = value[index]
+
+    def _getVariablesDict(self, keyList: list) -> tuple[dict[str, list[float]], int]:
+        """Liest alle Variablen-Listen deren Name in ``keyList`` ist aus dem DataFrame im Column[index]."""
+        dic: dict = {}
+        num: int = 0
+        for k in keyList:
+            val = self.rawInput[k]
+            if isinstance(val, str):
+                li = stringHelpers.getListFromStr(val)
+                num = len(li)
+                variables: list[float] = [float(i.replace(",", ".")) for i in li]
+                dic[str(k)] = variables
+            else:
+                dic[str(k)] = [str(val)]
+                num = 1
+        self.logger.debug("The following variables were provided: %s", dic)
+        return dic, num
+
+    @staticmethod
+    def _getVarsList(bps: str | list[str]) -> list:
+        """Durchsucht den bulletPoints String nach den Variablen ``{var}``.
+
+        It only finds variables after the ``=`` sign, to not catch LaTex.
+        """
+        varNames = []
+        regexFinder = re.compile(r"=\s*\{(\w+)\}")
+        if isinstance(bps, list):
+            for _p in bps:
+                varNames.extend(regexFinder.findall(str(_p)))
+        else:
+            varNames = regexFinder.findall(str(bps))
+        return varNames

excel2moodle/ui/appUi.py

@@ -10,18 +10,24 @@ from pathlib import Path
 from PySide6 import QtCore, QtWidgets
 from PySide6.QtCore import QRunnable, Qt, QThreadPool
 
-from excel2moodle import qSignalLogger
+from excel2moodle import mainLogger
+from excel2moodle.core.category import Category
 from excel2moodle.core.dataStructure import QuestionDB
+from excel2moodle.core.settings import Settings, SettingsKey
 from excel2moodle.extra import equationVerification as eqVerif
+from excel2moodle.logger import LogWindowHandler
 from excel2moodle.ui import dialogs
-from excel2moodle.ui.settings import Settings, SettingsKey
 from excel2moodle.ui.treewidget import CategoryItem, QuestionItem
+from excel2moodle.ui.windowDoc import DocumentationWindow
 from excel2moodle.ui.windowMain import Ui_MoodleTestGenerator
 
 from .windowEquationChecker import Ui_EquationChecker
 
 logger = logging.getLogger(__name__)
 
+loggerSignal = LogWindowHandler()
+mainLogger.addHandler(loggerSignal)
+
 
 class MainWindow(QtWidgets.QMainWindow):
     def __init__(self, settings: Settings, testDB: QuestionDB) -> None:
@@ -33,16 +39,18 @@ class MainWindow(QtWidgets.QMainWindow):
         self.testDB = testDB
         self.ui = Ui_MoodleTestGenerator()
         self.ui.setupUi(self)
+        self.exportDialog = dialogs.ExportDialog(self)
+        self.questionPreview = dialogs.QuestionPreview(self)
         self.connectEvents()
         logger.info("Settings are stored under: %s", self.settings.fileName())
         self.ui.treeWidget.setSelectionMode(QtWidgets.QAbstractItemView.MultiSelection)
         self.ui.treeWidget.header().setSectionResizeMode(
             QtWidgets.QHeaderView.ResizeToContents,
         )
-        self.ui.checkBoxIncludeCategories.setChecked(
+        self.exportDialog.ui.checkBoxIncludeCategories.setChecked(
             self.settings.get(SettingsKey.INCLUDEINCATS),
         )
-        self.ui.spinBoxDefaultQVariant.setValue(
+        self.exportDialog.ui.spinBoxDefaultQVariant.setValue(
             self.settings.get(SettingsKey.QUESTIONVARIANT)
         )
         self.ui.pointCounter.setReadOnly(True)
@@ -58,30 +66,35 @@ class MainWindow(QtWidgets.QMainWindow):
         self.threadPool = QThreadPool()
 
     def connectEvents(self) -> None:
-        self.ui.treeWidget.itemClicked.connect(self.onSelectionChanged)
+        self.ui.treeWidget.itemSelectionChanged.connect(self.onSelectionChanged)
         self.ui.checkBoxQuestionListSelectAll.checkStateChanged.connect(
             self.toggleQuestionSelectionState,
         )
-        qSignalLogger.emitter.signal.connect(self.updateLog)
+        loggerSignal.emitter.signal.connect(self.updateLog)
         self.ui.actionEquationChecker.triggered.connect(self.openEqCheckerDlg)
-        self.ui.checkBoxIncludeCategories.checkStateChanged.connect(
+        self.exportDialog.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.openPreviewQuestionDlg)
+        self.ui.actionParseAll.triggered.connect(self.parseSpreadsheetAll)
+        self.testDB.signals.categoryQuestionsReady.connect(self.treeRefreshCategory)
+        self.ui.actionSpreadsheet.triggered.connect(self.actionSpreadsheet)
+        self.ui.actionExport.triggered.connect(self.onButGenTest)
+        self.ui.buttonSpreadsheet.clicked.connect(self.actionSpreadsheet)
+        self.ui.buttonExport.clicked.connect(self.onButGenTest)
+        self.ui.treeWidget.itemClicked.connect(self.updateQuestionPreview)
         self.ui.actionAbout.triggered.connect(self.openAboutDlg)
+        self.ui.actionDocumentation.triggered.connect(self.openDocumentation)
         self.settings.shPathChanged.connect(self.onSheetPathChanged)
-        self.ui.spinBoxDefaultQVariant.valueChanged.connect(self.setQVariantDefault)
+        self.exportDialog.ui.spinBoxDefaultQVariant.valueChanged.connect(
+            self.setQVariantDefault
+        )
 
     @QtCore.Slot()
     def setQVariantDefault(self, value: int) -> None:
         self.settings.set(SettingsKey.QUESTIONVARIANT, value)
 
     @QtCore.Slot()
-    def onParseAll(self) -> None:
+    def parseSpreadsheetAll(self) -> None:
         """Event triggered by the *Tools/Parse all Questions* Event.
 
         It parses all the Questions found in the spreadsheet
@@ -89,7 +102,7 @@ class MainWindow(QtWidgets.QMainWindow):
         If successful it prints out a list of all exported Questions
         """
         self.ui.treeWidget.clear()
-        process = ParseSpreadsheetThread(self.testDB, self)
+        process = ParseAllThread(self.testDB, self)
         self.threadPool.start(process)
 
     @QtCore.Slot(Path)
@@ -100,14 +113,14 @@ class MainWindow(QtWidgets.QMainWindow):
         svgFolder = self.mainPath / self.settings.get(SettingsKey.PICTURESUBFOLDER)
         svgFolder.resolve()
         self.settings.set(SettingsKey.PICTUREFOLDER, svgFolder)
-        self.ui.buttonSpreadSheet.setText(str(sheet.name))
-        self.onParseAll()
+        self.ui.buttonSpreadsheet.setText(f"../{sheet.name}")
+        self.parseSpreadsheetAll()
 
     def updateLog(self, log) -> None:
         self.ui.loggerWindow.append(log)
 
     def setIncludeCategoriesSetting(self) -> None:
-        if self.ui.checkBoxIncludeCategories.isChecked():
+        if self.exportDialog.ui.checkBoxIncludeCategories.isChecked():
             self.settings.set(SettingsKey.INCLUDEINCATS, True)
         else:
             self.settings.set(SettingsKey.INCLUDEINCATS, False)
@@ -125,8 +138,6 @@ class MainWindow(QtWidgets.QMainWindow):
         for q in selection:
             questions += 1
             count += q.getQuestion().points
-
-        logger.info("%s questions are selected with %s points", questions, count)
         self.ui.pointCounter.setValue(count)
         self.ui.questionCounter.setValue(questions)
 
@@ -143,6 +154,7 @@ class MainWindow(QtWidgets.QMainWindow):
     @QtCore.Slot()
     def onButGenTest(self) -> None:
         """Open a file Dialog so the export file may be choosen."""
+        self.exportDialog.exec()
         path = QtWidgets.QFileDialog.getSaveFileName(
             self,
             "Select Output File",
@@ -155,7 +167,7 @@ class MainWindow(QtWidgets.QMainWindow):
         self.testDB.appendQuestions(selection, self.exportFile)
 
     @QtCore.Slot()
-    def onButSpreadsheet(self) -> None:
+    def actionSpreadsheet(self) -> None:
         file = QtWidgets.QFileDialog.getOpenFileName(
             self,
             self.tr("Open Spreadsheet"),
@@ -163,32 +175,28 @@ class MainWindow(QtWidgets.QMainWindow):
             filter=self.tr("Spreadsheet(*.xlsx *.ods)"),
             selectedFilter=("*.ods"),
         )
-        self.excelPath = Path(file[0]).resolve()
-        self.settings.setSpreadsheet(self.excelPath)
-        self.setStatus("[OK] Excel Tabelle wurde eingelesen")
+        path = Path(file[0]).resolve(strict=True)
+        if path.is_file():
+            self.excelPath = path
+            self.settings.setSpreadsheet(self.excelPath)
+            self.setStatus("[OK] Excel Tabelle wurde eingelesen")
+        else:
+            self.setStatus("[ERROR] keine Tabelle angegeben")
 
-    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()
-        for cat in cats.values():
-            catItem = CategoryItem(self.ui.treeWidget, cat)
-            catItem.setFlags(catItem.flags() & ~Qt.ItemIsSelectable)
-            for q in cat.questions.values():
-                QuestionItem(catItem, q)
-        self.setStatus("[OK] Fragen Liste wurde aktualisiert")
-        self.ui.buttonTestGen.setEnabled(True)
+    @QtCore.Slot(Category)
+    def treeRefreshCategory(self, cat: Category) -> None:
+        """Append Category with its Questions to the treewidget."""
+        catItem = CategoryItem(self.ui.treeWidget, cat)
+        catItem.setFlags(catItem.flags() & ~Qt.ItemIsSelectable)
+        for q in cat.questions.values():
+            QuestionItem(catItem, q)
+        self.ui.treeWidget.sortItems(0, Qt.SortOrder.AscendingOrder)
 
     @QtCore.Slot()
-    def openPreviewQuestionDlg(self) -> None:
+    def updateQuestionPreview(self) -> None:
         item = self.ui.treeWidget.currentItem()
         if isinstance(item, QuestionItem):
-            dialog = dialogs.QuestinoPreviewDialog(self, item.getQuestion())
-            dialog.show()
+            self.questionPreview.setupQuestion(item.getQuestion())
         else:
             logger.info("current Item is not a Question, can't preview")
 
@@ -208,8 +216,21 @@ class MainWindow(QtWidgets.QMainWindow):
         about = dialogs.AboutDialog(self)
         about.exec()
 
+    @QtCore.Slot()
+    def openDocumentation(self) -> None:
+        if hasattr(self, "documentationWindow"):
+            self.documentationWindow.show()
+        else:
+            self.documentationWindow = DocumentationWindow(self)
+            self.documentationWindow.show()
+
+
+class ParseAllThread(QRunnable):
+    """Parse the whole Spreadsheet.
+    Start by reading the spreadsheet asynchron.
+    When finished parse all Categories subsequently.
+    """
 
-class ParseSpreadsheetThread(QRunnable):
     def __init__(self, questionDB: QuestionDB, mainApp: MainWindow) -> None:
         super().__init__()
         self.testDB = questionDB
@@ -217,11 +238,10 @@ class ParseSpreadsheetThread(QRunnable):
 
     @QtCore.Slot()
     def run(self) -> None:
-        self.testDB.readSpreadsheetData(self.mainApp.spreadSheetPath)
+        self.testDB.readCategoriesMetadata(self.mainApp.spreadSheetPath)
+        self.testDB.asyncInitAllCategories(self.mainApp.spreadSheetPath)
         self.mainApp.setStatus("[OK] Tabellen wurde eingelesen")
-        self.testDB.parseAll()
-        self.mainApp.setStatus("[OK] Alle Fragen wurden erfolgreich geparsed")
-        self.mainApp.refreshList()
+        self.testDB.parseAllQuestions()
 
 
 class EqCheckerWindow(QtWidgets.QWidget):

excel2moodle/ui/dialogs.py

@@ -7,7 +7,7 @@ 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
+from excel2moodle.ui.exportSettingsDialog import Ui_ExportDialog
 from excel2moodle.ui.variantDialog import Ui_Dialog
 
 
@@ -32,43 +32,48 @@ class QuestionVariantDialog(QtWidgets.QDialog):
         return self.ui.checkBox.isChecked()
 
 
-class QuestinoPreviewDialog(QtWidgets.QDialog):
-    def __init__(self, parent: QtWidgets.QWidget, question: Question) -> None:
+class ExportDialog(QtWidgets.QDialog):
+    def __init__(self, parent) -> None:
         super().__init__(parent)
-        self.question = question
-        self.ui = Ui_QuestionPrevDialog()
+        self.setWindowTitle("Export question Selection")
+        self.ui = Ui_ExportDialog()
         self.ui.setupUi(self)
-        self.setModal(True)
-        self.setWindowTitle(f"Question - {question.id} - Preview")
-        self.setupQuestion()
 
-    def setupQuestion(self) -> None:
-        self.ui.qNameLine.setText(self.question.name)
-        self.ui.qTypeLine.setText(self.question.qtype)
+
+class QuestionPreview:
+    def __init__(self, parent) -> None:
+        self.ui = parent.ui
+        self.parent = parent
+
+    def setupQuestion(self, question: Question) -> None:
+        self.question: Question = question
+        self.ui.qNameLine.setText(f"{self.question.qtype} - {self.question.name}")
+        self.picScene = QtWidgets.QGraphicsScene(self.parent)
+        self.ui.graphicsView.setScene(self.picScene)
         self.setText()
         self.setAnswers()
+        if hasattr(self, "picItem"):
+            self.picScene.removeItem(self.picItem)
         self.setPicture()
 
     def setPicture(self) -> None:
         if hasattr(self.question, "picture") and self.question.picture.ready:
-            self.picScene = QtWidgets.QGraphicsScene(self)
-            self.ui.graphicsView.setScene(self.picScene)
             path = self.question.picture.path
             if path.suffix == ".svg":
-                picItem = QGraphicsSvgItem(str(self.question.picture.path))
+                self.picItem = QGraphicsSvgItem(str(self.question.picture.path))
             else:
                 pic = QtGui.QPixmap(self.question.picture.path)
                 aspRat = pic.height() // pic.width()
                 width = 400
                 scaleHeight = aspRat * width
-                picItem = QtWidgets.QGraphicsPixmapItem(
+                self.picItem = QtWidgets.QGraphicsPixmapItem(
                     pic.scaled(
                         width, scaleHeight, QtGui.Qt.AspectRatioMode.KeepAspectRatio
                     )
                 )
-            self.picScene.addItem(picItem)
-        else:
-            self.ui.graphicsView.setFixedHeight(1)
+            self.picScene.addItem(self.picItem)
+        # else:
+        #     self.ui.graphicsView.setFixedHeight(1)
 
     def setText(self) -> None:
         t = []
@@ -80,23 +85,26 @@ class QuestinoPreviewDialog(QtWidgets.QDialog):
 
     def setAnswers(self) -> None:
         if self.question.qtype == "NFM":
-            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)
-
+            list = ET.Element("ol")
+            for ans in self.question.answerVariants:
+                textEle = ET.Element("li")
+                textEle.text = f"Result: {ans.find('text').text}"
+                list.append(textEle)
+            self.ui.answersLabel.setText(ET.tostring(list, encoding="unicode"))
         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("Result", text)
-
+            self.ui.answersLabel.setText(f" Result: {ans.find('text').text}")
         elif self.question.qtype == "MC":
-            for i, ans in enumerate(self.question.element.findall(XMLTags.ANSWER)):
-                a = ans.find("text").text
+            list = ET.Element("ol")
+            for ans in self.question.element.findall(XMLTags.ANSWER):
+                textEle = ET.Element("li")
+                pEle = ans.find("text").text
                 frac = ans.get("fraction")
-                text = QtWidgets.QLineEdit(a, self)
-                self.ui.answersFormLayout.addRow(f"Fraction: {frac}", text)
+                anstext = ET.fromstring(pEle).text
+                text = f"Fraction {frac}: {anstext}"
+                textEle.text = text
+                list.append(textEle)
+            self.ui.answersLabel.setText(ET.tostring(list, encoding="unicode"))
 
 
 class AboutDialog(QtWidgets.QMessageBox):
@@ -107,14 +115,15 @@ class AboutDialog(QtWidgets.QMessageBox):
         self.setStandardButtons(QtWidgets.QMessageBox.StandardButton.Close)
 
         self.aboutMessage: str = f"""
-        <h1> About {e2mMetadata["name"]}</h1><br>
+        <h1> About {e2mMetadata["name"]} v {e2mMetadata["version"]}</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>
+            A <b>
+            <a href="{e2mMetadata["documentation"]}">documentation</a></b>
+            is also available.
             </br>
         </p>
         <p style="text-align:center">

excel2moodle/ui/exportSettingsDialog.py

@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*-
+
+################################################################################
+## Form generated from reading UI file 'exportSettingsDialog.ui'
+##
+## Created by: Qt User Interface Compiler version 6.9.0
+##
+## WARNING! All changes made in this file will be lost when recompiling UI file!
+################################################################################
+
+from PySide6.QtCore import (QCoreApplication, QDate, QDateTime, QLocale,
+    QMetaObject, QObject, QPoint, QRect,
+    QSize, QTime, QUrl, Qt)
+from PySide6.QtGui import (QBrush, QColor, QConicalGradient, QCursor,
+    QFont, QFontDatabase, QGradient, QIcon,
+    QImage, QKeySequence, QLinearGradient, QPainter,
+    QPalette, QPixmap, QRadialGradient, QTransform)
+from PySide6.QtWidgets import (QAbstractButton, QApplication, QCheckBox, QDialog,
+    QDialogButtonBox, QFormLayout, QHBoxLayout, QLabel,
+    QSizePolicy, QSpinBox, QWidget)
+
+class Ui_ExportDialog(object):
+    def setupUi(self, ExportDialog):
+        if not ExportDialog.objectName():
+            ExportDialog.setObjectName(u"ExportDialog")
+        ExportDialog.resize(572, 217)
+        self.horizontalLayout = QHBoxLayout(ExportDialog)
+        self.horizontalLayout.setObjectName(u"horizontalLayout")
+        self.formLayout_2 = QFormLayout()
+        self.formLayout_2.setObjectName(u"formLayout_2")
+        self.formLayout_2.setContentsMargins(5, 5, 5, 5)
+        self.label_10 = QLabel(ExportDialog)
+        self.label_10.setObjectName(u"label_10")
+
+        self.formLayout_2.setWidget(0, QFormLayout.ItemRole.LabelRole, self.label_10)
+
+        self.spinBoxDefaultQVariant = QSpinBox(ExportDialog)
+        self.spinBoxDefaultQVariant.setObjectName(u"spinBoxDefaultQVariant")
+
+        self.formLayout_2.setWidget(0, QFormLayout.ItemRole.FieldRole, self.spinBoxDefaultQVariant)
+
+        self.label_9 = QLabel(ExportDialog)
+        self.label_9.setObjectName(u"label_9")
+
+        self.formLayout_2.setWidget(1, QFormLayout.ItemRole.LabelRole, self.label_9)
+
+        self.checkBoxIncludeCategories = QCheckBox(ExportDialog)
+        self.checkBoxIncludeCategories.setObjectName(u"checkBoxIncludeCategories")
+
+        self.formLayout_2.setWidget(1, QFormLayout.ItemRole.FieldRole, self.checkBoxIncludeCategories)
+
+
+        self.horizontalLayout.addLayout(self.formLayout_2)
+
+        self.buttonBox = QDialogButtonBox(ExportDialog)
+        self.buttonBox.setObjectName(u"buttonBox")
+        self.buttonBox.setOrientation(Qt.Orientation.Vertical)
+        self.buttonBox.setStandardButtons(QDialogButtonBox.StandardButton.Cancel|QDialogButtonBox.StandardButton.Ok)
+
+        self.horizontalLayout.addWidget(self.buttonBox)
+
+
+        self.retranslateUi(ExportDialog)
+        self.buttonBox.accepted.connect(ExportDialog.accept)
+        self.buttonBox.rejected.connect(ExportDialog.reject)
+
+        QMetaObject.connectSlotsByName(ExportDialog)
+    # setupUi
+
+    def retranslateUi(self, ExportDialog):
+        ExportDialog.setWindowTitle(QCoreApplication.translate("ExportDialog", u"Dialog", None))
+        self.label_10.setText(QCoreApplication.translate("ExportDialog", u"Default Question Variant", None))
+#if QT_CONFIG(tooltip)
+        self.label_9.setToolTip(QCoreApplication.translate("ExportDialog", u"If enabled, all questions will be categorized, when importing into moodle. Otherwise they will all be imported into one category", None))
+#endif // QT_CONFIG(tooltip)
+        self.label_9.setText(QCoreApplication.translate("ExportDialog", u"Include Questions in Categories", None))
+        self.checkBoxIncludeCategories.setText("")
+    # retranslateUi
+

excel2moodle/ui/windowDoc.py

@@ -1,35 +1,27 @@
-import os
 import sys
-from PySide6 import QtWidgets, QtWebEngineWidgets, QtCore
-from excel2moodle import dirDocumentation
+
+from PySide6 import QtCore, QtWebEngineWidgets, QtWidgets
+
+from excel2moodle import e2mMetadata
+
 
 class DocumentationWindow(QtWidgets.QMainWindow):
-    def __init__(self, documentationDirectory, parent=None):
+    def __init__(self, parent=None) -> None:
         super().__init__(parent)
 
         self.web_view = QtWebEngineWidgets.QWebEngineView()
         self.setCentralWidget(self.web_view)
 
         # Load the HTML documentation
-
-        index_file = os.path.join(documentationDirectory, "index.html")
-        url = QtCore.QUrl.fromLocalFile(index_file)
+        url = QtCore.QUrl(e2mMetadata["documentation"])
+        print(f"Opening URL {url}")
         self.web_view.setUrl(url)
 
-        # Set up navigation events
-        self.web_view.page().linkHovered.connect(self.link_hovered)
-        self.web_view.page().loadFinished.connect(self.load_finished)
-
-    def link_hovered(self, url):
-        print(f"Link hovered: {url}")
-
-    def load_finished(self, ok):
-        print(f"Load finished: {ok}")
 
 if __name__ == "__main__":
     app = QtWidgets.QApplication(sys.argv)
 
-    window = DocumentationWindow(dirDocumentation)
+    window = DocumentationWindow()
     window.show()
 
     sys.exit(app.exec())