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

excel2moodle/core/settings.py

@@ -0,0 +1,201 @@
+"""Settings module provides the adjusted subclass of ``PySide6.QtCore.QSettings``."""
+
+import logging
+from enum import StrEnum
+from pathlib import Path
+from typing import ClassVar, Literal, overload
+
+from PySide6.QtCore import QSettings, QTimer, Signal
+
+import excel2moodle
+
+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 = "defaultQuestionVariant", "testgen", int, 0
+    INCLUDEINCATS = "includeCats", "testgen", bool, False
+    TOLERANCE = "tolerance", "parser/nf", int, 1
+    PICTUREFOLDER = "pictureFolder", "core", Path, None
+    SPREADSHEETFOLDER = "spreadsheetFolder", "core", Path, None
+    LOGLEVEL = "loglevel", "core", str, "INFO"
+    LOGFILE = "logfile", "core", str, "excel2moodleLogFile.log"
+    CATEGORIESSHEET = "categoriesSheet", "core", str, "Kategorien"
+    VERSION = "version", "project", int, 1
+    POINTS = "points", "project", float, 1.0
+    PICTURESUBFOLDER = "imgFolder", "project", str, "Abbildungen"
+    PICTUREWIDTH = "imgWidth", "project", int, 500
+    ANSPICWIDTH = "answerImgWidth", "project", int, 120
+
+
+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 excel2moodle.isMainState():
+            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(300, self._emitSpreadsheetChanged)
+
+    def _emitSpreadsheetChanged(self) -> None:
+        self.shPathChanged.emit(self.sheet)
+
+    @overload
+    def get(
+        self,
+        key: Literal[
+            SettingsKey.QUESTIONVARIANT,
+            SettingsKey.TOLERANCE,
+            SettingsKey.VERSION,
+            SettingsKey.POINTS,
+            SettingsKey.PICTUREWIDTH,
+            SettingsKey.ANSPICWIDTH,
+        ],
+    ) -> int: ...
+    @overload
+    def get(self, key: Literal[SettingsKey.INCLUDEINCATS]) -> bool: ...
+    @overload
+    def get(
+        self,
+        key: Literal[
+            SettingsKey.PICTURESUBFOLDER,
+            SettingsKey.LOGLEVEL,
+            SettingsKey.LOGFILE,
+            SettingsKey.CATEGORIESSHEET,
+        ],
+    ) -> str: ...
+    @overload
+    def get(
+        self,
+        key: Literal[SettingsKey.PICTUREFOLDER, SettingsKey.SPREADSHEETFOLDER],
+    ) -> Path: ...
+
+    def get(self, key: SettingsKey):
+        """Get the typesafe settings value.
+
+        If local Settings are stored, they are returned.
+        If no setting is made, the default value is returned.
+        """
+        if key in self.localSettings:
+            val = key.typ()(self.localSettings[key])
+            logger.debug("Returning project setting: %s = %s", key, val)
+            return val
+        if not excel2moodle.isMainState():
+            logger.warning("No GUI: Returning default value.")
+            return key.default
+        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 {key} couldn't be fetched with correct typ",
+                )
+                return key.default
+            logger.debug("Returning path setting: %s = %s", key, path)
+            return path
+        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:
+            logger.debug("Returning global setting: %s = %s", key, raw)
+            return key.typ()(raw)
+        except (ValueError, TypeError):
+            logger.warning(
+                f"The settingsvalue {key} couldn't be fetched with correct typ",
+            )
+            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 not excel2moodle.isMainState():
+            local = True
+        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."""
+        if isinstance(sheet, Path):
+            self.sheet = sheet.resolve(strict=True)
+            logpath = str(self.sheet.parent / "excel2moodleLogFile.log")
+            self.set(SettingsKey.LOGFILE, logpath)
+            self.set(SettingsKey.SPREADSHEETFOLDER, self.sheet)
+            self.shPathChanged.emit(sheet)
+            return

excel2moodle/core/stringHelpers.py

@@ -4,12 +4,15 @@ import base64
 from pathlib import Path
 
 import lxml.etree as ET
+from pandas import pandas
 
 
-def stripWhitespace(stringList):
-    stripped = []
-    for i in stringList:
-        s = i.strip()
+def getListFromStr(stringList: str | list[str]) -> list[str]:
+    """Get a python List of strings from a semi-colon separated string."""
+    stripped: list[str] = []
+    li = stringList if isinstance(stringList, list) else stringList.split(";")
+    for i in li:
+        s = i.strip() if not pandas.isna(i) else None
         if s:
             stripped.append(s)
     return stripped
@@ -20,32 +23,6 @@ def stringToFloat(string: str) -> float:
     return float(string)
 
 
-def get_bullet_string(s):
-    """Formatiert die Angaben zum Statischen System hübsch."""
-    split = s.split(";")
-    s_spl = stripWhitespace(split)
-    name = []
-    var = []
-    quant = []
-    unit = []
-    for sc in s_spl:
-        sc_split = sc.split()
-        name.append(sc_split[0])
-        var.append(sc_split[1])
-        quant.append(sc_split[3])
-        unit.append(sc_split[4])
-    bulletString = ['</p><ul dir="ltr">']
-    for i in range(len(s_spl)):
-        num = quant[i].split(",")
-        num_s = f"{num[0]!s},\\!{num[1]!s}~" if len(num) == 2 else f"{num[0]!s},\\!0~"
-        bulletString.append('<li style="text-align: left;">')
-        bulletString.append(
-            f"{name[i]}: \\( {var[i]} = {num_s} \\mathrm{{ {unit[i]}  }}\\) </li>\n",
-        )
-    bulletString.append("<br></ul>")
-    return "\n".join(bulletString)
-
-
 def getBase64Img(imgPath):
     with open(imgPath, "rb") as img:
         return base64.b64encode(img.read()).decode("utf-8")
@@ -62,7 +39,7 @@ def getUnitsElementAsString(unit) -> None:
 
 
 def printDom(xmlElement: ET.Element, file: Path | None = None) -> None:
-    """Prints the document tree of ``xmlTree`` to the ``file``, if specified, else dumps to stdout."""
+    """Prints the document tree of ``xmlTree`` to ``file``, if specified, else dumps to stdout."""
     documentTree = ET.ElementTree(xmlElement)
     if file is not None:
         if file.parent.exists():
@@ -73,11 +50,11 @@ def printDom(xmlElement: ET.Element, file: Path | None = None) -> None:
                 pretty_print=True,
             )
     else:
-        pass
+        print(xmlElement.tostring())  # noqa: T201
 
 
 def texWrapper(text: str | list[str], style: str) -> list[str]:
-    r"""Puts the strings inside ``text`` into a LaTex environment.
+    r"""Put the strings inside ``text`` into a LaTex environment.
 
     if ``style == unit``: inside ``\\mathrm{}``
     if ``style == math``: inside ``\\( \\)``

excel2moodle/core/{questionValidator.py → validator.py}

@@ -16,11 +16,11 @@ import pandas as pd
 
 from excel2moodle.core.exceptions import InvalidFieldException
 from excel2moodle.core.globals import DFIndex
-from excel2moodle.core.question import Question
 
 if TYPE_CHECKING:
     from types import UnionType
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -30,25 +30,25 @@ class Validator:
     Creates a dictionary with the data, for easier access later.
     """
 
