fuzzy-dl-owl2 1.0.9__py3-none-any.whl → 1.0.10__py3-none-any.whl

fuzzy_dl_owl2/fuzzydl/fuzzydl_to_owl2.py

@@ -3,8 +3,9 @@ from __future__ import annotations
 import os
 import sys
 import typing
-from functools import partial
+import urllib
 import urllib.parse
+from functools import partial
 
 from rdflib import RDF, RDFS, XSD, Literal, Namespace, URIRef
 
@@ -130,7 +131,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
-import urllib
 
 
 # @utils.timer_decorator
@@ -145,7 +145,7 @@ class FuzzydlToOwl2:
         base_iri: str = "http://www.semanticweb.org/ontologies/fuzzydl_ontology#",
     ) -> None:
         base_iri = urllib.parse.urlparse(base_iri).geturl().rstrip("/").rstrip("#")
-        
+
         self.num_classes: int = 0
         self.kb, _ = DLParser.get_kb(input_file)
         self.ontology_path: str = f"{base_iri}#"
@@ -349,17 +349,16 @@ class FuzzydlToOwl2:
             if str(c) in self.concepts:
                 return self.concepts.get(str(c))
             c4: OWLClassExpression = self.get_new_atomic_class(str(c))
-            c3: OWLClassExpression = self.get_base(c.c1)
+            c3: OWLClassExpression = self.get_base(c.curr_concept)
             self.concepts[str(c)] = c3
-
             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)]
+                        self.modifiers[str(c.modifier)].iri.value
                     ),
-                    FuzzyOWL2Keyword.BASE.get_str_value(): str(c3),
+                    FuzzyOWL2Keyword.BASE.get_str_value(): str(c3.iri.value),
                 },
             )
             main_xml.append(concept_xml)
@@ -418,14 +417,14 @@ class FuzzydlToOwl2:
         elif c_type == ConceptType.WEIGHTED:
             c: WeightedConcept = typing.cast(WeightedConcept, c)
             c4: OWLClassExpression = self.get_new_atomic_class(str(c))
-            c3: OWLClassExpression = self.get_base(c.c1)
+            c3: OWLClassExpression = self.get_base(c.curr_concept)
 
             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),
+                    FuzzyOWL2Keyword.BASE.get_str_value(): str(c3.iri.value),
                 },
             )
             main_xml.append(concept_xml)
@@ -497,7 +496,7 @@ class FuzzydlToOwl2:
                     FuzzyOWL2Keyword.DEGREE_VALUE.get_str_value(): str(
                         curr_concept.weights[i]
                     ),
-                    FuzzyOWL2Keyword.BASE.get_str_value(): str(c5),
+                    FuzzyOWL2Keyword.BASE.get_str_value(): str(c5.iri.value),
                 },
             )
             concept_xml.append(sub_concept_xml)
@@ -799,6 +798,21 @@ class FuzzydlToOwl2:
             # )
             self.add_ontology_annotation(annotation)
 
+        # Process atomic concepts
+        # TODO
+        for c in self.kb.atomic_concepts.values():
+            self.ontology.add_axiom(
+                OWLDeclaration(
+                    self.get_class(str(c)),
+                    [
+                        OWLAnnotation(
+                            OWLAnnotationProperty(URIRef(RDFS.label)),
+                            OWLLiteral(Literal(str(c), lang="en")),
+                        )
+                    ],
+                )
+            )
+
         # Process concrete concepts
         for c in self.kb.concrete_concepts.values():
             self._process_concrete_concept(c)

fuzzy_dl_owl2/fuzzydl/knowledge_base.py

@@ -12,51 +12,43 @@ from sortedcontainers import SortedSet
 from fuzzy_dl_owl2.fuzzydl.assertion.assertion import Assertion
 from fuzzy_dl_owl2.fuzzydl.classification_node import ClassificationNode
 from fuzzy_dl_owl2.fuzzydl.concept.all_some_concept import AllSomeConcept
-from fuzzy_dl_owl2.fuzzydl.concept.approximation_concept import ApproximationConcept
+from fuzzy_dl_owl2.fuzzydl.concept.approximation_concept import \
+    ApproximationConcept
 from fuzzy_dl_owl2.fuzzydl.concept.atomic_concept import AtomicConcept
 from fuzzy_dl_owl2.fuzzydl.concept.choquet_integral import ChoquetIntegral
 from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
-from fuzzy_dl_owl2.fuzzydl.concept.concrete.crisp_concrete_concept import (
-    CrispConcreteConcept,
-)
-from fuzzy_dl_owl2.fuzzydl.concept.concrete.fuzzy_concrete_concept import (
-    FuzzyConcreteConcept,
-)
-from fuzzy_dl_owl2.fuzzydl.concept.concrete.fuzzy_number.triangular_fuzzy_number import (
-    TriangularFuzzyNumber,
-)
-from fuzzy_dl_owl2.fuzzydl.concept.concrete.left_concrete_concept import (
-    LeftConcreteConcept,
-)
-from fuzzy_dl_owl2.fuzzydl.concept.concrete.linear_concrete_concept import (
-    LinearConcreteConcept,
-)
-from fuzzy_dl_owl2.fuzzydl.concept.concrete.modified_concrete_concept import (
-    ModifiedConcreteConcept,
-)
-from fuzzy_dl_owl2.fuzzydl.concept.concrete.right_concrete_concept import (
-    RightConcreteConcept,
-)
-from fuzzy_dl_owl2.fuzzydl.concept.concrete.trapezoidal_concrete_concept import (
-    TrapezoidalConcreteConcept,
-)
-from fuzzy_dl_owl2.fuzzydl.concept.concrete.triangular_concrete_concept import (
-    TriangularConcreteConcept,
-)
-from fuzzy_dl_owl2.fuzzydl.concept.ext_threshold_concept import ExtThresholdConcept
+from fuzzy_dl_owl2.fuzzydl.concept.concrete.crisp_concrete_concept import \
+    CrispConcreteConcept
+from fuzzy_dl_owl2.fuzzydl.concept.concrete.fuzzy_concrete_concept import \
+    FuzzyConcreteConcept
+from fuzzy_dl_owl2.fuzzydl.concept.concrete.fuzzy_number.triangular_fuzzy_number import \
+    TriangularFuzzyNumber
+from fuzzy_dl_owl2.fuzzydl.concept.concrete.left_concrete_concept import \
+    LeftConcreteConcept
+from fuzzy_dl_owl2.fuzzydl.concept.concrete.linear_concrete_concept import \
+    LinearConcreteConcept
+from fuzzy_dl_owl2.fuzzydl.concept.concrete.modified_concrete_concept import \
+    ModifiedConcreteConcept
+from fuzzy_dl_owl2.fuzzydl.concept.concrete.right_concrete_concept import \
+    RightConcreteConcept
+from fuzzy_dl_owl2.fuzzydl.concept.concrete.trapezoidal_concrete_concept import \
+    TrapezoidalConcreteConcept
+from fuzzy_dl_owl2.fuzzydl.concept.concrete.triangular_concrete_concept import \
+    TriangularConcreteConcept
+from fuzzy_dl_owl2.fuzzydl.concept.ext_threshold_concept import \
+    ExtThresholdConcept
 from fuzzy_dl_owl2.fuzzydl.concept.has_value_concept import HasValueConcept
 from fuzzy_dl_owl2.fuzzydl.concept.implies_concept import ImpliesConcept
-from fuzzy_dl_owl2.fuzzydl.concept.interface.has_concepts_interface import (
-    HasConceptsInterface,
-)
-from fuzzy_dl_owl2.fuzzydl.concept.interface.has_role_interface import HasRoleInterface
-from fuzzy_dl_owl2.fuzzydl.concept.interface.has_value_interface import (
-    HasValueInterface,
-)
-from fuzzy_dl_owl2.fuzzydl.concept.modified.modified_concept import ModifiedConcept
-from fuzzy_dl_owl2.fuzzydl.concept.modified.triangularly_modified_concept import (
-    TriangularlyModifiedConcept,
-)
+from fuzzy_dl_owl2.fuzzydl.concept.interface.has_concepts_interface import \
+    HasConceptsInterface
+from fuzzy_dl_owl2.fuzzydl.concept.interface.has_role_interface import \
+    HasRoleInterface
+from fuzzy_dl_owl2.fuzzydl.concept.interface.has_value_interface import \
+    HasValueInterface
+from fuzzy_dl_owl2.fuzzydl.concept.modified.modified_concept import \
+    ModifiedConcept
+from fuzzy_dl_owl2.fuzzydl.concept.modified.triangularly_modified_concept import \
+    TriangularlyModifiedConcept
 from fuzzy_dl_owl2.fuzzydl.concept.negated_nominal import NegatedNominal
 from fuzzy_dl_owl2.fuzzydl.concept.operator_concept import OperatorConcept
 from fuzzy_dl_owl2.fuzzydl.concept.owa_concept import OwaConcept
