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

MediLink/MediLink_837p_encoder.py

@@ -2,36 +2,35 @@ import re
 from datetime import datetime
 import argparse
 import os
-import MediLink_837p_encoder_library
 import MediLink_ConfigLoader
 from MediLink_DataMgmt import parse_fixed_width_data, read_fixed_width_data
+import MediLink_837p_encoder_library
 #from tqdm import tqdm
 
 """
-Development Task List:
+Single File Processing Flow:
 
-1. File Path Management: Enhance the handling of input paths to efficiently manage both individual files and directories, accommodating a range of file processing scenarios.
-2. User Interface Improvement: Advance the CLI for intuitive user interaction, offering clear options for file processing and real-time progress updates.
-3. Validation and Logging: Strengthen validation processes for input data, incorporating thorough checks against business rules and enhanced detailed logging for improved traceability and troubleshooting.
-4. Batch Processing and Output Handling: Enhance output file management to support efficient batch operations, including systematic naming and organization for output files.
-5. Comprehensive Documentation: Maintain up-to-date and detailed documentation within the codebase, ensuring all functions and complex logic are clearly explained.
-6. De-persisting Intermediate Files.
-"""
-def create_interchange_elements(config, endpoint, transaction_set_control_number):
-    """
-    Create interchange headers and trailers for an 837P document.
+This flow is triggered when the -d (directory) flag is not set. It handles the conversion of a single file specified by the -p flag.
+It directly processes the single file specified, without the need to iterate over a directory.
+The conversion initializes and processes this single file, appending the necessary EDI segments, and directly writes the output once processing is complete.
 
-    Parameters:
-    - config: Configuration settings loaded from a JSON file.
-    - endpoint_key: The endpoint for which the data is being processed.
-    - transaction_set_control_number: The starting transaction set control number.
+Batch Directory Processing Flow:
 
-    Returns:
-    - Tuple containing (ISA header, GS header, GE trailer, IEA trailer).
-    """
-    isa_header, gs_header = MediLink_837p_encoder_library.create_interchange_header(config, endpoint)
-    ge_trailer, iea_trailer = MediLink_837p_encoder_library.create_interchange_trailer(config, endpoint, transaction_set_control_number)
-    return isa_header, gs_header, ge_trailer, iea_trailer
+Activated when the -d flag is set, indicating that the -p flag points to a directory rather than a single file.
+Iterates over all files in the specified directory, processing only those that end with the ".DAT" extension.
+Each file is processed in sequence, with each undergoing a full cycle of reading, processing, and output file generation as in the single file flow.
+
+Development Task List:
+
+- [ ] 1. File Path Management: Enhance the handling of input paths to efficiently manage both individual files and directories, accommodating a range of file processing scenarios.
+- [ ] 2. User Interface Improvement: Advance the CLI for intuitive user interaction, offering clear options for file processing and real-time progress updates.
+- [ ] 3. Validation and Logging: Strengthen validation processes for input data, incorporating thorough checks against business rules and enhanced detailed logging for improved traceability and troubleshooting.
+- [ ] 4. Batch Processing and Output Handling: Enhance output file management to support efficient batch operations, including systematic naming and organization for output files.
+- [ ] 5. Comprehensive Documentation: Maintain up-to-date and detailed documentation within the codebase, ensuring all functions and complex logic are clearly explained.
+- [ ] 6. De-persisting Intermediate Files.
+- [ ] 7. Determination of Relationship to Patient for insurance holder. Can Compare Insured Name & closeness of DOB (usually spouse [2], child [3]). 
+- [ ] 8. Consolidation of certain functions needs to happen here.
+"""
 
 def format_single_claim(patient_data, config, endpoint, transaction_set_control_number):
     """
@@ -46,6 +45,9 @@ def format_single_claim(patient_data, config, endpoint, transaction_set_control_
     Returns:
     - String representation of the formatted 837P claim.
     """
+    # Pre-resolve and enrich with Payer Name and ID for special case handling like Florida Blue.
+    patient_data = MediLink_837p_encoder_library.payer_id_to_payer_name(patient_data, config, endpoint)
+    
     segments = []
         
     # Initialize with standard segments for all claims
@@ -53,7 +55,7 @@ def format_single_claim(patient_data, config, endpoint, transaction_set_control_
     segments.append(MediLink_837p_encoder_library.create_bht_segment(patient_data))
 
     # Submitter Name Segment and PER Contact Information (1000A Loop)
-    segments.extend(MediLink_837p_encoder_library.create_1000A_submitter_name_segment(config, endpoint))
+    segments.extend(MediLink_837p_encoder_library.create_1000A_submitter_name_segment(patient_data, config, endpoint))
     
     # Receiver Name Segment (1000B Loop)
     segments.extend([MediLink_837p_encoder_library.create_1000B_receiver_name_segment(config, endpoint)])
@@ -76,7 +78,10 @@ def format_single_claim(patient_data, config, endpoint, transaction_set_control_
     segments.append(MediLink_837p_encoder_library.create_dmg_segment(patient_data))
     
     # Payer information (2010BB loop)
-    segments.extend([MediLink_837p_encoder_library.create_2010BB_payer_information_segment(patient_data, config, endpoint)])
+    # TODO This function now includes detailed outputs and potential user interactions with the new implementation.
+    # The new implementation introduces user inputs directly in the flow, which could disrupt automated batch processes. 
+    # Ensure that there are mechanisms or workflows in place to handle such interruptions appropriately.
+    segments.extend([MediLink_837p_encoder_library.create_2010BB_payer_information_segment(patient_data)])
     #segments.extend(MediLink_837p_encoder_library.create_payer_address_segments(config)) OMITTED
     
     # Rendering Provider (2310B Loop)
@@ -92,8 +97,8 @@ def format_single_claim(patient_data, config, endpoint, transaction_set_control_
     formatted_837p = MediLink_837p_encoder_library.generate_segment_counts('\n'.join(filter(None, segments)), transaction_set_control_number)
 
     # Optionally, print or log the formatted 837P for debugging or verification
-    # BUG Add chart number to this.
-    MediLink_837p_encoder_library.log("Formatted 837P for endpoint {}.".format(endpoint), config, level="INFO")
+    # TODO (Low UI/usability) Add chart number to this.
+    MediLink_ConfigLoader.log("Formatted 837P for endpoint {}.".format(endpoint), config, level="INFO")
 
     return formatted_837p
 
@@ -118,194 +123,217 @@ def write_output_file(document_segments, output_directory, endpoint_key, input_f
     Returns:
     - String specifying the path to the successfully created output file. Consider returning a tuple (path, status) for enhanced error handling.
     """
-    formatted_837p = '\n'.join(document_segments)
+    # Check if document segments are 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
+    if not os.path.exists(output_directory):
+        try:
+            os.makedirs(output_directory)
+        except OSError as e:
+            MediLink_ConfigLoader.log("Error: Failed to create output directory. {}".format(e), config, level="ERROR")
+            return None
+    elif not os.access(output_directory, os.W_OK):
+        MediLink_ConfigLoader.log("Error: Output directory is not writable.", config, level="ERROR")
+        return None
+    
+    # Generate 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_path = os.path.join(output_directory, new_output_file_name)
 
-    with open(new_output_file_path, 'w') as output_file:
-        output_file.write(formatted_837p)
-
-    # need to pass config here. for what?   
-    # BUG Validate that the output file path has no spaces in it, Unless this is no issue (skip)
-    MediLink_837p_encoder_library.log("Successfully converted and saved to {}".format(new_output_file_path), config, level="INFO")
-    
-    return new_output_file_path
+    # Write formatted 837P document to the output file
+    try:
+        with open(new_output_file_path, 'w') as output_file:
+            output_file.write('\n'.join(document_segments))
+        MediLink_ConfigLoader.log("Successfully converted and saved to {}".format(new_output_file_path), config, level="INFO")
+        return new_output_file_path
+    except Exception as e:
+        MediLink_ConfigLoader.log("Error: Failed to write output file. {}".format(e), config, level="ERROR")
+        return None
 
 def process_file(file_path, config, endpoint_key, transaction_set_control_number):
     """
-    Reads, validates, and formats claim data from a given file into the 837P format.
+    Process the claim data from a file into the 837P format.
+
+    Args:
+        file_path (str): The path to the file containing the claim data.
+        config (dict): Configuration settings loaded from a JSON file.
+        endpoint_key (str): The key representing the endpoint for which the claim is being processed.
+        transaction_set_control_number (int): The starting transaction set control number for 837P segments.
 
-    :param file_path: The path to the file containing claim data.
-    :param config: Configuration settings loaded from a JSON file.
-    :param endpoint_key: The key representing the endpoint for which the claim is being processed.
-    :param transaction_set_control_number: The starting transaction set control number for 837P segments.
-    :return: A tuple containing the formatted claim segments and the next transaction set control number.
+    Returns:
+        tuple: A tuple containing the formatted claim segments and the next transaction set control number.
     """
-    formatted_claims = []
+    valid_claims, validation_errors = read_and_validate_claims(file_path, config)
     
-    for personal_info, insurance_info, service_info in read_fixed_width_data(file_path, config):
-        # Parse and validate claim data
-        parsed_data = parse_fixed_width_data(personal_info, insurance_info, service_info, config)
-        
-        # Assume validate_claim_data is a function that validates the parsed data
-        # DISABLED
-        #if not validate_claim_data(parsed_data, config):
-        #    MediLink_837p_encoder_library.log("Validation failed for claim data in file: {}".format(file_path), config, level="ERROR")
-        #    continue  # Skip invalid claims
-
-        # Format the claim into 837P segments
-        formatted_claim = format_single_claim(parsed_data, config, endpoint_key, transaction_set_control_number)
-        formatted_claims.append(formatted_claim)
-        transaction_set_control_number += 1  # Increment for each successfully processed claim
+    # Handle validation errors
+    if validation_errors:
+        if not MediLink_837p_encoder_library.handle_validation_errors(transaction_set_control_number, validation_errors, config):
+            return None, transaction_set_control_number  # Halt processing if the user chooses
 
-    # Combine all formatted claims into a single string to be appended to the document segments
-    formatted_claims_str = '\n'.join(formatted_claims)
-        
+    # Process each valid claim
+    formatted_claims, transaction_set_control_number = format_claims(valid_claims, config, endpoint_key, transaction_set_control_number)
+
+    formatted_claims_str = '\n'.join(formatted_claims)  # Join formatted claims into a single string
     return formatted_claims_str, transaction_set_control_number
 
-def winscp_validate_output_directory(output_directory):
+def read_and_validate_claims(file_path, config):
     """
-    Validates the output directory path to ensure it has no spaces.
-    If spaces are found, prompts the user to input a new path.
-    If the directory doesn't exist, creates it.
-    """
-    while ' ' in output_directory:
-        print("\nWARNING: The output directory path contains spaces, which can cause issues with upload operations.")
-        print("    Current proposed path: {}".format(output_directory))
-        new_path = input("Please enter a new path for the output directory: ")
-        output_directory = new_path.strip()  # Remove leading/trailing spaces
-    
-    # Check if the directory exists, if not, create it
-    if not os.path.exists(output_directory):
-        os.makedirs(output_directory)
-        print("INFO: Created output directory: {}".format(output_directory))
-    
-    return output_directory
+    Read and validate claim data from a file.
 
-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.
+    Args:
+        file_path (str): The path to the file containing the claim data.
+        config (dict): Configuration settings loaded from a JSON file.
+
+    Returns:
+        tuple: A tuple containing a list of valid parsed data and a list of validation errors.
+    """
+    valid_claims = []  # List to store valid parsed data
+    validation_errors = []  # List to store validation errors
+
+    # Iterate over data in the file
+    for personal_info, insurance_info, service_info in read_fixed_width_data(file_path):
+        # Parse data into a usable format
+        parsed_data = parse_fixed_width_data(personal_info, insurance_info, service_info, config.get('MediLink_Config', config))
+        # Validate the parsed data
+        is_valid, errors = validate_claim_data(parsed_data, config)
+        if is_valid:
+            valid_claims.append(parsed_data)  # Add valid data to the list
+        else:
+            validation_errors.append(errors)  # Add validation errors to the list
+            # Log validation failure
+            MediLink_ConfigLoader.log("Validation failed for claim data in file: {}. Errors: {}".format(file_path, errors), config, level="ERROR")
+
+    return valid_claims, validation_errors
+
+def format_claims(parsed_data_list, config, endpoint, starting_transaction_set_control_number):
+    """
+    Formats a list of parsed claim data into 837P segments.
 
     Parameters:
-    - detailed_patient_data: A list containing detailed patient data with endpoint information.
+    - parsed_data_list: List of dictionaries containing parsed claim data.
     - config: Configuration settings loaded from a JSON file.
+    - endpoint: The endpoint key representing the specific endpoint.
+    - starting_transaction_set_control_number: Starting transaction set control number for 837P segments.
 
     Returns:
-    - A list of paths to the converted files ready for submission.
+    - A list of formatted 837P claims and the next transaction set control number.
     """
+    formatted_claims = []
+    transaction_set_control_number = starting_transaction_set_control_number
 
-    # Initialize a dictionary to hold patient data segregated by confirmed endpoints
-    data_by_endpoint = {}
-        
-    # Populate the dictionary with patient data
-    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)
-
-    # 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)
+    for parsed_data in parsed_data_list:
+        formatted_claim = format_single_claim(parsed_data, config, endpoint, transaction_set_control_number)
+        formatted_claims.append(formatted_claim)
+        transaction_set_control_number += 1  # Increment for each successfully processed claim
 
-    # 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)
-            if converted_path:
-                converted_files_paths.append(converted_path)
-        
-    return converted_files_paths
+    return formatted_claims, transaction_set_control_number
 
-def process_claim(config, endpoint, patient_data_list):
+# Validation Function checks the completeness and correctness of each claim's data
+def validate_claim_data(parsed_data, config, required_fields=[]):
     """
-    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.
+    Used by both paths. 
+    
+    Validates the completeness and correctness of each claim's data based on configurable requirements.
 
     Parameters:
+    - parsed_data: Dictionary containing claim data to validate.
     - config: Configuration settings loaded from a JSON file.
-    - endpoint_key: The key representing the endpoint for which the data is being processed.
-    - patient_data_list: A list of dictionaries, each containing detailed patient data.
+    - required_fields: Optional list of tuples indicating required fields and their respective regex patterns for validation.
 
     Returns:
-    - Path to the converted file, or None if an error occurs.
-    """
-    # Retrieve endpoint-specific configuration
-    endpoint_config = config['endpoints'].get(endpoint)
-    if not endpoint_config:
-        print("Endpoint configuration for {} not found.".format(endpoint))
-        return None
+    - (bool, list): Tuple containing a boolean indicating whether the data is valid and a list of error messages if any.
 
-    # Retrieve desired default output file path from config
-    output_directory = config.get('outputFilePath', '')
+    # TODO This required fields thing needs to be redone. 
     
-    # BUG This is a WinSCP validation because of the mishandling of spaces in paths. 
-    # This shouldn't need to exist.
-    output_directory = winscp_validate_output_directory(output_directory)
+    if required_fields is None:
+        required_fields = [
+            ('CHART', None),
+            ('billing_provider_npi', r'^\d{10}$'),
+            ('IPOLICY', None),
+            ('CODEA', None),
+            ('DATE', r'^\d{8}$'),
+            ('AMOUNT', None),
+            ('TOS', None),
+            ('DIAG', None)
+        ]
+    """    
+    errors = []
+    MediLink_ConfigLoader.log("Starting claim vata validation...")
+    if not required_fields:
+        # If no required fields are specified, assume validation is true
+        return True, []
     
-    if not os.path.isdir(output_directory):
-        print("Output directory does not exist. Please check the configuration.")
-        return None
-
-    # Initialize document segments with headers
-    isa_header, gs_header = MediLink_837p_encoder_library.create_interchange_header(config, endpoint)
-    document_segments = [isa_header, gs_header]
-
-    # Initialize the transaction set control number
-    transaction_set_control_number = 1
-
-    # Process each patient's data in the list
-    for patient_data in patient_data_list:
-        # Assuming validate_claim_data is adapted to handle individual patient data dictionaries
-        if True: #validate_claim_data(patient_data, config): BUG DISABLED VALIDATION
-            # The format_single_claim function needs to be adapted to handle individual patient data dictionaries
-            formatted_claim = format_single_claim(patient_data, config, endpoint, transaction_set_control_number)
-            document_segments.append(formatted_claim)
-            transaction_set_control_number += 1
-
-    # Append interchange trailer
-    ge_trailer, iea_trailer = MediLink_837p_encoder_library.create_interchange_trailer(config, endpoint, transaction_set_control_number - 1)
-    document_segments.extend([ge_trailer, iea_trailer])
+    expected_keys = {field[0] for field in required_fields}  # Set of expected field keys
+    received_keys = set(parsed_data.keys())  # Set of keys present in the parsed data
+
+    # Check if there is any intersection between expected keys and received keys
+    if not expected_keys & received_keys:
+        # Log the preview of expected and received keys
+        preview_msg = "Validation skipped: No matching fields found between expected and received data."
+        error_msg = "{}\nExpected keys: {}\nReceived keys: {}".format(preview_msg, expected_keys, received_keys)
+        MediLink_ConfigLoader.log(error_msg, config, level="WARNING")
+        print(error_msg)  # Optionally print to console for immediate feedback
+        return True, [preview_msg]  # Return true to say that it's valid data anyway.
+
+    # Check for missing or empty fields and validate patterns
+    for field, pattern in required_fields:
+        value = parsed_data.get(field)
+        if not value:
+            errors.append("Missing or empty field: {}".format(field))
+        elif pattern and not re.match(pattern, value):
+            errors.append("Invalid format in field {}: {}".format(field, value))
+
+    # Validate date fields if required and ensure they are in the correct format
+    date_field = 'DATE'
+    date_value = parsed_data.get(date_field)
+    if date_value:
+        try:
+            datetime.strptime(date_value, "%Y%m%d")
+        except ValueError:
+            errors.append("Invalid date format: {}".format(date_value))
+
+    # Log validation errors and return
+    if errors:
+        for error in errors:
+            MediLink_ConfigLoader.log(error, config, level="ERROR")
+        return False, errors
 
-    # 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)
+    return True, []
 
-# Validation Function checks the completeness and correctness of each claim's data
-def validate_claim_data(parsed_data, config):
-    required_fields = ['CHART', 'billing_provider_npi', 'IPOLICY', 'CODEA', 'DATE', 'AMOUNT', 'TOS', 'DIAG']
-    errors = []
+def process_and_write_file(file_path, config, endpoint, starting_tscn=1):
+    """        
+    Process a single file, create complete 837P document with headers and trailers, and write to output file.
 
-    # Check for missing or empty fields
-    for field in required_fields:
-        if not parsed_data.get(field):
-            errors.append("Missing or empty field: {}".format(field))
+    Parameters:
+    - file_path: Path to the .DAT file to be processed.
+    - config: Configuration settings.
+    - endpoint: Endpoint key.
+    - starting_tscn: Starting Transaction Set Control Number.
+    """
+    print("Processing: {}".format(file_path))
+    MediLink_ConfigLoader.log("Processing: {}".format(file_path))
+    formatted_data, transaction_set_control_number = process_file(file_path, config, endpoint, starting_tscn)
+    isa_header, gs_header, ge_trailer, iea_trailer = MediLink_837p_encoder_library.create_interchange_elements(config, endpoint, transaction_set_control_number - 1)
     
-    # Validate NPI format
-    if not re.match(r'^\d{10}$', parsed_data.get('billing_provider_npi', '')):
-        errors.append("Invalid NPI format: {}".format(parsed_data.get('billing_provider_npi')))
-
-    # Validate date format
-    try:
-        datetime.strptime(parsed_data.get('DATE'), "%Y%m%d")
-    except ValueError:
-        errors.append("Invalid date format: {}".format(parsed_data.get('DATE')))
-
-    # Log validation errors
-    if errors:
-        for error in errors:
-            MediLink_837p_encoder_library.log(error, config, level="ERROR")
-        return False
+    # Combine everything into a single document
+    complete_document = "{}\n{}\n{}\n{}\n{}".format(
+        isa_header,
+        gs_header,
+        formatted_data,
+        ge_trailer,            
+        iea_trailer
+    )
     
-    return True
+    # Write to output file
+    output_file_path = write_output_file([complete_document], config.get('outputFilePath', ''), endpoint, file_path, config)
+    print("File processed. Output saved to: {}".format(output_file_path))
 
-if __name__ == "__main__":
+def main():
     """
     Converts fixed-width files to 837P format for health claim submissions.
 
@@ -349,44 +377,126 @@ if __name__ == "__main__":
 
     print("Starting the conversion process for {}. Processing {} at '{}'.".format(args.endpoint, 'directory' if args.is_directory else 'file', args.path))
 
-    # Load configuration
     config, _ = MediLink_ConfigLoader.load_configuration()
+    config = config.get('MediLink_Config', config)
     
-    def process_and_write_file(file_path, config, endpoint, starting_tscn=1):
-        """
-        Process a single file, create complete 837P document with headers and trailers, and write to output file.
-
-        Parameters:
-        - file_path: Path to the .DAT file to be processed.
-        - config: Configuration settings.
-        - endpoint: Endpoint key.
-        - starting_tscn: Starting Transaction Set Control Number.
-        """
-        print("Processing: {}".format(file_path))
-        formatted_data, transaction_set_control_number = process_file(file_path, config, endpoint, starting_tscn)
-        isa_header, gs_header, ge_trailer, iea_trailer = create_interchange_elements(config, endpoint, transaction_set_control_number - 1)
+    process_files(args.path, config, args.endpoint, args.is_directory)
+    print("Conversion complete.")
+
+def process_files(path, config, endpoint, is_directory):
+    """
+    Processes either a single file or all files within a directory.
+
+    Parameters:
+    - path: Path to the input fixed-width file or directory to process.
+    - config: Configuration settings loaded from a JSON file.
+    - endpoint: The endpoint for which the conversion is intended.
+    - is_directory: Boolean flag indicating if the path is a directory.
+
+    Returns:
+    - None
+    """
+    if is_directory:
+        MediLink_ConfigLoader.log("Processing all .DAT files in: {}".format(path))
+        for file_name in os.listdir(path):
+            if file_name.endswith(".DAT"):
+                file_path = os.path.join(path, file_name)
+                process_and_write_file(file_path, config, endpoint)
+    else:
+        MediLink_ConfigLoader.log("Processing the single file: {}".format(path))
+        process_and_write_file(path, config, endpoint)
+
+if __name__ == "__main__":
+    main()
+    
+# The functions below are the ones that are used as non-main library by outside scripts.
+#######################################################################################
+
+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.
+
+    Parameters:
+    - detailed_patient_data: A list containing detailed patient data with endpoint information.
+    - config: Configuration settings loaded from a JSON file.
+
+    Returns:
+    - A list of paths to the converted files ready for submission.
+    """
+
+    # Initialize a dictionary to hold patient data segregated by confirmed endpoints
+    data_by_endpoint = {}
         
-        # Combine everything into a single document
-        complete_document = "{}\n{}\n{}\n{}\n{}".format(
-            isa_header,
-            gs_header,
-            formatted_data,
-            ge_trailer,            
-            iea_trailer
-        )
+    # Populate the dictionary with patient data
+    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)
+
+    # 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)
+            if converted_path:
+                converted_files_paths.append(converted_path)
         
