medicafe 0.250722.0__py3-none-any.whl → 0.250723.0__py3-none-any.whl

MediBot/MediBot_UI.py

@@ -23,6 +23,8 @@ class AppControl:
         self.script_paused = False
         self.mapat_med_path = ''
         self.medisoft_shortcut = ''
+        # PERFORMANCE FIX: Add configuration caching to reduce lookup overhead
+        self._config_cache = {}  # Cache for Medicare vs Private configuration lookups
         # Load initial paths from config when instance is created
         self.load_paths_from_config()
 
@@ -47,12 +49,28 @@ class AppControl:
     def load_paths_from_config(self, medicare=False):
         # Assuming `config` is a module or a globally accessible configuration dictionary
         # TODO Is this where the MAINS paths should also be set?
-        if medicare:
-            self.mapat_med_path = config.get('MEDICARE_MAPAT_MED_PATH', "")
-            self.medisoft_shortcut = config.get('MEDICARE_SHORTCUT', "")
-        else:
-            self.mapat_med_path = config.get('MAPAT_MED_PATH', "")
-            self.medisoft_shortcut = config.get('PRIVATE_SHORTCUT', "")
+        
+        # PERFORMANCE FIX: Cache configuration lookups to reduce Medicare vs Private overhead
+        cache_key = 'medicare' if medicare else 'private'
+        
+        if cache_key not in self._config_cache:
+            # Build cache entry for this configuration type
+            if medicare:
+                cached_config = {
+                    'mapat_path': config.get('MEDICARE_MAPAT_MED_PATH', ""),
+                    'shortcut': config.get('MEDICARE_SHORTCUT', "")
+                }
+            else:
+                cached_config = {
+                    'mapat_path': config.get('MAPAT_MED_PATH', ""),
+                    'shortcut': config.get('PRIVATE_SHORTCUT', "")
+                }
+            self._config_cache[cache_key] = cached_config
+        
+        # Use cached values to avoid repeated config lookups
+        cached = self._config_cache[cache_key]
+        self.mapat_med_path = cached['mapat_path']
+        self.medisoft_shortcut = cached['shortcut']
 
 app_control = AppControl()
 
@@ -178,6 +196,12 @@ def display_menu_header(title):
     print("-" * 60)
 
 def handle_user_interaction(interaction_mode, error_message):
+    # Import here to avoid circular imports
+    try:
+        from MediBot import current_patient_context
+    except ImportError:
+        current_patient_context = None
+    
     while True:
         # If interaction_mode is neither 'triage' nor 'error', then it's normal mode.
         title = "Error Occurred" if interaction_mode == 'error' else "Data Entry Options"
@@ -186,9 +210,19 @@ def handle_user_interaction(interaction_mode, error_message):
         if interaction_mode == 'error':
             print("\nERROR: ", error_message)
 
-        # Need to tell the user which patient we're talking about because it won't be obvious anymore.
-        # Also, this ERROR might be called from a location where the menu below isn't relevant like selecting patients 
-        # -- need a better way to handle that.
+        # PERFORMANCE FIX: Display patient context to address "won't be obvious anymore" issue
+        # Show user which patient and field they're working with for better F11 menu usability
+        if current_patient_context:
+            patient_name = current_patient_context.get('patient_name', 'Unknown Patient')
+            surgery_date = current_patient_context.get('surgery_date', 'Unknown Date')
+            last_field = current_patient_context.get('last_field', 'Unknown Field')
+            print("\nCurrent Context:")
+            print("  Patient: {}".format(patient_name))
+            print("  Surgery Date: {}".format(surgery_date))
+            print("  Last Field: {}".format(last_field))
+            print("")
+
+        # Menu options with improved context
         print("1: Retry last entry")
         print("2: Skip to next patient and continue")
         print("3: Go back two patients and redo")

MediLink/MediLink_API_v3.py

@@ -668,6 +668,9 @@ def submit_uhc_claim(client, x12_request_data):
         if not transaction_id:
             raise ValueError("transactionId not found in the submission response")
         
