medicafe 0.240419.2__zip

medicafe-0.240419.2/MediLink/MediLink_ConfigLoader.py

@@ -0,0 +1,69 @@
+import os
+import json
+import logging
+from datetime import datetime
+from collections import OrderedDict
+import sys
+
+"""
+This function should be generalizable to have a initialization script over all the Medi* functions
+"""
+
+# Setup basic logging. 
+# BUG Consolidate this with MediLink_837p_encoder_library.log
+def setup_logger(local_storage_path):
+    # Define a reasonable name for the log file, e.g., "MediLink_Down_Process.log"
+    log_filename = datetime.now().strftime("MediLink_Down_Process_%m%d%Y.log")
+    log_filepath = os.path.join(local_storage_path, log_filename)
+
+    for handler in logging.root.handlers[:]:
+        logging.root.removeHandler(handler)
+    
+    # Setup logging to file
+    logging.basicConfig(level=logging.INFO,
+                        format='%(asctime)s - %(levelname)s - %(message)s',
+                        filename=log_filepath,  # Direct logging to a file in local_storage_path
+                        filemode='a')  # Append mode
+
+    # If you also want to see the logs in the console, add a StreamHandler
+    #console_handler = logging.StreamHandler()
+    #console_handler.setLevel(logging.INFO)
+    #formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+    #console_handler.setFormatter(formatter)
+    #logging.getLogger('').addHandler(console_handler)
+
+def load_configuration(config_path=os.path.join(os.path.dirname(__file__), '..', 'json', 'config.json'), crosswalk_path=os.path.join(os.path.dirname(__file__), '..', 'json', 'crosswalk.json')):
+    """
+    Loads endpoint configuration, credentials, and other settings from JSON files.
+        
+    Returns: A tuple containing dictionaries with configuration settings for the main config and crosswalk.
+    """
+    # BUG HARDCODE FOR NOW
+    config_path="G:\\My Drive\\Codes\\MediCafe\\json\\config.json"
+    # "F:\\Medibot\\json\\config.json"
+    crosswalk_path="G:\\My Drive\\Codes\\MediCafe\\json\\crosswalk.json"
+    # "F:\\Medibot\\json\\crosswalk.json"
+    
+    try:
+        with open(config_path, 'r') as config_file:
+            config = json.load(config_file, object_pairs_hook=OrderedDict)
+            if 'MediLink_Config' not in config:
+                raise KeyError("MediLink_Config key is missing from the loaded configuration.")
+            # MediLink_config = config['MediLink_Config']
+
+        with open(crosswalk_path, 'r') as crosswalk_file:
+            crosswalk = json.load(crosswalk_file)
+
+        return config, crosswalk
+    except json.JSONDecodeError as e:
+        print("Error parsing JSON file: {}".format(e))
+        sys.exit(1)  # Exit the script due to a critical error in configuration loading
+    except FileNotFoundError:
+        print("One or both JSON files not found. Config: {}, Crosswalk: {}".format(config_path, crosswalk_path))
+        sys.exit(1)  # Exit the script due to a critical error in configuration loading
+    except KeyError as e:
+        print("Critical configuration is missing: {}".format(e))
+        sys.exit(1)  # Exit the script due to a critical error in configuration loading
+    except Exception as e:
+        print("An unexpected error occurred while loading the configuration: {}".format(e))
+        sys.exit(1)  # Exit the script due to a critical error in configuration loading

medicafe-0.240419.2/MediLink/MediLink_DataMgmt.py