-        # Write to output file
-        output_file_path = write_output_file([complete_document], config.get('outputFilePath', ''), endpoint, file_path, config)
-        print("File processed. Output saved to: {}".format(output_file_path))
+    return converted_files_paths
+
+def process_claim(config, endpoint, patient_data_list):
+    """
+    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.
+
+    Parameters:
+    - config: Configuration settings loaded from a JSON file.
+    - endpoint_key: The key representing the endpoint for which the data is being processed.
+    - patient_data_list: A list of dictionaries, each containing detailed patient data.
+
+    Returns:
+    - Path to the converted file, or None if an error occurs.
     
-    if args.is_directory:
-        # Process each .DAT file within the directory
-        for file_name in os.listdir(args.path):
-            if file_name.endswith(".DAT"):
-                file_path = os.path.join(args.path, file_name)
-                process_and_write_file(file_path, config, args.endpoint)
-    else:
-        # Process a single file
-        process_and_write_file(args.path, config, args.endpoint)
+    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.
+    """
+    output_directory = MediLink_837p_encoder_library.get_output_directory(config)
+    if not output_directory:
+        return None
 
-    print("Conversion complete.")
+    # 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
+        is_valid, validation_errors = validate_claim_data(patient_data, config)
+        if is_valid:
+            # Format the claim if data is valid
+            formatted_claim = format_single_claim(patient_data, config, endpoint, transaction_set_control_number)
+            document_segments.append(formatted_claim)
+            transaction_set_control_number += 1
+        else:
+            if MediLink_837p_encoder_library.handle_validation_errors(transaction_set_control_number, validation_errors, config):
+                continue # Skip the current patient
+
+    # 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)
+
+    # Insert headers at the beginning and append trailers at the end of document segments
+    document_segments.insert(0, gs_header)
+    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)