excel2moodle 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

excel2moodle/core/question.py

@@ -1,19 +1,33 @@
-import logging 
-import lxml.etree as ET
+import base64
+import logging
+import re
 from pathlib import Path
-import base64 as base64
-
-from excel2moodle.core import category, etHelpers
-from excel2moodle.core.globals import XMLTags, TextElements, DFIndex, questionTypes, parserSettings
-from excel2moodle.core.exceptions import QNotParsedException
-from typing import Match
-import re as re
+from re import Match
 
+import lxml.etree as ET
 
-logger = logging.getLogger(__name__)
-
-class Question():
-    def __init__(self, category,name:str, number:int, parent=None, qtype:str="type", points:float=0):
+from excel2moodle.core import etHelpers
+from excel2moodle.core.exceptions import QNotParsedException
+from excel2moodle.core.globals import (
+    TextElements,
+    XMLTags,
+    questionTypes,
+)
+from excel2moodle.logger import LogAdapterQuestionID
+
+loggerObj = logging.getLogger(__name__)
+
+
+class Question:
+    def __init__(
+        self,
+        category,
+        name: str,
+        number: int,
+        parent=None,
+        qtype: str = "type",
+        points: float = 0,
+    ) -> None:
         self.category = category
         self.katName = self.category.name
         self.name = name
@@ -21,73 +35,75 @@ class Question():
         self.parent = parent
         self.qtype: str = qtype
         self.moodleType = questionTypes[qtype]
-        self.points = ( points if points != 0 else self.category.points)
-        self.element: ET.Element|None=None
-        self.picture:Picture
-        self.id:str
+        self.points = points if points != 0 else self.category.points
+        self.element: ET.Element | None = None
+        self.picture: Picture
+        self.id: str
         self.qtextParagraphs: list[ET.Element] = []
-        self.bulletList: ET.Element|None = None
+        self.bulletList: ET.Element | None = None
         self.answerVariants: list[ET.Element] = []
-        self.variants:int|None = None
-        self.variables: dict[str, list[float|int]] = {}
+        self.variants: int | None = None
+        self.variables: dict[str, list[float | int]] = {}
         self.setID()
-        self.standardTags = {
-            "hidden":"false"
-        }
-        logger.debug(f"Question {self.id} is initialized")
+        self.standardTags = {"hidden": "false"}
+        self.logger = LogAdapterQuestionID(loggerObj, {"qID": self.id})
+        self.logger.debug("Sucess initializing")
 
-    def __repr__(self)->str:
-        li:list[str] = []
+    def __repr__(self) -> str:
+        li: list[str] = []
         li.append(f"Question v{self.category.version}")
-        li.append(f'{self.id=}')
-        li.append(f'{self.parent=}')
+        li.append(f"{self.id=}")
+        li.append(f"{self.parent=}")
         return "\n".join(li)
 
-    def assemble(self, variant:int=1)->None:
-        textElements:list[ET.Element] = []
+    def assemble(self, variant: int = 1) -> None:
+        textElements: list[ET.Element] = []
         textElements.extend(self.qtextParagraphs)
-        logger.debug(f"Starting assembly of { self.id }")
+        self.logger.debug("Starting assembly")
         if self.element is not None:
             mainText = self.element.find(XMLTags.QTEXT)
-            logger.debug(f"found existing Text in element {mainText = }")
+            self.logger.debug(f"found existing Text in element {mainText=}")
             txtele = mainText.find("text")
             if txtele is not None:
                 mainText.remove(txtele)
-                logger.debug(f"removed prevously existing questiontext")
-        else: raise QNotParsedException("Cant assamble, if element is none", self.id)
-        if self.variants is not None:
-            textElements.append(self.getBPointVariant(variant-1))
+                self.logger.debug("removed previously existing questiontext")
         else:
+            msg = "Cant assamble, if element is none"
+            raise QNotParsedException(msg, self.id)
+        if self.variants is not None:
+            textElements.append(self.getBPointVariant(variant - 1))
+        elif self.bulletList is not None:
             textElements.append(self.bulletList)
         if hasattr(self, "picture") and self.picture.ready:
             textElements.append(self.picture.htmlTag)
             mainText.append(self.picture.element)
         mainText.append(etHelpers.getCdatTxtElement(textElements))
         # self.element.insert(3, mainText)
-        logger.debug(f"inserted MainText to question element")
-        if len( self.answerVariants ) > 0:
+        self.logger.debug("inserted MainText to element")
+        if len(self.answerVariants) > 0:
             ans = self.element.find(XMLTags.ANSWER)
             if ans is not None:
                 self.element.remove(ans)
-                logger.debug("removed previous answer element")
-            self.element.insert(5, self.answerVariants[variant-1])
-        return None
+                self.logger.debug("removed previous answer element")
+            self.element.insert(5, self.answerVariants[variant - 1])
 
