excel2moodle 0.3.2__py3-none-any.whl → 0.3.4__py3-none-any.whl

excel2moodle/core/exceptions.py

@@ -1,20 +1,27 @@
-
 from excel2moodle.core.globals import DFIndex
 
 
 class QNotParsedException(Exception):
-    def __init__(self, message:str, qID:str|int, *args, **kwargs)->None:
+    def __init__(self, message: str, qID: str | int, *args, **kwargs) -> None:
         super().__init__(message, *args, **kwargs)
         self.qID = qID
 
+
 class NanException(QNotParsedException):
     def __init__(self, message, qID, field, *args, **kwargs):
         super().__init__(message, qID, *args, **kwargs)
         self.field = field
 
+
 class InvalidFieldException(Exception):
-    def __init__(self, message:str,  qID:str, field:DFIndex|list[DFIndex], *args: object, **kwargs) -> None:
+    def __init__(
+        self,
+        message: str,
+        qID: str,
+        field: DFIndex | list[DFIndex],
+        *args: object,
+        **kwargs,
+    ) -> None:
         super().__init__(message, *args, **kwargs)
         self.field = field
         self.index = qID
-

excel2moodle/core/globals.py

@@ -1,4 +1,5 @@
 from enum import Enum, StrEnum
+
 import lxml.etree as ET
 
 questionTypes = {
@@ -7,14 +8,15 @@ questionTypes = {
     "MC": "multichoice",
 }
 
+
 class DFIndex(StrEnum):
     """This Enum holds 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"
+    TEXT = "text"
     BPOINTS = "bulletPoints"
     TRUE = "true"
     FALSE = "false"
@@ -25,50 +27,61 @@ class DFIndex(StrEnum):
     NUMBER = "number"
     ANSTYPE = "answerType"
 
+
 class TextElements(Enum):
-    PLEFT ="p","text-align: left;"
+    PLEFT = "p", "text-align: left;"
     SPANRED = "span", "color: rgb(239, 69, 64)"
     SPANGREEN = "span", "color: rgb(152, 202, 62)"
-    SPANORANGE = "span","color: rgb(152, 100, 100)"
-    ULIST = "ul", "",
-    LISTITEM = "li", "text-align: left;",
+    SPANORANGE = "span", "color: rgb(152, 100, 100)"
+    ULIST = (
+        "ul",
+        "",
+    )
+    LISTITEM = (
+        "li",
+        "text-align: left;",
+    )
 
-    def create(self, tag:str|None=None):
+    def create(self, tag: str | None = None):
         if tag is None:
             tag, style = self.value
-        else: style = self.value[1]
+        else:
+            style = self.value[1]
         return ET.Element(tag, dir="ltr", style=style)
 
     @property
-    def style(self,)->str:
+    def style(
+        self,
+    ) -> str:
         return self.value[1]
 
+
 class XMLTags(StrEnum):
-    def __new__(cls, value:str, dfkey: DFIndex|None = None):
+    def __new__(cls, value: str, dfkey: DFIndex | 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:
+    def __init__(self, _: str, dfkey: DFIndex | None = None, getEle=None) -> None:
         if isinstance(dfkey, DFIndex):
-            self._dfkey_:str=dfkey
+            self._dfkey_: str = dfkey
         if getEle:
-            self._getEle_:object=getEle
+            self._getEle_: object = getEle
 
     @property
-    def dfkey(self)->str:
+    def dfkey(self) -> str:
         return self._dfkey_
 
-    def set(self,getEle)->None:
+    def set(self, getEle) -> None:
         self._getEle_ = getEle
 
     def __repr__(self) -> str:
         msg = []
-        msg.append(f"XML Tag {self.value = }")
+        msg.append(f"XML Tag {self.value=}")
         if hasattr(self, "_dfkey_"):
-            msg.append(f"Df Key {self.dfkey =}")
+            msg.append(f"Df Key {self.dfkey=}")
         return "\n".join(msg)
 
     NAME = "name", DFIndex.NAME
@@ -89,31 +102,32 @@ class XMLTags(StrEnum):
     ANSWER = "answer"
     TOLERANCE = "tolerance"
 
+
 feedBElements = {
-    XMLTags.CORFEEDB:TextElements.SPANGREEN.create(),
+    XMLTags.CORFEEDB: TextElements.SPANGREEN.create(),
     XMLTags.PCORFEEDB: TextElements.SPANORANGE.create(),
     XMLTags.INCORFEEDB: TextElements.SPANRED.create(),
     XMLTags.ANSFEEDBACK: TextElements.SPANGREEN.create(),
     XMLTags.GENFEEDB: TextElements.SPANGREEN.create(),
 }
 feedbackStr = {
-    XMLTags.CORFEEDB:"Die Frage wurde richtig beantwortet",
+    XMLTags.CORFEEDB: "Die Frage wurde richtig beantwortet",
     XMLTags.PCORFEEDB: "Die Frage wurde teilweise richtig beantwortet",
     XMLTags.INCORFEEDB: "Die Frage wurde Falsch beantwortet",
     XMLTags.GENFEEDB: "Sie haben eine Antwort abgegeben",
     "right": "richtig",
     "wrong": "falsch",
-    "right1Percent": "Gratultaion, die Frage wurde im Rahmen der Toleranz richtig beantwortet"
+    "right1Percent": "Gratultaion, die Frage wurde im Rahmen der Toleranz richtig beantwortet",
 }
 
 parserSettings = {
-    "Parser" : {
-            "standards": {
-                "hidden": 0,
-            },
+    "Parser": {
+        "standards": {
+            "hidden": 0,
         },
-    "MCParser" : {
-        "standards" : {
+    },
+    "MCParser": {
+        "standards": {
             "single": "false",
             "shuffleanswers": "true",
             "answernumbering": "abc",
@@ -121,8 +135,7 @@ parserSettings = {
             "shownumcorrect": "",
         },
     },
-    "NFParser" : {
+    "NFParser": {
         "standards": {},
     },
 }
-

excel2moodle/core/numericMultiQ.py

@@ -6,37 +6,40 @@ As well it returns a bullet points string that shows the numerical values corres
 """
 
 import re as re
+
 import pandas as pd
 from asteval import Interpreter
 
 astEval = Interpreter()
 
 
-def getVariablesDict(df: pd.DataFrame, keyList: list, index:int)-> dict:
+def getVariablesDict(df: pd.DataFrame, keyList: list, index: int) -> dict:
     """Liest alle Variablen-Listen deren Name in ``keyList`` ist aus dem DataFrame im Column[index]"""
     dic = {}
     for k in keyList:
         val = df.loc[str(k)][index]
-        if type(val) == str and val != None  :
+        if isinstance(val, str) and val is not None:
             li = val.split(";")
             dic[str(k)] = li
-        else: 
+        else:
             dic[str(k)] = [str(val)]
     print(f"Folgende Variablen wurden gefunden:\n{dic}\n")
     return dic
 
-def setParameters(parameters: dict, index: int)->None:
+
+def setParameters(parameters: dict, index: int) -> None:
     """Ubergibt die Parameter mit entsprechenden Variablen-Namen an den asteval-Interpreter.
 
     Dann kann dieser die equation loesen.
     """
-    for k,v in parameters.items():
+    for k, v in parameters.items():
         comma = re.compile(r",")
-        value = comma.sub(".",v[index])
+        value = comma.sub(".", v[index])
         astEval.symtable[k] = float(value)
     return None
 
-def insertVariablesToBPoints(varDict: dict, bulletPoints: str, index: int)-> str:
+
+def insertVariablesToBPoints(varDict: dict, bulletPoints: str, index: int) -> str:
     """
     Für jeden Eintrag im varDict, wird im bulletPoints String der Substring "{key}" durch value[index] ersetzt
     """
@@ -46,23 +49,25 @@ def insertVariablesToBPoints(varDict: dict, bulletPoints: str, index: int)-> str
         bulletPoints = matcher.sub(str(v[index]), bulletPoints)
     return bulletPoints
 
-def getVarsList(bps: str)->list:
+
+def getVarsList(bps: str) -> list:
     """
     Durchsucht den bulletPoints String nach den Variablen, die als "{var}" gekennzeichnet sind
     """
     vars = re.findall(r"\{\w\}", str(bps))
-    variablen=[]
+    variablen = []
     for v in vars:
         variablen.append(v.strip("{}"))
     return variablen
 
 
-def parseNumericMultiQuestion(datFrame: pd.DataFrame, bulletPoints: str, 
-                              equation: str, questionIndex: int
-                              )-> tuple[list[str],list[float]]:
+def parseNumericMultiQuestion(
+    datFrame: pd.DataFrame, bulletPoints: str, equation: str, questionIndex: int
+) -> tuple[list[str], list[float]]:
     """Berechnet die Ergebnisse anhand der Variablen in *bulletPoints*
 
-    Gibt eine Liste mit allen Ergebnissen zurück und eine Liste mit den bulletPoints-Strings, die die Numerischen Variablen enthalten
+    Gibt eine Liste mit allen Ergebnissen zurück
+    und eine Liste mit den bulletPoints-Strings, die die Numerischen Variablen enthalten
     """
     results = []
     bps = []