Update libs/eurovoc/EurovocTh.py

libs/eurovoc/EurovocTh.py

@@ -192,7 +192,7 @@ class EurovocTh:
             return self.get_dom_label(id)
         elif hierarchy_level == "eurovoc_th":
             return self.get_th_label(id)
-        elif hierarchy_level == "eurovoc_classifiers":
+        elif hierarchy_level == "eurovoc_classifiers" or hierarchy_level == "eurovoc_classifiers_top_level":
             return self.get_label(id)
         else:
             UnknownParameterException(f'level {hierarchy_level} not implemented')
@@ -364,7 +364,7 @@ class EurovocTh:
     def get_narrower_ids(self, id:str):
         """ 
         :param id: a string of the searched id
-        :return the set of immediately broader terms for the given id possibly empty
+        :return the set of immediately narrower terms for the given id possibly empty
         """
         try:
             return self._relation_nt[id]
@@ -419,6 +419,25 @@ class EurovocTh:
 
         except KeyError:
             return {}
+    
+    def get_all_narrower_ids(self, id:str):
+        """ 
+        :param id: a string of the searched id
+        :retrun the set of all the ids that are narrower (i.e. lower in the hierarchy) for the given id
+        """
+        try:
+            broader_ids = self.get_narrower_ids(id)
+
+            return_ids = set().union(broader_ids)
+
+            for b_id in broader_ids:
+                
+                return_ids = return_ids.union(self.get_all_narrower_ids(b_id))
+            
+            return return_ids
+
+        except KeyError:
+            return {}
         
 
     def convert_ids_from_to(self, ids, input_level, target_level):
@@ -458,3 +477,56 @@ class UnknownParameterException(Exception):
 #it may also be possible to get terms that are related to another
 #but I'm not sure whether it may be usefull or not
         
+
+
+class EurovocThExt(EurovocTh):
+    """ EurovocTh extended class to account also for an additional sink class with 'other' meaning 
+        this sink class will be the same for all classification levels (same id and label), plus it will be
+        mapped in itself when moving between differente levels, additionally it will be considered a leaf and a top
+        term in the classification
+    """
+    def __init__(self, sink_class_id, sink_class_label,  language='it', sink_class_desc=None):
+
+        super().__init__(language)
+
+        self._sink_class_id = sink_class_id
+        self._sink_class_label = sink_class_label
+        self._sink_class_desk = sink_class_desc
+
+        # add the new id and label pairs
+        self.__update_language_data()
+
+        # add relations for other class with itself (we use the same sink class for all the levels)
+        self._id_th_relation[sink_class_id].add(sink_class_id)
+        self._dom_th_relation[sink_class_id].add(sink_class_id)
+        self._th_id_relation[sink_class_id].add(sink_class_id)
+
+
+    def __update_language_data(self):
+
+        # add the new id and label pairs
+        self._labels_dic[self._sink_class_id] = self._sink_class_label
+        self._th_labels_dic[self._sink_class_id] = self._sink_class_label
+        self._dom_labels_dic[self._sink_class_id] = self._sink_class_label
+
+        self._label_def[self._sink_class_id] = 'attitional class with meaning other' if not self._sink_class_desk else self._sink_class_desk
+
+
+    def __load_language_data(self, language:str):
+        super().__load_language_data(language)
+        self.__update_language_data()
+
+    
+    def get_leaves(self):
+        super().__init__(language)
+        self._leaves.add(self._sink_class_id)
+        return self._leaves
+
+
+    def get_th_dom(self, id:str):
+        if id == self._sink_class_id:
+            return self._sink_class_id
+        else:
+            return super().get_th_dom(id)
+
+