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

fuzzy_dl_owl2/fuzzydl/fuzzydl_to_owl2.py

@@ -64,6 +64,7 @@ from fuzzy_dl_owl2.fuzzydl.util import constants
 from fuzzy_dl_owl2.fuzzydl.util.constants import ConceptType, ConcreteFeatureType
 from fuzzy_dl_owl2.fuzzydl.util.util import Util
 from fuzzy_dl_owl2.fuzzyowl2.util.constants import FuzzyOWL2Keyword
+from fuzzy_dl_owl2.fuzzyowl2.util.fuzzy_xml import FuzzyXML
 from pyowl2.abstracts.axiom import OWLAxiom
 from pyowl2.abstracts.class_expression import OWLClassExpression
 from pyowl2.abstracts.data_range import OWLDataRange
@@ -276,11 +277,24 @@ class FuzzydlToOwl2:
             c4: OWLClassExpression = self.get_new_atomic_class(str(c))
             c3: OWLClassExpression = self.get_base(c.c1)
             self.concepts[str(c)] = c3
-            annotation: str = (
-                f'<{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()} {FuzzyOWL2Keyword.FUZZY_TYPE.get_str_value()}="{FuzzyOWL2Keyword.CONCEPT.get_str_value()}">\n',
-                f'\t<{FuzzyOWL2Keyword.CONCEPT.get_tag_name()} {FuzzyOWL2Keyword.TYPE.get_str_value()}="{FuzzyOWL2Keyword.MODIFIED.get_str_value()}" {FuzzyOWL2Keyword.MODIFIER.get_str_value()}="{self.modifiers[str(c)]}" {FuzzyOWL2Keyword.BASE.get_str_value()}="{c3}"/>\n',
-                f"</{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()}>",
+
+            main_xml = FuzzyXML.build_main_xml(FuzzyOWL2Keyword.CONCEPT.get_str_value())
+            concept_xml = FuzzyXML.build_concept_xml(
+                FuzzyOWL2Keyword.MODIFIED.get_str_value(),
+                {
+                    FuzzyOWL2Keyword.MODIFIER.get_str_value(): str(
+                        self.modifiers[str(c)]
+                    ),
+                    FuzzyOWL2Keyword.BASE.get_str_value(): str(c3),
+                },
             )
+            main_xml.append(concept_xml)
+            annotation: str = FuzzyXML.to_str(main_xml)
+            # annotation: str = (
+            #     f'<{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()} {FuzzyOWL2Keyword.FUZZY_TYPE.get_str_value()}="{FuzzyOWL2Keyword.CONCEPT.get_str_value()}">\n',
+            #     f'\t<{FuzzyOWL2Keyword.CONCEPT.get_tag_name()} {FuzzyOWL2Keyword.TYPE.get_str_value()}="{FuzzyOWL2Keyword.MODIFIED.get_str_value()}" {FuzzyOWL2Keyword.MODIFIER.get_str_value()}="{self.modifiers[str(c)]}" {FuzzyOWL2Keyword.BASE.get_str_value()}="{c3}"/>\n',
+            #     f"</{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()}>",
+            # )
             self.add_entity_annotation(annotation, c4)
             return c4
         elif c_type == ConceptType.SELF:
@@ -331,11 +345,22 @@ class FuzzydlToOwl2:
             c: WeightedConcept = typing.cast(WeightedConcept, c)
             c4: OWLClassExpression = self.get_new_atomic_class(str(c))
             c3: OWLClassExpression = self.get_base(c.c1)
-            annotation: str = (
-                f'<{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()} {FuzzyOWL2Keyword.FUZZY_TYPE.get_str_value()}="{FuzzyOWL2Keyword.CONCEPT.get_str_value()}">\n',
-                f'\t<{FuzzyOWL2Keyword.CONCEPT.get_tag_name()} {FuzzyOWL2Keyword.TYPE.get_str_value()}="{FuzzyOWL2Keyword.WEIGHTED.get_str_value()}" {FuzzyOWL2Keyword.DEGREE_VALUE.get_str_value()}="{c.weight}" {FuzzyOWL2Keyword.BASE.get_str_value()}="{c3}"/>\n',
-                f"</{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()}>",
+
+            main_xml = FuzzyXML.build_main_xml(FuzzyOWL2Keyword.CONCEPT.get_str_value())
+            concept_xml = FuzzyXML.build_concept_xml(
+                FuzzyOWL2Keyword.WEIGHTED.get_str_value(),
+                {
+                    FuzzyOWL2Keyword.DEGREE_VALUE.get_str_value(): str(c.weight),
+                    FuzzyOWL2Keyword.BASE.get_str_value(): str(c3),
+                },
             )
+            main_xml.append(concept_xml)
+            annotation: str = FuzzyXML.to_str(main_xml)
+            # annotation: str = (
+            #     f'<{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()} {FuzzyOWL2Keyword.FUZZY_TYPE.get_str_value()}="{FuzzyOWL2Keyword.CONCEPT.get_str_value()}">\n',
+            #     f'\t<{FuzzyOWL2Keyword.CONCEPT.get_tag_name()} {FuzzyOWL2Keyword.TYPE.get_str_value()}="{FuzzyOWL2Keyword.WEIGHTED.get_str_value()}" {FuzzyOWL2Keyword.DEGREE_VALUE.get_str_value()}="{c.weight}" {FuzzyOWL2Keyword.BASE.get_str_value()}="{c3}"/>\n',
+            #     f"</{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()}>",
+            # )
             self.add_entity_annotation(annotation, c3)
             return c4
         elif c_type in (
@@ -378,16 +403,33 @@ class FuzzydlToOwl2:
         curr_concept: HasWeightedConceptsInterface = type_cast[c.type](c)
         c3: OWLClassExpression = self.get_new_atomic_class(str(curr_concept))
 
-        annotation: str = (
-            f'<{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()} {FuzzyOWL2Keyword.FUZZY_TYPE.get_str_value()}="{FuzzyOWL2Keyword.CONCEPT.get_str_value()}">\n',
-            f'\t<{FuzzyOWL2Keyword.CONCEPT.get_tag_name()} {FuzzyOWL2Keyword.TYPE.get_str_value()}="{type_dict[c.type]}">\n ',
-        )
+        main_xml = FuzzyXML.build_main_xml(FuzzyOWL2Keyword.CONCEPT.get_str_value())
+        concept_xml = FuzzyXML.build_concept_xml(type_dict[c.type])
         for i in range(len(curr_concept.concepts)):
             c5: OWLClassExpression = self.get_base(curr_concept.concepts[i])
-            annotation += f'\t\t<{FuzzyOWL2Keyword.CONCEPT.get_tag_name()} {FuzzyOWL2Keyword.TYPE.get_str_value()}="{FuzzyOWL2Keyword.WEIGHTED.get_str_value()}" {FuzzyOWL2Keyword.DEGREE_VALUE.get_str_value()}="{curr_concept.weights[i]}" {FuzzyOWL2Keyword.BASE.get_str_value()}="{c5}" />\n'
-        annotation: str = (
-            f"\t</{FuzzyOWL2Keyword.CONCEPT.get_tag_name()} >\n</{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()} >"
-        )
+            sub_concept_xml = FuzzyXML.build_concept_xml(
+                FuzzyOWL2Keyword.WEIGHTED.get_str_value(),
+                {
+                    FuzzyOWL2Keyword.DEGREE_VALUE.get_str_value(): str(
+                        curr_concept.weights[i]
+                    ),
+                    FuzzyOWL2Keyword.BASE.get_str_value(): str(c5),
+                },
+            )
+            concept_xml.append(sub_concept_xml)
+        main_xml.append(concept_xml)
+        annotation: str = FuzzyXML.to_str(main_xml)
+
+        # annotation: str = (
+        #     f'<{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()} {FuzzyOWL2Keyword.FUZZY_TYPE.get_str_value()}="{FuzzyOWL2Keyword.CONCEPT.get_str_value()}">\n',
+        #     f'\t<{FuzzyOWL2Keyword.CONCEPT.get_tag_name()} {FuzzyOWL2Keyword.TYPE.get_str_value()}="{type_dict[c.type]}">\n ',
+        # )
+        # for i in range(len(curr_concept.concepts)):
+        #     c5: OWLClassExpression = self.get_base(curr_concept.concepts[i])
+        #     annotation += f'\t\t<{FuzzyOWL2Keyword.CONCEPT.get_tag_name()} {FuzzyOWL2Keyword.TYPE.get_str_value()}="{FuzzyOWL2Keyword.WEIGHTED.get_str_value()}" {FuzzyOWL2Keyword.DEGREE_VALUE.get_str_value()}="{curr_concept.weights[i]}" {FuzzyOWL2Keyword.BASE.get_str_value()}="{c5}" />\n'
+        # annotation: str = (
+        #     f"\t</{FuzzyOWL2Keyword.CONCEPT.get_tag_name()} >\n</{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()} >"
+        # )
         self.add_entity_annotation(annotation, c3)
         return c3
 
@@ -411,18 +453,31 @@ class FuzzydlToOwl2:
             return None
         curr_concept: HasWeightedConceptsInterface = type_cast[c.type](c)
         c4: OWLClassExpression = self.get_new_atomic_class(str(c))
-        annotation: str = (
-            f'<{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()} {FuzzyOWL2Keyword.FUZZY_TYPE.get_str_value()}="{FuzzyOWL2Keyword.CONCEPT.get_str_value()}">\n',
-            f'\t<{FuzzyOWL2Keyword.CONCEPT.get_tag_name()} {FuzzyOWL2Keyword.TYPE.get_str_value()}="{type_dict[c.type]}">\n',
-            f"\t\t<{FuzzyOWL2Keyword.WEIGHTS.get_tag_name()}>\n",
+
+        main_xml = FuzzyXML.build_main_xml(FuzzyOWL2Keyword.CONCEPT.get_str_value())
+        concept_xml = FuzzyXML.build_concept_xml(type_dict[c.type])
+        weights_xml = FuzzyXML.build_weights_xml(curr_concept.weights)
+        names_xml = FuzzyXML.build_names_xml(
+            [self.get_base(ci) for ci in curr_concept.concepts]
         )
-        for d in curr_concept.weights:
-            annotation += f"\t\t\t<{FuzzyOWL2Keyword.WEIGHT.get_tag_name()}>{d}</{FuzzyOWL2Keyword.WEIGHT.get_tag_name()}>\n"
-        annotation += f"\t\t</{FuzzyOWL2Keyword.WEIGHTS.get_tag_name()}>\n\t\t<{FuzzyOWL2Keyword.CONCEPT_NAMES.get_tag_name()}>\n"
-        for ci in curr_concept.concepts:
-            c5: OWLClassExpression = self.get_base(ci)
-            annotation += f"\t\t\t<{FuzzyOWL2Keyword.NAME.get_tag_name()}>{c5}</{FuzzyOWL2Keyword.NAME.get_tag_name()}>\n"
-        annotation += f"\t\t</{FuzzyOWL2Keyword.CONCEPT_NAMES.get_tag_name()}>\n\t</{FuzzyOWL2Keyword.CONCEPT.get_tag_name()}>\n</{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()}>"
+        concept_xml.append(weights_xml)
+        concept_xml.append(names_xml)
+        main_xml.append(concept_xml)
+        annotation: str = FuzzyXML.to_str(main_xml)
+
+        # annotation: str = (
+        #     f'<{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()} {FuzzyOWL2Keyword.FUZZY_TYPE.get_str_value()}="{FuzzyOWL2Keyword.CONCEPT.get_str_value()}">\n',
+        #     f'\t<{FuzzyOWL2Keyword.CONCEPT.get_tag_name()} {FuzzyOWL2Keyword.TYPE.get_str_value()}="{type_dict[c.type]}">\n',
+        #     f"\t\t<{FuzzyOWL2Keyword.WEIGHTS.get_tag_name()}>\n",
+        # )
+        # for d in curr_concept.weights:
+        #     annotation += f"\t\t\t<{FuzzyOWL2Keyword.WEIGHT.get_tag_name()}>{d}</{FuzzyOWL2Keyword.WEIGHT.get_tag_name()}>\n"
+        # annotation += f"\t\t</{FuzzyOWL2Keyword.WEIGHTS.get_tag_name()}>\n\t\t<{FuzzyOWL2Keyword.CONCEPT_NAMES.get_tag_name()}>\n"
+        # for ci in curr_concept.concepts:
+        #     c5: OWLClassExpression = self.get_base(ci)
+        #     annotation += f"\t\t\t<{FuzzyOWL2Keyword.NAME.get_tag_name()}>{c5}</{FuzzyOWL2Keyword.NAME.get_tag_name()}>\n"
+        # annotation += f"\t\t</{FuzzyOWL2Keyword.CONCEPT_NAMES.get_tag_name()}>\n\t</{FuzzyOWL2Keyword.CONCEPT.get_tag_name()}>\n</{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()}>"
+
         self.add_entity_annotation(annotation, c4)
         return c4
 
@@ -438,15 +493,27 @@ class FuzzydlToOwl2:
             return None
         curr_concept: QowaConcept = type_cast[c.type](c)
         c4: OWLClassExpression = self.get_new_atomic_class(str(c))
-        annotation: str = (
-            f'<{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()} {FuzzyOWL2Keyword.FUZZY_TYPE.get_str_value()}="{FuzzyOWL2Keyword.CONCEPT.get_str_value()}">\n',
-            f'\t<{FuzzyOWL2Keyword.CONCEPT.get_tag_name()} {FuzzyOWL2Keyword.TYPE.get_str_value()}="{type_dict[c.type]}" {FuzzyOWL2Keyword.QUANTIFIER.get_tag_name()}="{curr_concept.quantifier}">\n',
-            f"\t\t<{FuzzyOWL2Keyword.CONCEPT_NAMES.get_tag_name()}>\n",
+
+        main_xml = FuzzyXML.build_main_xml(FuzzyOWL2Keyword.CONCEPT.get_str_value())
+        concept_xml = FuzzyXML.build_concept_xml(
+            type_dict[c.type],
+            {FuzzyOWL2Keyword.QUANTIFIER.get_str_value(): str(curr_concept.quantifier)},
         )
-        for ci in curr_concept.concepts:
-            c5: OWLClassExpression = self.get_base(ci)
-            annotation += f"\t\t\t<{FuzzyOWL2Keyword.NAME.get_tag_name()}>{c5}</{FuzzyOWL2Keyword.NAME.get_tag_name()}>\n"
-        annotation += f"\t\t</{FuzzyOWL2Keyword.CONCEPT_NAMES.get_tag_name()}>\n\t</{FuzzyOWL2Keyword.CONCEPT.get_tag_name()}>\n</{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()}>"
+        names_xml = FuzzyXML.build_names_xml(
+            [self.get_base(ci) for ci in curr_concept.concepts]
+        )
+        concept_xml.append(names_xml)
+        main_xml.append(concept_xml)
+        annotation: str = FuzzyXML.to_str(main_xml)
+        # annotation: str = (
+        #     f'<{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()} {FuzzyOWL2Keyword.FUZZY_TYPE.get_str_value()}="{FuzzyOWL2Keyword.CONCEPT.get_str_value()}">\n',
+        #     f'\t<{FuzzyOWL2Keyword.CONCEPT.get_tag_name()} {FuzzyOWL2Keyword.TYPE.get_str_value()}="{type_dict[c.type]}" {FuzzyOWL2Keyword.QUANTIFIER.get_str_value()}="{curr_concept.quantifier}">\n',
+        #     f"\t\t<{FuzzyOWL2Keyword.CONCEPT_NAMES.get_tag_name()}>\n",
+        # )
+        # for ci in curr_concept.concepts:
+        #     c5: OWLClassExpression = self.get_base(ci)
+        #     annotation += f"\t\t\t<{FuzzyOWL2Keyword.NAME.get_tag_name()}>{c5}</{FuzzyOWL2Keyword.NAME.get_tag_name()}>\n"
+        # annotation += f"\t\t</{FuzzyOWL2Keyword.CONCEPT_NAMES.get_tag_name()}>\n\t</{FuzzyOWL2Keyword.CONCEPT.get_tag_name()}>\n</{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()}>"
         self.add_entity_annotation(annotation, c4)
         return c4
 
@@ -549,11 +616,16 @@ class FuzzydlToOwl2:
         elif isinstance(value, DegreeNumeric):  # Degree object
             n = value.get_numerical_value()
 
-        annotation_text: str = (
-            f'<{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()} {FuzzyOWL2Keyword.FUZZY_TYPE.get_str_value()}="{FuzzyOWL2Keyword.AXIOM.get_str_value()}">\n'
-            f'\t<{FuzzyOWL2Keyword.DEGREE_DEF.get_tag_name()} {FuzzyOWL2Keyword.DEGREE_VALUE.get_str_value()}="{n}"/>\n'
-            f"</{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()}>"
-        )
+        main_xml = FuzzyXML.build_main_xml(FuzzyOWL2Keyword.AXIOM.get_str_value())
+        degree_xml = FuzzyXML.build_degree_xml(n)
+        main_xml.append(degree_xml)
+        annotation_text: str = FuzzyXML.to_str(main_xml)
+
+        # annotation_text: str = (
+        #     f'<{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()} {FuzzyOWL2Keyword.FUZZY_TYPE.get_str_value()}="{FuzzyOWL2Keyword.AXIOM.get_str_value()}">\n'
+        #     f'\t<{FuzzyOWL2Keyword.DEGREE_DEF.get_tag_name()} {FuzzyOWL2Keyword.DEGREE_VALUE.get_str_value()}="{n}"/>\n'
+        #     f"</{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()}>"
+        # )
         annotation: OWLAnnotation = self.to_owl_annotation(annotation_text)
         return set([annotation])
 
@@ -590,11 +662,17 @@ class FuzzydlToOwl2:
         logic = str(constants.KNOWLEDGE_BASE_SEMANTICS)
 
         if logic:
-            annotation: str = (
-                f'<{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()} {FuzzyOWL2Keyword.FUZZY_TYPE.get_str_value()}="{FuzzyOWL2Keyword.ONTOLOGY.get_str_value()}">\n'
-                f'\t<{FuzzyOWL2Keyword.FUZZY_LOGIC.get_tag_name()} {FuzzyOWL2Keyword.LOGIC.get_str_value()}="{logic}" />\n'
-                f"</{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()}>"
+            main_xml = FuzzyXML.build_main_xml(
+                FuzzyOWL2Keyword.ONTOLOGY.get_str_value()
             )
+            logic_xml = FuzzyXML.build_logic_xml(logic)
+            main_xml.append(logic_xml)
+            annotation: str = FuzzyXML.to_str(main_xml)
+            # annotation: str = (
+            #     f'<{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()} {FuzzyOWL2Keyword.FUZZY_TYPE.get_str_value()}="{FuzzyOWL2Keyword.ONTOLOGY.get_str_value()}">\n'
+            #     f'\t<{FuzzyOWL2Keyword.FUZZY_LOGIC.get_tag_name()} {FuzzyOWL2Keyword.LOGIC.get_str_value()}="{logic}" />\n'
+            #     f"</{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()}>"
+            # )
             self.add_ontology_annotation(annotation)
 
         # Process concrete concepts
@@ -813,7 +891,8 @@ class FuzzydlToOwl2:
         current_datatype: OWLDatatype = OWLDatatype(self.iri(c))
         self.datatypes[str(c)] = current_datatype
 
-        specific: str = self._get_concrete_concept_specifics(c)
+        # specific: str = self._get_concrete_concept_specifics(c)
+        specific: tuple[str, dict[str, str]] = self._get_concrete_concept_specifics(c)
 
         int_datatype: OWLDatatype = OWLDatatype(XSD.integer)
         greater_than: OWLDatatypeRestriction = OWLDatatypeRestriction(
@@ -843,45 +922,102 @@ class FuzzydlToOwl2:
         self.ontology.add_axiom(OWLDeclaration(current_datatype))
         self.ontology.add_axiom(definition)
 
-        annotation: str = (
-            f'<{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()} {FuzzyOWL2Keyword.FUZZY_TYPE.get_str_value()}="{FuzzyOWL2Keyword.DATATYPE.get_str_value()}">\n'
-            f'\t<{FuzzyOWL2Keyword.DATATYPE.get_tag_name()} {FuzzyOWL2Keyword.TYPE.get_str_value()}="{specific}"/>\n'
-            f"</{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()}>"
-        )
+        main_xml = FuzzyXML.build_main_xml(FuzzyOWL2Keyword.DATATYPE.get_str_value())
+        datatype_xml = FuzzyXML.build_datatype_xml(specific[0], specific[1])
+        main_xml.append(datatype_xml)
+        annotation: str = FuzzyXML.to_str(main_xml)
+
+        # annotation: str = (
+        #     f'<{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()} {FuzzyOWL2Keyword.FUZZY_TYPE.get_str_value()}="{FuzzyOWL2Keyword.DATATYPE.get_str_value()}">\n'
+        #     f'\t<{FuzzyOWL2Keyword.DATATYPE.get_tag_name()} {FuzzyOWL2Keyword.TYPE.get_str_value()}="{specific}"/>\n'
+        #     f"</{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()}>"
+        # )
         self.add_entity_annotation(annotation, current_datatype)
 
-    def _get_concrete_concept_specifics(self, c: FuzzyConcreteConcept) -> str:
+    def _get_concrete_concept_specifics(
+        self, c: FuzzyConcreteConcept
+    ) -> tuple[str, dict[str, str]]:
         """Get concrete concept specific parameters"""
         if isinstance(c, CrispConcreteConcept):
-            return f'{FuzzyOWL2Keyword.CRISP.get_str_value()}" {FuzzyOWL2Keyword.A.get_str_value()}="{c.a}" {FuzzyOWL2Keyword.B.get_str_value()}="{c.b}'
+            return FuzzyOWL2Keyword.CRISP.get_str_value(), {
+                FuzzyOWL2Keyword.A.get_str_value(): str(c.a),
+                FuzzyOWL2Keyword.B.get_str_value(): str(c.b),
+            }
         elif isinstance(c, LeftConcreteConcept):
-            return f'{FuzzyOWL2Keyword.LEFT_SHOULDER.get_str_value()}" {FuzzyOWL2Keyword.A.get_str_value()}="{c.a}" {FuzzyOWL2Keyword.B.get_str_value()}="{c.b}'
+            return FuzzyOWL2Keyword.LEFT_SHOULDER.get_str_value(), {
+                FuzzyOWL2Keyword.A.get_str_value(): str(c.a),
+                FuzzyOWL2Keyword.B.get_str_value(): str(c.b),
+            }
         elif isinstance(c, RightConcreteConcept):
-            return f'{FuzzyOWL2Keyword.RIGHT_SHOULDER.get_str_value()}" {FuzzyOWL2Keyword.A.get_str_value()}="{c.a}" {FuzzyOWL2Keyword.B.get_str_value()}="{c.b}'
+            return FuzzyOWL2Keyword.RIGHT_SHOULDER.get_str_value(), {
+                FuzzyOWL2Keyword.A.get_str_value(): str(c.a),
+                FuzzyOWL2Keyword.B.get_str_value(): str(c.b),
+            }
         elif isinstance(c, TriangularConcreteConcept):
-            return f'{FuzzyOWL2Keyword.TRIANGULAR.get_str_value()}" {FuzzyOWL2Keyword.A.get_str_value()}="{c.a}" {FuzzyOWL2Keyword.B.get_str_value()}="{c.b}" {FuzzyOWL2Keyword.C.get_str_value()}="{c.c}'
+            return FuzzyOWL2Keyword.TRIANGULAR.get_str_value(), {
+                FuzzyOWL2Keyword.A.get_str_value(): str(c.a),
+                FuzzyOWL2Keyword.B.get_str_value(): str(c.b),
+                FuzzyOWL2Keyword.C.get_str_value(): str(c.c),
+            }
         elif isinstance(c, TrapezoidalConcreteConcept):
-            return f'{FuzzyOWL2Keyword.TRAPEZOIDAL.get_str_value()}" {FuzzyOWL2Keyword.A.get_str_value()}="{c.a}" {FuzzyOWL2Keyword.B.get_str_value()}="{c.b}" {FuzzyOWL2Keyword.C.get_str_value()}="{c.c}" {FuzzyOWL2Keyword.D.get_str_value()}="{c.d}'
-        return ""
+            return FuzzyOWL2Keyword.TRAPEZOIDAL.get_str_value(), {
+                FuzzyOWL2Keyword.A.get_str_value(): str(c.a),
+                FuzzyOWL2Keyword.B.get_str_value(): str(c.b),
+                FuzzyOWL2Keyword.C.get_str_value(): str(c.c),
+                FuzzyOWL2Keyword.D.get_str_value(): str(c.d),
+            }
+        return "", dict()
+
+    # def _get_concrete_concept_specifics(self, c: FuzzyConcreteConcept) -> str:
+    #     """Get concrete concept specific parameters"""
+    #     if isinstance(c, CrispConcreteConcept):
+    #         return f'{FuzzyOWL2Keyword.CRISP.get_str_value()}" {FuzzyOWL2Keyword.A.get_str_value()}="{c.a}" {FuzzyOWL2Keyword.B.get_str_value()}="{c.b}'
+    #     elif isinstance(c, LeftConcreteConcept):
+    #         return f'{FuzzyOWL2Keyword.LEFT_SHOULDER.get_str_value()}" {FuzzyOWL2Keyword.A.get_str_value()}="{c.a}" {FuzzyOWL2Keyword.B.get_str_value()}="{c.b}'
+    #     elif isinstance(c, RightConcreteConcept):
+    #         return f'{FuzzyOWL2Keyword.RIGHT_SHOULDER.get_str_value()}" {FuzzyOWL2Keyword.A.get_str_value()}="{c.a}" {FuzzyOWL2Keyword.B.get_str_value()}="{c.b}'
+    #     elif isinstance(c, TriangularConcreteConcept):
+    #         return f'{FuzzyOWL2Keyword.TRIANGULAR.get_str_value()}" {FuzzyOWL2Keyword.A.get_str_value()}="{c.a}" {FuzzyOWL2Keyword.B.get_str_value()}="{c.b}" {FuzzyOWL2Keyword.C.get_str_value()}="{c.c}'
+    #     elif isinstance(c, TrapezoidalConcreteConcept):
+    #         return f'{FuzzyOWL2Keyword.TRAPEZOIDAL.get_str_value()}" {FuzzyOWL2Keyword.A.get_str_value()}="{c.a}" {FuzzyOWL2Keyword.B.get_str_value()}="{c.b}" {FuzzyOWL2Keyword.C.get_str_value()}="{c.c}" {FuzzyOWL2Keyword.D.get_str_value()}="{c.d}'
+    #     return ""
 
     def _process_modifier(self, mod: Modifier) -> None:
         """Process a modifier"""
         Util.debug(f"Process modifier -> {mod}")
+
+        main_xml = FuzzyXML.build_main_xml(FuzzyOWL2Keyword.MODIFIER.get_str_value())
+
         if isinstance(mod, LinearModifier):
-            annotation: str = (
-                f'<{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()} {FuzzyOWL2Keyword.FUZZY_TYPE.get_str_value()}="{FuzzyOWL2Keyword.MODIFIER.get_str_value()}">\n'
-                f'\t<{FuzzyOWL2Keyword.MODIFIER.get_tag_name()} {FuzzyOWL2Keyword.TYPE.get_str_value()}="{FuzzyOWL2Keyword.LINEAR.get_str_value()}" {FuzzyOWL2Keyword.C.get_str_value()}="{mod.c}"/>\n'
-                f"</{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()}>"
+            modifier_xml = FuzzyXML.build_modifier_xml(
+                FuzzyOWL2Keyword.LINEAR.get_str_value(),
+                {FuzzyOWL2Keyword.C.get_str_value(): str(mod.c)},
             )
+            # annotation: str = (
+            #     f'<{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()} {FuzzyOWL2Keyword.FUZZY_TYPE.get_str_value()}="{FuzzyOWL2Keyword.MODIFIER.get_str_value()}">\n'
+            #     f'\t<{FuzzyOWL2Keyword.MODIFIER.get_tag_name()} {FuzzyOWL2Keyword.TYPE.get_str_value()}="{FuzzyOWL2Keyword.LINEAR.get_str_value()}" {FuzzyOWL2Keyword.C.get_str_value()}="{mod.c}"/>\n'
+            #     f"</{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()}>"
+            # )
         elif isinstance(mod, TriangularModifier):
-            annotation: str = (
-                f'<{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()} {FuzzyOWL2Keyword.FUZZY_TYPE.get_str_value()}="{FuzzyOWL2Keyword.MODIFIER.get_str_value()}">\n'
-                f'\t<{FuzzyOWL2Keyword.MODIFIER.get_tag_name()} {FuzzyOWL2Keyword.TYPE.get_str_value()}="{FuzzyOWL2Keyword.TRIANGULAR.get_str_value()}" {FuzzyOWL2Keyword.A.get_str_value()}="{mod.a}" {FuzzyOWL2Keyword.B.get_str_value()}="{mod.b}" {FuzzyOWL2Keyword.C.get_str_value()}="{mod.c}"/>\n'
-                f"</{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()}>"
+            modifier_xml = FuzzyXML.build_modifier_xml(
+                FuzzyOWL2Keyword.TRIANGULAR.get_str_value(),
+                {
+                    FuzzyOWL2Keyword.A.get_str_value(): str(mod.a),
+                    FuzzyOWL2Keyword.B.get_str_value(): str(mod.b),
+                    FuzzyOWL2Keyword.C.get_str_value(): str(mod.c),
+                },
             )
+            # annotation: str = (
+            #     f'<{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()} {FuzzyOWL2Keyword.FUZZY_TYPE.get_str_value()}="{FuzzyOWL2Keyword.MODIFIER.get_str_value()}">\n'
+            #     f'\t<{FuzzyOWL2Keyword.MODIFIER.get_tag_name()} {FuzzyOWL2Keyword.TYPE.get_str_value()}="{FuzzyOWL2Keyword.TRIANGULAR.get_str_value()}" {FuzzyOWL2Keyword.A.get_str_value()}="{mod.a}" {FuzzyOWL2Keyword.B.get_str_value()}="{mod.b}" {FuzzyOWL2Keyword.C.get_str_value()}="{mod.c}"/>\n'
+            #     f"</{FuzzyOWL2Keyword.FUZZY_OWL_2.get_str_value()}>"
+            # )
         else:
             raise ValueError(f"Unknown modifier type: {type(mod)}")
 
+        main_xml.append(modifier_xml)
+        annotation: str = FuzzyXML.to_str(main_xml)
+
         current_datatype: OWLDatatype = OWLDatatype(self.iri(mod))
         self.modifiers[str(mod)] = current_datatype
         self.ontology.add_axiom(OWLDeclaration(current_datatype))

fuzzy_dl_owl2/fuzzydl/util/__init__.py

@@ -1,3 +1,4 @@
 from .config_reader import ConfigReader
 from .util import Util
 from .utils import *
+from .constants import *

fuzzy_dl_owl2/fuzzyowl2/fuzzyowl2.py

@@ -35,7 +35,7 @@ from fuzzy_dl_owl2.fuzzyowl2.owl_types.weighted_sum_concept import WeightedSumCo
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.weighted_sum_zero_concept import (
     WeightedSumZeroConcept,
 )
-from fuzzy_dl_owl2.fuzzyowl2.parser.owl2_parser import FuzzyOwl2Parser
+from fuzzy_dl_owl2.fuzzyowl2.parser.owl2_xml_parser import FuzzyOwl2XMLParser
 from pyowl2.abstracts.annotation_value import OWLAnnotationValue
 from pyowl2.abstracts.axiom import OWLAxiom
 from pyowl2.abstracts.class_expression import OWLClassExpression
@@ -166,7 +166,7 @@ class FuzzyOwl2(object):
         self.processed_axioms: set[str] = set()
         self.ontologies: set[OWLOntology] = set()
 
-        FuzzyOwl2Parser.load_config()
+        FuzzyOwl2XMLParser.load_config()
 
         self.ontology_path = input_file
         self.ontology_iri = IRI(Namespace(base_iri))
@@ -200,9 +200,13 @@ class FuzzyOwl2(object):
                 if annotation.annotation_property != self.fuzzy_label:
                     continue
                 value: OWLAnnotationValue = annotation.annotation_value
-                annotation_str: str = str(value).replace('"', "")
+                annotation_str: str = str(value)
                 Util.debug(f"Annotation for ontology -> {annotation_str}")
-                self.write_fuzzy_logic(FuzzyOwl2Parser.parse_string(annotation_str)[0])
+                logic: typing.Optional[str] = FuzzyOwl2XMLParser.parse_string(
+                    annotation_str
+                )
+                Util.debug(f"Parsed annotation -> {logic}")
+                self.write_fuzzy_logic(logic)
 
     def __get_facets(self, name: str) -> list[float]:
         facets: list[float] = [float("-inf"), float("inf")]
@@ -282,13 +286,14 @@ class FuzzyOwl2(object):
                         f"Error: There are {len(annotations)} datatype annotations for {datatype}"
                     )
                 annotation: OWLAnnotation = list(annotations)[0].annotation_value
-                annotation_str: str = str(annotation).replace('"', "")
+                annotation_str: str = str(annotation)
                 Util.debug(f"Annotation for {datatype} -> {annotation_str}")
                 datatype_name: str = self.get_short_name(datatype)
                 facets: list[OWLFacet] = self.__get_facets(datatype_name)
                 c: typing.Union[ConceptDefinition, FuzzyModifier] = (
-                    FuzzyOwl2Parser.parse_string(annotation_str)[0]
+                    FuzzyOwl2XMLParser.parse_string(annotation_str)
                 )
+                Util.debug(f"Parsed annotation -> {c}")
                 if isinstance(c, FuzzyDatatype):
                     c.set_min_value(facets[0])
                     c.set_max_value(facets[1])
@@ -330,12 +335,12 @@ class FuzzyOwl2(object):
                         f"Error: There are {len(annotations)} class annotations for {cls}"
                     )
                 annotation: OWLAnnotation = list(annotations)[0].annotation_value
-                annotation_str: str = str(annotation).replace('"', "")
+                annotation_str: str = str(annotation)
                 Util.debug(f"Annotation for concept {cls} -> {annotation_str}")
-                concept: ConceptDefinition = FuzzyOwl2Parser.parse_string(
+                concept: ConceptDefinition = FuzzyOwl2XMLParser.parse_string(
                     annotation_str
-                )[0]
-                Util.debug(f"Concept -> {concept}")
+                )
+                Util.debug(f"Parsed annotation -> {concept}")
                 name: str = self.get_short_name(cls)
                 if isinstance(concept, ModifiedConcept):
                     mod_name: str = concept.get_fuzzy_modifier()
@@ -401,11 +406,12 @@ class FuzzyOwl2(object):
                         f"Error: There are {len(annotations)} property annotations for {property}"
                     )
                 annotation: OWLAnnotation = list(annotations)[0].annotation_value
-                annotation_str: str = str(annotation).replace('"', "")
+                annotation_str: str = str(annotation)
                 Util.debug(f"Annotation for property {property} -> {annotation_str}")
                 prop: typing.Optional[ModifiedProperty] = (
-                    FuzzyOwl2Parser.parse_string(annotation_str)
-                )[0]
+                    FuzzyOwl2XMLParser.parse_string(annotation_str)
+                )
+                Util.debug(f"Parsed annotation -> {prop}")
                 if prop is None:
                     return
                 if not isinstance(prop, ModifiedProperty):
@@ -428,10 +434,10 @@ class FuzzyOwl2(object):
                 f"Error: There are {len(annotations)} annotations for axiom {axiom}."
             )
         annotation: OWLAnnotation = list(annotations)[0].annotation_value
-        annotation_str: str = str(annotation).replace('"', "")
+        annotation_str: str = str(annotation)
         Util.debug(f"Annotation for degree -> {annotation_str}")
-        deg: float = FuzzyOwl2Parser.parse_string(annotation_str)[0]
-        Util.debug(f"Degree for axiom -> {deg}")
+        deg: float = FuzzyOwl2XMLParser.parse_string(annotation_str)
+        Util.debug(f"Parsed annotation -> {deg}")
         if not isinstance(deg, constants.NUMBER):
             raise ValueError
         return deg

fuzzy_dl_owl2/fuzzyowl2/owl_types/modified_property.py

@@ -4,7 +4,7 @@ from fuzzy_dl_owl2.fuzzyowl2.owl_types.fuzzy_property import FuzzyProperty
 class ModifiedProperty(FuzzyProperty):
 
     def __init__(self, mod: str, prop: str) -> None:
-        super.__init__()
+        super().__init__()
         self._mod: str = mod
         self._prop: str = prop
 
@@ -13,3 +13,9 @@ class ModifiedProperty(FuzzyProperty):
 
     def get_property(self) -> str:
         return self._prop
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    def __str__(self) -> str:
+        return f"({self.get_fuzzy_modifier()}, {self.get_property()})"

fuzzy_dl_owl2/fuzzyowl2/parser/__init__.py

@@ -1 +1,2 @@
-from .owl2_parser import *
+# from .owl2_parser import *
+from .owl2_xml_parser import *

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
 
 

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:]
+            ),
+        )

{fuzzy_dl_owl2-1.0.5.dist-info → fuzzy_dl_owl2-1.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: fuzzy-dl-owl2
-Version: 1.0.5
+Version: 1.0.6
 Summary: A python porting of the Fuzzy Description Language (see https://www.umbertostraccia.it/cs/software/fuzzyDL/fuzzyDL.html) and the Fuzzy OWL 2 framework (see https://www.umbertostraccia.it/cs/software/FuzzyOWL/index.html).
 License: CC-BY-SA-4.0
 Author: Giuseppe Filippone

{fuzzy_dl_owl2-1.0.5.dist-info → fuzzy_dl_owl2-1.0.6.dist-info}/RECORD

@@ -62,7 +62,7 @@ fuzzy_dl_owl2/fuzzydl/exception/__init__.py,sha256=IoYY5IQoU4UYyoB-dFOVLZyDvJN20
 fuzzy_dl_owl2/fuzzydl/exception/fuzzy_ontology_exception.py,sha256=eH1ybBCx1QoZaf8PLCq1rC_3tiBRA-gKCwECTcUUuro,122
 fuzzy_dl_owl2/fuzzydl/exception/inconsistent_ontology_exception.py,sha256=ez0RQN4KGlNRcfB7IXfPz3bM86CFLl6zo-RRTBRpa_o,129
 fuzzy_dl_owl2/fuzzydl/feature_function.py,sha256=KSQvCSYfJK5N6FFfDlyS1Y7UPHSYZNXzdYYZMWzXF8U,6399
-fuzzy_dl_owl2/fuzzydl/fuzzydl_to_owl2.py,sha256=BUt-LUHW9VPtUNT74zPblgbClwuQL8_HN6gXMQ2_X8k,46670
+fuzzy_dl_owl2/fuzzydl/fuzzydl_to_owl2.py,sha256=aqFuf7xH7_5fJL57RlLhN2tzpQEX8i6LzlTmKRAkZak,53023
 fuzzy_dl_owl2/fuzzydl/general_concept_inclusion.py,sha256=Noom35WAeJosPrliGd9_gvEtcK4BthazsSuZH-cxfyU,2380
 fuzzy_dl_owl2/fuzzydl/individual/__init__.py,sha256=zBCa24kE2nv08VgtphjLshpbGNEARUJgCdtyv9r6JGc,110
 fuzzy_dl_owl2/fuzzydl/individual/created_individual.py,sha256=HOo_UXjPPPtm7B0a7k90kE1veuR9gOCK5hp2f_aaJnY,7653
@@ -117,13 +117,13 @@ fuzzy_dl_owl2/fuzzydl/restriction/__init__.py,sha256=rpjzuQK3xxYYA3WeXFDdIK9tXbU
 fuzzy_dl_owl2/fuzzydl/restriction/has_value_restriction.py,sha256=DL-50TlD289OXVEEh_tK9Cu0ceP0ANmH-Q3k0oRe5ok,554
 fuzzy_dl_owl2/fuzzydl/restriction/restriction.py,sha256=SyeFvaJeKcTe750eAbLoAVYkWTK_UjdqWr2Lw8OF1S0,948
 fuzzy_dl_owl2/fuzzydl/role_parent_with_degree.py,sha256=1J5dtlVbiascxHBwAJ7uc97IHnJke9RWqxq5rgrrkoA,282
-fuzzy_dl_owl2/fuzzydl/util/__init__.py,sha256=44tug6cK4CwfOR865-q1FOVN34TEDzfLlaevh5YMiGo,84
+fuzzy_dl_owl2/fuzzydl/util/__init__.py,sha256=3GufSMUuWGISGukXM5T5ZGA0BC1WX-5eLFSuttVYueU,109
 fuzzy_dl_owl2/fuzzydl/util/config_reader.py,sha256=8kyrfK-wQaiGrKfrLsiVr77jg1NRaviGniWOtQwrZRU,1797
 fuzzy_dl_owl2/fuzzydl/util/constants.py,sha256=_BM9maPkVPzz-GjWjVHjPEtNOA72c5R4qjP9w-2bAdQ,12817
 fuzzy_dl_owl2/fuzzydl/util/util.py,sha256=5COC79TAJz8fNrRzXLbNpAT9rLd_0KrRI1OU-hob3oU,1903
 fuzzy_dl_owl2/fuzzydl/util/utils.py,sha256=TPVLEL9NJXgReuxEIOTEOVYqojSymg_-kyrLETXnYdo,2344
 fuzzy_dl_owl2/fuzzyowl2/__init__.py,sha256=C44P0-Sn35FQdVMqYLzeDWa5qPmokbcs8GPiD_zQaSg,153
-fuzzy_dl_owl2/fuzzyowl2/fuzzyowl2.py,sha256=EAC_DXYa694h3pUZ9T_4Y_f60DjzPUs4VqIGbpLY5vo,71402
+fuzzy_dl_owl2/fuzzyowl2/fuzzyowl2.py,sha256=5nMIJfNxes5OXyGJxFkdG5VIueOUaK-5TNN4KMLeESk,71603
 fuzzy_dl_owl2/fuzzyowl2/fuzzyowl2_to_fuzzydl.py,sha256=egspxTzY4kNvhsQLP0AAaqJgFUqyO6VJuXLLOej06PA,36994
 fuzzy_dl_owl2/fuzzyowl2/owl_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fuzzy_dl_owl2/fuzzyowl2/owl_types/choquet_concept.py,sha256=ymnyNfvkvWA3y2UMXyPviD0U98vJ6jrX6zddj09SUoI,671
@@ -137,7 +137,7 @@ fuzzy_dl_owl2/fuzzyowl2/owl_types/linear_function.py,sha256=3MZR09E0AhUTEHQZY_RU
 fuzzy_dl_owl2/fuzzyowl2/owl_types/linear_modifier.py,sha256=CIm4rlSuvcI9dqLscASFHexjHKcJ06Wg3fZy__tw7H4,340
 fuzzy_dl_owl2/fuzzyowl2/owl_types/modified_concept.py,sha256=JdjSemKb-mnVtVQhHnk_OAU8cvB3YRRmmEF0DLrtdXk,555
 fuzzy_dl_owl2/fuzzyowl2/owl_types/modified_function.py,sha256=3_GFKWMU4YrPrMC7bhEm7GDUKtCko8H5wx2dpGdXGZc,428
-fuzzy_dl_owl2/fuzzyowl2/owl_types/modified_property.py,sha256=uA7PlBGCbHcrjqYHIDWgsIvI_x3dpzTEJKtEfNRivwA,384
+fuzzy_dl_owl2/fuzzyowl2/owl_types/modified_property.py,sha256=d94ZQRWJ_BoH0lvM_XuwexeAlQGDZDB6Lq0WaO9acaQ,545
 fuzzy_dl_owl2/fuzzyowl2/owl_types/owa_concept.py,sha256=rQNp8zSQ-tQYwcJsc3sCVhG1chtZ7Ev1MumSBOPbOwI,659
 fuzzy_dl_owl2/fuzzyowl2/owl_types/property_definition.py,sha256=5NZd22GcaPQKCrIZwCGzPgx1M5h41A3tH9qKI_m2WVc,268
 fuzzy_dl_owl2/fuzzyowl2/owl_types/qowa_concept.py,sha256=yfErtkNIWWW-QUgA4T6F7tL-sCPC0GXYYkR2xT8LHKk,598
@@ -152,11 +152,13 @@ fuzzy_dl_owl2/fuzzyowl2/owl_types/weighted_max_concept.py,sha256=NEIshfx9h4XyvfO
 fuzzy_dl_owl2/fuzzyowl2/owl_types/weighted_min_concept.py,sha256=_sEao87lwH2fKspVR_NrpilFwuI6g25E1mNDI55dtYk,510
 fuzzy_dl_owl2/fuzzyowl2/owl_types/weighted_sum_concept.py,sha256=TrX3-M-LrG-5XgEo6LY8JESZpYwcaIX4rOCU8wfWE4k,510
 fuzzy_dl_owl2/fuzzyowl2/owl_types/weighted_sum_zero_concept.py,sha256=OJW8-ZJXvYTFHrqC8hpVBTY6SwLCTTIe72MSAO3H7hk,524
-fuzzy_dl_owl2/fuzzyowl2/parser/__init__.py,sha256=fKaME_uuWyG5UB7VKD-nMV-j95lC1jWV6E6vD59yM4M,27
-fuzzy_dl_owl2/fuzzyowl2/parser/owl2_parser.py,sha256=wSE5FBCfv3t-XePJ9Pzyr_EVFTPWtMrtMyqHNgKd9aw,20052
-fuzzy_dl_owl2/fuzzyowl2/util/__init__.py,sha256=81quoggCuIypZjZs3bbf1Ty70KHdva5RGEJxi0oC57E,25
-fuzzy_dl_owl2/fuzzyowl2/util/constants.py,sha256=05eQLYTB4CxxUZ_T-sNG9FsH8hkrBMAh2y24oiQN8xY,3904
-fuzzy_dl_owl2-1.0.5.dist-info/LICENSE,sha256=er4Z7Ju3OzYUG5mbhh0krYVegIuv4PgehMzihVb2wpc,20131
-fuzzy_dl_owl2-1.0.5.dist-info/METADATA,sha256=uPCNsrud2pSsRiLl4hydpRIAehnILDZcLgZF3iLs3y4,13057
-fuzzy_dl_owl2-1.0.5.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-fuzzy_dl_owl2-1.0.5.dist-info/RECORD,,
+fuzzy_dl_owl2/fuzzyowl2/parser/__init__.py,sha256=HjRhpobpAAB569symjAAoN98RVIqo0P6KtsVLDxC3Ok,60
+fuzzy_dl_owl2/fuzzyowl2/parser/owl2_parser.py,sha256=6rwMT_dGaaaKZQRotGiidbwqCOpLuPkyXaHXGQ5CV1k,20068
+fuzzy_dl_owl2/fuzzyowl2/parser/owl2_xml_parser.py,sha256=qbx6SsrYUdDOn1-qClq-0ECIZ24MKPJCeAuvl6rwk_s,11234
+fuzzy_dl_owl2/fuzzyowl2/util/__init__.py,sha256=4qG4CwkdYoT0vh3uX9N8DlmXh4QfKimVUqR4h2DR8Gg,50
+fuzzy_dl_owl2/fuzzyowl2/util/constants.py,sha256=Oev5Q-H4mhmdvV3nrp0fZKZx8jpo9beXjJwm0dfDUSc,6970
+fuzzy_dl_owl2/fuzzyowl2/util/fuzzy_xml.py,sha256=iYAodtBkZYt3cOvMBA0VEMOU87ljb-06_aUfH14gvwE,3416
+fuzzy_dl_owl2-1.0.6.dist-info/LICENSE,sha256=er4Z7Ju3OzYUG5mbhh0krYVegIuv4PgehMzihVb2wpc,20131
+fuzzy_dl_owl2-1.0.6.dist-info/METADATA,sha256=BjS_oE4GrApDHsEvGzus0rGZ6yXtLmf_U3ZmBa9VVe8,13057
+fuzzy_dl_owl2-1.0.6.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+fuzzy_dl_owl2-1.0.6.dist-info/RECORD,,