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

excel2moodle/__init__.py

@@ -25,13 +25,8 @@ Functionality
 """
 
 import logging
-import logging.config as logConfig
 from importlib import metadata
 from importlib.metadata import version
-from pathlib import Path
-
-from excel2moodle.logger import LogWindowHandler, loggerConfig
-from excel2moodle.ui.settings import Settings, SettingsKey
 
 try:
     __version__ = version("excel2moodle")
@@ -53,11 +48,11 @@ if __package__ is not None:
     }
 
 
-settings = Settings()
-logfile = Path(settings.get(SettingsKey.LOGFILE)).resolve()
-e2mMetadata["logfile"] = logfile
-if logfile.exists() and logfile.is_file():
-    logfile.replace(f"{logfile}.old")
+isMain: bool = False
 
 mainLogger = logging.getLogger(__name__)
-logConfig.dictConfig(config=loggerConfig)
+
+
+def isMainState() -> bool:
+    mainLogger.debug("Returning mainState %s", isMain)
+    return isMain

excel2moodle/__main__.py

@@ -1,13 +1,17 @@
 """Main Function to make the Package executable."""
 
+import logging.config as logConfig
 import signal
+from pathlib import Path
 
 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.logger import loggerConfig
 from excel2moodle.ui import appUi as ui
-from excel2moodle.ui.settings import Settings
 
 
 def main() -> None:
@@ -25,4 +29,12 @@ def main() -> None:
 
 
 if __name__ == "__main__":
+    excel2moodle.isMain = True
+    settings = Settings()
+    logfile = Path(settings.get(SettingsKey.LOGFILE)).resolve()
+    e2mMetadata["logfile"] = logfile
+    if logfile.exists() and logfile.is_file():
+        logfile.replace(f"{logfile}.old")
+
+    logConfig.dictConfig(config=loggerConfig)
     main()

excel2moodle/core/dataStructure.py

@@ -18,6 +18,7 @@ from excel2moodle.core.category import Category
 from excel2moodle.core.exceptions import InvalidFieldException, QNotParsedException
 from excel2moodle.core.globals import DFIndex
 from excel2moodle.core.question import Question
+from excel2moodle.core.settings import Settings, SettingsKey
 from excel2moodle.core.validator import Validator
 from excel2moodle.logger import LogAdapterQuestionID
 from excel2moodle.question_types import QuestionTypeMapping
@@ -25,7 +26,6 @@ from excel2moodle.question_types.mc import MCQuestion, MCQuestionParser
 from excel2moodle.question_types.nf import NFQuestion, NFQuestionParser
 from excel2moodle.question_types.nfm import NFMQuestion, NFMQuestionParser
 from excel2moodle.ui.dialogs import QuestionVariantDialog
-from excel2moodle.ui.settings import Settings, SettingsKey
 from excel2moodle.ui.treewidget import QuestionItem
 
 if TYPE_CHECKING:
@@ -93,10 +93,11 @@ class QuestionDB:
             self.categoriesMetaData = pd.read_excel(
                 f,
                 sheet_name=self.settings.get(SettingsKey.CATEGORIESSHEET),
-                usecols=["Kategorie", "Beschreibung", "Punkte", "Version"],
                 index_col=0,
             )
-            logger.info("Sucessfully read categoriesMetaData")
+            logger.info(
+                "Sucessfully read categoriesMetaData \n %s", self.categoriesMetaData
+            )
 
     def _setProjectSettings(self, settings: pd.DataFrame) -> None:
         for tag, value in settings.iterrows():
@@ -173,14 +174,22 @@ class QuestionDB:
         """Setup the category from the ``dataframe``.
         :emits: categoryReady(self) Signal.
         """  # noqa: D401
-        p = self.categoriesMetaData["Punkte"].iloc[categoryNumber - 1]
-        points = p if not pd.isna(p) else self.settings.get(SettingsKey.POINTS)
-        v = self.categoriesMetaData["Version"].iloc[categoryNumber - 1]
-        version = v if not pd.isna(v) else self.settings.get(SettingsKey.VERSION)
+        points = (
+            self.categoriesMetaData["points"].iloc[categoryNumber - 1]
+            if "points" in self.categoriesMetaData
+            and not pd.isna(self.categoriesMetaData["points"]).iloc[categoryNumber - 1]
+            else self.settings.get(SettingsKey.POINTS)
+        )
+        version = (
+            self.categoriesMetaData["version"].iloc[categoryNumber - 1]
+            if "version" in self.categoriesMetaData
+            and not pd.isna(self.categoriesMetaData["version"].iloc[categoryNumber - 1])
+            else self.settings.get(SettingsKey.VERSION)
+        )
         category = Category(
             categoryNumber,
             categoryName,
-            self.categoriesMetaData["Beschreibung"].iloc[categoryNumber - 1],
+            self.categoriesMetaData["description"].iloc[categoryNumber - 1],
             dataframe=categoryDf,
             points=points,
             version=version,
@@ -204,24 +213,19 @@ class QuestionDB:
         """
         for qNum in category.dataframe.columns:
             try:
-                self.parseQuestion(category, qNum)
-            except InvalidFieldException as e:
+                self.setupAndParseQuestion(category, qNum)
+            except (InvalidFieldException, QNotParsedException, ValueError) as e:
                 logger.exception(
-                    "Question %s%02d is invalid.",
+                    "Question %s%02d couldn't be parsed. The Question Data: \n %s",
                     category.id,
                     qNum,
-                    exc_info=e,
-                )
-            except QNotParsedException as e:
-                logger.exception(
-                    "Frage %s konnte nicht erstellt werden",
-                    category.questions[qNum].id,
+                    category.dataframe[qNum],
                     exc_info=e,
                 )
         self.signals.categoryQuestionsReady.emit(category)
 
     @classmethod
-    def parseQuestion(cls, category: Category, qNumber: int) -> None:
+    def setupAndParseQuestion(cls, category: Category, qNumber: int) -> None:
         """Check if the Question Data is valid. Then parse it.
 
         The Question data is accessed from  `category.dataframe` via its number
@@ -315,9 +319,9 @@ class QuestionDB:
                     if dialog.exec() == QtWidgets.QDialog.Accepted:
                         variant = dialog.variant
                         logger.debug("Die Fragen-Variante %s wurde gewählt", variant)
-                        q.assemble(variant)
                     else:
                         logger.warning("Keine Fragenvariante wurde gewählt.")
+                q.assemble(variant)
             else:
                 q.assemble()
             tree.append(q.element)

excel2moodle/core/globals.py

@@ -17,7 +17,7 @@ class DFIndex(StrEnum):
     """
 
     TEXT = "text"
-    BPOINTS = "bulletPoints"
+    BPOINTS = "bulletPoint"
     TRUE = "true"
     FALSE = "false"
     TYPE = "type"

excel2moodle/core/parser.py

@@ -2,7 +2,6 @@ import logging
 import re
 
 import lxml.etree as ET
-import pandas as pd
 
 import excel2moodle.core.etHelpers as eth
 from excel2moodle.core import stringHelpers
@@ -15,13 +14,11 @@ from excel2moodle.core.globals import (
     feedBElements,
 )
 from excel2moodle.core.question import Picture, Question
+from excel2moodle.core.settings import Settings, SettingsKey
 from excel2moodle.logger import LogAdapterQuestionID
-from excel2moodle.ui.settings import Settings, SettingsKey
 
 loggerObj = logging.getLogger(__name__)
 
-settings = Settings()
-
 
 class QuestionParser:
     """Setup the Parser Object.
@@ -30,6 +27,8 @@ class QuestionParser:
     Important to implement the answers methods.
     """
 
+    settings = Settings()
+
     def __init__(self) -> None:
         """Initialize the general Question parser."""
         self.genFeedbacks: list[XMLTags] = []
@@ -48,27 +47,22 @@ class QuestionParser:
         """Create a ``Picture`` object ``question``if the question needs a pic."""
         if hasattr(self, "picture") and self.question.picture.ready:
             return True
-        picKey = self.rawInput[DFIndex.PICTURE]
-        svgFolder = settings.get(SettingsKey.PICTUREFOLDER)
-        if picKey != 0 and pd.notna(picKey):
-            if not hasattr(self.question, "picture"):
-                self.question.picture = Picture(picKey, svgFolder, self.question)
-            if self.question.picture.ready:
-                return True
-        return False
+        picKey = self.rawInput.get(DFIndex.PICTURE, False)
+        f = self.settings.get(SettingsKey.PICTUREFOLDER)
+        svgFolder = (f / self.question.katName).resolve()
+        if not hasattr(self.question, "picture"):
+            self.question.picture = Picture(picKey, svgFolder, self.question.id)
+        return bool(self.question.picture.ready)
 
     def setMainText(self) -> None:
         paragraphs: list[ET._Element] = [TextElements.PLEFT.create()]
         ET.SubElement(paragraphs[0], "b").text = f"ID {self.question.id}"
         text = self.rawInput[DFIndex.TEXT]
