fuzzy-dl-owl2 1.0.4__py3-none-any.whl → 1.0.6__py3-none-any.whl

fuzzy_dl_owl2/fuzzyowl2/parser/owl2_parser.py

@@ -6,11 +6,7 @@ import typing
 
 import pyparsing as pp
 
-from fuzzy_dl_owl2.fuzzydl.concept.qowa_concept import QowaConcept
 from fuzzy_dl_owl2.fuzzydl.knowledge_base import KnowledgeBase
-from fuzzy_dl_owl2.fuzzydl.modifier.linear_modifier import LinearModifier
-from fuzzy_dl_owl2.fuzzydl.modifier.modifier import Modifier
-from fuzzy_dl_owl2.fuzzydl.modifier.triangular_modifier import TriangularModifier
 from fuzzy_dl_owl2.fuzzydl.query.query import Query
 from fuzzy_dl_owl2.fuzzydl.util import utils
 from fuzzy_dl_owl2.fuzzydl.util.config_reader import ConfigReader
@@ -18,14 +14,17 @@ from fuzzy_dl_owl2.fuzzydl.util.util import Util
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.choquet_concept import ChoquetConcept
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.concept_definition import ConceptDefinition
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.fuzzy_datatype import FuzzyDatatype
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.fuzzy_modifier import FuzzyModifier
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.fuzzy_nominal_concept import FuzzyNominalConcept
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.left_shoulder_function import (
     LeftShoulderFunction,
 )
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.linear_function import LinearFunction
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.linear_modifier import LinearModifier
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.modified_concept import ModifiedConcept
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.modified_property import ModifiedProperty
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.owa_concept import OwaConcept
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.qowa_concept import QowaConcept
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.quasi_sugeno_concept import QsugenoConcept
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.right_shoulder_function import (
     RightShoulderFunction,
@@ -33,6 +32,7 @@ from fuzzy_dl_owl2.fuzzyowl2.owl_types.right_shoulder_function import (
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.sugeno_concept import SugenoConcept
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.trapezoidal_function import TrapezoidalFunction
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.triangular_function import TriangularFunction
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.triangular_modifer import TriangularModifier
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.weighted_concept import WeightedConcept
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.weighted_max_concept import WeightedMaxConcept
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.weighted_min_concept import WeightedMinConcept
@@ -66,13 +66,13 @@ def _parse_fuzzy_datatype(tokens: pp.ParseResults) -> FuzzyDatatype:
     return tokens
 
 
-def _parse_modifier_function(tokens: pp.ParseResults) -> Modifier:
+def _parse_modifier_function(tokens: pp.ParseResults) -> FuzzyModifier:
     Util.debug(f"_parse_modifier_function -> {tokens}")
     list_tokens: list = tokens.as_list()
     if list_tokens[0] == FuzzyOWL2Keyword.LINEAR:
-        return LinearModifier(None, list_tokens[1])
+        return LinearModifier(list_tokens[1])
     elif list_tokens[0] == FuzzyOWL2Keyword.TRIANGULAR:
-        return TriangularModifier(None, list_tokens[1], list_tokens[2], list_tokens[3])
+        return TriangularModifier(list_tokens[1], list_tokens[2], list_tokens[3])
     return tokens
 
 
@@ -103,11 +103,9 @@ def _parse_fuzzy_nominal(tokens: pp.ParseResults) -> ConceptDefinition:
 def _parse_weighted_complex_concept(tokens: pp.ParseResults) -> ConceptDefinition:
     Util.debug(f"_parse_weighted_complex_concept -> {tokens}")
     list_tokens: list = tokens.as_list()
-    assert isinstance(list_tokens[1], list) and all(
-        isinstance(a, WeightedConcept) for a in list_tokens[1]
-    )
+    assert all(isinstance(a, WeightedConcept) for a in list_tokens[1:])
     wc: list[WeightedConcept] = [
-        typing.cast(WeightedConcept, w) for w in list_tokens[1]
+        typing.cast(WeightedConcept, w) for w in list_tokens[1:]
     ]
     if list_tokens[0] == FuzzyOWL2Keyword.WEIGHTED_MAXIMUM:
         return WeightedMaxConcept(wc)
@@ -221,7 +219,10 @@ class FuzzyOwl2Parser(object):
         concept = pp.Forward()
 
         modified_role_concept = (
-            FuzzyOWL2Keyword.MODIFIED.get_value().suppress()
+            FuzzyOWL2Keyword.CONCEPT.get_value().suppress()
+            + FuzzyOWL2Keyword.TYPE.get_value().suppress()
+            + FuzzyOWL2Keyword.EQUAL.get_value().suppress()
+            + FuzzyOWL2Keyword.MODIFIED.get_value().suppress()
             + FuzzyOWL2Keyword.MODIFIER.get_value().suppress()
             + FuzzyOWL2Keyword.EQUAL.get_value().suppress()
             + variables
@@ -231,13 +232,18 @@ class FuzzyOwl2Parser(object):
         ).add_parse_action(_parse_modified_concept)
 
         weighted_concept = (
-            FuzzyOWL2Keyword.WEIGHTED.get_value().suppress()
+            open_tag
+            + FuzzyOWL2Keyword.CONCEPT.get_value().suppress()
+            + FuzzyOWL2Keyword.TYPE.get_value().suppress()
+            + FuzzyOWL2Keyword.EQUAL.get_value().suppress()
+            + FuzzyOWL2Keyword.WEIGHTED.get_value().suppress()
             + FuzzyOWL2Keyword.DEGREE_VALUE.get_value().suppress()
             + FuzzyOWL2Keyword.EQUAL.get_value().suppress()
             + numbers
             + FuzzyOWL2Keyword.BASE.get_value().suppress()
             + FuzzyOWL2Keyword.EQUAL.get_value().suppress()
             + variables
+            + single_close_tag
         ).add_parse_action(_parse_weighted_concept)
 
         weights = (
@@ -280,7 +286,6 @@ class FuzzyOwl2Parser(object):
             + close_tag
         )
 
-        weighted_list_concept = close_tag + weights + concepts
         q_owa_concept = (
             FuzzyOWL2Keyword.QUANTIFIER.get_value().suppress()
             + FuzzyOWL2Keyword.EQUAL.get_value().suppress()
@@ -318,7 +323,9 @@ class FuzzyOwl2Parser(object):
                                 | FuzzyOWL2Keyword.SUGENO.get_value()
                                 | FuzzyOWL2Keyword.QUASI_SUGENO.get_value()
                             )
-                            + weighted_list_concept
+                            + close_tag
+                            + weights
+                            + concepts
                         ).add_parse_action(_parse_integral_concept)
                         | FuzzyOWL2Keyword.Q_OWA.get_value().suppress() + q_owa_concept
                     )

