medicafe 0.250728.8__tar.gz → 0.250728.9__tar.gz

{medicafe-0.250728.8 → medicafe-0.250728.9}/MediLink/MediLink.py

@@ -33,17 +33,25 @@ 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.
+    :return: A list of detailed patient data with 'patient_id' field populated.
     """
     detailed_patient_data = []
     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
@@ -56,8 +64,16 @@ def enrich_with_insurance_type(detailed_patient_data, patient_insurance_type_map
     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.
+    - 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:
@@ -70,48 +86,60 @@ def enrich_with_insurance_type(detailed_patient_data, patient_insurance_type_map
     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.
     """
-    # Import enhancement utilities
+    # Enhanced mode check with graceful degradation
+    enhanced_mode = False
+    
     try:
         from MediLink_insurance_utils import (
             get_feature_flag, 
-            enrich_patient_data_with_metadata,
-            generate_insurance_assignment_summary,
             validate_insurance_type_from_config
         )
         enhanced_mode = get_feature_flag('enhanced_insurance_enrichment', default=False)
-    except ImportError:
-        MediLink_ConfigLoader.log("Insurance utils not available, using legacy mode", level="DEBUG")
+        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="WARNING")
+        MediLink_ConfigLoader.log("No Patient:Insurance-Type mapping available.", level="INFO")
         patient_insurance_type_mapping = {}
     
-    # Enhanced mode with metadata and validation
+    # Enhanced mode with validation
     if enhanced_mode:
         MediLink_ConfigLoader.log("Using enhanced insurance type enrichment", level="INFO")
         
         for data in detailed_patient_data:
