simple-icd-10-cm 1.2.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

simple_icd_10_cm/simple_icd_10_cm.py

@@ -1,3 +1,8 @@
+# simple_icd_10_cm is released under the MIT License
+# Copyright (c) 2021-2025 Stefano Travasci
+# Read the full LICENCES at https://github.com/StefanoTrv/simple_icd_10_cm/blob/master/LICENSE
+
+from typing import Optional
 import xml.etree.ElementTree as ET
 
 try:
@@ -8,18 +13,21 @@ except ImportError:
 
 from . import data  # relative-import the "package" containing the data
 
-chapter_list: list["_CodeTree"] = []
+_chapter_list: list["_CodeTree"] = []
+
+_code_to_node: dict[str, "_CodeTree"] = {}
 
-code_to_node: dict[str, "_CodeTree"] = {}
+_all_codes_list: list[str] = []
 
-all_codes_list: list[str] = []
+_all_codes_list_no_dots: list[str] = []
 
-all_codes_list_no_dots: list[str] = []
+_code_to_index_dictionary: dict[str, int] = {}
 
-code_to_index_dictionary: dict[str, int] = {}
+_all_codes_package_file_name:str = 'code-list-April-2025.txt'
+_classification_data_package_file_name:str = 'icd10cm-tabular-April-2025.xml'
 
 class _CodeTree:
-    def __init__(self, tree, parent = None, seven_chr_def_ancestor = None, seven_chr_note_ancestor = None, use_additional_code_ancestor = None, code_first_ancestor = None):
+    def __init__(self, tree, parent = None, seven_chr_def_ancestor = None, seven_chr_note_ancestor = None, use_additional_code_ancestor = None, code_first_ancestor = None, code_also_ancestor = None, notes_ancestor = None):
         #initialize all the values
         self.name = ""
         self.description = ""
@@ -38,17 +46,24 @@ class _CodeTree:
         self.use_additional_code_ancestor = use_additional_code_ancestor
         self.code_first = ""
         self.code_first_ancestor = code_first_ancestor
+        self.code_also = ""
+        self.code_also_ancestor = code_also_ancestor
+        self.notes = ""
+        self.notes_ancestor = notes_ancestor
         
         #reads the data from the subtrees
         new_seven_chr_def_ancestor=seven_chr_def_ancestor
         new_seven_chr_note_ancestor=seven_chr_note_ancestor
         new_use_additional_code_ancestor=use_additional_code_ancestor
         new_code_first_ancestor=code_first_ancestor
+        new_code_also_ancestor=code_also_ancestor
+        new_notes_ancestor=notes_ancestor
         if "id" in tree.attrib: #the name of sections is an attribute instead of text inside an XML element
             self.name=tree.attrib["id"]
         for subtree in tree:
             if subtree.tag=="section" or subtree.tag=="diag": #creates a new child for this node
-                self.children.append(_CodeTree(subtree,parent=self,seven_chr_def_ancestor=new_seven_chr_def_ancestor,seven_chr_note_ancestor=new_seven_chr_note_ancestor,use_additional_code_ancestor=new_use_additional_code_ancestor,code_first_ancestor=new_code_first_ancestor))
+                # This is only correct because the XML elements for the children codes always follow the XML elements for this code's data
+                self.children.append(_CodeTree(subtree,parent=self,seven_chr_def_ancestor=new_seven_chr_def_ancestor,seven_chr_note_ancestor=new_seven_chr_note_ancestor,use_additional_code_ancestor=new_use_additional_code_ancestor,code_first_ancestor=new_code_first_ancestor,code_also_ancestor=new_code_also_ancestor,notes_ancestor=new_notes_ancestor))
             elif subtree.tag=="name":
                 self.name=subtree.text
             elif subtree.tag=="desc":
@@ -78,6 +93,7 @@ class _CodeTree:
                 self.seven_chr_note=subtree[0].text
                 new_seven_chr_note_ancestor=self
             elif subtree.tag=="useAdditionalCode":
+            # NOTE: multiple useAdditionalCode elements may be present, so self.use_additional_code should always be appended and never overwritten
                 for i in range(0,len(subtree)):#in case there are multiple lines
                     self.use_additional_code=self.use_additional_code+"\n"+subtree[i].text
                 new_use_additional_code_ancestor=self
