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

MediLink/MediLink_837p_encoder_library.py

@@ -1,30 +1,31 @@
 from datetime import datetime
-import json
-import requests
-import time
 import sys
-import MediLink_ConfigLoader
+from MediLink import MediLink_ConfigLoader
+
+# Add parent directory of the project to the Python path
+import sys
+import os
+project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.append(project_dir)
+
+from MediBot import MediBot_Preprocessor_lib
+load_insurance_data_from_mains = MediBot_Preprocessor_lib.load_insurance_data_from_mains
+from MediBot import MediBot_Crosswalk_Library
+from MediLink_API_v2 import fetch_payer_name_from_api
 
 """
-1. Code Refactoring: Increase modularity and clarity, particularly in segment creation functions (e.g., `create_st_segment`, `create_nm1_billing_provider_segment`), for better maintenance and readability.
-2. Endpoint Support: Extend support within segment creation for additional endpoints with attention to their unique claim submission requirements.
-3. Payer Identification Mechanism: Refine the mechanism for dynamically identifying payers, leveraging payer mappings and integrating with external APIs like Availity for precise payer information retrieval.
-4. Adherence to Endpoint-Specific Standards: Implement and verify the compliance of claim data formatting and inclusion based on the specific demands of each target endpoint within the segment creation logic.
-5. De-persisting Intermediate Files.
-6. Get an API for Optum "Entered As". 
+- [ ] 1. Code Refactoring: Increase modularity and clarity, particularly in segment creation functions (e.g., `create_st_segment`, `create_nm1_billing_provider_segment`), for better maintenance and readability.
+- [ ] 2. Endpoint Support: Extend support within segment creation for additional endpoints with attention to their unique claim submission requirements.
+- [ ] 3. Payer Identification Mechanism: Refine the mechanism for dynamically identifying payers, leveraging payer mappings and integrating with external APIs like Availity for precise payer information retrieval.
+- [ ] 4. Adherence to Endpoint-Specific Standards: Implement and verify the compliance of claim data formatting and inclusion based on the specific demands of each target endpoint within the segment creation logic.
+- [ ] 5. De-persisting Intermediate Files.
+- [ ] 6. Get an API for Optum "Entered As". 
+- [ ] 7. (MED) Add Authorization Number 
+- [X] 8. (HIGH) Interchange number should be 000HHMMSS instead of fixed constant.
+- [ ] 9. Upgrade Interchange formation to consolidate the batch processor and also de-risk batch 
+         interchange number matching for multiple .DAT.
 """
 
-# Logs messages with optional error type and claim data.
-def log(message, config='', level="INFO", error_type=None, claim=None):
-    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    level = level.upper()  # Ensure the log level is in uppercase for consistency
-    claim_data = "- Claim Data: {}\n".format(claim) if claim else ""
-    error_info = "- Error Type: {}\n".format(error_type) if error_type else ""
-    full_message = "[{}] {} - {} {} {}\n".format(timestamp, level, message, claim_data, error_info).strip()
-    log_file_path = 'process_log.txt' if config == '' else config.get('logFilePath', 'process_log.txt')
-    with open(log_file_path, 'a') as log_file:
-        log_file.write(full_message)
-
 # Converts date format from one format to another.
 def convert_date_format(date_str):
     # Parse the input date string into a datetime object using the input format    
@@ -137,15 +138,34 @@ def create_service_facility_location_npi_segment(config):
     return [nm1_segment, n3_segment, n4_segment]
 
 # Constructs the NM1 segment for submitter name and includes PER segment for contact information.
-def create_1000A_submitter_name_segment(config, endpoint):
+def create_1000A_submitter_name_segment(patient_data, config, endpoint):
+    """
+    Creates the 1000A submitter name segment, including the PER segment for contact information.
+
+    Args:
+        patient_data (dict): Enriched patient data containing payer information.
+        config (dict): Configuration settings.
+        endpoint (str): Intended Endpoint for resolving submitter information.
+
+    Returns:
+        list: A list containing the NM1 segment for the submitter name and the PER segment for contact information.
+    """
     endpoint_config = config['endpoints'].get(endpoint.upper(), {})
     submitter_id_qualifier = endpoint_config.get('submitter_id_qualifier', '46')  # '46' for ETIN or 'XX' for NPI
     submitter_name = endpoint_config.get('nm_103_value', 'DEFAULT NAME')  # Default name if not in config
-    submitter_id = endpoint_config.get('nm_109_value', 'DEFAULT ID')  # Default ID if not specified in endpoint
+    
+    # Extract payer_id from patient_data
+    payer_id = patient_data.get('payer_id', '')
+    
+    # Check if payer_id is Florida Blue (00590 or BCBSF) and assign submitter_id accordingly
+    if payer_id in ['00590', 'BCBSF']:
+        submitter_id = endpoint_config.get('nm_109_bcbsf', 'DEFAULT BCBSF ID')
+    else:
+        submitter_id = endpoint_config.get('nm_109_value', 'DEFAULT ID')  # Default ID if not specified in endpoint
     
     # Submitter contact details