-            patient_id = data.get('PATID') # I think this is the right name?
-            
-            # Get insurance type with validation
-            raw_insurance_type = patient_insurance_type_mapping.get(patient_id, '12')  # Default to '12' (PPO)
-            validated_insurance_type = validate_insurance_type_from_config(raw_insurance_type, patient_id)
-            
-            # Add enhanced metadata
-            data['insurance_type'] = validated_insurance_type
-            data['insurance_type_source'] = 'MANUAL' if patient_id in patient_insurance_type_mapping else 'DEFAULT'
-            data['insurance_type_validated'] = True
-            data['insurance_type_timestamp'] = time.time()
-        
-        # Generate summary statistics
-        generate_insurance_assignment_summary(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:
-            patient_id = data.get('PATID') # I think this is the right name?
-            insurance_type = patient_insurance_type_mapping.get(patient_id, '12')  # Default to '12' (PPO)
+            # 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
@@ -123,6 +151,16 @@ def extract_and_suggest_endpoint(file_path, config, crosswalk):
     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.
@@ -177,7 +215,9 @@ def extract_and_suggest_endpoint(file_path, config, crosswalk):
         detailed_data = parsed_data.copy()  # Copy parsed_data to avoid modifying the original dictionary
         detailed_data.update({
             'file_path': file_path,
-            'patient_id': parsed_data.get('CHART'),
+            # 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'),

{medicafe-0.250728.8 → medicafe-0.250728.9}/MediLink/MediLink_837p_encoder_library.py

@@ -607,8 +607,11 @@ def insurance_type_selection(parsed_data):
     try:
         from MediLink_insurance_utils import safe_insurance_type_selection
         return safe_insurance_type_selection(parsed_data, _original_insurance_type_selection_logic)
-    except ImportError:
-        MediLink_ConfigLoader.log("Enhanced insurance selection not available, using original logic", level="DEBUG")
+    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")
         return _original_insurance_type_selection_logic(parsed_data)
 
 def _original_insurance_type_selection_logic(parsed_data):
@@ -653,11 +656,24 @@ def _original_insurance_type_selection_logic(parsed_data):
     # User input for insurance type
     user_input = input("Enter the 2-character code for the insurance type (or press Enter to default to '12' for PPO): ").strip().upper()
 
-    # Validate input and set the insurance type code
-    if user_input in insurance_options:
-        insurance_type_code = user_input
+    # Input validation and assignment
+    if user_input:
+        # Basic format validation
+        if len(user_input) > 3 or not user_input.isalnum():
+            print("Invalid format: Insurance codes should be 1-3 alphanumeric characters. Defaulting to PPO.")
+        elif user_input in insurance_options:
+            insurance_type_code = user_input
+            print("Selected: {} - {}".format(user_input, insurance_options[user_input]))
+        else:
+            # 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(user_input)).strip().lower()
+            if confirm in ['y', 'yes']:
+                insurance_type_code = user_input
+                print("Using code: {}".format(user_input))
+            else:
+                print("Defaulting to PPO (Preferred Provider Organization)")
     else:
-        print("Skipped or Input not recognized. Defaulting to Preferred Provider Organization (PPO)\n")
+        print("Using default: PPO (Preferred Provider Organization)")
 
     return insurance_type_code
 

{medicafe-0.250728.8 → medicafe-0.250728.9}/MediLink/MediLink_DataMgmt.py

@@ -616,25 +616,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
+                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

{medicafe-0.250728.8 → medicafe-0.250728.9}/MediLink/MediLink_UI.py

@@ -102,14 +102,18 @@ def get_new_endpoint_choice():
 
 # Function to display full list of insurance options
 def display_insurance_options(insurance_options=None):
-
-    # Retrieve insurance options with codes and descriptions
-    config, _ = MediLink_ConfigLoader.load_configuration()
-    insurance_options = config['MediLink_Config'].get('insurance_options')
+    """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:")
+    print("\nInsurance Type Options (SBR09 Codes):")
+    print("-" * 50)
     for code, description in sorted(insurance_options.items()):
-        print("{}: {}".format(code, description))
+        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):
@@ -130,10 +134,10 @@ def display_file_summary(index, summary):
     
     # Add header row if it's the first index
     if index == 1:
-        print("{:<3} {:5} {:<10} {:20} {:15} {:2} {:20}".format(
+        print("{:<3} {:5} {:<10} {:20} {:15} {:3} {:20}".format(
             "No.", "Date", "ID", "Name", "Primary Ins.", "IT", "Current Endpoint"
         ))
-        print("-"*80)
+        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', '--')
@@ -143,14 +147,20 @@ def display_file_summary(index, summary):
                          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} {:2} {:20}".format(
+    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_type[:2],
+        insurance_display,
         effective_endpoint[:20])
     )
 

{medicafe-0.250728.8 → medicafe-0.250728.9}/MediLink/MediLink_insurance_utils.py

@@ -13,9 +13,19 @@ except ImportError:
     import MediLink_ConfigLoader
     import MediLink_UI
 
+# Safe tqdm import with fallback
+try:
+    from tqdm import tqdm
+except ImportError:
+    # Fallback for when tqdm is not available
+    def tqdm(iterable, desc="Processing", **kwargs):
+        if desc:
+            print("{}...".format(desc))
+        return iterable
+
 # Feature flag system
 def get_feature_flag(flag_name, default=False):
-    """Centralized feature flag management"""
+    """Get feature flag from config or return default"""
     try:
         config, _ = MediLink_ConfigLoader.load_configuration()
         feature_flags = config.get("MediLink_Config", {}).get("feature_flags", {})
@@ -27,25 +37,34 @@ def get_feature_flag(flag_name, default=False):
 # Enhanced insurance type validation
 def validate_insurance_type_from_config(insurance_type_code, payer_id=""):
     """
-    Validate insurance type against configuration with proper logging.
+    Validate insurance type against configuration.
     Returns validated type or safe fallback.
     """
     try:
         config, _ = MediLink_ConfigLoader.load_configuration()
-        insurance_options = config['MediLink_Config'].get('insurance_options', {})
+        insurance_options = config.get('MediLink_Config', {}).get('insurance_options', {})
         
         if not insurance_type_code:
-            MediLink_ConfigLoader.log("Empty insurance type code for payer {}, using default PPO".format(payer_id), level="WARNING")
+            MediLink_ConfigLoader.log("Empty insurance type code for payer {}, using default PPO".format(payer_id), level="INFO")
             return '12'  # Default to PPO
         
-        # Direct lookup - insurance type already in config
+        # Clean and normalize input
+        insurance_type_code = str(insurance_type_code).strip().upper()
+        
+        # Basic format validation
+        if len(insurance_type_code) > 3 or not insurance_type_code.isalnum():
+            MediLink_ConfigLoader.log("Invalid insurance type format '{}' for payer {}, using PPO fallback".format(
+                insurance_type_code, payer_id), level="WARNING")
+            return '12'
+        
+        # Configuration lookup - insurance type exists in config
         if insurance_type_code in insurance_options:
             MediLink_ConfigLoader.log("Validated insurance type '{}' for payer {}".format(
                 insurance_type_code, payer_id), level="DEBUG")
             return insurance_type_code
         
         # Unknown type - log and fallback
-        MediLink_ConfigLoader.log("UNKNOWN insurance type '{}' for payer {} - using PPO fallback".format(
+        MediLink_ConfigLoader.log("Unknown insurance type '{}' for payer {} - using PPO fallback".format(
             insurance_type_code, payer_id), level="WARNING")
         
         return '12'  # Safe fallback to PPO
@@ -54,69 +73,22 @@ def validate_insurance_type_from_config(insurance_type_code, payer_id=""):
         MediLink_ConfigLoader.log("Insurance validation error: {} - using PPO fallback".format(str(e)), level="ERROR")
         return '12'
 
-# Enhanced patient data enrichment
-def enrich_patient_data_with_metadata(detailed_patient_data, insurance_source='MANUAL'):
-    """
-    Add metadata to patient data for tracking and monitoring.
-    Safe enhancement that doesn't break existing functionality.
-    """
-    enhanced_data = []
-    
-    for data in detailed_patient_data:
-        # Create enhanced copy
-        enhanced_record = data.copy()
-        
-        # Add metadata fields
-        enhanced_record['insurance_type_source'] = insurance_source
-        enhanced_record['insurance_type_validated'] = True
-        enhanced_record['insurance_type_timestamp'] = time.time()
-        enhanced_record['insurance_type_metadata'] = {}
-        
-        enhanced_data.append(enhanced_record)
-    
-    return enhanced_data
-
-# Insurance type assignment logging
-def log_insurance_type_decision(patient_id, insurance_type, source, metadata=None):
-    """Enhanced logging for insurance type assignments"""
-    log_data = {
-        'patient_id': patient_id,
-        'insurance_type': insurance_type,
-        'source': source,
-        'timestamp': time.time()
-    }
-    if metadata:
-        log_data['metadata'] = metadata
-    
-    MediLink_ConfigLoader.log("Insurance assignment: {}".format(json.dumps(log_data)), level="INFO")
-
 # Monitoring and statistics
 def generate_insurance_assignment_summary(detailed_patient_data):
-    """
-    Generate summary statistics for insurance type assignments.
-    Helps monitor system performance and data quality.
-    """
+    """Generate basic summary statistics for insurance type assignments"""
     if not detailed_patient_data:
         return {}
     
-    # Collect statistics
-    source_counts = {}
+    # Collect basic statistics
     insurance_type_counts = {}
     
     for data in detailed_patient_data:
-        source = data.get('insurance_type_source', 'UNKNOWN')
         insurance_type = data.get('insurance_type', 'UNKNOWN')
-        
-        source_counts[source] = source_counts.get(source, 0) + 1
         insurance_type_counts[insurance_type] = insurance_type_counts.get(insurance_type, 0) + 1
     
-    total_patients = len(detailed_patient_data)
-    
     summary = {
-        'total_patients': total_patients,
-        'sources': source_counts,
-        'insurance_types': insurance_type_counts,
-        'timestamp': time.time()
+        'total_patients': len(detailed_patient_data),
+        'insurance_types': insurance_type_counts
     }
     
     # Log summary
@@ -138,23 +110,22 @@ def safe_insurance_type_selection(parsed_data, fallback_function):
         
         if enhanced_mode:
             # Try enhanced selection (would be implemented here)
-            MediLink_ConfigLoader.log("Attempting enhanced insurance selection for {}".format(patient_name), level="DEBUG")
+            MediLink_ConfigLoader.log("Attempting enhanced insurance selection", level="DEBUG")
             # For now, just call fallback - actual enhancement would go here
             result = fallback_function(parsed_data)
-            log_insurance_type_decision(patient_name, result, 'ENHANCED')
+            MediLink_ConfigLoader.log("Insurance decision: type={}, method=ENHANCED".format(result), level="INFO")
             return result
         else:
             # Use standard selection
             result = fallback_function(parsed_data)
-            log_insurance_type_decision(patient_name, result, 'MANUAL')
+            MediLink_ConfigLoader.log("Insurance decision: type={}, method=MANUAL".format(result), level="INFO")
             return result
             
     except Exception as e:
         # Error handling with safe fallback
-        MediLink_ConfigLoader.log("Insurance selection error for {}: {}. Using PPO default.".format(
-            patient_name, str(e)), level="ERROR")
+        MediLink_ConfigLoader.log("Insurance selection error: {}. Using PPO default.".format(str(e)), level="ERROR")
         
-        log_insurance_type_decision(patient_name, '12', 'ERROR_FALLBACK', {'error': str(e)})
+        MediLink_ConfigLoader.log("Insurance decision: type=12, method=ERROR_FALLBACK, error={}".format(str(e)), level="INFO")
         return '12'  # Safe fallback
 
 # Configuration validation
@@ -237,12 +208,7 @@ def process_patients_with_progress(patients, processing_function, description="P
     processed_results = []
     errors = []
     
-    try:
-        from tqdm import tqdm
-        iterator = tqdm(patients, desc=description)
-    except ImportError:
-        iterator = patients
-        MediLink_ConfigLoader.log("Processing {} patients (tqdm not available)".format(len(patients)), level="INFO")
+    iterator = tqdm(patients, desc=description)
     
     for i, patient in enumerate(iterator):
         try:

medicafe-0.250728.9/MediLink/__init__.py

@@ -0,0 +1 @@
+from .MediLink import enrich_with_insurance_type

{medicafe-0.250728.8 → medicafe-0.250728.9}/MediLink/insurance_type_integration_test.py

@@ -4,27 +4,29 @@
 
 import time
 import json
+import sys, os
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
 
 try:
     from MediLink import MediLink_ConfigLoader
-    from MediLink_API_v3_enhanced import (
-        validate_production_readiness,
-        validate_insurance_configuration,
-        get_feature_flag,
-        EnhancedAPIClient
+    from MediLink_API_v3 import (
+        APIClient
     )
-    from MediLink_enhanced import (
-        enrich_with_insurance_type,
-        monitor_insurance_type_assignments
+    from MediLink import (
+        enrich_with_insurance_type
     )
-    from MediLink_837p_encoder_library_enhanced import (
+    from MediLink_837p_encoder_library import (
         insurance_type_selection,
-        insurance_type_selection_safe,
-        is_api_insurance_selection_available
+        _original_insurance_type_selection_logic
+    )
+    from MediLink_insurance_utils import (
+        validate_insurance_type_from_config,
+        get_feature_flag,
+        generate_insurance_assignment_summary
     )
 except ImportError as e:
     print("Import error: {}".format(str(e)))
-    print("This module requires the enhanced insurance type components.")
+    print("This module requires the insurance type components.")
 
 def run_insurance_type_integration_tests():
     """
@@ -46,12 +48,13 @@ def run_insurance_type_integration_tests():
     test_results['total_tests'] += 1
     try:
         print("\n1. Testing Production Readiness Validation...")
-        validate_production_readiness()
-        print("   ✅ Production readiness validation PASSED")
+        from MediLink_insurance_utils import validate_insurance_configuration
+        validate_insurance_configuration()
+        print("   PASS Production readiness validation PASSED")
         test_results['passed_tests'] += 1
         test_results['test_details'].append({'test': 'production_readiness', 'status': 'PASSED'})
     except Exception as e:
-        print("   ❌ Production readiness validation FAILED: {}".format(str(e)))
+        print("   FAIL Production readiness validation FAILED: {}".format(str(e)))
         test_results['failed_tests'] += 1
         test_results['test_details'].append({'test': 'production_readiness', 'status': 'FAILED', 'error': str(e)})
     
@@ -59,12 +62,13 @@ def run_insurance_type_integration_tests():
     test_results['total_tests'] += 1
     try:
         print("\n2. Testing Insurance Configuration Validation...")
+        from MediLink_insurance_utils import validate_insurance_configuration
         validate_insurance_configuration()
-        print("   ✅ Insurance configuration validation PASSED")
+        print("   PASS Insurance configuration validation PASSED")
         test_results['passed_tests'] += 1
         test_results['test_details'].append({'test': 'insurance_config', 'status': 'PASSED'})
     except Exception as e:
-        print("   ❌ Insurance configuration validation FAILED: {}".format(str(e)))
+        print("   FAIL Insurance configuration validation FAILED: {}".format(str(e)))
         test_results['failed_tests'] += 1
         test_results['test_details'].append({'test': 'insurance_config', 'status': 'FAILED', 'error': str(e)})
     
@@ -76,24 +80,24 @@ def run_insurance_type_integration_tests():
         enhanced_flag = get_feature_flag('enhanced_insurance_enrichment', default=False)
         print("   API Insurance Selection Flag: {}".format(api_flag))
         print("   Enhanced Insurance Enrichment Flag: {}".format(enhanced_flag))
-        print("   ✅ Feature flag system PASSED")
+        print("   PASS Feature flag system PASSED")
         test_results['passed_tests'] += 1
         test_results['test_details'].append({'test': 'feature_flags', 'status': 'PASSED'})
     except Exception as e:
-        print("   ❌ Feature flag system FAILED: {}".format(str(e)))
+        print("   FAIL Feature flag system FAILED: {}".format(str(e)))
         test_results['failed_tests'] += 1
         test_results['test_details'].append({'test': 'feature_flags', 'status': 'FAILED', 'error': str(e)})
     
-    # Test 4: Enhanced API Client Initialization
+    # Test 4: API Client Initialization
     test_results['total_tests'] += 1
     try:
-        print("\n4. Testing Enhanced API Client Initialization...")
-        api_client = EnhancedAPIClient()
-        print("   ✅ Enhanced API client initialization PASSED")
+        print("\n4. Testing API Client Initialization...")
+        api_client = APIClient()
+        print("   PASS API client initialization PASSED")
         test_results['passed_tests'] += 1
         test_results['test_details'].append({'test': 'api_client_init', 'status': 'PASSED'})
     except Exception as e:
-        print("   ❌ Enhanced API client initialization FAILED: {}".format(str(e)))
+        print("   FAIL API client initialization FAILED: {}".format(str(e)))
         test_results['failed_tests'] += 1
         test_results['test_details'].append({'test': 'api_client_init', 'status': 'FAILED', 'error': str(e)})
     
@@ -109,11 +113,11 @@ def run_insurance_type_integration_tests():
         }
         result = insurance_type_selection(test_parsed_data)
         assert result == '12', "Should return pre-assigned insurance type"
-        print("   ✅ Insurance type selection backward compatibility PASSED")
+        print("   PASS Insurance type selection backward compatibility PASSED")
         test_results['passed_tests'] += 1
         test_results['test_details'].append({'test': 'backward_compatibility', 'status': 'PASSED'})
     except Exception as e:
-        print("   ❌ Insurance type selection backward compatibility FAILED: {}".format(str(e)))
+        print("   FAIL Insurance type selection backward compatibility FAILED: {}".format(str(e)))
         test_results['failed_tests'] += 1
         test_results['test_details'].append({'test': 'backward_compatibility', 'status': 'FAILED', 'error': str(e)})
     
@@ -131,33 +135,18 @@ def run_insurance_type_integration_tests():
         enriched_data = enrich_with_insurance_type(test_patient_data)
         assert len(enriched_data) == 1, "Should return same number of patients"
         assert 'insurance_type' in enriched_data[0], "Should add insurance_type field"
-        assert 'insurance_type_source' in enriched_data[0], "Should add source tracking"
-        print("   ✅ Patient data enrichment PASSED")
+        print("   PASS Patient data enrichment PASSED")
         test_results['passed_tests'] += 1
         test_results['test_details'].append({'test': 'patient_enrichment', 'status': 'PASSED'})
     except Exception as e:
-        print("   ❌ Patient data enrichment FAILED: {}".format(str(e)))
+        print("   FAIL Patient data enrichment FAILED: {}".format(str(e)))
         test_results['failed_tests'] += 1
         test_results['test_details'].append({'test': 'patient_enrichment', 'status': 'FAILED', 'error': str(e)})
     
-    # Test 7: API Availability Check
+    # Test 7: Monitoring System
     test_results['total_tests'] += 1
     try:
-        print("\n7. Testing API Availability Check...")
-        api_available = is_api_insurance_selection_available()
-        print("   API Insurance Selection Available: {}".format(api_available))
-        print("   ✅ API availability check PASSED")
-        test_results['passed_tests'] += 1
-        test_results['test_details'].append({'test': 'api_availability', 'status': 'PASSED'})
-    except Exception as e:
-        print("   ❌ API availability check FAILED: {}".format(str(e)))
-        test_results['failed_tests'] += 1
-        test_results['test_details'].append({'test': 'api_availability', 'status': 'FAILED', 'error': str(e)})
-    
-    # Test 8: Monitoring System
-    test_results['total_tests'] += 1
-    try:
-        print("\n8. Testing Monitoring System...")
+        print("\n7. Testing Monitoring System...")
         test_patient_data = [
             {
                 'patient_id': 'TEST001',
@@ -170,12 +159,12 @@ def run_insurance_type_integration_tests():
                 'insurance_type_source': 'API'
             }
         ]
-        monitor_insurance_type_assignments(test_patient_data)
-        print("   ✅ Monitoring system PASSED")
+        generate_insurance_assignment_summary(test_patient_data)
+        print("   PASS Monitoring system PASSED")
         test_results['passed_tests'] += 1
         test_results['test_details'].append({'test': 'monitoring', 'status': 'PASSED'})
     except Exception as e:
-        print("   ❌ Monitoring system FAILED: {}".format(str(e)))
+        print("   FAIL Monitoring system FAILED: {}".format(str(e)))
         test_results['failed_tests'] += 1
         test_results['test_details'].append({'test': 'monitoring', 'status': 'FAILED', 'error': str(e)})
     
@@ -184,13 +173,13 @@ def run_insurance_type_integration_tests():
     print("TEST SUMMARY")
     print("=" * 60)
     print("Total Tests: {}".format(test_results['total_tests']))
-    print("Passed: {} ✅".format(test_results['passed_tests']))
-    print("Failed: {} ❌".format(test_results['failed_tests']))
+    print("Passed: {}".format(test_results['passed_tests']))
+    print("Failed: {}".format(test_results['failed_tests']))
     
     if test_results['failed_tests'] == 0:
-        print("\n🎉 ALL TESTS PASSED! System ready for deployment.")
+        print("\nPASS ALL TESTS! System ready for deployment.")
     else:
-        print("\n⚠️  {} TESTS FAILED. Review before deployment.".format(test_results['failed_tests']))
+        print("\nFAIL {} TESTS. Review before deployment.".format(test_results['failed_tests']))
         for test in test_results['test_details']:
             if test['status'] == 'FAILED':
                 print("   - {}: {}".format(test['test'], test.get('error', 'Unknown error')))
@@ -203,41 +192,33 @@ def test_insurance_type_validation():
     print("INSURANCE TYPE VALIDATION TESTS")
     print("=" * 50)
     
-    # Import validation function
-    from MediLink_API_v3_enhanced import validate_insurance_type_from_super_connector
-    
     test_cases = [
         {
             'name': 'Valid PPO Type',
-            'plan_description': 'Preferred Provider Organization',
             'insurance_type': '12',
             'payer_id': '87726',
             'expected': '12'
         },
         {
             'name': 'Valid HMO Type', 
-            'plan_description': 'Health Maintenance Organization',
             'insurance_type': 'HM',
             'payer_id': '87726',
             'expected': 'HM'
         },
         {
-            'name': 'Novel Valid Type',
-            'plan_description': 'Exclusive Provider Organization',
+            'name': 'Novel Valid Type (Strict Validation)',
             'insurance_type': 'EP',
             'payer_id': '87726',
-            'expected': 'EP'  # Should accept if format is valid
+            'expected': '12'  # Strict validation rejects novel codes
         },
         {
             'name': 'Invalid Type Format',
-            'plan_description': 'Some Plan',
             'insurance_type': 'INVALID123',
             'payer_id': '87726',
             'expected': '12'  # Should fallback to PPO
         },
         {
             'name': 'Empty Type',
-            'plan_description': 'Some Plan',
             'insurance_type': '',
             'payer_id': '87726',
             'expected': '12'  # Should fallback to PPO
@@ -249,21 +230,20 @@ def test_insurance_type_validation():
     
     for test_case in test_cases:
         try:
-            result = validate_insurance_type_from_super_connector(
-                test_case['plan_description'],
+            result = validate_insurance_type_from_config(
                 test_case['insurance_type'], 
                 test_case['payer_id']
             )
             
             if result == test_case['expected']:
-                print("✅ {}: {} -> {}".format(test_case['name'], test_case['insurance_type'], result))
+                print("PASS {}: {} -> {}".format(test_case['name'], test_case['insurance_type'], result))
                 passed += 1
             else:
-                print("❌ {}: Expected {}, got {}".format(test_case['name'], test_case['expected'], result))
+                print("FAIL {}: Expected {}, got {}".format(test_case['name'], test_case['expected'], result))
                 failed += 1
                 
         except Exception as e:
-            print("❌ {}: Exception - {}".format(test_case['name'], str(e)))
+            print("FAIL {}: Exception - {}".format(test_case['name'], str(e)))
             failed += 1
     
     print("\nValidation Tests Summary: {} passed, {} failed".format(passed, failed))
@@ -301,9 +281,9 @@ def create_test_configuration():
     
     print("Test configuration created:")
     print(json.dumps(test_config, indent=2))
-    print("\n📝 Copy this configuration to your config.json file")
-    print("🚨 Ensure TestMode is False for production")
-    print("🔧 Enable feature flags gradually during rollout")
+    print("\nCopy this configuration to your config.json file")
+    print("Ensure TestMode is False for production")
+    print("Enable feature flags gradually during rollout")
     
     return test_config
 
@@ -332,9 +312,9 @@ def deployment_checklist():
     for item in checklist:
         print(item)
     
-    print("\n📋 Complete all checklist items before deployment")
-    print("🚀 Follow gradual rollout plan with feature flags")
-    print("🔍 Monitor logs and metrics closely during rollout")
+    print("\nComplete all checklist items before deployment")
+    print("Follow gradual rollout plan with feature flags")
+    print("Monitor logs and metrics closely during rollout")
 
 if __name__ == "__main__":
     print("Insurance Type Selection Enhancement - Integration Test Suite")
@@ -363,6 +343,6 @@ if __name__ == "__main__":
     print("Overall Tests: {} passed, {} failed out of {} total".format(total_passed, total_failed, total_tests))
     
     if total_failed == 0:
-        print("🎉 ALL SYSTEMS GO! Ready for phased deployment.")
+        print("PASS ALL SYSTEMS GO! Ready for phased deployment.")
     else:
-        print("⚠️  Address {} failed tests before deployment.".format(total_failed))
+        print("FAIL  Address {} failed tests before deployment.".format(total_failed))

{medicafe-0.250728.8 → medicafe-0.250728.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: medicafe
-Version: 0.250728.8
+Version: 0.250728.9
 Summary: MediCafe
 Home-page: https://github.com/katanada2
 Author: Daniel Vidaud

{medicafe-0.250728.8 → medicafe-0.250728.9}/medicafe.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: medicafe
-Version: 0.250728.8
+Version: 0.250728.9
 Summary: MediCafe
 Home-page: https://github.com/katanada2
 Author: Daniel Vidaud

{medicafe-0.250728.8 → medicafe-0.250728.9}/medicafe.egg-info/SOURCES.txt

@@ -1,6 +1,5 @@
 LICENSE
 MANIFEST.in
-README.md
 setup.py
 MediBot/MediBot.bat
 MediBot/MediBot.py

{medicafe-0.250728.8 → medicafe-0.250728.9}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='medicafe',
-    version="0.250728.8",
+    version="0.250728.9",
     description='MediCafe',
     long_description="""
     # Project Overview: MediCafe

medicafe-0.250728.8/README.md

@@ -1,58 +0,0 @@
-# MediCafe
-
-MediCafe is a specialized Python package designed to automate and enhance administrative tasks in medical practices using Medisoft. It features two primary components: **MediBot** and **MediLink**, which work together to streamline patient data entry and claims submission processes. This package is particularly tailored for environments running Windows XP with Python 3.4.4.
-
-## Features
-
-### Automated Data Entry
-MediCafe utilizes **AutoHotkey scripting** to automate the entry of patient information into Medisoft. This feature significantly reduces the time and effort required for manual data entry, minimizing human error and improving operational efficiency.
-
-### Claims Submission Automation
-The MediLink component automates the submission of 837p medical claims to various insurance providers via **APIs** and also using **WinSCP** for secure file transfers. It supports dynamic configurations for multiple endpoints, allowing for seamless integration with different payer systems with easy setup and management of custom 837p headers and trailers. This automation ensures timely and accurate claims processing, enhancing revenue cycle management for healthcare providers.
-
-### Crosswalk Setup Tooling
-MediCafe includes internal tooling to assist in setting up a **crosswalk** with referential data for payer IDs, diagnostic codes, and other essential mappings. This feature simplifies the process of aligning data formats and identifiers across different systems, ensuring consistency and accuracy in data handling.
-
-## Installation
-
-MediCafe can be easily installed via pip:
-```bash
-pip install medicafe
-```
-
-### Configuration
-A custom configuration file is required for each environment and provider. This file must be set up to define paths, mappings, and other necessary parameters specific to the user's setup.
-
-## Entry Point
-The primary entry point for running MediCafe is through the **MediBot** batch file:
-```bash
-MediBot.bat
-```
-
-## Known Bugs
-- **Endpoint Persistence**: Issues with endpoint update persistence when user adjustments are made.
-- **Insurance Mode Glitches**: Certain insurance modes may not adjust data correctly, requiring manual intervention.
-- **Manual Entry Requirements**: Some processes may require manual entries to handle off-nominal conditions, as indicated by comments in the codebase.
-
-## Future Work
-Future enhancements and features can be identified through TODO comments and other annotations in the codebase. These may include:
-- Improvements to the crosswalk setup process.
-- Additional automation features for data entry and claims processing.
-- Enhancements to user interaction and error handling mechanisms.
-
-### Developer Info:
-- Name: Daniel Vidaud
-- GitHub: [\[Your GitHub Profile\]](https://github.com/katanada2)
-- Email: daniel@personalizedtransformations.com
-- LinkedIn: [\[Your LinkedIn Profile\]](https://www.linkedin.com/in/dvidaud/)
-
-### Contribution Guideline:
-Contributions are welcome! If you'd like to contribute, please follow the steps below:
-1. Fork the repository.
-2. Create your feature branch (`git checkout -b feature/AmazingFeature`).
-3. Commit your changes (`git commit -m 'Add some AmazingFeature'`).
-4. Push to the branch (`git push origin feature/AmazingFeature`).
-5. Open a pull request.
-
-### Disclaimer:
-MediCafe is developed as an open-source project. While we strive to provide a reliable and effective system, the developers are not responsible for any discrepancies or issues that may arise from its use. Always ensure data confidentiality and compliance with healthcare regulations.