+        # Log the transaction ID for traceability
+        MediLink_ConfigLoader.log("UHCAPI claim submission transactionId: {}".format(transaction_id), level="INFO")
+        
         # Prepare the request body for the claim acknowledgement retrieval
         acknowledgement_body = {'transactionId': transaction_id}
 

MediLink/MediLink_ClaimStatus.py

@@ -1,6 +1,8 @@
 # MediLink_ClaimStatus.py
 from datetime import datetime, timedelta
 import os
+import time
+import json
 import MediLink_API_v3
 
 try:
@@ -21,140 +23,251 @@ start_date_str = start_date.strftime('%m/%d/%Y')
 billing_provider_tin = config['MediLink_Config'].get('billing_provider_tin')
 
 # Define the list of payer_id's to iterate over
-payer_ids = ['87726'] # Default Value
+payer_ids = ['87726', '03432', '96385', '95467', '86050', '86047', '95378', '37602']
 # Allowed payer id's for UHC 87726, 03432, 96385, 95467, 86050, 86047, 95378, 37602. This api does not support payerId 06111.
-# payer_ids = ['87726', '03432', '96385', '95467', '86050', '86047', '95378', '37602']
-# Oddly enough, the API is completely ignoring the payerId parameter and returning the exact same dataset for all payer IDs. 
 
 # Initialize the API client
 client = MediLink_API_v3.APIClient()
 
-# Function to process and display the data in a compact, tabular format
-def display_claim_summary(claim_summary, payer_id, output_file):
-    claims = claim_summary.get('claims', [])
+class ClaimCache:
+    """In-memory cache for API responses"""
+    def __init__(self):
+        self.cache = {}  # {cache_key: {'data': response, 'payer_id': payer_id}}
     
