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

simple_icd_10_cm/simple_icd_10_cm.py

@@ -2,6 +2,9 @@
 # Copyright (c) 2021-2025 Stefano Travasci
 # Read the full LICENCES at https://github.com/StefanoTrv/simple_icd_10_cm/blob/master/LICENSE
 
+from __future__ import annotations
+
+import warnings, inspect
 from typing import Optional
 import xml.etree.ElementTree as ET
 
@@ -13,6 +16,47 @@ except ImportError:
 
 from . import data  # relative-import the "package" containing the data
 
+# --- Class and function for warning management ---
+class _SimpleICD10CMWarning(UserWarning):
+     pass
+
+def _user_stacklevel() -> int:
+    for i, frameinfo in enumerate(inspect.stack()[1:], start=1):
+        module = inspect.getmodule(frameinfo.frame)
+        if module is None or not module.__name__.startswith("simple_icd_10_cm"):
+            return i
+    return 1
+
+def _check_node_has_text(text : str, node_tag : str, main_node_tag : str | None, code_this : _CodeTree, code_parent : _CodeTree | None) -> bool:
+    if main_node_tag is not None:
+        msg_subject = f"XML <{node_tag}> node of parent XML node <{main_node_tag}>"
+        msg_end = f"Ignoring this <{node_tag}> node."
+    else:
+        msg_subject = f"XML <{node_tag}> node"
+        msg_end = "Ignoring this node."
+
+    if text is None:
+        if code_this.name != "":
+            error_msg = f"{msg_subject} with no text was found in data for code \"{code_this.name}\". {msg_end}"
+        elif code_parent is not None:
+            error_msg = f"{msg_subject} with no text was found in data for child of \"{code_parent.name}\" with unknown name. {msg_end}"
+        else:
+            error_msg = f"{msg_subject} with no text was found in data of parentless code of unknown name. {msg_end}"
+        warnings.warn(error_msg,category=_SimpleICD10CMWarning,stacklevel=_user_stacklevel())
+        return False
+    return True
+
+def _warning_extensionless_seven_chr_def_note(code_this : _CodeTree, code_parent : _CodeTree | None) -> None:
+    if code_this.name != "":
+        msg_where = f"code {code_this.name}"
+    elif code_parent is not None:
+        msg_where = f"child code of \"{code_parent.name}\" with unknown name"
+    else:
+        msg_where = f"parentless code of unknown name"
+    error_msg = f"In data of {msg_where}, found <note> XML element in a <sevenChrDef> XML element with not preceded by an <extension> element. Ignoring this <note> element."
+    warnings.warn(error_msg,category=_SimpleICD10CMWarning,stacklevel=_user_stacklevel())
+# --- --- ---
+
 _chapter_list: list["_CodeTree"] = []
 
 _code_to_node: dict[str, "_CodeTree"] = {}
@@ -23,11 +67,15 @@ _all_codes_list_no_dots: list[str] = []
 
 _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'
