fix: fix method calls in Introspection, Navigation, Relations implementations using Graphblas

Author: ecarrenolozano

ontograph/queries/introspection.py

@@ -352,7 +352,7 @@ def get_distance_from_root(self, term_id: str) -> int:
             raise KeyError(f'Unknown term ID: {term_id}')
 
         # Get all ancestors with distance
-        ancestors_with_distance = self.get_ancestors_with_distance(
+        ancestors_with_distance = self.__navigator.get_ancestors_with_distance(
             term_id, include_self=True
         )
 
@@ -388,13 +388,13 @@ def get_path_between(self, node_a: str, node_b: str) -> list:
 
         # Check if a path exists
         if not (
-            self.is_ancestor(node_a, node_b)
-            or self.is_descendant(node_a, node_b)
+            self.__relations.is_ancestor(node_a, node_b)
+            or self.__relations.is_descendant(node_a, node_b)
         ):
             return []
 
         # Determine direction
-        if self.is_ancestor(node_a, node_b):
+        if self.__relations.is_ancestor(node_a, node_b):
             start, end = node_a, node_b
             adjacency_matrix = self.matrices_container['is_a']
         else:
@@ -417,7 +417,9 @@ def get_path_between(self, node_a: str, node_b: str) -> list:
                 return self.lookup_tables.index_to_term(path)
 
             # Get children (or parents depending on direction)
-            neighbors_vec = adjacency_matrix @ self.one_hot_vector(current)
+            neighbors_vec = adjacency_matrix @ self.__navigator.one_hot_vector(
+                current
+            )
             neighbors = neighbors_vec.to_coo()[0]
 
             for n in neighbors:

ontograph/queries/navigator.py

@@ -578,7 +578,7 @@ def _traverse_graph_with_distance(
 
     # -- get_parents(term_id, include_self=False)
     def get_parents(self, term_id: str, include_self: bool = False) -> list:
-        # validate and resolve the index
+        # Validate and resolve the index
         if term_id not in self.lookup_tables.get_lut_term_to_index():
             raise KeyError(f'Unknown term ID: {term_id}')
 
@@ -587,17 +587,16 @@ def get_parents(self, term_id: str, include_self: bool = False) -> list:
         # Initialize a one-hot vector for the term node
         vector_node = self.one_hot_vector(index=index)
 
-        # Propagate to children using matrix-vector multiplication
+        # Propagate to parents using matrix-vector multiplication
         parent_vec = (self.matrices_container['is_a'].T @ vector_node).new()
 
-        # Optionally include the node itself
+        # Extract parent indices efficiently
+        parent_indices = set(parent_vec.to_coo()[0])
         if include_self:
-            parent_vec[index] = True
+            parent_indices.add(index)
 
-        # translate indexes to terms
-        terms = list(parent_vec)
-
-        return self.lookup_tables.index_to_term(terms)
+        # Convert indices to term IDs
+        return self.lookup_tables.index_to_term(list(parent_indices))
 
     # -- get_root()
     def get_root(self) -> list:

ontograph/queries/relations.py

@@ -317,7 +317,7 @@ def is_descendant(self, descendant_node: str, ancestor_node: str) -> bool:
 
         # Retrieve descendants of the ancestor
         descendants = set(
-            self.get_descendants(ancestor_node, include_self=False)
+            self.__navigator.get_descendants(ancestor_node, include_self=False)
         )
         return descendant_node in descendants
 
@@ -344,8 +344,12 @@ def is_sibling(self, node_a: str, node_b: str) -> bool:
             raise KeyError(f'Unknown term ID: {node_b}')
 
         # Step 1: Get parents for both nodes
-        parents_a = set(self.get_parents(node_a, include_self=False))
-        parents_b = set(self.get_parents(node_b, include_self=False))
+        parents_a = set(
+            self.__navigator.get_parents(node_a, include_self=False)
+        )
+        parents_b = set(
+            self.__navigator.get_parents(node_b, include_self=False)
+        )
 
         # Step 2: Intersection of parents indicates sibling relationship
         shared_parents = parents_a.intersection(parents_b)
@@ -373,12 +377,14 @@ def get_common_ancestors(self, node_ids: list[str]) -> set:
 
         # get ancestors for the first node
         common_ancestors = set(
-            self.get_ancestors(node_ids[0], include_self=False)
+            self.__navigator.get_ancestors(node_ids[0], include_self=False)
         )
 
         # intersect with ancestors of the rest
         for term_id in node_ids[1:]:
-            ancestors = set(self.get_ancestors(term_id, include_self=False))
+            ancestors = set(
+                self.__navigator.get_ancestors(term_id, include_self=False)
+            )
             common_ancestors.intersection_update(ancestors)
 
             # early exit if no common ancestor remains
@@ -410,7 +416,9 @@ def get_lowest_common_ancestors(self, node_ids: list[str]) -> list[str]:
 
         # Compute ancestors with distances for the first node
         first_ancestors = dict(
-            self.get_ancestors_with_distance(node_ids[0], include_self=False)
+            self.__navigator.get_ancestors_with_distance(
+                node_ids[0], include_self=False
+            )
         )
         common_ancestors = set(first_ancestors.keys())
 
@@ -421,7 +429,9 @@ def get_lowest_common_ancestors(self, node_ids: list[str]) -> list[str]:
         # Process remaining nodes
         for term_id in node_ids[1:]:
             ancestors_with_distance = dict(
-                self.get_ancestors_with_distance(term_id, include_self=False)
+                self.__navigator.get_ancestors_with_distance(
+                    term_id, include_self=False
+                )
             )
             ancestors_set = set(ancestors_with_distance.keys())
             common_ancestors.intersection_update(ancestors_set)