medicafe 0.250822.2__py3-none-any.whl → 0.250822.3__py3-none-any.whl

MediBot/MediBot_Crosswalk_Library.py

@@ -42,7 +42,7 @@ else:
     load_and_parse_z_data = None
 
 # Import API functions using centralized import pattern
-MediLink_API_v3 = smart_import(['MediCafe.api_core', 'MediCafe.api_core_backup'])
+MediLink_API_v3 = smart_import(['MediCafe.api_core'])
 fetch_payer_name_from_api = getattr(MediLink_API_v3, 'fetch_payer_name_from_api', None) if MediLink_API_v3 else None
 
 # Module-level cache to prevent redundant API calls

MediBot/__init__.py

@@ -19,7 +19,7 @@ Smart Import Integration:
         medibot_main = get_components('medibot_main')
 """
 
-__version__ = "0.250822.2"
+__version__ = "0.250822.3"
 __author__ = "Daniel Vidaud"
 __email__ = "daniel@personalizedtransformation.com"
 

MediCafe/__init__.py

@@ -27,7 +27,7 @@ Smart Import System:
         api_suite = get_api_access()
 """
 
-__version__ = "0.250822.2"
+__version__ = "0.250822.3"
 __author__ = "Daniel Vidaud"
 __email__ = "daniel@personalizedtransformation.com"
 

MediCafe/api_core.py

@@ -118,10 +118,107 @@ except ImportError:
     class TokenCache:
         def __init__(self):
             self.tokens = {}
-        def get(self, endpoint_name, current_time):
-            return None
-        def set(self, endpoint_name, access_token, expires_in, current_time):
-            pass
+
+# -----------------------------------------------------------------------------
+# Endpoint-specific payer ID management (crosswalk-backed with hardcoded default)
+# -----------------------------------------------------------------------------
+# Intent:
+# - Validate payer IDs against the endpoint actually being called.
+# - Persist endpoint-specific payer ID lists into the crosswalk so they can be
+#   updated over time without changing code.
+# - For OPTUMAI: use the augmented list (includes LIFE1, WELM2, etc.).
+# - For UHCAPI (including its Super Connector fallback): strictly enforce the
+#   known-good UHC payer IDs only.
+# - Future: OPTUMAI will expose a dedicated endpoint that returns its current
+#   valid payer list. When available, this function should fetch and refresh the
+#   crosswalk entry automatically (likely weekly/monthly), replacing the
+#   hardcoded default below. The UHCAPI Super Connector will eventually be
+#   deprecated; when removed, cleanup the UHC-specific paths accordingly.
+
+try:
+    # Prefer using existing crosswalk persistence utilities
+    from MediBot.MediBot_Crosswalk_Utils import ensure_full_config_loaded, save_crosswalk
+except Exception:
+    ensure_full_config_loaded = None
+    save_crosswalk = None
+
+def _get_default_endpoint_payer_ids(endpoint_name):
+    """
+    Return hardcoded default payer IDs for a given endpoint.
+
+    NOTE: Defaults are used when crosswalk does not yet contain a list.
+    """
+    # UHC-only list – keep STRICT. Do not augment with non-UHC payers.
+    uhc_payer_ids = [
+        "87726", "03432", "96385", "95467", "86050", "86047", "95378", "06111", "37602"
+    ]
+
+    # OPTUMAI – augmented list (subject to growth once the API adds a payer-list endpoint)
+    optumai_payer_ids = [
+        "87726", "06111", "25463", "37602", "39026", "74227", "65088", "81400",
+        "03432", "86050", "86047", "95378", "95467", "LIFE1", "WELM2"
+    ]
+
+    if endpoint_name == 'OPTUMAI':
+        return optumai_payer_ids
+    # Default to UHCAPI for any other endpoint name
+    return uhc_payer_ids
+
+def get_valid_payer_ids_for_endpoint(client, endpoint_name):
+    """
+    Resolve the valid payer IDs for a specific endpoint using crosswalk storage
+    with a safe fallback to hardcoded defaults.
+
+    Behavior:
+    - Attempts to read crosswalk['endpoint_payer_ids'][endpoint_name].
+    - If missing, initializes with hardcoded defaults and persists to crosswalk
+      (non-interactive) so that future sessions use the saved list.
+    - Future: For OPTUMAI, replace the hardcoded default by calling the API's
+      payer-list endpoint once available, then update the crosswalk.
+    """
+    try:
+        # Load full config + crosswalk (non-destructive)
+        base_config = None
+        crosswalk = None
+        if ensure_full_config_loaded is not None:
+            base_config, crosswalk = ensure_full_config_loaded(
+                getattr(client, 'config', None),
+                getattr(client, 'crosswalk', None)
+            )
+        else:
+            # Fallback: attempt to load via MediLink_ConfigLoader directly
+            # If we reach this fallback, it means ensure_full_config_loaded is not available.
+            # This is unexpected in normal operation and should be alerted.
+            print("Warning: IN api_core, ensure_full_config_loaded is not available; falling back to MediLink_ConfigLoader.load_configuration().")
+            MediLink_ConfigLoader.log(
+                "Fallback: ensure_full_config_loaded not available in get_valid_payer_ids_for_endpoint; using MediLink_ConfigLoader.load_configuration().",
+                level="WARNING"
+            )
+            base_config, crosswalk = MediLink_ConfigLoader.load_configuration()
+
+        # Extract any existing stored list
+        cw_ep = crosswalk.get('endpoint_payer_ids', {}) if isinstance(crosswalk, dict) else {}
+        existing = cw_ep.get(endpoint_name)
+        if isinstance(existing, list) and len(existing) > 0:
+            return existing
+
+        # Initialize from defaults and persist to crosswalk
+        defaults = _get_default_endpoint_payer_ids(endpoint_name)
+        if isinstance(crosswalk, dict):
+            if 'endpoint_payer_ids' not in crosswalk:
+                crosswalk['endpoint_payer_ids'] = {}
+            crosswalk['endpoint_payer_ids'][endpoint_name] = list(defaults)
+
+            # Persist without interactive prompts; ignore errors silently to avoid breaking flows
+            if save_crosswalk is not None:
+                try:
+                    save_crosswalk(client, base_config, crosswalk, skip_api_operations=True)
+                except Exception:
+                    pass
+        return defaults
+    except Exception:
+        # As a last resort, return a safe default for the endpoint
+        return _get_default_endpoint_payer_ids(endpoint_name)
 
 class BaseAPIClient:
     def __init__(self, config):