@@ -0,0 +1,206 @@
+import csv
+import os
+from datetime import datetime, timedelta
+import logging
+import MediLink_837p_encoder_library
+import subprocess # BUG Currently disabled for testing.
+import logging
+
+# Helper function to slice and strip values
+def slice_data(data, slices):
+    # Convert slices list to a tuple for slicing operation
+    return {key: data[slice(*slices[key])].strip() for key in slices}
+
+# Function to parse fixed-width Medisoft output and extract claim data
+def parse_fixed_width_data(personal_info, insurance_info, service_info, config):
+    # Load slice definitions from config within the MediLink_Config section
+    personal_slices = config['fixedWidthSlices']['personal_slices']
+    insurance_slices = config['fixedWidthSlices']['insurance_slices']
+    service_slices = config['fixedWidthSlices']['service_slices']
+
+    # Parse each segment
+    parsed_data = {}
+    parsed_data.update(slice_data(personal_info, personal_slices))
+    parsed_data.update(slice_data(insurance_info, insurance_slices))
+    parsed_data.update(slice_data(service_info, service_slices))
+    
+    MediLink_837p_encoder_library.log("Successfully parsed data from segments", config, level="INFO")
+    
+    return parsed_data
+
+# Function to read fixed-width Medisoft output and extract claim data
+def read_fixed_width_data(file_path, config):
+    # Reads the fixed width data from the file and yields each patient's
+    # personal, insurance, and service information.
+    with open(file_path, 'r') as file:
+        lines_buffer = []  # Buffer to hold lines for current patient data
+        for line in file:
+            stripped_line = line.strip()
+            if stripped_line:  # Only process non-empty lines
+                lines_buffer.append(stripped_line)
+                # Once we have 3 lines of data, yield them as a patient record
+                if len(lines_buffer) == 3:
+                    personal_info, insurance_info, service_info = lines_buffer
+                    MediLink_837p_encoder_library.log("Successfully read data from file: {}".format(file_path), config, level="INFO")
+                    yield personal_info, insurance_info, service_info
+                    lines_buffer.clear()  # Reset buffer for the next patient record
+            # If the line is blank but we have already started collecting a patient record,
+            # we continue without resetting the buffer, effectively skipping blank lines.
+
+def consolidate_csvs(source_directory):
+    """
+    This default overwrites any existing CSV for the same day. We want this for the automated runs but want to switch through 
+    the user interaction option if we're running interactive. This has not been implemented, but the helper function exists.
+    """
+    today = datetime.now()
+    consolidated_filename = today.strftime("ERA_%m%d%y.csv")
+    consolidated_filepath = os.path.join(source_directory, consolidated_filename)
+
+    consolidated_data = []
+    header_saved = False
+
+    # Check if the file already exists and log the action
+    if os.path.exists(consolidated_filepath):
+        MediLink_837p_encoder_library.log("The file {} already exists. It will be overwritten.".format(consolidated_filename))
+
+    for filename in os.listdir(source_directory):
+        filepath = os.path.join(source_directory, filename)
+        if not filepath.endswith('.csv') or os.path.isdir(filepath) or filepath == consolidated_filepath:
+            continue  # Skip non-CSV files, directories, and the target consolidated file itself
+
+        # Check if the file was created within the last day
+        modification_time = datetime.fromtimestamp(os.path.getmtime(filepath))
+        if modification_time < today - timedelta(days=1):
+            continue  # Skip files not modified in the last day
+
+        # Read and append data from each CSV
+        with open(filepath, 'r', newline='') as csvfile:
+            reader = csv.reader(csvfile)
+            header = next(reader)  # Assumes all CSV files have the same header
+            if not header_saved:  # Save header from the first file
+                consolidated_data.append(header)
+                header_saved = True
+            consolidated_data.extend(row for row in reader)
+
+        # Delete the source file after its contents have been added to the consolidation list
+        os.remove(filepath)
+
+    # Write consolidated data to a new or existing CSV file, overwriting it if it exists
+    with open(consolidated_filepath, 'w', newline='') as csvfile:
+        writer = csv.writer(csvfile)
+        writer.writerows(consolidated_data)
+
+    MediLink_837p_encoder_library.log("Consolidated CSVs into {}".format(consolidated_filepath))
+    
+    return consolidated_filepath
+
+def operate_winscp(operation_type, files, endpoint_config, local_storage_path):
+    """
+    General function to operate WinSCP for uploading or downloading files.
+
+    :param operation_type: 'upload' or 'download'
+    :param files: List of files to upload or pattern for files to download.
+    :param endpoint_config: Dictionary containing endpoint configuration.
+    :param local_storage_path: Base local storage path for logs and files.
+
+    # Example of how to call this function for uploads
+    upload_files = ['path/to/local/file1.txt', 'path/to/local/file2.txt']
+    upload_config = {
+        'session_name': 'MySession',
+        'remote_directory_up': '/remote/upload/path'
+    }
+
+    operate_winscp('upload', upload_files, upload_config, 'path/to/local/storage')
+
+    # Example of how to call this function for downloads
+    download_config = {
+        'session_name': 'MySession',
+        'remote_directory_down': '/remote/download/path'
+    }
+
+    operate_winscp('download', None, download_config, 'path/to/local/storage')
+    """
+    # Setup paths
+    try:
+        winscp_path = endpoint_config['winscp_path']
+    except KeyError:
+        winscp_path = os.path.join(os.getcwd(), "Installers", "WinSCP-Portable", "WinSCP.com")
+    except Exception as e:
+        # Handle any other exceptions here
+        print("An error occurred:", e)
+        winscp_path = None
+        
+    if not os.path.isfile(winscp_path):
+        logging.error("WinSCP.com not found at {}".format(winscp_path))
+        return False
+
+    # Setup logging
+    log_filename = "winscp_upload.log" if operation_type == "upload" else "winscp_download.log"
+    winscp_log_path = os.path.join(local_storage_path, log_filename)
+
+    # Session and directory setup
+    session_name = endpoint_config.get('session_name', '')
+    remote_directory = endpoint_config['remote_directory_up'] if operation_type == "upload" else endpoint_config['remote_directory_down']
+
+    # Command building
+    command = [
+        winscp_path,
+        '/log=' + winscp_log_path,
+        '/loglevel=1',
+        '/command',
+        'open {}'.format(session_name),
+        'cd /',
+        'cd {}'.format(remote_directory)
+    ]
+
+    # Add commands to WinSCP script
+    # BUG We really need to fix this path situation.
+    #  Unfortunately, this just needs to be a non-spaced path because WinSCP can't
+    #  handle the spaces. Also, Windows won't let me use shutil to move the files out of G:\ into C:\ and it it wants an administrator security 
+    #  check or verification thing for me to even move the file by hand so that doesn't work either. 
+    #  command.append("put {}".format("C:\\Z_optumedi_04161742.txt"))
+    if operation_type == "upload":
+        for file_path in files:
+            normalized_path = os.path.normpath(file_path)
+            command.append("put \"{}\"".format(normalized_path))
+    else:
+        command.append('get *')  # Adjust pattern as needed
+
+    command += ['close', 'exit']
+
+    # Execute command
+    # process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False)
+    # stdout, stderr = process.communicate()
+    
+    if True: #process.returncode == 0:
+        print("WINSCP IS CURRENTLY DISABLED FOR TESTING.") # BUG
+        logging.info("Files {}ed successfully.".format(operation_type))
+        # BUG This return code is a little trigger happy.
+        # BUG If the WinSCP command specifies the correct download path, this might not be necessary
+        # move_downloaded_files(local_storage_path)
+        return True
+    else:
+        logging.error("Failed to {} files. Details: {}".format(operation_type, stderr.decode('utf-8')))
+        return False
+
+# UNUSED CSV Functions
+def remove_blank_rows_from_csv(csv_file_path):
+    with open(csv_file_path, 'r') as csv_file:
+        # Read the CSV file and filter out any empty rows
+        rows = [row for row in csv.reader(csv_file) if any(field.strip() for field in row)]
+    
+    # Write the filtered rows back to the CSV file
+    with open(csv_file_path, 'w', newline='') as csv_file:
+        writer = csv.writer(csv_file)
+        writer.writerows(rows)
+
+def list_chart_numbers_in_existing_file(filepath):
+    """Lists the Chart Numbers contained in an existing CSV file."""
+    chart_numbers = []
+    with open(filepath, 'r', newline='') as csvfile:
+        reader = csv.reader(csvfile)
+        next(reader)  # Skip header
+        for row in reader:
+            if len(row) > 2:  # Assuming Chart Number is in the 3rd column
+                chart_numbers.append(row[2])
+    return chart_numbers

