chores: change case style for parameters, from nodeA to node_a for instance.

Author: ecarrenolozano

notebooks/quickstart_demo.ipynb

@@ -706,7 +706,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "client_dummy_ontology.is_sibling(nodeA='F', nodeB='G')"
+    "client_dummy_ontology.is_sibling(node_a='F', node_b='G')"
    ]
   },
   {
@@ -745,7 +745,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "client_dummy_ontology.get_path_between(nodeA='Q', nodeB='B')"
+    "client_dummy_ontology.get_path_between(node_a='Q', node_b='B')"
    ]
   },
   {

ontograph/client.py

@@ -539,23 +539,23 @@ def is_descendant(self, descendant_node: str, ancestor_node: str) -> bool:
             ancestor_node=ancestor_node,
         )
 
-    def is_sibling(self, nodeA: str, nodeB: str) -> bool:
+    def is_sibling(self, node_a: str, node_b: str) -> bool:
         """Check if two terms are siblings.
 
         Args:
-            nodeA (str): First term ID.
-            nodeB (str): Second term ID.
+            node_a (str): First term ID.
+            node_b (str): Second term ID.
 
         Returns:
-            bool: True if nodeA and nodeB are siblings.
+            bool: True if node_a and node_b are siblings.
 
         Example:
             >>> client = ClientOntology()
             >>> ontology = client.load(file_path_ontology="./tests/resources/dummy_ontology.obo")
             >>> client.is_sibling("E", "F")
             True
         """
-        return self._relations.is_sibling(nodeA=nodeA, nodeB=nodeB)
+        return self._relations.is_sibling(node_a=node_a, node_b=node_b)
 
     def get_common_ancestors(self, node_ids: list[str]) -> set:
         """Get common ancestors of multiple terms.
@@ -610,12 +610,12 @@ def get_distance_from_root(self, term_id: str) -> int | None:
         """
         return self._introspection.get_distance_from_root(term_id=term_id)
 
-    def get_path_between(self, nodeA: str, nodeB: str) -> list[dict]:
+    def get_path_between(self, node_a: str, node_b: str) -> list[dict]:
         """Get the path between two terms.
 
         Args:
-            nodeA (str): Start term ID.
-            nodeB (str): End term ID.
+            node_a (str): Start term ID.
+            node_b (str): End term ID.
 
         Returns:
             list[dict]: List of path steps.
@@ -628,7 +628,9 @@ def get_path_between(self, nodeA: str, nodeB: str) -> list[dict]:
             >>> client.get_path_between("N", "C")
             []
         """
-        return self._introspection.get_path_between(nodeA=nodeA, nodeB=nodeB)
+        return self._introspection.get_path_between(
+            node_a=node_a, node_b=node_b
+        )
 
     def get_trajectories_from_root(self, term_id: str) -> list[dict]:
         """Get all trajectories from the root to a term.

ontograph/queries/introspection.py

@@ -65,12 +65,12 @@ def get_distance_from_root(self, term_id: str) -> int | None:
 
         return distance
 
-    def get_path_between(self, nodeA: str, nodeB: str) -> list[dict]:
+    def get_path_between(self, node_a: str, node_b: str) -> list[dict]:
         """Finds the trajectory (path) between two ontology terms if there is an ancestor-descendant relationship.
 
         Args:
-            nodeA (str): The ID of the first term.
-            nodeB (str): The ID of the second term.
+            node_a (str): The ID of the first term.
+            node_b (str): The ID of the second term.
 
         Returns:
             list[dict]: The path as a list of dictionaries with 'id' and 'distance' keys, or an empty list if no path exists.
@@ -79,15 +79,15 @@ def get_path_between(self, nodeA: str, nodeB: str) -> list[dict]:
             Exception: If an unexpected error occurs during path calculation.
         """
         if self.__relations.is_ancestor(
-            ancestor_node=nodeA, descendant_node=nodeB
+            ancestor_node=node_a, descendant_node=node_b
         ):
-            start, end, step = nodeA, nodeB, 1
+            start, end, step = node_a, node_b, 1
         elif self.__relations.is_ancestor(
-            ancestor_node=nodeB, descendant_node=nodeA
+            ancestor_node=node_b, descendant_node=node_a
         ):
-            start, end, step = nodeB, nodeA, 1
-        elif nodeA == nodeB:
-            return [{'id': nodeA, 'distance': 0}]
+            start, end, step = node_b, node_a, 1
+        elif node_a == node_b:
+            return [{'id': node_a, 'distance': 0}]
         else:
             return []
 

ontograph/queries/relations.py

@@ -69,12 +69,12 @@ def is_descendant(self, descendant_node: str, ancestor_node: str) -> bool:
             logger.error(f'Error checking descendant relationship: {e}')
             raise
 
-    def is_sibling(self, nodeA: str, nodeB: str) -> bool:
+    def is_sibling(self, node_a: str, node_b: str) -> bool:
         """Determine if two nodes are siblings (share at least one parent).
 
         Args:
-            nodeA (str): The ID of the first node.
-            nodeB (str): The ID of the second node.
+            node_a (str): The ID of the first node.
+            node_b (str): The ID of the second node.
 
         Returns:
             bool: True if the nodes are siblings (not the same node and share at least one parent), False otherwise.
@@ -83,11 +83,11 @@ def is_sibling(self, nodeA: str, nodeB: str) -> bool:
             Exception: If an error occurs during parent lookup.
         """
         try:
-            parentsA = set(self.__navigator.get_parents(term_id=nodeA))
-            parentsB = set(self.__navigator.get_parents(term_id=nodeB))
+            parentsA = set(self.__navigator.get_parents(term_id=node_a))
+            parentsB = set(self.__navigator.get_parents(term_id=node_b))
 
             # Siblings must not be the same node and must share at least one parent
-            return nodeA != nodeB and bool(parentsA & parentsB)
+            return node_a != node_b and bool(parentsA & parentsB)
         except Exception as e:
             logger.error(f'Error checking sibling relationship: {e}')
             raise

tests/test_queries/test_navigator.py

@@ -42,7 +42,6 @@ def navigator(dummy_ontology):
 
 # ---- Function: __get_term()
 def test_get_term_valid_id(navigator):
-    # Accessing the private method via name mangling
     term = navigator.get_term(term_id='G')
     assert term.id == 'G'