@@ -792,12 +889,14 @@ def get_eligibility_v3(client, payer_id, provider_last_name, search_option, date
     if not all([client, payer_id, provider_last_name, search_option, date_of_birth, member_id, npi]):
         raise ValueError("All required parameters must have values: client, payer_id, provider_last_name, search_option, date_of_birth, member_id, npi")
 
-    # Validate payer_id
-    valid_payer_ids = ["87726", "06111", "25463", "37602", "39026", "74227", "65088", "81400", "03432", "86050", "86047", "95378", "95467"]
-    if payer_id not in valid_payer_ids:
-        raise ValueError("Invalid payer_id: {}. Must be one of: {}".format(payer_id, ", ".join(valid_payer_ids)))
-    
+    # Endpoint is UHCAPI for this v3 REST call
     endpoint_name = 'UHCAPI'
+
+    # Validate payer_id strictly against UHC list
+    valid_payer_ids = get_valid_payer_ids_for_endpoint(client, endpoint_name)
+    if payer_id not in valid_payer_ids:
+        raise ValueError("Invalid payer_id: {} for endpoint {}. Must be one of: {}".format(
+            payer_id, endpoint_name, ", ".join(valid_payer_ids)))
     from MediCafe.core_utils import extract_medilink_config
     medi = extract_medilink_config(client.config)
     url_extension = medi.get('endpoints', {}).get(endpoint_name, {}).get('additional_endpoints', {}).get('eligibility_v3', '')
@@ -856,11 +955,6 @@ def get_eligibility_super_connector(client, payer_id, provider_last_name, search
     if not all([client, payer_id, provider_last_name, search_option, date_of_birth, member_id, npi]):
         raise ValueError("All required parameters must have values: client, payer_id, provider_last_name, search_option, date_of_birth, member_id, npi")
 
-    # Validate payer_id
-    valid_payer_ids = ["87726", "06111", "25463", "37602", "39026", "74227", "65088", "81400", "03432", "86050", "86047", "95378", "95467"]
-    if payer_id not in valid_payer_ids:
-        raise ValueError("Invalid payer_id: {}. Must be one of: {}".format(payer_id, ", ".join(valid_payer_ids)))
-    
     # Prefer OPTUMAI endpoint if configured, otherwise fall back to legacy UHCAPI super connector
     try:
         endpoints_cfg = client.config['MediLink_Config']['endpoints']
@@ -889,6 +983,14 @@ def get_eligibility_super_connector(client, payer_id, provider_last_name, search
         except Exception:
             url_extension = None
 
+    # Validate payer_id against the selected endpoint's list
+    # - If OPTUMAI is used, allow the augmented list (includes LIFE1, WELM2, etc.).
+    # - If UHCAPI fallback is used, enforce strict UHC list only.
+    valid_payer_ids = get_valid_payer_ids_for_endpoint(client, endpoint_name)
+    if payer_id not in valid_payer_ids:
+        raise ValueError("Invalid payer_id: {} for endpoint {}. Must be one of: {}".format(
+            payer_id, endpoint_name, ", ".join(valid_payer_ids)))
+
     if not url_extension:
         raise ValueError("Eligibility endpoint not configured for {}".format(endpoint_name))
 

MediCafe/core_utils.py

@@ -499,9 +499,7 @@ def get_api_client_factory():
     """
     # Try multiple import paths for factory
     import_specs = [
-        ('MediCafe.api_factory', 'APIClientFactory'),
-        ('MediLink.MediLink_API_Factory', 'APIClientFactory'),  # Legacy fallback
-        ('MediLink_API_Factory', 'APIClientFactory')  # Legacy fallback
+        ('MediCafe.api_factory', 'APIClientFactory')
     ]
     
     APIClientFactory = import_with_alternatives(import_specs)

MediLink/MediLink_Deductible.py

@@ -50,6 +50,11 @@ UPGRADED TO LATEST CORE_UTILS:
 - Improved import error handling with fallbacks
 """
 # MediLink_Deductible.py
+"""
+TODO Consdier the possibility of being CSV agnostic and looking for the date of service up to 60 days old and
+then with an option to select specific patients to look up for all the valid rows.
+
+"""
 import os, sys, json
 from datetime import datetime
 
@@ -116,14 +121,15 @@ except ImportError as e:
 
 # Function to check if the date format is correct
 def validate_and_format_date(date_str):
-    # Comprehensive list of common DOB date formats
-    date_formats = [
-        # 4-digit year formats
+    """
+    Enhanced date parsing that handles ambiguous formats intelligently.
+    For ambiguous formats like MM/DD vs DD/MM, uses heuristics to determine the most likely interpretation.
+    """
+    import re
+
+    # First, try unambiguous formats (4-digit years, month names, etc.)
+    unambiguous_formats = [
         '%Y-%m-%d',    # 1990-01-15
-        '%m/%d/%Y',    # 01/15/1990
-        '%m-%d-%Y',    # 01-15-1990
-        '%d-%m-%Y',    # 15-01-1990
-        '%d/%m/%Y',    # 15/01/1990
         '%d-%b-%Y',    # 15-Jan-1990
         '%d %b %Y',    # 15 Jan 1990
         '%b %d, %Y',   # Jan 15, 1990
@@ -132,46 +138,114 @@ def validate_and_format_date(date_str):
         '%B %d %Y',    # January 15 1990
         '%Y/%m/%d',    # 1990/01/15
         '%Y%m%d',      # 19900115
+        '%y%m%d',      # 900115 (unambiguous compact format)
+    ]
+
+    # Try unambiguous formats first
+    for fmt in unambiguous_formats:
+        try:
+            if '%y' in fmt:
+                parsed_date = datetime.strptime(date_str, fmt)
+                if parsed_date.year < 50:
+                    parsed_date = parsed_date.replace(year=parsed_date.year + 2000)
+                elif parsed_date.year < 100:
+                    parsed_date = parsed_date.replace(year=parsed_date.year + 1900)
+                return parsed_date.strftime('%Y-%m-%d')
+            else:
+                return datetime.strptime(date_str, fmt).strftime('%Y-%m-%d')
+        except ValueError:
+            continue
+
+    # Handle potentially ambiguous formats with smart heuristics
+    # Check if it's a MM/DD/YYYY or DD/MM/YYYY pattern
+    ambiguous_pattern = re.match(r'^(\d{1,2})[/-](\d{1,2})[/-](\d{4})$', date_str)
+    if ambiguous_pattern:
+        first_num, second_num, year = map(int, ambiguous_pattern.groups())
+
+        # If first number > 12, it must be DD/MM/YYYY format
+        if first_num > 12:
+            try:
+                return datetime(int(year), int(second_num), int(first_num)).strftime('%Y-%m-%d')
+            except ValueError:
+                return None
+
+        # If second number > 12, it must be MM/DD/YYYY format
+        elif second_num > 12:
+            try:
+                return datetime(int(year), int(first_num), int(second_num)).strftime('%Y-%m-%d')
+            except ValueError:
+                return None
+
+        # Both numbers could be valid months (1-12), need to make an educated guess
+        else:
+            # Preference heuristic: In US context, MM/DD/YYYY is more common
+            # But also consider: if first number is 1-12 and second is 1-31, both are possible
+            # Default to MM/DD/YYYY for US-centric systems, but this could be configurable
+            try:
+                # Try MM/DD/YYYY first (US preference)
+                return datetime(int(year), int(first_num), int(second_num)).strftime('%Y-%m-%d')
+            except ValueError:
+                try:
+                    # If that fails, try DD/MM/YYYY
+                    return datetime(int(year), int(second_num), int(first_num)).strftime('%Y-%m-%d')
+                except ValueError:
+                    return None
+
+    # Handle 2-digit year ambiguous formats
+    ambiguous_2digit_pattern = re.match(r'^(\d{1,2})[/-](\d{1,2})[/-](\d{2})$', date_str)
+    if ambiguous_2digit_pattern:
+        first_num, second_num, year = map(int, ambiguous_2digit_pattern.groups())
+
+        # Apply same logic as above, but handle 2-digit year
+        year = 2000 + year if year < 50 else 1900 + year
+
+        if first_num > 12:
+            try:
+                return datetime(year, second_num, first_num).strftime('%Y-%m-%d')
+            except ValueError:
+                return None
+        elif second_num > 12:
+            try:
+                return datetime(year, first_num, second_num).strftime('%Y-%m-%d')
+            except ValueError:
+                return None
+        else:
+            # Default to MM/DD/YY (US preference)
+            try:
+                return datetime(year, first_num, second_num).strftime('%Y-%m-%d')
+            except ValueError:
+                try:
+                    return datetime(year, second_num, first_num).strftime('%Y-%m-%d')
+                except ValueError:
+                    return None
 
-        # 2-digit year formats
-        '%m/%d/%y',    # 01/15/90
+    # Try remaining formats that are less likely to be ambiguous
+    remaining_formats = [
+        '%m-%d-%Y',    # 01-15-1990
+        '%d-%m-%Y',    # 15-01-1990
+        '%d/%m/%Y',    # 15/01/1990
         '%m-%d-%y',    # 01-15-90
-        '%d/%m/%y',    # 15/01/90
         '%d-%m-%y',    # 15-01-90
-        '%d %b %y',    # 15 Jan 90
         '%b %d, %y',   # Jan 15, 90
         '%b %d %y',    # Jan 15 90
         '%y/%m/%d',    # 90/01/15
         '%y-%m-%d',    # 90-01-15
-        '%y%m%d',      # 900115
-
-        # Single digit formats (no leading zeros)
-        '%m/%d/%Y',    # 1/15/1990 (already covered above)
-        '%m-%d-%Y',    # 1-15-1990 (already covered above)
-        '%d/%m/%Y',    # 15/1/1990 (already covered above)
-        '%d-%m-%Y',    # 15-1-1990 (already covered above)
-        '%m/%d/%y',    # 1/15/90 (already covered above)
-        '%m-%d-%y',    # 1-15-90 (already covered above)
-        '%d/%m/%y',    # 15/1/90 (already covered above)
-        '%d-%m-%y',    # 15-1-90 (already covered above)
     ]
 
-    for fmt in date_formats:
+    for fmt in remaining_formats:
         try:
-            # For 2-digit years, assume 20th/21st century
             if '%y' in fmt:
                 parsed_date = datetime.strptime(date_str, fmt)
-                # Handle year 00-99: assume 1950-2049 range
                 if parsed_date.year < 50:
                     parsed_date = parsed_date.replace(year=parsed_date.year + 2000)
                 elif parsed_date.year < 100:
                     parsed_date = parsed_date.replace(year=parsed_date.year + 1900)
-                formatted_date = parsed_date.strftime('%Y-%m-%d')
+                return parsed_date.strftime('%Y-%m-%d')
             else:
-                formatted_date = datetime.strptime(date_str, fmt).strftime('%Y-%m-%d')
-            return formatted_date
+                return datetime.strptime(date_str, fmt).strftime('%Y-%m-%d')
         except ValueError:
             continue
+
     return None
 
 # Use latest core_utils configuration cache for better performance
@@ -203,7 +277,8 @@ if provider_last_name == 'Unknown':
     MediLink_ConfigLoader.log("Warning: provider_last_name was not found in the configuration.", level="WARNING")
 
 # Define the list of payer_id's to iterate over
-payer_ids = ['87726', '03432', '96385', '95467', '86050', '86047', '95378', '06111', '37602']  # United Healthcare.
+payer_ids = ['87726', '03432', '96385', '95467', '86050', '86047', '95378', '06111', '37602']  # United Healthcare ONLY.
+
 
 # Get the latest CSV
 CSV_FILE_PATH = config.get('CSV_FILE_PATH', "")
@@ -222,10 +297,11 @@ summary_valid_rows = [
     for row in valid_rows
 ]
 
-# Print summary of valid rows
-print("\n--- Summary of Valid Rows ---")
-for row in summary_valid_rows:
-    print("DOB: {}, Member ID: {}, Payer ID: {}".format(row['DOB'], row['Ins1 Member ID'], row['Ins1 Payer ID']))
+# Display enhanced summary of valid rows using unified display philosophy
+from MediLink_Display_Utils import display_enhanced_deductible_table
+
+# Use the enhanced table display for pre-API context
+display_enhanced_deductible_table(valid_rows, context="pre_api")
 
 # List of patients with DOB and MemberID from CSV data with fallback
 patients = [
@@ -274,6 +350,15 @@ def manual_deductible_lookup():
             eligibility_data = get_eligibility_info(client, payer_id, provider_last_name, formatted_dob, member_id, npi, run_validation=run_validation, is_manual_lookup=True)
             if eligibility_data:
                 found_data = True
+                
+                # Convert to enhanced format and display
+                enhanced_result = convert_eligibility_to_enhanced_format(eligibility_data, formatted_dob, member_id)
+                if enhanced_result:
+                    print("\n" + "=" * 60)
+                    display_enhanced_deductible_table([enhanced_result], context="post_api", 
+                                                    title="Manual Lookup Result")
+                    print("=" * 60)
+                
                 # 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)
@@ -282,8 +367,6 @@ def manual_deductible_lookup():
                         "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))
                     display_eligibility_info(eligibility_data, formatted_dob, member_id, output_file)
                 
                 # Ask if user wants to open the report
@@ -799,10 +882,11 @@ def is_super_connector_response_format(data):
     """Determine if the response is in Super Connector format (has rawGraphQLResponse)"""
     return data is not None and "rawGraphQLResponse" in data
 
-# Function to extract required fields and display in a tabular format
-def display_eligibility_info(data, dob, member_id, output_file):
+# Function to convert eligibility data to enhanced display format
+def convert_eligibility_to_enhanced_format(data, dob, member_id, patient_id="", service_date=""):
+    """Convert API eligibility response to enhanced display format"""
     if data is None:
-        return
+        return None
 
     # Determine which API response format we're dealing with
     if is_legacy_response_format(data):
@@ -821,14 +905,21 @@ def display_eligibility_info(data, dob, member_id, output_file):
                 patient_info['firstName'], 
                 patient_info['middleName'], 
                 patient_info['lastName']
-            ).strip()[:20]
+            ).strip()
 
-            # Display patient information in a table row format
-            table_row = "{:<20} | {:<10} | {:<40} | {:<5} | {:<14} | {:<14}".format(
-                patient_name, dob, insurance_info['insuranceType'], 
-                insurance_info['payerId'], policy_status, remaining_amount)
-            output_file.write(table_row + "\n")
-            print(table_row)  # Print to console for progressive display
+            return {
+                'patient_id': patient_id,
+                'patient_name': patient_name,
+                'dob': dob,
+                'member_id': member_id,
+                'payer_id': insurance_info['payerId'],
+                'service_date_display': service_date,
+                'service_date_sort': datetime.min,  # Will be enhanced later
+                'status': 'Processed',
+                'insurance_type': insurance_info['insuranceType'],
+                'policy_status': policy_status,
+                'remaining_amount': remaining_amount
+            }
 
     elif is_super_connector_response_format(data):
         # Handle Super Connector API response format
@@ -841,19 +932,47 @@ def display_eligibility_info(data, dob, member_id, output_file):
             patient_info['firstName'], 
             patient_info['middleName'], 
             patient_info['lastName']
-        ).strip()[:20]
+        ).strip()
 
-        # Display patient information in a table row format
-        table_row = "{:<20} | {:<10} | {:<40} | {:<5} | {:<14} | {:<14}".format(
-            patient_name, dob, insurance_info['insuranceType'], 
-            insurance_info['payerId'], policy_status, remaining_amount)
-        output_file.write(table_row + "\n")
-        print(table_row)  # Print to console for progressive display
+        return {
+            'patient_id': patient_id,
+            'patient_name': patient_name,
+            'dob': dob,
+            'member_id': member_id,
+            'payer_id': insurance_info['payerId'],
+            'service_date_display': service_date,
+            'service_date_sort': datetime.min,  # Will be enhanced later
+            'status': 'Processed',
+            'insurance_type': insurance_info['insuranceType'],
+            'policy_status': policy_status,
+            'remaining_amount': remaining_amount
+        }
 
     else:
         # Unknown response format - log for debugging
-        MediLink_ConfigLoader.log("Unknown response format in display_eligibility_info", level="WARNING")
+        MediLink_ConfigLoader.log("Unknown response format in convert_eligibility_to_enhanced_format", level="WARNING")
         MediLink_ConfigLoader.log("Response structure: {}".format(json.dumps(data, indent=2)), level="DEBUG")
+        return None
+
+# Function to extract required fields and display in a tabular format
+def display_eligibility_info(data, dob, member_id, output_file, patient_id="", service_date=""):
+    """Legacy display function - converts to enhanced format and displays"""
+    if data is None:
+        return
+
+    # Convert to enhanced format
+    enhanced_data = convert_eligibility_to_enhanced_format(data, dob, member_id, patient_id, service_date)
+    if enhanced_data:
+        # Write to output file in legacy format for compatibility
+        table_row = "{:<20} | {:<10} | {:<40} | {:<5} | {:<14} | {:<14}".format(
+            enhanced_data['patient_name'][:20], 
+            enhanced_data['dob'], 
+            enhanced_data['insurance_type'][:40], 
+            enhanced_data['payer_id'][:5], 
+            enhanced_data['policy_status'][:14], 
+            enhanced_data['remaining_amount'][:14])
+        output_file.write(table_row + "\n")
+        print(table_row)  # Print to console for progressive display
 
 # Global mode flags (will be set in main)
 LEGACY_MODE = False
@@ -928,60 +1047,80 @@ if __name__ == "__main__":
                 print("Batch processing cancelled.")
                 continue
             
+            # PERFORMANCE FIX: Optimize patient-payer processing to avoid O(PxN) complexity
+            # Instead of nested loops, process each patient once and try payer_ids until success
+            # TODO: We should be able to determine the correct payer_id for each patient ahead of time
+            # by looking up their insurance information from the CSV data or crosswalk mapping.
+            # This would eliminate the need to try multiple payer_ids per patient and make this O(N).
+            # CLARIFICATION: In production, use the payer_id from the CSV/crosswalk as primary.
+            # Retain multi-payer probing behind a DEBUG/DIAGNOSTIC feature toggle only.
+            # Suggested flag: DEBUG_MODE_PAYER_PROBE = False (module-level), default False.
+            errors = []
+            validation_reports = []
+            processed_count = 0
+            validation_files_created = []  # Track validation files that were actually created
+            eligibility_results = []  # Collect all results for enhanced display
+            
+            for dob, member_id in patients:
+                processed_count += 1
+                print("Processing patient {}/{}: Member ID {}, DOB {}".format(
+                    processed_count, len(patients), member_id, dob))
+                
+                # Try each payer_id for this patient until we get a successful response
+                patient_processed = False
+                for payer_id in payer_ids:
+                    try:
+                        # Run with validation enabled only in debug mode
+                        run_validation = DEBUG_MODE
+                        eligibility_data = get_eligibility_info(client, payer_id, provider_last_name, dob, member_id, npi, run_validation=run_validation, is_manual_lookup=False)
+                        if eligibility_data is not None:
+                            # Convert to enhanced format and collect
+                            enhanced_result = convert_eligibility_to_enhanced_format(eligibility_data, dob, member_id)
+                            if enhanced_result:
+                                eligibility_results.append(enhanced_result)
+                            patient_processed = True
+                            
+                            # Track validation file creation in debug mode
+                            if DEBUG_MODE:
+                                validation_file_path = os.path.join(os.getenv('TEMP'), 'validation_report_{}_{}.txt'.format(member_id, dob))
+                                if os.path.exists(validation_file_path):
+                                    validation_files_created.append(validation_file_path)
+                                    print("  Validation report created: {}".format(os.path.basename(validation_file_path)))
+                            
+                            break  # Stop trying other payer_ids for this patient once we get a response
+                    except Exception as e:
+                        # Continue trying other payer_ids
+                        continue
+                
+                # If no payer_id worked for this patient, log the error
+                if not patient_processed:
+                    error_msg = "No successful payer_id found for patient"
+                    errors.append((dob, member_id, error_msg))
+
+            # Display results using enhanced table
+            if eligibility_results:
+                print("\n" + "=" * 80)
+                display_enhanced_deductible_table(eligibility_results, context="post_api")
+                print("=" * 80)
+            
+            # Write results to file for legacy compatibility
             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))
