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

fuzzy_dl_owl2/fuzzydl/fuzzydl_to_owl2.py

@@ -3,9 +3,11 @@ from __future__ import annotations
 import os
 import sys
 import typing
+import urllib
+import urllib.parse
 from functools import partial
 
-from rdflib import RDF, XSD, Literal, Namespace, URIRef
+from rdflib import RDF, RDFS, XSD, Literal, Namespace, URIRef
 
 from fuzzy_dl_owl2.fuzzydl.assertion.assertion import Assertion
 from fuzzy_dl_owl2.fuzzydl.concept.all_some_concept import AllSomeConcept
@@ -61,6 +63,7 @@ from fuzzy_dl_owl2.fuzzydl.primitive_concept_definition import (
     PrimitiveConceptDefinition,
 )
 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 ConceptType, ConcreteFeatureType
 from fuzzy_dl_owl2.fuzzydl.util.util import Util
 from fuzzy_dl_owl2.fuzzyowl2.util.constants import FuzzyOWL2Keyword
@@ -129,8 +132,6 @@ from pyowl2.individual.named_individual import OWLNamedIndividual
 from pyowl2.literal.literal import OWLLiteral
 from pyowl2.ontology import OWLOntology
 
-from fuzzy_dl_owl2.fuzzydl.util.config_reader import ConfigReader
-
 
 # @utils.timer_decorator
 class FuzzydlToOwl2:
@@ -143,10 +144,12 @@ class FuzzydlToOwl2:
         # base_iri: str = "http://www.semanticweb.org/ontologies/fuzzydl_ontology.owl",
         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 = base_iri
-        self.ontology_iri: IRI = IRI(Namespace(URIRef(base_iri)))
+        self.ontology_path: str = f"{base_iri}#"
+        self.ontology_iri: IRI = IRI(Namespace(URIRef(self.ontology_path)))
         self.ontology: OWLOntology = OWLOntology(
             self.ontology_iri, OWL1_annotations=True
         )
@@ -154,7 +157,19 @@ class FuzzydlToOwl2:
             IRI(self.ontology_iri.namespace, ConfigReader.OWL_ANNOTATION_LABEL)
         )
 
-        self.ontology.add_axiom(OWLDeclaration(self.fuzzyLabel))
+        self.ontology.add_axiom(
+            OWLDeclaration(
+                self.fuzzyLabel,
+                [
+                    OWLAnnotation(
+                        OWLAnnotationProperty(URIRef(RDFS.label)),
+                        OWLLiteral(
+                            Literal(ConfigReader.OWL_ANNOTATION_LABEL, lang="en")
+                        ),
+                    )
+                ],
+            )
+        )
 
         self.concepts: dict[str, OWLClassExpression] = dict()
         self.datatypes: dict[str, OWLDatatype] = dict()
@@ -162,9 +177,46 @@ class FuzzydlToOwl2:
         self.input_FDL: str = input_file
         self.output_FOWL: str = os.path.join(constants.RESULTS_PATH, output_file)
 
-    def iri(self, o: object) -> IRI:
+    def iri(self, o: object, iri_type: type = OWLClass) -> IRI:
         """Convert object to IRI string"""
-        return IRI(self.ontology_iri.namespace, str(o))
+        namespace: URIRef = self.ontology_iri.namespace
+        if iri_type == OWLClass:
+            namespace = Namespace(f"{self.ontology_path[:-1]}/class#")
+        elif iri_type == OWLDataProperty:
+            namespace = Namespace(f"{self.ontology_path[:-1]}/data-property#")
+        elif iri_type == OWLObjectProperty:
+            namespace = Namespace(f"{self.ontology_path[:-1]}/object-property#")
+        elif iri_type == OWLNamedIndividual:
+            namespace = Namespace(f"{self.ontology_path[:-1]}/individual#")
+        elif iri_type == OWLDatatype:
+            namespace = Namespace(f"{self.ontology_path[:-1]}/datatype#")
+        elif iri_type == OWLAnnotationProperty:
+            namespace = Namespace(f"{self.ontology_path[:-1]}/annotation-property#")
+        return IRI(namespace, str(o))
+
+    def individual_iri(self, o: object) -> IRI:
+        """Convert individual object to IRI string"""
+        return self.iri(o, OWLNamedIndividual)
+
+    def class_iri(self, o: object) -> IRI:
+        """Convert class to IRI string"""
+        return self.iri(o, OWLClass)
+
+    def data_property_iri(self, o: object) -> IRI:
+        """Convert data property to IRI string"""
+        return self.iri(o, OWLDataProperty)
+
+    def object_property_iri(self, o: object) -> IRI:
+        """Convert object property to IRI string"""
+        return self.iri(o, OWLObjectProperty)
+
+    def datatype_iri(self, o: object) -> IRI:
+        """Convert datatype to IRI string"""
+        return self.iri(o, OWLDatatype)
+
+    def annotation_property_iri(self, o: object) -> IRI:
+        """Convert datatype to IRI string"""
+        return self.iri(o, OWLAnnotationProperty)
 
     def get_base(self, c: Concept) -> OWLClassExpression:
         """Get the base class for a concept"""
@@ -189,8 +241,18 @@ class FuzzydlToOwl2:
 
     def __get_class_1(self, name: str) -> OWLClassExpression:
         """Get or create an OWL class by name"""
-        cls = OWLClass(self.iri(name))
-        self.ontology.add_axiom(OWLDeclaration(cls))
+        cls = OWLClass(self.class_iri(name))
+        self.ontology.add_axiom(
+            OWLDeclaration(
+                cls,
+                [
+                    OWLAnnotation(
+                        OWLAnnotationProperty(URIRef(RDFS.label)),
+                        OWLLiteral(Literal(name, lang="en")),
+                    )
+                ],
+            )
+        )
         return cls
 
     def __get_class_2(self, c: Concept) -> OWLClassExpression:
@@ -199,7 +261,17 @@ class FuzzydlToOwl2:
         c_type: ConceptType = c.type
         if c_type in (ConceptType.ATOMIC, ConceptType.CONCRETE):
             cls = self.get_class(str(c))
-            self.ontology.add_axiom(OWLDeclaration(cls))
+            self.ontology.add_axiom(
+                OWLDeclaration(
+                    cls,
+                    [
+                        OWLAnnotation(
+                            OWLAnnotationProperty(URIRef(RDFS.label)),
+                            OWLLiteral(Literal(str(c), lang="en")),
+                        )
+                    ],
+                )
+            )
             return cls
         elif c_type == ConceptType.TOP:
             return OWLClass.thing()
@@ -277,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)
@@ -346,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)
@@ -382,8 +453,18 @@ class FuzzydlToOwl2:
             return self.__get_class_weighted(c)
         elif c_type == ConceptType.QUANTIFIED_OWA:
             return self.__get_class_q_owa(c)
-        cls = OWLClass(self.iri(str(c)))
-        self.ontology.add_axiom(OWLDeclaration(cls))
+        cls = OWLClass(self.class_iri(str(c)))
+        self.ontology.add_axiom(
+            OWLDeclaration(
+                cls,
+                [
+                    OWLAnnotation(
+                        OWLAnnotationProperty(URIRef(RDFS.label)),
+                        OWLLiteral(Literal(str(c), lang="en")),
+                    )
+                ],
+            )
+        )
         return cls
 
     def __get_class_weighted_min_max_sum(self, c: Concept) -> OWLClassExpression:
@@ -415,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)
@@ -528,14 +609,24 @@ class FuzzydlToOwl2:
 
         self.num_classes += 1
         Util.debug(f"Creating new atomic concept -> {name}")
-        c2: OWLClass = OWLClass(self.iri(f"class__{self.num_classes}"))
+        c2: OWLClass = OWLClass(self.class_iri(f"class__{self.num_classes}"))
         self.concepts[name] = c2
-        self.ontology.add_axiom(OWLDeclaration(c2))
+        self.ontology.add_axiom(
+            OWLDeclaration(
+                c2,
+                [
+                    OWLAnnotation(
+                        OWLAnnotationProperty(URIRef(RDFS.label)),
+                        OWLLiteral(Literal(name, lang="en")),
+                    )
+                ],
+            )
+        )
         return c2
 
     def exist_object_property(self, role: str) -> bool:
         """Check if an object property exists"""
-        iri: IRI = self.iri(role)
+        iri: IRI = self.object_property_iri(role)
         return self.ontology.getter.exists_object_property(iri.to_uriref())
         # return any(
         #     typing.cast(OWLObjectProperty, typing.cast(OWLDeclaration, prop).entity).iri
@@ -545,7 +636,7 @@ class FuzzydlToOwl2:
 
     def exist_data_property(self, role: str) -> bool:
         """Check if a data property exists"""
-        iri: IRI = self.iri(role)
+        iri: IRI = self.data_property_iri(role)
         return self.ontology.getter.exists_data_property(iri.to_uriref())
         # return any(
         #     typing.cast(OWLDataProperty, typing.cast(OWLDeclaration, prop).entity).iri
@@ -560,8 +651,18 @@ class FuzzydlToOwl2:
         Util.debug(f"Getting object property -> {role}")
         if self.exist_data_property(role):
             return self.get_data_property(role)