-    # Display header
-    header = "Payer ID: {} | Start Date: {} | End Date: {}".format(payer_id, start_date_str, end_date_str)
+    def get_cache_key(self, tin, start_date, end_date, payer_id):
+        """Generate unique cache key for API call parameters"""
+        return "{}_{}_{}_{}".format(tin, start_date, end_date, payer_id)
+    
+    def is_cached(self, cache_key):
+        """Check if response is cached"""
+        return cache_key in self.cache
+    
+    def get_cached_response(self, cache_key):
+        """Retrieve cached response"""
+        return self.cache[cache_key]['data']
+    
+    def cache_response(self, cache_key, response, payer_id):
+        """Cache API response"""
+        self.cache[cache_key] = {
+            'data': response,
+            'payer_id': payer_id
+        }
+    
+    def clear_cache(self):
+        """Clear all cached data"""
+        self.cache.clear()
+
+class ConsolidatedClaims:
+    """Consolidated claims data structure"""
+    def __init__(self):
+        self.claims_by_number = {}  # {claim_number: {claim_data, payer_sources: [payer_ids]}}
+        self.payer_ids_checked = set()
+        self.duplicate_warnings = []
+    
+    def add_claim(self, claim_data, payer_id):
+        """Add claim to consolidated data, tracking payer sources"""
+        claim_number = claim_data['claim_number']
+        
+        if claim_number not in self.claims_by_number:
+            self.claims_by_number[claim_number] = {
+                'data': claim_data,
+                'payer_sources': [payer_id]
+            }
+        else:
+            # Check if this is a duplicate with different data
+            existing_data = self.claims_by_number[claim_number]['data']
+            if self._claims_equal(existing_data, claim_data):
+                # Same data, just add payer source
+                if payer_id not in self.claims_by_number[claim_number]['payer_sources']:
+                    self.claims_by_number[claim_number]['payer_sources'].append(payer_id)
+            else:
+                # Different data - create warning
+                self.duplicate_warnings.append({
+                    'claim_number': claim_number,
+                    'existing_payers': self.claims_by_number[claim_number]['payer_sources'],
+                    'new_payer': payer_id,
+                    'existing_data': existing_data,
+                    'new_data': claim_data
+                })
+        
+        self.payer_ids_checked.add(payer_id)
+    
+    def _claims_equal(self, claim1, claim2):
+        """Compare two claim data structures for equality"""
+        # Compare key fields that should be identical for the same claim
+        key_fields = ['claim_status', 'patient_name', 'processed_date', 'first_service_date', 
+                     'total_charged_amount', 'total_allowed_amount', 'total_paid_amount', 
+                     'total_patient_responsibility_amount']
+        
+        for field in key_fields:
+            if claim1.get(field) != claim2.get(field):
+                return False
+        return True
+
+def extract_claim_data(claim):
+    """Extract standardized claim data from API response"""
+    claim_number = claim['claimNumber']
+    claim_status = claim['claimStatus']
+    patient_first_name = claim['memberInfo']['ptntFn']
+    patient_last_name = claim['memberInfo']['ptntLn']
+    processed_date = claim['claimSummary']['processedDt']
+    first_service_date = claim['claimSummary']['firstSrvcDt']
+    total_charged_amount = claim['claimSummary']['totalChargedAmt']
+    total_allowed_amount = claim['claimSummary']['totalAllowdAmt']
+    total_paid_amount = claim['claimSummary']['totalPaidAmt']
+    total_patient_responsibility_amount = claim['claimSummary']['totalPtntRespAmt']
+    
+    patient_name = "{} {}".format(patient_first_name, patient_last_name)
+    
+    return {
+        'claim_number': claim_number,
+        'claim_status': claim_status,
+        'patient_name': patient_name,
+        'processed_date': processed_date,
+        'first_service_date': first_service_date,
+        'total_charged_amount': total_charged_amount,
+        'total_allowed_amount': total_allowed_amount,
+        'total_paid_amount': total_paid_amount,
+        'total_patient_responsibility_amount': total_patient_responsibility_amount,
+        'claim_xwalk_data': claim['claimSummary']['clmXWalkData']
+    }
+
+def process_claims_with_payer_rotation(billing_provider_tin, start_date_str, end_date_str, 
+                                     payer_ids, cache, consolidated_claims):
+    """
+    Process claims across multiple payer IDs with caching and consolidation
+    """
+    client = MediLink_API_v3.APIClient()
+    
+    for payer_id in payer_ids:
+        print("Processing Payer ID: {}".format(payer_id))
+        
+        # Generate cache key
+        cache_key = cache.get_cache_key(billing_provider_tin, start_date_str, end_date_str, payer_id)
+        
+        # Check cache first
+        if cache.is_cached(cache_key):
+            print("  Using cached response for Payer ID: {}".format(payer_id))
+            claim_summary = cache.get_cached_response(cache_key)
+        else:
+            print("  Making API call for Payer ID: {}".format(payer_id))
+            try:
+                claim_summary = MediLink_API_v3.get_claim_summary_by_provider(
+                    client, billing_provider_tin, start_date_str, end_date_str, payer_id=payer_id
+                )
+                cache.cache_response(cache_key, claim_summary, payer_id)
+            except Exception as e:
+                print("  Error processing Payer ID {}: {}".format(payer_id, e))
+                continue
+        
+        # Process claims from this payer
+        claims = claim_summary.get('claims', [])
+        for claim in claims:
+            claim_data = extract_claim_data(claim)
+            consolidated_claims.add_claim(claim_data, payer_id)
+
+def display_consolidated_claims(consolidated_claims, output_file):
+    """
+    Display consolidated claims with payer ID header and duplicate warnings
+    """
+    # Display header with all payer IDs checked
+    payer_ids_str = ", ".join(sorted(consolidated_claims.payer_ids_checked))
+    header = "Payer IDs Checked: {} | Start Date: {} | End Date: {}".format(
+        payer_ids_str, start_date_str, end_date_str)
     print(header)
-    output_file.write(header + "\n")  # Write header to the output file
+    output_file.write(header + "\n")
     print("=" * len(header))
-    output_file.write("=" * len(header) + "\n")  # Write separator to the output file
-
+    output_file.write("=" * len(header) + "\n")
+    
     # Table header