@@ -70,28 +62,30 @@ from fuzzy_dl_owl2.fuzzydl.concept.threshold_concept import ThresholdConcept
 from fuzzy_dl_owl2.fuzzydl.concept.truth_concept import TruthConcept
 from fuzzy_dl_owl2.fuzzydl.concept.value_concept import ValueConcept
 from fuzzy_dl_owl2.fuzzydl.concept.weighted_concept import WeightedConcept
-from fuzzy_dl_owl2.fuzzydl.concept.weighted_max_concept import WeightedMaxConcept
-from fuzzy_dl_owl2.fuzzydl.concept.weighted_min_concept import WeightedMinConcept
-from fuzzy_dl_owl2.fuzzydl.concept.weighted_sum_concept import WeightedSumConcept
-from fuzzy_dl_owl2.fuzzydl.concept.weighted_sum_zero_concept import (
-    WeightedSumZeroConcept,
-)
+from fuzzy_dl_owl2.fuzzydl.concept.weighted_max_concept import \
+    WeightedMaxConcept
+from fuzzy_dl_owl2.fuzzydl.concept.weighted_min_concept import \
+    WeightedMinConcept
+from fuzzy_dl_owl2.fuzzydl.concept.weighted_sum_concept import \
+    WeightedSumConcept
+from fuzzy_dl_owl2.fuzzydl.concept.weighted_sum_zero_concept import \
+    WeightedSumZeroConcept
 from fuzzy_dl_owl2.fuzzydl.concept_equivalence import ConceptEquivalence
 from fuzzy_dl_owl2.fuzzydl.concrete_feature import ConcreteFeature
 from fuzzy_dl_owl2.fuzzydl.degree.degree import Degree
 from fuzzy_dl_owl2.fuzzydl.degree.degree_expression import DegreeExpression
 from fuzzy_dl_owl2.fuzzydl.degree.degree_numeric import DegreeNumeric
 from fuzzy_dl_owl2.fuzzydl.degree.degree_variable import DegreeVariable
-from fuzzy_dl_owl2.fuzzydl.exception.inconsistent_ontology_exception import (
-    InconsistentOntologyException,
-)
+from fuzzy_dl_owl2.fuzzydl.exception.inconsistent_ontology_exception import \
+    InconsistentOntologyException
 from fuzzy_dl_owl2.fuzzydl.feature_function import FeatureFunction
-from fuzzy_dl_owl2.fuzzydl.general_concept_inclusion import GeneralConceptInclusion
-from fuzzy_dl_owl2.fuzzydl.individual.created_individual import CreatedIndividual
+from fuzzy_dl_owl2.fuzzydl.general_concept_inclusion import \
+    GeneralConceptInclusion
+from fuzzy_dl_owl2.fuzzydl.individual.created_individual import \
+    CreatedIndividual
 from fuzzy_dl_owl2.fuzzydl.individual.individual import Individual
-from fuzzy_dl_owl2.fuzzydl.individual.representative_individual import (
-    RepresentativeIndividual,
-)
+from fuzzy_dl_owl2.fuzzydl.individual.representative_individual import \
+    RepresentativeIndividual
 from fuzzy_dl_owl2.fuzzydl.milp.expression import Expression
 from fuzzy_dl_owl2.fuzzydl.milp.milp_helper import MILPHelper
 from fuzzy_dl_owl2.fuzzydl.milp.solution import Solution
@@ -99,29 +93,21 @@ from fuzzy_dl_owl2.fuzzydl.milp.term import Term
 from fuzzy_dl_owl2.fuzzydl.milp.variable import Variable
 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.primitive_concept_definition import (
-    PrimitiveConceptDefinition,
-)
+from fuzzy_dl_owl2.fuzzydl.modifier.triangular_modifier import \
+    TriangularModifier
+from fuzzy_dl_owl2.fuzzydl.primitive_concept_definition import \
+    PrimitiveConceptDefinition
 from fuzzy_dl_owl2.fuzzydl.relation import Relation
-from fuzzy_dl_owl2.fuzzydl.restriction.has_value_restriction import HasValueRestriction
+from fuzzy_dl_owl2.fuzzydl.restriction.has_value_restriction import \
+    HasValueRestriction
 from fuzzy_dl_owl2.fuzzydl.restriction.restriction import Restriction
 from fuzzy_dl_owl2.fuzzydl.util import constants
 from fuzzy_dl_owl2.fuzzydl.util.config_reader import ConfigReader
 from fuzzy_dl_owl2.fuzzydl.util.constants import (
-    BlockingDynamicType,
-    ConceptType,
-    ConcreteFeatureType,
-    CreatedIndividualBlockingType,
-    FeatureFunctionType,
-    FuzzyLogic,
-    InequalityType,
-    KnowledgeBaseRules,
-    LogicOperatorType,
-    RepresentativeIndividualType,
-    RestrictionType,
-    VariableType,
-)
+    BlockingDynamicType, ConceptType, ConcreteFeatureType,
+    CreatedIndividualBlockingType, FeatureFunctionType, FuzzyLogic,
+    InequalityType, KnowledgeBaseRules, LogicOperatorType,
+    RepresentativeIndividualType, RestrictionType, VariableType)
 from fuzzy_dl_owl2.fuzzydl.util.util import Util
 from fuzzy_dl_owl2.fuzzydl.util.utils import class_debugging
 

fuzzy_dl_owl2/fuzzydl/parser/dl_parser.py

@@ -525,9 +525,7 @@ class DLParser(object):
         if f is None:
             Util.error(f"Error: Fuzzy concept {f} has to be defined before being used.")
         if not isinstance(f, (RightConcreteConcept, LeftConcreteConcept)):
-            Util.error(
-                f"Error: Fuzzy concept {f} has to be a right or a linear function."
-            )
+            Util.error(f"Error: Fuzzy concept {f} has to be a right or left functions.")
         concepts: list[Concept] = [
             DLParser._to_concept(concept) for concept in list_tokens[1:]
         ]

fuzzy_dl_owl2/fuzzyowl2/fuzzyowl2.py

@@ -4,9 +4,11 @@ import typing
 from rdflib import Namespace
 
 from fuzzy_dl_owl2.fuzzydl.util import constants
+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.concept_definition import ConceptDefinition
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.crisp_function import CrispFunction
 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
@@ -146,8 +148,6 @@ 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
@@ -219,12 +219,16 @@ class FuzzyOwl2(object):
             if datatype_def_axioms is None:
                 continue
             for axiom in datatype_def_axioms:
+                Util.debug(f"Getting facets for axiom {axiom}...")
                 assert isinstance(axiom, OWLDatatypeDefinition)
                 datatype_name: str = self.get_short_name(axiom.datatype).replace(
                     ":", ""
                 )
                 if datatype_name != name:
                     continue
+                f1: typing.Optional[OWLFacet] = None
+                f2: typing.Optional[OWLFacet] = None
+                Util.debug(f"Getting facets for data range {axiom.data_range}...")
                 if isinstance(axiom.data_range, OWLDatatypeRestriction):
                     facets: list[OWLFacet] = list(axiom.data_range.restrictions)
                     f1: OWLFacet = facets[0]
@@ -260,14 +264,27 @@ class FuzzyOwl2(object):
                         continue
                     f1: OWLFacet = facets1[0]
                     f2: OWLFacet = facets2[0]
