medicafe 0.240419.2__zip

medicafe-0.240419.2/MediBot/MediBot_Preprocessor.py

@@ -0,0 +1,283 @@
+import csv
+import subprocess
+import os
+import re
+from datetime import datetime
+from collections import OrderedDict # so that the field_mapping stays in order.
+import re
+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)
+
+from MediLink import MediLink_ConfigLoader
+from MediLink import MediLink_DataMgmt
+
+"""
+Preprocessing Enhancements
+- [X] Preprocess Insurance Policy Numbers and Group Numbers to replace '-' with ''.
+- [X] De-duplicate entries in the CSV and only entering the px once even if they show up twice in the file.
+- [ ] Implement dynamic field combination in CSV pre-processing for flexibility with various CSV formats.
+- [ ] Enhance SSN cleaning logic to handle more variations of sensitive data masking.
+- [ ] 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.
+- [ ] Implement a mechanism to confirm the accuracy of entered data, potentially through a verification step or summary report.
+- [ ] Explore the possibility of integrating direct database queries for existing patient checks to streamline the process.
+- [ ] Automate the replacement of spaces with underscores ('_') in last names for Medicare entries, ensuring data consistency.
+- [ ] Enhance CSV integrity checks to identify and report potential issues with data format, especially concerning insurance policy numbers and special character handling.
+
+Known Issues and Bugs
+- [ ] Address the handling of '.' and other special characters that may disrupt parsing, especially under Windows XP.
+- [ ] Investigate the issue with Excel modifying long policy numbers in the CSV and provide guidance or a workaround.
+
+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.
+- [ ] Optimize the preprocessing of surgery dates and diagnosis codes for use in patient billing and scheduling systems.
+- [ ] This needs to be able to take in the Surgery Schedule doc and parse out a Patient ID : Diagnosis Code table
+- [ ] The Minutes & Cacncellation data with logic to consolidate into one table in memory.
+
+
+Future Work: crosswalk_update() automates the process of updating the crosswalk.json file with new Medisoft insurance information.
+
+Development Roadmap:
+1. Problem Statement:
+    - The need to update the crosswalk.json file arises whenever a new Medisoft insurance is discovered. Automation of this process is required for accuracy and efficiency.
+
+2. Identifying New Insurance:
+    - New Medisoft insurances are identified based on the payer ID number.
+    - The existence of the payer ID number is checked in the crosswalk.json under existing endpoints.
+
+3. Adding New Insurance:
+    - If the payer ID number does not exist in any endpoint, the tool prompts the user, assisted by endpoint APIs, to add the payer ID to a specific endpoint.
+    - The corresponding name from Carol's spreadsheet is used as the value for the new payer ID.
+
+4. Mapping to Main Insurance:
+    - The tool presents the user with a list of the top 5-7 insurances, scored higher on a fuzzy search or above a certain score.
+    - The user selects the appropriate insurance based on the identified Medisoft insurance, establishing the medisoft_insurance_to_payer_id relationship.
+
+5. Confirming Mapping:
+    - The tool implicitly establishes the insurance_to_endpoint_mapping based on the selected MediSoft name and endpoint.
+    - This step is confirmed or re-evaluated to ensure accuracy.
+
+6. User Interaction:
+    - Unrecognized payer IDs are presented to the user.
+    - Users can assign these payer IDs to MediSoft custom names individually.
+    - Grouping of payer IDs may be facilitated, especially for insurances like CIGNA with multiple addresses but few payer IDs.
+
+7. Handling Unavailable Payer IDs:
+    - An extra endpoint named "Fax/Mail or Other" is created to handle cases where the payer ID is unavailable.
+    - The tool retains payer IDs not existing in any endpoint, allowing users to assign them to the "Fax/Mail or Other" key in the crosswalk.
+
+8. Implementation Considerations:
+    - The tool should handle various scenarios, including checking for free payer IDs and determining the appropriate endpoint for assignment.
+    - Integration of API checks to verify payer ID availability and associated information is recommended.
+    - Validation mechanisms should be implemented to prevent incorrect mappings and ensure data integrity.
+
+NOTE: this needs to also pull from the CSV the listed address of the insruance.
+NOTE: La Forma Z can have the PatientID number which can link back to Carol's table which can then map the Medisoft insurance name to the payerID 
+and payer name and address when the insurance is already selected in Medisoft so the program can learn retroactively and would know the Medisoft # from
+the sequencing rather than trying to feed it from the beginning. so that'll be out of ["fixedWidthSlices"]["personal_slices"]["PATID"].
+NOTE: Also check MAPAT because maybe the PatientID to Medisoft custom insurance name might exist there enmasse + the PatientID to PayerID link from Carol's CSV
+gives us the Medisoft custom insurance name to Payer ID. Then, the endpoint mapping is the clearinghouse PayerID list (API?). MAPAT has the PatientID to Medisoft 
+insruance reference number which is the MAINS offset by 1 for the header. MAPAT has columns [159,162] for insurance and [195,200] for patient ID.
+"""
+
+# Load configuration
+# Should this also take args? Path for ./MediLink needed to be added for this to resolve
+config, _ = MediLink_ConfigLoader.load_configuration()
+
+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 in the default program
+        subprocess.run(['open' if os.name == 'posix' else 'start', csv_file_path], check=True, shell=True)
+        print("After saving the revised CSV, please re-run MediBot.")
+    except subprocess.CalledProcessError 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 Preprocessor built for Carol
+def preprocess_csv_data(csv_data):
+    try:
+        # Filter out rows without a Patient ID
+        csv_data[:] = [row for row in csv_data if row.get('Patient ID', '').strip()]
+        
+        # Remove Patients (rows) that are Primary Insurance: 'AETNA', 'AETNA MEDICARE', or 'HUMANA MED HMO'.
+        csv_data[:] = [row for row in csv_data if row.get('Primary Insurance', '').strip() not in ['AETNA', 'AETNA MEDICARE', 'HUMANA MED HMO']]
+                
+        # Convert 'Surgery Date' to datetime objects for sorting
+        for row in csv_data:
+            try:
+                row['Surgery Date'] = datetime.strptime(row.get('Surgery Date', ''), '%m/%d/%Y')
+            except ValueError:
+                # Handle or log the error if the date is invalid
+                row['Surgery Date'] = datetime.min  # Assign a minimum datetime value for sorting purposes
+
+        # Initially sort the patients first by 'Surgery Date' and then by 'Patient Last' alphabetically
+        csv_data.sort(key=lambda x: (x['Surgery Date'], x.get('Patient Last', '').strip()))
+        
+        # Deduplicate patient records based on Patient ID, keeping the entry with the earliest surgery date
+        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
+        
+        # Update csv_data to only include unique patient records
+        csv_data[:] = list(unique_patients.values())
+
+        # Re-sort the csv_data after deduplication to ensure correct order
+        csv_data.sort(key=lambda x: (x['Surgery Date'], x.get('Patient Last', '').strip()))
+        
+        # Maybe make a dataformat_library function for this? csv_data = format_preprocessor(csv_data)?
+        for row in csv_data:
+            # Convert 'Surgery Date' back to string format if needed for further processing (cleanup)
+            row['Surgery Date'] = row['Surgery Date'].strftime('%m/%d/%Y')
+            
+            # Combine name fields
+            first_name = row.get('Patient First', '').strip()
+            middle_name = row.get('Patient Middle', '').strip()
+            last_name = row.get('Patient Last', '').strip()
+            row['Patient Name'] = "{}, {} {}".format(last_name, first_name, middle_name).strip()
+
+            # Combine address fields
+            address1 = row.get('Patient Address1', '').strip()
+            address2 = row.get('Patient Address2', '').strip()
+            row['Patient Street'] = "{} {}".format(address1, address2).strip()
+            
+            # Probably make a data_format function for this:
+            # Define the replacements as a dictionary
+            replacements = {
+                '777777777': '',  # Replace '777777777' with an empty string
+                'RAILROAD MEDICARE': 'RAILROAD',  # Replace 'RAILROAD MEDICARE' with 'RAILROAD'
+                'AARP MEDICARE COMPLETE': 'AARP COMPLETE'  # Replace 'AARP MEDICARE COMPLETE' with 'AARP COMPLETE'
+            }
+
+            # Iterate over each key-value pair in the replacements dictionary
+            for old_value, new_value in replacements.items():
+                # Replace the old value with the new value if it exists in the row
+                if row.get('Patient SSN', '') == old_value:
+                    row['Patient SSN'] = new_value
+                elif row.get('Primary Insurance', '') == old_value:
+                    row['Primary Insurance'] = new_value
+
+    except Exception as e:
+        print("An error occurred while pre-processing CSV data. Please repair the CSV directly and try again:", e)
+
+def check_existing_patients(selected_patient_ids, MAPAT_MED_PATH):
+    existing_patients = []
+    patients_to_process = list(selected_patient_ids)  # Clone the selected patient IDs list
+
+    try:
+        with open(MAPAT_MED_PATH, 'r') as file:
+            next(file)  # Skip header row
+            for line in file:
+                if line.startswith("0"): # 1 is a flag for a deleted record so it would need to be re-entered.
+                    patient_id = line[194:202].strip()  # Extract Patient ID (Columns 195-202)
+                    patient_name = line[9:39].strip()  # Extract Patient Name (Columns 10-39)
+                    
+                    if patient_id in selected_patient_ids:
+                        existing_patients.append((patient_id, patient_name))
+                        # Remove all occurrences of this patient_id from patients_to_process as a filter rather than .remove because 
+                        # then it only makes one pass and removes the first instance.
+    except FileNotFoundError:
+        # Handle the case where MAPAT_MED_PATH is not found
+        print("MAPAT.med was not found at location indicated in config file.")
+        print("Skipping existing patient check and continuing...")
+        
+    # Filter out all instances of existing patient IDs
+    patients_to_process = [id for id in patients_to_process if id not in [patient[0] for patient in existing_patients]]
+    
+    return existing_patients, patients_to_process
+
+def intake_scan(csv_headers, field_mapping):
+    identified_fields = OrderedDict()
+    missing_fields_warnings = []
+    required_fields = config["required_fields"]
+    
+    # Iterate over the Medisoft fields defined in field_mapping
+    for medisoft_field in field_mapping.keys():
+        for pattern in field_mapping[medisoft_field]:
+            matched_headers = [header for header in csv_headers if re.search(pattern, header, re.IGNORECASE)]
+            if matched_headers:
+                # Assuming the first matched header is the desired one
+                identified_fields[matched_headers[0]] = medisoft_field
+                break
+        else:
+            # Check if the missing field is a required field before appending the warning
+            if medisoft_field in required_fields:
+                missing_fields_warnings.append("WARNING: No matching CSV header found for Medisoft field '{0}'".format(medisoft_field))
+   
+   #-----------------------
+   # CSV Integrity Check
+   #-----------------------
+   
+   # This section needs to be revamped further so that it can interpret the information from here and decide 
+   # if it's significant or not.
+   # e.g. If the 'Street' value:key is 'Address', then any warnings about City, State, Zip can be ignored. 
+   # Insurance Policy Numbers should be all alphanumeric with no other characters. 
+   # Make sure that the name field has at least one name under it (basically check for a blank or 
+   # partially blank csv with just a header)
+      
+    # Display the identified fields and missing fields warnings
+    #print("The following Medisoft fields have been identified in the CSV:\n")
+    #for header, medisoft_field in identified_fields.items():
+    #    print("{0} (CSV header: {1})".format(medisoft_field, header))
+    
+    #if missing_fields_warnings:
+    #    print("\nSome required fields could not be matched:")
+    #    for warning in missing_fields_warnings:
+    #        print(warning)  
+
+    #print("Debug - Identified fields mapping (intake scan):", identified_fields)
+    return identified_fields

