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

MediLink/MediLink_837p_encoder_library.py

@@ -1,64 +1,101 @@
 # MediLink_837p_encoder_library.py
 from datetime import datetime
 import sys, os
-from MediLink import MediLink_ConfigLoader
+# Set up paths and use core utilities
+import os, sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+from MediCafe.core_utils import get_shared_config_loader
+MediLink_ConfigLoader = get_shared_config_loader()
+import re
 
 project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
 if project_dir not in sys.path:
     sys.path.append(project_dir)
 
-from MediBot import MediBot_Preprocessor_lib
-load_insurance_data_from_mains = MediBot_Preprocessor_lib.load_insurance_data_from_mains
-from MediBot import MediBot_Crosswalk_Library
+# Import MediBot modules conditionally to avoid circular imports
+MediBot_Preprocessor_lib = None
+load_insurance_data_from_mains = None
+
+try:
+    from MediBot import MediBot_Preprocessor_lib
+    if hasattr(MediBot_Preprocessor_lib, 'load_insurance_data_from_mains'):
+        load_insurance_data_from_mains = MediBot_Preprocessor_lib.load_insurance_data_from_mains
+except ImportError:
+    pass
+
+try:
+    from MediBot import MediBot_Crosswalk_Library
+except ImportError:
+    MediBot_Crosswalk_Library = None
 
 # Safe import for API functions - works in multiple contexts
 try:
-    from .MediLink_API_v3 import fetch_payer_name_from_api
+    from MediCafe import api_core as MediLink_API_v3  # [auto-migrated]
+    fetch_payer_name_from_api = getattr(MediLink_API_v3, 'fetch_payer_name_from_api', None)
+except ImportError:
+    MediLink_API_v3 = None
+    fetch_payer_name_from_api = None
+
+# Safe import for utility functions - works in multiple contexts
+try:
+    import MediLink_837p_utilities
 except (ImportError, SystemError):
     try:
-        from MediLink_API_v3 import fetch_payer_name_from_api
+        import MediLink_837p_utilities
     except ImportError:
-        import MediLink_API_v3
-        fetch_payer_name_from_api = MediLink_API_v3.fetch_payer_name_from_api
+        MediLink_837p_utilities = None
 
-# Safe import for utility functions - works in multiple contexts
+# Safe import for UI functions - works in multiple contexts
 try:
-    from .MediLink_837p_utilities import (
-        convert_date_format,
-        format_datetime,
-        get_user_confirmation,
-        prompt_user_for_payer_id,
-        format_claim_number,
-        generate_segment_counts,
-        handle_validation_errors,
-        get_output_directory,
-        winscp_validate_output_directory
-    )
+    import MediLink_UI
 except (ImportError, SystemError):
     try:
-        from MediLink_837p_utilities import (
-            convert_date_format,
-            format_datetime,
-            get_user_confirmation,
-            prompt_user_for_payer_id,
-            format_claim_number,
-            generate_segment_counts,
-            handle_validation_errors,
-            get_output_directory,
-            winscp_validate_output_directory
-        )
+        import MediLink_UI
     except ImportError:
-        import MediLink_837p_utilities
-        convert_date_format = MediLink_837p_utilities.convert_date_format
-        format_datetime = MediLink_837p_utilities.format_datetime
-        get_user_confirmation = MediLink_837p_utilities.get_user_confirmation
-        prompt_user_for_payer_id = MediLink_837p_utilities.prompt_user_for_payer_id
-        format_claim_number = MediLink_837p_utilities.format_claim_number
-        generate_segment_counts = MediLink_837p_utilities.generate_segment_counts
-        handle_validation_errors = MediLink_837p_utilities.handle_validation_errors
-        get_output_directory = MediLink_837p_utilities.get_output_directory
-        winscp_validate_output_directory = MediLink_837p_utilities.winscp_validate_output_directory
+        MediLink_UI = None
 
+# Import MediBot crosswalk utilities with fallback - using dynamic imports to avoid circular dependencies
+try:
+    import MediBot_Crosswalk_Utils
+    update_crosswalk_with_corrected_payer_id = MediBot_Crosswalk_Utils.update_crosswalk_with_corrected_payer_id
+    update_crosswalk_with_new_payer_id = MediBot_Crosswalk_Utils.update_crosswalk_with_new_payer_id
+except ImportError:
+    # Fallback to main library if utility import fails
+    try:
+        import MediBot_Crosswalk_Library
+        update_crosswalk_with_corrected_payer_id = MediBot_Crosswalk_Library.update_crosswalk_with_corrected_payer_id
+        update_crosswalk_with_new_payer_id = MediBot_Crosswalk_Library.update_crosswalk_with_new_payer_id
+    except (ImportError, AttributeError):
+        # If functions are not available, set to None for graceful handling
+        update_crosswalk_with_corrected_payer_id = None
+        update_crosswalk_with_new_payer_id = None
+
+# Import enhanced insurance selection with fallback
+try:
+    from MediLink_insurance_utils import safe_insurance_type_selection
+except ImportError:
+    safe_insurance_type_selection = None
+
+# Import display utilities
+try:
+    import MediLink_Display_Utils
+except ImportError:
+    MediLink_Display_Utils = None
+
+# Re-export commonly used functions for backward compatibility
+if MediLink_837p_utilities:
+    get_output_directory = MediLink_837p_utilities.get_output_directory
+    format_datetime = MediLink_837p_utilities.format_datetime
+    get_user_confirmation = MediLink_837p_utilities.get_user_confirmation
+    prompt_user_for_payer_id = MediLink_837p_utilities.prompt_user_for_payer_id
+    convert_date_format = MediLink_837p_utilities.convert_date_format
+    format_claim_number = MediLink_837p_utilities.format_claim_number
+    generate_segment_counts = MediLink_837p_utilities.generate_segment_counts
+    handle_validation_errors = MediLink_837p_utilities.handle_validation_errors
+    winscp_validate_output_directory = MediLink_837p_utilities.winscp_validate_output_directory
+    find_closest_insurance_matches = MediLink_837p_utilities.find_closest_insurance_matches
+    prompt_for_insurance_selection = MediLink_837p_utilities.prompt_for_insurance_selection
+    build_nm1_segment = MediLink_837p_utilities.build_nm1_segment
 
 
 # Constructs the ST segment for transaction set.
@@ -174,7 +211,7 @@ def create_1000A_submitter_name_segment(patient_data, config, endpoint):
     
     # Check if payer_id is Florida Blue (00590 or BCBSF) and assign submitter_id accordingly
     if payer_id in ['00590', 'BCBSF']:
-        submitter_id = endpoint_config.get('nm_109_bcbsf', 'DEFAULT BCBSF ID')
+        submitter_id = endpoint_config.get('nm_109_bcbs', 'DEFAULT BCBSF ID')
     else:
         submitter_id = endpoint_config.get('nm_109_value', 'DEFAULT ID')  # Default ID if not specified in endpoint
     
@@ -329,7 +366,9 @@ def resolve_payer_name(payer_id, config, primary_endpoint, insurance_name, parse
                             exit(1)
                         
                         # Step 9: Update the crosswalk with the corrected Payer ID
-                        if MediBot_Crosswalk_Library.update_crosswalk_with_corrected_payer_id(client, payer_id, corrected_payer_id, config, crosswalk):
+                        # Note: update_crosswalk_with_corrected_payer_id is imported at module level
+                        
+                        if update_crosswalk_with_corrected_payer_id(client, payer_id, corrected_payer_id, config, crosswalk):
                             return resolved_name
                         else:
                             print("Failed to update crosswalk with the corrected Payer ID.")
@@ -358,8 +397,8 @@ def resolve_payer_name(payer_id, config, primary_endpoint, insurance_name, parse
                         
                         # Placeholder for future implementation:
                         # corrected_name = input("Please enter the correct insurance name: ")
-                        # MediLink_ConfigLoader.log(f"User provided corrected insurance name: {corrected_name}", config, level="INFO")
-                        # print(f"Using manually entered insurance name: {corrected_name}")
+                        # MediLink_ConfigLoader.log("User provided corrected insurance name: {}".format(corrected_name), config, level="INFO")
+                        # print("Using manually entered insurance name: {}".format(corrected_name))
                         # TODO: Implement update_crosswalk_with_corrected_payer_name(corrected_name, payer_id, config, crosswalk)
                         # return corrected_name
     
@@ -416,9 +455,10 @@ def handle_missing_payer_id(insurance_name, config, crosswalk, client):
     confirmation_prompt = "Is the standard insurance name '{}' correct? (yes/no): ".format(standard_insurance_name)
     if get_user_confirmation(confirmation_prompt):
         # Step 7: Update the crosswalk with the new payer ID and insurance name mapping
+        # Note: update_crosswalk_with_new_payer_id is imported at module level
         try:
             MediLink_ConfigLoader.log("Updating crosswalk with payer ID: {} for insurance name: {}".format(payer_id, insurance_name), config, level="DEBUG")
-            MediBot_Crosswalk_Library.update_crosswalk_with_new_payer_id(client, insurance_name, payer_id, config, crosswalk)
+            update_crosswalk_with_new_payer_id(client, insurance_name, payer_id, config, crosswalk)
             return payer_id  # Return the payer_id after successful update
         except Exception as e:
             # Enhanced error message to include exception type and context
@@ -436,9 +476,7 @@ def handle_missing_payer_id(insurance_name, config, crosswalk, client):
 
 
 
-def build_nm1_segment(payer_name, payer_id):
-    # Step 1: Build NM1 segment using payer name and ID
-    return "NM1*PR*2*{}*****PI*{}~".format(payer_name, payer_id)
+
 
 def map_insurance_name_to_payer_id(insurance_name, config, client, crosswalk):
     """
@@ -466,10 +504,58 @@ def map_insurance_name_to_payer_id(insurance_name, config, client, crosswalk):
         # Get medisoft ID corresponding to the insurance name
         medisoft_id = insurance_to_id.get(insurance_name)
         if medisoft_id is None:
-            error_message = "No Medisoft ID found for insurance name: {}. Consider checking MAINS directly.".format(insurance_name)
-            MediLink_ConfigLoader.log(error_message, config, level="ERROR")
-            # Asking for payer ID here is not the right approach.
-            raise ValueError(error_message)
+            # Find closest matches instead of immediately failing
+            closest_matches = find_closest_insurance_matches(insurance_name, insurance_to_id)
+            
+            if closest_matches:
+                # Prompt user to select from closest matches
+                selected_insurance_name = prompt_for_insurance_selection(insurance_name, closest_matches, config)
+                
+                if selected_insurance_name:
+                    # Use the selected insurance name
+                    medisoft_id = insurance_to_id.get(selected_insurance_name)
+                    MediLink_ConfigLoader.log("Using selected insurance name '{}' for original '{}'".format(selected_insurance_name, insurance_name), config, level="INFO")
+                else:
+                    # User chose manual intervention
+                    error_message = "CLAIM SUBMISSION CANCELLED: Insurance name '{}' not found in MAINS and user chose manual intervention.".format(insurance_name)
+                    MediLink_ConfigLoader.log(error_message, config, level="WARNING")
+                    print("\n" + "="*80)
+                    print("CLAIM SUBMISSION CANCELLED: MANUAL INTERVENTION REQUIRED")
+                    print("="*80)
+                    print("\nThe system cannot automatically process this claim because:")
+                    print("- Insurance name '{}' was not found in the MAINS database".format(insurance_name))
+                    print("- Without a valid insurance mapping, the claim cannot be submitted")
+                    print("\nTo proceed with this claim, you need to:")
+                    print("1. Verify the correct insurance company name")
+                    print("2. Ensure the insurance company is in your Medisoft system")
+                    print("3. Restart the claim submission process once the insurance is properly configured")
+                    print("="*80)
+                    raise ValueError(error_message)
+            else:
+                # No matches found in MAINS
+                error_message = "CLAIM SUBMISSION FAILED: Cannot find Medisoft ID for insurance name: '{}'. No similar matches found in MAINS database.".format(insurance_name)
+                MediLink_ConfigLoader.log(error_message, config, level="ERROR")
+                print("\n" + "="*80)
+                print("CLAIM SUBMISSION ERROR: INSURANCE MAPPING FAILED")
+                print("="*80)
+                print("\nThe system cannot process this claim because:")
+                print("- Insurance name '{}' was not found in the MAINS database".format(insurance_name))
+                print("- No similar insurance names were found for manual selection")
+                print("- Without a Medisoft ID, the system cannot:")
+                print("  - Convert the insurance name to a payer ID")
+                print("  - Generate the required 837p claim format")
+                print("  - Submit the claim to the insurance company")
+                print("\nThis typically happens when:")
+                print("- The insurance company name is misspelled or abbreviated")
+                print("- The insurance company is not in Medisoft")
+                print("- The MAINS database is missing or incomplete")
+                print("\nTO FIX THIS:")
+                print("1. Check the spelling of the insurance company name")
+                print("2. Verify the insurance company exists in Medisoft")
+                print("3. If the name is correct, llamar a Dani")
+                print("4. The insurance company may need to be added")
+                print("="*80)
+                raise ValueError(error_message)
         
         # Convert medisoft_id to string to match the JSON data type
         medisoft_id_str = str(medisoft_id)
@@ -604,14 +690,14 @@ def insurance_type_selection(parsed_data):
     MediLink_ConfigLoader.log("insurance_type_selection(parsed_data): {}".format(parsed_data), level="DEBUG")
     
     # Try enhanced selection with safe fallback
-    try:
-        from MediLink_insurance_utils import safe_insurance_type_selection
-        return safe_insurance_type_selection(parsed_data, _original_insurance_type_selection_logic)
-    except ImportError as e:
-        MediLink_ConfigLoader.log("Enhanced insurance selection not available: {}. Using original logic".format(str(e)), level="INFO")
-        return _original_insurance_type_selection_logic(parsed_data)
-    except Exception as e:
-        MediLink_ConfigLoader.log("Error in enhanced insurance selection: {}. Using original logic".format(str(e)), level="ERROR")
+    if safe_insurance_type_selection:
+        try:
+            return safe_insurance_type_selection(parsed_data, _original_insurance_type_selection_logic)
+        except Exception as e:
+            MediLink_ConfigLoader.log("Error in enhanced insurance selection: {}. Using original logic".format(str(e)), level="ERROR")
+            return _original_insurance_type_selection_logic(parsed_data)
+    else:
+        MediLink_ConfigLoader.log("Enhanced insurance selection not available. Using original logic", level="INFO")
         return _original_insurance_type_selection_logic(parsed_data)
 
 def _original_insurance_type_selection_logic(parsed_data):
@@ -644,8 +730,8 @@ def _original_insurance_type_selection_logic(parsed_data):
         display_full_list = input("Do you want to see the full list of insurance options? (yes/no): ").strip().lower()
 
         # Display full list if user confirms
-        if display_full_list in ['yes', 'y']:
-            MediLink_UI.display_insurance_options(insurance_options)
+        if display_full_list in ['yes', 'y'] and MediLink_Display_Utils:
+            MediLink_Display_Utils.display_insurance_options(insurance_options)
 
     # Horrible menu
     prompt_display_insurance_options()
@@ -892,8 +978,8 @@ def create_interchange_elements(config, endpoint, transaction_set_control_number
         isa13 = endpoint_config.get('isa_13_value', '000000001')
     
     # Create interchange header and trailer using provided library functions.
-    isa_header, gs_header = create_interchange_header(config, endpoint, isa13)
-    ge_trailer, iea_trailer = create_interchange_trailer(config, transaction_set_control_number, isa13)
+    isa_header, gs_header, gs06 = create_interchange_header(config, endpoint, isa13)
+    ge_trailer, iea_trailer = create_interchange_trailer(config, transaction_set_control_number, isa13, gs06)
     
     return isa_header, gs_header, ge_trailer, iea_trailer
 
@@ -909,7 +995,7 @@ def create_interchange_header(config, endpoint, isa13):
     - isa13: The ISA13 field value representing the current system time.
 
     Returns:
-    - Tuple containing the ISA and GS segment strings.
+    - Tuple containing the ISA segment, GS segment, and group control number (gs06).
     """
     endpoint_config = config['endpoints'].get(endpoint.upper(), {})
     
@@ -935,19 +1021,22 @@ def create_interchange_header(config, endpoint, isa13):
     # GS Segment
     # GS04 YYYYMMDD
     # GS06 Group Control Number, Field Length 1/9, must match GE02
-    # BUG probably move up a function.
-    gs06 = '1' # Placeholder for now?
+    # FIXED: Generate group control number using similar logic to ISA13 for consistency
+    current_time = datetime.now().strftime('%H%M%S')
+    gs06 = current_time[-6:]  # Use last 6 digits of time for uniqueness within reasonable bounds
+    if not gs06 or len(gs06) < 1:
+        gs06 = '1'  # Fallback to simple increment
     
     gs_segment = "GS*HC*{}*{}*{}*{}*{}*X*005010X222A1~".format(
         gs_sender_code, gs_receiver_code, format_datetime(), format_datetime(format_type='time'), gs06
     )
 
-    MediLink_ConfigLoader.log("Created interchange header for endpoint: {}".format(endpoint), config, level="INFO")
+    MediLink_ConfigLoader.log("Created interchange header for endpoint: {} with group control number: {}".format(endpoint, gs06), config, level="INFO")
     
-    return isa_segment, gs_segment
+    return isa_segment, gs_segment, gs06
 
 # Generates the GE and IEA segments for the interchange trailer based on the number of transactions and functional groups.
-def create_interchange_trailer(config, num_transactions, isa13, num_functional_groups=1):
+def create_interchange_trailer(config, num_transactions, isa13, gs06, num_functional_groups=1):
     """
     Generate GE and IEA segments for the interchange trailer.
     
@@ -955,6 +1044,7 @@ def create_interchange_trailer(config, num_transactions, isa13, num_functional_g
     - config: Configuration dictionary with settings and identifiers.
     - num_transactions: The number of transactions within the functional group.
     - isa13: The ISA13 field value representing the current system time.
+    - gs06: The group control number from GS segment (must match GE02).
     - num_functional_groups: The number of functional groups within the interchange. Default is 1.
     
     Returns:
@@ -965,14 +1055,13 @@ def create_interchange_trailer(config, num_transactions, isa13, num_functional_g
     # Indicates the end of a functional group and provides the count of the number of transactions within it.
     
     # GE02 Group Control Number, Field Length 1/9, must match GS06 (Header)
-    # TODO This gs/ge matching should probably move up a function like isa13. 
-    ge02 = '1' #Placeholder for now?
-    ge_segment = "GE*{}*{}~".format(num_transactions, ge02)
+    # FIXED: Use the gs06 parameter passed from the header generation instead of hardcoded placeholder
+    ge_segment = "GE*{}*{}~".format(num_transactions, gs06)
     
     # IEA Segment: Interchange Control Trailer (Note: IEA02 needs to equal ISA13)
     iea_segment = "IEA*{}*{}~".format(num_functional_groups, isa13)
     
-    MediLink_ConfigLoader.log("Created interchange trailer", config, level="INFO")
+    MediLink_ConfigLoader.log("Created interchange trailer with matching group control number: {}".format(gs06), config, level="INFO")
     
     return ge_segment, iea_segment
 
@@ -1029,78 +1118,65 @@ def validate_claim_data_for_837p(parsed_data, config, crosswalk):
         MediLink_ConfigLoader.log("Updated crosswalk with new diagnosis code: {}, for Medisoft code {}".format(diagnosis_code, medisoft_code), config, level="INFO")
         print("\n[SUCCESS] Added '{}' -> '{}' to crosswalk".format(diagnosis_code, medisoft_code))
         print("  IMPORTANT: You must manually save this to crosswalk.json to persist the change!")
-        # TODO This needs to actually save the .json though which right now I'd like to route through the dedicated function for updating the crosswalk. 
-        # TODO This should have been a validation exercise upstream and not a last minute check like this.
-    
-    # Validate procedure code
-    procedure_code = parsed_data.get('CODEA', '').strip()
-    if not procedure_code or procedure_code.lower() in ['unknown', 'none', '']:
-        # Log the error condition with detailed context
-        error_message = "Procedure code is empty for chart number: {}. Please verify. Diagnosis code is {}".format(chart_number, diagnosis_code)
-        MediLink_ConfigLoader.log(error_message, config, level="CRITICAL")
-        
-        print("\n{}".format("="*80))
-        print("CRITICAL: Missing procedure code for patient {}".format(chart_number))
-        print("{}".format("="*80))
-        print("Diagnosis: {}".format(diagnosis_code))
-        print("Patient: {}, {}".format(parsed_data.get('LAST', 'Unknown'), parsed_data.get('FIRST', 'Unknown')))
-        print("Service Date: {}".format(parsed_data.get('DATE', 'Unknown')))
-        print("\nThis procedure code needs to be added to the crosswalk.json file.")
-        print("\nCurrent procedure_to_diagnosis mapping format:")
-        
-        # Show example entries from the crosswalk
-        procedure_examples = list(crosswalk.get('procedure_to_diagnosis', {}).items())[:3]
-        for proc_code, diagnosis_list in procedure_examples:
-            print("  '{}': {}".format(proc_code, diagnosis_list))
-        
-        print("\nPlease enter the CPT procedure code (e.g., 66984):")
-        procedure_code = input("> ").strip()
-        
-        if not procedure_code:
-            raise ValueError("Cannot proceed without procedure code for patient {}".format(chart_number))
-        
-        # Update the crosswalk dictionary with the new pairing of procedure_code and diagnosis_code
-        if procedure_code not in crosswalk.get('procedure_to_diagnosis', {}):
-            crosswalk.setdefault('procedure_to_diagnosis', {})[procedure_code] = []
-        crosswalk['procedure_to_diagnosis'][procedure_code].append(diagnosis_code)
-        MediLink_ConfigLoader.log("Updated crosswalk with new procedure code: {}, for diagnosis code {}".format(procedure_code, diagnosis_code), config, level="INFO")
-        print("\n[SUCCESS] Added '{}' -> ['{}'] to crosswalk".format(procedure_code, diagnosis_code))
-        print("  IMPORTANT: You must manually save this to crosswalk.json to persist the change!")
-        # TODO This needs to actually save the .json though which right now I'd like to route through the dedicated function for updating the crosswalk. 
-        # TODO This should have been a validation exercise upstream and not a last minute check like this.
-    
-    # Update the validated data
-    validated_data['DIAG'] = medisoft_code
-    validated_data['CODEA'] = procedure_code
-    
-    # Validate other critical fields
-    critical_fields = {
-        'AMOUNT': 'claim amount',
-        'TOS': 'type of service',
-        'POS': 'place of service',
-        'MINTUES': 'service minutes'
-    }
-    
-    for field, description in critical_fields.items():
-        value = validated_data.get(field, '').strip()
-        if not value or value.lower() in ['unknown', 'none', '']:
-            print("\n{}".format("="*80))
-            print("CRITICAL: Missing {} for patient {}".format(description, chart_number))
-            print("{}".format("="*80))
-            print("Field: {}".format(field))
-            print("Patient: {}, {}".format(parsed_data.get('LAST', 'Unknown'), parsed_data.get('FIRST', 'Unknown')))
-            print("Service Date: {}".format(parsed_data.get('DATE', 'Unknown')))
-            print("\nPlease enter the {}:".format(description))
-            new_value = input("> ").strip()
-            
-            if not new_value:
-                raise ValueError("Cannot proceed without {} for patient {}".format(description, chart_number))
-            
-            validated_data[field] = new_value
-            print("\n[SUCCESS] Updated {} to '{}'".format(field, new_value))
-    
-    print("\n[SUCCESS] All claim data validated for patient {}".format(chart_number))
-    return validated_data
-
-
-
+        # TODO (HIGH PRIORITY - Crosswalk Data Persistence and Validation):
+        # PROBLEM: Diagnosis codes are added to crosswalk in memory but not persisted to file.
+        # Changes are lost when application restarts, requiring manual intervention.
+        # Additionally, validation should happen upstream rather than at encoding time.
+        #
+        # CURRENT WORKFLOW ISSUES:
+        # 1. In-memory crosswalk changes are not saved to crosswalk.json automatically
+        # 2. User must manually save changes (error-prone, often forgotten)
+        # 3. Validation happens during encoding (too late in the process)
+        # 4. No backup or rollback mechanism for crosswalk changes
+        # 5. No validation of new mappings before they're added
+        #
+        # IMPLEMENTATION PLAN:
+        # 
+        # Phase 1: Automatic Persistence
+        # 1. Identify or create dedicated crosswalk update function:
+        #    - Look for existing save_crosswalk_to_file() or similar
+        #    - If doesn't exist, create update_crosswalk_mapping(section, key, value, config)
+        # 2. Replace manual save requirement with automatic persistence:
+        #    - Call crosswalk persistence function immediately after in-memory update
+        #    - Add file locking to prevent concurrent modification conflicts
+        #    - Create backup before modification for rollback capability
+        #
+        # Phase 2: Upstream Validation (RECOMMENDED)
+        # 1. Move validation to data preprocessing stage:
+        #    - Add validate_diagnosis_codes_in_csv() function in preprocessing
+        #    - Check all diagnosis codes against crosswalk before encoding starts
+        #    - Batch collect all missing codes and prompt user once
+        # 2. Create interactive crosswalk update session:
+        #    - Present all missing codes to user in a single session
+        #    - Allow bulk updates with confirmation
+        #    - Save all changes at once rather than piecemeal
+        #
+        # Phase 3: Enhanced Validation (FUTURE)
+        # 1. Add ICD-10 code validation against official code sets
+        # 2. Suggest similar codes when exact matches aren't found
+        # 3. Add crosswalk versioning and change tracking
+        # 4. Implement crosswalk sharing across multiple users/systems
+        #
+        # IMMEDIATE IMPLEMENTATION:
+        # 1. Find existing crosswalk persistence function or create one
+        # 2. Add call here: save_crosswalk_to_file(crosswalk, config)
+        # 3. Remove manual save message
+        # 4. Add error handling for file save failures
+        # 5. Add logging for successful crosswalk updates
+        #
+        # FUNCTIONS TO LOOK FOR:
+        # - save_crosswalk_to_file()
+        # - update_crosswalk_json()
+        # - persist_crosswalk_changes()
+        # - write_crosswalk_config()
+        #
+        # FILES TO CHECK:
+        # - MediLink_main.py (likely location for config management)
+        # - MediCafe/MediLink_ConfigLoader.py (configuration management)
+        # - Current file (encoder_library.py) for existing patterns
+        #
+        # TESTING REQUIREMENTS:
+        # - Verify crosswalk changes persist across application restarts
+        # - Test concurrent access scenarios
+        # - Verify backup/restore functionality
+        # - Test with invalid JSON syntax in crosswalk file