medicafe 0.240613.0__py3-none-any.whl → 0.240809.0__py3-none-any.whl

MediBot/MediBot.bat

@@ -11,6 +11,8 @@ set "medicafe_package=medicafe"
 set "upgrade_medicafe=F:\Medibot\update_medicafe.py"
 set "temp_file=F:\Medibot\last_update_timestamp.txt"
 set "firefox_path=C:\Program Files\Mozilla Firefox\firefox.exe"
+set "claims_status_script=..\MediLink\MediLink_ClaimStatus.py"
+set "deductible_script=..\MediLink\MediLink_Deductible.py"
 set "package_version="
 set PYTHONWARNINGS=ignore
 
@@ -99,14 +101,18 @@ if "!internet_available!"=="1" (
     echo 1. Check for MediCafe Package Updates
     echo 2. Download Email de Carol
     echo 3. MediLink Claims
+    echo 4. United Claims Status
+    echo 5. United Deductible
 )
-echo 4. Run MediBot
-echo 5. Exit
+echo 6. Run MediBot
+echo 7. Exit
 echo.
 set /p choice=Enter your choice:  
 
-if "!choice!"=="5" goto end_script
-if "!choice!"=="4" goto medibot_flow
+if "!choice!"=="7" goto end_script
+if "!choice!"=="6" goto medibot_flow
+if "!choice!"=="5" goto united_deductible
+if "!choice!"=="4" goto united_claims_status
 if "!choice!"=="3" goto medilink_flow
 if "!choice!"=="2" goto download_emails
 if "!choice!"=="1" goto check_updates
@@ -168,6 +174,32 @@ if errorlevel 1 echo MediLink failed to execute.
 pause
 goto main_menu
 