@@ -85,12 +101,26 @@ class _CodeTree:
                 for i in range(0,len(subtree)):#in case there are multiple lines
                     self.code_first=self.code_first+"\n"+subtree[i].text
                 new_code_first_ancestor=self
+            elif subtree.tag=="codeAlso":
+            # see NOTE for useAdditionalCode
+                for i in range(0,len(subtree)):#in case there are multiple lines
+                    self.code_also=self.code_also+"\n"+subtree[i].text
+                new_code_also_ancestor=self
+            elif subtree.tag=="notes":
+            # see NOTE for useAdditionalCode
+                for i in range(0,len(subtree)):#in case there are multiple lines
+                    self.notes=self.notes+"\n"+subtree[i].text
+                new_notes_ancestor=self
         
-        #cleans the use_additional_code and code_first fields from extra new lines
+        #cleans the use_additional_code, code_first, code_also and notes fields from extra new lines
         if self.use_additional_code!="" and self.use_additional_code[0]=="\n":
             self.use_additional_code=self.use_additional_code[1:]
         if self.code_first!="" and self.code_first[0]=="\n":
             self.code_first=self.code_first[1:]
+        if self.code_also!="" and self.code_also[0]=="\n":
+            self.code_also=self.code_also[1:]
+        if self.notes!="" and self.notes[0]=="\n":
+            self.notes=self.notes[1:]
         
         #sets the type
         if tree.tag=="chapter":
@@ -105,15 +135,15 @@ class _CodeTree:
             self.type="subcategory"
         
         #adds the new node to the dictionary
-        if self.name not in code_to_node:#in case a section has the same name of a code (ex B99)
-            code_to_node[self.name]=self
+        if self.name not in _code_to_node:#in case a section has the same name of a code (ex B99)
+            _code_to_node[self.name]=self
         
         #if this code is a leaf, it adds to its children the codes created by adding the seventh character
         if len(self.children)==0 and (self.seven_chr_def!={} or self.seven_chr_def_ancestor!=None) and self.type!="extended subcategory":
             if self.seven_chr_def!={}:
                 dictionary = self.seven_chr_def
             else:
-                dictionary = self.seven_chr_def_ancestor.seven_chr_def
+                dictionary = self.seven_chr_def_ancestor.seven_chr_def # type: ignore[reportOptionalMemberAccess]
             extended_name=self.name
             if len(extended_name)==3:
                 extended_name=extended_name+"."
@@ -122,130 +152,156 @@ class _CodeTree:
             for extension in dictionary:
                 if((extended_name[:3]+extended_name[4:]+extension) in all_confirmed_codes):#checks if there's a special rule that excludes this new code
                     new_XML = "<diag_ext><name>"+extended_name+extension+"</name><desc>"+self.description+", "+dictionary[extension]+"</desc></diag_ext>"
-                    self.children.append(_CodeTree(ET.fromstring(new_XML),parent=self,seven_chr_def_ancestor=new_seven_chr_def_ancestor,seven_chr_note_ancestor=new_seven_chr_note_ancestor,use_additional_code_ancestor=new_use_additional_code_ancestor,code_first_ancestor=new_code_first_ancestor))
+                    self.children.append(_CodeTree(ET.fromstring(new_XML),parent=self,seven_chr_def_ancestor=new_seven_chr_def_ancestor,seven_chr_note_ancestor=new_seven_chr_note_ancestor,use_additional_code_ancestor=new_use_additional_code_ancestor,code_first_ancestor=new_code_first_ancestor,code_also_ancestor=new_code_also_ancestor,notes_ancestor=new_notes_ancestor))
 
-def _load_codes():
+def _load_codes(all_codes_file_path:Optional[str] = None, classification_data_file_path:Optional[str] = None) -> None: # either both or none of the strings must be None
     #loads the list of all codes, to remove later from the tree the ones that do not exist for very specific rules not easily extracted from the XML file
-    f = pkg_resources.read_text(data, 'icd10cm-order-Jan-2021.txt')
+    if all_codes_file_path is None:
+        assert classification_data_file_path is None
+        text = pkg_resources.read_text(data, _all_codes_package_file_name)
+    else:
+        assert classification_data_file_path is not None
+        with open(all_codes_file_path, encoding="utf-8") as f:
+            text = f.read()
     global all_confirmed_codes
     all_confirmed_codes = set()