+_all_codes_package_file_name:str = 'code-list-April-2026.txt'
+_classification_data_package_file_name:str = 'icd10c-tabular-April-1-2026.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, code_also_ancestor = None, notes_ancestor = None):
+    def __append_string_to_field_list(self, xml_node, parent_tag : str, list_to_be_appended : list[str]) -> None:
+        if _check_node_has_text(xml_node.text, xml_node.tag, parent_tag, self, self.parent):
+            list_to_be_appended.append(xml_node.text)
+
+    def __init__(self, tree, parent : _CodeTree | None = 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 = ""
@@ -58,6 +106,10 @@ class _CodeTree:
         new_code_first_ancestor=code_first_ancestor
         new_code_also_ancestor=code_also_ancestor
         new_notes_ancestor=notes_ancestor
+        use_additional_code_list=[]
+        code_first_list=[]
+        code_also_list=[]
+        notes_list=[]
         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:
@@ -65,62 +117,71 @@ class _CodeTree:
                 # 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
+                if subtree.text is not None:
+                    self.name=subtree.text
+                else:
+                    if self.parent is not None:
+                        err_msg = f"Found <name> XML element containing no text in child of code {self.parent.name}."
+                    else:
+                        err_msg = "Found <name> XML element containing no text in parentless code."
+                    raise ValueError(err_msg)
             elif subtree.tag=="desc":
-                self.description=subtree.text
+                if _check_node_has_text(subtree.text, subtree.tag, None, self, self.parent):
+                    self.description=subtree.text
             elif subtree.tag=="excludes1":
                 for note in subtree:
-                    self.excludes1.append(note.text)
+                    self.__append_string_to_field_list(note,subtree.tag,self.excludes1)
             elif subtree.tag=="excludes2":
                 for note in subtree:
-                    self.excludes2.append(note.text)
+                    self.__append_string_to_field_list(note,subtree.tag,self.excludes2)
             elif subtree.tag=="includes":
                 for note in subtree:
-                    self.includes.append(note.text)
+                    self.__append_string_to_field_list(note,subtree.tag,self.includes)
             elif subtree.tag=="inclusionTerm":
                 for note in subtree:
-                    self.inclusion_term.append(note.text)
+                    self.__append_string_to_field_list(note,subtree.tag,self.inclusion_term)
             elif subtree.tag=="sevenChrDef":
                 last_char = None
                 for extension in subtree:
                     if extension.tag=="extension":
-                        self.seven_chr_def[extension.attrib["char"]]=extension.text
+                        self.seven_chr_def[extension.attrib["char"]]=extension.text if extension.text is not None else "" # in the absurd case of a extension with an attribute but no text
                         last_char = extension.attrib["char"]
                     elif extension.tag=="note":
-                        self.seven_chr_def[last_char]=self.seven_chr_def[last_char]+"/"+extension.text
+                        if last_char is None:
+                            _warning_extensionless_seven_chr_def_note(self, self.parent)
+                        else:
+                            if _check_node_has_text(extension.text,extension.tag,subtree.tag,self,self.parent):
+                                self.seven_chr_def[last_char]=self.seven_chr_def[last_char]+"/"+extension.text
                 new_seven_chr_def_ancestor=self
             elif subtree.tag=="sevenChrNote":
-                self.seven_chr_note=subtree[0].text
-                new_seven_chr_note_ancestor=self
+                if _check_node_has_text(subtree[0].text, subtree.tag, None, self, self.parent):
+                        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
+                    self.__append_string_to_field_list(subtree[i],subtree.tag,use_additional_code_list)
                 new_use_additional_code_ancestor=self
             elif subtree.tag=="codeFirst":
                 for i in range(0,len(subtree)):#in case there are multiple lines
-                    self.code_first=self.code_first+"\n"+subtree[i].text
+                    self.__append_string_to_field_list(subtree[i],subtree.tag,code_first_list)
                 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
+                    self.__append_string_to_field_list(subtree[i],subtree.tag,code_also_list)
                 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
+                    self.__append_string_to_field_list(subtree[i],subtree.tag,notes_list)
                 new_notes_ancestor=self
         
-        #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:]
+        #merges the use_additional_code, code_first, code_also and notes fields into multiline strings
+        self.use_additional_code = "\n".join(use_additional_code_list)
+        self.code_first = "\n".join(code_first_list)
+        self.code_also = "\n".join(code_also_list)
+        self.notes = "\n".join(notes_list)
         
         #sets the type
         if tree.tag=="chapter":
@@ -154,7 +215,13 @@ class _CodeTree:
                     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,code_also_ancestor=new_code_also_ancestor,notes_ancestor=new_notes_ancestor))
 
-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
+def _load_codes(all_codes_file_path:Optional[str] = None, classification_data_file_path:Optional[str] = None, suppress_warnings:Optional[bool] = None) -> None: # either both or none of the strings must be None
+    if suppress_warnings is not None:
+        if suppress_warnings:
+            warnings.filterwarnings("ignore", category=_SimpleICD10CMWarning)
+        else:
+            warnings.simplefilter("default", category=_SimpleICD10CMWarning)
+    
     #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
     if all_codes_file_path is None:
         assert classification_data_file_path is None