-
-                # PERFORMANCE FIX: Optimize patient-payer processing to avoid O(PxN) complexity
-                # Instead of nested loops, process each patient once and try payer_ids until success
-                # TODO: We should be able to determine the correct payer_id for each patient ahead of time
-                # by looking up their insurance information from the CSV data or crosswalk mapping.
-                # This would eliminate the need to try multiple payer_ids per patient and make this O(N).
-                # CLARIFICATION: In production, use the payer_id from the CSV/crosswalk as primary.
-                # Retain multi-payer probing behind a DEBUG/DIAGNOSTIC feature toggle only.
-                # Suggested flag: DEBUG_MODE_PAYER_PROBE = False (module-level), default False.
-                errors = []
-                validation_reports = []
-                processed_count = 0
-                validation_files_created = []  # Track validation files that were actually created
                 
-                for dob, member_id in patients:
-                    processed_count += 1
-                    print("Processing patient {}/{}: Member ID {}, DOB {}".format(
-                        processed_count, len(patients), member_id, dob))
-                    
-                    # Try each payer_id for this patient until we get a successful response
-                    patient_processed = False
-                    for payer_id in payer_ids:
-                        try:
-                            # Run with validation enabled only in debug mode
-                            run_validation = DEBUG_MODE
-                            eligibility_data = get_eligibility_info(client, payer_id, provider_last_name, dob, member_id, npi, run_validation=run_validation, is_manual_lookup=False)
-                            if eligibility_data is not None:
-                                display_eligibility_info(eligibility_data, dob, member_id, output_file)
-                                patient_processed = True
-                                
-                                # Track validation file creation in debug mode
-                                if DEBUG_MODE:
-                                    validation_file_path = os.path.join(os.getenv('TEMP'), 'validation_report_{}_{}.txt'.format(member_id, dob))
-                                    if os.path.exists(validation_file_path):
-                                        validation_files_created.append(validation_file_path)
-                                        print("  Validation report created: {}".format(os.path.basename(validation_file_path)))
-                                
-                                break  # Stop trying other payer_ids for this patient once we get a response
-                        except Exception as e:
-                            # Continue trying other payer_ids
-                            continue
-                    
-                    # If no payer_id worked for this patient, log the error
-                    if not patient_processed:
-                        error_msg = "No successful payer_id found for patient"
-                        errors.append((dob, member_id, error_msg))
+                # Write all results to file
+                for result in eligibility_results:
+                    table_row = "{:<20} | {:<10} | {:<40} | {:<5} | {:<14} | {:<14}".format(
+                        result['patient_name'][:20], 
+                        result['dob'], 
+                        result['insurance_type'][:40], 
+                        result['payer_id'][:5], 
+                        result['policy_status'][:14], 
+                        result['remaining_amount'][:14])
+                    output_file.write(table_row + "\n")
 
                 # Display errors if any
                 if errors: