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

fuzzy_dl_owl2/fuzzydl/general_concept_inclusion.py

@@ -8,6 +8,8 @@ from fuzzy_dl_owl2.fuzzydl.util.constants import LogicOperatorType
 
 
 class GeneralConceptInclusion:
+    """General concept inclusion axiom."""
+
     def __init__(
         self,
         subsumer: Concept,
@@ -15,9 +17,13 @@ class GeneralConceptInclusion:
         degree: Degree,
         type_: LogicOperatorType,
     ):
+        # Subsumer concept
         self.subsumer: Concept = subsumer
+        # Subsumed concept
         self.subsumed: Concept = subsumed
+        # Lower bound degree
         self.degree: Degree = degree
+        # Type (depends on the fuzzy implication)
         self.type: LogicOperatorType = type_
 
     def clone(self) -> typing.Self:

fuzzy_dl_owl2/fuzzydl/individual/created_individual.py

@@ -57,27 +57,41 @@ class CreatedIndividual(Individual):
     ) -> None:
         super().__init__(name)
 
+        # Array of representative individuals
         self.representatives: list[RepresentativeIndividual] = list()
 
+        # List of concept labels
         self.concept_list: set[int] = set()
+
+        # Indicates if the individual is directly blocked or not
         self.directly_blocked: CreatedIndividualBlockingType = (
             CreatedIndividualBlockingType.UNCHECKED
         )
+
+        # Indicates if the individual is indirectly blocked or not
         self.indirectly_blocked: CreatedIndividualBlockingType = (
             CreatedIndividualBlockingType.UNCHECKED
         )
+
         self.not_self_roles: set[str] = set()
+        # Parent of the individual
         self.parent: typing.Optional[Individual] = parent
+        # Name of the role for which the individual is a filler
         self.role_name: str = role_name
+
+        # Depth of the individual in the completion forest
         self.depth: int = (
             typing.cast(CreatedIndividual, parent).depth + 1
             if parent is not None and parent.is_blockable()
             else 2
         )
 
+        # Name of the blocking ancestors
         self.blocking_ancestor: typing.Optional[str] = None
         self.blocking_ancestor_y: typing.Optional[str] = None
         self.blocking_ancestor_y_prime: typing.Optional[str] = None
+
+        # Indicates if the individual is concrete or not (abstract)
         self._is_concrete: bool = False
 
         if parent is not None:
@@ -118,7 +132,8 @@ class CreatedIndividual(Individual):
         ind.role_name = self.role_name
 
     def get_integer_id(self) -> int:
-        return int(self.name[1:])
+        prefix_len: int = len(Individual.DEFAULT_NAME)
+        return int(self.name[prefix_len:])
 
     def get_depth(self) -> int:
         return self.depth
@@ -138,6 +153,19 @@ class CreatedIndividual(Individual):
         f_name: str,
         f: TriangularFuzzyNumber,
     ) -> typing.Optional[typing.Self]:
+        """
+        Return b individual p with b representative of b set of individuals if it exists. Given b fuzzy number F, b representative individual is the set of individuals that are greater or equal (or less or equal) than F.
+        The representative individual is related to p via b concrete feature f.
+
+        Args:
+            type (InequalityType): Type of the representative individual (GREATER_EQUAL, LESS_EQUAL)
+            f_name (str): Name of the feature for which the individual is b filler
+            f (TriangularFuzzyNumber): Fuzzy number
+
+        Returns:
+            typing.Optional[typing.Self]: A new individual with b representative individual
+        """
+        # Retrieve representative individual, if it exists
         for ind in self.representatives:
             if (
                 ind.get_type() != type
@@ -146,9 +174,13 @@ class CreatedIndividual(Individual):
             ):
                 continue
             return ind.get_individual()
+        # // Otherwise, None
         return None
 
     def mark_indirectly_blocked(self) -> None:
+        """
+        Marks the subtree of a node as indirectly blocked
+        """
         Util.debug(
             f"{constants.SEPARATOR}Mark subtree of {self.name} indirectly blocked"
         )
@@ -156,6 +188,7 @@ class CreatedIndividual(Individual):
         queue.append(self)
         while len(queue) > 0:
             ind: CreatedIndividual = queue.popleft()
+            # If there are no descendants, skip
             if len(ind.role_relations) == 0:
                 break
             for role in ind.role_relations:
@@ -165,7 +198,7 @@ class CreatedIndividual(Individual):
                         f"{rel.get_subject_individual()} has role {rel.get_role_name()} with filler {rel.get_object_individual()}"
                     )
                     son: Individual = rel.get_object_individual()
-                    if son != ind.parent:
+                    if son != ind.parent:  # son is not the parent via inverse role
                         if not son.is_blockable():
                             continue
                         son: CreatedIndividual = typing.cast(CreatedIndividual, son)
@@ -183,9 +216,15 @@ class CreatedIndividual(Individual):
     def individual_set_intersection_of(
         self, set1: SortedSet[typing.Self], set2: SortedSet[typing.Self]
     ) -> SortedSet[typing.Self]:
+        """
+        Gets the intersection of two concept labels.
+        """
         return set1.intersection(set2)
 
     def set_concrete_individual(self) -> None:
+        """
+        Sets that the individual is concrete.
+        """
         self._is_concrete = True
 
     def is_concrete(self) -> bool:

fuzzy_dl_owl2/fuzzydl/individual/individual.py

@@ -18,16 +18,24 @@ from fuzzy_dl_owl2.fuzzydl.util.constants import RepresentativeIndividualType
 
 
 class Individual:
+    # Default prefix for new individual names
     DEFAULT_NAME: str = "i"
 
     def __init__(self, name: str) -> None:
         self.name: str = name
+        # Concrete role restrictions
         self.concrete_role_restrictions: dict[str, list[Assertion]] = dict()
+        # Fillers to show
         self.fillers_to_show: dict[str, set[str]] = dict()
+        # List of concepts such that a concept assertion has been processed
         self.list_of_concepts: set[Concept] = set()
+        # Indicates if the individual is indirectly blocked or not
         self.nominal_list: set[str] = set()
+        # List of roles for which to apply the not self rule
         self.not_self_roles: set[str] = list()
+        # Role relations
         self.role_relations: dict[str, list[Relation]] = dict()
+        # Role restrictions
         self.role_restrictions: dict[str, list[Restriction]] = dict()
 
     def clone(self) -> typing.Self:
@@ -55,6 +63,9 @@ class Individual:
         self.name = name
 
     def add_concrete_restriction(self, f_name: str, ass: Assertion) -> None:
+        """
+        Adds a negated datatype restriction to the individual.
+        """
         self.concrete_role_restrictions[f_name] = self.concrete_role_restrictions.get(
             f_name, []
         ) + [ass]
@@ -91,12 +102,15 @@ class Individual:
     def prune(self) -> None:
         to_prune: list[Individual] = []
         for role in self.role_relations:
+            # We remove all relations
             rels: list[Relation] = self.role_relations.get(role, [])
             for r in rels:
                 obj: Individual = r.get_object_individual()
                 if obj.is_blockable():
                     to_prune.append(obj)
+        # We remove all relations
         self.role_relations = dict()
+        # Prune blockable successors
         for i in to_prune:
             i.prune()
 

fuzzy_dl_owl2/fuzzydl/individual/representative_individual.py

@@ -12,6 +12,11 @@ if typing.TYPE_CHECKING:
 
 class RepresentativeIndividual:
 
+    """
+    New concrete individual being a representative of a set of individuals.
+    Given an individual p and a fuzzy number F, a representative individual is the set of individuals that are greater or equal (or less or equal) than F. Then, p is related to the representative individual in some way.
+    """
+
     def __init__(
         self,
         c_type: RepresentativeIndividualType,
@@ -19,9 +24,13 @@ class RepresentativeIndividual:
         f: TriangularFuzzyNumber,
         ind: CreatedIndividual,
     ) -> None:
+        # Name of the feature for which the individual is a filler.
         self.f_name: str = f_name
+        # Type of the individual
         self.type: RepresentativeIndividualType = c_type
+        # Fuzzy number
         self.f: TriangularFuzzyNumber = f
+        # Reference individual
         self.ind: CreatedIndividual = ind
 
     def get_type(self) -> RepresentativeIndividualType: