medicafe 0.250711.1__py3-none-any.whl → 0.250720.0__py3-none-any.whl

MediLink/MediLink_Deductible.py

@@ -52,6 +52,11 @@ try:
 except ImportError:
     import MediLink_ConfigLoader
 
+try:
+    from MediLink import MediLink_Deductible_Validator
+except ImportError:
+    import MediLink_Deductible_Validator
+
 project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
 if project_dir not in sys.path:
     sys.path.append(project_dir)
@@ -122,26 +127,39 @@ patients = [
 # Function to handle manual patient deductible lookup
 def manual_deductible_lookup():
     print("\n--- Manual Patient Deductible Lookup ---")
+    print("Available Payer IDs: {}".format(", ".join(payer_ids)))
+    print("Enter 'quit' at any time to return to main menu.\n")
+    
     while True:
-        member_id = input("Enter the Member ID of the subscriber (or press Enter to skip): ").strip()
-        if not member_id:
-            print("No Member ID entered. Skipping manual lookup.\n")
+        member_id = input("Enter the Member ID of the subscriber (or 'quit' to exit): ").strip()
+        if member_id.lower() == 'quit':
+            print("Returning to main menu.\n")
             break
+        if not member_id:
+            print("No Member ID entered. Please try again.\n")
+            continue
 
         dob_input = input("Enter the Date of Birth (YYYY-MM-DD): ").strip()
+        if dob_input.lower() == 'quit':
+            print("Returning to main menu.\n")
+            break
+            
         formatted_dob = validate_and_format_date(dob_input)
         if not formatted_dob:
             print("Invalid DOB format. Please enter in YYYY-MM-DD format.\n")
             continue
 
-        # Create a temporary list for single patient
-        single_patient = [(formatted_dob, member_id)]
-        print("Processing manual lookup for Member ID: {}, DOB: {}".format(member_id, formatted_dob))
+        print("\nProcessing manual lookup for Member ID: {}, DOB: {}".format(member_id, formatted_dob))
+        print("Checking {} payer IDs...".format(len(payer_ids)))
 
         # Fetch eligibility data
-        for payer_id in payer_ids:
-            eligibility_data = get_eligibility_info(client, payer_id, provider_last_name, formatted_dob, member_id, npi)
+        found_data = False
+        for i, payer_id in enumerate(payer_ids, 1):
+            print("Checking Payer ID {} ({}/{}): {}".format(payer_id, i, len(payer_ids), payer_id))
+            
+            eligibility_data = get_eligibility_info(client, payer_id, provider_last_name, formatted_dob, member_id, npi, run_validation=True)
             if eligibility_data:
+                found_data = True
                 # Generate unique output file for manual request
                 output_file_name = "eligibility_report_manual_{}_{}.txt".format(member_id, formatted_dob)
                 output_file_path = os.path.join(os.getenv('TEMP'), output_file_name)
@@ -153,26 +171,27 @@ def manual_deductible_lookup():
                     print(table_header)
                     print("-" * len(table_header))
                     display_eligibility_info(eligibility_data, formatted_dob, member_id, output_file)
-                # Open the generated file in Notepad
-                os.system('notepad.exe "{}"'.format(output_file_path))
+                
+                # Ask if user wants to open the report
+                open_report = input("\nEligibility data found! Open the report? (Y/N): ").strip().lower()
+                if open_report in ['y', 'yes']:
+                    os.system('notepad.exe "{}"'.format(output_file_path))
                 print("Manual eligibility report generated: {}\n".format(output_file_path))
                 break  # Assuming one payer ID per manual lookup
             else:
                 print("No eligibility data found for Payer ID: {}".format(payer_id))
         
+        if not found_data:
+            print("\nNo eligibility data found for any Payer ID.")
+        
         # Ask if the user wants to perform another manual lookup
         continue_choice = input("\nDo you want to perform another manual lookup? (Y/N): ").strip().lower()
         if continue_choice in ['n', 'no']:
             break
 
-    # Display available Payer IDs as a note
-    print("\nNOTE: The tool can only look up the following Payer IDs:")
-    print(", ".join(payer_ids))
-    print("-------------------------------------------------\n")
-
 
 # Function to get eligibility information
-def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, member_id, npi):
+def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, member_id, npi, run_validation=False):
     try:
         # Log the parameters being sent to the function
         MediLink_ConfigLoader.log("Calling eligibility check with parameters:", level="DEBUG")
