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

MediBot/PDF_to_CSV_Cleaner.py

@@ -0,0 +1,211 @@
+import pandas as pd
+import re
+
+def load_csv(file_path):
+    # Loads a CSV file and returns a pandas DataFrame
+    return pd.read_csv(file_path, header=None)
+
+def segment_data(data):
+    # Segments the data into individual patient records
+    
+    patient_records = []
+    current_record = []
+    
+    for line in data.itertuples(index=False):
+        # Convert the tuple to a list to process it easier
+        line = list(line)
+        # Flatten the list and filter out NaN values
+        line = [item for item in line if pd.notna(item)]
+        
+        if line:  # Make sure there is data in the line
+            # Check for the delimiter indicating a new patient record
+            if 'PATIENT INFORMATION' in line[0]:
+                if current_record:
+                    # If there's an existing record, this means we've reached a new one
+                    # Save the current record and start a new one
+                    patient_records.append(current_record)
+                    current_record = []
+            # Add the line to the current patient record
+            current_record.extend(line)
+    
+    # Don't forget to add the last record after exiting the loop
+    if current_record:
+        patient_records.append(current_record)
+    
+    return patient_records
+
+# Function to extract key-value pairs from a patient record segment
+def extract_patient_data(patient_record):
+    patient_data = {
+        "Name": None,
+        "Patient ID": None,
+        "Address": None,
+        "Home Phone": None,
+        "DOB": None,
+        "Gender": None
+    }
+    
+    # Function to extract value after a specific key in the patient record
+    def extract_value_after_key(lines, key):
+        for index, line in enumerate(lines):
+            if key in line:
+                try:
+                    split_line = line.split('\n')
+                    if len(split_line) > 1:
+                        # Return the value only if it exists after the newline character
+                        return split_line[1].strip()                
+                except AttributeError:
+                    # Handle the case where 'line' is not a string and doesn't have the 'split' method
+                    print("Error extracting value after key:", line)
+                    pass     
+    
+    # For each key in patient_data, extract its value from the patient_record
+    for key in patient_data.keys():
+        patient_data[key] = extract_value_after_key(patient_record, key)
+    return patient_data
+
+
+def parse_insurance_info(patient_record):
+    insurance_data = {
+        "Primary Insurance": None,
+        "Primary Policy Number": None,
+        "Primary Group Number": None,
+        "Secondary Insurance": None,
+        "Secondary Policy Number": None,
+        "Secondary Group Number": None
+    }
+
+    insurance_section_started = False
+    secondary_insurance_detected = False
+    group_header_detected = False
+
+    for element in patient_record:
+        if 'INSURANCE INFORMATION' in element:
+            insurance_section_started = True
+            secondary_insurance_detected = False
+            continue
+
+        if insurance_section_started:
+            split_element = element.split('\n')
+            if 'Primary Insurance' in element:
+                insurance_data["Primary Insurance"] = element.split('\n')[1].strip() if len(element.split('\n')) > 1 else None
+            elif 'Secondary Insurance' in element and len(split_element) > 1 and split_element[1].strip():
+                insurance_data["Secondary Insurance"] = element.split('\n')[1].strip() if len(element.split('\n')) > 1 else None
+                secondary_insurance_detected = True
+            elif 'Policy Number' in element:
+                split_element = element.split('\n')
+                if len(split_element) > 1:
+                    if not insurance_data["Primary Policy Number"]:
+                        insurance_data["Primary Policy Number"] = split_element[1].strip()
+                    elif secondary_insurance_detected and not insurance_data["Secondary Policy Number"]:
+                        insurance_data["Secondary Policy Number"] = split_element[1].strip()
+            elif 'Group Number' in element:
+                #print("Group Detected: ", element, secondary_insurance_detected)
+                group_header_detected = not group_header_detected # toggle between T/F to proxy as first or second position.
+                split_element = element.split('\n')
+                if len(split_element) > 1:
+                    if not insurance_data["Primary Group Number"] and group_header_detected:
+                        insurance_data["Primary Group Number"] = split_element[1].strip()
+                    elif secondary_insurance_detected and not insurance_data["Secondary Group Number"] and not group_header_detected:
+                        insurance_data["Secondary Group Number"] = split_element[1].strip()
+
+    return insurance_data
+
+def structure_data(patient_data_list):
+    # Define the column headers based on the sample data provided earlier
+    column_headers = [
+        "Name", 
+        "Patient ID", 
+        "Address", 
+        "Home Phone", 
+        "DOB", 
+        "Gender", 
+        "Primary Insurance", 
+        "Primary Policy Number", 
+        "Primary Group Number",
+        "Secondary Insurance", 
+        "Secondary Policy Number",
+        "Secondary Group Number"
+    ]
+
+    # Initialize a list to hold structured patient records
+    structured_patient_records = []
+
+    # Iterate over each patient record in the list
+    for patient_record in patient_data_list:
+        # Extract the basic patient data
+        patient_data = extract_patient_data(patient_record)
+        # Extract the insurance information
+        insurance_data = parse_insurance_info(patient_record)
+        # Merge the two dictionaries
+        full_patient_data = {**patient_data, **insurance_data}
+        
+        # Add the cleaned and transformed data to the list
+        structured_patient_records.append(full_patient_data)
+
+    # Create the DataFrame with the structured patient data
+    structured_patient_df = pd.DataFrame(structured_patient_records, columns=column_headers)
+
+    # Return the structured DataFrame
+    return structured_patient_df
+
+def validate_data(data_frame):
+    # Performing Quality Assurance and Validation checks on the structured data
+
+    # Completeness Check: Check for missing values in critical fields
+    missing_values_check = data_frame.isnull().sum()
+
+    # Consistency Check: Ensure data formats are consistent
+    date_format_check = data_frame['DOB'].apply(lambda x: bool(re.match(r'\d{4}-\d{2}-\d{2}', x)) if pd.notnull(x) else True)
+    phone_format_check = data_frame['Home Phone'].apply(lambda x: bool(re.match(r'\+\d-\d{3}-\d{3}-\d{4}', x)) if pd.notnull(x) else True)
+
+    # Anomaly Detection: This can be complex and domain-specific. As a basic check, we can look for outliers in data like dates.
+    dob_anomalies_check = data_frame['DOB'].describe()
+
+    # Compile the results of the checks
+    validation_results = {
+        "Missing Values Check": missing_values_check,
+        "Date Format Consistency": all(date_format_check),
+        "Phone Format Consistency": all(phone_format_check),
+        "DOB Anomalies Check": dob_anomalies_check
+    }
+    
+    print(validation_results)  # Display validation results
+    return data_frame  # Return the validated DataFrame
+
+
+# Main function to orchestrate the cleaning process
+def clean_patient_data(file_path):
+    # Load the CSV file
+    sxpatient_data = load_csv(file_path)
+
+    # Segment the data
+    segmented_patient_records = segment_data(sxpatient_data)
+
+    # Structure the data
+    structured_data_frame = structure_data(segmented_patient_records)
+
+    # Validate the data
+    validated_data = validate_data(structured_data_frame)
+    
+    return validated_data
+
+# Path to the CSV file with escaped backslashes
+file_path_sxpatient = 'C:\\Users\\danie\\OneDrive\\Desktop\\CSV02012024.CSV'
+# Define the file path for the output CSV file
+output_file_path = 'G:\\My Drive\\CocoWave\\XP typing bot\\cleaned_FEB01SXcsv_group.csv'
+
+# Call the main function to clean the patient data
+cleaned_patient_data = clean_patient_data(file_path_sxpatient)
+
+# Display the first few rows of the cleaned and validated data to verify the output
+print(cleaned_patient_data.head())
+
+# Save the processed data to a CSV file
+cleaned_patient_data.to_csv(output_file_path, index=False)
+
+print(f"Processed data saved to {output_file_path}")
+
+# Development Roadmap
+
+# Do not delete leading zeros from insurance numbers

