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

MediLink/MediLink_837p_encoder_library.py

@@ -1,13 +1,11 @@
+# MediLink_837p_encoder_library.py
 from datetime import datetime
-import sys
-from MediLink import MediLink_ConfigLoader, MediLink_UI
-
-# Add parent directory of the project to the Python path
-import sys
-import os
+import sys, os
+from MediLink import MediLink_ConfigLoader
 
 project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
-sys.path.append(project_dir)
+if project_dir not in sys.path:
+    sys.path.append(project_dir)
 
 from MediBot import MediBot_Preprocessor_lib
 load_insurance_data_from_mains = MediBot_Preprocessor_lib.load_insurance_data_from_mains
@@ -154,9 +152,10 @@ def create_1000A_submitter_name_segment(patient_data, config, endpoint):
     # Submitter contact details
     contact_name = config.get('submitter_name', 'NONE')
     contact_telephone_number = config.get('submitter_tel', 'NONE')
+    entity_type_qualifier = '2' # if contact_name else '1'  BUG - 1 if submitter_first_name is not empty.
     
     # Construct NM1 segment for the submitter
-    nm1_segment = "NM1*41*2*{}*****{}*{}~".format(submitter_name, submitter_id_qualifier, submitter_id)
+    nm1_segment = "NM1*41*{}*{}*****{}*{}~".format(entity_type_qualifier, submitter_name, submitter_id_qualifier, submitter_id)
     
     # Construct PER segment for the submitter's contact information
     per_segment = "PER*IC*{}*TE*{}~".format(contact_name, contact_telephone_number)
@@ -182,7 +181,7 @@ def create_1000B_receiver_name_segment(config, endpoint):
         receiver_edi=receiver_edi
     )
 
-def payer_id_to_payer_name(parsed_data, config, endpoint):
+def payer_id_to_payer_name(parsed_data, config, endpoint, crosswalk, client):
     """
     Preprocesses payer information from parsed data and enriches parsed_data with the payer name and ID.
 
@@ -198,7 +197,7 @@ def payer_id_to_payer_name(parsed_data, config, endpoint):
     insurance_name = parsed_data.get('INAME', '')
 
     # Step 2: Map insurance name to payer ID
-    payer_id = map_insurance_name_to_payer_id(insurance_name, config)
+    payer_id = map_insurance_name_to_payer_id(insurance_name, config, client)
 
     # Step 3: Validate payer_id
     if payer_id is None:
@@ -207,7 +206,7 @@ def payer_id_to_payer_name(parsed_data, config, endpoint):
         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)
+    payer_name = resolve_payer_name(payer_id, config, endpoint, insurance_name, parsed_data, crosswalk, client)
 
     # Enrich parsed_data with payer name and payer ID
     parsed_data['payer_name'] = payer_name
@@ -238,88 +237,160 @@ def create_2010BB_payer_information_segment(parsed_data):
     # 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:
-        str: The resolved payer name.
-    """
+def get_user_confirmation(prompt_message):
+    while True:
+        response = input(prompt_message).strip().lower()
+        if response in ['yes', 'y']:
+            return True
+        elif response in ['no', 'n']:
+            return False
+        else:
+            print("Please respond with 'yes' or 'no'.")
 
+def resolve_payer_name(payer_id, config, primary_endpoint, insurance_name, parsed_data, crosswalk, client):
+    # Check if the payer_id is in the crosswalk with a name already attached to it.
+    if payer_id in crosswalk.get('payer_id', {}):
+        payer_info = crosswalk['payer_id'][payer_id]
+        MediLink_ConfigLoader.log("Payer ID {} found in crosswalk with name: {}".format(payer_id, payer_info['name']), level="DEBUG")
+        return payer_info['name']  # Return the name from the crosswalk directly.
+    
     # 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:
-        return fetch_payer_name_from_api(payer_id, config, primary_endpoint)
+        return fetch_payer_name_from_api(client, 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("         Claims for '{}' may be incorrectly routed or fail without intervention.".format(insurance_name))
+        print("\nACTION REQUIRED: Please verify the internet connection and the Payer ID by searching for it 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
+        user_decision = input("\nType 'FORCE' to force-continue with the Medisoft name, or press Enter to pause processing and make corrections: ").strip().lower()
+        
         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
+        elif not user_decision:
+            # Step 6: Prompt user for corrected payer ID
             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)
+                    resolved_name = fetch_payer_name_from_api(client, 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):
+    
+                    # Step 7: Ask for user confirmation using the helper
+                    confirmation_prompt = "Is the standard insurance name '{}' correct? (yes/no): ".format(resolved_name)
+                    if get_user_confirmation(confirmation_prompt):
+                        # Step 8: Load crosswalk
+                        try:
+                            config, crosswalk = MediLink_ConfigLoader.load_configuration()
+                        except Exception as e:
+                            print("Failed to load configuration and crosswalk: {}".format(e))
+                            MediLink_ConfigLoader.log("Failed to load configuration and crosswalk: {}".format(e), config, level="ERROR")
+                            exit(1)
+                        
+                        # Step 9: Update the crosswalk with the corrected Payer ID
+                        if MediBot_Crosswalk_Library.update_crosswalk_with_corrected_payer_id(client, payer_id, corrected_payer_id, config, crosswalk):
                             return resolved_name
                         else:
                             print("Failed to update crosswalk with the corrected Payer ID.")
-                            exit(1) # probably needs a different failure direction here.
+                            MediLink_ConfigLoader.log("Failed to update crosswalk with the corrected Payer ID.", config, level="ERROR")
+                            exit(1)  # Consider handling failure differently.
                     else:
+                        # Step 10: Handle rejection
                         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.
+                        exit(1)  # Consider handling differently.
                 except Exception as e:
+                    # Step 11: Handle exceptions during resolution
                     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.
+                    exit(1)  # Consider handling differently.
             else:
+                # Step 12: Handle absence of corrected payer ID
                 print("Exiting script. Please make the necessary corrections and retry.")
-                exit(1) # probably needs a different failure direction here.
+                MediLink_ConfigLoader.log("Exiting script due to absence of corrected Payer ID.", config, level="CRITICAL")
+                exit(1)  # Consider handling differently.
+        else:
+            # Optional: Handle unexpected user input
+            print("Invalid input. Manual intervention is required.")
+            MediLink_ConfigLoader.log("Invalid user input during payer name resolution.", config, level="CRITICAL")
+            exit(1)  # Consider handling differently.
+
+def handle_missing_payer_id(insurance_name, config, crosswalk, client):
+    # Step 1: Inform about the missing 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")
+    
+    # Step 2: Prompt the user for manual payer ID input
+    payer_id = prompt_user_for_payer_id(insurance_name)
+    
+    if not payer_id:
+        # Step 3: Handle absence of payer ID input
+        message = "Unable to resolve missing Payer ID. Manual intervention is required."
+        MediLink_ConfigLoader.log(message, config, level="CRITICAL")
+        print(message)
+        return None
+    
+    # Step 4: 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={}, crosswalk=crosswalk, client=client)
+        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:
+        # Step 5: Handle exceptions during resolution
+        message = "Failed to resolve payer ID to standard insurance name: {}".format(e)
+        print(message)
+        MediLink_ConfigLoader.log(message, config, level="ERROR")
+        return None
+    
+    # Step 6: Ask for user confirmation
+    confirmation_prompt = "Is the standard insurance name '{}' correct? (yes/no): ".format(standard_insurance_name)
+    if get_user_confirmation(confirmation_prompt):
+        # Step 7: Update the crosswalk with the new payer ID and insurance name mapping
+        try:
+            MediBot_Crosswalk_Library.update_crosswalk_with_new_payer_id(insurance_name, payer_id, config)
+            return payer_id
+        except Exception as e:
+            print("Failed to update crosswalk with new Payer ID: {}".format(e))
+            MediLink_ConfigLoader.log("Failed to update crosswalk with new Payer ID: {}".format(e), config, level="ERROR")
+            return None
+    else:
+        # Step 8: Handle rejection
+        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 prompt_user_for_payer_id(insurance_name):
     """
-    Prompts the user to input the payer ID manually.
+    Prompts the user to input the payer ID manually and ensures that a valid ID is provided.
     """
-    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
+    while True:
+        print("Manual intervention required: No payer ID found for insurance name '{}'.".format(insurance_name))
+        payer_id = input("Please enter the payer ID manually: ").strip()
+        
+        if payer_id:
+            return payer_id
+        else:
+            print("Error: Payer ID cannot be empty. Please try again.")
 
 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 map_insurance_name_to_payer_id(insurance_name, config):
+def map_insurance_name_to_payer_id(insurance_name, config, client):
     """
     Maps insurance name to payer ID using the crosswalk configuration.
 
@@ -330,13 +401,15 @@ def map_insurance_name_to_payer_id(insurance_name, config):
     Returns:
         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
+    try:        
+        # Load crosswalk configuration // BUG This should already be passed in before we get here.
         _, crosswalk = MediLink_ConfigLoader.load_configuration(None, config.get('crosswalkPath', 'crosswalk.json'))
         
+        # Ensure crosswalk is initialized and 'payer_id' key is available
+        if 'payer_id' not in crosswalk:
+            print("Crosswalk 'payer_id' not found. Please run MediBot_Preprocessor.py with the --update-crosswalk argument.")
+            exit() # BUG Halting the script execution here for now, should be handled in the preprocessor script.
+
         # Load insurance data from MAINS to get insurance ID
         insurance_to_id = load_insurance_data_from_mains(config)
         
@@ -345,6 +418,7 @@ def map_insurance_name_to_payer_id(insurance_name, config):
         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")
+            # Asking for payer ID here is not the right approach.
             raise ValueError(error_message)
         
         # Convert medisoft_id to string to match the JSON data type
@@ -362,7 +436,7 @@ def map_insurance_name_to_payer_id(insurance_name, config):
             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)
+            payer_id = handle_missing_payer_id(insurance_name, config, crosswalk, client)
 
         return payer_id
 
@@ -376,47 +450,6 @@ def map_insurance_name_to_payer_id(insurance_name, config):
             MediLink_ConfigLoader.log(error_message, config, level="ERROR")
             raise e
 
-def handle_missing_payer_id(insurance_name, config):
-    """
-    Handles cases where the payer ID is not found for a given Medisoft 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):
     """
     Constructs the NM1 segment for the Pay-To Address, N3 for street address, and N4 for city, state, and ZIP.
@@ -627,7 +660,7 @@ def format_claim_number(chart_number, date_of_service):
     return formatted_claim_number
 
 # Constructs the CLM and related segments based on parsed data and configuration.
-def create_clm_and_related_segments(parsed_data, config):
+def create_clm_and_related_segments(parsed_data, config, crosswalk): 
     """
     Insert the claim information (2300 loop), 
     ensuring that details such as claim ID, total charge amount,and service date are included.
@@ -653,9 +686,23 @@ def create_clm_and_related_segments(parsed_data, config):
         parsed_data['TOS']))
     
     # HI - Health Care Diagnosis Code
-    # The code value should be preceded by the qualifier "ABK" or "BK" to specify the type of 
-    # diagnosis code being used. "ABK" typically indicates ICD-10 codes, while "BK" indicates ICD-9 codes.
-    segments.append("HI*ABK:H{}~".format(''.join(char for char in parsed_data['DIAG'] if char.isalnum() or char.isdigit())))
+    # Hardcoding "ABK" for ICD-10 codes as they are the only ones used now.
+    medisoft_code = ''.join(filter(str.isalnum, parsed_data['DIAG']))
+    diagnosis_code = next((key for key, value in crosswalk.get('diagnosis_to_medisoft', {}).items() if value == medisoft_code), None) 
+    
+    if diagnosis_code is None:
+        error_message = "Diagnosis code is empty for chart number: {}. Please verify. Medisoft code is {}".format(chart_number, medisoft_code)
+        MediLink_ConfigLoader.log(error_message, config, level="CRITICAL")
+        print(error_message)
+        diagnosis_code = input("Enter the complete diagnosis code: ")
+        # Update the crosswalk dictionary with the new pairing of diagnosis_code and medisoft_code.
+        crosswalk['diagnosis_to_medisoft'][diagnosis_code] = medisoft_code
+        MediLink_ConfigLoader.log("Updated crosswalk with new diagnosis code: {}, for Medisoft code {}".format(diagnosis_code, medisoft_code), config, level="INFO")
+        # TODO This needs to actually save the .json though which right now I'd like to route through the dedicated function for updating the crosswalk. 
+        # TODO This should have been a validation exercise upstream and not a last minute check like this.
+
+    cleaned_diagnosis_code = ''.join(char for char in diagnosis_code if char.isalnum())
+    segments.append("HI*ABK:{}~".format(cleaned_diagnosis_code))
     
     # (2310C Loop) Service Facility Location NPI and Address Information
     segments.extend(create_service_facility_location_npi_segment(config))
@@ -675,7 +722,10 @@ def create_clm_and_related_segments(parsed_data, config):
     # DTP - Date
     segments.append("DTP*472*D8*{}~".format(convert_date_format(parsed_data['DATE'])))
     
-    # Is there REF - Line Item Control Number missing here?
+    # Is there REF - Line Item Control Number missing here? Private insurance doesn't need it, but Medicare does?
+    # segments.append("REF*6R*1~") # REF01, Reference Identification Qualifier; REF02, Line Item Control Number.
+    # 6R - Provider Control Number (Number assigned by information provider company for tracking and billing purposes)
+    # 1 - Reference information as defined for a particular Transaction Set or as specified by the Reference Identification Qualifier
     
     return segments
 
@@ -847,10 +897,17 @@ def winscp_validate_output_directory(output_directory):
 
 def get_output_directory(config):
     # Retrieve desired default output file path from config 
-    output_directory = config.get('outputFilePath', '')
+    output_directory = config.get('outputFilePath', '').strip()
     # BUG (Low SFTP) Add WinSCP validation because of the mishandling of spaces in paths. (This shouldn't need to exist.)
+    if not output_directory:
+        print("Output file path is not specified in the configuration.")
+        output_directory = input("Please enter a valid output directory path: ").strip()
+    
+    # Validate the directory path (checks for spaces and existence)
     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.")
+        print("Output directory does not exist or is not accessible. Please check the configuration.")
         return None
+    
     return output_directory

MediLink/MediLink_API_Generator.py

@@ -1,15 +1,9 @@
 # This script requires Python 3.11 and is to be used for intalling new API clients.
-import os
-import time
-import subprocess
-import shutil
-import tempfile
+import os, time, subprocess, shutil, tempfile, shlex, re
 from pathlib import Path
 from watchdog.observers import Observer
 from watchdog.events import FileSystemEventHandler
 from MediLink_API_v3 import ConfigLoader
-import shlex
-import re
 
 class SwaggerHandler(FileSystemEventHandler):
     def __init__(self, json_folder):