-        pcount = 0
         for t in text:
-            if not pd.isna(t):
-                pcount += 1
-                paragraphs.append(TextElements.PLEFT.create())
-                paragraphs[-1].text = t
+            paragraphs.append(TextElements.PLEFT.create())
+            paragraphs[-1].text = t
         self.question.qtextParagraphs = paragraphs
-        self.logger.debug("Created main Text with: %s paragraphs", pcount)
+        self.logger.debug("Created main Text with: %s paragraphs", len(text))
 
     def setBPoints(self) -> None:
         """If there bulletPoints are set in the Spreadsheet it creates an unordered List-Element in ``Question.bulletList``."""
@@ -194,7 +188,6 @@ class QuestionParser:
     def getNumericAnsElement(
         self,
         result: float,
-        tolerance: float = 0,
         fraction: float = 100,
         format: str = "moodle_auto_format",
     ) -> ET.Element:
@@ -218,22 +211,15 @@ class QuestionParser:
                 TextElements.SPANGREEN,
             ),
         )
-        tolerance = self.getTolerancePercent(tolerance)
-        tol = abs(round(result * (tolerance / 100), 3))
-        ansEle.append(eth.getElement(XMLTags.TOLERANCE, text=str(tol)))
-        return ansEle
-
-    def getTolerancePercent(self, tolerance: float) -> int:
-        """Get the correct tolerance.
-        If ``tolerance < 1``:  it is interpreted as the fraction.
-        If ``tolerance >= 1``: it is interpreted as percentage.
-        """
-        if tolerance == 0 or pd.isna(tolerance) or tolerance >= 100:
-            tolerance = settings.get(SettingsKey.PARSERNF_TOLERANCE)
+        tolerance = float(self.rawInput.get(DFIndex.TOLERANCE, 0))
+        if tolerance == 0 or tolerance >= 100:
+            tolerance = self.settings.get(SettingsKey.TOLERANCE)
             self.logger.info(
                 "Using default tolerance %s percent from settings",
                 tolerance,
             )
-        tolerancePercent = 100 * tolerance if tolerance < 1 else tolerance
-        self.logger.debug("Using tolerance %s percent", tolerancePercent)
-        return int(tolerancePercent)
+        tolPercent = 100 * tolerance if tolerance < 1 else tolerance
+        self.logger.debug("Using tolerance %s percent", tolPercent)
+        relTolerance = abs(round(result * (tolerance / 100), 3))
+        ansEle.append(eth.getElement(XMLTags.TOLERANCE, text=str(relTolerance)))
+        return ansEle

excel2moodle/core/question.py

@@ -16,9 +16,11 @@ from excel2moodle.core.globals import (
     XMLTags,
     questionTypes,
 )
+from excel2moodle.core.settings import Settings, SettingsKey
 from excel2moodle.logger import LogAdapterQuestionID
 
 loggerObj = logging.getLogger(__name__)
+settings = Settings()
 
 
 class Question:
@@ -68,15 +70,15 @@ class Question:
 
     def __repr__(self) -> str:
         li: list[str] = []
-        li.append(f"Question v{self.category.version}")
-        li.append(f"{self.id=}")
+        li.append(f"Question v{self.id}")
+        li.append(f"{self.qtype}")
         li.append(f"{self.parent=}")
-        return "\n".join(li)
+        return "\t".join(li)
 
     def assemble(self, variant: int = 1) -> None:
         textElements: list[ET.Element] = []
         textElements.extend(self.qtextParagraphs)
-        self.logger.debug("Starting assembly")
+        self.logger.debug("Starting assembly, (variant %s)", variant)
         if self.element is not None:
             mainText = self.element.find(XMLTags.QTEXT)
             self.logger.debug(f"found existing Text in element {mainText=}")
