Add functions for finding ancestors and calculating hierarchical precision and recall

ham.py

@@ -1,4 +1,7 @@
-def find_ancestors(tree, code):
+from typing import List, Set, Dict, Tuple
+
+
+def find_ancestors1(tree, code):
     """
     Recursively finds ancestors of a given class (e.g., an ISCO-08 code) in a hierarchical JSON structure.
 
@@ -19,6 +22,50 @@ def find_ancestors(tree, code):
     return ancestors
 
 
+def find_ancestors(node, hierarchy):
+    ancestors = set()
+    nodes_to_visit = [node]
+    while nodes_to_visit:
+        current_node = nodes_to_visit.pop()
+        if current_node in hierarchy:
+            parents = hierarchy[current_node]
+            ancestors.update(parents)
+            nodes_to_visit.extend(parents)
+    return ancestors
+
+
+def extend_with_ancestors(classes, hierarchy):
+    extended_classes = set(classes)
+    for cls in classes:
+        ancestors = find_ancestors(cls, hierarchy)
+        extended_classes.update(ancestors)
+    return extended_classes
+
+
+def calculate_hierarchical_precision_recall(
+    real_codes: List[str], predicted_codes: List[str], hierarchy: Dict[str, Set[str]]
+) -> Tuple[float, float]:
+    # Extend the sets of real and predicted codes with their ancestors
+    extended_real = set()
+    for code in real_codes:
+        extended_real.add(code)
+        extended_real.update(hierarchy.get(code, set()))
+
+    extended_predicted = set()
+    for code in predicted_codes:
+        extended_predicted.add(code)
+        extended_predicted.update(hierarchy.get(code, set()))
+
+    # Calculate the intersection
+    correct_predictions = extended_real.intersection(extended_predicted)
+
+    # Calculate hierarchical precision and recall
+    hP = len(correct_predictions) / len(extended_predicted) if extended_predicted else 0
+    hR = len(correct_predictions) / len(extended_real) if extended_real else 0
+
+    return hP, hR
+
+
 def calculate_hierarchical_measures(true_labels, predicted_labels, tree):
     """
     Calculates hierarchical precision, recall, and F-measure in a hierarchical structure.