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

excel2moodle/question_types/nf.py

@@ -0,0 +1,30 @@
+"""Numerical question implementation."""
+
+import lxml.etree as ET
+
+from excel2moodle.core.globals import (
+    DFIndex,
+    XMLTags,
+)
+from excel2moodle.core.parser import QuestionParser
+from excel2moodle.core.question import Question
+
+
+class NFQuestion(Question):
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+
+
+class NFQuestionParser(QuestionParser):
+    """Subclass for parsing numeric questions."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.genFeedbacks = [XMLTags.GENFEEDB]
+
+    def setAnswers(self) -> list[ET.Element]:
+        result = self.rawInput[DFIndex.RESULT]
+        ansEle: list[ET.Element] = []
+        tol = self.rawInput[DFIndex.TOLERANCE]
+        ansEle.append(self.getNumericAnsElement(result=result, tolerance=tol))
+        return ansEle

excel2moodle/question_types/nfm.py

@@ -0,0 +1,92 @@
+"""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):
+                tol = self.rawInput[DFIndex.TOLERANCE]
+                ansElementsList.append(
+                    self.getNumericAnsElement(result=round(result, 3), tolerance=tol),
+                )
+        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

@@ -8,13 +8,13 @@ import logging
 from pathlib import Path
 
 from PySide6 import QtCore, QtWidgets
-from PySide6.QtCore import Qt
+from PySide6.QtCore import QRunnable, Qt, QThreadPool
 
-from excel2moodle import qSignalLogger
-
-# from excel2moodle.logger import LogWindowHandler
+from excel2moodle import mainLogger
+from excel2moodle.core.category import Category
 from excel2moodle.core.dataStructure import QuestionDB
 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
@@ -24,6 +24,9 @@ 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:
@@ -35,7 +38,8 @@ class MainWindow(QtWidgets.QMainWindow):
         self.testDB = testDB
         self.ui = Ui_MoodleTestGenerator()
         self.ui.setupUi(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,
@@ -43,33 +47,33 @@ class MainWindow(QtWidgets.QMainWindow):
         self.ui.checkBoxIncludeCategories.setChecked(
             self.settings.get(SettingsKey.INCLUDEINCATS),
         )
-
-        self.ui.retranslateUi(self)
-        logger.info("Settings are stored under: %s", self.settings.fileName())
+        self.ui.spinBoxDefaultQVariant.setValue(
+            self.settings.get(SettingsKey.QUESTIONVARIANT)
+        )
         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 eine Excel Tabelle mit den Fragen aus",
         )
         try:
             self.resize(self.settings.value("windowSize"))
             self.move(self.settings.value("windowPosition"))
         except Exception:
             pass
-        self.connectEvents()
+        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.setIncludeCategoriesSetting,
         )
-        self.ui.actionParseAll.triggered.connect(self.onParseAll)
-        self.testDB.dataChanged.signal.connect(self.refreshList)
+        self.ui.actionParseAll.triggered.connect(self.parseSpreadsheetAll)
+        self.testDB.signals.categoryQuestionsReady.connect(self.treeRefreshCategory)
         self.ui.buttonSpreadSheet.clicked.connect(self.onButSpreadsheet)
         self.ui.buttonTestGen.clicked.connect(self.onButGenTest)
         self.ui.actionPreviewQ.triggered.connect(self.openPreviewQuestionDlg)
@@ -81,6 +85,18 @@ class MainWindow(QtWidgets.QMainWindow):
     def setQVariantDefault(self, value: int) -> None:
         self.settings.set(SettingsKey.QUESTIONVARIANT, value)
 
