medicafe 0.250728.8__py3-none-any.whl → 0.250805.0__py3-none-any.whl

MediLink/MediLink_Deductible.py

@@ -41,29 +41,77 @@ Features Added:
 2. Supports multiple manual requests, each generating its own Notepad file.
 3. Validates user inputs and provides feedback on required formats.
 4. Displays available Payer IDs as a note after manual entries.
+
+UPGRADED TO LATEST CORE_UTILS:
+- Uses setup_project_path() for standardized path management
+- Uses get_api_core_client() for improved API client handling
+- Uses create_config_cache() for better performance
+- Uses log_import_error() for enhanced error logging
+- Improved import error handling with fallbacks
 """
 # MediLink_Deductible.py
-import MediLink_API_v3
-import os, sys, requests, json
+import os, sys, json
 from datetime import datetime
 
+# Add parent directory to Python path to access MediCafe module
+current_dir = os.path.dirname(os.path.abspath(__file__))
+parent_dir = os.path.dirname(current_dir)
+if parent_dir not in sys.path:
+    sys.path.insert(0, parent_dir)
+
+# Use latest core_utils for standardized setup and imports
+try:
+    from MediCafe.core_utils import (
+        setup_project_path, 
+        get_shared_config_loader, 
+        get_api_core_client,
+        log_import_error,
+        create_config_cache
+    )
+    # Set up project paths using latest core_utils
+    project_dir = setup_project_path(__file__)
+    MediLink_ConfigLoader = get_shared_config_loader()
+
+    # Import api_core for eligibility functions
+    try:
+        from MediCafe import api_core
+    except ImportError:
+        api_core = None
+    
+    # Import api_core for eligibility functions
+    try:
+        from MediCafe import api_core
+    except ImportError:
+        api_core = None
+    
+    # Import api_core for eligibility functions
+    try:
+        from MediCafe import api_core
+    except ImportError:
+        api_core = None
+except ImportError as e:
+    print("Error: Unable to import MediCafe.core_utils. Please ensure MediCafe package is properly installed.")
+    # Don't call log_import_error here since it's not available yet
+    print("Import error: {}".format(e))
+    sys.exit(1)
+
+# Safe import for requests with fallback
 try:
-    from MediLink import MediLink_ConfigLoader
+    import requests
 except ImportError:
-    import MediLink_ConfigLoader
+    requests = None
+    print("Warning: requests module not available. Some API functionality may be limited.")
 
 try:
     from MediLink import MediLink_Deductible_Validator
-except ImportError:
+except ImportError as e:
+    print("Warning: Unable to import MediLink_Deductible_Validator: {}".format(e))
     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)
-
 try:
     from MediBot import MediBot_Preprocessor_lib
-except ImportError:
+except ImportError as e:
+    print("Warning: Unable to import MediBot_Preprocessor_lib: {}".format(e))
     import MediBot_Preprocessor_lib
 
 # Function to check if the date format is correct
@@ -76,11 +124,25 @@ def validate_and_format_date(date_str):
             continue
     return None
 
-# Load configuration
-config, _ = MediLink_ConfigLoader.load_configuration()
+# Use latest core_utils configuration cache for better performance
+_get_config, (_config_cache, _crosswalk_cache) = create_config_cache()
 
-# Initialize the API client
-client = MediLink_API_v3.APIClient()
+# Load configuration using latest core_utils pattern
+config, _ = _get_config()
+
+# Initialize the API client using latest core_utils
+client = get_api_core_client()
+if client is None:
+    print("Warning: API client not available via core_utils")
+    # Fallback to direct instantiation
+    try:
+        if api_core:
+            client = api_core.APIClient()
+        else:
+            raise ImportError("api_core not available")
+    except ImportError as e:
+        print("Error: Unable to create API client: {}".format(e))
+        client = None
 
 # Get provider_last_name and npi from configuration
 provider_last_name = config['MediLink_Config'].get('default_billing_provider_last_name', 'Unknown')
@@ -97,14 +159,14 @@ payer_ids = ['87726', '03432', '96385', '95467', '86050', '86047', '95378', '061
 CSV_FILE_PATH = config.get('CSV_FILE_PATH', "")
 csv_data = MediBot_Preprocessor_lib.load_csv_data(CSV_FILE_PATH)
 
-# Only keep rows that contain a valid number from the payer_ids list
-valid_rows = [row for row in csv_data if str(row.get('Ins1 Payer ID', '')) in payer_ids]
+# Only keep rows that have an exact match with a payer ID from the payer_ids list
+valid_rows = [row for row in csv_data if str(row.get('Ins1 Payer ID', '')).strip() in payer_ids]
 
 # Extract important columns for summary with fallback
 summary_valid_rows = [
     {
         'DOB': row.get('Patient DOB', row.get('DOB', '')),  # Try 'Patient DOB' first, then 'DOB'
-        'Ins1 Member ID': row.get('Primary Policy Number', row.get('Ins1 Member ID', '')),  # Try 'Primary Policy Number' first, then 'Ins1 Member ID'
+        'Ins1 Member ID': row.get('Primary Policy Number', row.get('Ins1 Member ID', '')).strip(),  # Try 'Primary Policy Number' first, then 'Ins1 Member ID'
         'Ins1 Payer ID': row.get('Ins1 Payer ID', '')
     }
     for row in valid_rows
@@ -210,7 +272,7 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
             
             # Get legacy response
             MediLink_ConfigLoader.log("Getting legacy get_eligibility_v3 API response", level="INFO")
-            legacy_eligibility = MediLink_API_v3.get_eligibility_v3(
+            legacy_eligibility = api_core.get_eligibility_v3(
                 client, payer_id, provider_last_name, 'MemberIDDateOfBirth', date_of_birth, member_id, npi
             )
             
@@ -218,7 +280,7 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
             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(
+                super_connector_eligibility = api_core.get_eligibility_super_connector(
                     client, payer_id, provider_last_name, 'MemberIDDateOfBirth', date_of_birth, member_id, npi
                 )
             except Exception as e:
@@ -271,7 +333,7 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
             
             # Only get legacy response
             MediLink_ConfigLoader.log("Getting legacy get_eligibility_v3 API response", level="INFO")
-            eligibility = MediLink_API_v3.get_eligibility_v3(
+            eligibility = api_core.get_eligibility_v3(
                 client, payer_id, provider_last_name, 'MemberIDDateOfBirth', date_of_birth, member_id, npi
             )
         
@@ -279,17 +341,82 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
         MediLink_ConfigLoader.log("Eligibility response: {}".format(json.dumps(eligibility, indent=4)), level="DEBUG")
         
         return eligibility
-    except requests.exceptions.HTTPError as e:
-        # Log the HTTP error response
-        MediLink_ConfigLoader.log("HTTPError: {}".format(e), level="ERROR")
-        MediLink_ConfigLoader.log("Response content: {}".format(e.response.content), level="ERROR")
     except Exception as e:
-        # Log any other exceptions
-        MediLink_ConfigLoader.log("Error: {}".format(e), level="ERROR")
+        # Handle HTTP errors if requests is available
+        if requests and hasattr(requests, 'exceptions') and isinstance(e, requests.exceptions.HTTPError):
+            # Log the HTTP error response
+            print("API Request Error: {}".format(e))
+            if hasattr(e, 'response') and hasattr(e.response, 'content'):
+                MediLink_ConfigLoader.log("Response content: {}".format(e.response.content), level="ERROR")
+        else:
+            # Log any other exceptions
+            print("Eligibility Check Error: {}".format(e))
     return None
 
 # Helper functions to extract data from different API response formats
-# BUG the API response is coming through correctly but the parsers below are not correctly extracting the super_connector variables.
+# TODO (HIGH PRIORITY - API Response Parser Debugging):
+# PROBLEM: API responses are returning correctly but the parser functions below 
+# are not successfully extracting the super_connector variables (likely eligibility data).
+# This suggests a schema mismatch between expected and actual API response format.
+#
+# DEBUGGING STEPS:
+# 1. Response Structure Analysis:
+#    - Add comprehensive logging of raw API responses before parsing
+#    - Compare current response format vs expected format in parser functions
+#    - Check if API endpoint has changed response schema recently
+#    - Verify if different endpoints return different response structures
+#
+# 2. Parser Function Validation:
+#    - Test each extract_*_patient_info() function with sample responses
+#    - Check if field names/paths have changed (e.g., 'patientInfo' vs 'patient_info')
+#    - Verify array indexing logic (e.g., [0] access on empty arrays)
+#    - Check case sensitivity in field access
+#
+# 3. Super Connector Variable Mapping:
+#    - Document what "super_connector variables" should contain
+#    - Identify which fields from API response map to these variables
+#    - Verify the expected format vs actual format
+#    - Check if variable names have changed in the application
+#
+# IMPLEMENTATION PLAN:
+# 1. Enhanced Logging:
+#    - Add log_api_response_structure(response) function
+#    - Log raw JSON before each parser function call
+#    - Add field-by-field parsing logs with null checks
+#
+# 2. Parser Robustness:
+#    - Add null/empty checks for all field accesses
+#    - Implement graceful fallbacks for missing fields
+#    - Add validation for expected data types
+#    - Handle both old and new response formats if schema changed
+#
+# 3. Schema Validation:
+#    - Create validate_api_response_schema(response, expected_schema) function
+#    - Define expected schemas for each API endpoint
+#    - Alert when response doesn't match expected schema
+#    - Suggest schema updates when mismatches occur
+#
+# 4. Testing Framework:
+#    - Create test cases with known good API responses
+#    - Test parser functions independently of API calls
+#    - Add integration tests for end-to-end parsing workflow
+#    - Create mock responses for development testing
+#
+# IMMEDIATE ACTIONS:
+# 1. Add detailed logging before each extract_*_patient_info() call
+# 2. Log the structure of the 'policy' object being passed to parsers
+# 3. Check if the issue is in extract_legacy_patient_info() vs extract_super_connector_patient_info()
+# 4. Verify which API endpoint is being called and if it matches expected parser
+#
+# FILES TO EXAMINE:
+# - This file: all extract_*_patient_info() functions
+# - MediCafe/api_core.py: API call implementation and response handling
+# - Config files: Check if API endpoints or credentials have changed
+#
+# RELATED ISSUES:
+# - May be connected to authentication or endpoint configuration problems
+# - Could indicate API version updates that changed response format
+# - Might be related to different payer-specific response formats
 
 def extract_legacy_patient_info(policy):
     """Extract patient information from legacy API response format"""
@@ -725,7 +852,7 @@ if __name__ == "__main__":
                 print(table_header)
                 print("-" * len(table_header))
 
-                # PERFORMANCE FIX: Optimize patient-payer processing to avoid O(P×N) complexity
+                # 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.

MediLink/MediLink_Display_Utils.py

@@ -0,0 +1,72 @@
+# MediLink_Display_Utils.py
+# Display utility functions extracted from MediLink_UI.py to eliminate circular dependencies
+# Provides centralized display functions for insurance options and patient summaries
+
+from datetime import datetime
+
+# Use core utilities for standardized imports
+from MediCafe.core_utils import get_shared_config_loader
+MediLink_ConfigLoader = get_shared_config_loader()
+
+def display_insurance_options(insurance_options=None):
+    """Display insurance options, loading from config if not provided"""
+    
+    if insurance_options is None:
+        config, _ = MediLink_ConfigLoader.load_configuration()
+        insurance_options = config.get('MediLink_Config', {}).get('insurance_options', {})
+    
+    print("\nInsurance Type Options (SBR09 Codes):")
+    print("-" * 50)
+    for code, description in sorted(insurance_options.items()):
+        print("{:>3}: {}".format(code, description))
+    print("-" * 50)
+    print("Note: '12' (PPO) is the default if no selection is made.")
+    print()  # Add a blank line for better readability
+
+def display_patient_summaries(detailed_patient_data):
+    """
+    Displays summaries of all patients and their suggested endpoints.
+    """
+    print("\nSummary of patient details and suggested endpoint:")
+    for index, summary in enumerate(detailed_patient_data, start=1):
+        try:
+            display_file_summary(index, summary)
+        except KeyError as e:
+            print("Summary at index {} is missing key: {}".format(index, e))
+    print() # add blank line for improved readability.
+
+def display_file_summary(index, summary):
+    # Ensure surgery_date is converted to a datetime object
+    surgery_date = datetime.strptime(summary['surgery_date'], "%m-%d-%y")
+    
+    # Add header row if it's the first index
+    if index == 1:
+        print("{:<3} {:5} {:<10} {:20} {:15} {:3} {:20}".format(
+            "No.", "Date", "ID", "Name", "Primary Ins.", "IT", "Current Endpoint"
+        ))
+        print("-"*82)
+
+    # Check if insurance_type is available; if not, set a default placeholder (this should already be '12' at this point)
+    insurance_type = summary.get('insurance_type', '--')
+    
+    # Get the effective endpoint (confirmed > user preference > suggestion > default)
+    effective_endpoint = (summary.get('confirmed_endpoint') or 
+                         summary.get('user_preferred_endpoint') or 
+                         summary.get('suggested_endpoint', 'AVAILITY'))
+
+    # Format insurance type for display - handle both 2 and 3 character codes
+    if insurance_type and len(insurance_type) <= 3:
+        insurance_display = insurance_type
+    else:
+        insurance_display = insurance_type[:3] if insurance_type else '--'
+
+    # Displays the summary of a file.
+    print("{:02d}. {:5} ({:<8}) {:20} {:15} {:3} {:20}".format(
+        index,
+        surgery_date.strftime("%m-%d"),
+        summary['patient_id'],
+        summary['patient_name'][:20],
+        summary['primary_insurance'][:15],
+        insurance_display,
+        effective_endpoint[:20])
+    ) 

MediLink/MediLink_Down.py

@@ -1,8 +1,49 @@
 # MediLink_Down.py
-import os, shutil
-from MediLink_Decoder import process_decoded_file, display_consolidated_records, write_records_to_csv
-from MediLink_ConfigLoader import log, load_configuration
-from MediLink_DataMgmt import operate_winscp
+import os, shutil, sys
+
+# Add paths
+project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+current_dir = os.path.abspath(os.path.dirname(__file__))
+if project_dir not in sys.path:
+    sys.path.append(project_dir)
+if current_dir not in sys.path:
+    sys.path.append(current_dir)
+
+# Use core utilities for imports
+try:
+    from MediCafe.core_utils import get_shared_config_loader
+    MediLink_ConfigLoader = get_shared_config_loader()
+    if MediLink_ConfigLoader is not None:
+        log = MediLink_ConfigLoader.log
+        load_configuration = MediLink_ConfigLoader.load_configuration
+    else:
+        raise ImportError("MediLink_ConfigLoader not available")
+except ImportError:
+    # Fallback for when core_utils is not available
+    def log(message, level="INFO"):
+        print("[{}] {}".format(level, message))
+    def load_configuration():
+        return {}, {}
+
+try:
+    from MediLink_Decoder import process_decoded_file, display_consolidated_records, write_records_to_csv
+except ImportError:
+    # Fallback if decoder not available
+    process_decoded_file = None
+    display_consolidated_records = None
+    write_records_to_csv = None
+
+try:
+    from MediLink_DataMgmt import operate_winscp
+except ImportError:
+    operate_winscp = None
+
+try:
+    from tqdm import tqdm
+except ImportError:
+    # Fallback for when tqdm is not available
+    def tqdm(iterable, **kwargs):
+        return iterable
 
 def handle_files(local_storage_path, downloaded_files):
     """