-    lines=f.split("\n")
+    lines=text.split("\n")
     for line in lines:
-        all_confirmed_codes.add(line[6:13].strip())
+        all_confirmed_codes.add(line.split(" ")[0].replace(".",""))
     
     #creates the tree
-    root = ET.fromstring(pkg_resources.read_text(data, 'icd10cm_tabular_2021.xml'))
+    if classification_data_file_path is None:
+        root = ET.fromstring(pkg_resources.read_text(data, _classification_data_package_file_name))
+    else:
+        with open(classification_data_file_path, encoding="utf-8") as f:
+            text = f.read()
+            root = ET.fromstring(text)
     root.remove(root[0])
     root.remove(root[0])
+    if len(_chapter_list)>0: #empties data structures only if needed and if the files have been read with no error
+        _chapter_list.clear()
+        _code_to_node.clear()
+        _all_codes_list.clear()
+        _all_codes_list_no_dots.clear()
+        _code_to_index_dictionary.clear()
     for child in root:
-        chapter_list.append(_CodeTree(child))
+        _chapter_list.append(_CodeTree(child))
     
     del all_confirmed_codes #deletes this list since it won't be needed anymore
 
 
 _load_codes()
 
-def _add_dot_to_code(code):
+def change_version(all_codes_file_path:Optional[str] = None, classification_data_file_path:Optional[str] = None) -> None:
+    if (all_codes_file_path is None and classification_data_file_path is None) or (all_codes_file_path is not None and classification_data_file_path is not None):
+        _load_codes(all_codes_file_path=all_codes_file_path,classification_data_file_path=classification_data_file_path)
+    else:
+        ac_error = "None" if all_codes_file_path is None else "\"" + all_codes_file_path + "\""
+        cd_error = "None" if classification_data_file_path is None else "\"" + classification_data_file_path + "\""
+        raise ValueError("Either both paths must be provided, or none.\nProvided values were:\n\t-all_codes_file_path is "+ac_error+"\n\t-classification_data_file_path is "+cd_error+"\n")
+
+def _add_dot_to_code(code:str) -> str:
     if len(code)<4 or code[3]==".":
         return code
-    elif code[:3]+"."+code[3:] in code_to_node:
+    elif code[:3]+"."+code[3:] in _code_to_node:
         return code[:3]+"."+code[3:]
     else:
         return code
 
-def is_valid_item(code: str) -> bool:
-    return code in code_to_node or len(code)>=4 and code[:3]+"."+code[3:] in code_to_node
+def is_valid_item(code:str) -> bool:
+    return code in _code_to_node or len(code)>=4 and code[:3]+"."+code[3:] in _code_to_node
 
-def is_chapter(code: str) -> bool:
+def is_chapter(code:str) -> bool:
     code = _add_dot_to_code(code)
-    if code in code_to_node:
-        return code_to_node[code].type=="chapter"
+    if code in _code_to_node:
+        return _code_to_node[code].type=="chapter"
     else:
         return False
 
-def is_block(code: str) -> bool:
+def is_block(code:str) -> bool:
     code = _add_dot_to_code(code)
-    if code in code_to_node:
-        return code_to_node[code].type=="section" or code_to_node[code].parent!=None and code_to_node[code].parent.name==code #second half of the or is for sections containing a single category
+    if code in _code_to_node:
+        #second half of the or is for sections containing a single category
+        return _code_to_node[code].type=="section" or _code_to_node[code].parent!=None and _code_to_node[code].parent.name==code # type: ignore[reportOptionalMemberAccess]
     else:
         return False
 
-def is_category(code: str) -> bool:
+def is_category(code:str) -> bool:
     code = _add_dot_to_code(code)
-    if code in code_to_node:
-        return code_to_node[code].type=="category"
+    if code in _code_to_node:
+        return _code_to_node[code].type=="category"
     else:
         return False
 
-def is_subcategory(code: str, include_extended_subcategories=True) -> bool:
+def is_subcategory(code:str, include_extended_subcategories:bool=True) -> bool:
     code = _add_dot_to_code(code)
-    if code in code_to_node:
-        return code_to_node[code].type=="subcategory" or code_to_node[code].type=="extended subcategory" and include_extended_subcategories
+    if code in _code_to_node:
+        return _code_to_node[code].type=="subcategory" or _code_to_node[code].type=="extended subcategory" and include_extended_subcategories
     else:
         return False
 