MediBot/update_json.py

@@ -0,0 +1,43 @@
+import json
+import sys
+from collections import OrderedDict
+
+def update_csv_path(json_file, new_path):
+    try:
+        with open(json_file, 'r', encoding='utf-8') as file:
+            try:
+                data = json.load(file, object_pairs_hook=OrderedDict)
+            except ValueError as decode_err:
+                print("Error decoding JSON file '{}': {}".format(json_file, decode_err))
+                sys.exit(1)
+
+        # Ensure correct backslash formatting for JSON
+        if "\\" in new_path and "\\\\" not in new_path:
+            formatted_path = new_path.replace("\\", "\\\\")
+        else:
+            formatted_path = new_path
+
+        data['CSV_FILE_PATH'] = formatted_path
+
+        with open(json_file, 'w', encoding='utf-8') as file:
+            try:
+                json.dump(data, file, ensure_ascii=False, indent=4)
+            except ValueError as encode_err:
+                print("Error encoding JSON data to file '{}': {}".format(json_file, encode_err))
+                sys.exit(1)
+
+    except IOError as io_err:
+        print("Error accessing file '{}': {}".format(json_file, io_err))
+        sys.exit(1)
+    except Exception as e:
+        print("An unexpected error occurred: {}".format(e))
+        sys.exit(1)
+
+if __name__ == "__main__":
+    if len(sys.argv) == 3:
+        json_path = sys.argv[1]
+        new_csv_path = sys.argv[2]
+        update_csv_path(json_path, new_csv_path)
+    else:
+        print("Usage: update_json.py <path_to_json_file> <new_csv_path>")
+        sys.exit(1)

