excel2moodle 0.6.1__py3-none-any.whl → 0.6.3__py3-none-any.whl

excel2moodle/core/settings.py

@@ -60,8 +60,9 @@ class Tags(StrEnum):
         """Get type of the keys data."""
         return self._typ_
 
-    QUESTIONVARIANT = "defaultQuestionVariant", int, 1, "testgen"
-    INCLUDEINCATS = "includeCats", bool, False, "testgen"
+    QUESTIONVARIANT = "defaultquestionvariant", int, 1, "testgen"
+    INCLUDEINCATS = "includecats", bool, False, "testgen"
+    GENEXPORTREPORT = "exportreport", bool, False, "testgen"
     TOLERANCE = "tolerance", float, 0.01, "parser/nf"
     PICTUREFOLDER = "pictureFolder", Path, None, "core"
     PICTURESUBFOLDER = "imgfolder", str, "Abbildungen", "project"
@@ -87,8 +88,13 @@ class Tags(StrEnum):
     POINTS = "points", float, 1.0
     PICTUREWIDTH = "imgwidth", int, 500
     ANSPICWIDTH = "answerimgwidth", int, 120
-    WRONGSIGNPERCENT = "wrongsignpercent", int, 50
     FIRSTRESULT = "firstresult", float, 0
+    WRONGSIGNPERCENT = "wrongsignpercent", int, 50
+    WRONGSIGNFB = "wrongsignfeedback", str, "your result has the wrong sign (+-)"
+    TRUEFB = "truefeedback", str, "congratulations!!! your answer is right."
+    FALSEFB = "falsefeedback", str, "Your answer is sadly wrong, try again!!!"
+    PCORRECFB = "partialcorrectfeedback", str, "Your answer is partially right."
+    GENERALFB = "feedback", str, "You answered this question."
 
 
 class Settings:
@@ -101,6 +107,10 @@ class Settings:
     def clear(cls) -> None:
         cls.values.clear()
 
+    @classmethod
+    def pop(cls, key: str):
+        return cls.values.pop(key)
+
     @overload
     @classmethod
     def get(
@@ -121,7 +131,7 @@ class Settings:
     ) -> int: ...
     @overload
     @classmethod
-    def get(cls, key: Literal[Tags.INCLUDEINCATS]) -> bool: ...
+    def get(cls, key: Literal[Tags.INCLUDEINCATS, Tags.GENEXPORTREPORT]) -> bool: ...
     @overload
     @classmethod
     def get(
@@ -132,6 +142,7 @@ class Settings:
             Tags.LOGFILE,
             Tags.CATEGORIESSHEET,
             Tags.IMPORTMODULE,
+            Tags.WRONGSIGNFB,
         ],
     ) -> str: ...
     @overload
@@ -153,7 +164,7 @@ class Settings:
             default = key.default
             if default is None:
                 return None
-            logger.info("Returning the default value for %s", key)
+            logger.debug("Returning the default value for %s", key)
             return default
         if key.typ() is Path:
             path: Path = Path(raw)

excel2moodle/extra/equationVerification.py

@@ -32,8 +32,6 @@ from pathlib import Path
 
 import pandas as pd
 
-from excel2moodle.core import numericMultiQ as nmq
-
 # Hier Bitte die Frage angeben, die getestet Werden soll:
 
 # ===========================================================

excel2moodle/extra/updateQuery.py

@@ -0,0 +1,48 @@
+"""This module provides functions to query the GitLab API for project information."""
+
+import json
+import sys
+import urllib.request
+
+
+def get_latest_tag(project_id: str) -> str | None:
+    """Queries the GitLab API for the latest tag of a project.
+
+    Args:
+        project_id: The URL-encoded project ID (e.g., 'jbosse3%2Fexcel2moodle').
+
+    Returns:
+        The name of the latest tag.
+
+    """
+    url = f"https://gitlab.com/api/v4/projects/{project_id}/repository/tags"
+    try:
+        with urllib.request.urlopen(url) as response:
+            if response.status == 200:
+                data = json.loads(response.read().decode())
+                if data:
+                    return data[0]["name"]
+    except urllib.error.URLError as e:
+        print(f"Error fetching latest tag: {e}", file=sys.stderr)
+    return None
+
+
+def get_changelog(project_id: str, branch: str = "master") -> str:
+    """Queries the GitLab API for the content of the CHANGELOG.md file.
+
+    Args:
+        project_id: The URL-encoded project ID (e.g., 'jbosse3%2Fexcel2moodle').
+        branch: The branch to get the file from.
+
+    Returns:
+        The content of the CHANGELOG.md file.
+
+    """
+    url = f"https://gitlab.com/api/v4/projects/{project_id}/repository/files/CHANGELOG.md/raw?ref={branch}"
+    try:
+        with urllib.request.urlopen(url) as response:
+            if response.status == 200:
+                return response.read().decode()
+    except urllib.error.URLError as e:
+        print(f"Error fetching changelog: {e}", file=sys.stderr)
+    return ""

