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

MediBot/MediBot_Preprocessor_lib.py

@@ -0,0 +1,357 @@
+from collections import OrderedDict, defaultdict
+from datetime import datetime
+import os
+import csv
+import sys
+
+# Add parent directory of the project to the Python path
+project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(project_dir)
+
+try:
+    import MediLink_ConfigLoader
+    import MediLink_DataMgmt
+except ImportError:
+    from MediLink import MediLink_ConfigLoader
+    from MediLink import MediLink_DataMgmt
+    
+try:
+    from MediBot_UI import app_control
+except ImportError:
+    from MediBot import MediBot_UI
+    app_control = MediBot_UI.app_control
+
+"""
+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
+        super().__init__(self.message)
+
+def initialize(config):
+    global AHK_EXECUTABLE, CSV_FILE_PATH, field_mapping, page_end_markers
+    
+    try:
+        AHK_EXECUTABLE = config.get('AHK_EXECUTABLE', "")
+    except AttributeError:
+        raise InitializationError("Error: 'AHK_EXECUTABLE' not found in config.")
+    
+    try:
+        CSV_FILE_PATH = config.get('CSV_FILE_PATH', "")
+    except AttributeError:
+        raise InitializationError("Error: 'CSV_FILE_PATH' not found in config.")
+    
+    try:
+        field_mapping = OrderedDict(config.get('field_mapping', {}))
+    except AttributeError:
+        raise InitializationError("Error: 'field_mapping' not found in config.")
+    
+    try:
+        page_end_markers = config.get('page_end_markers', [])
+    except AttributeError:
+        raise InitializationError("Error: 'page_end_markers' not found in config.")
+
+
+def open_csv_for_editing(csv_file_path):
+    try:
+        # Open the CSV file with its associated application
+        os.system('start "" "{}"'.format(csv_file_path))
+        print("After saving the revised CSV, please re-run MediBot.")
+    except Exception as e:
+        print("Failed to open CSV file:", e)
+        
+# Function to load and process CSV data
+def load_csv_data(csv_file_path):
+    try:
+        # Check if the file exists
+        if not os.path.exists(csv_file_path):
+            raise FileNotFoundError("***Error: CSV file '{}' not found.".format(csv_file_path))
+        
+        with open(csv_file_path, 'r') as csvfile:
+            reader = csv.DictReader(csvfile)
+            return [row for row in reader]  # Return a list of dictionaries
+    except FileNotFoundError as e:
+        print(e)  # Print the informative error message
+        print("Hint: Check if CSV file is located in the expected directory or specify a different path in config file.")
+        print("Please correct the issue and re-run MediBot.")
+        sys.exit(1)  # Halt the script
+    except IOError as e:
+        print("Error reading CSV file: {}. Please check the file path and permissions.".format(e))
+        sys.exit(1)  # Halt the script in case of other IO errors
+
+# CSV Pre-processor Helper functions
+def add_insurance_id_column(csv_data):
+    for row in csv_data:
+        row['Ins1 Insurance ID'] = ''  # Initialize the column with empty values
+
+def filter_rows(csv_data):
+    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']]
+
+def convert_surgery_date(csv_data):
+    for row in csv_data:
+        try:
+            row['Surgery Date'] = datetime.strptime(row.get('Surgery Date', ''), '%m/%d/%Y')
+        except ValueError:
+            row['Surgery Date'] = datetime.min  # Assign a minimum datetime value for sorting purposes
+
+def sort_and_deduplicate(csv_data):
+    csv_data.sort(key=lambda x: (x['Surgery Date'], x.get('Patient Last', '').strip()))
+    unique_patients = {}
+    for row in csv_data:
+        patient_id = row.get('Patient ID')
+        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())
+    csv_data.sort(key=lambda x: (x['Surgery Date'], x.get('Patient Last', '').strip()))
+
+def combine_fields(csv_data):
+    for row in csv_data:
+        row['Surgery Date'] = row['Surgery Date'].strftime('%m/%d/%Y')
+        first_name = row.get('Patient First', '').strip()
+        middle_name = row.get('Patient Middle', '').strip()
+        if len(middle_name) > 1:
+            middle_name = middle_name[0]  # Take only the first character
+        last_name = row.get('Patient Last', '').strip()
+        row['Patient Name'] = "{}, {} {}".format(last_name, first_name, middle_name).strip()
+        address1 = row.get('Patient Address1', '').strip()
+        address2 = row.get('Patient Address2', '').strip()
+        row['Patient Street'] = "{} {}".format(address1, address2).strip()
+
+def apply_replacements(csv_data, crosswalk):
+    replacements = crosswalk.get('csv_replacements', {})
+    for row in csv_data:
+        for old_value, new_value in replacements.items():
+            if row.get('Patient SSN', '') == old_value:
+                row['Patient SSN'] = new_value
+            elif row.get('Primary Insurance', '') == old_value:
+                row['Primary Insurance'] = new_value
+            elif row.get('Ins1 Payer ID') == old_value:
+                row['Ins1 Payer ID'] = new_value
+
+def update_insurance_ids(csv_data, crosswalk):
+    for row in csv_data:
+        ins1_payer_id = row.get('Ins1 Payer ID', '').strip()
+        # MediLink_ConfigLoader.log("Ins1 Payer ID '{}' associated with Patient ID {}.".format(ins1_payer_id, row.get('Patient ID', "None")))
+        if ins1_payer_id:
+            if ins1_payer_id in crosswalk.get('payer_id', {}):
+                medisoft_ids = crosswalk['payer_id'][ins1_payer_id].get('medisoft_id', [])
+                if medisoft_ids:
+                    medisoft_ids = [int(id) for id in medisoft_ids]
+                    # TODO Try to match OpenPM's Insurance Name to get a better match
+                    row['Ins1 Insurance ID'] = medisoft_ids[0] 
+                    # MediLink_ConfigLoader.log("Ins1 Insurance ID '{}' used for Payer ID {} in crosswalk.".format(row.get('Ins1 Insurance ID', ''), ins1_payer_id))
+            else:
+                MediLink_ConfigLoader.log("Ins1 Payer ID '{}' not found in the crosswalk.".format(ins1_payer_id))
+                # Create a placeholder entry in the crosswalk, need to consider the medisoft_medicare_id handling later.
+                if 'payer_id' not in crosswalk:
+                    crosswalk['payer_id'] = {}
+                crosswalk['payer_id'][ins1_payer_id] = {
+                    'medisoft_id': [],
+                    'medisoft_medicare_id': [],
+                    '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 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)
+    if not patient_id_to_insurance_id:
+        raise ValueError("Failed to load historical Patient ID to Insurance ID mappings from MAPAT.")
+
+    payer_id_to_patient_ids = load_historical_payer_to_patient_mappings(config)
+    if not payer_id_to_patient_ids:
+        raise ValueError("Failed to load historical Carol's CSVs.")
+
+    return patient_id_to_insurance_id, payer_id_to_patient_ids
+
+def map_payer_ids_to_insurance_ids(patient_id_to_insurance_id, payer_id_to_patient_ids):
+    """Maps Payer IDs to Insurance IDs based on the historical mappings."""
+    payer_id_to_details = {}
+    for payer_id, patient_ids in payer_id_to_patient_ids.items():
+        medisoft_ids = set()
+        for patient_id in patient_ids:
+            if patient_id in patient_id_to_insurance_id:
+                medisoft_id = patient_id_to_insurance_id[patient_id]
+                medisoft_ids.add(medisoft_id)
+                MediLink_ConfigLoader.log("Added Medisoft ID {} for Patient ID {} and Payer ID {}".format(medisoft_id, patient_id, payer_id))
+            else:
+                MediLink_ConfigLoader.log("No matching Insurance ID found for Patient ID {}".format(patient_id))
+        if medisoft_ids:
+            payer_id_to_details[payer_id] = {
+                "endpoint": "OPTUMEDI",  # TODO Default, to be refined via API poll. There are 2 of these defaults!
+                "medisoft_id": list(medisoft_ids),
+                "medisoft_medicare_id": []  # Placeholder for future implementation
+            }
+    return payer_id_to_details
+
+def load_insurance_data_from_mains(config):
+    """
+    Loads insurance data from MAINS and creates a mapping from insurance names to their respective IDs.
+    This mapping is critical for the crosswalk update process to correctly associate payer IDs with insurance IDs.
+
+    Args:
+        config (dict): Configuration object containing necessary paths and parameters.
+
+    Returns:
+        dict: A dictionary mapping insurance names to insurance IDs.
+    """
+    # Reset config pull to make sure its not using the MediLink config key subset
+    config, crosswalk = MediLink_ConfigLoader.load_configuration()
+    
+    # Retrieve MAINS path and slicing information from the configuration   
+    # TODO (Low) For secondary insurance, this needs to be pulling from the correct MAINS (there are 2)
+    # TODO (Low) Performance: There probably needs to be a dictionary proxy for MAINS that gets updated.
+    mains_path = config['MAINS_MED_PATH']
+    mains_slices = crosswalk['mains_mapping']['slices']
+    
+    # Initialize the dictionary to hold the insurance to insurance ID mappings
+    insurance_to_id = {}
+    
+    # Read data from MAINS using a provided function to handle fixed-width data
+    for record, line_number in MediLink_DataMgmt.read_general_fixed_width_data(mains_path, mains_slices):
+        insurance_name = record['MAINSNAME']
+        # Assuming line_number gives the correct insurance ID without needing adjustment
+        insurance_to_id[insurance_name] = line_number
+    
+    return insurance_to_id
+
+def load_insurance_data_from_mapat(config, crosswalk):
+    """
+    Loads insurance data from MAPAT and creates a mapping from patient ID to insurance ID.
+    
+    Args:
+        config (dict): Configuration object containing necessary paths and parameters.
+        crosswalk ... ADD HERE.
+
+    Returns:
+        dict: A dictionary mapping patient IDs to insurance IDs.
+    """
+    # Retrieve MAPAT path and slicing information from the configuration
+    mapat_path = app_control.get_mapat_med_path()
+    mapat_slices = crosswalk['mapat_mapping']['slices']
+    
+    # Initialize the dictionary to hold the patient ID to insurance ID mappings
+    patient_id_to_insurance_id = {}
+    
+    # Read data from MAPAT using a provided function to handle fixed-width data
+    for record, _ in MediLink_DataMgmt.read_general_fixed_width_data(mapat_path, mapat_slices):
+        patient_id = record['MAPATPXID']
+        insurance_id = record['MAPATINID']
+        patient_id_to_insurance_id[patient_id] = insurance_id
+        
+    return patient_id_to_insurance_id
+
+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):
+            # 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))
+        
+            # 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
+    except Exception as e:
+        MediLink_ConfigLoader.log("Failed to parse Z.dat: {}".format(str(e)), config, level="ERROR")
+        raise
+
+    return patient_id_to_insurance_name
+
+def load_historical_payer_to_patient_mappings(config):
+    """
+    Loads historical mappings from multiple Carol's CSV files in a specified directory,
+    mapping Payer IDs to sets of Patient IDs.
+
+    Args:
+        config (dict): Configuration object containing the directory path for Carol's CSV files
+                       and other necessary parameters.
+
+    Returns:
+        dict: A dictionary where each key is a Payer ID and the value is a set of Patient IDs.
+    """
+    directory_path = os.path.dirname(config['CSV_FILE_PATH'])
+    payer_to_patient_ids = defaultdict(set)
+
+    try:
+        # Check if the directory exists
+        if not os.path.isdir(directory_path):
+            raise FileNotFoundError("Directory '{}' not found.".format(directory_path))
+
+        # Loop through each file in the directory containing Carol's historical CSVs
+        for filename in os.listdir(directory_path):
+            file_path = os.path.join(directory_path, filename)
+            if filename.endswith('.csv'):
+                try:
+                    with open(file_path, 'r', encoding='utf-8') as csvfile:
+                        reader = csv.DictReader(csvfile)
+                        patient_count = 0  # Counter for Patient IDs found in this CSV
+                        for row in reader:
+                            if 'Patient ID' not in row or 'Ins1 Payer ID' not in row:
+                                continue  # Skip this row if either key is missing
+                            if not row.get('Patient ID').strip() or not row.get('Ins1 Payer ID').strip():
+                                continue  # Skip this row if either value is missing or empty
+                            
+                            payer_id = row['Ins1 Payer ID'].strip()
+                            patient_id = row['Patient ID'].strip()
+                            payer_to_patient_ids[payer_id].add(patient_id)
+                            patient_count += 1  # Increment the counter for each valid mapping
+                        
+                        # Log the accumulated count for this CSV file
+                        if patient_count > 0:
+                            MediLink_ConfigLoader.log("CSV file '{}' has {} Patient IDs with Payer IDs.".format(filename, patient_count))
+                        else:
+                            MediLink_ConfigLoader.log("CSV file '{}' is empty or does not have valid Patient ID or Payer ID mappings.".format(filename))
+                except Exception as e:
+                    print("Error processing file {}: {}".format(filename, e))
+    except FileNotFoundError as e:
+        print("Error: {}".format(e))
+
+    if not payer_to_patient_ids:
+        print("No historical mappings were generated.")
+    
+    return dict(payer_to_patient_ids)

MediBot/MediBot_UI.py

@@ -0,0 +1,240 @@
+from sys import exit
+import ctypes
+from ctypes import wintypes
+import time
+import re
+
+# Add parent directory of the project to the Python path
+import os
+import sys
+project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(project_dir)
+
+try: 
+    from MediLink import MediLink_ConfigLoader
+    config, crosswalk = MediLink_ConfigLoader.load_configuration()
+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)
+
+class AppControl:
+    def __init__(self):
+        self.script_paused = False
+        self.mapat_med_path = ''
+        self.medisoft_shortcut = ''
+        # Load initial paths from config when instance is created
+        self.load_paths_from_config()
+
+    def get_pause_status(self):
+        return self.script_paused
+
+    def set_pause_status(self, status):
+        self.script_paused = status
+
+    def get_mapat_med_path(self):
+        return self.mapat_med_path
+
+    def set_mapat_med_path(self, path):
+        self.mapat_med_path = path
+
+    def get_medisoft_shortcut(self):
+        return self.medisoft_shortcut
+
+    def set_medisoft_shortcut(self, path):
+        self.medisoft_shortcut = path
+
+    def load_paths_from_config(self, medicare=False):
+        # Assuming `config` is a module or a globally accessible configuration dictionary
+        if medicare:
+            self.mapat_med_path = config.get('MEDICARE_MAPAT_MED_PATH', "")
+            self.medisoft_shortcut = config.get('MEDICARE_SHORTCUT', "")
+        else:
+            self.mapat_med_path = config.get('MAPAT_MED_PATH', "")
+            self.medisoft_shortcut = config.get('PRIVATE_SHORTCUT', "")
+
+app_control = AppControl()
+
+def is_key_pressed(key_code):
+    user32 = ctypes.WinDLL('user32', use_last_error=True)
+    user32.GetAsyncKeyState.restype = wintypes.SHORT
+    user32.GetAsyncKeyState.argtypes = [wintypes.INT]
+    return user32.GetAsyncKeyState(key_code) & 0x8000 != 0
+
+def manage_script_pause(csv_data, error_message, reverse_mapping):
+    user_action = 0 # initialize as 'continue'
+    
+    if not app_control.get_pause_status() and is_key_pressed(VK_PAUSE):
+        app_control.set_pause_status(True)
+        print("Script paused. Opening menu...")
+        interaction_mode = 'normal'  # Assuming normal interaction mode for script pause
+        user_action = user_interaction(csv_data, interaction_mode, error_message, reverse_mapping)
+    
+    while app_control.get_pause_status():
+        if is_key_pressed(VK_END):
+            app_control.set_pause_status(False)
+            print("Continuing...")
+        elif is_key_pressed(VK_PAUSE):
+            user_action = user_interaction(csv_data, 'normal', error_message, reverse_mapping)
+        time.sleep(0.1)
+    
+    return user_action
+
+# Menu Display & User Interaction
+def display_patient_selection_menu(csv_data, reverse_mapping, proceed_as_medicare):
+    selected_patient_ids = []
+    selected_indices = []
+
+    def display_menu_header(title):
+        print("\n" + "-" * 60)
+        print(title)
+        print("-" * 60)
+
+    def display_patient_list(csv_data, reverse_mapping, medicare_filter=False, exclude_medicare=False):
+        medicare_policy_pattern = r"^[a-zA-Z0-9]{11}$"  # Regex pattern for 11 alpha-numeric characters
+        primary_policy_number_header = reverse_mapping.get('Primary Policy Number', 'Primary Policy Number')
+        primary_insurance_header = reverse_mapping.get('Primary Insurance', 'Primary Insurance')  # Adjust field name as needed
+        
+        displayed_indices = []
+        displayed_patient_ids = []
+
+        for index, row in enumerate(csv_data):
+            policy_number = row.get(primary_policy_number_header, "")
+            primary_insurance = row.get(primary_insurance_header, "").upper()
+            
+            if medicare_filter and (not re.match(medicare_policy_pattern, policy_number) or "MEDICARE" not in primary_insurance):
+                continue
+            if exclude_medicare and re.match(medicare_policy_pattern, policy_number) and "MEDICARE" in primary_insurance:
+                continue
+
+            patient_id_header = reverse_mapping['Patient ID #2']
+            patient_name_header = reverse_mapping['Patient Name']
+            patient_id = row.get(patient_id_header, "N/A")
+            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))
+
+            displayed_indices.append(index)
+            displayed_patient_ids.append(patient_id)
+
+        return displayed_indices, displayed_patient_ids
+
+    if proceed_as_medicare:
+        display_menu_header("MEDICARE Patient Selection for Today's Data Entry")
+        selected_indices, selected_patient_ids = display_patient_list(csv_data, reverse_mapping, medicare_filter=True)
+    else:
+        display_menu_header("PRIVATE Patient Selection for Today's Data Entry")
+        selected_indices, selected_patient_ids = display_patient_list(csv_data, reverse_mapping, exclude_medicare=True)
+
+    print("-" * 60)
+    proceed = input("\nDo you want to proceed with the selected patients? (yes/no): ").lower().strip() in ['yes', 'y']
+
+    if not proceed:
+        display_menu_header("Patient Selection for Today's Data Entry")
+        selected_indices, selected_patient_ids = display_patient_list(csv_data, reverse_mapping)
+        print("-" * 60)
+        
+        while True:
+            selection = input("\nEnter the number(s) of the patients you wish to proceed with \n(e.g., 1,3,5): ").strip()
+            
+            if not selection:
+                print("Invalid entry. Please provide at least one number.")
+                continue
+            
+            selection = selection.replace('.', ',')  # Replace '.' with ',' in the user input just in case
+            selected_indices = [int(x.strip()) - 1 for x in selection.split(',') if x.strip().isdigit()]  
+            
+            if not selected_indices:
+                print("Invalid entry. Please provide at least one integer.")
+                continue
+            
+            proceed = True
+            break
+
+    patient_id_header = reverse_mapping['Patient ID #2']
+    selected_patient_ids = [csv_data[i][patient_id_header] for i in selected_indices if i < len(csv_data)]
+
+    return proceed, selected_patient_ids, selected_indices
+
+def display_menu_header(title):
+    print("\n" + "-" * 60)
+    print(title)
+    print("-" * 60)
+
+def handle_user_interaction(interaction_mode, error_message):
+    while True:
+        # If interaction_mode is neither 'triage' nor 'error', then it's normal mode.
+        title = "Error Occurred" if interaction_mode == 'error' else "Data Entry Options"
+        display_menu_header(title)
+
+        if interaction_mode == 'error':
+            print("\nERROR: ", error_message)
+
+        # Need to tell the user which patient we're talking about because it won't be obvious anymore.
+        # Also, this ERROR might be called from a location where the menu below isn't relevant like selecting patients 
+        # -- need a better way to handle that.
+        print("1: Retry last entry")
+        print("2: Skip to next patient and continue")
+        print("3: Go back two patients and redo")
+        print("4: Exit script")
+        print("-" * 60)
+        choice = input("Enter your choice (1/2/3/4): ").strip()
+        
+        if choice == '1':
+            print("Selected: 'Retry last entry'. Please press 'F12' to continue.")
+            return -1
+        elif choice == '2':
+            print("Selected: 'Skip to next patient and continue'. Please press 'F12' to continue.")
+            return 1
+        elif choice == '3':
+            print("Selected: 'Go back two patients and redo'. Please press 'F12' to continue.")
+            # Returning a specific value to indicate the action of going back two patients
+            # but we might run into a problem if we stop mid-run on the first row?
+            return -2
+        elif choice == '4':
+            print("Exiting the script.")
+            exit()
+        else:
+            print("Invalid choice. Please enter a valid number.")
+
+def user_interaction(csv_data, interaction_mode, error_message, reverse_mapping):
+    global app_control  # Use the instance of AppControl
+    selected_patient_ids = []
+    selected_indices = []
+
+    if interaction_mode == 'triage':
+        display_menu_header("            =(^.^)= Welcome to MediBot! =(^.^)=")
+
+        while True:
+            response = input("\nAm I processing Medicare patients? (yes/no): ").lower().strip()
+            if response:
+                if response in ['yes', 'y']:
+                    app_control.load_paths_from_config(medicare=True)
+                    break
+                elif response in ['no', 'n']:
+                    app_control.load_paths_from_config(medicare=False)
+                    break
+                else:
+                    print("Invalid entry. Please enter 'yes' or 'no'.")
+            else:
+                print("A response is required. Please try again.")
+
+        fixed_values = config.get('fixed_values', {})  # Get fixed values from config json 
+        if response in ['yes', 'y']:
+            medicare_added_fixed_values = config.get('medicare_added_fixed_values', {})
+            fixed_values.update(medicare_added_fixed_values)  # Add any medicare-specific fixed values from config
+        
+        proceed, selected_patient_ids, selected_indices = display_patient_selection_menu(csv_data, reverse_mapping, response in ['yes', 'y'])
+        return proceed, selected_patient_ids, selected_indices, fixed_values
+
+    return handle_user_interaction(interaction_mode, error_message)