medicafe 0.240517.0__py3-none-any.whl → 0.240716.2__py3-none-any.whl

MediBot/MediBot_Preprocessor_lib.py

@@ -17,37 +17,13 @@ except ImportError:
     
 try:
     from MediBot_UI import app_control
+    from MediBot_docx_decoder import parse_docx
 except ImportError:
     from MediBot import MediBot_UI
     app_control = MediBot_UI.app_control
+    from MediBot import MediBot_docx_decoder
+    parse_docx = MediBot_docx_decoder.parse_docx
 
-"""
-Draft Docstring to move over from Preprocessor.
-
-Data Integrity and Validation
- Implement a mechanism to confirm the accuracy of entered data, potentially through a verification step or summary report.
- Enhance CSV integrity checks to identify and report potential issues with data format, especially concerning insurance policy numbers and special character handling.
-
-Development Roadmap for crosswalk_update()
- Automation required for updating the crosswalk.json when new Medisoft insurance is discovered.
-For open_csv_for_editing
-
-Known Issues and Bugs
- Address the handling of '.' and other special characters that may disrupt parsing, especially under Windows XP.
-
-For load_csv_data
-
-Preprocessing Enhancements
- Optimize script startup and CSV loading to reduce initial latency.
-
-Data Integrity and Validation
- Conduct a thorough CSV integrity check before processing to flag potential issues upfront.
-
-Future Work
- Consolidate data from multiple sources (Provider_Notes.csv, Surgery_Schedule.csv, and Carols_CSV.csv) into a single table with Patient ID as the key, ensuring all data elements are aligned and duplicate entries are minimized.
- Implement logic to verify and match Patient IDs across different files to ensure data integrity before consolidation. (Catching errors between source data)
- Optimize the preprocessing of surgery dates and diagnosis codes for use in patient billing and scheduling systems.
-"""
 class InitializationError(Exception):
     def __init__(self, message):
         self.message = message
@@ -105,13 +81,32 @@ def load_csv_data(csv_file_path):
         sys.exit(1)  # Halt the script in case of other IO errors
 
 # CSV Pre-processor Helper functions
-def add_insurance_id_column(csv_data):
+def add_columns(csv_data, column_headers):
+    """
+    Adds one or multiple columns to the CSV data.
+    
+    Parameters:
+    csv_data (list of dict): The CSV data where each row is represented as a dictionary.
+    column_headers (list of str or str): A list of column headers to be added to each row, or a single column header.
+    
+    Returns:
+    None: The function modifies the csv_data in place.
+    """
+    if isinstance(column_headers, str):
+        column_headers = [column_headers]
+    elif not isinstance(column_headers, list):
+        raise ValueError("column_headers should be a list or a string")
+
     for row in csv_data:
-        row['Ins1 Insurance ID'] = ''  # Initialize the column with empty values
+        for header in column_headers:
+            row[header] = ''  # Initialize the column with empty values
 
+# Extracting the list to a variable for future refactoring:
 def filter_rows(csv_data):
+    # TODO This should go to the crosswalk.
+    excluded_insurance = ['AETNA', 'AETNA MEDICARE', 'HUMANA MED HMO']
     csv_data[:] = [row for row in csv_data if row.get('Patient ID', '').strip()]
-    csv_data[:] = [row for row in csv_data if row.get('Primary Insurance', '').strip() not in ['AETNA', 'AETNA MEDICARE', 'HUMANA MED HMO']]
+    csv_data[:] = [row for row in csv_data if row.get('Primary Insurance', '').strip() not in excluded_insurance]
 
 def convert_surgery_date(csv_data):
     for row in csv_data:
@@ -121,6 +116,7 @@ def convert_surgery_date(csv_data):
             row['Surgery Date'] = datetime.min  # Assign a minimum datetime value for sorting purposes
 
 def sort_and_deduplicate(csv_data):
+    # TODO we need to figure out a new logic here for doing second-eye charges. I don't know what the flow should be yet.
     csv_data.sort(key=lambda x: (x['Surgery Date'], x.get('Patient Last', '').strip()))
     unique_patients = {}
     for row in csv_data:
@@ -128,6 +124,8 @@ def sort_and_deduplicate(csv_data):
         if patient_id not in unique_patients or row['Surgery Date'] < unique_patients[patient_id]['Surgery Date']:
             unique_patients[patient_id] = row
     csv_data[:] = list(unique_patients.values())
+    # TODO Sorting, now that we're going to have the Surgery Schedules available, should be ordered as the patients show up on the schedule.
+    # If we don't have that surgery schedule yet for some reason, we should default to the current ordering strategy.
     csv_data.sort(key=lambda x: (x['Surgery Date'], x.get('Patient Last', '').strip()))
 
 def combine_fields(csv_data):
@@ -177,6 +175,149 @@ def update_insurance_ids(csv_data, crosswalk):
                     'endpoint': 'OPTUMEDI' # Default probably should be a flag for the crosswalk update function to deal with. BUG HARDCODE THERE ARE 3 of these defaults
                 } 
 
+def update_procedure_codes(csv_data):
+    # Define the Medisoft shorthand to diagnostic codes dictionary
+    # TODO The reverse of this will be in the crosswalk. We'll need to reverse it here for lookup.
+    medisoft_to_diagnosis = {
+        "25811": "H25.811",
+        "25812": "H25.812",
+        "2512": "H25.12",
+        "2511": "H25.11",
+        "529XA": "T85.29XA",
+        "4301": "H43.01",
+        "4302": "H43.02",
+        "011X2": "H40.11X2",
+        "051X3": "H40.51X3",
+        "5398A": "T85.398A"
+    }
+
+    # Define the procedure codes to diagnostic codes dictionary
+    procedure_to_diagnosis = {
+        "00142": ["H25.811", "H25.812", "H25.12", "H25.11", "T85.29XA"],
+        "00145": ["H43.01", "H43.02"],
+        "00140": ["H40.11X2", "H40.51X3"]
+    }
+
+    # Reverse the dictionary for easier lookup from diagnostic code to procedure code
+    diagnosis_to_procedure = {}
+    for procedure_code, diagnosis_codes in procedure_to_diagnosis.items():
+        for diagnosis_code in diagnosis_codes:
+            diagnosis_to_procedure[diagnosis_code] = procedure_code
+
+    # Initialize counter for updated rows
+    updated_count = 0
+
+    # Update the "Procedure Code" column in the CSV data
+    for row_num, row in enumerate(csv_data, start=1):
+        try:
+            medisoft_code = row.get('Default Diagnosis #1', '').strip()
+            diagnosis_code = medisoft_to_diagnosis.get(medisoft_code)
+            if diagnosis_code:
+                procedure_code = diagnosis_to_procedure.get(diagnosis_code)
+                if procedure_code:
+                    row['Procedure Code'] = procedure_code
+                    updated_count += 1
+                else:
+                    row['Procedure Code'] = "Unknown"  # Or handle as appropriate
+            else:
+                row['Procedure Code'] = "Unknown"  # Or handle as appropriate
+        except Exception as e:
+            MediLink_ConfigLoader.log("In update_procedure_codes, Error processing row {}: {}".format(row_num, e), level="ERROR")
+
+    # Log total count of updated rows
+    MediLink_ConfigLoader.log("Total {} 'Procedure Code' rows updated.".format(updated_count), level="INFO")
+
+    return True
+
+def update_diagnosis_codes(csv_data):
+    try:
+        # Load configuration and crosswalk
+        config, _ = MediLink_ConfigLoader.load_configuration()
+        
+        # Extract the local storage path from the configuration
+        local_storage_path = config['MediLink_Config']['local_storage_path']
+        
+        # Initialize a dictionary to hold diagnosis codes from all DOCX files
+        all_patient_data = {}
+
+        # Iterate through all files in the specified directory
+        for filename in os.listdir(local_storage_path):
+            if filename.endswith(".docx"):
+                filepath = os.path.join(local_storage_path, filename)
+                MediLink_ConfigLoader.log("Processing DOCX file: {}".format(filepath), level="INFO")
+                try:
+                    patient_data = parse_docx(filepath)
+                    for patient_id, service_dates in patient_data.items():
+                        if patient_id not in all_patient_data:
+                            all_patient_data[patient_id] = {}
+                        for date_of_service, diagnosis_data in service_dates.items():
+                            all_patient_data[patient_id][date_of_service] = diagnosis_data
+                except Exception as e:
+                    MediLink_ConfigLoader.log("Error parsing DOCX file {}: {}".format(filepath, e), level="ERROR")
+        
+        # Debug logging for all_patient_data
+        MediLink_ConfigLoader.log("All patient data collected from DOCX files: {}".format(all_patient_data), level="INFO")
+
+        # Define the diagnosis to Medisoft shorthand dictionary
+        diagnosis_to_medisoft = {
+            "H25.811": "25811",
+            "H25.812": "25812",
+            "H25.12": "2512",
+            "H25.11": "2511",
+            "T85.29XA": "529XA",
+            "H43.01": "4301",
+            "H43.02": "4302",
+            "H40.11X2": "011X2",
+            "H40.51X3": "051X3",
+            "T85.398A": "5398A"
+        }
+        
+        # Convert surgery dates in CSV data
+        convert_surgery_date(csv_data)
+        
+        # Initialize counter for updated rows
+        updated_count = 0
+
+        # Update the "Default Diagnosis #1" column in the CSV data
+        for row_num, row in enumerate(csv_data, start=1):
+            MediLink_ConfigLoader.log("Processing row number {}.".format(row_num), level="INFO")
+            patient_id = row.get('Patient ID', '').strip()
+            surgery_date = row.get('Surgery Date', '')
+
+            # Convert surgery_date to string format for lookup
+            if surgery_date != datetime.min:
+                surgery_date_str = surgery_date.strftime("%m-%d-%Y")
+            else:
+                surgery_date_str = ''
+
+            MediLink_ConfigLoader.log("Patient ID: {}, Surgery Date: {}".format(patient_id, surgery_date_str), level="INFO")
+
+            if patient_id in all_patient_data:
+                if surgery_date_str in all_patient_data[patient_id]:
+                    diagnosis_code, left_or_right_eye, femto_yes_or_no = all_patient_data[patient_id][surgery_date_str]
+                    MediLink_ConfigLoader.log("Found diagnosis data for Patient ID: {}, Surgery Date: {}".format(patient_id, surgery_date_str), level="INFO")
+                    
+                    # Convert diagnosis code to Medisoft shorthand format.
+                    defaulted_code = diagnosis_code[1:].replace('.', '')[-5:] if diagnosis_code else ''
+                    medisoft_shorthand = diagnosis_to_medisoft.get(diagnosis_code, defaulted_code)
+                    MediLink_ConfigLoader.log("Converted diagnosis code to Medisoft shorthand: {}".format(medisoft_shorthand), level="INFO")
+                    
+                    row['Default Diagnosis #1'] = medisoft_shorthand
+                    updated_count += 1
+                    MediLink_ConfigLoader.log("Updated row number {} with new diagnosis code.".format(row_num), level="INFO")
+                else:
+                    MediLink_ConfigLoader.log("No matching surgery date found for Patient ID: {} in row {}.".format(patient_id, row_num), level="INFO")
+            else:
+                MediLink_ConfigLoader.log("Patient ID: {} not found in DOCX data for row {}.".format(patient_id, row_num), level="INFO")
+
+        # Log total count of updated rows
+        MediLink_ConfigLoader.log("Total {} 'Default Diagnosis #1' rows updated.".format(updated_count), level="INFO")
+
+    except Exception as e:
+        message = "An error occurred while updating diagnosis codes. Please check the DOCX files and configuration: {}".format(e)
+        MediLink_ConfigLoader.log(message, level="ERROR")
+        print(message)
+
 def load_data_sources(config, crosswalk):
     """Loads historical mappings from MAPAT and Carol's CSVs."""
     patient_id_to_insurance_id = load_insurance_data_from_mapat(config, crosswalk)
@@ -269,36 +410,34 @@ def load_insurance_data_from_mapat(config, crosswalk):
 def parse_z_dat(z_dat_path, config):
     """
     Parses the Z.dat file to map Patient IDs to Insurance Names using the provided fixed-width file format.
-    
+
     Args:
         z_dat_path (str): Path to the Z.dat file.
         config (dict): Configuration object containing slicing information and other parameters.
-    
+
     Returns:
         dict: A dictionary mapping Patient IDs to Insurance Names.
     """
     patient_id_to_insurance_name = {}
-    
+
     try:
-        # Reading blocks of fixed-width data (3 lines per record: personal, insurance, service)
-        for personal_info, insurance_info, service_info in MediLink_DataMgmt.read_fixed_width_data(z_dat_path):
+        # Reading blocks of fixed-width data (up to 5 lines per record)
+        for personal_info, insurance_info, service_info, service_info_2, service_info_3 in MediLink_DataMgmt.read_fixed_width_data(z_dat_path):
             # Parsing the data using slice definitions from the config
-            parsed_data = MediLink_DataMgmt.parse_fixed_width_data(personal_info, insurance_info, service_info, config.get('MediLink_Config', config))
-        
+            parsed_data = MediLink_DataMgmt.parse_fixed_width_data(personal_info, insurance_info, service_info, service_info_2, service_info_3, config.get('MediLink_Config', config))
+
             # Extract Patient ID and Insurance Name from parsed data
             patient_id = parsed_data.get('PATID')
             insurance_name = parsed_data.get('INAME')