+    @QtCore.Slot()
+    def parseSpreadsheetAll(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.
+        If successful it prints out a list of all exported Questions
+        """
+        self.ui.treeWidget.clear()
+        process = ParseAllThread(self.testDB, self)
+        self.threadPool.start(process)
+
     @QtCore.Slot(Path)
     def onSheetPathChanged(self, sheet: Path) -> None:
         logger.debug("Slot, new Spreadsheet triggered")
@@ -90,9 +106,7 @@ class MainWindow(QtWidgets.QMainWindow):
         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()
+        self.parseSpreadsheetAll()
 
     def updateLog(self, log) -> None:
         self.ui.loggerWindow.append(log)
@@ -116,8 +130,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)
 
@@ -154,39 +166,22 @@ class MainWindow(QtWidgets.QMainWindow):
             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")
-        self.setStatus("[OK] Excel Tabelle wurde eingelesen")
-
-    @QtCore.Slot()
-    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.
-        If successful it prints out a list of all exported Questions
-        """
-        self.testDB.readSpreadsheetData(self.spreadSheetPath)
-        self.testDB.parseAll()
-        self.setStatus("[OK] Alle Fragen wurden erfolgreich in XML-Dateien umgewandelt")
-        self.refreshList()
-
-    def refreshList(self) -> None:
-        """Refresh the question overview in the main window.
+        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")
 
-        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:
@@ -214,6 +209,26 @@ class MainWindow(QtWidgets.QMainWindow):
         about.exec()
 
 
+class ParseAllThread(QRunnable):
+    """Parse the whole Spreadsheet.
+    Start by reading the spreadsheet asynchron.
+    When finished parse all Categories subsequently.
+    """
+
+    def __init__(self, questionDB: QuestionDB, mainApp: MainWindow) -> None:
+        super().__init__()
+        self.testDB = questionDB
+        self.mainApp = mainApp
+
+    @QtCore.Slot()
+    def run(self) -> None:
+        self.testDB.readCategoriesMetadata(self.mainApp.spreadSheetPath)
+        self.testDB.asyncInitAllCategories(self.mainApp.spreadSheetPath)
+        self.mainApp.setStatus("[OK] Tabellen wurde eingelesen")
+        self.testDB.parseAllQuestions()
+        self.mainApp.ui.buttonTestGen.setEnabled(True)
+
+
 class EqCheckerWindow(QtWidgets.QWidget):
     def __init__(self) -> None:
         super().__init__()

excel2moodle/ui/dialogs.py

@@ -81,21 +81,22 @@ 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)
+                t = ans.find("text").text
+                text = QtWidgets.QLineEdit(t, self)
                 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)
+            t = ans.find("text").text
+            text = QtWidgets.QLineEdit(t, self)
             self.ui.answersFormLayout.addRow("Result", text)
 
         elif self.question.qtype == "MC":
             for i, ans in enumerate(self.question.element.findall(XMLTags.ANSWER)):
-                a = ans.find("text").text
+                pEle = ans.find("text").text
+                t = ET.fromstring(pEle).text
                 frac = ans.get("fraction")
-                text = QtWidgets.QLineEdit(a, self)
+                text = QtWidgets.QLineEdit(t, self)
                 self.ui.answersFormLayout.addRow(f"Fraction: {frac}", text)
 
 
@@ -107,7 +108,7 @@ 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>

excel2moodle/ui/settings.py

@@ -3,7 +3,7 @@
 import logging
 from enum import StrEnum
 from pathlib import Path
-from typing import Literal, overload
+from typing import ClassVar, Literal, overload
 
 from PySide6.QtCore import QSettings, QTimer, Signal
 
@@ -11,50 +11,79 @@ logger = logging.getLogger(__name__)
 
 
 class SettingsKey(StrEnum):
+    """Settings Keys are needed to always acess the correct Value.
+
+    As the QSettings settings are accesed via strings, which could easily gotten wrong.
+    Further, this Enum defines, which type a setting has to be.
+    """
+
     def __new__(
         cls,
         key: str,
+        place: str,
         typ: type,
         default: str | float | Path | bool | None,
     ):
         """Define new settings class."""
         obj = str.__new__(cls, key)
         obj._value_ = key
+        obj._place_ = place
         obj._default_ = default
         obj._typ_ = typ
         return obj
 
+    def __init__(
+        self, _, place: str, typ: type, default: str | float | Path | None
+    ) -> None:
+        self._typ_ = typ
+        self._place_ = place
+        self._default_ = default
+        self._full_ = f"{self._place_}/{self._value_}"
+
     @property
     def default(self) -> str | int | float | Path | bool | None:
         """Get default value for the key."""
         return self._default_
 
+    @property
+    def place(self) -> str:
+        return self._place_
+
+    @property
+    def full(self) -> str:
+        return self._full_
+
     def typ(self) -> type:
         """Get default value for the key."""
         return self._typ_
 
-    QUESTIONVARIANT = "testgen/defaultQuestionVariant", int, 0
-    INCLUDEINCATS = "testgen/includeCats", bool, False
-    PARSERNF_TOLERANCE = "parser/nf/tolerance", int, 1
-    PICTURESUBFOLDER = "core/pictureSubFolder", str, "Abbildungen"
-    PICTUREFOLDER = "core/pictureFolder", Path, None
-    SPREADSHEETFOLDER = "core/spreadsheetFolder", Path, None
-    LOGLEVEL = "core/loglevel", str, "INFO"
-    LOGFILE = "core/logfile", str, "excel2moodleLogFile.log"
+    QUESTIONVARIANT = "defaultQuestionVariant", "testgen", int, 0
+    INCLUDEINCATS = "includeCats", "tesgen", bool, False
+    PARSERNF_TOLERANCE = "tolerance", "parser/nf", int, 1
+    PICTURESUBFOLDER = "imgSubFolder", "core", str, "Abbildungen"
+    PICTUREFOLDER = "pictureFolder", "core", Path, None
+    SPREADSHEETFOLDER = "spreadsheetFolder", "core", Path, None
+    LOGLEVEL = "loglevel", "core", str, "INFO"
+    LOGFILE = "logfile", "core", str, "excel2moodleLogFile.log"
+    CATEGORIESSHEET = "categoriesDataSheet", "core", str, "Kategorien"
+    VERSION = "version", "project", int, 1
+    POINTS = "points", "project", float, 1.0
 
 
 class Settings(QSettings):
     """Settings for Excel2moodle."""
 
     shPathChanged = Signal(Path)
+    localSettings: ClassVar[dict[str, str | float | Path]] = {}
 
     def __init__(self) -> None:
         """Instantiate the settings."""
         super().__init__("jbosse3", "excel2moodle")
-        if self.contains(SettingsKey.SPREADSHEETFOLDER):
+        logger.info("Settings are stored under: %s", self.fileName())
+        if self.contains(SettingsKey.SPREADSHEETFOLDER.full):
             self.sheet = self.get(SettingsKey.SPREADSHEETFOLDER)
             if self.sheet.is_file():
-                QTimer.singleShot(0, self._emitSpreadsheetChanged)
+                QTimer.singleShot(300, self._emitSpreadsheetChanged)
 
     def _emitSpreadsheetChanged(self) -> None:
         self.shPathChanged.emit(self.sheet)
@@ -62,54 +91,89 @@ class Settings(QSettings):
     @overload
     def get(
         self,
-        value: Literal[SettingsKey.QUESTIONVARIANT, SettingsKey.PARSERNF_TOLERANCE],
+        key: Literal[
+            SettingsKey.QUESTIONVARIANT,
+            SettingsKey.PARSERNF_TOLERANCE,
+            SettingsKey.VERSION,
+            SettingsKey.POINTS,
+        ],
     ) -> int: ...
     @overload
-    def get(self, value: Literal[SettingsKey.INCLUDEINCATS]) -> bool: ...
+    def get(self, key: Literal[SettingsKey.INCLUDEINCATS]) -> bool: ...
     @overload
     def get(
         self,
-        value: Literal[
-            SettingsKey.PICTURESUBFOLDER, SettingsKey.LOGLEVEL, SettingsKey.LOGFILE
+        key: Literal[
+            SettingsKey.PICTURESUBFOLDER,
+            SettingsKey.LOGLEVEL,
+            SettingsKey.LOGFILE,
+            SettingsKey.CATEGORIESSHEET,
         ],
     ) -> str: ...
     @overload
     def get(
         self,
-        value: Literal[SettingsKey.PICTUREFOLDER, SettingsKey.SPREADSHEETFOLDER],
+        key: Literal[SettingsKey.PICTUREFOLDER, SettingsKey.SPREADSHEETFOLDER],
     ) -> Path: ...
 
-    def get(self, value: SettingsKey):
+    def get(self, key: SettingsKey):
         """Get the typesafe settings value."""
-        logger.debug("entering get method. searched typ: %s", value.typ())
-        if value.typ() is Path:
-            logger.debug("trying to acess a path object from settings")
-            path = self.value(value, defaultValue=value.default)
+        logger.debug("LocalSettings: %s", self.localSettings)
+        if key in self.localSettings:
+            val = key.typ()(self.localSettings[key])
+            logger.debug("Returning project setting: %s = %s", key, val)
+            return val
+        if key.typ() is Path:
+            path: Path = self.value(key.full, defaultValue=key.default)
             try:
                 path.resolve(strict=True)
             except ValueError:
                 logger.warning(
-                    f"The settingsvalue {value} couldn't be fetched with correct typ",
+                    f"The settingsvalue {key} couldn't be fetched with correct typ",
                 )
-                return value.default
+                return key.default
+            logger.debug("Returning path setting: %s = %s", key, path)
             return path
-        raw = self.value(value, defaultValue=value.default, type=value.typ())
-        logger.debug("read a settings Value: %s of type: %s", value, value.typ())
+        raw = self.value(key.full, defaultValue=key.default, type=key.typ())
+        logger.debug("read a settings Value: %s of type: %s", key, key.typ())
         try:
-            return value.typ()(raw)
+            logger.debug("Returning global setting: %s = %s", key, raw)
+            return key.typ()(raw)
         except (ValueError, TypeError):
             logger.warning(
-                f"The settingsvalue {value} couldn't be fetched with correct typ",
+                f"The settingsvalue {key} couldn't be fetched with correct typ",
             )
-            return value.default
-
-    def set(self, settingKey: SettingsKey, value: float | bool | Path | str) -> None:
-        """Set the setting to value."""
-        # if isinstance(value, SettingsKey.type):
-        self.setValue(settingKey, value)
-        logger.info("Saved the Setting %s = %s", settingKey, value)
-        # else:
-        #     logger.error("trying to save setting with wrong type not possible")
+            return key.default
+
+    def set(
+        self,
+        key: SettingsKey | str,
+        value: float | bool | Path | str,
+        local: bool = False,
+    ) -> None:
+        """Set the setting to value.
+
+        Parameters
+        ----------
+        local
+            True saves local project specific settings.
+            Defaults to False
+            The local settings are meant to be set in the first sheet ``settings``
+
+        """
+        if local:
+            if key in SettingsKey:
+                self.localSettings[key] = value
+                logger.info("Saved the project setting %s = %s", key, value)
+            else:
+                logger.warning("got invalid local Setting %s = %s", key, value)
+            return
+        if not local and isinstance(key, SettingsKey):
+            if not isinstance(value, key.typ()):
+                logger.error("trying to save setting with wrong type not possible")
+                return
+            self.setValue(key.full, value)
+            logger.info("Saved the global setting %s = %s", key, value)
 
     def setSpreadsheet(self, sheet: Path) -> None:
         """Save spreadsheet path and emit the changed event."""

{excel2moodle-0.3.5.dist-info → excel2moodle-0.3.7.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: excel2moodle
-Version: 0.3.5
+Version: 0.3.7
 Summary: A package for converting questions from a spreadsheet, to valid moodle-xml
 Author: Jakob Bosse
 License-Expression: GPL-3.0-or-later
 Project-URL: Repository, https://gitlab.com/jbosse3/excel2moodle.git
 Project-URL: Documentation, https://jbosse3.gitlab.io/excel2moodle
-Keywords: moodle,XML,teaching,question,converter
+Keywords: moodle,XML,teaching,question,converter,open educational Ressource
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10

excel2moodle-0.3.7.dist-info/RECORD

@@ -0,0 +1,37 @@
+excel2moodle/__init__.py,sha256=SUSyvbQCcfOtTr00HvHpjziNy-flEdWanVFCM9F9yX0,2223
+excel2moodle/__main__.py,sha256=VGOlPEmC4bhNNIt8uuuG80DZ5unUvPjm1PoVf0yH1FA,756
+excel2moodle/logger.py,sha256=WomQ_EAiqZ2oVHNReG4KdfGRMrJl3jC3LIr8cbvOlbY,3084
+excel2moodle/core/__init__.py,sha256=H4Bt6u076RKb6BH5F58nHLQvYPDUoayosM_Onyr9yT0,398
+excel2moodle/core/category.py,sha256=QIl8nh1ryvlVMtNy8hWRfhZZMgGOhQZ3rwDFqf4woa4,1809
+excel2moodle/core/dataStructure.py,sha256=krsoifn6fUDBcbp8CHRAvL8Zfbm1nAXwjoESK_2Jeh8,13052
+excel2moodle/core/etHelpers.py,sha256=i8DAx7YBxrQqzbXFsU-pIvYMPHSRhYci-JvuzY1MzeI,2299
+excel2moodle/core/exceptions.py,sha256=VgbxrnoR9RRnmDYK2rbB_Bv00r7NLWET6FgddPwo3uw,748
+excel2moodle/core/globals.py,sha256=cB5kstn57UYYiUJgLxNnqAGNAKVTolUjHPTt7XIA4G8,3294
+excel2moodle/core/numericMultiQ.py,sha256=vr-gYogu2sf2a_Bhvhnu1ZSZFZXM32MfhJesjTkoOQM,2618
+excel2moodle/core/parser.py,sha256=eVSHUihgW_Zk-mIffGL1kWJnHeSn9J76MfrgOzg0gNg,8991
+excel2moodle/core/question.py,sha256=gF7dbbNgchoBWSti_kWlAHW17REYc5jpdtTjmNl2iU8,7157
+excel2moodle/core/questionWriter.py,sha256=UiWbrtNSiQiYY_x3sF3nz6Ic0b_lL0uWHyeDNDtFvPM,10985
+excel2moodle/core/stringHelpers.py,sha256=P7xr5LM2r7qfKzEPBVUSMMDsiVB6jpFAUuhOhGkOMQY,2284
+excel2moodle/core/validator.py,sha256=-ogarWJ1tNrWg457SZtfDqwc8ToDAxgyLM6GW4rvI7g,4829
+excel2moodle/extra/__init__.py,sha256=PM-id60HD21A3IcGC_fCYFihS8osBGZMIJCcN-ZRsIM,293
+excel2moodle/extra/equationVerification.py,sha256=GLJl1r90d8AAiNy0H2hooZrg3D6aEwNfifYKAe3aGxM,3921
+excel2moodle/question_types/__init__.py,sha256=ZYGg_tYop9c5yUfN8St6FddeaDxbyE2hneKKUFVzcGM,955
+excel2moodle/question_types/mc.py,sha256=N0BREdzg6jcVq1CZMg_G8L4yAU1_1QKeDMaMrfmOBCU,3151
+excel2moodle/question_types/nf.py,sha256=r1qSqYl31yUrmvzUxs2Dkkn3pBmFGN1aO7HQYIoOqkA,835
+excel2moodle/question_types/nfm.py,sha256=gv3LvB6M9UI6U2PlpGerGlDVXzz4TZEudc8IsqdIru0,3301
+excel2moodle/ui/__init__.py,sha256=4EdGtpzwH3rgw4xW9E5x9kdPQYwKbo9rehHRZTNxCrQ,44
+excel2moodle/ui/appUi.py,sha256=sZ92bS1DBgoK3Chg1Nu_FQ2ry3Iu_ITKgpwqt4zLVAk,10582
+excel2moodle/ui/dialogs.py,sha256=HkIe3CgSpBb_shbnNEfNJs82OVm1xUA53dsjDE8wwO0,5395
+excel2moodle/ui/questionPreviewDialog.py,sha256=_rJvz1GM90aNnj3P6SugEezK7JW6m74ZALgkChohWLM,4980
+excel2moodle/ui/settings.py,sha256=XRnCUgYrF9cz_bv91Zj965SJw3vJ0QlS0dgzzGeee-Y,6331
+excel2moodle/ui/treewidget.py,sha256=mTRqmZHMZT3QTTvt5Gw9L-yl4KdhhulkF7O1KBwW-_E,2449
+excel2moodle/ui/variantDialog.py,sha256=snVaF3_YAc7NWjMRg7NzbjL_PzNbOpt4eiqElkE46io,5414
+excel2moodle/ui/windowDoc.py,sha256=IciZpwrLnGzIQV1aCdKQBg6km3oufHGs8havTFzNJyU,1055
+excel2moodle/ui/windowEquationChecker.py,sha256=fLyal3sbJwpthWCAxLB5vbSFOX23JoivoYksNp3mZVY,7925
+excel2moodle/ui/windowMain.py,sha256=FsaApCyWgngnWPb46R8_01z8q4XeWxRFVqewSIt742c,19027
+excel2moodle-0.3.7.dist-info/licenses/LICENSE,sha256=ywQqe6Sitymkf2lV2NRcx_aGsaC-KbSl_EfEsRXmNRw,35135
+excel2moodle-0.3.7.dist-info/METADATA,sha256=RmY9IFvitRlUaI6EugujfhXdZe8IFAsUdpJBmp_Oq-o,2972
+excel2moodle-0.3.7.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+excel2moodle-0.3.7.dist-info/entry_points.txt,sha256=myfMLDThuGgWHMJDPPfILiZqo_7D3fhmDdJGqWOAjPw,60
+excel2moodle-0.3.7.dist-info/top_level.txt,sha256=5V1xRUQ9o7UmOCmNoWCZPAuy5nXp3Qbzyqch8fUGT_c,13
+excel2moodle-0.3.7.dist-info/RECORD,,

{excel2moodle-0.3.5.dist-info → excel2moodle-0.3.7.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.4.0)
+Generator: setuptools (80.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any