-                if f1.constraint_to_uriref() == OWLFacet.MIN_INCLUSIVE:
-                    facets[0] = float(str(f1.value.value))
-                elif f1.constraint_to_uriref() == OWLFacet.MAX_INCLUSIVE:
-                    facets[1] = float(str(f1.value.value))
-                if f2.constraint_to_uriref() == OWLFacet.MIN_INCLUSIVE:
-                    facets[0] = float(str(f2.value.value))
-                elif f2.constraint_to_uriref() == OWLFacet.MAX_INCLUSIVE:
-                    facets[1] = float(str(f2.value.value))
+
+                Util.debug(f"Facets 1 {f1}.")
+                Util.debug(f"Facets 2 {f2}.")
+                if f1:
+                    if f1.constraint_to_uriref() == OWLFacet.MIN_INCLUSIVE:
+                        facets[0] = float(str(f1.value.value))
+                    elif f1.constraint_to_uriref() == OWLFacet.MIN_EXCLUSIVE:
+                        facets[0] = float(str(f1.value.value)) + ConfigReader.EPSILON
+                    elif f1.constraint_to_uriref() == OWLFacet.MAX_INCLUSIVE:
+                        facets[1] = float(str(f1.value.value))
+                    elif f1.constraint_to_uriref() == OWLFacet.MAX_EXCLUSIVE:
+                        facets[1] = float(str(f1.value.value)) - ConfigReader.EPSILON
+                if f2:
+                    if f2.constraint_to_uriref() == OWLFacet.MIN_INCLUSIVE:
+                        facets[0] = float(str(f2.value.value))
+                    elif f2.constraint_to_uriref() == OWLFacet.MIN_EXCLUSIVE:
+                        facets[0] = float(str(f2.value.value)) + ConfigReader.EPSILON
+                    elif f2.constraint_to_uriref() == OWLFacet.MAX_INCLUSIVE:
+                        facets[1] = float(str(f2.value.value))
+                    elif f2.constraint_to_uriref() == OWLFacet.MAX_INCLUSIVE:
+                        facets[1] = float(str(f2.value.value)) - ConfigReader.EPSILON
                 return facets
         return facets
 
@@ -301,7 +318,9 @@ class FuzzyOwl2(object):
                     c.set_max_value(facets[1])
                     Util.debug(f"Concept for {datatype} -> {c}")
                     self.fuzzy_datatypes[datatype_name] = c
-                    if isinstance(c, LeftShoulderFunction):
+                    if isinstance(c, CrispFunction):
+                        self.write_crisp_function_definition(datatype_name, c)
+                    elif isinstance(c, LeftShoulderFunction):
                         self.write_left_shoulder_function_definition(datatype_name, c)
                     elif isinstance(c, RightShoulderFunction):
                         self.write_right_shoulder_function_definition(datatype_name, c)
@@ -913,6 +932,7 @@ class FuzzyOwl2(object):
             )
 
     def get_class_name(self, c: OWLClassExpression) -> str:
+        Util.debug(f"Getting class name for expression: {c}")
         if isinstance(c, OWLClass):
             d: OWLClass = typing.cast(OWLClass, c)
             if d.is_thing():
@@ -1053,6 +1073,7 @@ class FuzzyOwl2(object):
             raise ValueError
 
     def get_object_property_name(self, p: OWLObjectPropertyExpression) -> str:
+        Util.debug(f"Getting object property name for expression: {p}")
         if p.is_top_object_property():
             return self.get_top_object_property_name()
         elif p.is_bottom_object_property():
@@ -1061,6 +1082,7 @@ class FuzzyOwl2(object):
             return self.get_atomic_object_property_name(p)
 
     def get_data_property_name(self, p: OWLDataPropertyExpression) -> str:
+        Util.debug(f"Getting data property name for expression: {p}")
         if p.is_top_data_property():
             return self.get_top_data_property_name()
         elif p.is_bottom_data_property():
@@ -1069,6 +1091,7 @@ class FuzzyOwl2(object):
             return self.get_atomic_data_property_name(p)
 
     def get_individual_name(self, i: OWLIndividual) -> typing.Optional[str]:
+        Util.debug(f"Getting individual name for expression: {i}")
         if isinstance(i, OWLAnonymousIndividual):
             Util.info(f"Anonymous individual not supported")
             return None
@@ -1221,7 +1244,7 @@ class FuzzyOwl2(object):
 
     def get_atomic_object_property_name(self, p: OWLObjectProperty) -> str:
         name: str = self.get_short_name(p)
-        Util.info(f"Write object property {name}")
+        Util.info(f"Write atomic object property {name}")
         return ""
 
     def get_top_data_property_name(self) -> str:
@@ -1234,27 +1257,27 @@ class FuzzyOwl2(object):
 
     def get_atomic_data_property_name(self, p: OWLDataProperty) -> str:
         name: str = self.get_short_name(p)
-        Util.info(f"Write data property {name}")
+        Util.info(f"Write atomic data property {name}")
         return ""
 
     def write_fuzzy_logic(self, logic: str) -> None:
         Util.info(f"Write fuzzy logic {logic}")
 
     def write_concept_declaration(self, c: OWLClassExpression) -> None:
-        Util.info(f"Write declaration {c}")
+        Util.info(f"Write concept declaration {c}")
 
     def write_data_property_declaration(self, dp: OWLDataPropertyExpression) -> None:
-        Util.info(f"Write declaration {dp}")
+        Util.info(f"Write data property declaration {dp}")
 
     def write_object_property_declaration(
         self, op: OWLObjectPropertyExpression
     ) -> None:
-        Util.info(f"Write declaration {op}")
+        Util.info(f"Write object property declaration {op}")
 
     def write_concept_assertion_axiom(
         self, i: OWLIndividual, c: OWLClassExpression, d: float
     ) -> None:
-        Util.info(f"Write axiom {i}: {c} >= {d}")
+        Util.info(f"Write concept assertion axiom {i}: {c} >= {d}")
 
     def write_object_property_assertion_axiom(
         self,
@@ -1263,7 +1286,7 @@ class FuzzyOwl2(object):
         p: OWLObjectPropertyExpression,
         d: float,
     ) -> None:
-        Util.info(f"Write axiom ({i1}, {i2}): {p} >= {d}")
+        Util.info(f"Write object property assertion axiom ({i1}, {i2}): {p} >= {d}")
 
     def write_data_property_assertion_axiom(
         self,
@@ -1272,7 +1295,7 @@ class FuzzyOwl2(object):
         p: OWLDataPropertyExpression,
         d: float,
     ) -> None:
-        Util.info(f"Write axiom ({i}, {lit}): {p} >= {d}")
+        Util.info(f"Write data property assertion axiom ({i}, {lit}): {p} >= {d}")
 
     def write_negative_object_property_assertion_axiom(
         self,
@@ -1281,7 +1304,9 @@ class FuzzyOwl2(object):
         p: OWLObjectPropertyExpression,
         d: float,
     ) -> None:
-        Util.info(f"Write axiom ({i1}, {i2}): not {p} >= {d}")
+        Util.info(
+            f"Write negative object property assertion axiom ({i1}, {i2}): not {p} >= {d}"
+        )
 
     def write_negative_data_property_assertion_axiom(
         self,
@@ -1290,7 +1315,9 @@ class FuzzyOwl2(object):
         p: OWLDataPropertyExpression,
         d: float,
     ) -> None:
-        Util.info(f"Write axiom ({i}, {lit}): not {p} >= {d}")
+        Util.info(
+            f"Write negative data property assertion axiom ({i}, {lit}): not {p} >= {d}"
+        )
 
     def write_same_individual_axiom(self, ind_set: set[OWLIndividual]) -> None:
         Util.info(f"Write axiom SameIndividual({ind_set})")
@@ -1394,7 +1421,7 @@ class FuzzyOwl2(object):
     def write_inverse_object_property_axiom(
         self, p1: OWLObjectPropertyExpression, p2: OWLObjectPropertyExpression
     ) -> None:
-        Util.info(f"Write axiom ({p1} inverse of {p2})")
+        Util.info(f"Write inverse object property axiom - axiom ({p1} inverse of {p2})")
 
     def write_inverse_functional_object_property_axiom(
         self, p: OWLObjectPropertyExpression
@@ -1424,100 +1451,103 @@ class FuzzyOwl2(object):
     def write_disjoint_object_properties_axiom(
         self, class_set: set[OWLObjectPropertyExpression]
     ) -> None:
-        Util.info(f"Write axiom ({class_set})")
+        Util.info(f"Write disjoint object properties axiom ({class_set})")
 
     def write_disjoint_data_properties_axiom(
         self, class_set: set[OWLDataPropertyExpression]
     ) -> None:
-        Util.info(f"Write axiom ({class_set})")
+        Util.info(f"Write disjoint data properties axiom ({class_set})")
 
     def write_triangular_modifier_definition(
         self, name: str, mod: TriangularModifier
     ) -> None:
-        Util.info(f"Write definition {name} = {mod}")
+        Util.info(f"Write triangular modifier definition {name} = {mod}")
 
     def write_linear_modifier_definition(self, name: str, mod: LinearModifier) -> None:
-        Util.info(f"Write definition {name} = {mod}")
+        Util.info(f"Write linear modifier definition {name} = {mod}")
+
+    def write_crisp_function_definition(self, name: str, dat: CrispFunction) -> None:
+        Util.info(f"Write crisp function definition {name} = {dat}")
 
     def write_left_shoulder_function_definition(
         self, name: str, dat: LeftShoulderFunction
     ) -> None:
-        Util.info(f"Write definition {name} = {dat}")
+        Util.info(f"Write left shoulder function definition {name} = {dat}")
 
     def write_right_shoulder_function_definition(
         self, name: str, dat: RightShoulderFunction
     ) -> None:
-        Util.info(f"Write definition {name} = {dat}")
+        Util.info(f"Write right shoulder function definition {name} = {dat}")
 
     def write_linear_function_definition(self, name: str, dat: LinearFunction) -> None:
-        Util.info(f"Write definition {name} = {dat}")
+        Util.info(f"Write linear function definition {name} = {dat}")
 
     def write_triangular_function_definition(
         self, name: str, dat: TriangularFunction
     ) -> None:
-        Util.info(f"Write definition {name} = {dat}")
+        Util.info(f"Write triangular function definition {name} = {dat}")
 
     def write_trapezoidal_function_definition(
         self, name: str, dat: TrapezoidalFunction
     ) -> None:
-        Util.info(f"Write definition {name} = {dat}")
+        Util.info(f"Write trapezoidal function definition {name} = {dat}")
 
     def write_modified_function_definition(
         self, name: str, dat: ModifiedFunction
     ) -> None:
-        Util.info(f"Write definition {name} = {dat}")
+        Util.info(f"Write modified function definition {name} = {dat}")
 
     def write_modified_property_definition(
         self, name: str, dat: ModifiedProperty
     ) -> None:
-        Util.info(f"Write definition {name} = {dat}")
+        Util.info(f"Write modified property definition {name} = {dat}")
 
     def write_modified_concept_definition(
         self, name: str, dat: ModifiedConcept
     ) -> None:
-        Util.info(f"Write definition {name} = {dat}")
+        Util.info(f"Write modified concept definition {name} = {dat}")
 
     def write_fuzzy_nominal_concept_definition(
         self, name: str, dat: FuzzyNominalConcept
     ) -> None:
-        Util.info(f"Write definition {name} = {dat}")
+        Util.info(f"Write fuzzy nominal concept definition {name} = {dat}")
 
     def write_weighted_concept_definition(self, name: str, c: WeightedConcept) -> None:
-        Util.info(f"Write definition {name} = {c}")
+        Util.info(f"Write weighted concept definition {name} = {c}")
 
     def write_weighted_max_concept_definition(
         self, name: str, c: WeightedMaxConcept
     ) -> None:
-        Util.info(f"Write definition {name} = {c}")
+        Util.info(f"Write weighted max concept definition {name} = {c}")
 
     def write_weighted_min_concept_definition(
         self, name: str, c: WeightedMinConcept
     ) -> None:
-        Util.info(f"Write definition {name} = {c}")
+        Util.info(f"Write weighted min concept definition {name} = {c}")
 
     def write_weighted_sum_concept_definition(
         self, name: str, c: WeightedSumConcept
     ) -> None:
-        Util.info(f"Write definition {name} = {c}")
+        Util.info(f"Write weighted sum concept definition {name} = {c}")
 
     def write_weighted_sum_zero_concept_definition(
         self, name: str, c: WeightedSumZeroConcept
     ) -> None:
-        Util.info(f"Write definition {name} = {c}")
+        Util.info(f"Write weighted sum zero concept definition {name} = {c}")
 
     def write_owa_concept_definition(self, name: str, c: OwaConcept) -> None:
-        Util.info(f"Write definition {name} = {c}")
+        Util.info(f"Write owa concept definition {name} = {c}")
 
     def write_choquet_concept_definition(self, name: str, c: ChoquetConcept) -> None:
-        Util.info(f"Write definition {name} = {c}")
+        Util.info(f"Write choquet concept definition {name} = {c}")
 
     def write_sugeno_concept_definition(self, name: str, c: SugenoConcept) -> None:
-        Util.info(f"Write definition {name} = {c}")
+        Util.info(f"Write sugeno concept definition {name} = {c}")
 
     def write_quasi_sugeno_concept_definition(
         self, name: str, c: QsugenoConcept
     ) -> None:
-        Util.info(f"Write definition {name} = {c}")
+        Util.info(f"Write quasi sugeno concept definition {name} = {c}")
 
     def write_qowa_concept_definition(self, name: str, c: QowaConcept) -> None:
-        Util.info(f"Write definition {name} = {c}")
+        Util.info(f"Write quasi owa concept definition {name} = {c}")

fuzzy_dl_owl2/fuzzyowl2/fuzzyowl2_to_fuzzydl.py

@@ -7,6 +7,7 @@ from fuzzy_dl_owl2.fuzzydl.util.constants import FuzzyDLKeyword
 from fuzzy_dl_owl2.fuzzydl.util.util import Util
 from fuzzy_dl_owl2.fuzzyowl2.fuzzyowl2 import FuzzyOwl2
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.choquet_concept import ChoquetConcept
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.crisp_function import CrispFunction
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.fuzzy_nominal_concept import FuzzyNominalConcept
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.left_shoulder_function import (
     LeftShoulderFunction,
@@ -102,6 +103,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
             return False
 
     def __write(self, line: str) -> None:
+        Util.debug(f"Writing line to FuzzyDL file: {line}")
         with open(self.output_dl, "a") as file:
             file.write(f"{line}\n")
 
@@ -208,7 +210,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
             if len(literat_set) > 0:
                 return f"(= {self.get_data_property_name(p)} {literat_set})"
         Util.error(
-            f"Data some values restriction with range {range} and type {type} not supported -- DataSomeValuesFrom({p} {range})"
+            f"Data some values restriction with range {range} and type {type(range)} not supported -- DataSomeValuesFrom({p} {range})"
         )
         return None
 
@@ -220,7 +222,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
             if datatype_name in self.fuzzy_datatypes:
                 return f"(all {self.get_data_property_name(p)} {datatype_name})"
         Util.error(
-            f"Data all values restriction with range {range} and type {type} not supported -- DataAllValuesFrom({p} {range})"
+            f"Data all values restriction with range {range} and type {type(range)} not supported -- DataAllValuesFrom({p} {range})"
         )
         return None
 
@@ -418,25 +420,29 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
         return name
 
     def write_fuzzy_logic(self, logic: str) -> None:
+        super().write_fuzzy_logic(logic)
         self.__write(f"(define-fuzzy-logic {logic})")
 
     def write_concept_declaration(self, c: OWLClassExpression) -> None:
+        super().write_concept_declaration(c)
         self.__write(
             f"(define-primitive-concept {self.get_class_name(c)} {self.get_top_concept_name()})"
         )
 
     def write_data_property_declaration(self, dp: OWLDataPropertyExpression) -> None:
+        super().write_data_property_declaration(dp)
         self.write_functional_data_property_axiom(dp)
         self.__write(f"(range {self.get_data_property_name(dp)} *string*)")
 
     def write_object_property_declaration(
         self, op: OWLObjectPropertyExpression
     ) -> None:
-        pass
+        super().write_object_property_declaration(op)
 
     def write_concept_assertion_axiom(
         self, i: OWLIndividual, c: OWLClassExpression, d: float
     ) -> None:
+        super().write_concept_assertion_axiom(i, c, d)
         self.__write(
             f"(instance {self.get_individual_name(i)} {self.get_class_name(c)} {d})"
         )
@@ -448,6 +454,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
         p: OWLObjectPropertyExpression,
         d: float,
     ) -> None:
+        super().write_object_property_assertion_axiom(i1, i2, p, d)
         self.__write(
             f"(related {self.get_individual_name(i1)} {self.get_individual_name(i2)} {self.get_object_property_name(p)} {d})"
         )
@@ -459,6 +466,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
         p: OWLDataPropertyExpression,
         d: float,
     ) -> None:
+        super().write_data_property_assertion_axiom(i, lit, p, d)
         datatype: OWLDatatype = lit.datatype
         dp_name: str = self.get_data_property_name(p)
         if datatype is None:
@@ -490,7 +498,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
                     else:
                         value = int(str(lit.value))
                     self.__write(
-                        f"(instance {self.get_individual_name(i)} (>= {dp_name} {value}) {d})"
+                        f"(instance {self.get_individual_name(i)} (= {dp_name} {value}) {d})"
                     )
                 else:
                     if dp_name not in self.string_datatypes:
@@ -513,6 +521,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
         p: OWLObjectPropertyExpression,
         d: float,
     ) -> None:
+        super().write_negative_object_property_assertion_axiom(i1, i2, p, d)
         Util.error(
             f"Negative object property assertion not supported -- NegativeObjectPropertyAssertion({p} {i1} {i2} {d})"
         )
@@ -525,24 +534,28 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
         p: OWLDataPropertyExpression,
         d: float,
     ) -> None:
+        super().write_negative_data_property_assertion_axiom(i, lit, p, d)
         Util.error(
             f"Negative data property assertion not supported -- NegativeDataPropertyAssertion({p} {i} {lit} {d})"
         )
         return None
 
     def write_same_individual_axiom(self, ind_set: set[OWLIndividual]) -> None:
+        super().write_same_individual_axiom(ind_set)
         Util.error(
-            f"Same individual axiom not supported -- NegativeDataPropertyAssertion({self.__get_set_name(ind_set)})"
+            f"Same individual axiom not supported -- SameIndividuals({self.__get_set_name(ind_set)})"
         )
         return None
 
     def write_different_individuals_axiom(self, ind_set: set[OWLIndividual]) -> None:
+        super().write_different_individuals_axiom(ind_set)
         Util.error(
             f"Different individual axiom not supported -- DifferentIndividuals({self.__get_set_name(ind_set)})"
         )
         return None
 
     def write_disjoint_classes_axiom(self, class_set: set[OWLClassExpression]) -> None:
+        super().write_disjoint_classes_axiom(class_set)
         if len(class_set) <= 1:
             return
         self.__write(
@@ -550,6 +563,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
         )
 
     def write_disjoint_union_axiom(self, class_set: set[OWLClassExpression]) -> None:
+        super().write_disjoint_union_axiom(class_set)
         if len(class_set) <= 1:
             return
         for c in class_set:
@@ -562,6 +576,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
     def write_subclass_of_axiom(
         self, subclass: OWLClassExpression, superclass: OWLClassExpression, d: float
     ) -> None:
+        super().write_subclass_of_axiom(subclass, superclass, d)
         if isinstance(subclass, OWLClass) and d == 1:
             self.__write(
                 f"(define-primitive-concept {self.get_short_name(subclass)} {self.get_class_name(superclass)})"
@@ -574,6 +589,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
     def write_equivalent_classes_axiom(
         self, class_set: set[OWLClassExpression]
     ) -> None:
+        super().write_equivalent_classes_axiom(class_set)
         name: str = None
         left_class: OWLClassExpression = None
         for c in class_set:
@@ -596,6 +612,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
         superproperty: OWLObjectPropertyExpression,
         d: float,
     ) -> None:
+        super().write_sub_object_property_of_axiom(subproperty, superproperty, d)
         self.__write(
             f"(implies-role {self.get_object_property_name(subproperty)} {self.get_object_property_name(superproperty)} {d})"
         )
@@ -606,6 +623,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
         superproperty: OWLDataPropertyExpression,
         d: float,
     ) -> None:
+        super().write_sub_data_property_of_axiom(subproperty, superproperty, d)
         self.__write(
             f"(implies-role {self.get_data_property_name(subproperty)} {self.get_data_property_name(superproperty)} {d})"
         )
@@ -616,13 +634,16 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
         superproperty: OWLObjectPropertyExpression,
         d: float,
     ) -> None:
+        super().write_sub_property_chain_of_axiom(chain, superproperty, d)
         Util.error(
             f"Subproperty chain axiom not supported -- SubObjectPropertyOf(ObjectPropertyChain({self.__get_set_name(chain)}) {superproperty} {d})"
         )
+        return None
 
     def write_equivalent_object_properties_axiom(
         self, class_set: set[OWLObjectPropertyExpression]
     ) -> None:
+        super().write_equivalent_object_properties_axiom(class_set)
         first: OWLObjectPropertyExpression = next(class_set)
         first_name: str = self.get_object_property_name(first)
         for property in class_set - set([first]):
@@ -633,6 +654,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
     def write_equivalent_data_properties_axiom(
         self, class_set: set[OWLDataPropertyExpression]
     ) -> None:
+        super().write_equivalent_data_properties_axiom(class_set)
         first: OWLDataPropertyExpression = next(class_set)
         first_name: str = self.get_data_property_name(first)
         for property in class_set - set([first]):
@@ -643,28 +665,34 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
     def write_transitive_object_property_axiom(
         self, p: OWLObjectPropertyExpression
     ) -> None:
+        super().write_transitive_object_property_axiom(p)
         self.__write(f"(transitive {self.get_object_property_name(p)})")
 
     def write_symmetric_object_property_axiom(
         self, p: OWLObjectPropertyExpression
     ) -> None:
+        super().write_symmetric_object_property_axiom(p)
         self.__write(f"(symmetric {self.get_object_property_name(p)})")
 
     def write_asymmetric_object_property_axiom(
         self, p: OWLObjectPropertyExpression
     ) -> None:
+        super().write_asymmetric_object_property_axiom(p)
         Util.error(
             f"Asymmetric object property axiom not supported -- AsymmetricObjectProperty({p})"
         )
+        return None
 
     def write_reflexive_object_property_axiom(
         self, p: OWLObjectPropertyExpression
     ) -> None:
+        super().write_reflexive_object_property_axiom(p)
         self.__write(f"(reflexive {self.get_object_property_name(p)})")
 
     def write_irreflexive_object_property_axiom(
         self, p: OWLObjectPropertyExpression
     ) -> None:
+        super().write_irreflexive_object_property_axiom(p)
         Util.error(
             f"Irreflexive object property axiom not supported -- IrreflexiveObjectProperty({p})"
         )
@@ -672,14 +700,16 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
     def write_functional_object_property_axiom(
         self, p: OWLObjectPropertyExpression
     ) -> None:
+        super().write_functional_object_property_axiom(p)
         name: str = self.get_object_property_name(p)
         if name not in self.processed_functional_object_properties:
             self.processed_functional_object_properties.add(name)
             self.__write(f"(functional {name})")
 
     def write_functional_data_property_axiom(
-        self, p: OWLObjectPropertyExpression
+        self, p: OWLDataPropertyExpression
     ) -> None:
+        super().write_functional_data_property_axiom(p)
         name: str = self.get_data_property_name(p)
         if name not in self.processed_functional_data_properties:
             self.processed_functional_data_properties.add(name)
@@ -688,6 +718,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
     def write_inverse_object_property_axiom(
         self, p1: OWLObjectPropertyExpression, p2: OWLObjectPropertyExpression
     ) -> None:
+        super().write_inverse_object_property_axiom(p1, p2)
         self.__write(
             f"(inverse {self.get_object_property_name(p1)} {self.get_object_property_name(p2)})"
         )
@@ -695,11 +726,13 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
     def write_inverse_functional_object_property_axiom(
         self, p: OWLObjectPropertyExpression
     ) -> None:
+        super().write_inverse_functional_object_property_axiom(p)
         self.__write(f"(inverse-functional {self.get_object_property_name(p)})")
 
     def write_object_property_domain_axiom(
         self, p: OWLObjectPropertyExpression, c: OWLClassExpression
     ) -> None:
+        super().write_object_property_domain_axiom(p, c)
         self.__write(
             f"(domain {self.get_object_property_name(p)} {self.get_class_name(c)})"
         )
@@ -707,6 +740,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
     def write_object_property_range_axiom(
         self, p: OWLObjectPropertyExpression, c: OWLClassExpression
     ) -> None:
+        super().write_object_property_range_axiom(p, c)
         self.__write(
             f"(range {self.get_object_property_name(p)} {self.get_class_name(c)})"
         )
@@ -714,6 +748,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
     def write_data_property_domain_axiom(
         self, p: OWLDataPropertyExpression, c: OWLClassExpression
     ) -> None:
+        super().write_data_property_domain_axiom(p, c)
         self.__write(
             f"(domain {self.get_data_property_name(p)} {self.get_class_name(c)})"
         )
@@ -721,6 +756,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
     def write_data_property_range_axiom(
         self, p: OWLDataPropertyExpression, range: OWLDataRange
     ) -> None:
+        super().write_data_property_range_axiom(p, range)
         range_str: str = None
         dp_name: str = self.get_data_property_name(p)
         if isinstance(range, OWLDatatype):
@@ -809,108 +845,139 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
     def write_disjoint_object_properties_axiom(
         self, class_set: set[OWLObjectPropertyExpression]
     ) -> None:
+        super().write_disjoint_object_properties_axiom(class_set)
         Util.error(
             f"Disjoint object properties axiom not supported -- DisjointObjectProperties({self.__get_set_name(class_set)})"
         )