medicafe-0.240419.2/MediLink/MediLink_Down.py

@@ -0,0 +1,151 @@
+import os
+import logging
+import argparse
+import shutil
+from datetime import datetime
+import glob
+import MediLink_ERA_decoder
+from MediLink_DataMgmt import operate_winscp
+import MediLink_ConfigLoader
+
+"""
+We need to make another function that figures out claim rejections and tries to solve them.
+
+1. Config File Path Adjustment: Ensure the configuration file's path is adaptable for various environments, or clearly document the process for setting this path.
+2. Logging Enhancements: Improve the logging mechanism to offer comprehensive insights through both file and console outputs, aiding in troubleshooting and operational monitoring.
+3. CSV Output Refinement: Update the CSV output structure to include essential ERA data such as Payer Address, ensuring completeness and accuracy of information.
+4. CSV Consolidation Logic: Develop logic for intelligently consolidating CSV outputs from batch-processed ERA files, ensuring coherent and comprehensive data aggregation.
+5. Secure Endpoint Authentication: Establish a secure method for inputting and storing endpoint authentication details, enhancing script security.
+6. Automated Endpoint Processing: Integrate automated looping through configured endpoints for ERA file retrieval, maximizing efficiency and reducing manual oversight.
+7. Configuration Key Accuracy: Audit the script to correct any inaccuracies in configuration key references, ensuring seamless configuration data retrieval.
+"""
+
+# Setup basic logging
+def setup_logger(local_storage_path):
+    # Define a reasonable name for the log file, e.g., "MediLink_Down_Process.log"
+    log_filename = datetime.now().strftime("MediLink_Down_Process_%m%d%Y.log")
+    log_filepath = os.path.join(local_storage_path, log_filename)
+
+    for handler in logging.root.handlers[:]:
+        logging.root.removeHandler(handler)
+    
+    # Setup logging to file
+    logging.basicConfig(level=logging.INFO,
+                        format='%(asctime)s - %(levelname)s - %(message)s',
+                        filename=log_filepath,  # Direct logging to a file in local_storage_path
+                        filemode='a')  # Append mode
+
+    # If you also want to see the logs in the console, add a StreamHandler
+    #console_handler = logging.StreamHandler()
+    #console_handler.setLevel(logging.INFO)
+    #formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+    #console_handler.setFormatter(formatter)
+    #logging.getLogger('').addHandler(console_handler)
+
+# Because I can't figure out how to get it to work directly in the WinSCP command.
+# And on the Windows XP machine apparently the default path is C:\\ ...
+# This needs to get fixed. Ugh.
+def move_downloaded_files(local_storage_path):
+    # Define the target directory for storing downloaded files
+    local_response_directory = os.path.join(local_storage_path, "responses")
+    
+    if not os.path.exists(local_response_directory):
+        os.makedirs(local_response_directory)
+    
+    # Identify all downloaded .era files in the current directory
+    # downloaded_files = [f for f in os.listdir('.') if f.endswith('.era')]
+    downloaded_files = [f for f in os.listdir('C:\\Users\\danie\\OneDrive\\Documents') if f.endswith('.era')]
+    
+    # Move each file to the local_response_directory
+    for file in downloaded_files:
+        source_path = os.path.join('C:\\Users\\danie\\OneDrive\\Documents', file)
+        # source_path = os.path.join('.', file)    for the XP machine? -- This whole thing needs repaired. 
+        destination_path = os.path.join(local_response_directory, file)
+        shutil.move(source_path, destination_path)
+        logging.info("Moved '{}' to '{}'".format(file, local_response_directory))
+
+def find_era_files(era_file_path):
+    """
+    Find all files matching the era_file_path pattern.
+    This function normalizes the path and supports wildcard patterns.
+    """
+    # Normalize the path to handle slashes correctly
+    normalized_path = os.path.normpath(era_file_path)
+
+    # Handling different wildcard scenarios
+    if "*" in normalized_path:
+        # Use glob to find all files matching the pattern
+        matching_files = glob.glob(normalized_path)
+        # Normalize paths in the resulting list
+        return [os.path.normpath(file) for file in matching_files]
+    else:
+        # Single file specified, return it in a list if it exists
+        return [normalized_path] if os.path.exists(normalized_path) else []
+
+def main(desired_endpoint='AVAILITY'):
+    parser = argparse.ArgumentParser(description="Process ERA files and convert them to CSV format.")
+    parser.add_argument('--config_path', type=str, help='Path to the configuration JSON file', default="json\\config.json") # Default handling of json path
+    parser.add_argument('--desired_endpoint', type=str, help='The desired endpoint key from the configuration.', default=desired_endpoint)
+    parser.add_argument('--era_file_path', type=str, help='Optional: Specify a path to an ERA file for direct translation.', default=None)
+    args = parser.parse_args()
+    
+    # Setup Logger, Load configuration and output directory
+    config, _ = MediLink_ConfigLoader.load_configuration(args.config_path)
+    local_storage_path = config['MediLink_Config']['local_storage_path']
+    setup_logger(local_storage_path)
+    output_directory = os.path.join(local_storage_path, "translated_csvs")
+     
+    # Direct ERA file translation if a file path is provided
+    if args.era_file_path:
+        era_files = find_era_files(args.era_file_path)
+        if era_files:
+            era_files_str = ', '.join(era_files)
+            logging.info("Translating ERA files: {}".format(era_files_str))
+            MediLink_ERA_decoder.translate_era_to_csv(era_files, output_directory)
+            # Instead of returning a single CSV file path, consolidate here
+            consolidate_csv_path = MediLink_ERA_decoder.consolidate_csvs(output_directory)
+            logging.info("Translation and consolidation completed.")
+            return consolidate_csv_path
+        else:
+            logging.error("No ERA files found matching: {}".format(args.era_file_path))
+            return
+    
+    # TODO This probably needs to be built into a loop that cycles through all 3 endpoints. 
+    # The loop should use the tdqa or whatever the progress bar is called.
+    print("Please wait...\n")
+    
+    # Validate endpoint key
+    endpoint_key = args.desired_endpoint
+    if endpoint_key not in config['MediLink_Config']['endpoints']:
+        logging.error("Endpoint '{}' not found in configuration. Using default 'AVAILITY'.".format(endpoint_key))
+        endpoint_key = 'AVAILITY'
+    
+    # Retrieve endpoint configuration and local storage path
+    endpoint_config = config['MediLink_Config']['endpoints'][endpoint_key]
+    local_storage_path = config['MediLink_Config']['local_storage_path']
+        
+    # Download ERA files from the configured endpoint
+    downloaded_files = operate_winscp("download", None, endpoint_config, local_storage_path)
+    
+    # Translate downloaded ERA files to CSV format
+    translated_csv_paths = []
+    for file in downloaded_files:
+        # TODO This needs to add functionality for differentiating between ERA and 277 or 
+        # whatever else might be included in the download folders.
+        MediLink_ERA_decoder.translate_era_to_csv([file], output_directory)
+        csv_file_path = os.path.join(output_directory, os.path.basename(file) + '.csv')
+        translated_csv_paths.append(csv_file_path)
+        logging.info("Translated ERA to CSV: {}".format(csv_file_path))
+    
+    # Consolidate new CSVs
+    consolidate_csv_path = MediLink_ERA_decoder.consolidate_csvs(output_directory)
+    
+    # Return the list of translated CSV file paths
+    return consolidate_csv_path
+
+if __name__ == "__main__":
+    consolidate_csv_path = main()
+    if consolidate_csv_path:
+        print("CSV File Created: {}".format(consolidate_csv_path))
+    else:
+        print("No CSV file was created.")

