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

excel2moodle/core/settings.py

@@ -5,16 +5,13 @@ 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.
+class Tags(StrEnum):
+    """Tags and Settings Keys are needed to always acess the correct Value.
 
+    The Tags can be used to acess the settings or the QuestionData respectively.
     As the QSettings settings are accesed via strings, which could easily gotten wrong.
     Further, this Enum defines, which type a setting has to be.
     """
@@ -22,23 +19,27 @@ class SettingsKey(StrEnum):
     def __new__(
         cls,
         key: str,
-        place: str,
         typ: type,
         default: str | float | Path | bool | None,
+        place: str = "project",
     ):
         """Define new settings class."""
         obj = str.__new__(cls, key)
         obj._value_ = key
-        obj._place_ = place
-        obj._default_ = default
         obj._typ_ = typ
+        obj._default_ = default
+        obj._place_ = place
         return obj
 
     def __init__(
-        self, _, place: str, typ: type, default: str | float | Path | None
+        self,
+        _,
+        typ: type,
+        default: str | float | Path | None,
+        place: str = "project",
     ) -> None:
-        self._typ_ = typ
-        self._place_ = place
+        self._typ_: type = typ
+        self._place_: str = place
         self._default_ = default
         self._full_ = f"{self._place_}/{self._value_}"
 
@@ -56,88 +57,105 @@ class SettingsKey(StrEnum):
         return self._full_
 
     def typ(self) -> type:
-        """Get default value for the key."""
+        """Get type of the keys data."""
         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)
+    QUESTIONVARIANT = "defaultQuestionVariant", int, 1, "testgen"
+    INCLUDEINCATS = "includeCats", bool, False, "testgen"
+    TOLERANCE = "tolerance", float, 0.01, "parser/nf"
+    PICTUREFOLDER = "pictureFolder", Path, None, "core"
+    PICTURESUBFOLDER = "imgfolder", str, "Abbildungen", "project"
+    SPREADSHEETPATH = "spreadsheetFolder", Path, None, "core"
+    LOGLEVEL = "loglevel", str, "INFO", "core"
+    LOGFILE = "logfile", str, "excel2moodleLogFile.log", "core"
+    CATEGORIESSHEET = "categoriessheet", str, "Kategorien", "core"
+
+    IMPORTMODULE = "importmodule", str, None
+    TEXT = "text", list, None
+    BPOINTS = "bulletpoint", list, None
+    TRUE = "true", list, None
+    FALSE = "false", list, None
+    TYPE = "type", str, None
+    NAME = "name", str, None
+    RESULT = "result", float, None
+    EQUATION = "formula", str, None
+    PICTURE = "picture", str, None
+    NUMBER = "number", int, None
+    ANSTYPE = "answertype", str, None
+    QUESTIONPART = "part", list, None
+    PARTTYPE = "parttype", str, None
+    VERSION = "version", int, 1
+    POINTS = "points", float, 1.0
+    PICTUREWIDTH = "imgwidth", int, 500
+    ANSPICWIDTH = "answerimgwidth", int, 120
+    WRONGSIGNPERCENT = "wrongsignpercentage", int, 50
+    FIRSTRESULT = "firstresult", float, 0
+
+
+class Settings:
+    values: ClassVar[dict[str, str | float | Path]] = {}
+
+    @classmethod
+    def clear(cls) -> None:
+        cls.values.clear()
 
     @overload
+    @classmethod
     def get(
-        self,
+        cls,
+        key: Literal[Tags.POINTS],
+    ) -> float: ...
+    @overload
+    @classmethod
+    def get(
+        cls,
         key: Literal[
-            SettingsKey.QUESTIONVARIANT,
-            SettingsKey.TOLERANCE,
-            SettingsKey.VERSION,
-            SettingsKey.POINTS,
-            SettingsKey.PICTUREWIDTH,
-            SettingsKey.ANSPICWIDTH,
+            Tags.QUESTIONVARIANT,
+            Tags.TOLERANCE,
+            Tags.VERSION,
+            Tags.PICTUREWIDTH,
+            Tags.ANSPICWIDTH,
+            Tags.WRONGSIGNPERCENT,
         ],
     ) -> int: ...
     @overload
-    def get(self, key: Literal[SettingsKey.INCLUDEINCATS]) -> bool: ...
+    @classmethod
+    def get(cls, key: Literal[Tags.INCLUDEINCATS]) -> bool: ...
     @overload
+    @classmethod
     def get(
-        self,
+        cls,
         key: Literal[
-            SettingsKey.PICTURESUBFOLDER,
-            SettingsKey.LOGLEVEL,
-            SettingsKey.LOGFILE,
-            SettingsKey.CATEGORIESSHEET,
+            Tags.PICTURESUBFOLDER,
+            Tags.LOGLEVEL,
+            Tags.LOGFILE,
+            Tags.CATEGORIESSHEET,
+            Tags.IMPORTMODULE,
         ],
     ) -> str: ...
     @overload
+    @classmethod
     def get(
-        self,
-        key: Literal[SettingsKey.PICTUREFOLDER, SettingsKey.SPREADSHEETFOLDER],
+        cls,
+        key: Literal[Tags.PICTUREFOLDER, Tags.SPREADSHEETPATH],
     ) -> Path: ...
 
-    def get(self, key: SettingsKey):
+    @classmethod
+    def get(cls, key: Tags):
         """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
+        try:
+            raw = cls.values[key]
+        except KeyError:
+            default = key.default
+            if default is None:
+                return None
+            logger.info("Returning the default value for %s", key)
+            return default
         if key.typ() is Path:
-            path: Path = self.value(key.full, defaultValue=key.default)
+            path: Path = Path(raw)
             try:
                 path.resolve(strict=True)
             except ValueError:
@@ -147,10 +165,7 @@ class Settings(QSettings):
                 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(
@@ -158,44 +173,25 @@ class Settings(QSettings):
             )
             return key.default
 
+    @classmethod
     def set(
-        self,
-        key: SettingsKey | str,
+        cls,
+        key: Tags | 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")
+        """Set the setting to value."""
+        if key in Tags:
+            tag = Tags(key) if not isinstance(key, Tags) else key
+            try:
+                cls.values[tag] = tag.typ()(value)
+            except TypeError:
+                logger.exception(
+                    "trying to save %s = %s %s with wrong type not possible.",
+                    tag,
+                    value,
+                    type(value),
+                )
                 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
+            logger.info("Saved  %s = %s, type %s", key, value, tag.typ())
+        else:
+            logger.warning("got invalid local Setting %s = %s", key, value)

excel2moodle/core/validator.py

@@ -10,19 +10,20 @@ which can be accessed via ``Validator.question``
 """
 
 import logging
-from typing import TYPE_CHECKING
 
 import pandas as pd
 
+from excel2moodle.core import stringHelpers
 from excel2moodle.core.exceptions import InvalidFieldException
-from excel2moodle.core.globals import DFIndex
-
-if TYPE_CHECKING:
-    from types import UnionType
-
+from excel2moodle.core.globals import QUESTION_TYPES, Tags
+from excel2moodle.core.question import QuestionData
+from excel2moodle.core.settings import Settings
+from excel2moodle.question_types import QuestionTypeMapping
 
 logger = logging.getLogger(__name__)
 
+settings = Settings()
+
 
 class Validator:
     """Validate the question data from the spreadsheet.
@@ -30,52 +31,15 @@ class Validator:
     Creates a dictionary with the data, for easier access later.
     """
 
-    def __init__(self) -> None:
-        self.allMandatory: dict[DFIndex, type | UnionType] = {
-            DFIndex.TEXT: str,
-            DFIndex.NAME: str,
-            DFIndex.TYPE: str,
-        }
-        self.allOptional: dict[DFIndex, type | UnionType] = {
-            DFIndex.PICTURE: int | str,
-        }
-        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] = {
-            DFIndex.TRUE: str,
-            DFIndex.FALSE: str,
-            DFIndex.ANSTYPE: str,
-        }
-
-        self.mapper: dict = {
-            "NF": (self.nfOpt, self.nfMand),
-            "MC": (self.mcOpt, self.mcMand),
-            "NFM": (self.nfmOpt, self.nfmMand),
-        }
-
     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:
+        typ = self.df.loc[Tags.TYPE]
+        if typ not in QUESTION_TYPES:
             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])
+            raise InvalidFieldException(msg, "index:02d", Tags.TYPE)
+        self.mandatory = QuestionTypeMapping[typ].value.mandatoryTags
+        self.optional = QuestionTypeMapping[typ].value.optionalTags
 
     def validate(self) -> None:
         qid = f"{self.index:02d}"
@@ -90,9 +54,9 @@ class Validator:
             if missing is not None:
                 raise InvalidFieldException(msg, qid, missing)
 