-        obj = OWLObjectProperty(self.iri(role))
-        self.ontology.add_axiom(OWLDeclaration(obj))
+        obj = OWLObjectProperty(self.object_property_iri(role))
+        self.ontology.add_axiom(
+            OWLDeclaration(
+                obj,
+                [
+                    OWLAnnotation(
+                        OWLAnnotationProperty(URIRef(RDFS.label)),
+                        OWLLiteral(Literal(role, lang="en")),
+                    )
+                ],
+            )
+        )
         return obj
 
     def get_data_property(
@@ -571,15 +672,35 @@ class FuzzydlToOwl2:
         Util.debug(f"Getting data property -> {role}")
         if self.exist_object_property(role):
             return self.get_object_property(role)
-        data = OWLDataProperty(self.iri(role))
-        self.ontology.add_axiom(OWLDeclaration(data))
+        data = OWLDataProperty(self.data_property_iri(role))
+        self.ontology.add_axiom(
+            OWLDeclaration(
+                data,
+                [
+                    OWLAnnotation(
+                        OWLAnnotationProperty(URIRef(RDFS.label)),
+                        OWLLiteral(Literal(role, lang="en")),
+                    )
+                ],
+            )
+        )
         return data
 
     def get_individual(self, name: str) -> OWLNamedIndividual:
         """Get or create a named individual"""
         Util.debug(f"Getting individual -> {name}")
-        ind = OWLNamedIndividual(self.iri(f"{name}_Individual"))
-        self.ontology.add_axiom(OWLDeclaration(ind))
+        ind = OWLNamedIndividual(self.individual_iri(f"{name}"))
+        self.ontology.add_axiom(
+            OWLDeclaration(
+                ind,
+                [
+                    OWLAnnotation(
+                        OWLAnnotationProperty(URIRef(RDFS.label)),
+                        OWLLiteral(Literal(name, lang="en")),
+                    )
+                ],
+            )
+        )
         return ind
 
     def to_owl_annotation(self, annotation: str) -> OWLAnnotation:
@@ -677,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)
@@ -890,7 +1026,7 @@ class FuzzydlToOwl2:
     def _process_concrete_concept(self, c: FuzzyConcreteConcept) -> None:
         """Process a concrete concept"""
         Util.debug(f"Process concrete concept -> {c}")
-        current_datatype: OWLDatatype = OWLDatatype(self.iri(c))
+        current_datatype: OWLDatatype = OWLDatatype(self.datatype_iri(c))
         self.datatypes[str(c)] = current_datatype
 
         # specific: str = self._get_concrete_concept_specifics(c)
@@ -921,7 +1057,17 @@ class FuzzydlToOwl2:
         definition: OWLDatatypeDefinition = OWLDatatypeDefinition(
             current_datatype, unit_interval
         )
-        self.ontology.add_axiom(OWLDeclaration(current_datatype))
+        self.ontology.add_axiom(
+            OWLDeclaration(
+                current_datatype,
+                [
+                    OWLAnnotation(
+                        OWLAnnotationProperty(URIRef(RDFS.label)),
+                        OWLLiteral(Literal(str(c), lang="en")),
+                    )
+                ],
+            )
+        )
         self.ontology.add_axiom(definition)
 
         main_xml = FuzzyXML.build_main_xml(FuzzyOWL2Keyword.DATATYPE.get_str_value())
@@ -1020,9 +1166,19 @@ class FuzzydlToOwl2:
         main_xml.append(modifier_xml)
         annotation: str = FuzzyXML.to_str(main_xml)
 
-        current_datatype: OWLDatatype = OWLDatatype(self.iri(mod))
+        current_datatype: OWLDatatype = OWLDatatype(self.datatype_iri(mod))
         self.modifiers[str(mod)] = current_datatype
-        self.ontology.add_axiom(OWLDeclaration(current_datatype))
+        self.ontology.add_axiom(
+            OWLDeclaration(
+                current_datatype,
+                [
+                    OWLAnnotation(
+                        OWLAnnotationProperty(URIRef(RDFS.label)),
+                        OWLLiteral(Literal(str(mod), lang="en")),
+                    )
+                ],
+            )
+        )
         self.add_entity_annotation(annotation, current_datatype)
 
     def _process_assertion(self, ass: Assertion) -> None:

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
 
@@ -10139,7 +10125,7 @@ class CreatedIndividualHandler:
     ) -> bool:
         """
         Gets if the individual is indirectly blocked with respect to a fuzzy KB.
-            Case SUBSET or SET blocking.
+        Case SUBSET or SET blocking.
         A node v is indirectly blocked iff one of its ancestors are blocked.
         """
         # Don't test if not deep enough in completion forest
@@ -10353,11 +10339,7 @@ class CreatedIndividualHandler:
     ) -> bool:
         """
         Gets if the individual is directly blocked with respect to a fuzzy KB.
-
-        A node v is directly blocked iff none of its ancestors are blocked
-        and there exists an ancestor w such that
-                                    L(v) = L(w),
-        where L(*) is the set of Concept's labels for a node.
+        A node v is directly blocked iff none of its ancestors are blocked and there exists an ancestor w such that L(v) = L(w), where L(*) is the set of Concept's labels for a node.
         In this case we say that w directly blocks v.
         """
         type: BlockingDynamicType = kb.blocking_type

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:]
         ]