-    def __init__(self, category) -> None:
-        self.question: Question
-        self.category = category
-        self.mandatory: dict[DFIndex, type | UnionType] = {
+    def __init__(self) -> None:
+        self.allMandatory: dict[DFIndex, type | UnionType] = {
             DFIndex.TEXT: str,
             DFIndex.NAME: str,
             DFIndex.TYPE: str,
         }
-        self.optional: dict[DFIndex, type | UnionType] = {
-            DFIndex.BPOINTS: str,
+        self.allOptional: dict[DFIndex, type | UnionType] = {
             DFIndex.PICTURE: int | str,
         }
-        self.nfOpt: dict[DFIndex, type | UnionType] = {}
+        self.nfOpt: dict[DFIndex, type | UnionType] = {
+            DFIndex.BPOINTS: str,
+        }
         self.nfMand: dict[DFIndex, type | UnionType] = {
             DFIndex.RESULT: float | int,
         }
         self.nfmOpt: dict[DFIndex, type | UnionType] = {}
         self.nfmMand: dict[DFIndex, type | UnionType] = {
             DFIndex.RESULT: str,
+            DFIndex.BPOINTS: str,
         }
         self.mcOpt: dict[DFIndex, type | UnionType] = {}
         self.mcMand: dict[DFIndex, type | UnionType] = {
@@ -63,35 +63,41 @@ class Validator:
             "NFM": (self.nfmOpt, self.nfmMand),
         }
 
-    def setup(self, df: pd.Series, index: int) -> bool:
+    def setup(self, df: pd.Series, index: int) -> None:
         self.df = df
         self.index = index
+        self.mandatory = {}
+        self.optional = {}
         typ = self.df.loc[DFIndex.TYPE]
+        if typ not in self.mapper:
+            msg = f"No valid question type provided. {typ} is not a known type"
+            raise InvalidFieldException(msg, "index:02d", DFIndex.TYPE)
+        self.mandatory.update(self.allMandatory)
+        self.optional.update(self.allOptional)
         self.mandatory.update(self.mapper[typ][1])
         self.optional.update(self.mapper[typ][0])
-        return True
 
-    def validate(self) -> bool:
-        id = f"{self.category.id}{self.index:02d}"
+    def validate(self) -> None:
+        qid = f"{self.index:02d}"
         checker, missing = self._mandatory()
         if not checker:
-            msg = f"Question {id} misses the key {missing}"
+            msg = f"Question {qid} misses the key {missing}"
             if missing is not None:
-                raise InvalidFieldException(msg, id, missing)
+                raise InvalidFieldException(msg, qid, missing)
         checker, missing = self._typeCheck()
         if not checker:
-            msg = f"Question {id} has wrong typed data {missing}"
+            msg = f"Question {qid} has wrong typed data {missing}"
             if missing is not None:
-                raise InvalidFieldException(msg, id, missing)
-        self._getQuestion()
-        self._getData()
-        return True
+                raise InvalidFieldException(msg, qid, missing)
 
-    def _getData(self) -> None:
+    def getQuestionRawData(self) -> dict[str, str | float | list[str]]:
+        """Get the data from the spreadsheet as a dictionary."""
         self.qdata: dict[str, str | float | int | list] = {}
         for idx, val in self.df.items():
             if not isinstance(idx, str):
                 continue
+            if pd.isna(val):
+                continue
             if idx in self.qdata:
                 if isinstance(self.qdata[idx], list):
                     self.qdata[idx].append(val)
@@ -100,6 +106,7 @@ class Validator:
                     self.qdata[idx] = [existing, val]
             else:
                 self.qdata[idx] = val
+        return self.qdata
 
     def _mandatory(self) -> tuple[bool, DFIndex | None]:
         """Detects if all keys of mandatory are filled with values."""
@@ -119,26 +126,17 @@ class Validator:
     def _typeCheck(self) -> tuple[bool, list[DFIndex] | None]:
         invalid: list[DFIndex] = []
         for field, typ in self.mandatory.items():
-            if isinstance(self.df[field], pd.Series):
+            if field in self.df and isinstance(self.df[field], pd.Series):
                 for f in self.df[field]:
                     if pd.notna(f) and not isinstance(f, typ):
                         invalid.append(field)
             elif not isinstance(self.df[field], typ):
                 invalid.append(field)
         for field, typ in self.optional.items():
-            if field in self.df:
-                if not isinstance(self.df[field], typ) and pd.notna(self.df[field]):
-                    invalid.append(field)
+            if field in self.df and isinstance(self.df[field], pd.Series):
+                for f in self.df[field]:
+                    if pd.notna(f) and not isinstance(f, typ):
+                        invalid.append(field)
         if len(invalid) == 0:
             return True, None
         return False, invalid
-
-    def _getQuestion(self) -> None:
-        name = self.df[DFIndex.NAME]
-        qtype = self.df[DFIndex.TYPE]
-        self.question = Question(
-            self.category,
-            name=str(name),
-            number=self.index,
-            qtype=str(qtype),
-        )

excel2moodle/logger.py

@@ -8,7 +8,7 @@ import logging
 
 from PySide6.QtCore import QObject, Signal
 
-from excel2moodle.ui.settings import Settings, SettingsKey
+from excel2moodle.core.settings import Settings, SettingsKey
 
 settings = Settings()
 

excel2moodle/question_types/__init__.py

@@ -0,0 +1,33 @@
+"""Implementations of all different question types.
+
+For each question type supported by excel2moodle here are the implementations.
+Two classes need to be defined for each type:
+
+* The Question class subclassing core.Question()
+* The Parser class subclassing core.Parser()
+
+Both go into a module named ``excel2moodle.question_types.type.py``
+"""
+
+from enum import Enum
+
+from excel2moodle.core.category import Category
+from excel2moodle.question_types.mc import MCQuestion
+from excel2moodle.question_types.nf import NFQuestion
+from excel2moodle.question_types.nfm import NFMQuestion
+
+
+class QuestionTypeMapping(Enum):
+    """The Mapping between question-types name and the classes."""
+
+    MC = MCQuestion
+    NF = NFQuestion
+    NFM = NFMQuestion
+
+    def create(
+        self,
+        category: Category,
+        questionData: dict[str, str | int | float | list[str]],
+        **kwargs,
+    ):
+        return self.value(category, questionData, **kwargs)

excel2moodle/question_types/mc.py

@@ -0,0 +1,127 @@
+"""Multiple choice Question implementation."""
+
+from typing import ClassVar
+
+import lxml.etree as ET
+
+import excel2moodle.core.etHelpers as eth
+from excel2moodle.core import stringHelpers
+from excel2moodle.core.exceptions import InvalidFieldException
+from excel2moodle.core.globals import (
+    DFIndex,
+    TextElements,
+    XMLTags,
+    feedbackStr,
+)
+from excel2moodle.core.parser import QuestionParser
+from excel2moodle.core.question import Picture, Question
+from excel2moodle.core.settings import SettingsKey
+
+
+class MCQuestion(Question):
+    """Multiple-choice Question Implementation."""
+
+    standardTags: ClassVar[dict[str, str | float]] = {
+        "single": "false",
+        "shuffleanswers": "true",
+        "answernumbering": "abc",
+        "showstandardinstruction": "0",
+        "shownumcorrect": "",
+    }
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.AnsStyles = ["math", "unit", "text", "picture"]
+
+
+class MCQuestionParser(QuestionParser):
+    """Parser for the multiple choice Question."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.genFeedbacks = [
+            XMLTags.CORFEEDB,
+            XMLTags.PCORFEEDB,
+            XMLTags.INCORFEEDB,
+        ]
+
+    def setup(self, question: MCQuestion) -> None:
+        self.question: MCQuestion = question
+        super().setup(question)
+
+    def getAnsElementsList(
+        self,
+        answerList: list,
+        fraction: float = 50,
+        format="html",
+    ) -> list[ET.Element]:
+        elementList: list[ET.Element] = []
+        for i, ans in enumerate(answerList):
+            p = TextElements.PLEFT.create()
+            if self.answerType == "picture":
+                p.append(ans)
+            else:
+                p.text = str(ans)
+            text = eth.getCdatTxtElement(p)
+            elementList.append(
+                ET.Element(XMLTags.ANSWER, fraction=str(fraction), format=format),
+            )
+            elementList[-1].append(text)
+            if fraction < 0:
+                elementList[-1].append(
+                    eth.getFeedBEle(
+                        XMLTags.ANSFEEDBACK,
+                        text=feedbackStr["wrong"],
+                        style=TextElements.SPANRED,
+                    ),
+                )
+                if self.answerType == "picture":
+                    elementList[-1].append(self.falseImgs[i].element)
+            elif fraction > 0:
+                elementList[-1].append(
+                    eth.getFeedBEle(
+                        XMLTags.ANSFEEDBACK,
+                        text=feedbackStr["right"],
+                        style=TextElements.SPANGREEN,
+                    ),
+                )
+                if self.answerType == "picture":
+                    elementList[-1].append(self.trueImgs[i].element)
+        return elementList
+
+    def setAnswers(self) -> list[ET.Element]:
+        self.answerType = self.rawInput[DFIndex.ANSTYPE]
+        true = stringHelpers.getListFromStr(self.rawInput[DFIndex.TRUE])
+        false = stringHelpers.getListFromStr(self.rawInput[DFIndex.FALSE])
+        if self.answerType not in self.question.AnsStyles:
+            msg = f"The Answer style: {self.answerType} is not supported"
+            raise InvalidFieldException(msg, self.question.id, DFIndex.ANSTYPE)
+        if self.answerType == "picture":
+            f = self.settings.get(SettingsKey.PICTUREFOLDER)
+            imgFolder = (f / self.question.katName).resolve()
+            w = self.settings.get(SettingsKey.ANSPICWIDTH)
+            self.trueImgs: list[Picture] = [
+                Picture(t, imgFolder, self.question.id, width=w) for t in true
+            ]
+            self.falseImgs: list[Picture] = [
+                Picture(t, imgFolder, self.question.id, width=w) for t in false
+            ]
+            trueAnsList: list[str] = [pic.htmlTag for pic in self.trueImgs]
+            falseAList: list[str] = [pic.htmlTag for pic in self.falseImgs]
+        else:
+            trueAnsList: list[str] = stringHelpers.texWrapper(
+                true, style=self.answerType
+            )
+            self.logger.debug(f"got the following true answers \n {trueAnsList=}")
+            falseAList: list[str] = stringHelpers.texWrapper(
+                false, style=self.answerType
+            )
+            self.logger.debug(f"got the following false answers \n {falseAList=}")
+        truefrac = 1 / len(trueAnsList) * 100
+        falsefrac = 1 / len(falseAList) * (-100)
+        self.tmpEle.find(XMLTags.PENALTY).text = str(round(truefrac / 100, 4))
+        ansList = self.getAnsElementsList(trueAnsList, fraction=round(truefrac, 4))
+        ansList.extend(
+            self.getAnsElementsList(falseAList, fraction=round(falsefrac, 4)),
+        )
+        return ansList

excel2moodle/question_types/nf.py

@@ -0,0 +1,29 @@
+"""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] = []
+        ansEle.append(self.getNumericAnsElement(result=result))
+        return ansEle