medicafe-0.240419.2/MediBot/MediBot_UI.py

@@ -0,0 +1,190 @@
+from sys import exit
+import ctypes
+from ctypes import wintypes
+import time
+import re
+import re  #for addresses
+from MediBot_Preprocessor import config
+
+"""
+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)
+
+MAPAT_MED_PATH = '' # Initialize global constant for MAPAT path
+MEDISOFT_SHORTCUT = '' # Initialize global constant for LNK path
+
+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):
+    global script_paused
+    #print("Debug - Entered manage_script_pause with pause status: {}".format(script_paused))
+    user_action = 0 # initialize as 'continue'
+    
+    if not script_paused and is_key_pressed(VK_PAUSE):
+        script_paused = 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 script_paused:
+        if is_key_pressed(VK_END):
+            script_paused = 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:02d}: {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)
+        selection = input("\nEnter the number(s) of the patients you wish to proceed with \n(e.g., 1,3,5): ")
+        selection = selection.replace('.', ',')  # Replace '.' with ',' in the user input just in case
+        selected_indices = [int(x.strip()) - 1 for x in selection.split(',')]  
+        proceed = True
+
+    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):
+    # Consider logging the actions taken during user interaction for audit purposes.
+    global MAPAT_MED_PATH, MEDISOFT_SHORTCUT # Initialize global constants
+    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:  # Check if the response is not empty
+                if response in ['yes', 'y']:
+                    proceed_as_medicare = True
+                    break
+                elif response in ['no', 'n']:
+                    proceed_as_medicare = False
+                    break
+                else:
+                    print("Invalid entry. Please enter 'yes' or 'no'.")
+            else:
+                print("A response is required. Please try again.")
+
+        MAPAT_MED_PATH = config.get('MEDICARE_MAPAT_MED_PATH', "") if proceed_as_medicare else config.get('MAPAT_MED_PATH', "")
+        MEDISOFT_SHORTCUT = config.get('MEDICARE_SHORTCUT', "") if proceed_as_medicare else config.get('PRIVATE_SHORTCUT', "")
+        
+        fixed_values = config.get('fixed_values', {})  # Get fixed values from config json 
+        if proceed_as_medicare:
+            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, proceed_as_medicare)
+        return proceed, selected_patient_ids, selected_indices, fixed_values
+    
+    return handle_user_interaction(interaction_mode, error_message)

medicafe-0.240419.2/MediBot/MediBot_dataformat_library.py

@@ -0,0 +1,145 @@
+import re
+from datetime import datetime
+import re  #for addresses
+from MediBot_Preprocessor import open_csv_for_editing, config, initialize
+from MediBot_UI import manage_script_pause
+
+# Bring in all the constants
+initialize(config)
+
+# Format Data
+def format_name(value):  
+    if ',' in value:
+        return value
+    hyphenated_name_pattern = r'(?P<First>[\w-]+)\s+(?P<Middle>[\w-]+)?\s+(?P<Last>[\w-]+)'
+    match = re.match(hyphenated_name_pattern, value)
+    if match:
+        first_name = match.group('First')
+        middle_name = match.group('Middle') or ''
+        last_name = match.group('Last')
+        return '{}, {} {}'.format(last_name, first_name, middle_name).strip()
+    parts = value.split()
+    return '{}, {}'.format(parts[-1], ' '.join(parts[:-1]))
+
+def format_date(value):
+    try:
+        date_obj = datetime.strptime(value, '%m/%d/%Y')
+        return date_obj.strftime('%m%d%Y')
+    except ValueError as e:
+        print("Date format error:", e)
+        return value
+
+def format_phone(value):
+    digits = ''.join(filter(str.isdigit, value))
+    if len(digits) == 10:
+        return digits
+    print("Phone number format error: Invalid number of digits")
+    return value
+
+def format_policy(value):
+    alphanumeric = ''.join(filter(str.isalnum, value))
+    return alphanumeric
+
+def format_gender(value):
+    return value[0].upper()
+
+def format_street(value, csv_data, reverse_mapping, parsed_address_components):
+    global script_paused
+    script_paused = False
+    
+    # Remove periods from the input (seems to be an XP-only issue?)
+    value = value.replace('.', '')
+    
+    # Only proceed with parsing if a comma is present in the value
+    if ',' in value:
+        try:
+            # Access the common cities from the loaded configuration
+            common_cities = config.get('cities', [])
+
+            # Convert cities to a case-insensitive regex pattern
+            city_pattern = '|'.join(re.escape(city) for city in common_cities)
+            city_regex_pattern = r'(?P<City>{})'.format(city_pattern)
+            city_regex = re.compile(city_regex_pattern, re.IGNORECASE)
+
+            # Check if the address contains one of the common cities
+            city_match = city_regex.search(value)
+                    
+            if city_match:
+                city = city_match.group('City').upper()  # Normalize city name to uppercase
+                street, _, remainder = value.partition(city)
+
+                # Extract state and zip code from the remainder
+                address_pattern = r',\s*(?P<State>[A-Z]{2})\s*(?P<Zip>\d{5}(?:-\d{4})?)?'
+
+                match = re.search(address_pattern, remainder)
+                    
+                if match:
+                    # Update global parsed address components
+                    parsed_address_components['City'] = city
+                    parsed_address_components['State'] = match.group('State')
+                    parsed_address_components['Zip Code'] = match.group('Zip')
+                    
+                    return street.strip()  # Return formatted street address
+            else:
+                # Fallback to old regex
+                # value = street + ', ' + city + remainder
+                address_pattern = r'(?P<Street>[\w\s]+),?\s+(?P<City>[\w\s]+),\s*(?P<State>[A-Z]{2})\s*(?P<Zip>\d{5}(-\d{4})?)'
+                match = re.match(address_pattern, value)
+
+                if match:
+                    # Update global parsed address components
+                    parsed_address_components['City'] = match.group('City')
+                    parsed_address_components['State'] = match.group('State')
+                    parsed_address_components['Zip Code'] = match.group('Zip')
+
+                    return match.group('Street').strip()  # Return formatted street address
+                    
+        except Exception as e:
+            print("Address format error: Unable to parse address '{}'. Error: {}".format(value, e))
+            print("Please update the CSV file for this record.")
+            script_paused = True
+            open_csv_for_editing(CSV_FILE_PATH)  # Offer to open the CSV for manual correction
+            manage_script_pause(csv_data, e, reverse_mapping) 
+            return value.replace(' ', '{Space}')  # Fallback to return original value with spaces escaped
+    else:
+        # If no comma is present, return the value as is, assuming it's just a street name
+        return value.replace(' ', '{Space}')
+    
+    # This return acts as a fallback in case the initial comma check passes but no address components are matched
+    return value.replace(' ', '{Space}')  
+
+def format_zip(value):
+    # Ensure the value is a string, in case it's provided as an integer
+    value_str = str(value)
+    # Return only the first 5 characters of the zip code
+    return value_str[:5]
+
+def format_data(medisoft_field, value, csv_data, reverse_mapping, parsed_address_components):
+    if medisoft_field == 'Patient Name':
+        formatted_value = format_name(value)
+    elif medisoft_field == 'Birth Date':
+        formatted_value = format_date(value)
+    elif medisoft_field == 'Phone':
+        formatted_value = format_phone(value)
+    elif medisoft_field == 'Phone #2':
+        formatted_value = format_phone(value)
+    elif medisoft_field == 'Gender':
+        formatted_value = format_gender(value)
+    elif medisoft_field == 'Street':
+        formatted_value = format_street(value, csv_data, reverse_mapping, parsed_address_components)
+    elif medisoft_field == 'Zip Code':
+        formatted_value = format_zip(value)
+    elif medisoft_field == 'Primary Policy Number':
+        formatted_value = format_policy(value)
+    elif medisoft_field == 'Secondary Policy Number':
+        formatted_value = format_policy(value)
+    elif medisoft_field == 'Primary Group Number':
+        formatted_value = format_policy(value)
+    elif medisoft_field == 'Secondary Group Number':
+        formatted_value = format_policy(value)
+    else:
+        formatted_value = value
+
+    formatted_value = formatted_value.replace(',', '{,}').replace(' ', '{Space}')
+    ahk_command = 'SendInput, {}{{Enter}}'.format(formatted_value)
+    return ahk_command

medicafe-0.240419.2/MediBot/MediPost.py

@@ -0,0 +1,5 @@
+"""
+Takes CSV from MediLink_Down.py and utilizes config and MediBot to post the CSV to Medisoft.
+This script now also processes ERAs and responses (277CA/277A) to update claims status and finalize billing records.
+Handles parsing and cleaning of input CSV files to ensure data accuracy and compliance with Medisoft requirements.
+"""