-    contact_name = config.get('submitter_contact_name', 'RAFAEL OLIVERVIDAUD')
-    contact_telephone_number = config.get('submitter_contact_tel', '9543821782')
+    contact_name = config.get('submitter_name', 'NONE')
+    contact_telephone_number = config.get('submitter_tel', 'NONE')
     
     # Construct NM1 segment for the submitter
     nm1_segment = "NM1*41*2*{}*****{}*{}~".format(submitter_name, submitter_id_qualifier, submitter_id)
@@ -174,123 +194,240 @@ def create_1000B_receiver_name_segment(config, endpoint):
         receiver_edi=receiver_edi
     )
 
-def map_insurance_name_to_payer_id(insurance_name, config):
+def payer_id_to_payer_name(parsed_data, config, endpoint):
     """
-    Maps the insurance name provided by Medisoft to the corresponding payer ID by referencing
-    a crosswalk mapping stored in the "crosswalk" JSON file. This file must be located at a path
-    specified in the config under the key 'crosswalk_path'.
+    Preprocesses payer information from parsed data and enriches parsed_data with the payer name and ID.
 
-    Inputs:
-    - insurance_name: The name of the insurance as provided by Medisoft.
+    Args:
+        parsed_data (dict): Parsed data containing Z-dat information.
+        config (dict): Configuration settings.
+        endpoint (str): Intended Endpoint for resolving payer information.
 
-    Outputs:
-    - payer_id: The unique identifier (ID) corresponding to the insurance name, if the mapping
-      is successful. It will be a 5-character alphanumeric code.
+    Returns:
+        dict: Enriched parsed data with payer name and payer ID.
+    """
+    # Step 1: Extract insurance name from parsed data
+    insurance_name = parsed_data.get('INAME', '')
 
-    Functionality:
-    - This function retrieves the mapping from a "crosswalk" JSON file.
-    - If the mapping is successful, it returns the payer ID.
-    - If the mapping fails or the payer ID cannot be retrieved, it raises an error indicating
-      the inability to extract the payer ID.
+    # Step 2: Map insurance name to payer ID
+    payer_id = map_insurance_name_to_payer_id(insurance_name, config)
+
+    # Step 3: Validate payer_id
+    if payer_id is None:
+        error_message = "Payer ID for '{}' cannot be None.".format(insurance_name)
+        MediLink_ConfigLoader.log(error_message, level="WARNING")
+        raise ValueError(error_message)
+
+    # Step 4: Resolve payer name using payer ID
+    payer_name = resolve_payer_name(payer_id, config, endpoint, insurance_name, parsed_data)
+
+    # Enrich parsed_data with payer name and payer ID
+    parsed_data['payer_name'] = payer_name
+    parsed_data['payer_id'] = payer_id
+
+    return parsed_data
+
+# Then you can use the enriched parsed_data in your main function
+def create_2010BB_payer_information_segment(parsed_data):
     """
-    _, crosswalk = MediLink_ConfigLoader.load_configuration(None, config.get('crosswalkPath', 'crosswalk.json'))
-    
-    try:
-        payer_id = crosswalk['medisoft_insurance_to_payer_id'].get(insurance_name)
-        if not payer_id:
-            raise ValueError("No payer ID found for insurance name: {}".format(insurance_name))
-        return payer_id
-    except json.JSONDecodeError:
-        raise ValueError("Error decoding the crosswalk JSON file")
+    Creates the 2010BB payer information segment.
 
-def fetch_payer_name_from_crosswalk(payer_id, config, endpoint):
+    Args:
+        parsed_data (dict): Parsed data containing enriched payer information.
+
+    Returns:
+        str: The 2010BB payer information segment.
     """
-    Retrieves the payer name corresponding to a given payer ID from a crosswalk mapping.
-    
-    Parameters:
-    - payer_id: The unique identifier for the payer whose name is to be resolved.
-    - config: Configuration dictionary including the path to the crosswalk JSON.
-    
+    # Extract enriched payer name and payer ID
+    payer_name = parsed_data.get('payer_name')
+    payer_id = parsed_data.get('payer_id')
+
+    # Validate payer_name and payer_id
+    if not payer_name or not payer_id:
+        error_message = "Payer name and payer ID must be provided."
+        raise ValueError(error_message)
+
+    # Build NM1 segment using provided payer name and payer ID
+    return build_nm1_segment(payer_name, payer_id)
+
+def resolve_payer_name(payer_id, config, primary_endpoint, insurance_name, parsed_data):
+    """
+    Resolves the payer name using the provided payer ID.
+
+    Args:
+        payer_id (str): The ID of the payer.
+        config (dict): Configuration settings.
+        primary_endpoint (str): The primary endpoint for resolving payer information.
+        insurance_name (str): The name of the insurance.
+        parsed_data (dict): Parsed data containing patient information.
+
     Returns:
-    - The payer name corresponding to the payer ID.
-    
-    Raises:
-    - ValueError if the payer ID is not found in the crosswalk mapping.
+        str: The resolved payer name.
     """
-    # Ensure the 'crosswalkPath' key exists in config and contains the path to the crosswalk JSON file
-    if 'crosswalkPath' not in config:
-        raise ValueError("Crosswalk path not defined in configuration.")
 