@@ -184,20 +203,46 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
 
         # Configuration flag to control which API to use
         # Set to False to use the new Super Connector API, True to use the legacy v3 API
-        USE_LEGACY_API = False
+        USE_LEGACY_API = True  # Changed to True to use legacy as primary
+        
+        # Always get legacy response first
+        MediLink_ConfigLoader.log("Getting legacy get_eligibility_v3 API response", level="INFO")
+        legacy_eligibility = MediLink_API_v3.get_eligibility_v3(
+            client, payer_id, provider_last_name, 'MemberIDDateOfBirth', date_of_birth, member_id, npi
+        )
         
-        if USE_LEGACY_API:
-            # Use the legacy get_eligibility_v3 function as primary
-            MediLink_ConfigLoader.log("Using legacy get_eligibility_v3 API", level="INFO")
-            eligibility = MediLink_API_v3.get_eligibility_v3(
+        # Also get Super Connector response for comparison
+        MediLink_ConfigLoader.log("Getting new get_eligibility_super_connector API response", level="INFO")
+        super_connector_eligibility = None
+        try:
+            super_connector_eligibility = MediLink_API_v3.get_eligibility_super_connector(
                 client, payer_id, provider_last_name, 'MemberIDDateOfBirth', date_of_birth, member_id, npi
             )
-        else:
-            # Use the new Super Connector API as primary
-            MediLink_ConfigLoader.log("Using new get_eligibility_super_connector API", level="INFO")
-            eligibility = MediLink_API_v3.get_eligibility_super_connector(
-                client, payer_id, provider_last_name, 'MemberIDDateOfBirth', date_of_birth, member_id, npi
+        except Exception as e:
+            MediLink_ConfigLoader.log("Super Connector API failed: {}".format(e), level="ERROR")
+        
+        # Run validation if requested and we have both responses
+        if run_validation and legacy_eligibility and super_connector_eligibility:
+            validation_file_path = os.path.join(os.getenv('TEMP'), 'validation_report_{}_{}.txt'.format(member_id, date_of_birth))
+            validation_report = MediLink_Deductible_Validator.run_validation_comparison(
+                legacy_eligibility, super_connector_eligibility, validation_file_path
             )
+            print("\nValidation report generated: {}".format(validation_file_path))
+            
+            # Log any Super Connector API errors
+            if super_connector_eligibility and "rawGraphQLResponse" in super_connector_eligibility:
+                raw_response = super_connector_eligibility.get('rawGraphQLResponse', {})
+                errors = raw_response.get('errors', [])
+                if errors:
+                    print("Super Connector API returned {} error(s):".format(len(errors)))
+                    for i, error in enumerate(errors):
+                        print("  Error {}: {} - {}".format(i+1, error.get('code', 'UNKNOWN'), error.get('description', 'No description')))
+            
+            # Open validation report in Notepad
+            os.system('notepad.exe "{}"'.format(validation_file_path))
+        
+        # Return the primary response (legacy for now)
+        eligibility = legacy_eligibility if USE_LEGACY_API else super_connector_eligibility
         
         # Log the response
         MediLink_ConfigLoader.log("Eligibility response: {}".format(json.dumps(eligibility, indent=4)), level="DEBUG")
@@ -229,7 +274,25 @@ def extract_super_connector_patient_info(eligibility_data):
     if not eligibility_data:
         return {'lastName': '', 'firstName': '', 'middleName': ''}
     
-    # The response structure is flat at the top level
+    # Handle multiple eligibility records - use the first one with valid data
+    if "rawGraphQLResponse" in eligibility_data:
+        raw_response = eligibility_data.get('rawGraphQLResponse', {})
+        data = raw_response.get('data', {})
+        check_eligibility = data.get('checkEligibility', {})
+        eligibility_list = check_eligibility.get('eligibility', [])
+        
+        # Try to get from the first eligibility record
+        if eligibility_list:
+            first_eligibility = eligibility_list[0]
+            member_info = first_eligibility.get('eligibilityInfo', {}).get('member', {})
+            if member_info:
+                return {
+                    'lastName': member_info.get("lastName", ""),
+                    'firstName': member_info.get("firstName", ""),
+                    'middleName': member_info.get("middleName", "")
+                }
+    
+    # Fallback to top-level fields
     return {
         'lastName': eligibility_data.get("lastName", ""),
         'firstName': eligibility_data.get("firstName", ""),
@@ -258,44 +321,95 @@ def extract_super_connector_remaining_amount(eligibility_data):
     if met_amount is not None:
         return str(met_amount)
     
-    # Navigate to the rawGraphQLResponse structure
-    raw_response = eligibility_data.get('rawGraphQLResponse', {})
-    if not raw_response:
-        return "Not Found"
-    
-    data = raw_response.get('data', {})
-    check_eligibility = data.get('checkEligibility', {})
-    eligibility_list = check_eligibility.get('eligibility', [])
-    
-    if not eligibility_list:
-        return "Not Found"
-    
-    first_eligibility = eligibility_list[0]
-    service_levels = first_eligibility.get('serviceLevels', [])
+    # Collect all deductible amounts to find the most relevant one
+    all_deductible_amounts = []
     
-    # Look for deductible information in service levels
-    for service_level in service_levels:
-        individual_services = service_level.get('individual', [])
-        for individual in individual_services:
-            services = individual.get('services', [])
-            for service in services:
-                # Look for deductible-related information
-                if service.get('service') == 'deductible' or 'deductible' in service.get('text', '').lower():
-                    return service.get('remainingAmount', "")
-                
-                # Check the message.deductible.text field for deductible information
-                message = service.get('message', {})
-                deductible_msg = message.get('deductible', {})
-                if deductible_msg and deductible_msg.get('text'):
-                    return deductible_msg.get('text', "")
-    
-    # If no specific deductible found, try to get from plan levels
-    plan_levels = first_eligibility.get('eligibilityInfo', {}).get('planLevels', [])
+    # Look for deductible information in planLevels (based on validation report)
+    plan_levels = eligibility_data.get('planLevels', [])
     for plan_level in plan_levels:
-        if plan_level.get('level') == 'deductibleInfo/outOfPocket/coPayMax':
+        if plan_level.get('level') == 'deductibleInfo':
+            # Collect individual deductible amounts
             individual_levels = plan_level.get('individual', [])
             if individual_levels:
-                return individual_levels[0].get('remainingAmount', "")
+                for individual in individual_levels:
+                    remaining = individual.get('remainingAmount')
+                    if remaining is not None:
+                        try:
+                            amount = float(remaining)
+                            all_deductible_amounts.append(('individual', amount))
+                        except (ValueError, TypeError):
+                            pass
+            
+            # Collect family deductible amounts
+            family_levels = plan_level.get('family', [])
+            if family_levels:
+                for family in family_levels:
+                    remaining = family.get('remainingAmount')
+                    if remaining is not None:
+                        try:
+                            amount = float(remaining)
+                            all_deductible_amounts.append(('family', amount))
+                        except (ValueError, TypeError):
+                            pass
+    
+    # Navigate to the rawGraphQLResponse structure as fallback
+    raw_response = eligibility_data.get('rawGraphQLResponse', {})
+    if raw_response:
+        data = raw_response.get('data', {})
+        check_eligibility = data.get('checkEligibility', {})
+        eligibility_list = check_eligibility.get('eligibility', [])
+        
+        # Try all eligibility records for deductible information
+        for eligibility in eligibility_list:
+            plan_levels = eligibility.get('eligibilityInfo', {}).get('planLevels', [])
+            for plan_level in plan_levels:
+                if plan_level.get('level') == 'deductibleInfo':
+                    # Collect individual deductible amounts
+                    individual_levels = plan_level.get('individual', [])
+                    if individual_levels:
+                        for individual in individual_levels:
+                            remaining = individual.get('remainingAmount')
+                            if remaining is not None:
+                                try:
+                                    amount = float(remaining)
+                                    all_deductible_amounts.append(('individual', amount))
+                                except (ValueError, TypeError):
+                                    pass
+                    
+                    # Collect family deductible amounts
+                    family_levels = plan_level.get('family', [])
+                    if family_levels:
+                        for family in family_levels:
+                            remaining = family.get('remainingAmount')
+                            if remaining is not None:
+                                try:
+                                    amount = float(remaining)
+                                    all_deductible_amounts.append(('family', amount))
+                                except (ValueError, TypeError):
+                                    pass
+    
+    # Select the most relevant deductible amount
+    if all_deductible_amounts:
+        # Strategy: Prefer individual over family, and prefer non-zero amounts
+        # First, try to find non-zero individual amounts
+        non_zero_individual = [amt for type_, amt in all_deductible_amounts if type_ == 'individual' and amt > 0]
+        if non_zero_individual:
+            return str(max(non_zero_individual))  # Return highest non-zero individual amount
+        
+        # If no non-zero individual, try non-zero family amounts
+        non_zero_family = [amt for type_, amt in all_deductible_amounts if type_ == 'family' and amt > 0]
+        if non_zero_family:
+            return str(max(non_zero_family))  # Return highest non-zero family amount
+        
+        # If all amounts are zero, return the first individual amount (or family if no individual)
+        individual_amounts = [amt for type_, amt in all_deductible_amounts if type_ == 'individual']
+        if individual_amounts:
+            return str(individual_amounts[0])
+        
+        # Fallback to first family amount
+        family_amounts = [amt for type_, amt in all_deductible_amounts if type_ == 'family']
+        if family_amounts:
+            return str(family_amounts[0])
     
     return "Not Found"
 
@@ -314,12 +428,57 @@ def extract_super_connector_insurance_info(eligibility_data):
     if not eligibility_data:
         return {'insuranceType': '', 'insuranceTypeCode': '', 'memberId': '', 'payerId': ''}
     
-    # Get plan type description instead of coverage type
+    # Handle multiple eligibility records - use the first one with valid data
+    if "rawGraphQLResponse" in eligibility_data:
+        raw_response = eligibility_data.get('rawGraphQLResponse', {})
+        data = raw_response.get('data', {})
+        check_eligibility = data.get('checkEligibility', {})
+        eligibility_list = check_eligibility.get('eligibility', [])
+        
+        # Try to get from the first eligibility record
+        if eligibility_list:
+            first_eligibility = eligibility_list[0]
+            insurance_info = first_eligibility.get('eligibilityInfo', {}).get('insuranceInfo', {})
+            if insurance_info:
+                return {
+                    'insuranceType': insurance_info.get("planTypeDescription", ""),
+                    'insuranceTypeCode': insurance_info.get("productServiceCode", ""),
+                    'memberId': insurance_info.get("memberId", ""),
+                    'payerId': insurance_info.get("payerId", "")
+                }
+    
+    # Fallback to top-level fields
     insurance_type = eligibility_data.get("planTypeDescription", "")
+    if not insurance_type:
+        insurance_type = eligibility_data.get("productType", "")
+    
+    # Clean up the insurance type if it's too long (like the LPPO description)
+    if insurance_type and len(insurance_type) > 50:
+        # Extract just the plan type part
+        if "PPO" in insurance_type:
+            insurance_type = "Preferred Provider Organization (PPO)"
+        elif "HMO" in insurance_type:
+            insurance_type = "Health Maintenance Organization (HMO)"
+        elif "EPO" in insurance_type:
+            insurance_type = "Exclusive Provider Organization (EPO)"
+        elif "POS" in insurance_type:
+            insurance_type = "Point of Service (POS)"
+    
+    # Get insurance type code from multiple possible locations
+    insurance_type_code = eligibility_data.get("productServiceCode", "")
+    if not insurance_type_code:
+        # Try to get from coverageTypes
+        coverage_types = eligibility_data.get("coverageTypes", [])
+        if coverage_types:
+            insurance_type_code = coverage_types[0].get("typeCode", "")
+    
+    # Note: We're not mapping "M" to "PR" as "M" likely means "Medical" 
+    # and "PR" should be "12" for PPO according to CMS standards
+    # This mapping should be handled by the API developers
     
     return {
         'insuranceType': insurance_type,
-        'insuranceTypeCode': eligibility_data.get("productServiceCode", ""),
+        'insuranceTypeCode': insurance_type_code,
         'memberId': eligibility_data.get("subscriberId", ""),
         'payerId': eligibility_data.get("payerId", "")  # Use payerId instead of legalEntityCode (this should be payer_id from the inputs)
     }
@@ -334,7 +493,21 @@ def extract_super_connector_policy_status(eligibility_data):
     if not eligibility_data:
         return ""
     
-    # Policy status is at the top level
+    # Handle multiple eligibility records - use the first one with valid data
+    if "rawGraphQLResponse" in eligibility_data:
+        raw_response = eligibility_data.get('rawGraphQLResponse', {})
+        data = raw_response.get('data', {})
+        check_eligibility = data.get('checkEligibility', {})
+        eligibility_list = check_eligibility.get('eligibility', [])
+        
+        # Try to get from the first eligibility record
+        if eligibility_list:
+            first_eligibility = eligibility_list[0]
+            insurance_info = first_eligibility.get('eligibilityInfo', {}).get('insuranceInfo', {})
+            if insurance_info:
+                return insurance_info.get("policyStatus", "")
+    
+    # Fallback to top-level field
     return eligibility_data.get("policyStatus", "")
 
 def is_legacy_response_format(data):
@@ -403,47 +576,111 @@ def display_eligibility_info(data, dob, member_id, output_file):
 
 # Main Execution Flow
 if __name__ == "__main__":
-    # Step 1: Handle Manual Deductible Lookups
-    manual_deductible_lookup()
-
-    # Step 2: Proceed with Existing CSV Processing
-    print("--- Starting Batch Eligibility Processing ---")
-    output_file_path = os.path.join(os.getenv('TEMP'), 'eligibility_report.txt')
-    with open(output_file_path, 'w') as output_file:
-        table_header = "{:<20} | {:<10} | {:<40} | {:<5} | {:<14} | {:<14}".format(
-            "Patient Name", "DOB", "Insurance Type", "PayID", "Policy Status", "Remaining Amt")
-        output_file.write(table_header + "\n")
-        output_file.write("-" * len(table_header) + "\n")
-        print(table_header)
-        print("-" * len(table_header))
-
-        # Set to keep track of processed patients
-        processed_patients = set()
-
-        # Loop through each payer_id and patient to call the API, then display the eligibility information
-        errors = []
-        for payer_id in payer_ids:
-            for dob, member_id in patients:
-                # Skip if this patient has already been processed
-                if (dob, member_id) in processed_patients:
-                    continue
-                try:
-                    eligibility_data = get_eligibility_info(client, payer_id, provider_last_name, dob, member_id, npi)
-                    if eligibility_data is not None:
-                        display_eligibility_info(eligibility_data, dob, member_id, output_file)  # Display as we get the result
-                        processed_patients.add((dob, member_id))  # Mark this patient as processed
-                except Exception as e:
-                    errors.append((dob, member_id, str(e)))
-
-        # Display errors if any
-        if errors:
-            error_msg = "\nErrors encountered during API calls:\n"
-            output_file.write(error_msg)
-            print(error_msg)
-            for error in errors:
-                error_details = "DOB: {}, Member ID: {}, Error: {}\n".format(error[0], error[1], error[2])
-                output_file.write(error_details)
-                print(error_details)
-
-    # Open the generated file in Notepad
-    os.system('notepad.exe "{}"'.format(output_file_path))
+    print("\n" + "=" * 80)
+    print("MEDILINK DEDUCTIBLE LOOKUP TOOL")
+    print("=" * 80)
+    print("This tool provides manual and batch eligibility lookups with validation.")
+    print("Validation reports compare legacy vs Super Connector API responses.")
+    print("=" * 80)
+    
+    while True:
+        print("\nChoose an option:")
+        print("1. Manual Patient Lookup (with validation)")
+        print("2. Batch CSV Processing (with validation)")
+        print("3. Exit")
+        
+        choice = input("\nEnter your choice (1-3): ").strip()
+        
+        if choice == "1":
+            # Step 1: Handle Manual Deductible Lookups
+            manual_deductible_lookup()
+            
+            # Ask if user wants to continue
+            continue_choice = input("\nDo you want to perform another operation? (Y/N): ").strip().lower()
+            if continue_choice in ['n', 'no']:
+                print("\nExiting. Thank you for using MediLink Deductible Tool!")
+                break
+                
+        elif choice == "2":
+            # Step 2: Proceed with Existing CSV Processing
+            print("\n--- Starting Batch Eligibility Processing ---")
+            print("Processing {} patients from CSV data...".format(len(patients)))
+            
+            # Ask for confirmation before starting batch processing
+            confirm = input("Proceed with batch processing? (Y/N): ").strip().lower()
+            if confirm not in ['y', 'yes']:
+                print("Batch processing cancelled.")
+                continue
+            
+            output_file_path = os.path.join(os.getenv('TEMP'), 'eligibility_report.txt')
+            with open(output_file_path, 'w') as output_file:
+                table_header = "{:<20} | {:<10} | {:<40} | {:<5} | {:<14} | {:<14}".format(
+                    "Patient Name", "DOB", "Insurance Type", "PayID", "Policy Status", "Remaining Amt")
+                output_file.write(table_header + "\n")
+                output_file.write("-" * len(table_header) + "\n")
+                print(table_header)
+                print("-" * len(table_header))
+
+                # Set to keep track of processed patients
+                processed_patients = set()
+
+                # Loop through each payer_id and patient to call the API, then display the eligibility information
+                errors = []
+                validation_reports = []
+                total_patients = len(patients) * len(payer_ids)
+                processed_count = 0
+                
+                for payer_id in payer_ids:
+                    for dob, member_id in patients:
+                        # Skip if this patient has already been processed
+                        if (dob, member_id) in processed_patients:
+                            continue
+                        try:
+                            processed_count += 1
+                            print("Processing patient {}/{}: Member ID {}, DOB {}".format(
+                                processed_count, total_patients, member_id, dob))
+                            
+                            # Run with validation enabled for batch processing
+                            eligibility_data = get_eligibility_info(client, payer_id, provider_last_name, dob, member_id, npi, run_validation=True)
+                            if eligibility_data is not None:
+                                display_eligibility_info(eligibility_data, dob, member_id, output_file)  # Display as we get the result
+                                processed_patients.add((dob, member_id))  # Mark this patient as processed
+                        except Exception as e:
+                            errors.append((dob, member_id, str(e)))
+
+                # Display errors if any
+                if errors:
+                    error_msg = "\nErrors encountered during API calls:\n"
+                    output_file.write(error_msg)
+                    print(error_msg)
+                    for error in errors:
+                        error_details = "DOB: {}, Member ID: {}, Error: {}\n".format(error[0], error[1], error[2])
+                        output_file.write(error_details)
+                        print(error_details)
+
+            # Ask if user wants to open the report
+            open_report = input("\nBatch processing complete! Open the eligibility report? (Y/N): ").strip().lower()
+            if open_report in ['y', 'yes']:
+                os.system('notepad.exe "{}"'.format(output_file_path))
+            
+            # Print summary of validation reports
+            print("\n" + "=" * 80)
+            print("VALIDATION SUMMARY")
+            print("=" * 80)
+            print("Validation reports have been generated for each patient processed.")
+            print("Each report compares the legacy API response with the Super Connector API response.")
+            print("Check the TEMP directory for validation_report_*.txt files.")
+            print("=" * 80)
+            
+            # Ask if user wants to continue
+            continue_choice = input("\nDo you want to perform another operation? (Y/N): ").strip().lower()
+            if continue_choice in ['n', 'no']:
+                print("\nExiting. Thank you for using MediLink Deductible Tool!")
+                break
+                
+        elif choice == "3":
+            print("\nExiting. Thank you for using MediLink Deductible Tool!")
+            break
+            
+        else:
+            print("Invalid choice. Please enter 1, 2, or 3.")