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

MediLink/MediLink_DataMgmt.py

@@ -1,13 +1,29 @@
 import csv, os, re, subprocess, time
 from datetime import datetime, timedelta
 
+# Import centralized logging configuration
+try:
+    from MediCafe.logging_config import PERFORMANCE_LOGGING
+except ImportError:
+    # Fallback to local flag if centralized config is not available
+    PERFORMANCE_LOGGING = False
+
 # Need this for running Medibot and MediLink
+from MediCafe.core_utils import get_shared_config_loader
+MediLink_ConfigLoader = get_shared_config_loader()
 try:
-    import MediLink_ConfigLoader
-    import MediLink_UI
+    import MediLink_Display_Utils
 except ImportError:
-    from . import MediLink_ConfigLoader
-    from . import MediLink_UI
+    from MediLink import MediLink_Display_Utils
+
+# MediBot imports will be done locally in functions to avoid circular imports
+def _get_medibot_function(module_name, function_name):
+    """Dynamically import MediBot functions when needed to avoid circular imports."""
+    try:
+        module = __import__('MediBot.{}'.format(module_name), fromlist=[function_name])
+        return getattr(module, function_name)
+    except (ImportError, AttributeError):
+        return None
 
 # Helper function to slice and strip values with optional key suffix
 def slice_data(data, slices, suffix=''):
@@ -29,16 +45,17 @@ def parse_fixed_width_data(personal_info, insurance_info, service_info, service_
     insurance_slices = config['fixedWidthSlices']['insurance_slices']
     service_slices = config['fixedWidthSlices']['service_slices']
 
-    # Parse each segment
+    # Parse each segment - core 3-line record structure
     parsed_data = {}
-    parsed_data.update(slice_data(personal_info, personal_slices))
-    parsed_data.update(slice_data(insurance_info, insurance_slices))
-    parsed_data.update(slice_data(service_info, service_slices))
+    parsed_data.update(slice_data(personal_info, personal_slices))    # Line 1: Personal info
+    parsed_data.update(slice_data(insurance_info, insurance_slices))  # Line 2: Insurance info
+    parsed_data.update(slice_data(service_info, service_slices))      # Line 3: Service info
     
-    if service_info_2:
+    # Parse reserved expansion lines (future-ready design)
+    if service_info_2:  # Line 4: Reserved for additional service data
         parsed_data.update(slice_data(service_info_2, service_slices, suffix='_2'))
     
-    if service_info_3:
+    if service_info_3:  # Line 5: Reserved for additional service data
         parsed_data.update(slice_data(service_info_3, service_slices, suffix='_3'))
     
     # Replace underscores with spaces in first and last names since this is downstream of MediSoft. 
@@ -53,52 +70,174 @@ def parse_fixed_width_data(personal_info, insurance_info, service_info, service_
 
 # Function to read fixed-width Medisoft output and extract claim data
 def read_fixed_width_data(file_path):
-    # Reads the fixed width data from the file and yields each patient's
-    # personal, insurance, and service information.
-    MediLink_ConfigLoader.log("Starting to read fixed width data...")
-    with open(file_path, 'r') as file:
-        lines_buffer = []  # Buffer to hold lines for current patient data
-        
-        def yield_record(buffer):
-            personal_info = buffer[0]
-            insurance_info = buffer[1]
-            service_info = buffer[2]
-            service_info_2 = buffer[3] if len(buffer) > 3 else None
-            service_info_3 = buffer[4] if len(buffer) > 4 else None
-            MediLink_ConfigLoader.log("Successfully read data from file: {}".format(file_path), level="INFO")
-            return personal_info, insurance_info, service_info, service_info_2, service_info_3
-        
-        for line in file:
-            stripped_line = line.strip()
-            if stripped_line:
-                lines_buffer.append(stripped_line)
-                if 3 <= len(lines_buffer) <= 5:
-                    next_line = file.readline().strip()
-                    if not next_line:
-                        yield yield_record(lines_buffer)
-                        lines_buffer.clear()
-            else:
-                if len(lines_buffer) >= 3:
-                    yield yield_record(lines_buffer)
-                    lines_buffer.clear()
-                    
-        if lines_buffer:  # Yield any remaining buffer if file ends without a blank line
-            yield yield_record(lines_buffer)
+    """
+    Legacy function maintained for backward compatibility.
+    Reads fixed-width Medisoft data with RESERVED 5-line patient record format.
+    
+    DESIGN NOTE: This implements a reserved record structure where each patient
+    record can contain 3-5 lines (currently using 3, with 2 reserved for future expansion).
+    The peek-ahead logic is intentional to handle variable-length records and maintain
+    proper spacing between patient records.
+    """
+    # Use the consolidated function with Medisoft-specific configuration
+    medisoft_config = {
+        'mode': 'medisoft_records',
+        'min_lines': 3,
+        'max_lines': 5,
+        'skip_header': False
+    }
+    return read_consolidated_fixed_width_data(file_path, config=medisoft_config)
 
-# TODO (Refactor) Consider consolidating with the other read_fixed_with_data 
 def read_general_fixed_width_data(file_path, slices):
-    # handle any fixed-width data based on provided slice definitions
+    """
+    Legacy function maintained for backward compatibility.
+    Handles fixed-width data based on provided slice definitions.
+    """
+    # Use the consolidated function with slice-based configuration
+    slice_config = {
+        'mode': 'slice_based',
+        'slices': slices,
+        'skip_header': True
+    }
+    return read_consolidated_fixed_width_data(file_path, config=slice_config)
+
+# CONSOLIDATED IMPLEMENTATION - Replaces both read_fixed_width_data and read_general_fixed_width_data
+def read_consolidated_fixed_width_data(file_path, config=None):
+    """
+    Unified function for reading various fixed-width data formats.
+    
+    Parameters:
+    - file_path: Path to the fixed-width data file
+    - config: Configuration dictionary with the following keys:
+        - mode: 'medisoft_records' (reserved 5-line format) or 'slice_based'
+        - slices: Dictionary of field slices (for slice_based mode)
+        - skip_header: Boolean, whether to skip first line
+        - min_lines: Minimum lines per record (for medisoft_records mode)
+        - max_lines: Maximum lines per record (for medisoft_records mode)
+    
+    Returns:
+    - Generator yielding parsed records based on the specified mode
+    """
+    if config is None:
+        config = {'mode': 'medisoft_records', 'min_lines': 3, 'max_lines': 5, 'skip_header': False}
+    
+    mode = config.get('mode', 'medisoft_records')
+    
     try:
         with open(file_path, 'r', encoding='utf-8') as file:
-            next(file)  # Skip the header
-            for line_number, line in enumerate(file, start=1):
-                insurance_name = {key: line[start:end].strip() for key, (start, end) in slices.items()}
-                yield insurance_name, line_number
+            # Skip header if configured
+            if config.get('skip_header', False):
+                next(file)
+            
+            if mode == 'medisoft_records':
+                # Handle Medisoft reserved 5-line patient record format
+                yield from _process_medisoft_records(file, file_path, config)
+            elif mode == 'slice_based':
+                # Handle slice-based field extraction
+                yield from _process_slice_based_records(file, file_path, config)
+            else:
+                raise ValueError("Invalid mode '{}'. Use 'medisoft_records' or 'slice_based'".format(mode))
+                
     except FileNotFoundError:
         print("File not found: {}".format(file_path))
         MediLink_ConfigLoader.log("File not found: {}".format(file_path), level="ERROR")
         return
 
+def _process_medisoft_records(file, file_path, config):
+    """Helper function to process Medisoft-style multi-line patient records
+    
+    RECORD FORMAT DESIGN (RESERVED 5-LINE STRUCTURE):
+    ════════════════════════════════════════════════════════════════
+    Each patient record is designed as a RESERVED 5-line block:
+    
+    Line 1: Personal Info     (REQUIRED - Always present)
+    Line 2: Insurance Info    (REQUIRED - Always present)  
+    Line 3: Service Info      (REQUIRED - Always present)
+    Line 4: Service Info 2    (RESERVED - Future expansion)
+    Line 5: Service Info 3    (RESERVED - Future expansion)
+    [Blank line]             (Record separator)
+    
+    CURRENT PRODUCTION STATE:
+    ────────────────────────────
+    - Currently using: 3 active lines per record
+    - Lines 4-5: Reserved for future service data expansion
+    - Blank lines: Maintain proper record separation
+    - Total: 5-line reserved format ready for expansion
+    
+    PEEK-AHEAD LOGIC PURPOSE:
+    ────────────────────────────
+    The peek-ahead logic serves to:
+    1. Detect when we've reached the end of a record (blank line)
+    2. Allow for future expansion to 4-5 lines without code changes
+    3. Maintain proper spacing between patient records
+    4. Handle variable-length records (3-5 lines) gracefully
+    
+    FUTURE EXPANSION READY:
+    ────────────────────────────
+    When additional service lines are needed:
+    - No code changes required in reader logic
+    - Parser automatically handles service_info_2 and service_info_3
+    - Slice definitions can be extended in configuration
+    - Maintains backward compatibility with 3-line records
+    ════════════════════════════════════════════════════════════════
+    """
+    MediLink_ConfigLoader.log("Starting to read fixed width data...")
+    lines_buffer = []  # Buffer to hold lines for current patient data
+    min_lines = config.get('min_lines', 3)
+    max_lines = config.get('max_lines', 5)
+    
+    def yield_record(buffer):
+        personal_info = buffer[0]        # Line 1: Always present (personal data)
+        insurance_info = buffer[1]       # Line 2: Always present (insurance data)
+        service_info = buffer[2]         # Line 3: Always present (primary service data)
+        service_info_2 = buffer[3] if len(buffer) > 3 else None  # Line 4: Reserved (future expansion)
+        service_info_3 = buffer[4] if len(buffer) > 4 else None  # Line 5: Reserved (future expansion)
+        MediLink_ConfigLoader.log("Successfully read data from file: {}".format(file_path), level="INFO")
+        return personal_info, insurance_info, service_info, service_info_2, service_info_3
+    
+    # RESERVED RECORD FORMAT PROCESSING
+    # This logic handles the current 3-line + 2-reserved-line format
+    # and is ready for future expansion without modification
+    for line in file:
+        stripped_line = line.strip()
+        if stripped_line:
+            lines_buffer.append(stripped_line)
+            # Check if we're within the reserved record size (3-5 lines)
+            if min_lines <= len(lines_buffer) <= max_lines:
+                # Peek ahead to detect record boundary (intentional design)
+                next_line = file.readline().strip()
+                if not next_line:
+                    # Found record separator (blank line) - yield complete record
+                    yield yield_record(lines_buffer)
+                    lines_buffer.clear()
+                # If next_line has content, continue building the record
+                # (This handles future expansion to 4-5 line records)
+        else:
+            # Blank line encountered - end of current record
+            if len(lines_buffer) >= min_lines:
+                yield yield_record(lines_buffer)
+                lines_buffer.clear()
+                
+    if lines_buffer:  # Yield any remaining buffer if file ends without a blank line
+        yield yield_record(lines_buffer)
+
+def _process_slice_based_records(file, file_path, config):
+    """Helper function to process slice-based field extraction"""
+    slices = config.get('slices', {})
+    for line_number, line in enumerate(file, start=1):
+        extracted_data = {key: line[start:end].strip() for key, (start, end) in slices.items()}
+        yield extracted_data, line_number
+
+# TODO (Refactor) COMPLETED: Consolidated read_fixed_width_data and read_general_fixed_width_data
+# into read_consolidated_fixed_width_data with unified configuration-based approach.
+# Legacy functions maintained for backward compatibility.
+# 
+# DESIGN NOTE: The reserved 5-line record format is intentional architecture:
+# - Lines 1-3: Active data (personal, insurance, service)  
+# - Lines 4-5: Reserved for future service expansion
+# - Peek-ahead logic maintains proper record spacing and handles variable-length records
+# Next steps: Update all callers to use the new consolidated function directly.
+
 def consolidate_csvs(source_directory, file_prefix="Consolidated", interactive=False):
     """
     Consolidate CSV files in the source directory into a single CSV file.
@@ -411,9 +550,40 @@ def build_command(winscp_path, winscp_log_path, endpoint_config, remote_director
 
             # Handle filemask input
             if filemask:
-                # TODO: Implement logic to translate filemask into WinSCP syntax
-                # This should handle cases where filemask is a list, JSON, dictionary, or None.
-                # Example: Convert to a string like "*.{ext1}|*.{ext2}|*.{ext3}".
+                # TODO (MEDIUM PRIORITY - WinSCP Filemask Implementation):
+                # PROBLEM: Need to translate various filemask input formats into proper WinSCP syntax.
+                # Current implementation is incomplete and may not handle all edge cases.
+                #
+                # WINSCP FILEMASK SYNTAX REQUIREMENTS:
+                # - Multiple extensions: "*.ext1|*.ext2|*.ext3" (pipe-separated)
+                # - Single extension: "*.ext"
+                # - All files: "*" or "*.*"
+                # - Date patterns: "*YYYYMMDD*" for date-based filtering
+                # - Size patterns: ">100K" for files larger than 100KB
+                # - Combined: "*.csv|*.txt;>1K" (semicolon for AND conditions)
+                #
+                # INPUT FORMATS TO HANDLE:
+                # 1. List: ['csv', 'txt', 'pdf'] -> "*.csv|*.txt|*.pdf"
+                # 2. Dictionary: {'extensions': ['csv'], 'size': '>1K'} -> "*.csv;>1K"
+                # 3. String: "csv,txt" -> "*.csv|*.txt" (comma-separated to pipe-separated)
+                # 4. None/Empty: -> "*" (all files)
+                #
+                # IMPLEMENTATION STEPS:
+                # 1. Add helper function normalize_filemask(filemask) -> str
+                # 2. Handle list input: join with "|" prefix with "*."
+                # 3. Handle dict input: combine extensions with other filters using ";"
+                # 4. Handle string input: split on comma and normalize
+                # 5. Add validation for WinSCP-compatible patterns
+                # 6. Add logging for debugging filemask translations
+                #
+                # TESTING SCENARIOS:
+                # - filemask=['csv', 'txt'] should work for CSV and TXT files
+                # - filemask={'extensions': ['pdf'], 'min_size': '1MB'} for large PDFs
+                # - filemask="era,835" for claims response files
+                # - filemask=None should download all files
+                #
+                # FILES TO MODIFY: This file (execute_winscp_command function)
+                # REFERENCE: WinSCP documentation on file masks and filters
                 if isinstance(filemask, list):
                     filemask_str = '|'.join(['*.' + ext for ext in filemask])
                 elif isinstance(filemask, dict):
@@ -488,7 +658,32 @@ def execute_winscp_command(command, operation_type, files, local_storage_path):
         MediLink_ConfigLoader.log("WinSCP {} operation completed successfully.".format(operation_type))
 
         if operation_type == 'download':
-            downloaded_files = list_downloaded_files(local_storage_path) # BUG This isn't behaving correctly because the local_storage_path isn't where winscp is dumping the files
+            downloaded_files = list_downloaded_files(local_storage_path) 
+            # TODO (HIGH PRIORITY - WinSCP Path Configuration Issue): 
+            # PROBLEM: WinSCP is not downloading files to the expected local_storage_path directory.
+            # The list_downloaded_files() function is checking the wrong location.
+            #
+            # INVESTIGATION STEPS:
+            # 1. Check WinSCP logs to determine actual download destination:
+            #    - Look in config['MediLink_Config']['local_claims_path'] + "winscp_download.log"
+            #    - Parse log entries for "file downloaded to:" or similar patterns
+            # 2. Compare actual WinSCP download path vs configured local_storage_path
+            # 3. Check if WinSCP uses different path conventions (forward/backward slashes)
+            #
+            # IMPLEMENTATION OPTIONS:
+            # Option A: Fix WinSCP command to use correct target directory
+            #   - Update the lcd_command generation in execute_winscp_command()
+            #   - Ensure local_storage_path is properly escaped for WinSCP
+            # Option B: Update list_downloaded_files() to check actual WinSCP location
+            #   - Add function get_actual_winscp_download_path() that parses logs
+            #   - Call list_downloaded_files(get_actual_winscp_download_path())
+            # Option C: Add configuration parameter for WinSCP-specific download path
+            #   - Add 'winscp_download_path' to config
+            #   - Default to local_storage_path if not specified
+            #
+            # RECOMMENDED: Option A (fix root cause) + Option C (explicit config)
+            # FILES TO MODIFY: This file (execute_winscp_command, list_downloaded_files functions)
+            # TESTING: Verify downloads work correctly after fix with various file types
             MediLink_ConfigLoader.log("Files currently located in local_storage_path: {}".format(downloaded_files), level="DEBUG")
 
             if not downloaded_files:
@@ -537,40 +732,58 @@ def detect_new_files(directory_path, file_extension='.DAT'):
     :param file_extension: Extension of the files to detect.
     :return: A tuple containing a list of paths to new files detected in the directory and a flag indicating if a new file was just renamed.
     """
+    import time
+    detect_start = time.time()
+    if PERFORMANCE_LOGGING:
+        MediLink_ConfigLoader.log("File detection started for directory: {}".format(directory_path), level="INFO")
+    
     MediLink_ConfigLoader.log("Scanning directory: {}".format(directory_path), level="INFO")
     detected_file_paths = []
     file_flagged = False
     
     try:
+        listdir_start = time.time()
         filenames = os.listdir(directory_path)
-        MediLink_ConfigLoader.log("Files in directory: {}".format(filenames), level="INFO")
+        listdir_end = time.time()
+        if PERFORMANCE_LOGGING:
+            print("Directory listing completed in {:.2f} seconds".format(listdir_end - listdir_start))
         
+        # Batch log the files found instead of logging each one individually
+        matching_files = []
+        for filename in filenames:
+            if filename.endswith(file_extension):
+                matching_files.append(filename)
+        
+        if matching_files:
+            MediLink_ConfigLoader.log("Found {} files with extension {}: {}".format(
+                len(matching_files), file_extension, matching_files), level="INFO")
+        
+        file_check_start = time.time()
         for filename in filenames:
-            MediLink_ConfigLoader.log("Checking file: {}".format(filename), level="INFO")
             if filename.endswith(file_extension):
-                MediLink_ConfigLoader.log("File matches extension: {}".format(file_extension), level="INFO")
                 name, ext = os.path.splitext(filename)
-                MediLink_ConfigLoader.log("File name: {}, File extension: {}".format(name, ext), level="INFO")
                 
                 if not is_timestamped(name):
-                    MediLink_ConfigLoader.log("File is not timestamped: {}".format(filename), level="INFO")
                     new_name = "{}_{}{}".format(name, datetime.now().strftime('%Y%m%d_%H%M%S'), ext)
                     os.rename(os.path.join(directory_path, filename), os.path.join(directory_path, new_name))
                     MediLink_ConfigLoader.log("Renamed file from {} to {}".format(filename, new_name), level="INFO")
                     file_flagged = True
                     filename = new_name
-                else:
-                    MediLink_ConfigLoader.log("File is already timestamped: {}".format(filename), level="INFO")
                 
                 file_path = os.path.join(directory_path, filename)
                 detected_file_paths.append(file_path)
-                MediLink_ConfigLoader.log("Detected file path: {}".format(file_path), level="INFO")
+        
+        file_check_end = time.time()
+        if PERFORMANCE_LOGGING:
+            print("File checking completed in {:.2f} seconds".format(file_check_end - file_check_start))
     
     except Exception as e:
         MediLink_ConfigLoader.log("Error occurred: {}".format(str(e)), level="INFO")
     
-    MediLink_ConfigLoader.log("Detected files: {}".format(detected_file_paths), level="INFO")
-    MediLink_ConfigLoader.log("File flagged status: {}".format(file_flagged), level="INFO")
+    detect_end = time.time()
+    if PERFORMANCE_LOGGING:
+        print("File detection completed in {:.2f} seconds".format(detect_end - detect_start))
+    MediLink_ConfigLoader.log("Detected {} files, flagged: {}".format(len(detected_file_paths), file_flagged), level="INFO")
     
     return detected_file_paths, file_flagged
 
@@ -616,25 +829,43 @@ def confirm_all_suggested_endpoints(detailed_patient_data):
     return detailed_patient_data
 
 def bulk_edit_insurance_types(detailed_patient_data, insurance_options):
-    # Allow user to edit insurance types in a table-like format with validation
-    print("Edit Insurance Type (Enter the 2-character code). Enter 'LIST' to display available insurance types.")
+    """Allow user to edit insurance types in a table-like format with validation"""
+    print("\nEdit Insurance Type (Enter the code). Enter 'LIST' to display available insurance types.")
 
     for data in detailed_patient_data:
-        current_insurance_type = data['insurance_type']
+        patient_id = data.get('patient_id', 'Unknown')
+        patient_name = data.get('patient_name', 'Unknown')
+        current_insurance_type = data.get('insurance_type', '12')
         current_insurance_description = insurance_options.get(current_insurance_type, "Unknown")
+        
         print("({}) {:<25} | Current Ins. Type: {} - {}".format(
-            data['patient_id'], data['patient_name'], current_insurance_type, current_insurance_description))
+            patient_id, patient_name, current_insurance_type, current_insurance_description))
 
         while True:
-            new_insurance_type = input("Enter new insurance type (or press Enter to keep current): ").upper()
+            new_insurance_type = input("Enter new insurance type (or press Enter to keep current): ").strip().upper()
+            
             if new_insurance_type == 'LIST':
-                MediLink_UI.display_insurance_options(insurance_options)
-            elif not new_insurance_type or new_insurance_type in insurance_options:
-                if new_insurance_type:
-                    data['insurance_type'] = new_insurance_type
+                MediLink_Display_Utils.display_insurance_options(insurance_options)
+                continue
+                
+            elif not new_insurance_type:
+                # Keep current insurance type
+                break
+                
+            elif new_insurance_type in insurance_options:
+                # Valid insurance type from config
+                data['insurance_type'] = new_insurance_type
                 break
+                
             else:
-                print("Invalid insurance type. Please enter a valid 2-character code or type 'LIST' to see options.")
+                # User wants to use a code not in config - confirm with them
+                confirm = input("Code '{}' not found in configuration. Use it anyway? (y/n): ".format(new_insurance_type)).strip().lower()
+                if confirm in ['y', 'yes']:
+                    data['insurance_type'] = new_insurance_type
+                    break
+                else:
+                    print("Invalid insurance type. Please enter a valid code or type 'LIST' to see options.")
+                    continue
 
 def review_and_confirm_changes(detailed_patient_data, insurance_options):
     # Review and confirm changes
@@ -646,4 +877,106 @@ def review_and_confirm_changes(detailed_patient_data, insurance_options):
         insurance_description = insurance_options.get(insurance_type, "Unknown")
         print("{:<20} {:<10} {:<30}".format(data['patient_name'], insurance_type, insurance_description))
     confirm = input("\nConfirm changes? (y/n): ").strip().lower()
-    return confirm in ['y', 'yes', '']
+    return confirm in ['y', 'yes', '']
+
+
+def update_suggested_endpoint_with_user_preference(detailed_patient_data, patient_index, new_endpoint, config, crosswalk):
+    """
+    Updates the suggested endpoint for a patient and optionally updates the crosswalk 
+    for future patients with the same insurance.
+    
+    :param detailed_patient_data: List of patient data dictionaries
+    :param patient_index: Index of the patient being updated
+    :param new_endpoint: The new endpoint selected by the user
+    :param config: Configuration settings
+    :param crosswalk: Crosswalk data for in-memory updates
+    :return: Updated crosswalk if changes were made, None otherwise
+    """
+    # Note: load_insurance_data_from_mains is now imported at module level
+    
+    data = detailed_patient_data[patient_index]
+    original_suggested = data.get('suggested_endpoint')
+    
+    # Update the patient's endpoint preference
+    data['user_preferred_endpoint'] = new_endpoint
+    data['confirmed_endpoint'] = new_endpoint
+    
+    # If user changed from the original suggestion, offer to update crosswalk
+    if original_suggested != new_endpoint:
+        primary_insurance = data.get('primary_insurance')
+        patient_name = data.get('patient_name')
+        
+        print("\nYou changed the endpoint for {} from {} to {}.".format(patient_name, original_suggested, new_endpoint))
+        update_future = input("Would you like to use {} as the default endpoint for future patients with {}? (Y/N): ".format(new_endpoint, primary_insurance)).strip().lower()
+        
+        if update_future in ['y', 'yes']:
+            # Find the payer ID associated with this insurance
+            load_insurance_data_from_mains = _get_medibot_function('MediBot_Preprocessor_lib', 'load_insurance_data_from_mains')
+            insurance_to_id = load_insurance_data_from_mains(config) if load_insurance_data_from_mains else {}
+            insurance_id = insurance_to_id.get(primary_insurance)
+            
+            if insurance_id:
+                # Find the payer ID in crosswalk and update it
+                updated = False
+                for payer_id, payer_data in crosswalk.get('payer_id', {}).items():
+                    medisoft_ids = [str(id) for id in payer_data.get('medisoft_id', [])]
+                    if str(insurance_id) in medisoft_ids:
+                        # Update the crosswalk in memory
+                        crosswalk['payer_id'][payer_id]['endpoint'] = new_endpoint
+                        MediLink_ConfigLoader.log("Updated crosswalk in memory: Payer ID {} ({}) now defaults to {}".format(payer_id, primary_insurance, new_endpoint), level="INFO")
+                        
+                        # Update suggested_endpoint for other patients with same insurance in current batch
+                        for other_data in detailed_patient_data:
+                            if (other_data.get('primary_insurance') == primary_insurance and 
+                                'user_preferred_endpoint' not in other_data):
+                                other_data['suggested_endpoint'] = new_endpoint
+                        
+                        updated = True
+                        break
+                
+                if updated:
+                    # Save the updated crosswalk to disk immediately using API bypass mode
+                    if save_crosswalk_immediately(config, crosswalk):
+                        print("Updated default endpoint for {} to {}".format(primary_insurance, new_endpoint))
+                    else:
+                        print("Updated endpoint preference (will be saved during next crosswalk update)")
+                    return crosswalk
+                else:
+                    MediLink_ConfigLoader.log("Could not find payer ID in crosswalk for insurance {}".format(primary_insurance), level="WARNING")
+            else:
+                MediLink_ConfigLoader.log("Could not find insurance ID for {} to update crosswalk".format(primary_insurance), level="WARNING")
+    
+    return None
+
+
+def save_crosswalk_immediately(config, crosswalk):
+    """
+    Saves the crosswalk to disk immediately using API bypass mode.
+    
+    :param config: Configuration settings
+    :param crosswalk: Crosswalk data to save
+    :return: True if saved successfully, False otherwise
+    """
+    try:
+        # Note: save_crosswalk is imported at module level
+        
+        # Save using API bypass mode (no client needed, skip API operations)
+        save_crosswalk = _get_medibot_function('MediBot_Crosswalk_Utils', 'save_crosswalk')
+        if not save_crosswalk:
+            save_crosswalk = _get_medibot_function('MediBot_Crosswalk_Library', 'save_crosswalk')
+        
+        success = save_crosswalk(None, config, crosswalk, skip_api_operations=True) if save_crosswalk else False
+        
+        if success:
+            MediLink_ConfigLoader.log("Successfully saved crosswalk with updated endpoint preferences", level="INFO")
+        else:
+            MediLink_ConfigLoader.log("Failed to save crosswalk - preferences will be saved during next crosswalk update", level="WARNING")
+            
+        return success
+        
+    except ImportError:
+        MediLink_ConfigLoader.log("Could not import MediBot_Crosswalk_Library for saving crosswalk", level="ERROR")
+        return False
+    except Exception as e:
+        MediLink_ConfigLoader.log("Error saving crosswalk: {}".format(e), level="ERROR")
+        return False

MediLink/MediLink_Decoder.py

@@ -1,6 +1,25 @@
 # MediLink_Decoder.py
 import os, sys, csv
-from MediLink_ConfigLoader import load_configuration, log
+
+# Add workspace directory to Python path for MediCafe imports
+current_dir = os.path.dirname(os.path.abspath(__file__))
+workspace_dir = os.path.dirname(current_dir)
+if workspace_dir not in sys.path:
+    sys.path.insert(0, workspace_dir)
+
+from MediCafe.core_utils import get_shared_config_loader
+
+# Get shared config loader
+MediLink_ConfigLoader = get_shared_config_loader()
+if MediLink_ConfigLoader:
+    load_configuration = MediLink_ConfigLoader.load_configuration
+    log = MediLink_ConfigLoader.log
+else:
+    # Fallback functions if config loader is not available
+    def load_configuration():
+        return {}, {}
+    def log(message, level="INFO"):
+        print("[{}] {}".format(level, message))
 from MediLink_Parser import parse_era_content, parse_277_content, parse_277IBR_content, parse_277EBR_content, parse_dpt_content, parse_ebt_content, parse_ibt_content
 
 # Define new_fieldnames globally