-    crosswalk_path = config.get('crosswalkPath')
+    # Step 1: Attempt to fetch payer name from API using primary endpoint
+    MediLink_ConfigLoader.log("Attempting to resolve Payer ID {} via API.".format(payer_id), level="INFO")
     try:
-        with open(crosswalk_path, 'r') as file:
-            crosswalk_mappings = json.load(file)
-        # Select the endpoint-specific section from the mappings
-        endpoint_mappings = crosswalk_mappings['payer_id_to_name'].get(endpoint, {})
-        payer_name = endpoint_mappings.get(payer_id)
-
-        if not payer_name:
-            raise ValueError("Payer name not found for payer ID: {} in {} mappings.".format(payer_id, endpoint))
+        return fetch_payer_name_from_api(payer_id, config, primary_endpoint)
+    except Exception as api_error:
+        # Step 2: Log API resolution failure and initiate user intervention
+        MediLink_ConfigLoader.log("API resolution failed for {}: {}. Initiating user intervention.".format(payer_id, str(api_error)), config, level="WARNING")
+        
+        # Step 3: Print warning message for user intervention
+        print("\n\nWARNING: Unable to verify Payer ID '{}' for patient '{}'!".format(payer_id, parsed_data.get('CHART', 'unknown')))
+        print("         Claims for '{}' may be incorrectly\nrouted or fail without intervention.".format(insurance_name))
+        print("\nACTION REQUIRED: Please verify the internet connection and the Payer ID by searching for it")
+        print("at the expected endpoint's website or using Google.")
+        print("\nNote: If the Payer ID '{}' is incorrect for '{}', \nit may need to be manually corrected.".format(payer_id, insurance_name))
+        print("If the Payer ID appears correct, you may skip the correction and force-continue with this one.")
+        print("\nPlease check the Payer ID in the Crosswalk and the initial \ndata source (e.g., Carol's CSV) as needed.")
+        print("If unsure, llamar a Dani for guidance on manual corrections.")
+
+        # Step 4: Integrate user input logic
+        user_decision = input("\nType 'FORCE' to force-continue with the Medisoft name, \nor press Enter to pause processing and make corrections: ")
+        user_decision = user_decision.strip().lower()  # Convert to lowercase and remove leading/trailing whitespace
+        if user_decision == 'force':
+            # Step 5: Fallback to truncated insurance name
+            truncated_name = insurance_name[:10]  # Temporary fallback
+            MediLink_ConfigLoader.log("Using truncated insurance name '{}' as a fallback for {}".format(truncated_name, payer_id), config, level="WARNING")
+            return truncated_name
+        elif not user_decision:  # Check if user pressed Enter
+            corrected_payer_id = prompt_user_for_payer_id(insurance_name)
+            if corrected_payer_id:
+                try:
+                    resolved_name = fetch_payer_name_from_api(corrected_payer_id, config, primary_endpoint)
+                    print("API resolved to insurance name: {}".format(resolved_name))
+                    MediLink_ConfigLoader.log("API Resolved to standard insurance name: {} for corrected payer ID: {}".format(resolved_name, corrected_payer_id), config, level="INFO")
+                    
+                    confirmation = input("Is the standard insurance name '{}' correct? (yes/no): ".format(resolved_name)).strip().lower()
+                    
+                    if confirmation in ['yes', 'y']:
+                        if MediBot_Crosswalk_Library.update_crosswalk_with_corrected_payer_id(payer_id, corrected_payer_id):
+                            return resolved_name
+                        else:
+                            print("Failed to update crosswalk with the corrected Payer ID.")
+                            exit(1) # probably needs a different failure direction here.
+                    else:
+                        print("User did not confirm the standard insurance name. Manual intervention is required.")
+                        MediLink_ConfigLoader.log("User did not confirm the standard insurance name. Manual intervention is required.", config, level="CRITICAL")
+                        exit(1) # probably needs a different failure direction here.
+                except Exception as e:
+                    print("Failed to resolve corrected payer ID to standard insurance name: {}".format(e))
+                    MediLink_ConfigLoader.log("Failed to resolve corrected payer ID to standard insurance name: {}".format(e), config, level="ERROR")
+                    exit(1) # probably needs a different failure direction here.
+            else:
+                print("Exiting script. Please make the necessary corrections and retry.")
+                exit(1) # probably needs a different failure direction here.
+
+def prompt_user_for_payer_id(insurance_name):
+    """
+    Prompts the user to input the payer ID manually.
+    """
+    print("Manual intervention required: No payer ID found for insurance name '{}'.".format(insurance_name))
+    payer_id = input("Please enter the payer ID manually: ").strip()
+    return payer_id
 
-        return payer_name
-    except FileNotFoundError:
-        raise FileNotFoundError("Crosswalk file not found at {}".format(crosswalk_path))
-    except json.JSONDecodeError as e:
-        raise ValueError("Error decoding the crosswalk JSON file: {}".format(e))
+def build_nm1_segment(payer_name, payer_id):
+    # Step 1: Build NM1 segment using payer name and ID
+    return "NM1*PR*2*{}*****PI*{}~".format(payer_name, payer_id)
 