-    table_header = "{:<10} | {:<10} | {:<20} | {:<6} | {:<6} | {:<7} | {:<7} | {:<7} | {:<7}".format(
-        "Claim #", "Status", "Patient", "Proc.", "Serv.", "Allowed", "Paid", "Pt Resp", "Charged")
+    table_header = "{:<10} | {:<10} | {:<20} | {:<6} | {:<6} | {:<7} | {:<7} | {:<7} | {:<7} | {:<15}".format(
+        "Claim #", "Status", "Patient", "Proc.", "Serv.", "Allowed", "Paid", "Pt Resp", "Charged", "Payer Sources")
     print(table_header)
-    output_file.write(table_header + "\n")  # Write table header to the output file
+    output_file.write(table_header + "\n")
     print("-" * len(table_header))
-    output_file.write("-" * len(table_header) + "\n")  # Write separator to the output file
-
-    # Process each claim and display it in a compact format
-    claims_dict = {}
-    for claim in claims:
-        claim_number = claim['claimNumber']  # String: e.g., "29285698"
-        claim_status = claim['claimStatus']  # String: e.g., "Finalized"
-        patient_first_name = claim['memberInfo']['ptntFn']  # String: e.g., "FRANK"
-        patient_last_name = claim['memberInfo']['ptntLn']  # String: e.g., "LOHR"
-        processed_date = claim['claimSummary']['processedDt']  # String (Date in "MM/DD/YYYY" format): e.g., "06/10/2024"
-        first_service_date = claim['claimSummary']['firstSrvcDt']  # String (Date in "MM/DD/YYYY" format): e.g., "05/13/2024"
-        total_charged_amount = claim['claimSummary']['totalChargedAmt']  # String (Decimal as String): e.g., "450.00"
-        total_allowed_amount = claim['claimSummary']['totalAllowdAmt']  # String (Decimal as String): e.g., "108.95"
-        total_paid_amount = claim['claimSummary']['totalPaidAmt']  # String (Decimal as String): e.g., "106.78"
-        total_patient_responsibility_amount = claim['claimSummary']['totalPtntRespAmt']  # String (Decimal as String): e.g., "0.00"
+    output_file.write("-" * len(table_header) + "\n")
+    
+    # Sort claims by first service date
+    sorted_claims = sorted(
+        consolidated_claims.claims_by_number.items(),
+        key=lambda x: x[1]['data']['first_service_date']
+    )
+    
+    # Display each claim
+    for claim_number, claim_info in sorted_claims:
+        claim_data = claim_info['data']
+        payer_sources = claim_info['payer_sources']
+        
+        # Format payer sources
+        payer_sources_str = ", ".join(sorted(payer_sources))
+        
+        table_row = "{:<10} | {:<10} | {:<20} | {:<6} | {:<6} | {:<7} | {:<7} | {:<7} | {:<7} | {:<15}".format(
+            claim_number, claim_data['claim_status'], claim_data['patient_name'][:20],
+            claim_data['processed_date'][:5], claim_data['first_service_date'][:5],
+            claim_data['total_allowed_amount'], claim_data['total_paid_amount'],
+            claim_data['total_patient_responsibility_amount'], claim_data['total_charged_amount'],
+            payer_sources_str
+        )
+        print(table_row)
+        output_file.write(table_row + "\n")
         
