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

fuzzy_dl_owl2/fuzzydl/fuzzydl_to_owl2.py

@@ -5,6 +5,8 @@ import sys
 import typing
 from functools import partial
 
+from rdflib import RDF, XSD, Literal, Namespace, URIRef
+
 from fuzzy_dl_owl2.fuzzydl.assertion.assertion import Assertion
 from fuzzy_dl_owl2.fuzzydl.concept.all_some_concept import AllSomeConcept
 from fuzzy_dl_owl2.fuzzydl.concept.choquet_integral import ChoquetIntegral
@@ -62,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
@@ -125,7 +128,6 @@ from pyowl2.expressions.object_property import OWLObjectProperty
 from pyowl2.individual.named_individual import OWLNamedIndividual
 from pyowl2.literal.literal import OWLLiteral
 from pyowl2.ontology import OWLOntology
-from rdflib import RDF, XSD, Literal, Namespace, URIRef
 
 
 # @utils.timer_decorator
@@ -275,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:
@@ -330,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 (
@@ -346,12 +372,14 @@ class FuzzydlToOwl2:
             return self.__get_class_weighted_min_max_sum(c)
         elif c_type in (
             ConceptType.OWA,
-            ConceptType.QUANTIFIED_OWA,
+            # ConceptType.QUANTIFIED_OWA,
             ConceptType.CHOQUET_INTEGRAL,
             ConceptType.SUGENO_INTEGRAL,
             ConceptType.QUASI_SUGENO_INTEGRAL,
         ):
             return self.__get_class_weighted(c)
+        elif c_type == ConceptType.QUANTIFIED_OWA:
+            return self.__get_class_q_owa(c)
         cls = OWLClass(self.iri(str(c)))
         self.ontology.add_axiom(OWLDeclaration(cls))
         return cls
@@ -375,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
 
@@ -392,14 +437,14 @@ class FuzzydlToOwl2:
         """Get the class for OWA, Quantified OWA, Choquet Integral, Sugeno Integral, or Quasi Sugeno Integral"""
         type_dict: dict[ConceptType, str] = {
             ConceptType.OWA: FuzzyOWL2Keyword.OWA.get_str_value(),
-            ConceptType.QUANTIFIED_OWA: FuzzyOWL2Keyword.Q_OWA.get_str_value(),
+            # ConceptType.QUANTIFIED_OWA: FuzzyOWL2Keyword.Q_OWA.get_str_value(),
             ConceptType.CHOQUET_INTEGRAL: FuzzyOWL2Keyword.CHOQUET.get_str_value(),
             ConceptType.SUGENO_INTEGRAL: FuzzyOWL2Keyword.SUGENO.get_str_value(),
             ConceptType.QUASI_SUGENO_INTEGRAL: FuzzyOWL2Keyword.QUASI_SUGENO.get_str_value(),
         }
         type_cast: dict[ConceptType, typing.Callable] = {
             ConceptType.OWA: partial(typing.cast, OwaConcept),
-            ConceptType.QUANTIFIED_OWA: partial(typing.cast, QowaConcept),
+            # ConceptType.QUANTIFIED_OWA: partial(typing.cast, QowaConcept),
             ConceptType.CHOQUET_INTEGRAL: partial(typing.cast, ChoquetIntegral),
             ConceptType.SUGENO_INTEGRAL: partial(typing.cast, SugenoIntegral),
             ConceptType.QUASI_SUGENO_INTEGRAL: partial(typing.cast, QsugenoIntegral),
@@ -408,18 +453,67 @@ 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]
+        )
+        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
+
+    def __get_class_q_owa(self, c: Concept) -> OWLClassExpression:
+        """Get the class for OWA, Quantified OWA, Choquet Integral, Sugeno Integral, or Quasi Sugeno Integral"""
+        type_dict: dict[ConceptType, str] = {
+            ConceptType.QUANTIFIED_OWA: FuzzyOWL2Keyword.Q_OWA.get_str_value(),
+        }
+        type_cast: dict[ConceptType, typing.Callable] = {
+            ConceptType.QUANTIFIED_OWA: partial(typing.cast, QowaConcept),
+        }
+        if c.type not in type_dict:
+            return None
+        curr_concept: QowaConcept = type_cast[c.type](c)
+        c4: OWLClassExpression = self.get_new_atomic_class(str(c))
+
+        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)},
+        )
+        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(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
 
@@ -522,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])
 
@@ -563,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
@@ -786,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(
@@ -816,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/fuzzyowl2_to_fuzzydl.py

@@ -48,7 +48,6 @@ from pyowl2.expressions.data_property import OWLDataProperty
 from pyowl2.expressions.object_property import OWLObjectProperty
 from pyowl2.individual.anonymous_individual import OWLAnonymousIndividual
 from pyowl2.literal.literal import OWLLiteral
-from pyowl2.utils import utils
 
 
 # @utils.timer_decorator
@@ -608,7 +607,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
         d: float,
     ) -> None:
         self.__write(
-            f"(implies-role {self.get_object_property_name(subproperty)} {self.get_object_property_name(superproperty)} {d})"
+            f"(implies-role {self.get_data_property_name(subproperty)} {self.get_data_property_name(superproperty)} {d})"
         )
 
     def write_sub_property_chain_of_axiom(
@@ -635,9 +634,9 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
         self, class_set: set[OWLDataPropertyExpression]
     ) -> None:
         first: OWLDataPropertyExpression = next(class_set)
-        first_name: str = self.get_object_property_name(first)
+        first_name: str = self.get_data_property_name(first)
         for property in class_set - set([first]):
-            property_name: str = self.get_object_property_name(property)
+            property_name: str = self.get_data_property_name(property)
             self.__write(f"(implies-role {first_name} {property_name})")
             self.__write(f"(implies-role {property_name} {first_name})")
 

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 *