-def is_extended_subcategory(code: str) -> bool:
+def is_extended_subcategory(code:str) -> bool:
     code = _add_dot_to_code(code)
-    if code in code_to_node:
-        return code_to_node[code].type=="extended subcategory"
+    if code in _code_to_node:
+        return _code_to_node[code].type=="extended subcategory"
     else:
         return False
     
-def is_category_or_subcategory(code: str) -> bool:
+def is_category_or_subcategory(code:str) -> bool:
     return is_subcategory(code) or is_category(code)
 
-def is_chapter_or_block(code: str) -> bool:
+def is_chapter_or_block(code:str) -> bool:
     return is_block(code) or is_chapter(code)
 
-def get_description(code: str, prioritize_blocks=False) -> str:
+def get_description(code:str, prioritize_blocks:bool=False) -> str:
     if not is_valid_item(code):
         raise ValueError("The code \""+code+"\" does not exist.")
-    node = code_to_node[_add_dot_to_code(code)]
+    node = _code_to_node[_add_dot_to_code(code)]
     if prioritize_blocks and node.parent!=None and node.parent.name==node.name:
         return node.parent.description
     else:
         return node.description
 
-def get_excludes1(code: str, prioritize_blocks=False) -> list[str]:
+def get_excludes1(code:str, prioritize_blocks:bool=False) -> list[str]:
     if not is_valid_item(code):
         raise ValueError("The code \""+code+"\" does not exist.")
-    node = code_to_node[_add_dot_to_code(code)]
+    node = _code_to_node[_add_dot_to_code(code)]
     if prioritize_blocks and node.parent!=None and node.parent.name==node.name:
         return node.parent.excludes1.copy()
     else:
         return node.excludes1.copy()
 
-def get_excludes2(code: str, prioritize_blocks=False) -> list[str]:
+def get_excludes2(code:str, prioritize_blocks:bool=False) -> list[str]:
     if not is_valid_item(code):
         raise ValueError("The code \""+code+"\" does not exist.")
-    node = code_to_node[_add_dot_to_code(code)]
+    node = _code_to_node[_add_dot_to_code(code)]
     if prioritize_blocks and node.parent!=None and node.parent.name==node.name:
         return node.parent.excludes2.copy()
     else:
         return node.excludes2.copy()
 
-def get_includes(code: str, prioritize_blocks=False) -> list[str]:
+def get_includes(code:str, prioritize_blocks:bool=False) -> list[str]:
     if not is_valid_item(code):
         raise ValueError("The code \""+code+"\" does not exist.")
-    node = code_to_node[_add_dot_to_code(code)]
+    node = _code_to_node[_add_dot_to_code(code)]
     if prioritize_blocks and node.parent!=None and node.parent.name==node.name:
         return node.parent.includes.copy()
     else:
         return node.includes.copy()
 
-def get_inclusion_term(code: str, prioritize_blocks=False) -> list[str]:
+def get_inclusion_term(code:str, prioritize_blocks:bool=False) -> list[str]:
     if not is_valid_item(code):
         raise ValueError("The code \""+code+"\" does not exist.")
-    node = code_to_node[_add_dot_to_code(code)]
+    node = _code_to_node[_add_dot_to_code(code)]
     if prioritize_blocks and node.parent!=None and node.parent.name==node.name:
         return node.parent.inclusion_term.copy()
     else:
         return node.inclusion_term.copy()
 
-def get_seven_chr_def(code: str, search_in_ancestors=False, prioritize_blocks=False) -> dict[str, str]:
+def get_seven_chr_def(code:str, search_in_ancestors:bool=False, prioritize_blocks:bool=False) -> dict[str,str]:
     if not is_valid_item(code):
         raise ValueError("The code \""+code+"\" does not exist.")
-    node = code_to_node[_add_dot_to_code(code)]
+    node = _code_to_node[_add_dot_to_code(code)]
     if prioritize_blocks and node.parent!=None and node.parent.name==node.name:
         node = node.parent
     res = node.seven_chr_def.copy()
