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

MediLink/MediLink_PatientProcessor.py

@@ -0,0 +1,257 @@
+# MediLink_PatientProcessor.py
+# Patient data processing and endpoint determination functions
+# Extracted from MediLink.py for better modularity and maintainability
+
+import os, sys
+
+# Use core utilities for standardized imports
+from MediCafe.core_utils import get_shared_config_loader
+MediLink_ConfigLoader = get_shared_config_loader()
+
+import MediLink_DataMgmt
+import MediLink_Display_Utils
+
+# Add parent directory access for MediBot import
+project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+if project_dir not in sys.path:
+    sys.path.append(project_dir)
+
+# Use dynamic import to avoid circular dependencies
+def _get_load_insurance_function():
+    """Dynamically import load_insurance_data_from_mains to avoid circular imports."""
+    try:
+        import MediBot_Preprocessor_lib
+        return MediBot_Preprocessor_lib.load_insurance_data_from_mains
+    except (ImportError, AttributeError) as e:
+        MediLink_ConfigLoader.log("Failed to import load_insurance_data_from_mains: {}".format(e), level="WARNING")
+        return None
+
+load_insurance_data_from_mains = _get_load_insurance_function()
+
+
+def collect_detailed_patient_data(selected_files, config, crosswalk):
+    """
+    Collects detailed patient data from the selected files.
+    
+    DATA FLOW CLARIFICATION:
+    This function processes fixed-width files through extract_and_suggest_endpoint(),
+    which creates data structures with 'patient_id' field (sourced from 'CHART' field).
+    This is DIFFERENT from MediBot's parse_z_dat() flow which uses 'PATID' field.
+    
+    :param selected_files: List of selected file paths.
+    :param config: Configuration settings loaded from a JSON file.
+    :param crosswalk: Crosswalk data for mapping purposes.
+    :return: A list of detailed patient data with 'patient_id' field populated.
+    """
+    detailed_patient_data = []
+    
+    # Retrieve insurance options with codes and descriptions
+    insurance_options = config['MediLink_Config'].get('insurance_options')
+    
+    for file_path in selected_files:
+        # IMPORTANT: extract_and_suggest_endpoint creates data with 'patient_id' field
+        # sourced from the 'CHART' field in fixed-width files
+        detailed_data = extract_and_suggest_endpoint(file_path, config, crosswalk)
+        detailed_patient_data.extend(detailed_data)  # Accumulate detailed data for processing
+        
+    # Enrich the detailed patient data with insurance type
+    # NOTE: This receives data from extract_and_suggest_endpoint with 'patient_id' field
+    detailed_patient_data = enrich_with_insurance_type(detailed_patient_data, insurance_options)
+    
+    # Display summaries and provide an option for bulk edit
+    MediLink_Display_Utils.display_patient_summaries(detailed_patient_data)
+
+    return detailed_patient_data
+
+
+def enrich_with_insurance_type(detailed_patient_data, patient_insurance_type_mapping=None):
+    """
+    Enriches the detailed patient data with insurance type based on patient ID.
+    Enhanced with optional API integration and comprehensive logging.
+
+    DATA FLOW CLARIFICATION:
+    This function receives data from collect_detailed_patient_data() -> extract_and_suggest_endpoint().
+    The patient ID field is 'patient_id' (NOT 'PATID').
+    
+    IMPORTANT: Do not confuse with MediBot's parse_z_dat() flow which uses 'PATID'.
+    MediLink flow: fixed-width files -> extract_and_suggest_endpoint() -> 'patient_id' field (from 'CHART')
+    MediBot flow: Z.dat files -> parse_z_dat() -> 'PATID' field
+
+    Parameters:
+    - detailed_patient_data: List of dictionaries containing detailed patient data with 'patient_id' field.
+    - patient_insurance_mapping: Dictionary mapping patient IDs to their insurance types.
+
+    Returns:
+    - Enriched detailed patient data with insurance type added.
+    
+    TODO: Implement a function to provide `patient_insurance_mapping` from a reliable source.
+    This is going to be coming soon as an API feature from United Healthcare. We'll be able to get insurance types directly via their API.
+    So, while we won't be able to do it for all payerIDs, we'll be able to do it for the ones that are supported by UHC.
+    So, we'll need a way to augment the associated menu here so that the user is aware of which insurance types are already pulled from
+    UHC and which ones are not yet supported so they know which ones they need to edit. It is possible that we may want to isolate the 
+    patient data that is already pulled from UHC so that the user can see which ones are already using the enriched data.
+    """
+    # Enhanced mode check with graceful degradation
+    enhanced_mode = False
+    
+    try:
+        from MediLink_insurance_utils import (
+            get_feature_flag, 
+            validate_insurance_type_from_config
+        )
+        enhanced_mode = get_feature_flag('enhanced_insurance_enrichment', default=False)
+        MediLink_ConfigLoader.log("Insurance enhancement utilities loaded successfully", level="DEBUG")
+    except ImportError as e:
+        MediLink_ConfigLoader.log("Insurance utils not available: {}. Using legacy mode.".format(str(e)), level="INFO")
+        enhanced_mode = False
+    except Exception as e:
+        MediLink_ConfigLoader.log("Error initializing insurance enhancements: {}. Using legacy mode.".format(str(e)), level="ERROR")
+        enhanced_mode = False
+    
+    if patient_insurance_type_mapping is None:
+        MediLink_ConfigLoader.log("No Patient:Insurance-Type mapping available.", level="INFO")
+        patient_insurance_type_mapping = {}
+    
+    # Enhanced mode with validation
+    if enhanced_mode:
+        MediLink_ConfigLoader.log("Using enhanced insurance type enrichment", level="INFO")
+        
+        for data in detailed_patient_data:
+            # FIELD NAME CLARIFICATION: Use 'patient_id' field created by extract_and_suggest_endpoint()
+            # This field contains the value from the 'CHART' field in the original fixed-width file
+            patient_id = data.get('patient_id')
+            if patient_id:
+                raw_insurance_type = patient_insurance_type_mapping.get(patient_id, '12')  # Default to '12' (PPO/SBR09)
+                validated_insurance_type = validate_insurance_type_from_config(raw_insurance_type, patient_id)
+                data['insurance_type'] = validated_insurance_type
+                data['insurance_type_source'] = 'MANUAL' if patient_id in patient_insurance_type_mapping else 'DEFAULT'
+            else:
+                # Handle case where patient_id is missing or empty
+                MediLink_ConfigLoader.log("No patient_id found in data record", level="WARNING")
+                data['insurance_type'] = '12'  # SBR09 default PPO
+                data['insurance_type_source'] = 'DEFAULT_FALLBACK'
+        
+    else:
+        # Legacy mode (preserve existing behavior exactly)
+        MediLink_ConfigLoader.log("Using legacy insurance type enrichment", level="INFO")
+        for data in detailed_patient_data:
+            # FIELD NAME CLARIFICATION: Use 'patient_id' field created by extract_and_suggest_endpoint()
+            # This field contains the value from the 'CHART' field in the original fixed-width file
+            patient_id = data.get('patient_id')
+            if patient_id:
+                insurance_type = patient_insurance_type_mapping.get(patient_id, '12')  # Default to '12' (PPO/SBR09)
+            else:
+                # Handle case where patient_id is missing or empty
+                MediLink_ConfigLoader.log("No patient_id found in data record", level="WARNING")
+                insurance_type = '12'  # Default when no patient ID available
+            
+            data['insurance_type'] = insurance_type
+    
+    return detailed_patient_data
+
+
+def extract_and_suggest_endpoint(file_path, config, crosswalk):
+    """
+    Reads a fixed-width file, extracts file details including surgery date, patient ID, 
+    patient name, primary insurance, and other necessary details for each record. It suggests 
+    an endpoint based on insurance provider information found in the crosswalk and prepares 
+    detailed patient data for processing.
+    
+    DATA FLOW CLARIFICATION:
+    This function is the PRIMARY data source for MediLink patient processing.
+    It creates the 'patient_id' field by extracting the 'CHART' field from fixed-width files.
+    
+    IMPORTANT: This is DIFFERENT from MediBot's parse_z_dat() which extracts 'PATID'.
+    
+    Field mapping for MediLink flow:
+    - Fixed-width file 'CHART' field -> detailed_data['patient_id']
+    - This 'patient_id' is then used by enrich_with_insurance_type()
+    
+    Parameters:
+    - file_path: Path to the fixed-width file.
+    - crosswalk: Crosswalk dictionary loaded from a JSON file.
+
+    Returns:
+    - A comprehensive data structure retaining detailed patient claim details needed for processing,
+      including new key-value pairs for file path, surgery date, patient name, and primary insurance.
+    """
+    detailed_patient_data = []
+    
+    # Load insurance data from MAINS to create a mapping from insurance names to their respective IDs
+    if load_insurance_data_from_mains is None:
+        MediLink_ConfigLoader.log("load_insurance_data_from_mains function not available. Using empty insurance mapping.", level="WARNING")
+        insurance_to_id = {}
+    else:
+        insurance_to_id = load_insurance_data_from_mains(config)
+        MediLink_ConfigLoader.log("Insurance data loaded from MAINS. {} insurance providers found.".format(len(insurance_to_id)), level="INFO")
+
+    for personal_info, insurance_info, service_info, service_info_2, service_info_3 in MediLink_DataMgmt.read_fixed_width_data(file_path):
+        # Parse reserved 5-line record: 3 active lines + 2 reserved for future expansion
+        parsed_data = MediLink_DataMgmt.parse_fixed_width_data(personal_info, insurance_info, service_info, service_info_2, service_info_3, config.get('MediLink_Config', config))
+        
+        primary_insurance = parsed_data.get('INAME')
+               
+        # Retrieve the insurance ID associated with the primary insurance
+        insurance_id = insurance_to_id.get(primary_insurance)
+        MediLink_ConfigLoader.log("Primary insurance ID retrieved for '{}': {}".format(primary_insurance, insurance_id))
+
+        # Use insurance ID to retrieve the payer ID(s) associated with the insurance
+        payer_ids = []
+        if insurance_id:
+            for payer_id, payer_data in crosswalk.get('payer_id', {}).items():
+                medisoft_ids = [str(id) for id in payer_data.get('medisoft_id', [])]
+                # MediLink_ConfigLoader.log("Payer ID: {}, Medisoft IDs: {}".format(payer_id, medisoft_ids))
+                if str(insurance_id) in medisoft_ids:
+                    payer_ids.append(payer_id)
+        if payer_ids:
+            MediLink_ConfigLoader.log("Payer IDs retrieved for insurance '{}': {}".format(primary_insurance, payer_ids))
+        else:
+            MediLink_ConfigLoader.log("No payer IDs found for insurance '{}'".format(primary_insurance))
+        
+        # Find the suggested endpoint from the crosswalk based on the payer IDs
+        suggested_endpoint = 'AVAILITY'  # Default endpoint if no matching payer IDs found
+        if payer_ids:
+            payer_id = payer_ids[0]  # Select the first payer ID
+            suggested_endpoint = crosswalk['payer_id'].get(payer_id, {}).get('endpoint', 'AVAILITY')
+            MediLink_ConfigLoader.log("Suggested endpoint for payer ID '{}': {}".format(payer_id, suggested_endpoint))
+            
+            # Validate suggested endpoint against the config
+            if suggested_endpoint not in config['MediLink_Config'].get('endpoints', {}):
+                MediLink_ConfigLoader.log("Warning: Suggested endpoint '{}' is not defined in the configuration. Please Run MediBot. If this persists, check the crosswalk and config file.".format(suggested_endpoint), level="ERROR")
+                raise ValueError("Invalid suggested endpoint: '{}' for payer ID '{}'. Please correct the configuration.".format(suggested_endpoint, payer_id))
+        else:
+            MediLink_ConfigLoader.log("No suggested endpoint found for payer IDs: {}".format(payer_ids))
+
+        # Enrich detailed patient data with additional information and suggested endpoint
+        detailed_data = parsed_data.copy()  # Copy parsed_data to avoid modifying the original dictionary
+        detailed_data.update({
+            'file_path': file_path,
+            # CRITICAL FIELD MAPPING: 'CHART' field from fixed-width file becomes 'patient_id'
+            # This is the field that enrich_with_insurance_type() will use
+            'patient_id': parsed_data.get('CHART'),  # <- This is the key field mapping for MediLink flow
+            'surgery_date': parsed_data.get('DATE'),
+            'patient_name': ' '.join([parsed_data.get(key, '') for key in ['FIRST', 'MIDDLE', 'LAST']]),
+            'amount': parsed_data.get('AMOUNT'),
+            'primary_insurance': primary_insurance,
+            'suggested_endpoint': suggested_endpoint
+        })
+        detailed_patient_data.append(detailed_data)
+
+    # Return only the enriched detailed patient data, eliminating the need for a separate summary list
+    return detailed_patient_data
+
+
+def get_effective_endpoint(patient_data):
+    """
+    Returns the most appropriate endpoint for a patient based on the hierarchy:
+    1. Confirmed endpoint (final decision)
+    2. User preferred endpoint (if user made a change)
+    3. Original suggested endpoint
+    4. Default (AVAILITY)
+    
+    :param patient_data: Individual patient data dictionary
+    :return: The effective endpoint to use for this patient
+    """
+    return (patient_data.get('confirmed_endpoint') or 
+            patient_data.get('user_preferred_endpoint') or 
+            patient_data.get('suggested_endpoint', 'AVAILITY'))