-        patient_name = "{} {}".format(patient_first_name, patient_last_name)
-
-        # Store claims in a dictionary to handle duplicate claim numbers
-        if claim_number not in claims_dict:
-            claims_dict[claim_number] = []
-        claims_dict[claim_number].append({
-            'claim_status': claim_status,
-            'patient_name': patient_name,
-            'processed_date': processed_date,
-            'first_service_date': first_service_date,
-            'total_charged_amount': total_charged_amount,
-            'total_allowed_amount': total_allowed_amount,
-            'total_paid_amount': total_paid_amount,
-            'total_patient_responsibility_amount': total_patient_responsibility_amount,
-            'claim_xwalk_data': claim['claimSummary']['clmXWalkData']
-        })
-
-    # Sort claims by first_service_date
-    sorted_claims = sorted(claims_dict.items(), key=lambda x: x[1][0]['first_service_date'])
-
-    for claim_number, claim_data_list in sorted_claims:
-        # Check for repeated claim numbers and validate data
-        if len(claim_data_list) > 1:
-            # Validate data
-            unique_claims = {tuple(claim_data.items()) for claim_data in claim_data_list}
-            if len(unique_claims) == 1:
-                # Data is the same, only print once
-                claim_data = claim_data_list[0]
-                table_row = "{:<10} | {:<10} | {:<20} | {:<6} | {:<6} | {:<7} | {:<7} | {:<7} | {:<7}".format(
-                    claim_number, claim_data['claim_status'], claim_data['patient_name'][:20], 
-                    claim_data['processed_date'][:5], claim_data['first_service_date'][:5],
-                    claim_data['total_allowed_amount'], claim_data['total_paid_amount'], 
-                    claim_data['total_patient_responsibility_amount'], claim_data['total_charged_amount']
+        # Display crosswalk data for $0.00 claims
+        if claim_data['total_paid_amount'] == '0.00':
+            for xwalk in claim_data['claim_xwalk_data']:
+                clm507Cd = xwalk['clm507Cd']
+                clm507CdDesc = xwalk['clm507CdDesc']
+                clm508Cd = xwalk['clm508Cd']
+                clm508CdDesc = xwalk['clm508CdDesc']
+                clmIcnSufxCd = xwalk['clmIcnSufxCd']
+                print("  507: {} ({}) | 508: {} ({}) | ICN Suffix: {}".format(
+                    clm507Cd, clm507CdDesc, clm508Cd, clm508CdDesc, clmIcnSufxCd))
+    
+    # Display duplicate warnings (terminal and log only, not file)
+    if consolidated_claims.duplicate_warnings:
+        print("\n" + "="*80)
+        print("DUPLICATE CLAIM WARNINGS:")
+        print("="*80)
+        
+        for warning in consolidated_claims.duplicate_warnings:
+            warning_msg = (
+                "Claim {} found in multiple payers with different data:\n"
+                "  Existing payers: {}\n"
+                "  New payer: {}\n"
+                "  Status difference: {} vs {}\n"
+                "  Amount difference: ${} vs ${}".format(
+                    warning['claim_number'],
+                    ", ".join(warning['existing_payers']),
+                    warning['new_payer'],
+                    warning['existing_data']['claim_status'],
+                    warning['new_data']['claim_status'],
+                    warning['existing_data']['total_paid_amount'],
+                    warning['new_data']['total_paid_amount']
                 )
-                print(table_row)
-                output_file.write(table_row + "\n")  # Write each row to the output file
-
-                if claim_data['total_paid_amount'] == '0.00':
-                    for xwalk in claim_data['claim_xwalk_data']:
-                        clm507Cd = xwalk['clm507Cd']  # String: e.g., "F1"
-                        clm507CdDesc = xwalk['clm507CdDesc']  # String: e.g., "Finalized/Payment-The claim/line has been paid."
-                        clm508Cd = xwalk['clm508Cd']  # String: e.g., "104"
-                        clm508CdDesc = xwalk['clm508CdDesc']  # String: e.g., "Processed according to plan provisions..."
-                        clmIcnSufxCd = xwalk['clmIcnSufxCd']  # String: e.g., "01"
-                        print("  507: {} ({}) | 508: {} ({}) | ICN Suffix: {}".format(clm507Cd, clm507CdDesc, clm508Cd, clm508CdDesc, clmIcnSufxCd))
-            else:
-                # Data is different, print all
-                for claim_data in claim_data_list:
-                    table_row = "{:<10} | {:<10} | {:<20} | {:<6} | {:<6} | {:<7} | {:<7} | {:<7} | {:<7}".format(
-                        claim_number, claim_data['claim_status'], claim_data['patient_name'][:20], 
-                        claim_data['processed_date'][:5], claim_data['first_service_date'][:5],
-                        claim_data['total_allowed_amount'], claim_data['total_paid_amount'], 
-                        claim_data['total_patient_responsibility_amount'], claim_data['total_charged_amount']
-                    )
-                    print(table_row + " (Duplicate with different data)")
-                    output_file.write(table_row + " (Duplicate with different data)\n")  # Write each row to the output file
-
-                    if claim_data['total_paid_amount'] == '0.00':
-                        for xwalk in claim_data['claim_xwalk_data']:
-                            clm507Cd = xwalk['clm507Cd']  # String: e.g., "F1"
-                            clm507CdDesc = xwalk['clm507CdDesc']  # String: e.g., "Finalized/Payment-The claim/line has been paid."
-                            clm508Cd = xwalk['clm508Cd']  # String: e.g., "104"
-                            clm508CdDesc = xwalk['clm508CdDesc']  # String: e.g., "Processed according to plan provisions..."
-                            clmIcnSufxCd = xwalk['clmIcnSufxCd']  # String: e.g., "01"
-                            print("  507: {} ({}) | 508: {} ({}) | ICN Suffix: {}".format(clm507Cd, clm507CdDesc, clm508Cd, clm508CdDesc, clmIcnSufxCd))
-        else:
-            # Only one claim, print normally
-            claim_data = claim_data_list[0]
-            table_row = "{:<10} | {:<10} | {:<20} | {:<6} | {:<6} | {:<7} | {:<7} | {:<7} | {:<7}".format(
-                claim_number, claim_data['claim_status'], claim_data['patient_name'][:20], 
-                claim_data['processed_date'][:5], claim_data['first_service_date'][:5],
-                claim_data['total_allowed_amount'], claim_data['total_paid_amount'], 
-                claim_data['total_patient_responsibility_amount'], claim_data['total_charged_amount']
             )
-            print(table_row)
-            output_file.write(table_row + "\n")  # Write each row to the output file
-
-            if claim_data['total_paid_amount'] == '0.00':
-                for xwalk in claim_data['claim_xwalk_data']:
-                    clm507Cd = xwalk['clm507Cd']  # String: e.g., "F1"
-                    clm507CdDesc = xwalk['clm507CdDesc']  # String: e.g., "Finalized/Payment-The claim/line has been paid."
-                    clm508Cd = xwalk['clm508Cd']  # String: e.g., "104"
-                    clm508CdDesc = xwalk['clm508CdDesc']  # String: e.g., "Processed according to plan provisions..."
-                    clmIcnSufxCd = xwalk['clmIcnSufxCd']  # String: e.g., "01"
-                    print("  507: {} ({}) | 508: {} ({}) | ICN Suffix: {}".format(clm507Cd, clm507CdDesc, clm508Cd, clm508CdDesc, clmIcnSufxCd))
-
-# Create a temporary file to store the claim summary
+            print(warning_msg)
+            
+            # Log the warning
+            MediLink_ConfigLoader.log(
+                "Duplicate claim warning: {}".format(warning_msg),
+                level="WARNING"
+            )
+
+# Initialize cache and consolidated claims
+cache = ClaimCache()
+consolidated_claims = ConsolidatedClaims()
+
+# Process claims with payer rotation
+process_claims_with_payer_rotation(
+    billing_provider_tin, start_date_str, end_date_str, payer_ids, cache, consolidated_claims
+)
+
+# Display consolidated results
 output_file_path = os.path.join(os.getenv('TEMP'), 'claim_summary_report.txt')
 with open(output_file_path, 'w') as output_file:
-    # Loop through each payer_id and call the API, then display the claim summary
-    for payer_id in payer_ids:
-        claim_summary = MediLink_API_v3.get_claim_summary_by_provider(client, billing_provider_tin, start_date_str, end_date_str, payer_id=payer_id)
-        display_claim_summary(claim_summary, payer_id, output_file)  # Pass output_file to the display function
+    display_consolidated_claims(consolidated_claims, output_file)
+
+# Clear cache after consolidated table is generated
+cache.clear_cache()
 
 # Open the generated file in Notepad
 os.startfile(output_file_path)  # Use os.startfile for better handling