-def create_2010BB_payer_information_segment(parsed_data, config, endpoint):
+def map_insurance_name_to_payer_id(insurance_name, config):
     """
-    Dynamically generates the NM1 segment for the payer in the 2010BB loop of an 837P transaction.
-    This process involves mapping the insurance name to the correct payer ID and then resolving the payer name.
-    The function prioritizes the Availity API for payer name resolution (currently the only API integrated) 
-    and falls back to crosswalk mapping if necessary or when additional APIs are not available.
-    
-    Parameters:
-    - parsed_data: Dictionary containing parsed claim data, including the insurance name.
-    - config: Configuration dictionary including endpoint-specific settings and crosswalk paths.
-    - endpoint: Target endpoint for submission, e.g., 'Availity'. Future integrations may include 'Optum', 'PNT_DATA'.
+    Maps insurance name to payer ID using the crosswalk configuration.
+
+    Args:
+        insurance_name (str): Name of the insurance.
+        config (dict): Configuration settings.
 
     Returns:
-    - A formatted NM1*PR segment string for the 2010BB loop, correctly identifying the payer with its name and ID.
+        str: The payer ID corresponding to the insurance name.
+    """
+    try:
+        # Ensure crosswalk is initialized and 'payer_id' key is available
+        MediBot_Crosswalk_Library.check_and_initialize_crosswalk(config)
+        
+        # Load crosswalk configuration
+        _, crosswalk = MediLink_ConfigLoader.load_configuration(None, config.get('crosswalkPath', 'crosswalk.json'))
+        
+        # Load insurance data from MAINS to get insurance ID
+        insurance_to_id = load_insurance_data_from_mains(config)
+        
+        # Get medisoft ID corresponding to the insurance name
+        medisoft_id = insurance_to_id.get(insurance_name)
+        if medisoft_id is None:
+            error_message = "No Medisoft ID found for insurance name: {}. Consider checking MAINS directly.".format(insurance_name)
+            MediLink_ConfigLoader.log(error_message, config, level="ERROR")
+            raise ValueError(error_message)
+        
+        # Convert medisoft_id to string to match the JSON data type
+        medisoft_id_str = str(medisoft_id)
+        
+        # Get payer ID corresponding to the medisoft ID
+        payer_id = None
+        for payer, payer_info in crosswalk['payer_id'].items():
+            if medisoft_id_str in payer_info['medisoft_id']:
+                payer_id = payer
+                break
+
+        # Handle the case where no payer ID is found
+        if payer_id is None:
+            error_message = "No payer ID found for Medisoft ID: {}".format(medisoft_id)
+            MediLink_ConfigLoader.log(error_message, config, level="ERROR")
+            print(error_message)
+            payer_id = handle_missing_payer_id(insurance_name, config)
 
