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

MediLink/MediLink_837p_encoder.py

@@ -1,13 +1,12 @@
-import re
+# MediLink_837p_encoder.py
+import re, argparse, os
 from datetime import datetime
-import argparse
-import os
 import MediLink_ConfigLoader
 from MediLink_DataMgmt import parse_fixed_width_data, read_fixed_width_data
 import MediLink_837p_encoder_library
 #from tqdm import tqdm
 
-def format_single_claim(patient_data, config, endpoint, transaction_set_control_number):
+def format_single_claim(patient_data, config, endpoint, transaction_set_control_number, crosswalk, client):
     """
     Formats a single claim into 837P segments based on the provided patient data and endpoint.
     
@@ -21,7 +20,7 @@ def format_single_claim(patient_data, config, endpoint, transaction_set_control_
     - 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)
+    patient_data = MediLink_837p_encoder_library.payer_id_to_payer_name(patient_data, config, endpoint, crosswalk, client)
     
     segments = []
         
@@ -63,7 +62,7 @@ def format_single_claim(patient_data, config, endpoint, transaction_set_control_
     segments.extend(MediLink_837p_encoder_library.create_nm1_rendering_provider_segment(config))
     
     # Claim information 2300, 2310C Service Facility and 2400 loop segments
-    segments.extend(MediLink_837p_encoder_library.create_clm_and_related_segments(patient_data, config))
+    segments.extend(MediLink_837p_encoder_library.create_clm_and_related_segments(patient_data, config, crosswalk))
 
     # Placeholder for the SE segment to be updated with actual segment count later
     segments.append("SE**{transaction_set_control_number:04d}~")
@@ -77,33 +76,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 +107,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))
@@ -130,7 +123,7 @@ def write_output_file(document_segments, output_directory, endpoint_key, input_f
         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):
+def process_single_file(file_path, config, endpoint_key, transaction_set_control_number, crosswalk): # BUG Duplicate function name??
     """
     Process the claim data from a file into the 837P format.
 
@@ -151,7 +144,7 @@ def process_file(file_path, config, endpoint_key, transaction_set_control_number
             return None, transaction_set_control_number  # Halt processing if the user chooses
 
     # Process each valid claim
-    formatted_claims, transaction_set_control_number = format_claims(valid_claims, config, endpoint_key, transaction_set_control_number)
+    formatted_claims, transaction_set_control_number = format_claims(valid_claims, config, endpoint_key, transaction_set_control_number, crosswalk)
 
     formatted_claims_str = '\n'.join(formatted_claims)  # Join formatted claims into a single string
     return formatted_claims_str, transaction_set_control_number
@@ -185,7 +178,7 @@ def read_and_validate_claims(file_path, config):
 
     return valid_claims, validation_errors
 
-def format_claims(parsed_data_list, config, endpoint, starting_transaction_set_control_number):
+def format_claims(parsed_data_list, config, endpoint, starting_transaction_set_control_number, crosswalk):
     """
     Formats a list of parsed claim data into 837P segments.
 
@@ -202,7 +195,7 @@ def format_claims(parsed_data_list, config, endpoint, starting_transaction_set_c
     transaction_set_control_number = starting_transaction_set_control_number
 
     for parsed_data in parsed_data_list:
-        formatted_claim = format_single_claim(parsed_data, config, endpoint, transaction_set_control_number)
+        formatted_claim = format_single_claim(parsed_data, config, endpoint, transaction_set_control_number, crosswalk)
         formatted_claims.append(formatted_claim)
         transaction_set_control_number += 1  # Increment for each successfully processed claim
 
@@ -280,7 +273,7 @@ def validate_claim_data(parsed_data, config, required_fields=[]):
 
     return True, []
 
-def process_and_write_file(file_path, config, endpoint, starting_tscn=1):
+def process_and_write_file(file_path, config, endpoint, crosswalk, starting_tscn=1):
     """        
     Process a single file, create complete 837P document with headers and trailers, and write to output file.
 
@@ -292,7 +285,7 @@ def process_and_write_file(file_path, config, endpoint, starting_tscn=1):
     """
     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)
+    formatted_data, transaction_set_control_number = process_single_file(file_path, config, endpoint, starting_tscn, crosswalk)
     isa_header, gs_header, ge_trailer, iea_trailer = MediLink_837p_encoder_library.create_interchange_elements(config, endpoint, transaction_set_control_number - 1)
     
     # Combine everything into a single document
@@ -309,6 +302,7 @@ def process_and_write_file(file_path, config, endpoint, starting_tscn=1):
     print("File processed. Output saved to: {}".format(output_file_path))
 
 def main():
+    # BUG (MAJOR) THIS NEEDS THE API CLIENT TO BE PASSED INTO THE FUNCTION FOR SINGLE FILE PROCESSING.
     """
     Converts fixed-width files to 837P format for health claim submissions.
 
@@ -335,7 +329,7 @@ def main():
     parser.add_argument(
         "-e", "--endpoint", 
         required=True,
-        choices=["AVAILITY", "OPTUMEDI", "PNT_DATA"],
+        choices=["AVAILITY", "OPTUMEDI", "PNT_DATA", "UHCAPI", "CLAIMSHUTTLE"], # This should read from the config?
         help="Specify the endpoint for which the conversion is intended."
     )
     parser.add_argument(
@@ -352,13 +346,13 @@ def main():
 
     print("Starting the conversion process for {}. Processing {} at '{}'.".format(args.endpoint, 'directory' if args.is_directory else 'file', args.path))
 
-    config, _ = MediLink_ConfigLoader.load_configuration()
+    config, crosswalk = MediLink_ConfigLoader.load_configuration()
     config = config.get('MediLink_Config', config)
     
-    process_files(args.path, config, args.endpoint, args.is_directory)
+    process_dat_files(args.path, config, args.endpoint, args.is_directory, crosswalk)
     print("Conversion complete.")
 
-def process_files(path, config, endpoint, is_directory):
+def process_dat_files(path, config, endpoint, is_directory, crosswalk):
     """
     Processes either a single file or all files within a directory.
 
@@ -376,10 +370,10 @@ def process_files(path, config, endpoint, is_directory):
         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)
+                process_and_write_file(file_path, config, endpoint, crosswalk)
     else:
         MediLink_ConfigLoader.log("Processing the single file: {}".format(path))
-        process_and_write_file(path, config, endpoint)
+        process_and_write_file(path, config, endpoint, crosswalk)
 
 if __name__ == "__main__":
     main()
@@ -387,10 +381,10 @@ if __name__ == "__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):
-    """    
+def convert_files_for_submission(detailed_patient_data, config, crosswalk, client): 
+    """
     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], crosswalk, client, 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, crosswalk, client)
             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, crosswalk, client, 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
-            formatted_claim = format_single_claim(patient_data, config, endpoint, transaction_set_control_number)
+            # Format the claim into 837P segments
+            formatted_claim = format_single_claim(patient_data, config, endpoint, transaction_set_control_number, crosswalk, client)
             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