medicafe-0.240419.2/MediLink/MediLink_ERA_decoder.py

@@ -0,0 +1,192 @@
+import os
+import logging
+import sys
+from MediLink_ConfigLoader import setup_logger, load_configuration
+from MediLink_DataMgmt import consolidate_csvs
+
+"""
+1. ERA File Processing: Implement robust mechanisms for reading and parsing ERA files, addressing potential file integrity issues and accommodating scenarios with multiple payer addresses within a single ERA.
+2. Wildcard File Processing: Enable effective batch processing of ERA files using wildcard patterns in the `--era_file_path` argument, resulting in a unified CSV output.
+3. Date of Service Parsing: Enhance the parsing logic for 'Date of Service' to accommodate different segment identifiers, improving data extraction reliability.
+4. Payer Address Extraction: Fine-tune the logic for extracting payer and provider addresses from ERA files, ensuring only relevant information is captured.
+5. De-persisting Intermediate Files.
+"""
+
+# ERA Parser
+def parse_era_content(content):
+    extracted_data = []
+    normalized_content = content.replace('~\n', '~')
+    lines = normalized_content.split('~')
+    
+    # Reset these values for each new CLP segment
+    record = {}
+    check_eft, payer_address = None, None
+    allowed_amount, write_off, patient_responsibility, adjustment_amount = 0, 0, 0, 0
+    is_payer_section = False  # Flag to identify payer section for accurate address capture
+    
+    for line in lines:
+        segments = line.split('*')
+        
+        if segments[0] == 'TRN' and len(segments) > 2:
+            check_eft = segments[2]
+            
+        # Determine the start and end of the payer section to correctly capture the payer's address
+        if segments[0] == 'N1':
+            if segments[1] == 'PR':  # Payer information starts
+                is_payer_section = True
+                # payer_name = segments[2]  # Can capture payer name here if needed
+            elif segments[1] == 'PE':  # Provider information starts, ending payer section
+                is_payer_section = False
+        
+        # Correctly capture payer address only within payer section
+        if is_payer_section and segments[0] == 'N3' and len(segments) > 1:
+            payer_address = segments[1]
+        
+        if segments[0] == 'CLP' and len(segments) >= 5:
+            if record:
+                if adjustment_amount == 0 and (write_off > 0 or patient_responsibility > 0):
+                    adjustment_amount = write_off + patient_responsibility
+
+                # Finalize and append the current record before starting a new one
+                record.update({
+                    # 'Payer Name': payer_name,
+                    'Payer Address': payer_address,
+                    'Allowed Amount': allowed_amount,
+                    'Write Off': write_off,
+                    'Patient Responsibility': patient_responsibility,
+                    'Adjustment Amount': adjustment_amount, 
+                })
+                extracted_data.append(record)
+                
+                # Reset variables for the next record
+                allowed_amount, write_off, patient_responsibility, adjustment_amount = 0, 0, 0, 0
+                # payer_address = None  # Reset address for the next CLP segment if it changes within one ERA file (so no. disable.)
+            
+            # Initialize a new record
+            record = {
+                'Check EFT': check_eft,
+                'Chart Number': segments[1],
+                'Payer Address': payer_address,
+                'Amount Paid': segments[4],
+                'Charge': segments[3],  # Total submitted charges for the claim
+            }
+        
+        elif segments[0] == 'CAS':
+            # Parsing CAS segments for Write Off and Patient Responsibility
+            if segments[1] == 'CO':  # Write Off
+                write_off += float(segments[3])
+            elif segments[1] == 'PR':  # Patient Responsibility
+                patient_responsibility += float(segments[3])
+            elif segments[1] == 'OA':  # Capture Adjustment Amount from CAS*OA segment
+                adjustment_amount += float(segments[3])
+        
+        elif segments[0] == 'AMT' and segments[1] == 'B6':
+            # Allowed Amount from AMT segment
+            allowed_amount += float(segments[2])
+        
+        elif segments[0] == 'DTM' and (segments[1] == '232' or segments[1] == '472'):
+            record['Date of Service'] = segments[2]
+    
+
+    if record:
+    # Final record handling
+        if adjustment_amount == 0 and (write_off > 0 or patient_responsibility > 0):
+            adjustment_amount = write_off + patient_responsibility
+        # Append the last record
+        record.update({
+            'Allowed Amount': allowed_amount,
+            'Write Off': write_off,
+            'Patient Responsibility': patient_responsibility,
+            'Adjustment Amount': adjustment_amount, 
+        })
+        extracted_data.append(record)
+        
+    return extracted_data
+
+def translate_era_to_csv(files, output_directory):
+    if not os.path.exists(output_directory):
+        os.makedirs(output_directory)
+    
+    for file_path in files:
+        # Ensure the file is read correctly
+        with open(file_path, 'r') as era_file:
+            era_content = era_file.read()
+        
+        data = parse_era_content(era_content)
+        # print("Parsed Data: ", data)  # DEBUG
+        
+        csv_file_path = os.path.join(output_directory, os.path.basename(file_path) + '.csv')
+        
+        try:
+            # Open the CSV file with explicit newline handling
+            with open(csv_file_path, 'w', newline='') as csv_file:
+                fieldnames = ['Date of Service',
+                              'Check EFT', 
+                              'Chart Number', 
+                              'Payer Address', 
+                              'Amount Paid', 
+                              'Adjustment Amount',
+                              'Allowed Amount',
+                              'Write Off',
+                              'Patient Responsibility',
+                              'Charge'
+                              ]
+                writer = csv.DictWriter(csv_file, fieldnames=fieldnames)
+                
+                writer.writeheader()
+                for record in data:
+                    
+                    # print("Writing record: ", record)
+                    
+                    writer.writerow({
+                        'Date of Service': record.get('Date of Service', ''),
+                        'Check EFT': record.get('Check EFT', ''),
+                        'Chart Number': record.get('Chart Number', ''),
+                        'Payer Address': record.get('Payer Address', ''),
+                        'Amount Paid': record.get('Amount Paid', ''),
+                        'Adjustment Amount': record.get('Adjustment Amount', ''),
+                        'Allowed Amount': record.get('Allowed Amount', ''),
+                        'Write Off': record.get('Write Off', ''),
+                        'Patient Responsibility': record.get('Patient Responsibility', ''),
+                        'Charge': record.get('Charge', ''),
+                    })
+                # Explicitly flush data to ensure it's written
+                csv_file.flush()
+        except Exception as e:
+            print("Error writing CSV: ", e)
+
+# User Interface
+def user_confirm_overwrite(chart_numbers):
+    """Asks the user for confirmation to overwrite an existing file, showing Chart Numbers."""
+    print("The following Chart Numbers are in the existing file:")
+    for number in chart_numbers:
+        print(number)
+    return input("The file already exists. Do you want to overwrite it? (y/n): ").strip().lower() == 'y'
+
+if __name__ == "__main__":
+    # Load configuration
+    
+    config, _ = load_configuration()
+    
+    # Setup logger
+    local_storage_path = config['MediLink_Config']['local_storage_path']
+    setup_logger(local_storage_path)
+    
+    # Define output directory
+    output_directory = os.path.join(local_storage_path, "translated_csvs")
+    
+    # Retrieve ERA files from command line arguments
+    files = sys.argv[1:]  # Exclude the script name
+    if not files:
+        logging.error("No ERA files provided as arguments.")
+        sys.exit(1)
+
+    # Translate ERA files to CSV format
+    translate_era_to_csv(files, output_directory)
+    
+    # Consolidate CSVs
+    consolidate_csv_path = consolidate_csvs(output_directory)
+    if consolidate_csv_path:
+        print("Consolidated CSV File Created: {}".format(consolidate_csv_path))
+    else:
+        print("No CSV file was created.")

medicafe-0.240419.2/MediLink/MediLink_Gmail.py

@@ -0,0 +1,4 @@
+"""
+Get new filtered GMail emails with Carol's CSV, make OTP request, login, download CSV.
+Also download the surgery schedule.
+"""