fuzzy-dl-owl2 1.0.9__tar.gz → 1.0.10__tar.gz

{fuzzy_dl_owl2-1.0.9 → fuzzy_dl_owl2-1.0.10}/PKG-INFO

@@ -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 → fuzzy_dl_owl2-1.0.10}/README.md

@@ -265,9 +265,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 → fuzzy_dl_owl2-1.0.10}/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-1.0.9 → fuzzy_dl_owl2-1.0.10}/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-1.0.9 → fuzzy_dl_owl2-1.0.10}/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-1.0.9 → fuzzy_dl_owl2-1.0.10}/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}")