+:: United Claims Status
+:united_claims_status
+if "!internet_available!"=="0" (
+    echo No internet connection available.
+    goto main_menu
+)
+cls
+echo Checking United Claims Status...
+py "%claims_status_script%"
+if errorlevel 1 echo Failed to check United Claims Status.
+pause
+goto main_menu
+
+:: United Deductible
+:united_deductible
+if "!internet_available!"=="0" (
+    echo No internet connection available.
+    goto main_menu
+)
+cls
+echo Checking United Deductible...
+py "%deductible_script%"
+if errorlevel 1 echo Failed to check United Deductible.
+pause
+goto main_menu
+
 :: Process CSV Files
 :process_csvs
 for /f "tokens=1-5 delims=/: " %%a in ('echo %time%') do (
@@ -203,4 +235,4 @@ goto :eof
 :end_script
 echo Exiting MediCafe.
 pause
-exit /b
+exit /b

MediBot/MediBot.py

@@ -262,10 +262,21 @@ if __name__ == "__main__":
                 print("\nNOTE: The following patient(s) already EXIST in the system and \n      will be excluded from processing:")
                 # TODO ... not excluded anymore, because charges may need to be added. 
                 # So at this point in the processing, we should have already processed the surgery schedules and enriched the data with Charges.
+                # Find the corresponding rows in csv_data to get the surgery dates and store them along with patient info
+                patient_info = []
                 for patient_id, patient_name in existing_patients:
-                    print("(ID: {0}) {1}".format(patient_id, patient_name))
+                    surgery_date = next((row.get('Surgery Date', 'Unknown Date') for row in csv_data if row.get(reverse_mapping['Patient ID #2']) == patient_id), 'Unknown Date')
+                    patient_info.append((surgery_date, patient_name, patient_id))
+
+                # Sort by surgery date first and then by patient name
+                patient_info.sort(key=lambda x: (x[0], x[1]))
+
+                # Print the sorted patient info
+                for index, (surgery_date, patient_name, patient_id) in enumerate(patient_info):
+                    print("{0:03d}: {3:%m-%d} (ID: {2}) {1} ".format(index + 1, patient_name, patient_id, surgery_date))
+
                 # Update csv_data to exclude existing patients
-                # TODO This now has to be updated to handle patients that exist but need new charges added. 
+                # TODO This now has to be updated to handle patients that exist but need new charges added.
                 csv_data = [row for row in csv_data if row[reverse_mapping['Patient ID #2']] in patients_to_process]
             else:
                 print("\nSelected patient(s) are NEW patients and will be processed.")

MediBot/MediBot_Crosswalk_Library.py

@@ -14,10 +14,10 @@ except ImportError:
     from MediLink import MediLink_ConfigLoader
 
 try:
-    from MediLink_API_v2 import fetch_payer_name_from_api
+    from MediLink_API_v3 import fetch_payer_name_from_api
 except ImportError:
-    from MediLink import MediLink_API_v2
-    fetch_payer_name_from_api = MediLink_API_v2.fetch_payer_name_from_api
+    from MediLink import MediLink_API_v3
+    fetch_payer_name_from_api = MediLink_API_v3.fetch_payer_name_from_api
 
 try:
     from MediBot import MediBot_Preprocessor_lib
@@ -127,7 +127,7 @@ def initialize_crosswalk_from_mapat():
     validate_and_correct_payer_ids(crosswalk, config)
     
     # Save the initial crosswalk
-    if save_crosswalk(config['MediLink_Config']['crosswalkPath'], crosswalk):
+    if save_crosswalk(config, crosswalk):
         message = "Crosswalk initialized with mappings for {} payers.".format(len(crosswalk.get('payer_id', {})))
         print(message)
         MediLink_ConfigLoader.log(message, config, level="INFO")
@@ -197,7 +197,7 @@ def crosswalk_update(config, crosswalk):
             crosswalk['payer_id'][payer_id]['medisoft_medicare_id'] = list(crosswalk['payer_id'][payer_id]['medisoft_medicare_id'])
             
     # Save the updated crosswalk to the specified file
-    return save_crosswalk(config['MediLink_Config']['crosswalkPath'], crosswalk)
+    return save_crosswalk(config, crosswalk)
 
 def update_crosswalk_with_corrected_payer_id(old_payer_id, corrected_payer_id, config, crosswalk):
     """Updates the crosswalk with the corrected payer ID."""
@@ -216,7 +216,7 @@ def update_crosswalk_with_corrected_payer_id(old_payer_id, corrected_payer_id, c
     MediLink_ConfigLoader.log("Crosswalk csv_replacements updated: added {} -> {}".format(old_payer_id, corrected_payer_id), config, level="INFO")
     
     # Save the updated crosswalk
-    return save_crosswalk(config['MediLink_Config']['crosswalkPath'], crosswalk)
+    return save_crosswalk(config, crosswalk)
 
 def update_crosswalk_with_new_payer_id(insurance_name, payer_id, config):
     """Updates the crosswalk with a new payer ID."""
@@ -229,14 +229,14 @@ def update_crosswalk_with_new_payer_id(insurance_name, payer_id, config):
             crosswalk['payer_id'][payer_id] = {"medisoft_id": [medisoft_id_str], "medisoft_medicare_id": []}
         else:
             crosswalk['payer_id'][payer_id]['medisoft_id'].append(medisoft_id_str)
-        save_crosswalk(config['MediLink_Config']['crosswalkPath'], crosswalk)
+        save_crosswalk(config, crosswalk)
         MediLink_ConfigLoader.log("Updated crosswalk with new payer ID {} for insurance name {}".format(payer_id, insurance_name), config, level="INFO")
     else:
         message = "Failed to update crosswalk: Medisoft ID not found for insurance name {}".format(insurance_name)
         print(message)
         MediLink_ConfigLoader.log(message, config, level="ERROR")
         
-def save_crosswalk(crosswalk_path, crosswalk):
+def save_crosswalk(config, crosswalk):
     """
     Saves the updated crosswalk to a JSON file.
     Args:
@@ -245,6 +245,13 @@ def save_crosswalk(crosswalk_path, crosswalk):
     Returns:
         bool: True if the file was successfully saved, False otherwise.
     """
+    # Attempt to fetch crosswalkPath from MediLink_Config
+    try:
+        crosswalk_path = config['MediLink_Config']['crosswalkPath']
+    except KeyError:
+        # If KeyError occurs, fall back to fetching crosswalkPath directly
+        crosswalk_path = config.get('crosswalkPath', None)  # Replace None with a default value if needed
+
     try:
         # Initialize 'payer_id' key if not present
         if 'payer_id' not in crosswalk:

MediBot/MediBot_Preprocessor_lib.py

@@ -124,7 +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.
+    # TODO Sorting, now that we're going to have the Surgery Schedules available, should (or shouldn't?? 
+    # maybe we should build in the option as liek a 'setting' in the config) 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()))
 
@@ -161,7 +162,16 @@ def update_insurance_ids(csv_data, crosswalk):
                 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
+                    # TODO Try to match OpenPM's Insurance Name to get a better match. 
+                    # Potential approach:
+                    # 1. Retrieve the insurance name from the current row
+                    # insurance_name = row.get('Primary Insurnace', '').strip()
+                    # 2. Check if the insurance name exists in the subset of MAINS names associated with 
+                    # crosswalk medisoft ID values for the given payer ID.
+                    # 3. If an approximate match is found above a certain confidence, use the corresponding medisoft_id.
+                    # else: 4. If no match is found, default to the first medisoft_id
+                    #     row['Ins1 Insurance ID'] = medisoft_ids[0]
+                    
                     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:
@@ -367,6 +377,8 @@ def load_insurance_data_from_mains(config):
     # 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.
+    # Meh, this just has to be part of the new architecture plan where we make Medisoft a downstream 
+    # recipient from the db.
     mains_path = config['MAINS_MED_PATH']
     mains_slices = crosswalk['mains_mapping']['slices']
     

MediBot/MediBot_docx_decoder.py

@@ -238,10 +238,19 @@ def parse_patient_id(text):
 
 def parse_diagnosis_code(text):
     try:
-        if '(' in text and ')' in text:  # Extract the diagnosis code before the '/'
-            full_code = text[text.index('(')+1:text.index(')')]
-            return full_code.split('/')[0]
-        return text.split('/')[0]
+        # Regular expression to find all ICD-10 codes starting with 'H' and containing a period
+        pattern = re.compile(r'H\d{2}\.\d+')
+        matches = pattern.findall(text)
+        
+        if matches:
+            return matches[0]  # Return the first match
+        else:
+            # Fallback to original method if no match is found
+            if '(' in text and ')' in text:  # Extract the diagnosis code before the '/'
+                full_code = text[text.index('(')+1:text.index(')')]
+                return full_code.split('/')[0]
+            return text.split('/')[0]
+    
     except Exception as e:
         MediLink_ConfigLoader.log("Error parsing diagnosis code: {}. Error: {}".format(text, e))
         return "Unknown"
@@ -268,7 +277,6 @@ def parse_femto_yes_or_no(text):
         MediLink_ConfigLoader.log("Error parsing femto yes or no: {}. Error: {}".format(text, e))
         return False
 
-
 def rotate_docx_files(directory):
     # List all files in the directory
     files = os.listdir(directory)

MediLink/MediLink.py

@@ -2,7 +2,6 @@ import os
 import MediLink_Down
 import MediLink_Up
 import MediLink_ConfigLoader
-import MediLink_837p_encoder
 import MediLink_DataMgmt
 
 # For UI Functions
@@ -19,73 +18,31 @@ from MediBot import MediBot_Preprocessor_lib
 load_insurance_data_from_mains = MediBot_Preprocessor_lib.load_insurance_data_from_mains
 from MediBot import MediBot_Crosswalk_Library
 
-# Define insurance options with codes and descriptions. 
-# TODO This needs to move to the config file
-insurance_options = {
-    "11": "Other Non-Federal Programs",
-    "12": "Preferred Provider Organization (PPO)",
-    "13": "Point of Service (POS)",
-    "14": "Exclusive Provider Organization (EPO)",
-    "15": "Indemnity Insurance",
-    "16": "Health Maintenance Organization (HMO) Medicare Risk",
-    "17": "Dental Maintenance Organization",
-    "AM": "Automobile Medical",
-    "BL": "Blue Cross/Blue Shield",
-    "CH": "Champus",
-    "CI": "Commercial Insurance Co.",
-    "DS": "Disability",
-    "FI": "Federal Employees Program",
-    "HM": "Health Maintenance Organization",
-    "LM": "Liability Medical",
-    "MA": "Medicare Part A",
-    "MB": "Medicare Part B",
-    "MC": "Medicaid",
-    "OF": "Other Federal Program",
-    "TV": "Title V",
-    "VA": "Veterans Affairs Plan",
-    "WC": "Workers Compensation Health Claim",
-    "ZZ": "Mutually Defined"
-}
-
-def detect_and_display_file_summaries(directory_path, config, crosswalk):
+# Retrieve insurance options with codes and descriptions
+config, _ = MediLink_ConfigLoader.load_configuration()
+insurance_options = config['MediLink_Config'].get('insurance_options')
+    
+def collect_detailed_patient_data(selected_files, config, crosswalk):
     """
-    Detects new files in the specified directory and prepares detailed patient data for processing,
-    including suggestions for endpoints based on insurance provider information found in the config.
+    Collects detailed patient data from the selected files.
     
-    :param directory_path: Path to the directory containing files to be detected.
+    :param selected_files: List of selected file paths.
     :param config: Configuration settings loaded from a JSON file.
     :param crosswalk: Crosswalk data for mapping purposes.
-    :return: A tuple containing a list of new file paths and the detailed patient data.
+    :return: A list of detailed patient data.
     """
-    try:
-        new_files, file_flagged = MediLink_DataMgmt.detect_new_files(directory_path)
-        if not new_files:
-            print("No new claims detected. Check Medisoft claims output.")
-            MediLink_ConfigLoader.log("No new claims detected. Check Medisoft claims output.")
-            return False, []
-        
-        if not file_flagged:
-            selected_files = MediLink_UI.user_select_files(new_files)
-        else:
-            # Extract the newest single latest file from the list
-            selected_files = [max(new_files, key=os.path.getctime)]
-        
-        detailed_patient_data = []  # Initialize list for detailed patient data
-        for file_path in selected_files:
-            detailed_data = extract_and_suggest_endpoint(file_path, config, crosswalk)
-            detailed_patient_data.extend(detailed_data)  # Accumulate detailed data for processing
-            
-        # Enrich the detailed patient data with insurance type
-        detailed_patient_data = enrich_with_insurance_type(detailed_patient_data, insurance_options)
+    detailed_patient_data = []
+    for file_path in selected_files:
+        detailed_data = extract_and_suggest_endpoint(file_path, config, crosswalk)
+        detailed_patient_data.extend(detailed_data)  # Accumulate detailed data for processing
         
-        # Display summaries and provide an option for bulk edit
-        MediLink_UI.display_patient_summaries(detailed_patient_data)
+    # Enrich the detailed patient data with insurance type
+    detailed_patient_data = enrich_with_insurance_type(detailed_patient_data, insurance_options)
+    
+    # Display summaries and provide an option for bulk edit
+    MediLink_UI.display_patient_summaries(detailed_patient_data)
 
-        # Return the list of new files and the enriched detailed patient data
-        return selected_files, detailed_patient_data
-    except Exception as e:
-        MediLink_ConfigLoader.log("Error in detect_and_display_file_summaries: {}".format(e))
-        return False, []
+    return detailed_patient_data
 
 def enrich_with_insurance_type(detailed_patient_data, patient_insurance_type_mapping=None):
     """
@@ -101,7 +58,7 @@ def enrich_with_insurance_type(detailed_patient_data, patient_insurance_type_map
     TODO: Implement a function to provide `patient_insurance_mapping` from a reliable source.
     """
     if patient_insurance_type_mapping is None:
-        MediLink_ConfigLoader.log("No Patient:Insurance-Type mapping available.")
+        MediLink_ConfigLoader.log("No Patient:Insurance-Type mapping available.", level="WARNING")
         patient_insurance_type_mapping = {}
     
     for data in detailed_patient_data:
@@ -129,7 +86,7 @@ def extract_and_suggest_endpoint(file_path, config, crosswalk):
     
     # Load insurance data from MAINS to create a mapping from insurance names to their respective IDs
     insurance_to_id = load_insurance_data_from_mains(config)
-    MediLink_ConfigLoader.log("Insurance data loaded from MAINS. {} insurance providers found.".format(len(insurance_to_id)))
+    MediLink_ConfigLoader.log("Insurance data loaded from MAINS. {} insurance providers found.".format(len(insurance_to_id)), level="INFO")
 
     for personal_info, insurance_info, service_info, service_info_2, service_info_3 in MediLink_DataMgmt.read_fixed_width_data(file_path):
         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))