-    def setID(self, id = 0)->None:
+    def setID(self, id=0) -> None:
         if id == 0:
             self.id: str = f"{self.category.id}{self.number:02d}"
-        else: self.id:str = str(id)
+        else:
+            self.id: str = str(id)
 
-    def getBPointVariant(self, variant:int)->ET.Element:
+    def getBPointVariant(self, variant: int) -> ET.Element:
         if self.bulletList is None:
             return None
-        varPlaceholder = re.compile(r"{(\w+)}")  # matches {a}, {some_var}, etc.
+        # matches {a}, {some_var}, etc.
+        varPlaceholder = re.compile(r"{(\w+)}")
 
-        def replaceMatch(match: Match[str])->str|int|float:
+        def replaceMatch(match: Match[str]) -> str | int | float:
             key = match.group(1)
             if key in self.variables:
                 value = self.variables[key][variant]
-                return f"{value}".replace(".",",\\!") 
+                return f"{value}".replace(".", ",\\!")
             return match.group(0)  # keep original if no match
 
         unorderedList = TextElements.ULIST.create()
@@ -95,52 +111,67 @@ class Question():
             listItemText = li.text or ""
             bullet = TextElements.LISTITEM.create()
             bullet.text = varPlaceholder.sub(replaceMatch, listItemText)
-            logger.debug(f"Inserted Variables into List: {bullet}")
+            self.logger.debug(f"Inserted Variables into List: {bullet}")
             unorderedList.append(bullet)
         return unorderedList
 
 
-class Picture():
-    def __init__(self, picKey:str, imgFolder:Path, question:Question):
+class Picture:
+    def __init__(self, picKey: str, imgFolder: Path, question: Question) -> None:
         self.pic = picKey
-        self.ready:bool = False
+        self.ready: bool = False
         self.question = question
+        self.logger = LogAdapterQuestionID(loggerObj, {"qID": self.question.id})
         self.imgFolder = (imgFolder / question.katName).resolve()
-        self.htmlTag:ET.Element
-        self.path:Path
+        self.htmlTag: ET.Element
+        self.path: Path
         self._setPath()
-        if hasattr(self, 'picID'):
+        if hasattr(self, "picID"):
             self.ready = self.__getImg()
 
-    def _setPath(self):
+    def _setPath(self) -> None:
         if self.pic == 1:
             self.picID = self.question.id
         else:
             selectedPic = self.pic[2:]
-            logger.debug(f"got a picture key {selectedPic =}")
+            self.logger.debug("Got the picture key: %s", selectedPic)
             try:
                 self.picID = f"{self.question.category.id}{int(selectedPic):02d}"
             except ValueError as e:
-                logger.warning(msg=f"Bild-ID konnte aus dem Key: {self.pic = }nicht festgestellt werden", exc_info=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:
-            img64 = base64.b64encode(img.read()).decode('utf-8')
-        return img64
-
-    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')
+        with open(imgPath, "rb") as img:
+            return base64.b64encode(img.read()).decode("utf-8")
+
+    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 __getImg(self)->bool:
+    def __getImg(self) -> bool:
         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")
+            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:
-            logger.warning(msg=f"Bild {self.picID} konnte nicht gefunden werden ", exc_info=e)
+            self.logger.warning(
+                msg=f"Bild {self.picID} konnte nicht gefunden werden ",
+                exc_info=e,
+            )
             self.element = None
             return False

excel2moodle/core/questionValidator.py

@@ -1,51 +1,57 @@
-"""This Module checks if the data inside the Spreadsheet is valid
+"""This Module checks if the data inside the Spreadsheet is valid.
 
 Those things are considered:
 
 #. The mandatory entries must not be ``Nan``
 #. All fields must have the right data-type
 
-If Those checks pass, a question is created, which can be accessed via ``Validator.question``
+If Those checks pass, a question is created,
+which can be accessed via ``Validator.question``
 """
 
-from types import UnionType
+import logging
+from typing import TYPE_CHECKING
 
-from pandas.core.series import notna
-from excel2moodle.core.question import Question
-from excel2moodle.core.globals import DFIndex
-from excel2moodle.core.exceptions  import InvalidFieldException, NanException
 import pandas as pd
-import logging
+
+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__)
 
 
-class Validator():
+class Validator:
+    """Validate the question data from the spreadsheet.
+
+    Creates a dictionary with the data, for easier access later.
+    """
+
     def __init__(self, category) -> None:
-        self.question:Question
+        self.question: Question
         self.category = category
-        self.mandatory: dict[DFIndex, type|UnionType] = {
+        self.mandatory: dict[DFIndex, type | UnionType] = {
             DFIndex.TEXT: str,
             DFIndex.NAME: str,
             DFIndex.TYPE: str,
         }
-        self.optional: dict[DFIndex, type|UnionType] = {
-            DFIndex.BPOINTS : str,
-            DFIndex.NAME: str,
-            DFIndex.PICTURE: int|str,
-        }
-        self.nfOpt: dict[DFIndex, type|UnionType] = {
-            DFIndex.RESULT: float|int,
-        }
-        self.nfMand: dict[DFIndex, type|UnionType] = {
-        }
-        self.nfmOpt: dict[DFIndex, type|UnionType] = {
+        self.optional: dict[DFIndex, type | UnionType] = {
+            DFIndex.BPOINTS: str,
+            DFIndex.PICTURE: int | str,
         }
-        self.nfmMand: dict[DFIndex, type|UnionType] = {
+        self.nfOpt: dict[DFIndex, type | UnionType] = {}
+        self.nfMand: dict[DFIndex, type | UnionType] = {
+            DFIndex.RESULT: float | int,
         }
-        self.mcOpt: dict[DFIndex, type|UnionType] = {
+        self.nfmOpt: dict[DFIndex, type | UnionType] = {}
+        self.nfmMand: dict[DFIndex, type | UnionType] = {
+            DFIndex.RESULT: str,
         }
-        self.mcMand: dict[DFIndex, type|UnionType] = {
+        self.mcOpt: dict[DFIndex, type | UnionType] = {}
+        self.mcMand: dict[DFIndex, type | UnionType] = {
             DFIndex.TRUE: str,
             DFIndex.FALSE: str,
             DFIndex.ANSTYPE: str,
@@ -57,15 +63,15 @@ class Validator():
             "NFM": (self.nfmOpt, self.nfmMand),
         }
 
-    def setup(self, df:pd.Series, index:int)->bool:
+    def setup(self, df: pd.Series, index: int) -> bool:
         self.df = df
         self.index = index
         typ = self.df.loc[DFIndex.TYPE]
         self.mandatory.update(self.mapper[typ][1])
         self.optional.update(self.mapper[typ][0])
         return True
-        
-    def validate(self )->bool:
+
+    def validate(self) -> bool:
         id = f"{self.category.id}{self.index:02d}"
         checker, missing = self._mandatory()
         if not checker:
@@ -74,32 +80,31 @@ class Validator():
                 raise InvalidFieldException(msg, id, missing)
         checker, missing = self._typeCheck()
         if not checker:
-            msg = f"Question {id} misses keys {missing}"
+            msg = f"Question {id} has wrong typed data {missing}"
             if missing is not None:
                 raise InvalidFieldException(msg, id, missing)
         self._getQuestion()
         self._getData()
         return True
 
-    def _getData(self)->None:
-        self.qdata:dict[str, str|float|int|list]={}
+    def _getData(self) -> None:
+        self.qdata: dict[str, str | float | int | list] = {}
         for idx, val in self.df.items():
             if not isinstance(idx, str):
-                logger.debug(f"Got a non String key in the spreadsheet, skipping it")
                 continue
             if idx in self.qdata:
                 if isinstance(self.qdata[idx], list):
-                    self.qdata[idx].append(val) 
+                    self.qdata[idx].append(val)
                 else:
                     existing = self.qdata[idx]
                     self.qdata[idx] = [existing, val]
             else:
-                self.qdata[idx]=val
+                self.qdata[idx] = val
 
-    def _mandatory(self)->tuple[bool,DFIndex|None]:
-        """detects if all keys of mandatory are filled with values"""
+    def _mandatory(self) -> tuple[bool, DFIndex | None]:
+        """Detects if all keys of mandatory are filled with values."""
         checker = pd.Series.notna(self.df)
-        for k in self.mandatory.keys():
+        for k in self.mandatory:
             try:
                 c = checker[k]
             except KeyError:
@@ -108,35 +113,32 @@ class Validator():
                 if not c.any():
                     return False, k
             elif not c:
-                return False, k,
+                return False, k
         return True, None
 
-    def _typeCheck(self)->tuple[bool, list[DFIndex]|None]:
-        invalid:list[DFIndex] = []
+    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):
                 for f in self.df[field]:
-                    if pd.notna(f):
-                        if not isinstance(f, typ):
-                            invalid.append(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):
+                if not isinstance(self.df[field], typ) and pd.notna(self.df[field]):
                     invalid.append(field)
         if len(invalid) == 0:
             return True, None
-        else: 
-            return False, invalid
+        return False, invalid
 
-
-    def _getQuestion(self)->None:
+    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))
-        return None
-
+        self.question = Question(
+            self.category,
+            name=str(name),
+            number=self.index,
+            qtype=str(qtype),
+        )