-    Process:
-    1. Maps the insurance name to a payer ID using a crosswalk mapping or configuration.
-    2. Attempts to resolve the payer name using the Availity API based on the payer ID.
-    3. Falls back to crosswalk mapping for payer name resolution if the API call fails or is not applicable.
-    
-    Raises an error if the payer ID extraction or payer name resolution fails, ensuring transaction integrity.
-    
-    A reference for a payer ID to payer name mapping for Optum can be found here:
-    https://iedi.optum.com/iedi/enspublic/Download/Payerlists/Medicalpayerlist.pdf
-    This or similar resources could be used to populate the initial configuration mapping.
+        return payer_id
+
+    except ValueError as e:
+        if "JSON" in str(e) and "decode" in str(e):
+            error_message = "Error decoding the crosswalk JSON file in map_insurance_name_to_payer_id"
+            MediLink_ConfigLoader.log(error_message, config, level="CRITICAL")
+            raise ValueError(error_message)
+        else:
+            error_message = "Unexpected error in map_insurance_name_to_payer_id: {}".format(e)
+            MediLink_ConfigLoader.log(error_message, config, level="ERROR")
+            raise e
+
+def handle_missing_payer_id(insurance_name, config):
     """
-    # Step 1: Map insurance name to Payer ID
-    insurance_name = parsed_data.get('INAME', '')
-    payer_id = map_insurance_name_to_payer_id(insurance_name, config)
+    Handles cases where the payer ID is not found for a given Medisoft ID.
 
-    payer_name = ''
-    # Step 2: Attempt to Retrieve Payer Name from Availity API (current API integration)
-    endpoint = 'availity' # Force availity API because none of the other ones are connected BUG
-    if True: #endpoint.lower() == 'availity':
-        try:
-            payer_name = fetch_payer_name_from_api(payer_id, config, endpoint)
-            log("Resolved payer name {} via {} API for Payer ID: {}".format(payer_name, endpoint, payer_id), config, level="INFO")
-        except Exception as api_error:
-            print("{} API call failed for Payer ID '{}': {}".format(endpoint, payer_id, api_error))
-
-    # Placeholder for future API integrations with other endpoints
-    # elif endpoint.lower() == 'optum':
-    #     payer_name = fetch_payer_name_from_optum_api(payer_id, config)
-    # elif endpoint.lower() == 'pnt_data':
-    #     payer_name = fetch_payer_name_from_pnt_data_api(payer_id, config)
-
-    # Step 3: Fallback to Crosswalk Mapping if API resolution fails or is not applicable
-    if not payer_name:
-        payer_name = fetch_payer_name_from_crosswalk(payer_id, config, endpoint)
-
-    # Construct and return the NM1*PR segment for the 2010BB loop with the payer name and ID
-    # Is this supposed to be PI instead of PR?
-    return "NM1*PR*2*{}*****PI*{}~".format(payer_name, payer_id)
+    """
+    print("Missing Payer ID for insurance name: {}".format(insurance_name))
+    MediLink_ConfigLoader.log("Missing Payer ID for insurance name: {}".format(insurance_name), config, level="WARNING")
+
+    # Prompt the user for manual intervention to input the payer ID
+    payer_id = prompt_user_for_payer_id(insurance_name)
+    
+    if not payer_id:
+        message = "Unable to resolve missing Payer ID. Manual intervention is required."
+        MediLink_ConfigLoader.log(message, config, level="CRITICAL")
+        return None
+    
+    # Resolve the payer ID to a standard insurance name via API
+    try:
+        # primary_endpoint=None should kick to the default in the api function.
+        standard_insurance_name = resolve_payer_name(payer_id, config, primary_endpoint=None, insurance_name=insurance_name, parsed_data={})
+        message = "Resolved to standard insurance name: {} for payer ID: {}".format(standard_insurance_name, payer_id)
+        print(message)
+        MediLink_ConfigLoader.log(message, config, level="INFO")
+    except Exception as e:
+        message = "Failed to resolve payer ID to standard insurance name: {}".format(e)
+        print(message)
+        MediLink_ConfigLoader.log(message, config, level="ERROR")
+        return None
+    
+    # Ask for user confirmation
+    confirmation = input("Is the standard insurance name '{}' correct? (yes/no): ".format(standard_insurance_name)).strip().lower() or 'yes'
+    
+    if confirmation in ['yes', 'y']:
+        # Update the crosswalk with the new payer ID and insurance name mapping
+        MediBot_Crosswalk_Library.update_crosswalk_with_new_payer_id(insurance_name, payer_id, config)
+        return payer_id
+    else:
+        print("User did not confirm the standard insurance name. Manual intervention is required.")
+        MediLink_ConfigLoader.log("User did not confirm the standard insurance name. Manual intervention is required.", config, level="CRITICAL")
+        return None
 
 def create_nm1_payto_address_segments(config):
     """
@@ -324,102 +461,6 @@ def create_payer_address_segments(config):
 
     return [n3_segment, n4_segment]
 
-# Fetches the payer name from API based on the payer ID.
-# Initialize a global dictionary to store the access token and its expiry time
-# BUG This will need to get setup for each endpoint separately. 
-token_cache = {
-    'access_token': None,
-    'expires_at': 0  # Timestamp of when the token expires
-}
-
-def get_access_token(endpoint_config):
-    current_time = time.time()
-    
-    # Check if the cached token is still valid
-    if token_cache['access_token'] and token_cache['expires_at'] > current_time:
-        return token_cache['access_token']
-
-    # Validate endpoint configuration
-    if not endpoint_config or not all(k in endpoint_config for k in ['client_id', 'client_secret', 'token_url']):
-        raise ValueError("Endpoint configuration is incomplete or missing necessary fields.")
-
-    # Extract credentials and URL from the config
-    CLIENT_ID = endpoint_config.get("client_id")
-    CLIENT_SECRET = endpoint_config.get("client_secret")
-    url = endpoint_config.get("token_url")
-
-    # Setup the data payload and headers for the HTTP request
-    data = {
-        'grant_type': 'client_credentials',
-        'client_id': CLIENT_ID,
-        'client_secret': CLIENT_SECRET,
-        'scope': 'hipaa'
-    }
-    headers = {
-        'Content-Type': 'application/x-www-form-urlencoded'
-    }
-
-    try:
-        # Perform the HTTP request to get the access token
-        response = requests.post(url, headers=headers, data=data)
-        response.raise_for_status()  # This will raise an exception for HTTP error statuses
-        json_response = response.json()
-        access_token = json_response.get('access_token')
-        expires_in = json_response.get('expires_in', 3600)  # Default to 3600 seconds if not provided
-
-        if not access_token:
-            raise ValueError("No access token returned by the server.")
-        
-        # Store the access token and calculate the expiry time
-        token_cache['access_token'] = access_token
-        token_cache['expires_at'] = current_time + expires_in - 120  # Subtracting 120 seconds to provide buffer
-
-        return access_token
-    except requests.RequestException as e:
-        # Handle HTTP errors (e.g., network problems, invalid response)
-        error_msg = "Failed to retrieve access token: {0}. Response status: {1}".format(str(e), response.status_code if response else 'No response')
-        raise Exception(error_msg)
-    except ValueError as e:
-        # Handle specific errors like missing access token
-        raise Exception("Configuration or server response error: {0}".format(str(e)))
-
-def fetch_payer_name_from_api(payer_id, config, endpoint):
-    
-    endpoint_config = config['endpoints'].get(endpoint.upper(), {})
-    # Currently configured for Availity
-    token = get_access_token(endpoint_config)  # Get the access token using the function above
-       
-    api_url = endpoint_config.get("api_url", "")
-    headers = {
-        'Authorization': 'Bearer {0}'.format(token),
-        'Accept': 'application/json'
-    }
-    params = {'payerId': payer_id}
-    # print(params) DEBUG
-
-    try:
-        response = requests.get(api_url, headers=headers, params=params)
-        response.raise_for_status()  # This will raise an HTTPError if the HTTP request returned an unsuccessful status code
-        data = response.json()
-        # print(data) DEBUG
-                
-        # Check if 'payers' key exists and has at least one item
-        if 'payers' in data and data['payers']:
-            payer = data['payers'][0]
-            payer_name = payer.get('displayName') or payer.get('name', 'No name available')
-            return payer_name
-        else:
-            raise ValueError("No payer found for ID: {0}".format(payer_id))
-    except requests.RequestException as e:
-        print("Error fetching payer name: {0}".format(e))
-        raise
-
-# Test Case for API fetch
-#payer_id = "11347"
-#config = load_configuration() 
-#payer_name = fetch_payer_name_from_api(payer_id, config, endpoint='AVAILITY')
-#print(payer_id, payer_name)
-
 # Constructs the PRV segment for billing provider.
 def create_billing_prv_segment(config, endpoint):
     if endpoint.lower() == 'optumedi':
@@ -430,28 +471,118 @@ def create_billing_prv_segment(config, endpoint):
 def create_hl_subscriber_segment():
     return ["HL*2*1*22*0~"]
 
-# Constructs the SBR segment for subscriber based on parsed data and configuration.
+# (2000B Loop) Constructs the SBR segment for subscriber based on parsed data and configuration.
 def create_sbr_segment(config, parsed_data, endpoint):
     # Determine the payer responsibility sequence number code based on the payer type
     # If the payer is Medicare, use 'P' (Primary)
     # If the payer is not Medicare and is primary insurance, use 'P' (Primary)
     # If the payer is secondary insurance after Medicare, use 'S' (Secondary)
-    # For simplicity, we're going to assume everything is Primary for now.
+    # Assume everything is Primary for now.
     responsibility_code = 'P'
 
-    # Determine the insurance type code based on the payer
-    # Map different payers to their respective insurance type codes
-    # For simplicity, 'CI' (Commercial Insurance) as a default
-    insurance_type_code = 'CI'
+    # Insurance Type Code
+    insurance_type_code = insurance_type_selection(parsed_data)
 
     # Construct the SBR segment using the determined codes
     sbr_segment = "SBR*{responsibility_code}*18*******{insurance_type_code}~".format(
         responsibility_code=responsibility_code,
         insurance_type_code=insurance_type_code
     )
-
     return sbr_segment
 
+def insurance_type_selection(parsed_data):
+    """
+    Quick Fix: This funtion selects the insurance type for a patient based on predefined codes.
+    
+    TODO (HIGH SBR09) Finish making this function. 
+    This should  eventually integrate into a menu upstream. This menu flow probably needs to be alongside the suggested endpoint flow.
+    For now let's make a menu here and then figure out the automated/API method to getting this per patient as there are no
+    useful historical patterns other than to say that the default should be PPO (12), then CI, then FI as most common options, 
+    followed by the rest. 
+    
+    Present a user-selectable menu of insurance types based on predefined codes.
+    User needs to input the desired 2 character code for that patient or default to PPO.
+    
+    Currently implements a simple text-based selection menu to choose
+    an insurance type for a patient. The default selection is '12' for PPO, but the user
+    can input other codes as per the options listed. This initial implementation uses
+    simple input/output functions for selection and can be replaced in the future by a 
+    more dynamic interface or API-driven selection method.
+
+    Future Enhancements:
+    - Automate selection via an API that fetches patient data directly and auto-assigns the insurance type.
+    - Error handling to manage incorrect inputs and retry mechanisms.
+    
+    Parameters:
+    - parsed_data (dict): Contains patient's last name under key 'LAST'.
+    
+    Returns:
+    - str: The insurance type code selected by the user.
+    
+    """
+    print("\nHorrible Temporary Menu: Select the insurance type for patient {}: ".format(parsed_data['LAST']))
+
+    # Define insurance options with codes and descriptions
+    insurance_options = {
+        "11": "Other Non-Federal Programs",
+        "12": "Preferred Provider Organization (PPO)",
+        "13": "Point of Service (POS)",
+        "14": "Exclusive Provider Organization (EPO)",
+        "15": "Indemnity Insurance",
+        "16": "Health Maintenance Organization (HMO) Medicare Risk",
+        "17": "Dental Maintenance Organization",
+        "AM": "Automobile Medical",
+        "BL": "Blue Cross/Blue Shield",
+        "CH": "Champus",
+        "CI": "Commercial Insurance Co.",
+        "DS": "Disability",
+        "FI": "Federal Employees Program",
+        "HM": "Health Maintenance Organization",
+        "LM": "Liability Medical",
+        "MA": "Medicare Part A",
+        "MB": "Medicare Part B",
+        "MC": "Medicaid",
+        "OF": "Other Federal Program",
+        "TV": "Title V",
+        "VA": "Veterans Affairs Plan",
+        "WC": "Workers Compensation Health Claim",
+        "ZZ": "Mutually Defined"
+    }
+
+    # Function to display full list of insurance options
+    def display_insurance_options(options):
+        print("Insurance Type Options:")
+        # Sorting the dictionary keys to ensure consistent order
+        sorted_keys = sorted(options.keys())
+        for code in sorted_keys:
+            description = options[code]
+            print("{} - {}".format(code, description))
+
+    def prompt_display_insurance_options():
+        # Prompt to display full list
+        display_full_list = input("Do you want to see the full list of insurance options? (yes/no): ").strip().lower()
+
+        # Display full list if user confirms
+        if display_full_list in ['yes', 'y']:
+            display_insurance_options(insurance_options)
+
+    # Horrible menu
+    prompt_display_insurance_options()
+    
+    # Default selection
+    insurance_type_code = '12'
+
+    # User input for insurance type
+    user_input = input("Enter the 2-character code for the insurance type (or press Enter to default to '12' for PPO): ").strip().upper()
+
+    # Validate input and set the insurance type code
+    if user_input in insurance_options:
+        insurance_type_code = user_input
+    else:
+        print("Skipped or Input not recognized. Defaulting to Preferred Provider Organization (PPO)\n")
+
+    return insurance_type_code
+
 # Constructs the NM1 segment for subscriber based on parsed data and configuration.
 def create_nm1_subscriber_segment(config, parsed_data, endpoint):
     if endpoint.lower() == 'optumedi':
@@ -487,7 +618,7 @@ def create_dmg_segment(parsed_data):
 
 def create_nm1_rendering_provider_segment(config, is_rendering_provider_different=False):
     """
-    #BUG This is getting placed incorrectly.
+    # BUG This is getting placed incorrectly. Has this been fixed??
     
     Constructs the NM1 segment for the rendering provider in the 2310B loop using configuration data.
     
@@ -582,8 +713,44 @@ def create_clm_and_related_segments(parsed_data, config):
     
     return segments
 
+def get_endpoint_config(config, endpoint):
+    endpoint_config = config['endpoints'].get(endpoint.upper(), {})
+    if not endpoint_config:
+        print("Endpoint configuration for {} not found.".format(endpoint))
+        return None
+    return endpoint_config
+
+def create_interchange_elements(config, endpoint, transaction_set_control_number):
+    """
+    Create interchange headers and trailers for an 837P document.
+
+    Parameters:
+    - config: Configuration settings loaded from a JSON file.
+    - endpoint: The endpoint for which the data is being processed.
+    - transaction_set_control_number: The starting transaction set control number.
+
+    Returns:
+    - Tuple containing (ISA header, GS header, GE trailer, IEA trailer).
+    """
+    endpoint_config = get_endpoint_config(config, endpoint)
+    
+    # Get the current system time and format it as 'HHMMSS' in 24-hour clock.
+    current_time = datetime.now().strftime('%H%M%S')
+    isa13 = '000' + current_time  # Format ISA13 with '000HHMMSS'.
+
+    # Check if isa13 could not be generated from the current time
+    if len(isa13) != 9:
+        # If isa13 cannot be generated from the current time, use the configured value.
+        isa13 = endpoint_config.get('isa_13_value', '000000001')
+    
+    # Create interchange header and trailer using provided library functions.
+    isa_header, gs_header = create_interchange_header(config, endpoint, isa13)
+    ge_trailer, iea_trailer = create_interchange_trailer(config, transaction_set_control_number, isa13)
+    
+    return isa_header, gs_header, ge_trailer, iea_trailer
+
 # Generates the ISA and GS segments for the interchange header based on configuration and endpoint.
-def create_interchange_header(config, endpoint):
+def create_interchange_header(config, endpoint, isa13):
     """
     Generate ISA and GS segments for the interchange header, ensuring endpoint-specific requirements are met.
     Includes support for Availity, Optum, and PNT_DATA endpoints, with streamlined configuration and default handling.
@@ -591,6 +758,7 @@ def create_interchange_header(config, endpoint):
     Parameters:
     - config: Configuration dictionary with settings and identifiers.
     - endpoint: String indicating the target endpoint ('Availity', 'Optum', 'PNT_DATA').
+    - isa13: The ISA13 field value representing the current system time.
 
     Returns:
     - Tuple containing the ISA and GS segment strings.
@@ -600,14 +768,12 @@ def create_interchange_header(config, endpoint):
     # Set defaults for ISA segment values
     isa02 = isa04 = "          "  # Default value for ISA02 and ISA04
     isa05 = isa07 = 'ZZ'  # Default qualifier
-    isa13 = '000000001' # Default Interchange Control Number. Not sure what to do with this. date? See also trailer
     isa15 = 'P'  # 'T' for Test, 'P' for Production
     
     # Conditional values from config
     isa_sender_id = endpoint_config.get('isa_06_value', config.get('submitterId', '')).rstrip()
     isa07_value = endpoint_config.get('isa_07_value', isa07)
     isa_receiver_id = endpoint_config.get('isa_08_value', config.get('receiverId', '')).rstrip()
-    isa13_value = endpoint_config.get('isa_13_value', isa13) # Needs to match IEA02
     gs_sender_code = endpoint_config.get('gs_02_value', config.get('submitterEdi', ''))
     gs_receiver_code = endpoint_config.get('gs_03_value', config.get('receiverEdi', ''))
     isa15_value = endpoint_config.get('isa_15_value', isa15)
@@ -615,49 +781,50 @@ def create_interchange_header(config, endpoint):
     # ISA Segment
     isa_segment = "ISA*00*{}*00*{}*{}*{}*{}*{}*{}*{}*^*00501*{}*0*{}*:~".format(
         isa02, isa04, isa05, isa_sender_id.ljust(15), isa07_value, isa_receiver_id.ljust(15),
-        format_datetime(format_type='isa'), format_datetime(format_type='time'), isa13_value, isa15_value
+        format_datetime(format_type='isa'), format_datetime(format_type='time'), isa13, isa15_value
     )
 
     # GS Segment
     # GS04 YYYYMMDD
     # GS06 Group Control Number, Field Length 1/9, must match GE02
+    # BUG probably move up a function.
     gs06 = '1' # Placeholder for now?
     
     gs_segment = "GS*HC*{}*{}*{}*{}*{}*X*005010X222A1~".format(
         gs_sender_code, gs_receiver_code, format_datetime(), format_datetime(format_type='time'), gs06
     )
 
-    log("Created interchange header for endpoint: {}".format(endpoint), config, level="INFO")
+    MediLink_ConfigLoader.log("Created interchange header for endpoint: {}".format(endpoint), config, level="INFO")
     
     return isa_segment, gs_segment
 
 # Generates the GE and IEA segments for the interchange trailer based on the number of transactions and functional groups.
-def create_interchange_trailer(config, endpoint, num_transactions, num_functional_groups=1):
+def create_interchange_trailer(config, num_transactions, isa13, num_functional_groups=1):
     """
     Generate GE and IEA segments for the interchange trailer.
     
     Parameters:
+    - config: Configuration dictionary with settings and identifiers.
     - num_transactions: The number of transactions within the functional group.
+    - isa13: The ISA13 field value representing the current system time.
     - num_functional_groups: The number of functional groups within the interchange. Default is 1.
     
     Returns:
     - Tuple containing the GE and IEA segment strings.
     """
-    endpoint_config = config['endpoints'].get(endpoint.upper(), {})
+    
     # GE Segment: Functional Group Trailer
     # Indicates the end of a functional group and provides the count of the number of transactions within it.
+    
     # GE02 Group Control Number, Field Length 1/9, must match GS06 (Header)
+    # TODO This gs/ge matching should probably move up a function like isa13. 
     ge02 = '1' #Placeholder for now?
     ge_segment = "GE*{}*{}~".format(num_transactions, ge02)
     
-    # IEA Segment: Interchange Control Trailer
-    isa13 = '000000001' # Default Interchange Control Number. Not sure what to do with this. date? See also trailer
-    isa13_value = endpoint_config.get('isa_13_value', isa13) # Needs to match IEA02, can this be a date/time?
-    # Indicates the end of an interchange and provides the count of the number of functional groups within it.
-    # The Interchange Control Number needs to match isa13 and iea02
-    iea_segment = "IEA*{}*{}~".format(num_functional_groups, isa13_value)
+    # IEA Segment: Interchange Control Trailer (Note: IEA02 needs to equal ISA13)
+    iea_segment = "IEA*{}*{}~".format(num_functional_groups, isa13)
     
-    log("Created interchange trailer", config, level="INFO")
+    MediLink_ConfigLoader.log("Created interchange trailer", config, level="INFO")
     
     return ge_segment, iea_segment
 
@@ -676,4 +843,48 @@ def generate_segment_counts(compiled_segments, transaction_set_control_number):
     # This time, we directly replace the placeholder with the correct SE segment
     formatted_837p = compiled_segments.rsplit('SE**', 1)[0] + se_segment
     
-    return formatted_837p
+    return formatted_837p
+
+def handle_validation_errors(transaction_set_control_number, validation_errors, config):
+    for error in validation_errors:
+        MediLink_ConfigLoader.log("Validation error for transaction set {}: {}".format(transaction_set_control_number, error), config, level="WARNING")
+    
+    print("Validation errors encountered for transaction set {}. Errors: {}".format(transaction_set_control_number, validation_errors))
+    user_input = input("Skip this patient and continue without incrementing transaction set number? (yes/no): ")
+    if user_input.lower() == 'yes':
+        print("Skipping patient...")
+        MediLink_ConfigLoader.log("Skipped processing of transaction set {} due to user decision.".format(transaction_set_control_number), config, level="INFO")
+        return True  # Skip the current patient
+    else:
+        print("Processing halted due to validation errors.")
+        MediLink_ConfigLoader.log("HALT: Processing halted at transaction set {} due to unresolved validation errors.".format(transaction_set_control_number), config, level="ERROR")
+        sys.exit()  # Optionally halt further processing
+        
+def winscp_validate_output_directory(output_directory):
+    """
+    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
+
+def get_output_directory(config):
+    # Retrieve desired default output file path from config 
+    output_directory = config.get('outputFilePath', '')
+    # BUG (Low SFTP) Add 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 not os.path.isdir(output_directory):
+        print("Output directory does not exist. Please check the configuration.")
+        return None
+    return output_directory