@@ -95,7 +97,6 @@ class Question:
             textElements.append(self.picture.htmlTag)
             mainText.append(self.picture.element)
         mainText.append(etHelpers.getCdatTxtElement(textElements))
-        # self.element.insert(3, mainText)
         self.logger.debug("inserted MainText to element")
         if len(self.answerVariants) > 0:
             ans = self.element.find(XMLTags.ANSWER)
@@ -134,61 +135,94 @@ class Question:
 
 
 class Picture:
-    def __init__(self, picKey: str, imgFolder: Path, question: Question) -> None:
-        self.pic = picKey
+    def __init__(
+        self, picKey: str, imgFolder: Path, questionId: str, width: int = 0
+    ) -> None:
+        self.logger = LogAdapterQuestionID(loggerObj, {"qID": questionId})
+        self.picID: str
+        w: int = width if width > 0 else settings.get(SettingsKey.PICTUREWIDTH)
+        self.size: dict[str, str] = {"width": str(w)}
         self.ready: bool = False
-        self.question = question
-        self.logger = LogAdapterQuestionID(loggerObj, {"qID": self.question.id})
-        self.imgFolder = (imgFolder / question.katName).resolve()
+        self.imgFolder = imgFolder
         self.htmlTag: ET.Element
         self.path: Path
-        self._setPath()
-        if hasattr(self, "picID"):
+        self.questionId: str = questionId
+        self.logger.debug("Instantiating a new picture in %s", picKey)
+        if self.getImgId(picKey):
             self.ready = self.__getImg()
-
-    def _setPath(self) -> None:
-        if self.pic == 1:
-            self.picID = self.question.id
         else:
-            selectedPic = self.pic[2:]
-            self.logger.debug("Got the picture key: %s", selectedPic)
-            try:
-                self.picID = f"{self.question.category.id}{int(selectedPic):02d}"
-            except ValueError as e:
-                self.logger.warning(
-                    msg=f"Bild-ID konnte aus dem Key: {self.pic} nicht festgestellt werden",
-                    exc_info=e,
-                )
-
-    def _getBase64Img(self, imgPath):
-        with open(imgPath, "rb") as img:
-            return base64.b64encode(img.read()).decode("utf-8")
+            self.ready = False
+
+    def getImgId(self, imgKey: str) -> bool:
+        """Get the image ID and width based on the given key.
+        The key should either be the full ID (as the question) or only the question Num.
+        If only the number is given, the category.id is prepended.
+        The width should be specified by `ID:width:XX`. where xx is the px value.
+        """
+        width = re.findall(r"\:width\:(\d+)", str(imgKey))
+        height = re.findall(r"\:height\:(\d+)", str(imgKey))
+        if len(width) > 0 and width[0]:
+            self.size["width"] = width[0]
+        elif len(height) > 0 and height[0]:
+            self.size["height"] = height[0]
+            self.size.pop("width")
+        self.logger.debug("Size of picture is %s", self.size)
+        if imgKey in ("true", "True", "yes"):
+            self.picID = self.questionId
+            return True
+        num: list[int | str] = re.findall(r"^\d+", str(imgKey))
+        app: list[int | str] = re.findall(r"^\d+([A-Za-z_\-]+)", str(imgKey))
+        if imgKey in ("false", "nan", False) or len(num) == 0:
+            return False
+        imgID: int = int(num[0])
+        if imgID < 10:
+            picID = f"{self.questionId[:3]}{imgID:02d}"
+        elif imgID < 10000:
+            picID = f"{self.questionId[:1]}{imgID:04d}"
+        elif imgID <= 100000:
+            picID = str(imgID)
+        if len(app) > 0 and app[0]:
+            self.picID = f"{picID}{app[0]}"
+        else:
+            self.picID = str(picID)
+        self.logger.debug("Evaluated the imgID %s from %s", self.picID, imgKey)
+        return True
 
-    def _setImgElement(self, dir: Path, picID: int) -> None:
-        """Gibt das Bild im dirPath mit dir qID als base64 encodiert mit den entsprechenden XML-Tags zurück."""
-        self.path: Path = (dir / str(picID)).with_suffix(".svg")
-        self.element: ET.Element = ET.Element(
-            "file",
-            name=f"{self.path.name}",
-            path="/",
-            encoding="base64",
-        )
-        self.element.text = self._getBase64Img(self.path)
+    def _getBase64Img(self, imgPath: Path):
+        with imgPath.open("rb") as img:
+            return base64.b64encode(img.read()).decode("utf-8")
 
     def __getImg(self) -> bool:
+        suffixes = ["png", "svg", "jpeg", "jpg"]
+        paths = [
+            path
+            for suf in suffixes
+            for path in self.imgFolder.glob(f"{self.picID}.{suf}")
+        ]
+        self.logger.debug("Found the following paths %s", paths)
         try:
-            self._setImgElement(self.imgFolder, int(self.picID))
-            self.htmlTag = ET.Element(
-                "img",
-                src=f"@@PLUGINFILE@@/{self.path.name}",
-                alt=f"Bild {self.path.name}",
-                width="500",
-            )
-            return True
-        except FileNotFoundError as e:
+            self.path = paths[0]
+        except IndexError as e:
+            msg = f"The Picture from key {self.picID} is not found"
+            # raise InvalidFieldException(msg, self.questionId, DFIndex.PICTURE)
             self.logger.warning(
                 msg=f"Bild {self.picID} konnte nicht gefunden werden ",
                 exc_info=e,
             )
             self.element = None
             return False
+        base64Img = self._getBase64Img(self.path)
+        self.element: ET.Element = ET.Element(
+            "file",
+            name=f"{self.path.name}",
+            path="/",
+            encoding="base64",
+        )
+        self.element.text = base64Img
+        self.htmlTag = ET.Element(
+            "img",
+            src=f"@@PLUGINFILE@@/{self.path.name}",
+            alt=f"Bild {self.path.name}",
+            **self.size,
+        )
+        return True

excel2moodle/{ui → core}/settings.py

@@ -7,6 +7,8 @@ from typing import ClassVar, Literal, overload
 
 from PySide6.QtCore import QSettings, QTimer, Signal
 
+import excel2moodle
+
 logger = logging.getLogger(__name__)
 
 
@@ -58,16 +60,18 @@ class SettingsKey(StrEnum):
         return self._typ_
 
     QUESTIONVARIANT = "defaultQuestionVariant", "testgen", int, 0
-    INCLUDEINCATS = "includeCats", "tesgen", bool, False
-    PARSERNF_TOLERANCE = "tolerance", "parser/nf", int, 1
-    PICTURESUBFOLDER = "imgSubFolder", "core", str, "Abbildungen"
+    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 = "categoriesDataSheet", "core", str, "Kategorien"
+    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):
@@ -79,11 +83,12 @@ class Settings(QSettings):
     def __init__(self) -> None:
         """Instantiate the settings."""
         super().__init__("jbosse3", "excel2moodle")
-        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)
+        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)
@@ -93,9 +98,11 @@ class Settings(QSettings):
         self,
         key: Literal[
             SettingsKey.QUESTIONVARIANT,
-            SettingsKey.PARSERNF_TOLERANCE,
+            SettingsKey.TOLERANCE,
             SettingsKey.VERSION,
             SettingsKey.POINTS,
+            SettingsKey.PICTUREWIDTH,
+            SettingsKey.ANSPICWIDTH,
         ],
     ) -> int: ...
     @overload
@@ -117,12 +124,18 @@ class Settings(QSettings):
     ) -> Path: ...
 
     def get(self, key: SettingsKey):
-        """Get the typesafe settings value."""
-        logger.debug("LocalSettings: %s", self.localSettings)
+        """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:
@@ -158,9 +171,11 @@ class Settings(QSettings):
         local
             True saves local project specific settings.
             Defaults to False
-            The local settings are meant to be set in the first sheet ``settings``
+            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

excel2moodle/core/stringHelpers.py

@@ -4,14 +4,15 @@ import base64
 from pathlib import Path
 
 import lxml.etree as ET
+from pandas import pandas
 
 
-def getListFromStr(stringList: str) -> list[str]:
+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.split(";")
+    li = stringList if isinstance(stringList, list) else stringList.split(";")
     for i in li:
-        s = i.strip()
+        s = i.strip() if not pandas.isna(i) else None
         if s:
             stripped.append(s)
     return stripped

excel2moodle/core/validator.py

@@ -96,6 +96,8 @@ class Validator:
         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)
@@ -124,16 +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 pd.notna(self.df[field]) and not isinstance(self.df[field], typ):
-                    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

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()