excel2moodle/extra/variableGenerator.py

@@ -2,9 +2,11 @@ import logging
 import random
 
 from asteval import Interpreter
+from PySide6.QtCore import Qt, Slot
 from PySide6.QtWidgets import (
     QDialog,
     QLineEdit,
+    QListWidgetItem,
     QMainWindow,
     QMessageBox,
     QTableWidget,
@@ -52,7 +54,7 @@ class VariableGeneratorDialog(QDialog):
             # Add QLineEdit for Min, Max, and Decimal Places
             min_le = QLineEdit(str(min(values)) if values else "0")
             max_le = QLineEdit(str(max(values)) if values else "100")
-            dec_le = QLineEdit("0")  # Default to 0 decimal places
+            dec_le = QLineEdit("1")  # Default to 0 decimal places
 
             self.ui.tableWidget_variables.setCellWidget(row, 1, min_le)
             self.ui.tableWidget_variables.setCellWidget(row, 2, max_le)
@@ -67,11 +69,20 @@ class VariableGeneratorDialog(QDialog):
         self.ui.groupBox_existing_variables.toggled.connect(
             self.ui.tableWidget_existing_variables.setVisible
         )
+        self.ui.listWidget_rules.itemDoubleClicked.connect(self._edit_rule)
+
+    @Slot(QListWidgetItem)
+    def _edit_rule(self, item) -> None:
+        """Move the double-clicked rule into the line edit and remove it from the list."""
+        self.ui.lineEdit_newRule.setText(item.text())
+        self.ui.listWidget_rules.takeItem(self.ui.listWidget_rules.row(item))
 
     def _add_rule(self) -> None:
         rule_text = self.ui.lineEdit_newRule.text().strip()
         if rule_text:
-            self.ui.listWidget_rules.addItem(rule_text)
+            # Check if the rule already exists. If so, do nothing.
+            if not self.ui.listWidget_rules.findItems(rule_text, Qt.MatchExactly):
+                self.ui.listWidget_rules.addItem(rule_text)
             self.ui.lineEdit_newRule.clear()
 
     def _remove_rule(self) -> None:
@@ -100,40 +111,70 @@ class VariableGeneratorDialog(QDialog):
 
         num_sets = self.ui.spinBox_numSets.value()
 
+        # Build a set of existing variable combinations to ensure we don't generate duplicates of them.
+        unique_sets_tracker = set()
+        if self.origParametrics.variables:
+            var_names = list(self.origParametrics.variables.keys())
+            if var_names:
+                # Assuming all variable lists have the same length
+                num_variants = len(self.origParametrics.variables[var_names[0]])
+                for i in range(num_variants):
+                    existing_set = {
+                        var: self.origParametrics.variables[var][i] for var in var_names
+                    }
+                    unique_sets_tracker.add(frozenset(existing_set.items()))
+
+        generated_sets = []  # This will be a list of dicts
         try:
-            generated_sets = [
-                self._findSet(varConstraints, rules) for _ in range(num_sets)
-            ]
+            while len(generated_sets) < num_sets:
+                new_set = self._findSet(varConstraints, rules, unique_sets_tracker)
+                generated_sets.append(new_set)
+                unique_sets_tracker.add(frozenset(new_set.items()))
+
         except IndexError as e:
             logger.exception("Invalid variables in Rule:")
             QMessageBox.critical(self, "Rule Error", f"{e}")
+            return  # Stop generation
         except ValueError as e:
-            logger.warning("No variable set found:")
-            QMessageBox.warning(
-                self,
-                "Generation Failed",
-                f"{e} Consider relaxing your rules or increasing the number of attempts.",
-            )
-        else:
-            # convert the generated_sets list[dict[str, float]] into dict[str, list[float]]
-            # [{A:7, B:8}, {A:11, B:9}] -> {A: [7, 11], B: [8, 9]}
-            newVariables = {}
-            for var in self.origParametrics.variables:
-                newVariables[var] = [dataSet[var] for dataSet in generated_sets]
-            self._generatedParametrics.variables = newVariables
-            self.ui.groupBox_generated_variables.show()
-            populateDataSetTable(
-                self.ui.tableWidget_generated_variables,
-                parametrics=self._generatedParametrics,
-            )
+            logger.warning("Failed to generate a new unique set: %s", e)
+            if len(generated_sets) < num_sets:
+                QMessageBox.warning(
+                    self,
+                    "Generation Incomplete",
+                    f"Could only generate {len(generated_sets)} unique sets out of the requested {num_sets}. "
+                    "The space of possible unique combinations may be exhausted.",
+                )
+
+        if not generated_sets:
+            logger.info("No new variable sets were generated.")
+            if not self._rule_error_occurred:
+                QMessageBox.information(
+                    self,
+                    "No Sets Generated",
+                    "No new unique variable sets could be generated with the given constraints and rules.",
+                )
+            return
+
+        # convert the generated_sets list[dict[str, float]] into dict[str, list[float]]
+        # [{A:7, B:8}, {A:11, B:9}] -> {A: [7, 11], B: [8, 9]}
+        newVariables = {}
+        for var in self.origParametrics.variables:
+            newVariables[var] = [dataSet[var] for dataSet in generated_sets]
+        self._generatedParametrics.variables = newVariables
+        self.ui.groupBox_generated_variables.show()
+        populateDataSetTable(
+            self.ui.tableWidget_generated_variables,
+            parametrics=self._generatedParametrics,
+        )
 
     def _findSet(
         self,
         constraints: dict[str, dict[str, float | int]],
         rules: list[str],
+        existing_sets: set[frozenset],
         maxAttempts: int = 1000,
     ) -> dict[str, float]:
-        """Generate Random numbers for each variable and check if the rules apply.
+        """Generate a random set of variables that satisfies the rules and is not in existing_sets.
 
         Raises
         ------
@@ -143,6 +184,7 @@ class VariableGeneratorDialog(QDialog):
         """
         attempts = 0
         while attempts < maxAttempts:
+            attempts += 1
             current_set: dict[str, float] = {}
             # Generate initial values based on min/max constraints
             for var_name, constr in constraints.items():
@@ -158,11 +200,15 @@ class VariableGeneratorDialog(QDialog):
                     current_set[var_name] = round(
                         random.uniform(min_val, max_val), dec_places
                     )
+
+            # Check for uniqueness first, as it's a cheaper check than evaluating rules.
+            if frozenset(current_set.items()) in existing_sets:
+                continue  # It's a duplicate, try again.
+
             if self._check_rules(current_set, rules):
-                logger.info("Found matching set after %s attemps", attempts)
+                logger.info("Found matching unique set after %s attempts", attempts)
                 return current_set
-            attempts += 1
-        msg = f"Could not generate a valid set after {maxAttempts} attempts."
+        msg = f"Could not generate a valid unique set after {maxAttempts} attempts."
         raise ValueError(msg)
 
     def _check_rules(
@@ -226,25 +272,3 @@ def populateDataSetTable(
             )
     tableWidget.resizeColumnsToContents()
 
-
-# This part is for testing the UI independently
-if __name__ == "__main__":
-    import sys
-
-    from PySide6.QtWidgets import QApplication
-
-    # Mock ParametricQuestion for testing
-    class MockParametricQuestion:
-        def __init__(self) -> None:
-            self.origParametrics.variables = {
-                "a": [1.0, 2.0, 3.0],
-                "b": [10, 20, 30],
-                "c": [0.5, 1.5, 2.5],
-            }
-
-    app = QApplication(sys.argv)
-    mock_question = MockParametricQuestion()
-    dialog = VariableGeneratorDialog(paramQuestion=mock_question)
-    if dialog.exec():
-        print("Generated Sets:", dialog.generatedVarSets())
-    sys.exit(app.exec())

excel2moodle/question_types/cloze.py

@@ -5,6 +5,7 @@ All Answers are calculated off an equation using the same variables.
 """
 
 import logging
+import math
 import re
 from typing import Literal, overload
 
@@ -18,6 +19,7 @@ from excel2moodle.core.globals import (
 from excel2moodle.core.question import (
     ParametricQuestion,
     Parametrics,
+    QuestionData,
 )
 from excel2moodle.core.settings import Tags
 from excel2moodle.logger import LogAdapterQuestionID
@@ -67,7 +69,8 @@ class ClozePart:
             return
         if self.typ == "NFM":
             result = self.result.getResult(variant)
-            self._element.text = ClozeQuestionParser.getNumericAnsStr(
+            self._element.text = self.getNumericAnsStr(
+                self.question.rawData,
                 result,
                 self.question.rawData.get(Tags.TOLERANCE),
                 wrongSignCount=self.question.rawData.get(Tags.WRONGSIGNPERCENT),
@@ -99,16 +102,20 @@ class ClozePart:
         return f"{self.question.id}-{self.num}"
 
     @property
-    def points(self) -> float:
+    def points(self) -> int:
+        """Points of clozes can be only integers.
+
+        Otherwise the moodle import fails.
+        """
         if hasattr(self, "_points"):
             return self._points
-        return 0.0
+        return 0
         self.question.logger.error("Invalid call to points of unparsed cloze part")
-        return 0.0
+        return 0
 
     @points.setter
-    def points(self, points: float) -> None:
-        self._points = points if points > 0 else 0.0
+    def points(self, points: int) -> None:
+        self._points = max(0, points)
 
     @property
     def mcAnswerString(self) -> str:
@@ -131,6 +138,73 @@ class ClozePart:
     def __repr__(self) -> str:
         return f"Cloze Part {self.id}-{self.typ}"
 
+    @staticmethod
+    def getNumericAnsStr(
+        questionData: QuestionData,
+        result: float,
+        tolerance: float = 0.0,
+        points: int = 1,
+        wrongSignCount: int = 0,
+        wrongSignFeedback: str | None = None,
+    ) -> str:
+        """Generate the answer string from `result`.
+
+        Parameters.
+        ----------
+        wrongSignCount:
+            If the wrong sign `+` or `-` is given, how much of the points should be given.
+            Interpreted as percent.
+        tolerance:
+            The relative tolerance, as fraction
+
+        """
+        if wrongSignFeedback is None:
+            wrongSignFeedback = questionData.get(Tags.WRONGSIGNFB)
+        if wrongSignCount == 0:
+            wrongSignCount = questionData.get(Tags.WRONGSIGNPERCENT)
+        if tolerance == 0.0:
+            tolerance = questionData.get(Tags.TOLERANCE)
+        absTol = f":{round(result * tolerance, 3)}"
+        answerParts: list[str | float] = [
+            "{",
+            points,
+            ":NUMERICAL:=",
+            round(result, 3),
+            absTol,
+            "~%",
+            wrongSignCount,
+            "%",
+            round(result * (-1), 3),
+            absTol,
+            f"#{wrongSignFeedback}",
+            "}",
+        ]
+        answerPStrings = [str(part) for part in answerParts]
+        return "".join(answerPStrings)
+
+    @staticmethod
+    def getMCAnsStr(
+        true: list[str],
+        false: list[str],
+        points: int = 1,
+    ) -> str:
+        """Generate the answer string for the MC answers."""
+        truePercent: float = round(100 / len(true), 1)
+        falsePercent: float = round(100 / len(false), 1)
+        falseList: list[str] = [f"~%-{falsePercent}%{ans}" for ans in false]
+        trueList: list[str] = [f"~%{truePercent}%{ans}" for ans in true]
+        answerParts: list[str | float] = [
+            "{",
+            points,
+            ":MULTIRESPONSE:",
+        ]
+        answerParts.extend(trueList)
+        answerParts.extend(falseList)
+        answerParts.append("}")
+
+        answerPStrings = [str(part) for part in answerParts]
+        return "".join(answerPStrings)
+
 
 class ClozeQuestion(ParametricQuestion):
     """Cloze Question Type."""
@@ -146,13 +220,18 @@ class ClozeQuestion(ParametricQuestion):
         return len(self.questionParts)
 
     @property
-    def points(self) -> float:
-        pts: float = 0
-        if self.isParsed:
-            for p in self.questionParts.values():
-                pts = pts + p.points
-        else:
-            pts = self.rawData.get(Tags.POINTS)
+    def points(self) -> int:
+        """Points for the cloze question. The sum of all its parts points.
+
+        Returns only integer values.
+        """
+        pts: int = 0
+        if not self.isParsed:
+            msg = "The Cloze question has no points because it is not yet parsed"
+            self.logger.warning(msg)
+            return pts
+        for p in self.questionParts.values():
+            pts = pts + p.points
         return pts
 
     def getUpdatedElement(self, variant: int = 0) -> ET.Element:
@@ -232,17 +311,30 @@ class ClozeQuestionParser(NFMQuestionParser):
                 raise QNotParsedException(msg, self.question.id)
         if len(points) == 0:
             pts = round(self.rawInput.get(Tags.POINTS) / partsNum, 3)
+            point = self._roundClozePartPoints(pts)
             for part in parts.values():
-                part.points = pts
-        elif len(points) != partsNum:
-            logger.warning(
+                part.points = point
+        else:
+            loclogger.warning(
                 "Some Answer parts are missing the points, they will get the standard points"
             )
             for num, part in parts.items():
-                p = points.get(num)
-                part.points = p if p is not None else self.rawInput.get(Tags.POINTS)
+                part.points = self._roundClozePartPoints(points=points.get(num))
         self.question.questionParts = parts
 
+    def _roundClozePartPoints(self, points: float | None = None) -> int:
+        """Get the integer points for the cloze part."""
+        if points is None:
+            points = self.rawInput.get(Tags.POINTS)
+        corrPoints: int = round(points)
+        if not math.isclose(corrPoints, points):
+            self.logger.warning(
+                "Type cloze supports only integers as points. %s was round to %s",
+                points,
+                corrPoints,
+            )
+        return corrPoints
+
     @overload
     def _getPartValues(self, Tag: Literal[Tags.RESULT]) -> dict[int, str]: ...
     @overload
@@ -270,20 +362,20 @@ class ClozeQuestionParser(NFMQuestionParser):
         for partNum, part in self.question.questionParts.items():
             if part.typ == "NFM":
                 result = self.question.parametrics.getResult(1, partNum)
-                ansStr = self.getNumericAnsStr(
-                    result,
-                    self.rawInput.get(Tags.TOLERANCE),
-                    wrongSignCount=self.rawInput.get(Tags.WRONGSIGNPERCENT),
+                ansStr = ClozePart.getNumericAnsStr(
+                    self.rawInput,
+                    result=result,
                     points=part.points,
                 )
-                self.logger.info("NF answer part: %s ", ansStr)
-                logger.debug("Appended NF part %s result", partNum)
+                self.logger.debug("Generated %s answer part: %s ", partNum, ansStr)
             elif part.typ == "MC":
-                ansStr = self.getMCAnsStr(
-                    part.trueAnswers, part.falseAnswers, points=part.points
+                ansStr = ClozePart.getMCAnsStr(
+                    part.trueAnswers,
+                    part.falseAnswers,
+                    points=part.points,
                 )
                 part.mcAnswerString = ansStr
-                logger.debug("Appended MC part %s: %s", partNum, ansStr)
+                self.logger.debug("Appended MC part %s: %s", partNum, ansStr)
             else:
                 msg = "Type of the answer part is invalid"
                 raise QNotParsedException(msg, self.id)
@@ -311,63 +403,3 @@ class ClozeQuestionParser(NFMQuestionParser):
             raise QNotParsedException(msg, self.question.id)
         else:
             return int(num)
-
-    @staticmethod
-    def getNumericAnsStr(
-        result: float,
-        tolerance: float,
-        points: float = 1,
-        wrongSignCount: int = 50,
-        wrongSignFeedback: str = "your result has the wrong sign (+-)",
-    ) -> str:
-        """Generate the answer string from `result`.
-
-        Parameters.
-        ----------
-        wrongSignCount:
-            If the wrong sign `+` or `-` is given, how much of the points should be given.
-            Interpreted as percent.
-        tolerance:
-            The relative tolerance, as fraction
-
-        """
-        absTol = f":{round(result * tolerance, 3)}"
-        answerParts: list[str | float] = [
-            "{",
-            points,
-            ":NUMERICAL:=",
-            round(result, 3),
-            absTol,
-            "~%",
-            wrongSignCount,
-            "%",
-            round(result * (-1), 3),
-            absTol,
-            f"#{wrongSignFeedback}",
-            "}",
-        ]
-        answerPStrings = [str(part) for part in answerParts]
-        return "".join(answerPStrings)
-
-    @staticmethod
-    def getMCAnsStr(
-        true: list[str],
-        false: list[str],
-        points: float = 1,
-    ) -> str:
-        """Generate the answer string for the MC answers."""
-        truePercent: float = round(100 / len(true), 1)
-        falsePercent: float = round(100 / len(false), 1)
-        falseList: list[str] = [f"~%-{falsePercent}%{ans}" for ans in false]
-        trueList: list[str] = [f"~%{truePercent}%{ans}" for ans in true]
-        answerParts: list[str | float] = [
-            "{",
-            points,
-            ":MULTIRESPONSE:",
-        ]
-        answerParts.extend(trueList)
-        answerParts.extend(falseList)
-        answerParts.append("}")
-
-        answerPStrings = [str(part) for part in answerParts]
-        return "".join(answerPStrings)

excel2moodle/question_types/mc.py

@@ -12,7 +12,6 @@ from excel2moodle.core.globals import (
     Tags,
     TextElements,
     XMLTags,
-    feedbackStr,
 )
 from excel2moodle.core.parser import QuestionParser
 from excel2moodle.core.question import Picture, Question
@@ -46,11 +45,6 @@ class MCQuestionParser(QuestionParser):
 
     def __init__(self) -> None:
         super().__init__()
-        self.genFeedbacks = [
-            XMLTags.CORFEEDB,
-            XMLTags.PCORFEEDB,
-            XMLTags.INCORFEEDB,
-        ]
 
     def setup(self, question: MCQuestion) -> None:
         self.question: MCQuestion = question
@@ -76,9 +70,9 @@ class MCQuestionParser(QuestionParser):
             elementList[-1].append(text)
             if fraction < 0:
                 elementList[-1].append(
-                    eth.getFeedBEle(
+                    self.getFeedBEle(
                         XMLTags.ANSFEEDBACK,
-                        text=feedbackStr["wrong"],
+                        text=self.rawInput.get(Tags.FALSEFB),
                         style=TextElements.SPANRED,
                     ),
                 )
@@ -86,9 +80,9 @@ class MCQuestionParser(QuestionParser):
                     elementList[-1].append(self.falseImgs[i].element)
             elif fraction > 0:
                 elementList[-1].append(
-                    eth.getFeedBEle(
+                    self.getFeedBEle(
                         XMLTags.ANSFEEDBACK,
-                        text=feedbackStr["right"],
+                        text=self.rawInput.get(Tags.TRUEFB),
                         style=TextElements.SPANGREEN,
                     ),
                 )
@@ -135,3 +129,14 @@ class MCQuestionParser(QuestionParser):
             self.getAnsElementsList(falseAList, fraction=round(falsefrac, 4)),
         )
         return ansList
+
+    def parse(self) -> None:
+        super().parse()
+        feedBacks = {
+            XMLTags.CORFEEDB: Tags.TRUEFB,
+            XMLTags.PCORFEEDB: Tags.PCORRECFB,
+            XMLTags.INCORFEEDB: Tags.FALSEFB,
+        }
+        for feedb, tag in feedBacks.items():
+            self.tmpEle.append(self.getFeedBEle(feedb, text=self.rawInput.get(tag)))
+        self._finalizeParsing()

excel2moodle/question_types/nf.py

@@ -30,7 +30,7 @@ class NFQuestionParser(QuestionParser):
 
     def __init__(self) -> None:
         super().__init__()
-        self.genFeedbacks = [XMLTags.GENFEEDB]
+        self.feedBackList = {XMLTags.GENFEEDB: Tags.GENERALFB}
 
     def setup(self, question: NFQuestion) -> None:
         self.question: NFQuestion = question
@@ -41,3 +41,9 @@ class NFQuestionParser(QuestionParser):
         ansEle: list[ET.Element] = []
         ansEle.append(self.getNumericAnsElement(result=result))
         return ansEle
+
+    def _finalizeParsing(self) -> None:
+        self.tmpEle.append(
+            self.getFeedBEle(XMLTags.GENFEEDB, text=self.rawInput.get(Tags.GENERALFB))
+        )
+        return super()._finalizeParsing()