-            
+
             if patient_id and insurance_name:
                 patient_id_to_insurance_name[patient_id] = insurance_name
                 MediLink_ConfigLoader.log("Mapped Patient ID {} to Insurance Name {}".format(patient_id, insurance_name), config, level="INFO")
-    
+
     except FileNotFoundError:
-        MediLink_ConfigLoader.log("File not found: {}".format(z_dat_path), config, level="ERROR")
-        raise
+        MediLink_ConfigLoader.log("File not found: {}".format(z_dat_path), config, level="INFO")
     except Exception as e:
-        MediLink_ConfigLoader.log("Failed to parse Z.dat: {}".format(str(e)), config, level="ERROR")
-        raise
+        MediLink_ConfigLoader.log("Failed to parse Z.dat: {}".format(str(e)), config, level="INFO")
 
     return patient_id_to_insurance_name
 

MediBot/MediBot_UI.py

@@ -17,12 +17,7 @@ except ImportError:
     from MediLink_ConfigLoader import load_configuration
     config, crosswalk = load_configuration()
 
-"""
-User Interaction Refinements
-- [ ] Refine the menu options for clearer user guidance during script pauses and errors.
-- [ ] Add functionality for user to easily repeat or skip specific entries without script restart.
-    Develop more intuitive skip and retry mechanisms that are responsive to user input during data entry sessions.
-"""
+
 # Function to check if a specific key is pressed
 VK_END = int(config.get('VK_END', ""), 16) # Try F12 (7B). Virtual key code for 'End' (23)
 VK_PAUSE = int(config.get('VK_PAUSE', ""), 16) # Try F11 (7A). Virtual-key code for 'Home' (24)
@@ -122,7 +117,7 @@ def display_patient_selection_menu(csv_data, reverse_mapping, proceed_as_medicar
             patient_name = row.get(patient_name_header, "Unknown")
             surgery_date = row.get('Surgery Date', "Unknown Date")  # Access 'Surgery Date' as string directly from the row
             
-            print("{0:03d}: {3:.5s} (ID: {2}) {1} ".format(index+1, patient_name, patient_id, surgery_date))
+            print("{0:03d}: {3:%m-%d} (ID: {2}) {1} ".format(index+1, patient_name, patient_id, surgery_date))
 
             displayed_indices.append(index)
             displayed_patient_ids.append(patient_id)

MediBot/MediBot_dataformat_library.py

@@ -19,15 +19,6 @@ from MediBot_Preprocessor_lib import open_csv_for_editing, initialize
 from MediBot_UI import manage_script_pause, app_control
 
 
-"""
-- [X] (TEST) Address Formatting 30-character Limit:
-    (LOW) Address the issue where the format_street function in Medibot may produce addresses exceeding
-    the 30-character limit. Current stop-gap is removing period characters and the abbreviation "APT" 
-    surrounded by spaces from all records as a temporary solution. 
-    If the address still exceeds 30 characters, the function will attempt to remove spaces from right to left
-    until it reaches 30 significant digits or runs out of spaces, then truncate to 30 characters if necessary.
-"""
-
 # Bring in all the constants
 initialize(config)