fuzzy_dl_owl2/fuzzyowl2/parser/owl2_xml_parser.py

@@ -0,0 +1,226 @@
+from __future__ import annotations
+
+import os
+import traceback
+import typing
+from xml.etree import ElementTree
+
+import pyparsing as pp
+
+from fuzzy_dl_owl2.fuzzydl.util.config_reader import ConfigReader
+from fuzzy_dl_owl2.fuzzydl.util.util import Util
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.choquet_concept import ChoquetConcept
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.fuzzy_nominal_concept import FuzzyNominalConcept
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.left_shoulder_function import (
+    LeftShoulderFunction,
+)
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.linear_function import LinearFunction
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.linear_modifier import LinearModifier
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.modified_concept import ModifiedConcept
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.modified_property import ModifiedProperty
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.owa_concept import OwaConcept
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.qowa_concept import QowaConcept
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.quasi_sugeno_concept import QsugenoConcept
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.right_shoulder_function import (
+    RightShoulderFunction,
+)
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.sugeno_concept import SugenoConcept
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.trapezoidal_function import TrapezoidalFunction
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.triangular_function import TriangularFunction
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.triangular_modifer import TriangularModifier
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.weighted_concept import WeightedConcept
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.weighted_max_concept import WeightedMaxConcept
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.weighted_min_concept import WeightedMinConcept
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.weighted_sum_concept import WeightedSumConcept
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.weighted_sum_zero_concept import (
+    WeightedSumZeroConcept,
+)
+from fuzzy_dl_owl2.fuzzyowl2.util.constants import FuzzyOWL2Keyword
+from fuzzy_dl_owl2.fuzzyowl2.util.fuzzy_xml import FuzzyXML
+
+
+class FuzzyOwl2XMLParser(object):
+
+    @staticmethod
+    def get_caseless_attrib(attrib: dict[str, str], key: str) -> typing.Optional[str]:
+        keys = [k for k in attrib if k.lower() == key.lower()]
+        return attrib.get(keys[0]) if len(keys) > 0 else None
+
+    @staticmethod
+    def parse_string(
+        instring: str,
+    ) -> pp.ParseResults:
+        root: ElementTree.Element = ElementTree.fromstring(instring)
+        Util.debug(f"XML PARSER -> {FuzzyXML.to_str(root)}")
+        assert root.tag == FuzzyOWL2Keyword.FUZZY_OWL_2
+
+        annotation_type: str = root.attrib.get(
+            FuzzyOWL2Keyword.FUZZY_TYPE.get_str_value()
+        )
+        if annotation_type == FuzzyOWL2Keyword.CONCEPT:
+            child = root.find(FuzzyOWL2Keyword.CONCEPT.get_tag_name())
+            concept_type = child.attrib.get(FuzzyOWL2Keyword.TYPE.get_str_value())
+            if concept_type == FuzzyOWL2Keyword.MODIFIED:
+                return ModifiedConcept(
+                    child.attrib.get(FuzzyOWL2Keyword.MODIFIER.get_str_value()),
+                    child.attrib.get(FuzzyOWL2Keyword.BASE.get_str_value()),
+                )
+            elif concept_type == FuzzyOWL2Keyword.WEIGHTED:
+                return WeightedConcept(
+                    float(
+                        child.attrib.get(FuzzyOWL2Keyword.DEGREE_VALUE.get_str_value())
+                    ),
+                    child.attrib.get(FuzzyOWL2Keyword.BASE.get_str_value()),
+                )
+            elif concept_type in (
+                FuzzyOWL2Keyword.WEIGHTED_MINIMUM,
+                FuzzyOWL2Keyword.WEIGHTED_MAXIMUM,
+                FuzzyOWL2Keyword.WEIGHTED_SUM,
+                FuzzyOWL2Keyword.WEIGHTED_SUMZERO,
+            ):
+                wc: list[WeightedConcept] = [
+                    WeightedConcept(
+                        float(
+                            inner_child.attrib.get(
+                                FuzzyOWL2Keyword.DEGREE_VALUE.get_str_value()
+                            )
+                        ),
+                        inner_child.attrib.get(FuzzyOWL2Keyword.BASE.get_str_value()),
+                    )
+                    for inner_child in child
+                    if inner_child.tag == FuzzyOWL2Keyword.CONCEPT.get_tag_name()
+                    and inner_child.attrib.get(FuzzyOWL2Keyword.TYPE.get_str_value())
+                    == FuzzyOWL2Keyword.WEIGHTED
+                ]
+                if concept_type == FuzzyOWL2Keyword.WEIGHTED_MAXIMUM:
+                    return WeightedMaxConcept(wc)
+                elif concept_type == FuzzyOWL2Keyword.WEIGHTED_MINIMUM:
+                    return WeightedMinConcept(wc)
+                elif concept_type == FuzzyOWL2Keyword.WEIGHTED_SUM:
+                    return WeightedSumConcept(wc)
+                elif concept_type == FuzzyOWL2Keyword.WEIGHTED_SUMZERO:
+                    return WeightedSumZeroConcept(wc)
+            elif concept_type in (
+                FuzzyOWL2Keyword.OWA,
+                FuzzyOWL2Keyword.CHOQUET,
+                FuzzyOWL2Keyword.SUGENO,
+                FuzzyOWL2Keyword.QUASI_SUGENO,
+            ):
+                weights: list[float] = [
+                    float(weight.text)
+                    for weight in child.find(
+                        FuzzyOWL2Keyword.WEIGHTS.get_tag_name()
+                    ).findall(FuzzyOWL2Keyword.WEIGHT.get_tag_name())
+                ]
+                concepts: list[str] = [
+                    name.text
+                    for name in child.find(
+                        FuzzyOWL2Keyword.CONCEPT_NAMES.get_tag_name()
+                    ).findall(FuzzyOWL2Keyword.NAME.get_tag_name())
+                ]
+                if concept_type == FuzzyOWL2Keyword.OWA:
+                    return OwaConcept(weights, concepts)
+                elif concept_type == FuzzyOWL2Keyword.CHOQUET:
+                    return ChoquetConcept(weights, concepts)
+                elif concept_type == FuzzyOWL2Keyword.SUGENO:
+                    return SugenoConcept(weights, concepts)
+                elif concept_type == FuzzyOWL2Keyword.QUASI_SUGENO:
+                    return QsugenoConcept(weights, concepts)
+            elif concept_type == FuzzyOWL2Keyword.Q_OWA:
+                quantifier = child.attrib.get(
+                    FuzzyOWL2Keyword.QUANTIFIER.get_str_value()
+                )
+                concepts: list[str] = [
+                    name.text
+                    for name in child.find(
+                        FuzzyOWL2Keyword.CONCEPT_NAMES.get_tag_name()
+                    ).findall(FuzzyOWL2Keyword.NAME.get_tag_name())
+                ]
+                return QowaConcept(quantifier, concepts)
+            elif concept_type == FuzzyOWL2Keyword.NOMINAL:
+                return FuzzyNominalConcept(
+                    float(
+                        child.attrib.get(FuzzyOWL2Keyword.DEGREE_DEF.get_str_value())
+                    ),
+                    child.attrib.get(FuzzyOWL2Keyword.INDIVIDUAL.get_str_value()),
+                )
+        elif annotation_type == FuzzyOWL2Keyword.DATATYPE:
+            child = root.find(FuzzyOWL2Keyword.DATATYPE.get_tag_name())
+            datatype_type = child.attrib.get(FuzzyOWL2Keyword.TYPE.get_str_value())
+
+            if datatype_type == FuzzyOWL2Keyword.LEFT_SHOULDER:
+                return LeftShoulderFunction(
+                    float(child.attrib.get(FuzzyOWL2Keyword.A.get_str_value())),
+                    float(child.attrib.get(FuzzyOWL2Keyword.B.get_str_value())),
+                )
+            elif datatype_type == FuzzyOWL2Keyword.RIGHT_SHOULDER:
+                return RightShoulderFunction(
+                    float(child.attrib.get(FuzzyOWL2Keyword.A.get_str_value())),
+                    float(child.attrib.get(FuzzyOWL2Keyword.B.get_str_value())),
+                )
+            elif datatype_type == FuzzyOWL2Keyword.LINEAR:
+                return LinearFunction(
+                    float(child.attrib.get(FuzzyOWL2Keyword.A.get_str_value())),
+                    float(child.attrib.get(FuzzyOWL2Keyword.B.get_str_value())),
+                )
+            elif datatype_type == FuzzyOWL2Keyword.TRIANGULAR:
+                return TriangularFunction(
+                    float(child.attrib.get(FuzzyOWL2Keyword.A.get_str_value())),
+                    float(child.attrib.get(FuzzyOWL2Keyword.B.get_str_value())),
+                    float(child.attrib.get(FuzzyOWL2Keyword.C.get_str_value())),
+                )
+            elif datatype_type == FuzzyOWL2Keyword.TRAPEZOIDAL:
+                return TrapezoidalFunction(
+                    float(child.attrib.get(FuzzyOWL2Keyword.A.get_str_value())),
+                    float(child.attrib.get(FuzzyOWL2Keyword.B.get_str_value())),
+                    float(child.attrib.get(FuzzyOWL2Keyword.C.get_str_value())),
+                    float(child.attrib.get(FuzzyOWL2Keyword.D.get_str_value())),
+                )
+        elif annotation_type == FuzzyOWL2Keyword.MODIFIER:
+            child = root.find(FuzzyOWL2Keyword.MODIFIER.get_tag_name())
+            mod_type = child.attrib.get(FuzzyOWL2Keyword.TYPE.get_str_value())
+            if mod_type == FuzzyOWL2Keyword.LINEAR:
+                return LinearModifier(
+                    float(child.attrib.get(FuzzyOWL2Keyword.C.get_str_value())),
+                )
+            elif mod_type == FuzzyOWL2Keyword.TRIANGULAR:
+                return TriangularModifier(
+                    float(child.attrib.get(FuzzyOWL2Keyword.A.get_str_value())),
+                    float(child.attrib.get(FuzzyOWL2Keyword.B.get_str_value())),
+                    float(child.attrib.get(FuzzyOWL2Keyword.C.get_str_value())),
+                )
+        elif annotation_type == FuzzyOWL2Keyword.AXIOM:
+            child = root.find(FuzzyOWL2Keyword.DEGREE_DEF.get_tag_name())
+            return float(
+                child.attrib.get(FuzzyOWL2Keyword.DEGREE_VALUE.get_str_value())
+            )
+        elif annotation_type == FuzzyOWL2Keyword.ONTOLOGY:
+            child = root.find(FuzzyOWL2Keyword.FUZZY_LOGIC.get_tag_name())
+            return child.attrib.get(FuzzyOWL2Keyword.LOGIC.get_str_value())
+        elif annotation_type == FuzzyOWL2Keyword.ROLE:
+            child = root.find(FuzzyOWL2Keyword.ROLE.get_tag_name())
+            assert (
+                child.attrib.get(FuzzyOWL2Keyword.TYPE.get_str_value())
+                == FuzzyOWL2Keyword.MODIFIED
+            )
+            return ModifiedProperty(
+                child.attrib.get(FuzzyOWL2Keyword.MODIFIER.get_str_value()),
+                child.attrib.get(FuzzyOWL2Keyword.BASE.get_str_value()),
+            )
+        else:
+            raise ValueError
+
+    @staticmethod
+    def load_config(*args) -> None:
+        ConfigReader.load_parameters(os.path.join(os.getcwd(), "CONFIG.ini"), args)
+
+    @staticmethod
+    def main(annotation: str, *args) -> typing.Any:
+        try:
+            FuzzyOwl2XMLParser.load_config(*args)
+            return FuzzyOwl2XMLParser.parse_string(annotation)
+        except FileNotFoundError as e:
+            Util.error(f"Error: File {args[0]} not found.")
+        except Exception as e:
+            Util.error(e)
+            Util.error(traceback.format_exc())