-    def getQuestionRawData(self) -> dict[str, str | float | list[str]]:
+    def getQuestionData(self) -> QuestionData:
         """Get the data from the spreadsheet as a dictionary."""
-        self.qdata: dict[str, str | float | int | list] = {}
+        self.qdata: dict[str, int | float | list[str] | str] = {}
         for idx, val in self.df.items():
             if not isinstance(idx, str):
                 continue
@@ -106,9 +70,26 @@ class Validator:
                     self.qdata[idx] = [existing, val]
             else:
                 self.qdata[idx] = val
-        return self.qdata
-
-    def _mandatory(self) -> tuple[bool, DFIndex | None]:
+        return self.formatQData()
+
+    def formatQData(self) -> QuestionData:
+        """Format the dictionary to The types for QuestionData."""
+        listTags = (Tags.BPOINTS, Tags.TRUE, Tags.FALSE, Tags.TEXT, Tags.QUESTIONPART)
+        for tag in listTags:
+            for key in self.qdata:
+                if key.startswith(tag) and not isinstance(self.qdata[key], list):
+                    self.qdata[key] = stringHelpers.getListFromStr(self.qdata[key])
+        tol = float(self.qdata.get(Tags.TOLERANCE, 0))
+        if tol <= 0 or tol > 99:
+            self.qdata[Tags.TOLERANCE] = settings.get(Tags.TOLERANCE)
+        else:
+            self.qdata[Tags.TOLERANCE] = tol if tol < 1 else tol / 100
+
+        if self.qdata[Tags.TYPE] == "NFM":
+            self.qdata[Tags.EQUATION] = str(self.qdata[Tags.RESULT])
+        return QuestionData(self.qdata)
+
+    def _mandatory(self) -> tuple[bool, Tags | None]:
         """Detects if all keys of mandatory are filled with values."""
         checker = pd.Series.notna(self.df)
         for k in self.mandatory:
@@ -123,8 +104,8 @@ class Validator:
                 return False, k
         return True, None
 
-    def _typeCheck(self) -> tuple[bool, list[DFIndex] | None]:
-        invalid: list[DFIndex] = []
+    def _typeCheck(self) -> tuple[bool, list[Tags] | None]:
+        invalid: list[Tags] = []
         for field, typ in self.mandatory.items():
             if field in self.df and isinstance(self.df[field], pd.Series):
                 for f in self.df[field]:

excel2moodle/logger.py

@@ -6,10 +6,11 @@ This includes emitting the signals for the main Window, to fast forward all logs
 
 import logging
 
-from PySide6.QtCore import QObject, Signal
+from PySide6.QtCore import QObject, QSettings, Signal
 
-from excel2moodle.core.settings import Settings, SettingsKey
+from excel2moodle.core.settings import Settings, Tags
 
+qSettings = QSettings("jbosse3", "excel2moodle")
 settings = Settings()
 
 loggerConfig = {
@@ -36,7 +37,9 @@ loggerConfig = {
             "formatter": "file",
             "class": "logging.FileHandler",
             # "class": "logging.handlers.TimedRotatingFileHandler",
-            "filename": settings.get(SettingsKey.LOGFILE),
+            "filename": qSettings.value(
+                Tags.LOGFILE, defaultValue=Tags.LOGFILE.default
+            ),
             # "when": "M",
             # "interval": 1,
             # "backupCount": "3",
@@ -75,7 +78,7 @@ class LogWindowHandler(logging.Handler):
         log_format = "[%(levelname)s] %(module)s: %(message)s"
         self.formatter = logging.Formatter(log_format)
         self.setFormatter(self.formatter)
-        loglevel = settings.get(SettingsKey.LOGLEVEL)
+        loglevel = settings.get(Tags.LOGLEVEL)
         self.setLevel(loglevel)
         self.logLevelColors = {
             "DEBUG": "gray",

excel2moodle/question_types/__init__.py

@@ -12,6 +12,7 @@ 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.cloze import ClozeQuestion
 from excel2moodle.question_types.mc import MCQuestion
 from excel2moodle.question_types.nf import NFQuestion
 from excel2moodle.question_types.nfm import NFMQuestion
@@ -23,6 +24,7 @@ class QuestionTypeMapping(Enum):
     MC = MCQuestion
     NF = NFQuestion
     NFM = NFMQuestion
+    CLOZE = ClozeQuestion
 
     def create(
         self,