+        return None
 
     def write_disjoint_data_properties_axiom(
         self, class_set: set[OWLDataPropertyExpression]
     ) -> None:
+        super().write_disjoint_data_properties_axiom(class_set)
         Util.error(
             f"Disjoint data properties axiom not supported -- DisjointDataProperties({self.__get_set_name(class_set)})"
         )
+        return None
 
     def write_triangular_modifier_definition(
         self, name: str, mod: TriangularModifier
     ) -> None:
+        super().write_triangular_modifier_definition(name, mod)
         self.__write(f"(define-modifier {name} {mod})")
 
     def write_linear_modifier_definition(self, name: str, mod: LinearModifier) -> None:
+        super().write_linear_modifier_definition(name, mod)
         self.__write(f"(define-modifier {name} {mod})")
 
+    def write_crisp_function_definition(self, name: str, dat: CrispFunction) -> None:
+        super().write_crisp_function_definition(name, dat)
+        self.__write(f"(define-fuzzy-concept {name} {dat})")
+
     def write_left_shoulder_function_definition(
         self, name: str, dat: LeftShoulderFunction
     ) -> None:
+        super().write_left_shoulder_function_definition(name, dat)
         self.__write(f"(define-fuzzy-concept {name} {dat})")
 
     def write_right_shoulder_function_definition(
         self, name: str, dat: RightShoulderFunction
     ) -> None:
+        super().write_right_shoulder_function_definition(name, dat)
         self.__write(f"(define-fuzzy-concept {name} {dat})")
 
     def write_linear_function_definition(self, name: str, dat: LinearFunction) -> None:
+        super().write_linear_function_definition(name, dat)
         self.__write(f"(define-fuzzy-concept {name} {dat})")
 
     def write_triangular_function_definition(
         self, name: str, dat: TriangularFunction
     ) -> None:
+        super().write_triangular_function_definition(name, dat)
         self.__write(f"(define-fuzzy-concept {name} {dat})")
 
     def write_trapezoidal_function_definition(
         self, name: str, dat: TrapezoidalFunction
     ) -> None:
+        super().write_trapezoidal_function_definition(name, dat)
         self.__write(f"(define-fuzzy-concept {name} {dat})")
 
     def write_modified_function_definition(
         self, name: str, dat: ModifiedFunction
     ) -> None:
+        super().write_modified_function_definition(name, dat)
         self.__write(f"(define-concept {name} {dat})")
 
     def write_modified_property_definition(
         self, name: str, dat: ModifiedProperty
     ) -> None:
+        super().write_modified_property_definition(name, dat)
         Util.error(
             f"Modified property not supported -- EquivalentObjectProperties({name} <{dat.get_fuzzy_modifier()} {dat.get_property()}>)"
         )
+        return None
 
     def write_modified_concept_definition(
         self, name: str, dat: ModifiedConcept
     ) -> None:
+        super().write_modified_concept_definition(name, dat)
         self.__write(f"(define-concept {name} {dat})")
 
     def write_fuzzy_nominal_concept_definition(
         self, name: str, dat: FuzzyNominalConcept
     ) -> None:
+        super().write_fuzzy_nominal_concept_definition(name, dat)
         Util.error(
             f"Fuzzy nominal not supported -- EquivalentConcepts({name} OneOf({dat}))"
         )
+        return None
 
     def write_weighted_concept_definition(self, name: str, c: WeightedConcept) -> None:
+        super().write_weighted_concept_definition(name, c)
         self.__write(f"(define-concept {name} {c})")
 
     def write_weighted_max_concept_definition(
         self, name: str, c: WeightedMaxConcept
     ) -> None:
+        super().write_weighted_max_concept_definition(name, c)
         self.__write(f"(define-concept {name} {c})")
 
     def write_weighted_min_concept_definition(
         self, name: str, c: WeightedMinConcept
     ) -> None:
+        super().write_weighted_min_concept_definition(name, c)
         self.__write(f"(define-concept {name} {c})")
 
     def write_weighted_sum_concept_definition(
         self, name: str, c: WeightedSumConcept
     ) -> None:
+        super().write_weighted_sum_concept_definition(name, c)
         self.__write(f"(define-concept {name} {c})")
 
     def write_weighted_sum_zero_concept_definition(
         self, name: str, c: WeightedSumZeroConcept
     ) -> None:
+        super().write_weighted_sum_zero_concept_definition(name, c)
         self.__write(f"(define-concept {name} {c})")
 
     def write_owa_concept_definition(self, name: str, c: OwaConcept) -> None:
+        super().write_owa_concept_definition(name, c)
         self.__write(f"(define-concept {name} {c})")
 
     def write_choquet_concept_definition(self, name: str, c: ChoquetConcept) -> None:
+        super().write_choquet_concept_definition(name, c)
         self.__write(f"(define-concept {name} {c})")
 
     def write_sugeno_concept_definition(self, name: str, c: SugenoConcept) -> None:
+        super().write_sugeno_concept_definition(name, c)
         self.__write(f"(define-concept {name} {c})")
 
     def write_quasi_sugeno_concept_definition(
         self, name: str, c: QsugenoConcept
     ) -> None:
+        super().write_quasi_sugeno_concept_definition(name, c)
         self.__write(f"(define-concept {name} {c})")
 
     def write_qowa_concept_definition(self, name: str, c: QowaConcept) -> None:
+        super().write_qowa_concept_definition(name, c)
         self.__write(f"(define-concept {name} {c})")

fuzzy_dl_owl2/fuzzyowl2/owl_types/crisp_function.py

@@ -0,0 +1,17 @@
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.fuzzy_datatype import FuzzyDatatype
+
+
+class CrispFunction(FuzzyDatatype):
+    def __init__(self, a: float, b: float) -> None:
+        super().__init__()
+        self._a: float = a
+        self._b: float = b
+
+    def get_a(self) -> float:
+        return self._a
+
+    def get_b(self) -> float:
+        return self._b
+
+    def __str__(self) -> str:
+        return f"crisp({self._k1}, {self._k2}, {self._a}, {self._b})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/fuzzy_nominal_concept.py

@@ -16,4 +16,4 @@ class FuzzyNominalConcept(ConceptDefinition):
         return self._i
 
     def __str__(self) -> str:
-        return f"({self.get_degree()}, {self.get_individual()})"
+        return f"({self.get_degree()} {self.get_individual()})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/modified_concept.py

@@ -16,4 +16,4 @@ class ModifiedConcept(ConceptDefinition):
         return self._c
 
     def __str__(self) -> str:
-        return f"({self._mod}, {self._c})"
+        return f"({self._mod} {self._c})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/modified_function.py

@@ -14,4 +14,4 @@ class ModifiedFunction(FuzzyDatatype):
         return self._d
 
     def __str__(self) -> str:
-        return f"({self._mod}, {self._d})"
+        return f"({self._mod} {self._d})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/modified_property.py

@@ -18,4 +18,4 @@ class ModifiedProperty(FuzzyProperty):
         return str(self)
 
     def __str__(self) -> str:
-        return f"({self.get_fuzzy_modifier()}, {self.get_property()})"
+        return f"({self.get_fuzzy_modifier()} {self.get_property()})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/weighted_max_concept.py

@@ -12,4 +12,4 @@ class WeightedMaxConcept(ConceptDefinition):
         return self._wc
 
     def __str__(self) -> str:
-        return f"(w-max {self._wc})"
+        return f"(w-max {' '.join(map(str, self._wc))})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/weighted_min_concept.py

@@ -12,4 +12,4 @@ class WeightedMinConcept(ConceptDefinition):
         return self._wc
 
     def __str__(self) -> str:
-        return f"(w-min {self._wc})"
+        return f"(w-min {' '.join(map(str, self._wc))})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/weighted_sum_concept.py

@@ -12,4 +12,4 @@ class WeightedSumConcept(ConceptDefinition):
         return self._wc
 
     def __str__(self) -> str:
-        return f"(w-sum {self._wc})"
+        return f"(w-sum {' '.join(map(str, self._wc))})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/weighted_sum_zero_concept.py

@@ -12,4 +12,4 @@ class WeightedSumZeroConcept(ConceptDefinition):
         return self._wc
 
     def __str__(self) -> str:
-        return f"(w-sum-zero {self._wc})"
+        return f"(w-sum-zero {' '.join(map(str, self._wc))})"

fuzzy_dl_owl2/fuzzyowl2/parser/owl2_xml_parser.py