fuzzy_dl_owl2/fuzzyowl2/util/__init__.py

@@ -1 +1,2 @@
+from .fuzzy_xml import *
 from .constants import *

fuzzy_dl_owl2/fuzzyowl2/util/constants.py

@@ -26,63 +26,149 @@ class ConceptType(enum.StrEnum):
         return self.name
 
 
+# class FuzzyOWL2Keyword(enum.Enum):
+#     OPEN_TAG = pp.Word("<")
+#     CLOSE_TAG = pp.Word(">")
+#     SINGLE_CLOSE_TAG = pp.Word("/>")
+#     SLASH = pp.Word("/")
+#     ONTOLOGY = pp.CaselessKeyword("ontology")
+#     FUZZY_OWL_2 = pp.CaselessKeyword("fuzzyOwl2")
+#     FUZZY_LABEL = pp.CaselessKeyword("fuzzyLabel")
+#     FUZZY_TYPE = pp.CaselessKeyword("fuzzytype")
+#     FUZZY_LOGIC = pp.CaselessKeyword("FuzzyLogic")
+#     TYPE = pp.CaselessKeyword("type")
+#     LOGIC = pp.CaselessKeyword("logic")
+#     DATATYPE = pp.CaselessKeyword("datatype")
+#     CONCEPT = pp.CaselessKeyword("concept")
+#     ROLE = pp.CaselessKeyword("role")
+#     AXIOM = pp.CaselessKeyword("axiom")
+#     DEGREE_DEF = pp.CaselessKeyword("degree")
+#     DEGREE_VALUE = pp.CaselessKeyword("value")
+#     MODIFIED = pp.CaselessKeyword("modified")
+#     WEIGHTED = pp.CaselessKeyword("weighted")
+#     NOMINAL = pp.CaselessKeyword("nominal")
+#     INDIVIDUAL = pp.CaselessKeyword("individual")
+#     WEIGHTED_MAXIMUM = pp.CaselessKeyword("weightedMaximum")
+#     WEIGHTED_MINIMUM = pp.CaselessKeyword("weightedMinimum")
+#     WEIGHTED_SUM = pp.CaselessKeyword("weightedSum")
+#     WEIGHTED_SUMZERO = pp.CaselessKeyword("weightedSumZero")
+#     OWA = pp.CaselessKeyword("owa")
+#     Q_OWA = pp.CaselessKeyword("qowa")
+#     CHOQUET = pp.CaselessKeyword("choquet")
+#     SUGENO = pp.CaselessKeyword("sugeno")
+#     QUASI_SUGENO = pp.CaselessKeyword("quasisugeno")
+#     MODIFIER = pp.CaselessKeyword("modifier")
+#     BASE = pp.CaselessKeyword("base")
+#     CONCEPT_NAMES = pp.CaselessKeyword("names")
+#     NAME = pp.CaselessKeyword("name")
+#     WEIGHT = pp.CaselessKeyword("weight")
+#     WEIGHTS = pp.CaselessKeyword("weights")
+#     QUANTIFIER = pp.CaselessKeyword("quantifier")
+#     CRISP = pp.CaselessKeyword("crisp")
+#     LEFT_SHOULDER = pp.CaselessKeyword("leftshoulder")
+#     RIGHT_SHOULDER = pp.CaselessKeyword("rightshoulder")
+#     TRIANGULAR = pp.CaselessKeyword("triangular")
+#     TRAPEZOIDAL = pp.CaselessKeyword("trapezoidal")
+#     LINEAR = pp.CaselessKeyword("linear")
+#     A = pp.CaselessKeyword("a")
+#     B = pp.CaselessKeyword("b")
+#     C = pp.CaselessKeyword("c")
+#     D = pp.CaselessKeyword("d")
+#     LUKASIEWICZ = pp.CaselessKeyword("lukasiewicz")
+#     GOEDEL = pp.CaselessKeyword("goedel")
+#     ZADEH = pp.CaselessKeyword("zadeh")
+#     PRODUCT = pp.CaselessKeyword("product")
+#     EQUAL = pp.Word("=")
+#     LES = pp.CaselessKeyword("les")
+#     LEQ = pp.CaselessKeyword("leq")
+#     GEQ = pp.CaselessKeyword("geq")
+#     GRE = pp.CaselessKeyword("gre")
+
+#     def get_name(self) -> str:
+#         return re.sub(r"[\"\']+", "", self.value.name.lower())
+
+#     def get_value(self) -> typing.Union[pp.CaselessKeyword, pp.Word]:
+#         return self.value
+
+#     def get_str_value(self) -> str:
+#         return str(self.value).replace('"', "").replace("'", "")
+
+#     def get_tag_name(self) -> str:
+#         return self.get_str_value().capitalize()
+
+#     def __eq__(self, value: object) -> bool:
+#         if isinstance(value, str):
+#             return self.get_name() == value.lower()
+#         elif isinstance(value, pp.CaselessKeyword):
+#             return self.get_name() == value.name.lower()
+#         elif isinstance(value, FuzzyOWL2Keyword):
+#             return self.get_name() == value.get_name()
+#         raise NotImplementedError
+
+#     def __repr__(self) -> str:
+#         return self.name
+
+#     def __str__(self) -> str:
+#         return self.name
+
+
 class FuzzyOWL2Keyword(enum.Enum):
     OPEN_TAG = pp.Word("<")
     CLOSE_TAG = pp.Word(">")
     SINGLE_CLOSE_TAG = pp.Word("/>")
     SLASH = pp.Word("/")