MediLink/MediLink_UI.py

@@ -2,14 +2,15 @@
 from datetime import datetime
 import os, sys
 
-project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
-if project_dir not in sys.path:
-    sys.path.append(project_dir)
+# Set up paths using core utilities
+from MediCafe.core_utils import setup_module_paths
+setup_module_paths(__file__)
 
-try:
-    import MediLink_ConfigLoader
-except ImportError:
-    from MediLink import MediLink_ConfigLoader
+from MediCafe.core_utils import get_shared_config_loader
+MediLink_ConfigLoader = get_shared_config_loader()
+import MediLink_DataMgmt
+import MediLink_PatientProcessor
+import MediLink_Display_Utils
 
 def display_welcome():
     print("\n" + "-" * 60)
@@ -100,69 +101,7 @@ def get_new_endpoint_choice():
             print("Invalid input. I understood your request as: '{}'. Please enter valid endpoint numbers separated by commas.".format(choice))
             print("Tip: Ensure there are no extra spaces or periods in your input.")
 
-# Function to display full list of insurance options
-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])
-    )
+# Display functions moved to MediLink_Display_Utils.py to eliminate circular dependencies
 
 def user_select_files(file_list):
     # Sort files by creation time in descending order
@@ -196,4 +135,79 @@ def user_select_files(file_list):
     selected_indices = [int(i.strip()) - 1 for i in selected_indices.split(',')]
     selected_files = [formatted_files[i][1] for i in selected_indices]
     