@@ -192,9 +259,9 @@ def _load_codes(all_codes_file_path:Optional[str] = None, classification_data_fi
 
 _load_codes()
 
-def change_version(all_codes_file_path:Optional[str] = None, classification_data_file_path:Optional[str] = None) -> None:
+def change_version(all_codes_file_path:Optional[str] = None, classification_data_file_path:Optional[str] = None, suppress_warnings:Optional[bool] = 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)
+        _load_codes(all_codes_file_path=all_codes_file_path,classification_data_file_path=classification_data_file_path,suppress_warnings=suppress_warnings)
     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 + "\""

{simple_icd_10_cm-1.4.0.dist-info → simple_icd_10_cm-1.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simple_icd_10_cm
-Version: 1.4.0
+Version: 1.5.0
 Summary: A simple python library for ICD-10-CM codes
 Home-page: https://github.com/StefanoTrv/simple_icd_10_CM
 Author: Stefano Travasci
@@ -68,10 +68,15 @@ A simple python library for ICD-10-CM codes
   * [get_index(code)](#get_indexcode)
   * [remove_dot(code)](#remove_dotcode)
   * [add_dot(code)](#add_dotcode)
-  * [change_version(all_codes_file_path=None, classification_data_file_path=None)](#change_versionall_codes_file_pathnone-classification_data_file_pathnone)
+  * [change_version(all_codes_file_path=None, classification_data_file_path=None, suppress_warnings=None)](#change_versionall_codes_file_pathnone-classification_data_file_pathnone-suppress_warningsnone)
 * [Conclusion](#conclusion)
 
 ## Release notes
+* **1.5.0**:
+  * The default ICD-10-CM release of the library is now the **April 2026 release**
+  * Certain kinds of defects in the data will now emit warnings instead of crashing the library
+  * Small refactoring for my own sanity
+  * Thanks to @Qwemep on Github for her valuable insights!
 * **1.4.0**: The data in the fields "codeAlso" and "notes" can now be retrieved using the get_code_also() and get_notes() functions
 * **1.3.0**:
   * Users can now use their preferred ICD-10-CM release by providing properly formatted files as inputs
@@ -92,7 +97,7 @@ The objective of this library is to provide a simple instrument for dealing with
 If you are looking for a library that deals with ICD-10 codes instead of ICD-10-CM codes, you can check the [simple_icd_10 library](https://github.com/StefanoTrv/simple_icd_10), which is based on the 2019 version of ICD-10. If you are interested in the ICD-11 MMS classification, you can check out instead the [simple_icd_11 library](https://github.com/StefanoTrv/simple_icd_11).  
 There is also a Java version of this library, [SimpleICD10CM-Java-edition](https://github.com/StefanoTrv/SimpleICD10CM-Java-edition).
 
-The data used in this library was taken from the [website of the CDC](https://www.cdc.gov/nchs/icd/icd-10-cm/files.html). This library currently uses the **April 2025 release of ICD-10-CM**. This package can be configured to use other releases of the ICD-10-CM classification, read the section [Using other ICD-10-CM releases](#using-other-icd-10-cm-releases) for more details.
+The data used in this library was taken from the [website of the CDC](https://www.cdc.gov/nchs/icd/icd-10-cm/files.html). This library currently uses the **April 2026 release of ICD-10-CM**. This package can be configured to use other releases of the ICD-10-CM classification, read the section [Using other ICD-10-CM releases](#using-other-icd-10-cm-releases) for more details.
 
 If you feel like supporting me, please check out the [Conclusion section](#conclusion).
 
@@ -128,14 +133,14 @@ cm.change_version(classification_data_file_path="icd10cm_tabular_2021.xml")
 
 The file specified in `all_codes_file_path` should contain all the unique codes of the desired release. However, it is sufficient that it contains all the seven-characters codes that must be generated programmatically, that is all the valid codes that are not explicitly listed in the XML file (see [About the special seventh character](#about-the-special-seventh-character) for more information). Each line in this file must contain a single code. Codes can be written in the format with or without the dot. In each line, the code may be followed by any text, as long as there is at least one space character immediately after the code. The `icd10cm-codes` text files available from the [CDC's website](https://www.cdc.gov/nchs/icd/icd-10-cm/files.html) can be used for this purpose, without modification.  
 The file specified in `classification_data_file_path` is the XML containing the whole classification. This typically corresponds to the `icd10cm-tabular` XML files available from the [CDC's website](https://www.cdc.gov/nchs/icd/icd-10-cm/files.html). If using XML files from another origin, note that, in the official releases, the first two children of the root XML element are not part of the structure of the classification, and are therefore skipped by the library.
-Examples of both file types can be found in the [all-data folder](https://github.com/StefanoTrv/simple_icd_10_CM/tree/master/all-data), which includes data for the current default release and for a previous release.
+Examples of both file types can be found in the [all-data folder](https://github.com/StefanoTrv/simple_icd_10_CM/tree/master/all-data), which includes data for the current default release and for previous releases.
 
 ## The format of the codes
 Subcategories codes can be written in two different ways: with a dot (for example "I13.1") and with no dot (for example "I131"). The functions in this library can receive as input codes in both these formats. The codes returned by the functions will always be in the format with the dot.  
 You can easily change the format of a code by using the [`remove_dot`](#remove_dotcode) and [`add_dot`](#add_dotcode) functions.
 
 ## About the file "Instructional Notations.md"
-The file [Instructional Notations.md](https://github.com/StefanoTrv/simple_icd_10_CM/blob/master/Instructional%20Notations.md) contains the introduction present in the file `icd10cm-tabular-April-2025.xml` (the file that contains the whole ICD-10-CM classification), copied there in a more accessible and readable format. There you can find an explanation about the meaning of most of the additional fields that can accompany a code.
+The file [Instructional Notations.md](https://github.com/StefanoTrv/simple_icd_10_CM/blob/master/Instructional%20Notations.md) contains the introduction present in the file `icd10cm-tabular-April-2026.xml` (the file that contains the whole ICD-10-CM classification), copied there in a more accessible and readable format. There you can find an explanation about the meaning of most of the additional fields that can accompany a code.
 
 ## Blocks containing only one category
 Unlike ICD-10, ICD-10-CM includes blocks of categories that contain only one category (and its subcategories). These blocks are named after the category that they contain, which means that ICD-10-CM contains blocks and categories that have the same exact code. This is a problem: because of this questionable decision, we can't know for sure if the code "B99", for example, refers to the category "B99" or to the block with the same name. This can be seen in the following example, where "B99" is recognized as both a block and a category:
@@ -161,9 +166,9 @@ cm.is_block("I12") and cm.is_category("I12")
 ```
 
 ## About the special seventh character
-The file `icd10cm-tabular-April-2025.xml`, which is the XML file that contains the whole ICD-10-CM classification, doesn't have an entry for all the codes generated by adding the "special" seventh character, but it often contains instead rules that explain how to generate these codes in the "sevenChrDef" field (and sometimes in the "sevenChrNote" field too, just to complicate things a little bit...). You can find more about the structure of these particular codes in [Instructional Notations.md](https://github.com/StefanoTrv/simple_icd_10_CM/blob/master/Instructional%20Notations.md).  
+The file `icd10cm-tabular-April-2026.xml`, which is the XML file that contains the whole ICD-10-CM classification, doesn't have an entry for all the codes generated by adding the "special" seventh character, but it often contains instead rules that explain how to generate these codes in the "sevenChrDef" field (and sometimes in the "sevenChrNote" field too, just to complicate things a little bit...). You can find more about the structure of these particular codes in [Instructional Notations.md](https://github.com/StefanoTrv/simple_icd_10_CM/blob/master/Instructional%20Notations.md).  
 Due to the lack of a complete entry for these missing codes, I had to decide how they would be handled in this library. So I decided that their only field would be the description, composed of the description of their parent followed by the description of the meaning of the additional character, with a comma between the two: this description appears in official documents about ICD-10-CM, so it's not my invention but the actual official format. All the other fields are empty, but the optional argument `search_in_ancestors` of certain functions can be used to automatically retrieve the content of certain fields from the ancestors of the code (see the description of the specific functions in the [Documentation](#documentation) for more details).  
-Seven-characters codes that have an entry in `icd10cm-tabular-April-2025.xml` are treated like any other code, and their data is taken directly from the file.  
+Seven-characters codes that have an entry in `icd10cm-tabular-April-2026.xml` are treated like any other code, and their data is taken directly from the file.  
 If you need to know whether a code has been automatically generated using a rule described in a "sevenChrDef" field, you can use the [`is_extended_subcategory`](#is_extended_subcategorycode) function. Only the codes generated programmatically are classified as "extended subcategories", the seven-characters codes explicitly listed in the data are classified as "subcategories".
 
 ## Documentation
@@ -504,8 +509,8 @@ cm.add_dot("K00-K14")
 #'K00-K14'
 ```
 
-### change_version(all_codes_file_path=None, classification_data_file_path=None)
-This function can be used to load any ICD-10-CM release provided by the user, or to revert to using the default release for the package. Its usage is explained in the paragraph [Using other ICD-10-CM releases](#using-other-icd-10-cm-releases).
+### change_version(all_codes_file_path=None, classification_data_file_path=None, suppress_warnings=None)
+This function can be used to load any ICD-10-CM release provided by the user, or to revert to using the default release for the package. Its usage is explained in the paragraph [Using other ICD-10-CM releases](#using-other-icd-10-cm-releases). The optional argument `suppress_warnings` can be used to hide the warnings that are emitted when some kinds of small inconsistencies are detected in the loaded data. Setting this parameter to `True` will hide the warnings, setting it to `False` will show them, setting it to `None` or omitting it will not change whether warnings are hidden or shown. It is recommended that you always omit this parameter.
 
 ## Conclusion
 This should be everything you need to know about the simple_icd_10_cm library. Please contact me if you find any mistake, bug, missing feature or anything else that could be improved or made easier to comprehend, both in this documentation and in the library itself as well as in the [Showcase notebook](https://github.com/StefanoTrv/simple_icd_10_CM/blob/master/Showcase%20notebook.ipynb). You can also contact me if you need any help using this library, but I may not be able to help with questions about the ICD-10-CM classification itself.

simple_icd_10_cm-1.5.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+simple_icd_10_cm/__init__.py,sha256=Z1KTvT112WEfhmGoTFyloLMte55xISt0t0CQAeUysRk,31
+simple_icd_10_cm/simple_icd_10_cm.py,sha256=2B50YqwjD8EIPyGN3DEvYpr7-Bxg8ATEuwfpXXoCbgA,29509
+simple_icd_10_cm/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+simple_icd_10_cm/data/code-list-April-2026.txt,sha256=31TZdDo0mfSk_BKILtt84Nl1tEraWiolWXqlbQwqwcQ,799043
+simple_icd_10_cm/data/icd10c-tabular-April-1-2026.xml,sha256=8WH4GCr_POOip44gL4JZwI6u4sZwqeRbAHJEXFIwKTU,9747661
+simple_icd_10_cm-1.5.0.dist-info/licenses/LICENSE,sha256=ESrc5DumgzIiwvf1981qtBgmqpE4pH8H8x1vxcIzVlI,1099
+simple_icd_10_cm-1.5.0.dist-info/METADATA,sha256=K5C8NQjNEIfUR9uoAiXqNXrYQQLK91HNsYde8LGQV6E,40985
+simple_icd_10_cm-1.5.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+simple_icd_10_cm-1.5.0.dist-info/top_level.txt,sha256=6SUf2VHvXP1HmldCp4mtErBEUJHSI0FH39s9aYDAmx4,17
+simple_icd_10_cm-1.5.0.dist-info/RECORD,,

{simple_icd_10_cm-1.4.0.dist-info → simple_icd_10_cm-1.5.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

simple_icd_10_cm-1.4.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-simple_icd_10_cm/__init__.py,sha256=Z1KTvT112WEfhmGoTFyloLMte55xISt0t0CQAeUysRk,31
-simple_icd_10_cm/simple_icd_10_cm.py,sha256=auQ8dcioKjU9r9cuOSrjwR2mO9LU9ZOMXm-5I7-8VbE,25594
-simple_icd_10_cm/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-simple_icd_10_cm/data/code-list-April-2025.txt,sha256=75Pd9bOV14HTokVY-lw2v5jD_Dt3sYb2Dm_xlaNNcWI,794065
-simple_icd_10_cm/data/icd10cm-tabular-April-2025.xml,sha256=1s31KD81oQLXfq0jbsjIkp8iun8zVtut_xjt4Bo6PeU,9658391
-simple_icd_10_cm-1.4.0.dist-info/licenses/LICENSE,sha256=ESrc5DumgzIiwvf1981qtBgmqpE4pH8H8x1vxcIzVlI,1099
-simple_icd_10_cm-1.4.0.dist-info/METADATA,sha256=QUEA00sNj2rpZtippJiHpQJywruO_RWYtZ2_-3wmu1k,40214
-simple_icd_10_cm-1.4.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-simple_icd_10_cm-1.4.0.dist-info/top_level.txt,sha256=6SUf2VHvXP1HmldCp4mtErBEUJHSI0FH39s9aYDAmx4,17
-simple_icd_10_cm-1.4.0.dist-info/RECORD,,