-    ONTOLOGY = pp.CaselessKeyword("ontology")
-    FUZZY_OWL_2 = pp.CaselessKeyword("fuzzyOwl2")
-    FUZZY_LABEL = pp.CaselessKeyword("fuzzyLabel")
-    FUZZY_TYPE = pp.CaselessKeyword("fuzzytype")
-    FUZZY_LOGIC = pp.CaselessKeyword("FuzzyLogic")
-    TYPE = pp.CaselessKeyword("type")
-    LOGIC = pp.CaselessKeyword("logic")
-    DATATYPE = pp.CaselessKeyword("datatype")
-    CONCEPT = pp.CaselessKeyword("concept")
-    ROLE = pp.CaselessKeyword("role")
-    AXIOM = pp.CaselessKeyword("axiom")
-    DEGREE_DEF = pp.CaselessKeyword("degree")
-    DEGREE_VALUE = pp.CaselessKeyword("value")
-    MODIFIED = pp.CaselessKeyword("modified")
-    WEIGHTED = pp.CaselessKeyword("weighted")
-    NOMINAL = pp.CaselessKeyword("nominal")
-    INDIVIDUAL = pp.CaselessKeyword("individual")
-    WEIGHTED_MAXIMUM = pp.CaselessKeyword("weightedMaximum")
-    WEIGHTED_MINIMUM = pp.CaselessKeyword("weightedMinimum")
-    WEIGHTED_SUM = pp.CaselessKeyword("weightedSum")
-    WEIGHTED_SUMZERO = pp.CaselessKeyword("weightedSumZero")
-    OWA = pp.CaselessKeyword("owa")
-    Q_OWA = pp.CaselessKeyword("qowa")
-    CHOQUET = pp.CaselessKeyword("choquet")
-    SUGENO = pp.CaselessKeyword("sugeno")
-    QUASI_SUGENO = pp.CaselessKeyword("quasisugeno")
-    MODIFIER = pp.CaselessKeyword("modifier")
-    BASE = pp.CaselessKeyword("base")
-    CONCEPT_NAMES = pp.CaselessKeyword("names")
-    NAME = pp.CaselessKeyword("name")
-    WEIGHT = pp.CaselessKeyword("weight")
-    WEIGHTS = pp.CaselessKeyword("weights")
-    QUANTIFIER = pp.CaselessKeyword("quantifier")
-    CRISP = pp.CaselessKeyword("crisp")
-    LEFT_SHOULDER = pp.CaselessKeyword("leftshoulder")
-    RIGHT_SHOULDER = pp.CaselessKeyword("rightshoulder")
-    TRIANGULAR = pp.CaselessKeyword("triangular")
-    TRAPEZOIDAL = pp.CaselessKeyword("trapezoidal")
-    LINEAR = pp.CaselessKeyword("linear")
-    A = pp.CaselessKeyword("a")
-    B = pp.CaselessKeyword("b")
-    C = pp.CaselessKeyword("c")
-    D = pp.CaselessKeyword("d")
-    LUKASIEWICZ = pp.CaselessKeyword("lukasiewicz")
-    GOEDEL = pp.CaselessKeyword("goedel")
-    ZADEH = pp.CaselessKeyword("zadeh")
-    PRODUCT = pp.CaselessKeyword("product")
+    ONTOLOGY = pp.Keyword("ontology")
+    FUZZY_OWL_2 = pp.Keyword("fuzzyOwl2")
+    FUZZY_LABEL = pp.Keyword("fuzzyLabel")
+    FUZZY_TYPE = pp.Keyword("fuzzyType")
+    FUZZY_LOGIC = pp.Keyword("FuzzyLogic")
+    TYPE = pp.Keyword("type")
+    LOGIC = pp.Keyword("logic")
+    DATATYPE = pp.Keyword("datatype")
+    CONCEPT = pp.Keyword("concept")
+    ROLE = pp.Keyword("role")
+    AXIOM = pp.Keyword("axiom")
+    DEGREE_DEF = pp.Keyword("degree")
+    DEGREE_VALUE = pp.Keyword("value")
+    MODIFIED = pp.Keyword("modified")
+    WEIGHTED = pp.Keyword("weighted")
+    NOMINAL = pp.Keyword("nominal")
+    INDIVIDUAL = pp.Keyword("individual")
+    WEIGHTED_MAXIMUM = pp.Keyword("weightedMaximum")
+    WEIGHTED_MINIMUM = pp.Keyword("weightedMinimum")
+    WEIGHTED_SUM = pp.Keyword("weightedSum")
+    WEIGHTED_SUMZERO = pp.Keyword("weightedSumZero")
+    OWA = pp.Keyword("owa")
+    Q_OWA = pp.Keyword("qowa")
+    CHOQUET = pp.Keyword("choquet")
+    SUGENO = pp.Keyword("sugeno")
+    QUASI_SUGENO = pp.Keyword("quasisugeno")
+    MODIFIER = pp.Keyword("modifier")
+    BASE = pp.Keyword("base")
+    CONCEPT_NAMES = pp.Keyword("names")
+    NAME = pp.Keyword("name")
+    WEIGHT = pp.Keyword("weight")
+    WEIGHTS = pp.Keyword("weights")
+    QUANTIFIER = pp.Keyword("quantifier")
+    CRISP = pp.Keyword("crisp")
+    LEFT_SHOULDER = pp.Keyword("leftshoulder")
+    RIGHT_SHOULDER = pp.Keyword("rightshoulder")
+    TRIANGULAR = pp.Keyword("triangular")
+    TRAPEZOIDAL = pp.Keyword("trapezoidal")
+    LINEAR = pp.Keyword("linear")
+    A = pp.Keyword("a")
+    B = pp.Keyword("b")
+    C = pp.Keyword("c")
+    D = pp.Keyword("d")
+    LUKASIEWICZ = pp.Keyword("lukasiewicz")
+    GOEDEL = pp.Keyword("goedel")
+    ZADEH = pp.Keyword("zadeh")
+    PRODUCT = pp.Keyword("product")
     EQUAL = pp.Word("=")