-    return selected_files
+    return selected_files
+
+
+def user_decision_on_suggestions(detailed_patient_data, config, insurance_edited, crosswalk):
+    """
+    Presents the user with all patient summaries and suggested endpoints,
+    then asks for confirmation to proceed with all or specify adjustments manually.
+    
+    FIXED: Display now properly shows effective endpoints (user preferences over original suggestions)
+    """
+    if insurance_edited:
+        # Display summaries only if insurance types were edited
+        MediLink_Display_Utils.display_patient_summaries(detailed_patient_data)
+
+    while True:
+        proceed_input = input("Do you want to proceed with all suggested endpoints? (Y/N): ").strip().lower()
+        if proceed_input in ['y', 'yes']:
+            proceed = True
+            break
+        elif proceed_input in ['n', 'no']:
+            proceed = False
+            break
+        else:
+            print("Invalid input. Please enter 'Y' for yes or 'N' for no.")
+
+    # If the user agrees to proceed with all suggested endpoints, confirm them.
+    if proceed:
+        return MediLink_DataMgmt.confirm_all_suggested_endpoints(detailed_patient_data), crosswalk
+    # Otherwise, allow the user to adjust the endpoints manually.
+    else:
+        return select_and_adjust_files(detailed_patient_data, config, crosswalk)
+   
+
+def select_and_adjust_files(detailed_patient_data, config, crosswalk):
+    """
+    Allows users to select patients and adjust their endpoints by interfacing with UI functions.
+    
+    FIXED: Now properly updates suggested_endpoint and persists user preferences to crosswalk.
+    """
+    # Display options for patients
+    display_patient_options(detailed_patient_data)
+
+    # Get user-selected indices for adjustment
+    selected_indices = get_selected_indices(len(detailed_patient_data))
+    
+    # Get an ordered list of endpoint keys
+    endpoint_keys = list(config['MediLink_Config']['endpoints'].keys())
+    
+    # Iterate over each selected index and process endpoint changes
+    for i in selected_indices:
+        data = detailed_patient_data[i]
+        current_effective_endpoint = MediLink_PatientProcessor.get_effective_endpoint(data)
+        display_patient_for_adjustment(data['patient_name'], current_effective_endpoint)
+        
+        endpoint_change = get_endpoint_decision()
+        if endpoint_change == 'y':
+            display_endpoint_options(config['MediLink_Config']['endpoints'])
+            endpoint_index = int(get_new_endpoint_choice()) - 1  # Adjusting for zero-based index
+            
+            if 0 <= endpoint_index < len(endpoint_keys):
+                selected_endpoint_key = endpoint_keys[endpoint_index]
+                print("Endpoint changed to {0} for patient {1}.".format(config['MediLink_Config']['endpoints'][selected_endpoint_key]['name'], data['patient_name']))
+                
+                # Use the new endpoint management system
+                updated_crosswalk = MediLink_DataMgmt.update_suggested_endpoint_with_user_preference(
+                    detailed_patient_data, i, selected_endpoint_key, config, crosswalk
+                )
+                if updated_crosswalk:
+                    crosswalk = updated_crosswalk
+            else:
+                print("Invalid selection. Keeping the current endpoint.")
+                data['confirmed_endpoint'] = current_effective_endpoint
+        else:
+            data['confirmed_endpoint'] = current_effective_endpoint
+
+    return detailed_patient_data, crosswalk