@@ -10,6 +10,7 @@ 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.crisp_function import CrispFunction
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.fuzzy_nominal_concept import FuzzyNominalConcept
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.left_shoulder_function import (
     LeftShoulderFunction,
@@ -140,7 +141,7 @@ class FuzzyOwl2XMLParser(object):
             elif concept_type == FuzzyOWL2Keyword.NOMINAL:
                 return FuzzyNominalConcept(
                     float(
-                        child.attrib.get(FuzzyOWL2Keyword.DEGREE_DEF.get_str_value())
+                        child.attrib.get(FuzzyOWL2Keyword.DEGREE_VALUE.get_str_value())
                     ),
                     child.attrib.get(FuzzyOWL2Keyword.INDIVIDUAL.get_str_value()),
                 )
@@ -148,7 +149,12 @@ class FuzzyOwl2XMLParser(object):
             child = root.find(FuzzyOWL2Keyword.DATATYPE.get_tag_name())
             datatype_type = child.attrib.get(FuzzyOWL2Keyword.TYPE.get_str_value())
 
-            if datatype_type == FuzzyOWL2Keyword.LEFT_SHOULDER:
+            if datatype_type == FuzzyOWL2Keyword.CRISP:
+                return CrispFunction(
+                    float(child.attrib.get(FuzzyOWL2Keyword.A.get_str_value())),
+                    float(child.attrib.get(FuzzyOWL2Keyword.B.get_str_value())),
+                )
+            elif 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())),

{fuzzy_dl_owl2-1.0.9.dist-info → fuzzy_dl_owl2-1.0.10.dist-info}/METADATA

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: fuzzy-dl-owl2
-Version: 1.0.9
+Version: 1.0.10
 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
+License-File: LICENSE
 Author: Giuseppe Filippone
 Author-email: filipponegiuseppe94@gmail.com
 Requires-Python: >=3.11,<4.0
@@ -11,6 +12,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: networkx (>=3.3,<4.0)
 Requires-Dist: owlready2 (>=0.47,<0.48)
 Requires-Dist: pyowl2 (>=1.0.3,<2.0.0)