@@ -139,10 +180,91 @@ def main(desired_endpoint=None):
         else:
             log("No files were downloaded for endpoint: {}. Exiting...".format(desired_endpoint), level="WARNING")
             return None, None
-
+    
     except Exception as e:
         log("An error occurred in MediLink_Down.main: {}".format(e), level="ERROR")
         return None, None
 
+
+def check_for_new_remittances(config=None):
+    """
+    Function to check for new remittance files across all configured endpoints.
+    Loads the configuration, validates it, and processes each endpoint to download and handle files.
+    Accumulates results from all endpoints and processes them together at the end.
+    """
+    # Start the process and log the initiation
+    log("Starting check_for_new_remittances function")
+    print("\nChecking for new files across all endpoints...")
+    log("Checking for new files across all endpoints...")
+
+    # Step 1: Load and validate the configuration
+    if config is None:
+        config, _ = load_configuration()
+
+    if not config or 'MediLink_Config' not in config or 'endpoints' not in config['MediLink_Config']:
+        log("Error: Config is missing necessary sections. Aborting...", level="ERROR")
+        return
+
+    endpoints = config['MediLink_Config'].get('endpoints')
+    if not isinstance(endpoints, dict):
+        log("Error: 'endpoints' is not a dictionary. Aborting...", level="ERROR")
+        return
+
+    # Lists to accumulate all consolidated records and translated files across all endpoints
+    all_consolidated_records = []
+    all_translated_files = []
+
+    # Step 2: Process each endpoint and accumulate results
+    for endpoint_key, endpoint_info in tqdm(endpoints.items(), desc="Processing endpoints"):
+        # Validate endpoint structure
+        if not endpoint_info or not isinstance(endpoint_info, dict):
+            log("Error: Invalid endpoint structure for {}. Skipping...".format(endpoint_key), level="ERROR")
+            continue
+
+        if 'remote_directory_down' in endpoint_info:
+            # Process the endpoint and handle the files
+            log("Processing endpoint: {}".format(endpoint_key))
+            consolidated_records, translated_files = process_endpoint(endpoint_key, endpoint_info, config)
+            
+            # Accumulate the results for later processing
+            if consolidated_records:
+                all_consolidated_records.extend(consolidated_records)
+            if translated_files:
+                all_translated_files.extend(translated_files)
+        else:
+            log("Skipping endpoint '{}'. 'remote_directory_down' not configured.".format(endpoint_info.get('name', 'Unknown')), level="WARNING")
+
+    # Step 3: After processing all endpoints, handle the accumulated results
+    if all_consolidated_records:
+        display_consolidated_records(all_consolidated_records)  # Ensure this is called only once
+        prompt_csv_export(all_consolidated_records, config['MediLink_Config']['local_storage_path'])
+    else:
+        log("No records to display after processing all endpoints.", level="WARNING")
+        print("No records to display after processing all endpoints.")
+
+
+def process_endpoint(endpoint_key, endpoint_info, config):
+    """
+    Helper function to process a single endpoint.
+    Downloads files from the endpoint, processes them, and returns the consolidated records and translated files.
+    """
+    try:
+        # Process the files for the given endpoint
+        local_storage_path = config['MediLink_Config']['local_storage_path']
+        log("[Process Endpoint] Local storage path set to {}".format(local_storage_path))
+        downloaded_files = operate_winscp("download", None, endpoint_info, local_storage_path, config)
+        
+        if downloaded_files:
+            log("[Process Endpoint] WinSCP Downloaded the following files: \n{}".format(downloaded_files))
+            return handle_files(local_storage_path, downloaded_files)
+        else:
+            log("[Process Endpoint]No files were downloaded for endpoint: {}.".format(endpoint_key), level="WARNING")
+            return [], []
+
+    except Exception as e:
+        # Handle any exceptions that occur during the processing
+        log("Error processing endpoint {}: {}".format(endpoint_key, e), level="ERROR")
+        return [], []
+
 if __name__ == "__main__":
     main()