MediLink/MediLink_Up.py

@@ -8,9 +8,19 @@ except ImportError:
     def tqdm(iterable, **kwargs):
         return iterable
 import MediLink_837p_encoder
-from MediLink_ConfigLoader import log, load_configuration
 from MediLink_DataMgmt import operate_winscp
-import MediLink_API_v3
+
+# Use core utilities for standardized imports
+from MediCafe.core_utils import get_shared_config_loader, get_api_client
+MediLink_ConfigLoader = get_shared_config_loader()
+log = MediLink_ConfigLoader.log
+load_configuration = MediLink_ConfigLoader.load_configuration
+
+# Import api_core for claim submission
+try:
+    from MediCafe import api_core
+except ImportError:
+    api_core = None
 
 # Pre-compile regex patterns for better performance
 GS_PATTERN = re.compile(r'GS\*HC\*[^*]*\*[^*]*\*([0-9]{8})\*([0-9]{4})')
@@ -75,7 +85,16 @@ def submit_claims(detailed_patient_data_grouped_by_endpoint, config, crosswalk):
         # Attempt submission to each endpoint
         if True: #confirm_transmission({endpoint: patients_data}): # Confirm transmission to each endpoint with detailed overview
             if check_internet_connection():
-                client = MediLink_API_v3.APIClient()
+                client = get_api_client()
+                if client is None:
+                    print("Warning: API client not available via factory")
+                    # Fallback to direct instantiation  
+                    try:
+                        from MediCafe import api_core
+                        client = api_core.APIClient()
+                    except ImportError:
+                        print("Error: Unable to create API client")
+                        continue
                 # Process files per endpoint
                 converted_files = MediLink_837p_encoder.convert_files_for_submission(patients_data, config, crosswalk, client)
                 if converted_files:
@@ -103,7 +122,12 @@ def submit_claims(detailed_patient_data_grouped_by_endpoint, config, crosswalk):
                                 with open(file_path, 'r') as file:
                                     # Optimize string operations by doing replacements in one pass
                                     x12_request_data = file.read().replace('\n', '').replace('\r', '').strip()
-                                    response = MediLink_API_v3.submit_uhc_claim(client, x12_request_data)
+                                    try:
+                                        from MediCafe import api_core
+                                        response = api_core.submit_uhc_claim(client, x12_request_data)
+                                    except ImportError:
+                                        print("Error: Unable to import api_core for claim submission")
+                                        response = {"error": "API module not available"}
                                     api_responses.append((file_path, response))
                             success_dict = handle_transmission_result(api_responses, config, "api", method)
                             submission_results[endpoint] = success_dict