@@ -254,10 +310,10 @@ def get_seven_chr_def(code: str, search_in_ancestors=False, prioritize_blocks=Fa
     else:
         return res
 
-def get_seven_chr_note(code: str, search_in_ancestors=False, prioritize_blocks=False) -> str:
+def get_seven_chr_note(code:str, search_in_ancestors:bool=False, prioritize_blocks:bool=False) -> str:
     if not is_valid_item(code):
         raise ValueError("The code \""+code+"\" does not exist.")
-    node = code_to_node[_add_dot_to_code(code)]
+    node = _code_to_node[_add_dot_to_code(code)]
     if prioritize_blocks and node.parent!=None and node.parent.name==node.name:
         node = node.parent
     res = node.seven_chr_note
@@ -266,10 +322,10 @@ def get_seven_chr_note(code: str, search_in_ancestors=False, prioritize_blocks=F
     else:
         return res
 
-def get_use_additional_code(code: str, search_in_ancestors=False, prioritize_blocks=False) -> str:
+def get_use_additional_code(code:str, search_in_ancestors:bool=False, prioritize_blocks:bool=False) -> str:
     if not is_valid_item(code):
         raise ValueError("The code \""+code+"\" does not exist.")
-    node = code_to_node[_add_dot_to_code(code)]
+    node = _code_to_node[_add_dot_to_code(code)]
     if prioritize_blocks and node.parent!=None and node.parent.name==node.name:
         node = node.parent
     res = node.use_additional_code
@@ -278,10 +334,10 @@ def get_use_additional_code(code: str, search_in_ancestors=False, prioritize_blo
     else:
         return res
 
-def get_code_first(code: str, search_in_ancestors=False, prioritize_blocks=False) -> str:
+def get_code_first(code:str, search_in_ancestors:bool=False, prioritize_blocks:bool=False) -> str:
     if not is_valid_item(code):
         raise ValueError("The code \""+code+"\" does not exist.")
-    node = code_to_node[_add_dot_to_code(code)]
+    node = _code_to_node[_add_dot_to_code(code)]
     if prioritize_blocks and node.parent!=None and node.parent.name==node.name:
         node = node.parent
     res = node.code_first
@@ -290,10 +346,34 @@ def get_code_first(code: str, search_in_ancestors=False, prioritize_blocks=False
     else:
         return res
 
-def get_parent(code: str, prioritize_blocks=False) -> str:
+def get_code_also(code:str, search_in_ancestors:bool=False, prioritize_blocks:bool=False) -> str:
+    if not is_valid_item(code):
+        raise ValueError("The code \""+code+"\" does not exist.")
+    node = _code_to_node[_add_dot_to_code(code)]
+    if prioritize_blocks and node.parent!=None and node.parent.name==node.name:
+        node = node.parent
+    res = node.code_also
+    if search_in_ancestors and res=="" and node.code_also_ancestor!=None:
+        return node.code_also_ancestor.code_also
+    else:
+        return res
+
+def get_notes(code:str, search_in_ancestors:bool=False, prioritize_blocks:bool=False) -> str:
+    if not is_valid_item(code):
+        raise ValueError("The code \""+code+"\" does not exist.")
+    node = _code_to_node[_add_dot_to_code(code)]
+    if prioritize_blocks and node.parent!=None and node.parent.name==node.name:
+        node = node.parent
+    res = node.notes
+    if search_in_ancestors and res=="" and node.notes_ancestor!=None:
+        return node.notes_ancestor.notes
+    else:
+        return res
+
+def get_parent(code:str, prioritize_blocks:bool=False) -> str:
     if not is_valid_item(code):
         raise ValueError("The code \""+code+"\" does not exist.")
-    node = code_to_node[_add_dot_to_code(code)]
+    node = _code_to_node[_add_dot_to_code(code)]
     if prioritize_blocks and node.parent!=None and node.parent.name==node.name:
         node = node.parent
     if node.parent!=None:
@@ -301,10 +381,10 @@ def get_parent(code: str, prioritize_blocks=False) -> str:
     else:
         return ""
 
-def get_children(code: str, prioritize_blocks=False) -> list[str]:
+def get_children(code:str, prioritize_blocks:bool=False) -> list[str]:
     if not is_valid_item(code):
         raise ValueError("The code \""+code+"\" does not exist.")
-    node = code_to_node[_add_dot_to_code(code)]
+    node = _code_to_node[_add_dot_to_code(code)]
     if prioritize_blocks and node.parent!=None and node.parent.name==node.name:
         node = node.parent
     res = []
@@ -312,18 +392,18 @@ def get_children(code: str, prioritize_blocks=False) -> list[str]:
         res.append(child.name)
     return res
 
-def is_leaf(code: str, prioritize_blocks=False) -> bool:
+def is_leaf(code:str, prioritize_blocks:bool=False) -> bool:
     if not is_valid_item(code):
         raise ValueError("The code \""+code+"\" does not exist.")
-    node = code_to_node[_add_dot_to_code(code)]
+    node = _code_to_node[_add_dot_to_code(code)]
     if prioritize_blocks and node.parent!=None and node.parent.name==node.name:
         node = node.parent
     return len(node.children)==0
 
-def get_full_data(code: str, search_in_ancestors=False, prioritize_blocks=False) -> str:
+def get_full_data(code:str, search_in_ancestors:bool=False, prioritize_blocks:bool=False) -> str:
     if not is_valid_item(code):
         raise ValueError("The code \""+code+"\" does not exist.")
-    node = code_to_node[_add_dot_to_code(code)]
+    node = _code_to_node[_add_dot_to_code(code)]
     if prioritize_blocks and node.parent!=None and node.parent.name==node.name:
         node = node.parent
     str = "Name:\n"+node.name+"\nDescription:\n"+node.description
@@ -359,6 +439,12 @@ def get_full_data(code: str, search_in_ancestors=False, prioritize_blocks=False)
     code_first=get_code_first(code,search_in_ancestors=search_in_ancestors,prioritize_blocks=prioritize_blocks)
     if code_first!="":
         str = str + "\ncode first:\n" + code_first
+    code_also=get_code_also(code,search_in_ancestors=search_in_ancestors,prioritize_blocks=prioritize_blocks)
+    if code_also!="":
+        str = str + "\ncode also:\n" + code_also
+    notes=get_notes(code,search_in_ancestors=search_in_ancestors,prioritize_blocks=prioritize_blocks)
+    if notes!="":
+        str = str + "\nnotes:\n" + notes
     if node.children==[]:
         str = str + "\nChildren:\nNone--"
     else:
@@ -367,10 +453,10 @@ def get_full_data(code: str, search_in_ancestors=False, prioritize_blocks=False)
             str = str + child.name + ", "
     return str[:-2]
 
-def get_ancestors(code: str,prioritize_blocks=False) -> list[str]:
+def get_ancestors(code:str,prioritize_blocks:bool=False) -> list[str]:
     if not is_valid_item(code):
         raise ValueError("The code \""+code+"\" does not exist.")
-    node = code_to_node[_add_dot_to_code(code)]
+    node = _code_to_node[_add_dot_to_code(code)]
     if prioritize_blocks and node.parent!=None and node.parent.name==node.name:
         node = node.parent
     result = []
@@ -379,33 +465,33 @@ def get_ancestors(code: str,prioritize_blocks=False) -> list[str]:
         node=node.parent
     return result
 
-def get_descendants(code: str,prioritize_blocks=False) -> list[str]:
+def get_descendants(code:str,prioritize_blocks:bool=False) -> list[str]:
     if not is_valid_item(code):
         raise ValueError("The code \""+code+"\" does not exist.")
-    node = code_to_node[_add_dot_to_code(code)]
+    node = _code_to_node[_add_dot_to_code(code)]
     if prioritize_blocks and node.parent!=None and node.parent.name==node.name:
         node = node.parent
     result = []
     _add_children_to_list(node, result)
     return result
 
-def _add_children_to_list(node, list):
+def _add_children_to_list(node:_CodeTree, list:list[str]) -> None:
     for child in node.children:
         list.append(child.name)
         _add_children_to_list(child,list)
 
-def is_ancestor(a:str,b:str,prioritize_blocks_a=False,prioritize_blocks_b=False) -> bool:
+def is_ancestor(a:str,b:str,prioritize_blocks_a:bool=False,prioritize_blocks_b:bool=False) -> bool:
     if not is_valid_item(a):
         raise ValueError("The code \""+a+"\" does not exist.")
-    node = code_to_node[_add_dot_to_code(a)]
+    node = _code_to_node[_add_dot_to_code(a)]
     if prioritize_blocks_a and node.parent!=None and node.parent.name==node.name:
         node = node.parent
     return a in get_ancestors(b, prioritize_blocks=prioritize_blocks_b) and (a!=b or prioritize_blocks_a)
 
-def is_descendant(a:str,b:str,prioritize_blocks_a=False,prioritize_blocks_b=False) -> bool:
+def is_descendant(a:str,b:str,prioritize_blocks_a:bool=False,prioritize_blocks_b:bool=False) -> bool:
     return is_ancestor(b,a,prioritize_blocks_a=prioritize_blocks_b,prioritize_blocks_b=prioritize_blocks_a)
 
-def get_nearest_common_ancestor(a:str,b:str,prioritize_blocks_a=False,prioritize_blocks_b=False) -> str:
+def get_nearest_common_ancestor(a:str,b:str,prioritize_blocks_a:bool=False,prioritize_blocks_b:bool=False) -> str:
     anc_a = [_add_dot_to_code(a)] + get_ancestors(a, prioritize_blocks=prioritize_blocks_a)
     anc_b = [_add_dot_to_code(b)] + get_ancestors(b, prioritize_blocks=prioritize_blocks_b)
     if len(anc_b) > len(anc_a):
@@ -417,50 +503,50 @@ def get_nearest_common_ancestor(a:str,b:str,prioritize_blocks_a=False,prioritize
             return anc
     return ""
 
-def get_all_codes(with_dots=True) -> list[str]:
-    if all_codes_list==[]:
-        for chapter in chapter_list:
-            _add_tree_to_list(chapter)
+def get_all_codes(with_dots:bool=True) -> list[str]:
+    if _all_codes_list==[]:
+        _fill_all_codes_list()
     if with_dots:
-        return all_codes_list.copy()
+        return _all_codes_list.copy()
     else:
-        return all_codes_list_no_dots.copy()
+        return _all_codes_list_no_dots.copy()
+
+def _fill_all_codes_list() -> None:
+    for chapter in _chapter_list:
+        _add_tree_to_list(chapter)
 
-def _add_tree_to_list(tree):
-    all_codes_list.append(tree.name)
+def _add_tree_to_list(tree:_CodeTree) -> None:
+    _all_codes_list.append(tree.name)
     if(len(tree.name)>4 and tree.name[3]=="."):
-        all_codes_list_no_dots.append(tree.name[:3]+tree.name[4:])
+        _all_codes_list_no_dots.append(tree.name[:3]+tree.name[4:])
     else:
-        all_codes_list_no_dots.append(tree.name)
+        _all_codes_list_no_dots.append(tree.name)
     for child in tree.children:
         _add_tree_to_list(child)
 
-def get_index(code: str) -> int:
+def get_index(code:str) -> int: # type: ignore[reportReturnType]
     if not is_valid_item(code):
         raise ValueError("The code \""+code+"\" does not exist.")
     code = _add_dot_to_code(code)
-    if all_codes_list==[]:
-        for chapter in chapter_list:
-            _add_tree_to_list(chapter)
-    if code in code_to_index_dictionary:
-        return code_to_index_dictionary[code]
+    if _all_codes_list==[]:
+        _fill_all_codes_list()
+    if code in _code_to_index_dictionary:
+        return _code_to_index_dictionary[code]
     else:
         i=0
-        for c in all_codes_list:
+        for c in _all_codes_list:
             if c==code:
-                code_to_index_dictionary[code]=i
+                _code_to_index_dictionary[code]=i
                 return i
             else:
                 i=i+1
 
-def remove_dot(code: str) -> str:
-    if all_codes_list==[]:
-        for chapter in chapter_list:
-            _add_tree_to_list(chapter)
-    return all_codes_list_no_dots[get_index(code)]
-
-def add_dot(code: str) -> str:
-    if all_codes_list==[]:
-        for chapter in chapter_list:
-            _add_tree_to_list(chapter)
-    return all_codes_list[get_index(code)]
+def remove_dot(code:str) -> str:
+    if _all_codes_list==[]:
+        _fill_all_codes_list()
+    return _all_codes_list_no_dots[get_index(code)]
+
+def add_dot(code:str) -> str:
+    if _all_codes_list==[]:
+        _fill_all_codes_list()
+    return _all_codes_list[get_index(code)]