excel2moodle 0.4.1__py3-none-any.whl → 0.4.3__py3-none-any.whl

excel2moodle/__init__.py

@@ -48,11 +48,4 @@ if __package__ is not None:
     }
 
 
-isMain: bool = False
-
 mainLogger = logging.getLogger(__name__)
-
-
-def isMainState() -> bool:
-    mainLogger.debug("Returning mainState %s", isMain)
-    return isMain

excel2moodle/__main__.py

@@ -9,7 +9,7 @@ from PySide6 import QtWidgets, sys
 import excel2moodle
 from excel2moodle import e2mMetadata, mainLogger
 from excel2moodle.core import dataStructure
-from excel2moodle.core.settings import Settings, SettingsKey
+from excel2moodle.core.settings import Settings, Tags
 from excel2moodle.logger import loggerConfig
 from excel2moodle.ui import appUi as ui
 
@@ -17,7 +17,7 @@ from excel2moodle.ui import appUi as ui
 def main() -> None:
     excel2moodle.isMain = True
     settings = Settings()
-    logfile = Path(settings.get(SettingsKey.LOGFILE)).resolve()
+    logfile = Path(settings.get(Tags.LOGFILE)).resolve()
     e2mMetadata["logfile"] = logfile
     if logfile.exists() and logfile.is_file():
         logfile.replace(f"{logfile}.old")

excel2moodle/core/__init__.py

@@ -1,11 +1 @@
 """These Modules are the heart of the excel2moodle Package."""
-
-# from pandas._config import config
-# from excel2moodle.core  import questionWriter
-# from  excel2moodle.core import stringHelpers
-# from excel2moodle.core import numericMultiQ
-# from excel2moodle.core import globals
-# from PySide6.QtCore import QObject, Signal
-# import logging as logging
-# from logging import config as logConfig
-#

excel2moodle/core/category.py

@@ -1,4 +1,5 @@
 import logging
+import re
 from typing import TYPE_CHECKING
 
 import lxml.etree as ET
@@ -15,7 +16,6 @@ class Category:
 
     def __init__(
         self,
-        n: int,
         name: str,
         description: str,
         dataframe: pd.DataFrame,
@@ -23,8 +23,9 @@ class Category:
         version: int = 0,
     ) -> None:
         """Instantiate a new Category object."""
-        self.n = n
         self.NAME = name
+        match = re.search(r"\d+$", self.NAME)
+        self.n: int = int(match.group(0)) if match else 99
         self.desc = str(description)
         self.dataframe: pd.DataFrame = dataframe
         self.points = points
@@ -56,6 +57,6 @@ class Category:
         info = ET.SubElement(header, "info", format="html")
         ET.SubElement(cat, "text").text = f"$module$/top/{self.NAME}"
         ET.SubElement(info, "text").text = str(self.desc)
-        ET.SubElement(header, "idnumber").text = str(self.n)
+        ET.SubElement(header, "idnumber").text = self.id
         ET.indent(header)
         return header

excel2moodle/core/dataStructure.py

@@ -4,6 +4,7 @@ At the heart is the class ``xmlTest``
 """
 
 import logging
+import sys
 from concurrent.futures import ProcessPoolExecutor, as_completed
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -16,12 +17,13 @@ from PySide6.QtCore import QObject, Signal
 from excel2moodle.core import stringHelpers
 from excel2moodle.core.category import Category
 from excel2moodle.core.exceptions import InvalidFieldException, QNotParsedException
-from excel2moodle.core.globals import DFIndex
+from excel2moodle.core.globals import Tags
 from excel2moodle.core.question import Question
-from excel2moodle.core.settings import Settings, SettingsKey
+from excel2moodle.core.settings import Settings
 from excel2moodle.core.validator import Validator
 from excel2moodle.logger import LogAdapterQuestionID
 from excel2moodle.question_types import QuestionTypeMapping
+from excel2moodle.question_types.cloze import ClozeQuestion, ClozeQuestionParser
 from excel2moodle.question_types.mc import MCQuestion, MCQuestionParser
 from excel2moodle.question_types.nf import NFQuestion, NFQuestionParser
 from excel2moodle.question_types.nfm import NFMQuestion, NFMQuestionParser
@@ -49,6 +51,7 @@ def processSheet(sheetPath: str, categoryName: str) -> pd.DataFrame:
         sheet_name=str(categoryName),
         index_col=0,
         header=None,
+        engine="calamine",
     )
 
 
@@ -64,6 +67,7 @@ class QuestionDB:
     nfParser: NFQuestionParser = NFQuestionParser()
     nfmParser: NFMQuestionParser = NFMQuestionParser()
     mcParser: MCQuestionParser = MCQuestionParser()
+    clozeParser: ClozeQuestionParser = ClozeQuestionParser()
 
     def __init__(self, settings: Settings) -> None:
         self.settings = settings
@@ -72,7 +76,18 @@ class QuestionDB:
         self.categoriesMetaData: pd.DataFrame
         self.categories: dict[str, Category]
 
-    def readCategoriesMetadata(self, sheetPath: Path) -> None:
+    @property
+    def spreadsheet(self) -> Path:
+        return self._spreadsheet
+
+    @spreadsheet.setter
+    def spreadsheet(self, sheet) -> None:
+        self.settings.clear()
+        self._spreadsheet = sheet
+        self.settings.set(Tags.SPREADSHEETPATH, sheet)
+        logger.info("saved new spreadsheet %s", sheet)
+
+    def readCategoriesMetadata(self, sheetPath: Path | None = None) -> pd.DataFrame:
         """Read the metadata and questions from the spreadsheet.
 
         Get the category data from the spreadsheet and stores it in the
@@ -80,31 +95,56 @@ class QuestionDB:
         Setup the categories and store them  in ``self.categories = {}``
         Pass the question data to the categories.
         """
+        sheetPath = sheetPath if sheetPath else self.spreadsheet
         logger.info("Start Parsing the Excel Metadata Sheet\n")
         with Path(sheetPath).open("rb") as f:
             settingDf = pd.read_excel(
                 f,
                 sheet_name="settings",
                 index_col=0,
+                engine="calamine",
             )
             logger.debug("Found the settings: \n\t%s", settingDf)
-            self._setProjectSettings(settingDf)
+            self._setProjectSettings(settingDf, mainPath=sheetPath.parent)
         with Path(sheetPath).open("rb") as f:
             self.categoriesMetaData = pd.read_excel(
                 f,
-                sheet_name=self.settings.get(SettingsKey.CATEGORIESSHEET),
+                sheet_name=self.settings.get(Tags.CATEGORIESSHEET),
                 index_col=0,
+                engine="calamine",
             )
             logger.info(
                 "Sucessfully read categoriesMetaData \n %s", self.categoriesMetaData
             )
+        return self.categoriesMetaData
 
-    def _setProjectSettings(self, settings: pd.DataFrame) -> None:
+    def _setProjectSettings(
+        self, settings: pd.DataFrame, mainPath: Path | None = None
+    ) -> None:
+        settings = self.harmonizeDFIndex(settings)
         for tag, value in settings.iterrows():
-            self.settings.set(tag, value.iloc[0], local=True)
+            value = value.iloc[0]
+            if tag == Tags.TOLERANCE:
+                tol = value if value <= 1 else value / 100
+                self.settings.set(Tags.TOLERANCE, tol)
+            else:
+                self.settings.set(tag, value)
+        if Tags.IMPORTMODULE in settings.index:
+            logger.warning(
+                "Appending: %s to sys.path. All names defined by it will be usable",
+                mainPath,
+            )
+            sys.path.append(str(mainPath))
+        imgFolder = self.settings.get(Tags.SPREADSHEETPATH).parent / self.settings.get(
+            Tags.PICTURESUBFOLDER
+        )
+        if Tags.PICTURESUBFOLDER not in settings.index:
+            logger.warning("You didn't specify an image Folder. This may cause errors.")
+        self.settings.set(Tags.PICTUREFOLDER, imgFolder.resolve())
 
-    def initAllCategories(self, sheetPath: Path) -> None:
+    def initAllCategories(self, sheetPath: Path | None = None) -> None:
         """Read all category sheets and initialize all Categories."""
+        sheetPath = sheetPath if sheetPath else self.spreadsheet
         if not hasattr(self, "categoriesMetaData"):
             logger.error("Can't process the Categories without Metadata")
             return
@@ -112,19 +152,19 @@ class QuestionDB:
             self.categories.clear()
         else:
             self.categories: dict[str, Category] = {}
-        with Path(sheetPath).open("rb") as f:
-            excelFile = pd.ExcelFile(f)
+        with pd.ExcelFile(sheetPath, engine="calamine") as excelFile:
             for categoryName in excelFile.sheet_names:
                 logger.debug("Starting to read category %s", categoryName)
-                if categoryName.startswith("KAT"):
-                    self.initCategory(sheetPath, categoryName)
+                if categoryName in self.categoriesMetaData.index:
+                    self.initCategory(categoryName, sheetPath=sheetPath)
 
-    def asyncInitAllCategories(self, sheetPath: Path) -> None:
+    def asyncInitAllCategories(self, sheetPath: Path | None = None) -> None:
         """Read all category sheets asynchron and initialize all Categories.
 
         It does the same as `initAllCategories` but the parsing of the excelfile
         is done asynchron via `concurrent.futures.ProcessPoolExecutor`
         """
+        sheetPath = sheetPath if sheetPath else self.spreadsheet
         if not hasattr(self, "categoriesMetaData"):
             logger.error("Can't process the Categories without Metadata")
             return
@@ -132,71 +172,86 @@ class QuestionDB:
             self.categories.clear()
         else:
             self.categories: dict[str, Category] = {}
-        sheet_names = []
-        with Path(sheetPath).open("rb") as f:
-            excel_file = pd.ExcelFile(f)
-            sheet_names = [
-                name for name in excel_file.sheet_names if name.startswith("KAT_")
+        sheetNames = []
+        with pd.ExcelFile(sheetPath, engine="calamine") as excelFile:
+            sheetNames = [
+                name
+                for name in excelFile.sheet_names
+                if name in self.categoriesMetaData.index
             ]
-        logger.debug("found those caetegory sheets: \n %s ", sheet_names)
+        logger.debug("found those category sheets: \n %s ", sheetNames)
         with ProcessPoolExecutor() as executor:
             futures = {
                 executor.submit(processSheet, str(sheetPath), sheet): sheet
-                for sheet in sheet_names
+                for sheet in sheetNames
             }
             for future in as_completed(futures):
                 categoryName = futures[future]
                 try:
                     categoryDataF = future.result()
-                    categoryNumber = int(categoryName[4:])
-                    self._setupCategory(categoryDataF, categoryName, categoryNumber)
+                    self._setupCategory(categoryDataF, categoryName)
                     logger.debug("Finished processing %s", categoryName)
                 except Exception as e:
                     logger.exception("Error processing sheet %s: %s", categoryName, e)
                     logger.debug("Future exception: %s", future.exception())
 
-    def initCategory(self, sheetPath: Path, categoryName: str) -> None:
-        """Read `categoryName` from the file ``sheetPath`` and initialize the category."""
-        categoryNumber = int(categoryName[4:])
+    def initCategory(
+        self, categoryName: str, sheetPath: Path | None = None
+    ) -> bool | Category:
+        """Read `categoryName` from the ``sheetPath`` and initialize the category.
+        Returns the Category and appends it to `self.categories`.
+        """
+        sheetPath = sheetPath if sheetPath else self.spreadsheet
         katDf = pd.read_excel(
             sheetPath,
             sheet_name=str(categoryName),
             index_col=0,
             header=None,
+            engine="calamine",
         )
         if not katDf.empty:
             logger.debug("Sucessfully read the Dataframe for cat %s", categoryName)
-            self._setupCategory(katDf, categoryName, categoryNumber)
-
-    def _setupCategory(
-        self, categoryDf: pd.DataFrame, categoryName: str, categoryNumber: int
-    ) -> None:
+            return self._setupCategory(katDf, categoryName)
+        return False
+
+    @staticmethod
+    def harmonizeDFIndex(dataframe: pd.DataFrame) -> pd.DataFrame:
+        """Convert the index strings to lowercase without whitespace."""
+        index = dataframe.index.str.lower()
+        harmonizedIdx = ["".join(i.split()) if pd.notna(i) else i for i in index]
+        dataframe.index = pd.Index(harmonizedIdx)
+        return dataframe
+
+    def _setupCategory(self, categoryDf: pd.DataFrame, categoryName: str) -> Category:
         """Setup the category from the ``dataframe``.
+
         :emits: categoryReady(self) Signal.
-        """  # noqa: D401
+        """
+        categoryDf = self.harmonizeDFIndex(categoryDf)
         points = (
-            self.categoriesMetaData["points"].iloc[categoryNumber - 1]
+            self.categoriesMetaData["points"].loc[categoryName]
             if "points" in self.categoriesMetaData
-            and not pd.isna(self.categoriesMetaData["points"]).iloc[categoryNumber - 1]
-            else self.settings.get(SettingsKey.POINTS)
+            and not pd.isna(self.categoriesMetaData["points"]).loc[categoryName]
+            else self.settings.get(Tags.POINTS)
         )
         version = (
-            self.categoriesMetaData["version"].iloc[categoryNumber - 1]
+            self.categoriesMetaData["version"].loc[categoryName]
             if "version" in self.categoriesMetaData
-            and not pd.isna(self.categoriesMetaData["version"].iloc[categoryNumber - 1])
-            else self.settings.get(SettingsKey.VERSION)
+            and not pd.isna(self.categoriesMetaData["version"].loc[categoryName])
+            else self.settings.get(Tags.VERSION)
         )
         category = Category(
-            categoryNumber,
             categoryName,
-            self.categoriesMetaData["description"].iloc[categoryNumber - 1],
+            self.categoriesMetaData["description"].loc[categoryName],
             dataframe=categoryDf,
             points=points,
             version=version,
         )
-        self.categories[categoryName] = category
+        if hasattr(self, "categories"):
+            self.categories[categoryName] = category
+            self.signals.categoryReady.emit(category)
         logger.debug("Category %s is initialized", categoryName)
-        self.signals.categoryReady.emit(category)
+        return category
 
     def parseAllQuestions(self) -> None:
         """Parse all question from all categories.
@@ -214,13 +269,12 @@ class QuestionDB:
         for qNum in category.dataframe.columns:
             try:
                 self.setupAndParseQuestion(category, qNum)
-            except (InvalidFieldException, QNotParsedException, ValueError) as e:
+            except (InvalidFieldException, QNotParsedException):
                 logger.exception(
                     "Question %s%02d couldn't be parsed. The Question Data: \n %s",
                     category.id,
                     qNum,
                     category.dataframe[qNum],
-                    exc_info=e,
                 )
         self.signals.categoryQuestionsReady.emit(category)
 
@@ -255,30 +309,33 @@ class QuestionDB:
             raise QNotParsedException(msg, f"{category.id}{qNumber}")
         cls.validator.setup(qdat, qNumber)
         cls.validator.validate()
-        validData = cls.validator.getQuestionRawData()
-        qtype: str = str(validData.get(DFIndex.TYPE))
-        category.questions[qNumber] = QuestionTypeMapping[qtype].create(
-            category, validData
-        )
-        question = category.questions[qNumber]
-        if question.element is not None:
+        validData = cls.validator.getQuestionData()
+        qtype: str = validData.get(Tags.TYPE)
+        logger.debug("Question type is: %s", qtype)
+        question = QuestionTypeMapping[qtype].create(category, validData)
+        if question.isParsed:
             locallogger.info("Question already parsed")
             return
         if isinstance(question, NFQuestion):
             cls.nfParser.setup(question)
-            cls.nfParser.parse()
             locallogger.debug("setup a new NF parser ")
+            cls.nfParser.parse()
         elif isinstance(question, MCQuestion):
             cls.mcParser.setup(question)
-            cls.mcParser.parse()
             locallogger.debug("setup a new MC parser ")
+            cls.mcParser.parse()
         elif isinstance(question, NFMQuestion):
             cls.nfmParser.setup(question)
-            cls.nfmParser.parse()
             locallogger.debug("setup a new NFM parser ")
+            cls.nfmParser.parse()
+        elif isinstance(question, ClozeQuestion):
+            cls.clozeParser.setup(question)
+            locallogger.debug("setup a new CLOZE parser")
+            cls.clozeParser.parse()
         else:
             msg = "couldn't setup Parser"
             raise QNotParsedException(msg, question.id)
+        category.questions[qNumber] = question
 
     def appendQuestions(
         self, questions: list[QuestionItem], file: Path | None = None
@@ -293,15 +350,15 @@ class QuestionDB:
                 catdict[cat] = []
             catdict[cat].append(q.getQuestion())
         for cat, qlist in catdict.items():
-            self.appendQElements(
+            self._appendQElements(
                 cat,
                 qlist,
                 tree=tree,
-                includeHeader=self.settings.get(SettingsKey.INCLUDEINCATS),
+                includeHeader=self.settings.get(Tags.INCLUDEINCATS),
             )
         stringHelpers.printDom(tree, file=file)
 
-    def appendQElements(
+    def _appendQElements(
         self,
         cat: Category,
         qList: list[Question],
@@ -311,9 +368,9 @@ class QuestionDB:
         if includeHeader:
             tree.append(cat.getCategoryHeader())
             logger.debug(f"Appended a new category item {cat=}")
-        variant: int = self.settings.get(SettingsKey.QUESTIONVARIANT)
+        variant: int = self.settings.get(Tags.QUESTIONVARIANT)
         for q in qList:
-            if q.variants is not None:
+            if hasattr(q, "variants") and q.variants is not None:
                 if variant == 0 or variant > q.variants:
                     dialog = QuestionVariantDialog(self.window, q)
                     if dialog.exec() == QtWidgets.QDialog.Accepted:
@@ -321,7 +378,5 @@ class QuestionDB:
                         logger.debug("Die Fragen-Variante %s wurde gewählt", variant)
                     else:
                         logger.warning("Keine Fragenvariante wurde gewählt.")
-                q.assemble(variant)
-            else:
-                q.assemble()
+            q.assemble(variant=variant)
             tree.append(q.element)

excel2moodle/core/etHelpers.py

@@ -8,7 +8,7 @@ import lxml.etree as ET
 import excel2moodle.core.etHelpers as eth
 from excel2moodle.core.globals import TextElements, feedbackStr, feedBElements
 
-from .globals import DFIndex, XMLTags
+from .globals import Tags, XMLTags
 
 
 def getElement(eleName: str, text: str, **attribs) -> ET.Element:
@@ -27,7 +27,7 @@ def getElement(eleName: str, text: str, **attribs) -> ET.Element:
     return toEle
 
 
-def getTextElement(eleName: str, text: str | DFIndex, **attribs) -> ET.Element:
+def getTextElement(eleName: str, text: str | Tags, **attribs) -> ET.Element:
     """Creates two nested elements: ``eleName`` with child ``text`` which holds the text."""
     toEle = ET.Element(eleName, **attribs)
     child = getElement("text", text)

excel2moodle/core/exceptions.py

@@ -1,4 +1,4 @@
-from excel2moodle.core.globals import DFIndex
+from excel2moodle.core.globals import Tags
 
 
 class QNotParsedException(Exception):
@@ -18,7 +18,7 @@ class InvalidFieldException(Exception):
         self,
         message: str,
         qID: str,
-        field: DFIndex | list[DFIndex],
+        field: Tags | list[Tags],
         *args: object,
         **kwargs,
     ) -> None:

excel2moodle/core/globals.py

@@ -2,33 +2,16 @@ from enum import Enum, StrEnum
 
 import lxml.etree as ET
 
-questionTypes = {
+from excel2moodle.core.settings import Tags
+
+QUESTION_TYPES = {
     "NF": "numerical",
     "NFM": "numerical",
     "MC": "multichoice",
+    "CLOZE": "cloze",
 }
 
 
-class DFIndex(StrEnum):
-    """The identifier string for for the spreadsheet and the string for the xml-tag.
-
-    Each enum corresponds to a list of two values.
-    The first Value is the index in the spreadsheet, the second is the name of the xml-tag
-    """
-
-    TEXT = "text"
-    BPOINTS = "bulletPoint"
-    TRUE = "true"
-    FALSE = "false"
-    TYPE = "type"
-    NAME = "name"
-    RESULT = "result"
-    PICTURE = "picture"
-    NUMBER = "number"
-    ANSTYPE = "answerType"
-    TOLERANCE = "tolerance"
-
-
 class TextElements(Enum):
     PLEFT = "p", "text-align: left;"
     SPANRED = "span", "color: rgb(239, 69, 64)"
@@ -58,15 +41,15 @@ class TextElements(Enum):
 
 
 class XMLTags(StrEnum):
-    def __new__(cls, value: str, dfkey: DFIndex | None = None):
+    def __new__(cls, value: str, dfkey: Tags | None = None):
         obj = str.__new__(cls, value)
         obj._value_ = value
         if dfkey is not None:
             obj._dfkey_ = dfkey
         return obj
 
-    def __init__(self, _: str, dfkey: DFIndex | None = None, getEle=None) -> None:
-        if isinstance(dfkey, DFIndex):
+    def __init__(self, _: str, dfkey: Tags | None = None, getEle=None) -> None:
+        if isinstance(dfkey, Tags):
             self._dfkey_: str = dfkey
         if getEle:
             self._getEle_: object = getEle
@@ -85,11 +68,11 @@ class XMLTags(StrEnum):
             msg.append(f"Df Key {self.dfkey=}")
         return "\n".join(msg)
 
-    NAME = "name", DFIndex.NAME
-    QTEXT = "questiontext", DFIndex.TEXT
+    NAME = "name", Tags.NAME
+    QTEXT = "questiontext", Tags.TEXT
     QUESTION = "question"
     TEXT = "text"
-    PICTURE = "file", DFIndex.PICTURE
+    PICTURE = "file", Tags.PICTURE
     GENFEEDB = "generalfeedback"
     CORFEEDB = "correctfeedback"
     PCORFEEDB = "partialcorrectfeedback"