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

fuzzy_dl_owl2/fuzzydl/milp/term.py

@@ -64,11 +64,14 @@ class Term:
     def __eq__(self, term: typing.Self) -> bool:
         if not isinstance(term, Term):
             return False
-        return self.var == term.var
+        return self.var == term.var and self.coeff == term.coeff
 
     def __ne__(self, term: typing.Self) -> bool:
         return not (self == term)
 
+    def __hash__(self) -> int:
+        return hash(str(self))
+
     def __repr__(self) -> str:
         return str(self)
 

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/fuzzydl/util/config_reader.py

@@ -1,19 +1,42 @@
 from __future__ import annotations
 
 import configparser
+import enum
 import math
 
+from fuzzy_dl_owl2.fuzzydl.util import constants
+
+
+class MILPProvider(enum.StrEnum):
+    GUROBI = enum.auto()
+    MIP = enum.auto()
+    # SCIPY = enum.auto()
+    PULP = enum.auto()
+    PULP_GLPK = enum.auto()
+    PULP_HIGHS = enum.auto()
+    PULP_CPLEX = enum.auto()
+
+    @staticmethod
+    def from_str(value: str) -> MILPProvider:
+        try:
+            return MILPProvider(value.lower())
+        except ValueError:
+            raise ValueError(
+                f"Invalid MILP provider: {value}. Valid options are: {list(MILPProvider)}"
+            )
+
 
 class ConfigReader:
     ANYWHERE_DOUBLE_BLOCKING: bool = True
     ANYWHERE_SIMPLE_BLOCKING: bool = True
-    RELAX_MILP: bool = False
     DEBUG_PRINT: bool = True
     EPSILON: float = 0.001
     MAX_INDIVIDUALS: int = -1
     NUMBER_DIGITS: int = 2
     OPTIMIZATIONS: int = 1
     RULE_ACYCLIC_TBOXES: bool = True
+    OWL_ANNOTATION_LABEL: str = "fuzzyLabel"
+    MILP_PROVIDER: MILPProvider = MILPProvider.GUROBI
 
     @staticmethod
     def load_parameters(config_file: str, args: list[str]) -> None:
@@ -33,13 +56,32 @@ class ConfigReader:
             #         "author": False,
             #     }
 
-            ConfigReader.RELAX_MILP = config.getboolean("DEFAULT", "relaxMilp")
             ConfigReader.DEBUG_PRINT = config.getboolean("DEFAULT", "debugPrint")
             ConfigReader.EPSILON = config.getfloat("DEFAULT", "epsilon")
             ConfigReader.MAX_INDIVIDUALS = config.getint("DEFAULT", "maxIndividuals")
+            ConfigReader.OWL_ANNOTATION_LABEL = config.get(
+                "DEFAULT", "owlAnnotationLabel"
+            )
+            ConfigReader.MILP_PROVIDER = MILPProvider(
+                config.get("DEFAULT", "milpProvider").lower()
+            )
             ConfigReader.NUMBER_DIGITS = int(
                 round(abs(math.log10(ConfigReader.EPSILON) - 1.0))
             )
+            if ConfigReader.MILP_PROVIDER in [
+                MILPProvider.MIP,
+                MILPProvider.PULP,
+            ]:
+                constants.MAXVAL = (1 << 31) - 1
+                constants.MAXVAL2 = constants.MAXVAL * 2
+            elif ConfigReader.MILP_PROVIDER in [
+                MILPProvider.PULP_GLPK,
+                MILPProvider.PULP_HIGHS,
+                MILPProvider.PULP_CPLEX,
+                # MILPProvider.SCIPY,
+            ]:
+                constants.MAXVAL = (1 << 28) - 1
+                constants.MAXVAL2 = constants.MAXVAL * 2
 
             if ConfigReader.DEBUG_PRINT:
                 print(f"Debugging mode = {ConfigReader.DEBUG_PRINT}")

fuzzy_dl_owl2/fuzzydl/util/constants.py

@@ -4,7 +4,6 @@ import re
 import typing
 
 import pyparsing as pp
-from gurobipy import GRB
 
 SEPARATOR: str = "-" * 25
 STAR_SEPARATOR: str = "*" * 25
@@ -239,10 +238,10 @@ class InequalityType(enum.StrEnum):
 
 
 class VariableType(enum.StrEnum):
-    BINARY = GRB.BINARY
-    CONTINUOUS = GRB.CONTINUOUS
-    INTEGER = GRB.INTEGER
-    SEMI_CONTINUOUS = GRB.SEMICONT
+    BINARY = enum.auto()
+    CONTINUOUS = enum.auto()
+    INTEGER = enum.auto()
+    SEMI_CONTINUOUS = enum.auto()
 
     def __repr__(self) -> str:
         return self.name
@@ -421,5 +420,5 @@ class FuzzyLogic(enum.StrEnum):
 
 
 KNOWLEDGE_BASE_SEMANTICS: FuzzyLogic = FuzzyLogic.CLASSICAL
-MAXVAL: float = 2.147483647e12
+MAXVAL: float = ((1 << 31) - 1) * 1000  # 2.147483647e12
 MAXVAL2: float = MAXVAL * 2

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
@@ -146,6 +146,8 @@ from pyowl2.individual.anonymous_individual import OWLAnonymousIndividual
 from pyowl2.literal.literal import OWLLiteral
 from pyowl2.ontology import OWLOntology
 
+from fuzzy_dl_owl2.fuzzydl.util.config_reader import ConfigReader
+
 
 class FuzzyOwl2(object):
     POS_INFINITY: float = 10000.0
@@ -166,7 +168,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))
@@ -174,7 +176,7 @@ class FuzzyOwl2(object):
             self.ontology_iri, self.ontology_path, OWL1_annotations=True
         )
         self.fuzzy_label: OWLAnnotationProperty = OWLAnnotationProperty(
-            IRI(self.ontology_iri.namespace, "fuzzyLabel")
+            IRI(self.ontology_iri.namespace, ConfigReader.OWL_ANNOTATION_LABEL)
         )
         self.ontologies.add(self.ontology)
         # self.ontologies.update(self.manager.getImportsClosure(self.ontology))
@@ -200,9 +202,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 +288,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 +337,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 +408,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 +436,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 *