@@ -191,13 +148,13 @@ def check_for_new_remittances(config):
                 try:
                     ERA_path = MediLink_Down.main(desired_endpoint=endpoint_key)
                     processed_endpoints.append((endpoint_info['name'], ERA_path))
-                    MediLink_ConfigLoader.log("Results for {} saved to: {}".format(endpoint_info['name'], ERA_path))
+                    MediLink_ConfigLoader.log("Results for {} saved to: {}".format(endpoint_info['name'], ERA_path), level="DEBUG")
                     # TODO (Low SFTP - Download side) This needs to check to see if this actually worked maybe winscplog before saying it completed successfully 
                     # Check if there is commonality with the upload side so we can use the same validation function.
                 except Exception as e:
                     print("An error occurred while checking remittances for {}: {}".format(endpoint_info['name'], e))
             else:
-                MediLink_ConfigLoader.log("Skipping endpoint '{}' as it does not have 'remote_directory_down' configured.".format(endpoint_info['name']))
+                MediLink_ConfigLoader.log("Skipping endpoint '{}' as it does not have 'remote_directory_down' configured.".format(endpoint_info['name']), level="WARNING")
     else:
         print("Error: Endpoint config is not a 'dictionary' as expected.")
     # Check if all ERA paths are the same
@@ -299,17 +256,14 @@ def main_menu():
     # Normalize the directory path for file operations.
     directory_path = os.path.normpath(config['MediLink_Config']['inputFilePath'])
 