@@ -290,9 +292,9 @@ restriction             := '(' ('>=' | '<=', '=') name (name | restriction_funct
 |$(\mathrm{>=}\ F\ \text{variable})$| ${\mathrm{sup}}_{b \in {\Delta}_D} \[F^\mathcal{I} (x, b) \otimes (b \geq \text{variable})\]$|
 |$(\mathrm{<=}\ F\ \text{variable})$| $\mathrm{sup}_{b \in \Delta_D} \[F^\mathcal{I} (x, b) \otimes (b \leq \text{variable})\]$|
 |$(=\ F\ \text{variable}) $| $\mathrm{sup}_{b \in \Delta_D} \[F^\mathcal{I} (x, b) \otimes (b = \text{variable})\]$|
-|$(\mathrm{>=}\ F\ \text{fuzzy\_number})$|$\mathrm{sup}_{b^\prime, b \in \Delta_D} \[F^\mathcal{I} (x, b) \otimes (b \geq b^\prime) \otimes {\text{fuzzy\_number}(b^\prime)}^\mathcal{I}\]$|
-|$(\mathrm{<=}\ F\ \text{fuzzy\_number})$|$\mathrm{sup}_{b^\prime, b \in \Delta_D} \[F^\mathcal{I} (x, b) \otimes (b \leq b^\prime) \otimes {\text{fuzzy\_number}(b^\prime)}^\mathcal{I}\]$|
-|$(=\ F\ \text{fuzzy\_number})$|$\mathrm{sup}_{b^\prime, b \in \Delta_D} \[F^\mathcal{I} (x, b) \otimes (b = b^\prime) \otimes {\text{fuzzy\_number}(b^\prime)}^\mathcal{I}\]$|
+|$(\mathrm{>=}\ F\ \text{fuzzy\\_number})$|$\mathrm{sup}_{b^\prime, b \in \Delta_D} \[F^\mathcal{I} (x, b) \otimes (b \geq b^\prime) \otimes {\text{fuzzy\\_number}(b^\prime)}^\mathcal{I}\]$|
+|$(\mathrm{<=}\ F\ \text{fuzzy\\_number})$|$\mathrm{sup}_{b^\prime, b \in \Delta_D} \[F^\mathcal{I} (x, b) \otimes (b \leq b^\prime) \otimes {\text{fuzzy\\_number}(b^\prime)}^\mathcal{I}\]$|
+|$(=\ F\ \text{fuzzy\\_number})$|$\mathrm{sup}_{b^\prime, b \in \Delta_D} \[F^\mathcal{I} (x, b) \otimes (b = b^\prime) \otimes {\text{fuzzy\\_number}(b^\prime)}^\mathcal{I}\]$|
 |$(\mathrm{>=}\ F\ \mathrm{function}(F_1, \ldots, F_n))$|$\mathrm{sup}_{b \in \Delta_D} \[F^\mathcal{I} (x, b) \otimes (b \geq {\mathrm{function}(F_1, \ldots, F_n)}^{\mathcal{I}})\]$|
 |$(\mathrm{<=}\ F\ \mathrm{function}(F_1, \ldots, F_n))$|$\mathrm{sup}_{b \in \Delta_D} \[F^\mathcal{I} (x, b) \otimes (b \leq {\mathrm{function}(F_1, \ldots, F_n)}^{\mathcal{I}})\]$|
 |$(=\ F\ \mathrm{function}(F_1, \ldots, F_n))$|$\mathrm{sup}_{b \in \Delta_D} \[F^\mathcal{I} (x, b) \otimes (b = {\mathrm{function}(F_1, \ldots, F_n)}^{\mathcal{I}})\]$|

{fuzzy_dl_owl2-1.0.9.dist-info → fuzzy_dl_owl2-1.0.10.dist-info}/RECORD

@@ -65,13 +65,13 @@ 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=DXc2ZgjSqAIK5TauJzhcXgifQOB2ZkPxfElRAhJsGVw,6716
-fuzzy_dl_owl2/fuzzydl/fuzzydl_to_owl2.py,sha256=hBYvkfhgwdzhewvAHWUbhie6gNGyfuhVivdnHsDKPvE,57885
+fuzzy_dl_owl2/fuzzydl/fuzzydl_to_owl2.py,sha256=1EPRTpvtnEzfmXB1ktDfJT9cOxIdOCSQxjhK7sDlqzc,58440
 fuzzy_dl_owl2/fuzzydl/general_concept_inclusion.py,sha256=X2gIpmKs0RsU7VoKILxpQdBs2yyLAIqWd5UWOAuk22M,2557
 fuzzy_dl_owl2/fuzzydl/individual/__init__.py,sha256=zBCa24kE2nv08VgtphjLshpbGNEARUJgCdtyv9r6JGc,110
 fuzzy_dl_owl2/fuzzydl/individual/created_individual.py,sha256=lERkUgXkhYJgLJjuEbqLHimd5O2ABuMkMDnNipliJtY,9293
 fuzzy_dl_owl2/fuzzydl/individual/individual.py,sha256=iQIqQvbrQ9XOQABVQTt9UF-3MTc2zrcZgBprNYWJfgA,4408
 fuzzy_dl_owl2/fuzzydl/individual/representative_individual.py,sha256=nayeaoV0B-9xO_I8mttHZTi1CWHs7X7ezhiIjQP7ZBs,1538
-fuzzy_dl_owl2/fuzzydl/knowledge_base.py,sha256=7KcbsRRUS6rsftknzXkDZKXUvlzH9NeqSw56UI8YQqI,449486
+fuzzy_dl_owl2/fuzzydl/knowledge_base.py,sha256=mcRwGq6bPZK9mthGoX5CENulpq9NKiZwQcKlqpu8JGg,449470
 fuzzy_dl_owl2/fuzzydl/label.py,sha256=gh4V0LTwzucaOWoV2n4JIATjs5EbxIIdtppOZttaiw0,1187
 fuzzy_dl_owl2/fuzzydl/milp/__init__.py,sha256=g2oFT2Ge8W5Li2kP2CJjpjJ1a0PRI2vDoDdzYDsEtDY,246
 fuzzy_dl_owl2/fuzzydl/milp/expression.py,sha256=KBGIBid5kZhOT5l4buWmAtPAvm_8JfK3lUNg10GhANg,7160
@@ -86,7 +86,7 @@ fuzzy_dl_owl2/fuzzydl/modifier/linear_modifier.py,sha256=2g3wR-UNqJhLMvyroapu_mb
 fuzzy_dl_owl2/fuzzydl/modifier/modifier.py,sha256=rjNND_cOeGZXNSHlP_eO2RloSlkR6MfvrJgFqUa8Ars,1365
 fuzzy_dl_owl2/fuzzydl/modifier/triangular_modifier.py,sha256=9z_oVC0QidpNCEk0FsN2EDzy7lDWTXl5dNGr3sc04j4,2131
 fuzzy_dl_owl2/fuzzydl/parser/__init__.py,sha256=vs0cN8a1ATeFx1J4evw6k7mWe4zOvba_xMO2eBXZ_gc,32
-fuzzy_dl_owl2/fuzzydl/parser/dl_parser.py,sha256=F0ISLr3uiVLW2AKXiGXDFHmFYuj8ItxBXkHRV3tXgyE,97275
+fuzzy_dl_owl2/fuzzydl/parser/dl_parser.py,sha256=1AqO_7U9xuIRvir-CQNGfSuSDmC13hEhEFLH6W3x-Hs,97242
 fuzzy_dl_owl2/fuzzydl/primitive_concept_definition.py,sha256=xe-pqIDJw64bej2PFQXXApisgK0gHAnhxKJ1ruuyvDk,2523
 fuzzy_dl_owl2/fuzzydl/query/__init__.py,sha256=hWPTep2e_-q4rLitvqiMhA3dWp0VqrFxxv6ZphljMaQ,459
 fuzzy_dl_owl2/fuzzydl/query/all_instances_query.py,sha256=W12qjt6qyPyioR7H3730PiJOq0PbNoTGHfepbG66C24,4946
@@ -127,21 +127,22 @@ fuzzy_dl_owl2/fuzzydl/util/constants.py,sha256=He8y8tmhgku9ZB2IbZP-OUaZYLQN_6dkd
 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=TYnSLXK-oR7jsOEFR46WryA0gKVBLbBI0_3Cd-dHUuU,71691
-fuzzy_dl_owl2/fuzzyowl2/fuzzyowl2_to_fuzzydl.py,sha256=egspxTzY4kNvhsQLP0AAaqJgFUqyO6VJuXLLOej06PA,36994
+fuzzy_dl_owl2/fuzzyowl2/fuzzyowl2.py,sha256=BzUdv4W4TOXUGMLY1frEi4UPw6a5WEruROGOU8-fE70,74128
+fuzzy_dl_owl2/fuzzyowl2/fuzzyowl2_to_fuzzydl.py,sha256=dvMq7y8fPm5WZaPnESw4C7r7ZwQfewqSDJ01S7WD5YE,40876
 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
 fuzzy_dl_owl2/fuzzyowl2/owl_types/concept_definition.py,sha256=d5ZsEX8NN-aYJohXGzeJFhrnufCJ6AZ1YLGiclwysDc,324
+fuzzy_dl_owl2/fuzzyowl2/owl_types/crisp_function.py,sha256=YmXcbFfnqFR7YONl4jNJjG8b2ErpzCH-vUuNNGGrAkY,455
 fuzzy_dl_owl2/fuzzyowl2/owl_types/fuzzy_datatype.py,sha256=hgwLDROjJjevl8IUxRMSw1s_HX0Ooww3MaXYrwvF7n4,464
 fuzzy_dl_owl2/fuzzyowl2/owl_types/fuzzy_modifier.py,sha256=LOqjKDz6_Gi0vXzz9oKagSBnlHqUS_PDwIFYFbb6ne0,50
-fuzzy_dl_owl2/fuzzyowl2/owl_types/fuzzy_nominal_concept.py,sha256=reEvK6IS-rerO5wnIUWNg49mohh5irAEQ0teopztjMo,565
+fuzzy_dl_owl2/fuzzyowl2/owl_types/fuzzy_nominal_concept.py,sha256=0M-YtytiiHCip_YfAJHX1OHd2GHfdesKmnA40ubol9g,564
 fuzzy_dl_owl2/fuzzyowl2/owl_types/fuzzy_property.py,sha256=AK_L-JtEwTN_gjmDRnY5i4i3w7lGDVtT4Ba7ryVPz38,52
 fuzzy_dl_owl2/fuzzyowl2/owl_types/left_shoulder_function.py,sha256=xeiJGisZSwWbHp4a9indXmu-IOJsR-qMDYLBzw2c1UI,470
 fuzzy_dl_owl2/fuzzyowl2/owl_types/linear_function.py,sha256=3MZR09E0AhUTEHQZY_RUpucYqIBZPiP84rBj4EMQOyo,457
 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=d94ZQRWJ_BoH0lvM_XuwexeAlQGDZDB6Lq0WaO9acaQ,545
+fuzzy_dl_owl2/fuzzyowl2/owl_types/modified_concept.py,sha256=U-E7RfIfbYvqm_08p7kcIAfuwXNYC5lkfKne4MHjPFg,554
+fuzzy_dl_owl2/fuzzyowl2/owl_types/modified_function.py,sha256=liebxiX_dHmbPTdpSVmdrnOdR6lBALYBD_bOB_MnUHE,427
+fuzzy_dl_owl2/fuzzyowl2/owl_types/modified_property.py,sha256=CFdaZJyozJZB-g69YZfBw0gN-aFSi-LJSMvibVXo4Mk,544
 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,17 +153,17 @@ fuzzy_dl_owl2/fuzzyowl2/owl_types/trapezoidal_function.py,sha256=l3KRs7ACesW9MM8
 fuzzy_dl_owl2/fuzzyowl2/owl_types/triangular_function.py,sha256=gteNPNUnUheMpNEKnr6t88Lxe5p_ust-oeDrLU51Au4,567
 fuzzy_dl_owl2/fuzzyowl2/owl_types/triangular_modifer.py,sha256=Z7Tc3bDbU9U_LXUGnrdugGHa2PQ81qN91NbQAdaWbXo,552
 fuzzy_dl_owl2/fuzzyowl2/owl_types/weighted_concept.py,sha256=sd_KYs0__df_Zv1P6KGU1oTvz4zi5Y2UyyfF57vYru0,542
-fuzzy_dl_owl2/fuzzyowl2/owl_types/weighted_max_concept.py,sha256=NEIshfx9h4XyvfOOA3pKMGE5dkDWofujnn2LTNg7SNo,510
-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/owl_types/weighted_max_concept.py,sha256=kAfNUtxq-SmVA9WCyJpwHkj57znpg_c28MioQJ89myM,530
+fuzzy_dl_owl2/fuzzyowl2/owl_types/weighted_min_concept.py,sha256=zJY2v58sPhmFcUAWKPuyT0rJXoU82Prqg4aCT62MtRQ,530
+fuzzy_dl_owl2/fuzzyowl2/owl_types/weighted_sum_concept.py,sha256=wlVYizlgvMlD6GGTX20a8mTMBJqFSYn9CV-tKL76jeE,530
+fuzzy_dl_owl2/fuzzyowl2/owl_types/weighted_sum_zero_concept.py,sha256=SD1xHZaEDeOkGHp0kceyoXRH44g8tbRjEKvFm1dpdXI,544
 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/parser/owl2_xml_parser.py,sha256=-no2LqMt8xqx5o_I4BRzk6q3c2tmot3EhXbMN8OglYE,11587
 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.9.dist-info/LICENSE,sha256=er4Z7Ju3OzYUG5mbhh0krYVegIuv4PgehMzihVb2wpc,20131
-fuzzy_dl_owl2-1.0.9.dist-info/METADATA,sha256=4ZAdUZlkFAlvimwzfmr2c6nwNElsiKGE8x4Ai7l4nI4,43763
-fuzzy_dl_owl2-1.0.9.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-fuzzy_dl_owl2-1.0.9.dist-info/RECORD,,
+fuzzy_dl_owl2-1.0.10.dist-info/METADATA,sha256=-exBj5DbR3tU5en64ZVyhxjGMIZzR2Yx4l8jx1AaIoo,43843
+fuzzy_dl_owl2-1.0.10.dist-info/WHEEL,sha256=kJCRJT_g0adfAJzTx2GUMmS80rTJIVHRCfG0DQgLq3o,88
+fuzzy_dl_owl2-1.0.10.dist-info/licenses/LICENSE,sha256=er4Z7Ju3OzYUG5mbhh0krYVegIuv4PgehMzihVb2wpc,20131
+fuzzy_dl_owl2-1.0.10.dist-info/RECORD,,

{fuzzy_dl_owl2-1.0.9.dist-info → fuzzy_dl_owl2-1.0.10.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.3
+Generator: poetry-core 2.3.1
 Root-Is-Purelib: true
 Tag: py3-none-any