MediBot/update_medicafe.py

@@ -0,0 +1,19 @@
+import subprocess
+import sys
+from tqdm import tqdm
+
+def upgrade_medicafe(package):
+    try:
+        # Use tqdm to create a progress bar
+        with tqdm(total=100, desc="Upgrading %s" % package, unit="%") as progress_bar:
+            subprocess.check_call([sys.executable, '-m', 'pip', 'install', '--upgrade', package, '--no-deps', '--disable-pip-version-check'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            # Update progress bar to 100% upon completion
+            progress_bar.update(100 - progress_bar.n)
+        print("Update successful.")
+    except subprocess.CalledProcessError:
+        print("Update failed. Please check your internet connection and try again later.")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    medicafe_package = "medicafe"
+    upgrade_medicafe(medicafe_package)

MediLink/MediLink.py

@@ -0,0 +1,277 @@
+import os
+import MediLink_ConfigLoader
+import MediLink_837p_encoder
+import logging
+import MediLink_Down
+import MediLink_Up
+
+# For UI Functions
+import os
+import MediLink_UI  # Import UI module for handling all user interfaces
+
+"""
+Development Tasks for Backend Enhancement in MediSoft Claims Submittal (MediLink) Script:
+
+Implement dynamic configurations for multiple endpoints (Availity, Optum, PNT Data) with environmental settings support.
+Enhance file detection with detailed logging and introduce integrity checks for pre-processing validation.
+Verify file transmissions via WinSCP log analysis for successful endpoint acknowledgments and secure data transfer.
+Automate response file handling from endpoints and integrate feedback into MediSoft with exception alerts.
+De-persisting Intermediate Files.
+When transmissions fail, there is some retaining of patient data in memory or something that seems to default
+any new endpoint changes to Optum. May need to "de-confirm" patients, but leave the suggested endpoints as the previously
+confirmed endpoints. This should be similar logic to if the user made a mistake and wants to go back and fix it.
+These tasks involve backend enhancements such as dynamic configurations, file detection improvements, file transmission verification, automation of response file handling, and management of intermediate files and transmission failures.
+
+TODO Crosswalk should be to PayerID key vs Medisoft:Endpoint.
+TODO Availity has a response file that says "File was received at TIME. File was sent for processing." as a confirmation 
+that sits in the SendFiles folder after a submittal. 
+
+BUG Suggested Endpoint when you say 'n' to proceed with transmission is not getting updated with the endpoint 
+that was selected previously by the user. However, when we go back to the confirmation list, we do have a persist of the assignment.
+This can be confusing for the user.
+"""
+
+# Setup basic logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s\n')
+
+def detect_and_display_file_summaries(directory_path, 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.
+    
+    :param directory_path: Path to the directory containing files to be detected.
+    :param config: Configuration settings loaded from a JSON file.
+    :return: A tuple containing a list of new file paths and the detailed patient data.
+    """
+    new_files = detect_new_files(directory_path)
+    if not new_files:
+        print("    No new claims detected. Check Medisoft claims output.\n")
+        return False, []
+
+    detailed_patient_data = []  # Initialize list for detailed patient data
+    for file_path in new_files:
+        detailed_data = extract_and_suggest_endpoint(file_path, config, crosswalk)
+        detailed_patient_data.extend(detailed_data)  # Accumulate detailed data for processing
+
+    # Return just the list of new files and the enriched detailed patient data
+    return new_files, detailed_patient_data
+
+def detect_new_files(directory_path, file_extension='.DAT'):
+    """
+    Scans the specified directory for new files with a given extension.
+    
+    :param directory_path: Path to the directory containing files to be detected.
+    :param file_extension: Extension of the files to detect. Defaults to '.csv'.
+    :return: A list of paths to new files detected in the directory.
+    """
+    detected_file_paths = []
+    for filename in os.listdir(directory_path):
+        if filename.endswith(file_extension):
+            file_path = os.path.join(directory_path, filename)
+            detected_file_paths.append(file_path)
+    return detected_file_paths
+
+def extract_and_suggest_endpoint(file_path, config, crosswalk):
+    """
+    Reads a fixed-width file, extracts file details including surgery date, patient ID, 
+    patient name, primary insurance, and other necessary details for each record. It suggests 
+    an endpoint based on insurance provider information found in the crosswalk and prepares 
+    detailed patient data for processing.
+    
+    Parameters:
+    - file_path: Path to the fixed-width file.
+    - crosswalk: Crosswalk dictionary loaded from a JSON file.
+
+    Returns:
+    - A comprehensive data structure retaining detailed patient claim details needed for processing,
+      including new key-value pairs for file path, surgery date, patient name, and primary insurance.
+    """
+    detailed_patient_data = []
+    
+    for personal_info, insurance_info, service_info in MediLink_837p_encoder.read_fixed_width_data(file_path, config.get('MediLink_Config', {})):
+        parsed_data = MediLink_837p_encoder.parse_fixed_width_data(personal_info, insurance_info, service_info, config.get('MediLink_Config', {}))
+        
+        primary_insurance = parsed_data.get('INAME')
+        
+        # TODO This suggested endpoint should be a payerid_to_endpoint_mapping.
+        suggested_endpoint = crosswalk['insurance_to_endpoint_mapping'].get(primary_insurance, 'AVAILITY')
+        
+        # Directly enrich detailed patient data with additional information and suggested endpoint
+        detailed_data = parsed_data.copy()  # Copy parsed_data to avoid modifying the original dictionary
+        detailed_data.update({
+            'file_path': file_path,
+            'patient_id': parsed_data.get('CHART'),
+            'surgery_date': parsed_data.get('DATE'),
+            'patient_name': ' '.join([parsed_data.get(key, '') for key in ['FIRST', 'MIDDLE', 'LAST']]),
+            'amount': parsed_data.get('AMOUNT'),
+            'primary_insurance': primary_insurance,
+            'suggested_endpoint': suggested_endpoint
+        })
+        detailed_patient_data.append(detailed_data)
+
+    # Return only the enriched detailed patient data, eliminating the need for a separate summary list
+    return detailed_patient_data
+
+def organize_patient_data_by_endpoint(detailed_patient_data):
+    """
+    Organizes detailed patient data by their confirmed endpoints.
+    This simplifies processing and conversion per endpoint basis, ensuring that claims are generated and submitted
+    according to the endpoint-specific requirements.
+
+    :param detailed_patient_data: A list of dictionaries, each containing detailed patient data including confirmed endpoint.
+    :return: A dictionary with endpoints as keys and lists of detailed patient data as values for processing.
+    """
+    organized = {}
+    for data in detailed_patient_data:
+        # Retrieve confirmed endpoint from each patient's data
+        endpoint = data['confirmed_endpoint'] if 'confirmed_endpoint' in data else data['suggested_endpoint']
+        # Initialize a list for the endpoint if it doesn't exist
+        if endpoint not in organized:
+            organized[endpoint] = []
+        organized[endpoint].append(data)
+    return organized
+
+def check_for_new_remittances(config):
+    print("\nChecking for new files across all endpoints...")
+    endpoints = config['MediLink_Config']['endpoints']
+    for endpoint_key, endpoint_info in endpoints.items():
+        try:
+            # Pass the endpoint key to MediLink_Down.main() as an argument
+            ERA_path = MediLink_Down.main(desired_endpoint=endpoint_key)
+            # BUG This needs to check to see if this actually worked maybe winscplog before saying it completed successfully 
+            print("New remittances for {} completed successfully.".format(endpoint_info['name']))
+            print("Results saved to: {}\n".format(ERA_path))
+        except Exception as e:
+            print("An error occurred while checking remittances for {}: {}".format(endpoint_info['name'], e))
+
+def user_decision_on_suggestions(detailed_patient_data, config):
+    """
+    Presents the user with all patient summaries and suggested endpoints,
+    then asks for confirmation to proceed with all or specify adjustments manually.
+    """
+    # Display summaries of patient details and endpoints.
+    MediLink_UI.display_patient_summaries(detailed_patient_data)
+
+    # Ask the user if they want to proceed with all suggested endpoints.
+    proceed = MediLink_UI.ask_for_proceeding_with_endpoints()
+
+    # If the user agrees to proceed with all suggested endpoints, confirm them.
+    if proceed:
+        return confirm_all_suggested_endpoints(detailed_patient_data)
+    # Otherwise, allow the user to adjust the endpoints manually.
+    else:
+        return select_and_adjust_files(detailed_patient_data, config)
+    
+def confirm_all_suggested_endpoints(detailed_patient_data):
+    """
+    Confirms all suggested endpoints for each patient's detailed data.
+    """
+    for data in detailed_patient_data:
+        if 'confirmed_endpoint' not in data:
+            data['confirmed_endpoint'] = data['suggested_endpoint']
+    return detailed_patient_data
+
+def select_and_adjust_files(detailed_patient_data, config):
+    """
+    Allows users to select patients and adjust their endpoints by interfacing with UI functions.
+    """
+    # Display options for patients
+    MediLink_UI.display_patient_options(detailed_patient_data)
+
+    # Get user-selected indices for adjustment
+    selected_indices = MediLink_UI.get_selected_indices(len(detailed_patient_data))
+
+    # Fetch endpoint names dynamically from the JSON config
+    endpoint_mapping = {str(i + 1): config['MediLink_Config']['endpoints'][endpoint]['name'] for i, endpoint in enumerate(config['MediLink_Config']['endpoints'])}
+
+    # Iterate over each selected index and process endpoint changes
+    for i in selected_indices:
+        data = detailed_patient_data[i]
+        MediLink_UI.display_patient_for_adjustment(data['patient_name'], data.get('suggested_endpoint', 'N/A'))
+        
+        endpoint_change = MediLink_UI.get_endpoint_decision()
+
+        if endpoint_change == 'y':
+            MediLink_UI.display_endpoint_options(endpoint_mapping)            
+            new_endpoint_choice = MediLink_UI.get_new_endpoint_choice()
+            
+            if new_endpoint_choice in endpoint_mapping:
+                data['confirmed_endpoint'] = endpoint_mapping[new_endpoint_choice]
+                print("Endpoint changed to {0} for patient {1}.".format(data['confirmed_endpoint'], data['patient_name']))
+            else:
+                print("Invalid selection. Keeping the suggested endpoint.")
+        else:
+            data['confirmed_endpoint'] = data.get('suggested_endpoint', 'N/A')
+
+    # Return the updated data
+    return detailed_patient_data
+
+def main_menu():
+    """
+    Initializes the main menu loop and handles the overall program flow,
+    including loading configurations and managing user input for menu selections.
+    """
+    # Load configuration settings and display the initial welcome message.
+    config, crosswalk = MediLink_ConfigLoader.load_configuration() # BUG does this need an argument?
+    
+    # Display Welcome Message
+    MediLink_UI.display_welcome()
+
+    # 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)
+
+    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:
+            options.insert(1, "Submit claims")
+
+        # Display the dynamically adjusted menu options.
+        MediLink_UI.display_menu(options)
+        # Retrieve user choice and handle it.
+        choice = MediLink_UI.get_user_choice()
+
+        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)
+        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.
+            MediLink_UI.display_exit_message()
+            break
+        else:
+            # Display an error message if the user's choice does not match any valid option.
+            MediLink_UI.display_invalid_choice()
+
+def handle_submission(detailed_patient_data, config):
+    """
+    Handles the submission process for claims based on detailed patient data.
+    This function orchestrates the flow from user decision on endpoint suggestions to the actual submission of claims.
+    """
+    # Initiate user interaction to confirm or adjust suggested endpoints.
+    adjusted_data = user_decision_on_suggestions(detailed_patient_data, config)
+    # Confirm all remaining suggested endpoints.
+    confirmed_data = confirm_all_suggested_endpoints(adjusted_data)
+    if confirmed_data:  # Proceed if there are confirmed data entries.
+        # Organize data by confirmed endpoints for submission.
+        organized_data = organize_patient_data_by_endpoint(confirmed_data)
+        # Confirm transmission with the user and check for internet connectivity.
+        if MediLink_Up.confirm_transmission(organized_data):
+            if MediLink_Up.check_internet_connection():
+                # Submit claims if internet connectivity is confirmed.
+                MediLink_Up.submit_claims(organized_data, config)
+            else:
+                # Notify the user of an internet connection error.
+                print("Internet connection error. Please ensure you're connected and try again.")
+        else:
+            # Notify the user if the submission is cancelled.
+            print("Submission cancelled. No changes were made.")
+
+if __name__ == "__main__":
+    main_menu()

MediLink/MediLink_277_decoder.py

@@ -0,0 +1,92 @@
+import csv
+import os
+import sys
+
+"""
+This script processes a 277 healthcare claim status response file, extracting and structuring key information
+about each claim into a CSV format. The goal is to interpret acknowledgment returns and provide a readable receipt
+of claim statuses for further analysis or record-keeping.
+
+Extracted fields and their sources from the 277 transaction set include:
+- Clearing House: Extracted from 'NM1' segment where entity identifier code is '41' (payer) as the clearinghouse or payer name.
+- Received Date: Extracted from the 'DTP' segment with qualifier '050' indicating the date claim information was received.
+- Claim Status Tracking #: Extracted from the 'TRN' segment, representing a unique identifier used to track the claim.
+- Billed Amount: Extracted from the 'AMT' segment with qualifier 'YU' representing the total billed amount.
+- Date of Service: Extracted from the 'DTP' segment with qualifier '472', indicating the date services were rendered.
+- Last and First Name: Extracted from 'NM1' segment where entity identifier is 'QC' (patient) to obtain patient's last and first names.
+- Acknowledged Amount: Extracted from the 'STC' segment, specifically the monetary amount acknowledged.
+- Status: Extracted from the 'STC' segment, indicating the processing status of the claim.
+
+Each record corresponds to a single claim, and the script consolidates these records from the raw 277 file into a structured CSV file.
+The CSV output contains headers corresponding to the above fields for ease of review and use in subsequent processes.
+
+Prerequisites:
+- Python 3.x
+- Access to a filesystem for reading input files and writing output CSV files.
+
+Usage:
+The script requires the path to the 277 file as input and specifies an output directory for the CSV files.
+Example command-line usage:
+    python3 MediLink_277_decoder.py input_file.txt output_directory
+"""
+
+def parse_277_content(content):
+    segments = content.split('~')
+    records = []
+    current_record = {}
+    for segment in segments:
+        parts = segment.split('*')
+        if parts[0] == 'HL':
+            if current_record:
+                records.append(current_record)
+                current_record = {}
+        elif parts[0] == 'NM1':
+            if parts[1] == 'QC':  # Patient information
+                current_record['Last'] = parts[3]
+                current_record['First'] = parts[4]
+            elif parts[1] == '41':  # Payer information
+                current_record['Clearing House'] = parts[3]
+        elif parts[0] == 'TRN':
+            current_record['Claim Status Tracking #'] = parts[2]
+        elif parts[0] == 'STC':
+            current_record['Status'] = parts[1]
+            current_record['Acknowledged Amt'] = parts[4]
+        elif parts[0] == 'DTP':
+            if parts[1] == '472':  # Service date
+                current_record['Date of Service'] = parts[3]
+            elif parts[1] == '050':  # Received date
+                current_record['Received Date'] = parts[3]
+        elif parts[0] == 'AMT':
+            if parts[1] == 'YU':
+                current_record['Billed Amt'] = parts[2]
+    
+    if current_record:
+        records.append(current_record)
+    
+    return records
+
+def write_records_to_csv(records, output_file_path):
+    with open(output_file_path, 'w', newline='') as csvfile:
+        fieldnames = ['Clearing House', 'Received Date', 'Claim Status Tracking #', 'Billed Amt', 'Date of Service', 'Last', 'First', 'Acknowledged Amt', 'Status']
+        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+        writer.writeheader()
+        for record in records:
+            writer.writerow(record)
+
+def main(file_path, output_directory):
+    if not os.path.exists(output_directory):
+        os.makedirs(output_directory)
+    
+    output_file_path = os.path.join(output_directory, os.path.basename(file_path) + '_decoded.csv')
+    
+    with open(file_path, 'r') as file:
+        content = file.read().replace('\n', '')
+    
+    records = parse_277_content(content)
+    write_records_to_csv(records, output_file_path)
+    print("Decoded data written to {}".format(output_file_path))
+
+if __name__ == "__main__":
+    file_path = sys.argv[1]
+    output_directory = 'output'
+    main(file_path, output_directory)