-    LES = pp.CaselessKeyword("les")
-    LEQ = pp.CaselessKeyword("leq")
-    GEQ = pp.CaselessKeyword("geq")
-    GRE = pp.CaselessKeyword("gre")
+    LES = pp.Keyword("les")
+    LEQ = pp.Keyword("leq")
+    GEQ = pp.Keyword("geq")
+    GRE = pp.Keyword("gre")
 
     def get_name(self) -> str:
         return re.sub(r"[\"\']+", "", self.value.name.lower())
@@ -99,7 +185,7 @@ class FuzzyOWL2Keyword(enum.Enum):
     def __eq__(self, value: object) -> bool:
         if isinstance(value, str):
             return self.get_name() == value.lower()
-        elif isinstance(value, pp.CaselessKeyword):
+        elif isinstance(value, pp.Keyword):
             return self.get_name() == value.name.lower()
         elif isinstance(value, FuzzyOWL2Keyword):
             return self.get_name() == value.get_name()

fuzzy_dl_owl2/fuzzyowl2/util/fuzzy_xml.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import re
+import typing
+from xml.dom import minidom
+from xml.etree.ElementTree import Element, tostring
+
+from fuzzy_dl_owl2.fuzzyowl2.util.constants import FuzzyOWL2Keyword
+from pyowl2.abstracts.class_expression import OWLClassExpression
+
+
+class FuzzyXML(object):
+
+    @staticmethod
+    def build_main_xml(fuzzy_type: str) -> Element:
+        return Element(
+            FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value(),
+            attrib={FuzzyOWL2Keyword.FUZZY_TYPE.get_str_value(): fuzzy_type},
+        )
+
+    @staticmethod
+    def build_logic_xml(logic: str, attrib: dict[str, str] = dict()) -> Element:
+        full_attrib = {FuzzyOWL2Keyword.LOGIC.get_str_value(): logic}
+        if attrib:
+            full_attrib.update(attrib)
+        return Element(
+            FuzzyOWL2Keyword.FUZZY_LOGIC.get_tag_name(),
+            attrib=full_attrib,
+        )
+
+    @staticmethod
+    def build_datatype_xml(
+        datatype_type: str, attrib: dict[str, str] = dict()
+    ) -> Element:
+        full_attrib = {FuzzyOWL2Keyword.TYPE.get_str_value(): datatype_type}
+        if attrib:
+            full_attrib.update(attrib)
+        return Element(
+            FuzzyOWL2Keyword.DATATYPE.get_tag_name(),
+            attrib=full_attrib,
+        )
+
+    @staticmethod
+    def build_modifier_xml(
+        modifier_type: str, attrib: dict[str, str] = dict()
+    ) -> Element:
+        full_attrib = {FuzzyOWL2Keyword.TYPE.get_str_value(): modifier_type}
+        if attrib:
+            full_attrib.update(attrib)
+        return Element(
+            FuzzyOWL2Keyword.MODIFIER.get_tag_name(),
+            attrib=full_attrib,
+        )
+
+    @staticmethod
+    def build_degree_xml(
+        value: typing.Union[int, float], attrib: dict[str, str] = dict()
+    ) -> Element:
+        full_attrib = {FuzzyOWL2Keyword.DEGREE_VALUE.get_str_value(): str(value)}
+        if attrib:
+            full_attrib.update(attrib)
+        return Element(
+            FuzzyOWL2Keyword.DEGREE_DEF.get_tag_name(),
+            attrib=full_attrib,
+        )
+
+    @staticmethod
+    def build_concept_xml(
+        concept_type: str, attrib: dict[str, str] = dict()
+    ) -> Element:
+        full_attrib = {FuzzyOWL2Keyword.TYPE.get_str_value(): concept_type}
+        if attrib:
+            full_attrib.update(attrib)
+        return Element(
+            FuzzyOWL2Keyword.CONCEPT.get_tag_name(),
+            attrib=full_attrib,
+        )
+
+    @staticmethod
+    def build_weights_xml(weights: list[float]) -> Element:
+        element = Element(FuzzyOWL2Keyword.WEIGHTS.get_tag_name())
+        for w in weights:
+            curr = Element(FuzzyOWL2Keyword.WEIGHT.get_tag_name())
+            curr.text = str(w)
+            element.append(curr)
+        return element
+
+    @staticmethod
+    def build_names_xml(concepts: list[OWLClassExpression]) -> Element:
+        element = Element(FuzzyOWL2Keyword.CONCEPT_NAMES.get_tag_name())
+        for c in concepts:
+            curr = Element(FuzzyOWL2Keyword.NAME.get_tag_name())
+            curr.text = str(c)
+            element.append(curr)
+        return element
+
+    @staticmethod
+    def to_str(element: Element) -> str:
+        return re.sub(
+            "\n+",
+            "\n",
+            "\n".join(
+                minidom.parseString(tostring(element, encoding="unicode", method="xml"))
+                .toprettyxml()
+                .split("\n")[1:]
+            ),
+        )