-    # Detect new files and collect detailed patient data if available.
-    new_files, detailed_patient_data = detect_and_display_file_summaries(directory_path, config, crosswalk)
-    
-    if new_files:
-        handle_submission(detailed_patient_data, config)
+    # Detect files and determine if a new file is flagged.
+    all_files, file_flagged = MediLink_DataMgmt.detect_new_files(directory_path)
 
     while True:
         # Define the menu options. Base options include checking remittances and exiting the program.
         options = ["Check for new remittances", "Exit"]
-        # If new files are detected, add the option to submit claims.
-        if new_files:
+        # If any files are detected, add the option to submit claims.
+        if all_files:
             options.insert(1, "Submit claims")
 
         # Display the dynamically adjusted menu options.
@@ -320,11 +274,22 @@ def main_menu():
         if choice == '1':
             # Handle remittance checking.
             check_for_new_remittances(config)
-        elif choice == '2' and new_files:
-            # Handle the claims submission flow if new files are present.
-            handle_submission(detailed_patient_data, config) # Since we have the bulk edit, we should actually go there first 
-        elif choice == '3' or (choice == '2' and not new_files):
-            # Exit the program if the user chooses to exit or if no new files are present.
+        elif choice == '2' and all_files:
+            # Handle the claims submission flow if any files are present.
+            if file_flagged:
+                # Extract the newest single latest file from the list if a new file is flagged.
+                selected_files = [max(all_files, key=os.path.getctime)]
+            else:
+                # Prompt the user to select files if no new file is flagged.
+                selected_files = MediLink_UI.user_select_files(all_files)
+
+            # Collect detailed patient data for selected files.
+            detailed_patient_data = collect_detailed_patient_data(selected_files, config, crosswalk)
+            
+            # Process the claims submission.
+            handle_submission(detailed_patient_data, config)
+        elif choice == '3' or (choice == '2' and not all_files):
+            # Exit the program if the user chooses to exit or if no files are present.
             MediLink_UI.display_exit_message()
             break
         else:

MediLink/MediLink_837p_encoder.py

@@ -77,33 +77,27 @@ def format_single_claim(patient_data, config, endpoint, transaction_set_control_
 
     return formatted_837p
 
-def write_output_file(document_segments, output_directory, endpoint_key, input_file_path, config):
+def write_output_file(document_segments, output_directory, endpoint_key, input_file_path, config, suffix=""):
     """
     Writes formatted 837P document segments to an output file with a dynamically generated name.
-    
-    Development Roadmap:
-    - Ensure input `document_segments` is a non-empty list to avoid creating empty files.
-    - Verify `output_directory` exists and is writable before proceeding. Create the directory if it does not exist.
-    - Consider parameterizing the file naming convention or providing options for customization to accommodate different organizational needs.
-    - Implement error handling to gracefully manage file writing failures, potentially returning a status or error message alongside the file path.
-    - Incorporate logging directly within the function, accepting an optional `config` or `logger` parameter to facilitate tracking of the file writing process and outcomes.
-    - Update the return value to include both the path to the output file and any relevant status information (e.g., success flag, error message) to enhance downstream error handling and user feedback.
-    
+
     Parameters:
     - document_segments: List of strings, where each string is a segment of the 837P document to be written.
     - output_directory: String specifying the directory where the output file will be saved.
     - endpoint_key: String specifying the endpoint for which the claim is processed, used in naming the output file.
     - input_file_path: String specifying the path to the input file being processed, used in naming the output file.
-    
+    - config: Configuration settings for logging and other purposes.
+    - suffix: Optional string to differentiate filenames, useful for single-patient processing.
+
     Returns:
-    - String specifying the path to the successfully created output file. Consider returning a tuple (path, status) for enhanced error handling.
+    - String specifying the path to the successfully created output file, or None if an error occurred.
     """
-    # Check if document segments are empty
+    # Ensure the document segments are not empty
     if not document_segments:
         MediLink_ConfigLoader.log("Error: Empty document segments provided. No output file created.", config, level="ERROR")
         return None
     
-    # Check if the output directory exists and is writable
+    # Verify the output directory exists and is writable, create if necessary
     if not os.path.exists(output_directory):
         try:
             os.makedirs(output_directory)
@@ -114,13 +108,13 @@ def write_output_file(document_segments, output_directory, endpoint_key, input_f
         MediLink_ConfigLoader.log("Error: Output directory is not writable.", config, level="ERROR")
         return None
     
-    # Generate new output file path
+    # Generate the new output file path
     base_name = os.path.splitext(os.path.basename(input_file_path))[0]
     timestamp = datetime.now().strftime("%m%d%H%M")
-    new_output_file_name = "{}_{}_{}.txt".format(base_name, endpoint_key.lower(), timestamp)
+    new_output_file_name = "{}_{}_{}{}.txt".format(base_name, endpoint_key.lower(), timestamp, suffix)
     new_output_file_path = os.path.join(output_directory, new_output_file_name)
 
-    # Write formatted 837P document to the output file
+    # Write the document to the output file
     try:
         with open(new_output_file_path, 'w') as output_file:
             output_file.write('\n'.join(document_segments))
@@ -335,7 +329,7 @@ def main():
     parser.add_argument(
         "-e", "--endpoint", 
         required=True,
-        choices=["AVAILITY", "OPTUMEDI", "PNT_DATA"],
+        choices=["AVAILITY", "OPTUMEDI", "PNT_DATA", "UHCAPI"],
         help="Specify the endpoint for which the conversion is intended."
     )
     parser.add_argument(
@@ -388,9 +382,9 @@ if __name__ == "__main__":
 #######################################################################################
 
 def convert_files_for_submission(detailed_patient_data, config):
-    """    
+    """
     Processes detailed patient data for submission based on their confirmed endpoints,
-    generating a separate 837P file for each endpoint.
+    generating separate 837P files for each endpoint according to the configured submission type.
 
     Parameters:
     - detailed_patient_data: A list containing detailed patient data with endpoint information.
@@ -398,73 +392,93 @@ def convert_files_for_submission(detailed_patient_data, config):
 
     Returns:
     - A list of paths to the converted files ready for submission.
+
+    Note:
+    - This function currently supports batch and single-patient submissions based on the configuration.
+    - Future implementation may include progress tracking using tools like `tqdm`.
     """
 
     # Initialize a dictionary to hold patient data segregated by confirmed endpoints
     data_by_endpoint = {}
-        
-    # Populate the dictionary with patient data
+
+    # Group patient data by endpoint
     for data in detailed_patient_data:
-        endpoint = data['confirmed_endpoint']
-        if endpoint not in data_by_endpoint:
-            data_by_endpoint[endpoint] = []
-        data_by_endpoint[endpoint].append(data)
+        endpoint = data.get('confirmed_endpoint')
+        if endpoint:
+            if endpoint not in data_by_endpoint:
+                data_by_endpoint[endpoint] = []
+            data_by_endpoint[endpoint].append(data)
 
     # List to store paths of converted files for each endpoint
     converted_files_paths = []
 
-    # Determine the total number of unique endpoints for progress bar
-    # total_endpoints = len(data_by_endpoint)
-
     # Iterate over each endpoint and process its corresponding patient data
     for endpoint, patient_data_list in data_by_endpoint.items():
-        # tqdm(data_by_endpoint.items(), desc="Creating 837p(s)", total=total_endpoints, ascii=True)
-        # Each endpoint might have multiple patients' data to be processed into a single 837P file
-        if patient_data_list:
-            converted_path = process_claim(config['MediLink_Config'], endpoint, patient_data_list)
+        # Retrieve submission type from config; default to "batch" if not specified
+        submission_type = config.get('MediLink_Config', {}).get('endpoints', {}).get(endpoint, {}).get('submission_type', 'batch')
+
+        if submission_type == 'single':
+            # Process each patient's data individually for single-patient submissions
+            for patient_data in patient_data_list:
+                # Generate a unique suffix for each patient, e.g., using a truncated chart number
+                chart_number = patient_data.get('CHART', 'UNKNOWN')#[:5] truncation might cause collisions.
+                suffix = "_{}".format(chart_number)
+                # Process and convert each patient's data to a separate file
+                converted_path = process_claim(config, endpoint, [patient_data], suffix)
+                if converted_path:
+                    converted_files_paths.append(converted_path)
+        else:
+            # Process all patient data together for batch submissions
+            converted_path = process_claim(config, endpoint, patient_data_list)
             if converted_path:
                 converted_files_paths.append(converted_path)
-        
+
     return converted_files_paths
 
-def process_claim(config, endpoint, patient_data_list):
+def process_claim(config, endpoint, patient_data_list, suffix=""):
     """
     Processes patient data for a specified endpoint, converting it into the 837P format.
-    Generates a separate 837P file for each endpoint based on detailed patient data.
+    Can handle both batch and single-patient submissions.
 
     Parameters:
     - config: Configuration settings loaded from a JSON file.
-    - endpoint_key: The key representing the endpoint for which the data is being processed.
+    - endpoint: The key representing the endpoint for which the data is being processed.
     - patient_data_list: A list of dictionaries, each containing detailed patient data.
+    - suffix: An optional suffix to differentiate filenames for single-patient processing.
 
     Returns:
     - Path to the converted file, or None if an error occurs.
-    
-    TODO (LOW) Why are there duplicated interchange flows? Because the arg if we're doing a .dat directory or not. 
-    Although, that shouldn't be making duplicates of these interchange headers. That's still confusing and could end up making 
-    duplicate interchange headers because processing .dat in batch might be fast enough to be a problem.
     """
+    # Ensure we're accessing the correct configuration key
+    config = config.get('MediLink_Config', config)
+    
+    # Retrieve the output directory from the configuration
     output_directory = MediLink_837p_encoder_library.get_output_directory(config)
     if not output_directory:
         return None
 
-    # Initialize the transaction set control number and document segments
     transaction_set_control_number = 1
     document_segments = []
 
-    # Process each patient's data in the list
     for patient_data in patient_data_list:
-        # Validate each patient's data
+        # Validate each patient's data before processing
         is_valid, validation_errors = validate_claim_data(patient_data, config)
         if is_valid:
-            # Format the claim if data is valid
+            # Format the claim into 837P segments
             formatted_claim = format_single_claim(patient_data, config, endpoint, transaction_set_control_number)
             document_segments.append(formatted_claim)
             transaction_set_control_number += 1
         else:
+            # Log any validation errors encountered
+            MediLink_ConfigLoader.log("Validation errors for patient data: {}".format(validation_errors), config, level="ERROR")
             if MediLink_837p_encoder_library.handle_validation_errors(transaction_set_control_number, validation_errors, config):
                 continue # Skip the current patient
 
+    if not document_segments:
+        # If no valid segments were created, log the issue and return None
+        MediLink_ConfigLoader.log("No valid document segments created.", config, level="ERROR")
+        return None
+
     # Create interchange elements with the final transaction set control number
     isa_header, gs_header, ge_trailer, iea_trailer = MediLink_837p_encoder_library.create_interchange_elements(config, endpoint, transaction_set_control_number - 1)
 
@@ -473,5 +487,8 @@ def process_claim(config, endpoint, patient_data_list):
     document_segments.insert(0, isa_header)
     document_segments.extend([ge_trailer, iea_trailer])
 
-    # Write the complete 837P document to an output file and return its path
-    return write_output_file(document_segments, output_directory, endpoint, patient_data_list[0]['file_path'], config)
+    # Use the first patient's file path as a reference for output file naming
+    input_file_path = patient_data_list[0].get('file_path', 'UNKNOWN')
+    # Write the complete 837P document to an output file
+    converted_file_path = write_output_file(document_segments, output_directory, endpoint, input_file_path, config, suffix)
+    return converted_file_path