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

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'),

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
 

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

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])
     )
 

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:

MediLink/__init__.py

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

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.dist-info → medicafe-0.250728.9.dist-info}/METADATA

@@ -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.dist-info → medicafe-0.250728.9.dist-info}/RECORD

@@ -13,11 +13,11 @@ MediBot/PDF_to_CSV_Cleaner.py,sha256=ZZphmq-5K04DkrZNlcwNAIoZPOD_ROWvS3PMkKFxeiM
 MediBot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 MediBot/update_json.py,sha256=9FJZb-32EujpKuSoCjyCbdTdthOIuhcMoN4Wchuzn8A,2508
 MediBot/update_medicafe.py,sha256=E09jPw_aBjO30YqqUqDOL1zxN1srCyraFDX6vPexGLo,12725
-MediLink/MediLink.py,sha256=KOZH3dMQPCf5cs61_cIWBm8veuBU3bO4BYB328A5EdY,30449
+MediLink/MediLink.py,sha256=p91MYghOCbNf3ikTzm5P9V1Luj035yd83EDbQ-Ov6oM,33258
 MediLink/MediLink_277_decoder.py,sha256=Z3hQK2j-YzdXjov6aDlDRc7M_auFBnl3se4OF5q6_04,4358
 MediLink/MediLink_837p_cob_library.py,sha256=pWWd03yXTamNJKDbPCdOCkfglW4OLXQtIN3eiMSdfAA,29934
 MediLink/MediLink_837p_encoder.py,sha256=2YcbIi3G3AETLDITWJIcMh2kBM62IgwR0W_lCVVLO0w,28816
-MediLink/MediLink_837p_encoder_library.py,sha256=v3fhGoM89gzweFi78rdrv0Gx2_WoJk38BF9-PNIm7Y0,56563
+MediLink/MediLink_837p_encoder_library.py,sha256=GR-3ltBz9f1E9rjMGu_rpmqSzsi-ioD-NT3DHLcwRcw,57560
 MediLink/MediLink_837p_utilities.py,sha256=Bi91S1aJbsEOpWXp_IOUgCQ76IPiOJNkOfXXtcirzmI,10416
 MediLink/MediLink_API_Generator.py,sha256=vBZ8moR9tvv7mb200HlZnJrk1y-bQi8E16I2r41vgVM,10345
 MediLink/MediLink_API_v2.py,sha256=mcIgLnXPS_NaUBrkKJ8mxCUaQ0AuQUeU1vG6DoplbVY,7733
@@ -26,7 +26,7 @@ MediLink/MediLink_APIs.py,sha256=jm3f9T034MJKH8A_CIootULoeuk7H8s7PazpFZRCbKI,622
 MediLink/MediLink_Azure.py,sha256=Ow70jctiHFIylskBExN7WUoRgrKOvBR6jNTnQMk6lJA,210
 MediLink/MediLink_ClaimStatus.py,sha256=kXIDidxSGuqTwjFNMQIKms42jqIu5Qmnet-7Ohe8zjE,11645
 MediLink/MediLink_ConfigLoader.py,sha256=u9ecB0SIN7zuJAo8KcoQys95BtyAo-8S2n4mRd0S3XU,4356
-MediLink/MediLink_DataMgmt.py,sha256=AVkiQ3kMmOZHaZ3Q-I2QyCZdfcU-45mIapSoZ2rdW5M,33374
+MediLink/MediLink_DataMgmt.py,sha256=Wly53vnZo-kIxO0o3e45guj0cMIWDqVmLl6-fWQtVqI,34084
 MediLink/MediLink_Decoder.py,sha256=lKWiOcRClz8F5P3jrvFTq_hW9XF4OrPfA4LFz2zLSLg,14013
 MediLink/MediLink_Deductible.py,sha256=els8CQMK3pRzlqzs12HDgqx42WLXuHFU-nfXiA4y0Js,39426
 MediLink/MediLink_Deductible_Validator.py,sha256=2g-lZd-Y5fJ1mfP87vM6oABg0t5Om-7EkEkilVvDWYY,22888
@@ -39,21 +39,21 @@ MediLink/MediLink_Parser.py,sha256=w2ZD4minjwkaMz7nzP_r8v_Ow_uM5KHjpPSY8mIHcdE,9
 MediLink/MediLink_Scan.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 MediLink/MediLink_Scheduler.py,sha256=UJvxhDvHraqra2_TlQVlGeh5jRFrrfK6nCVUHnKOEMY,38
 MediLink/MediLink_StatusCheck.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-MediLink/MediLink_UI.py,sha256=I9nIZsHJhIVRUPqj0xHoorgEbZUIWO7fn-l7yg2HU1g,7862
+MediLink/MediLink_UI.py,sha256=cDWKaXCqQgBUMSkPfQqs5ZFHSm7T3SUycXlrVqVOWzY,8327
 MediLink/MediLink_Up.py,sha256=r_VvTGsMzJUy_y-51kMYDBvVdxiq4lYm20PPIU31lCY,24119
 MediLink/MediLink_api_utils.py,sha256=dsGLRPRvSwfXPLrrfgnkIKGDIF00wE93TrDB6HMDPQU,11857
 MediLink/MediLink_batch.bat,sha256=nqL5QwCLyRQFSPdv6kgtcV_cpky7FXSOWVl6OxjRXb4,118
-MediLink/MediLink_insurance_utils.py,sha256=vzNkaOTA8tF-UwjDWxcKAQt8yOFNeC-JwFFuzM1BoGg,10544
+MediLink/MediLink_insurance_utils.py,sha256=igZ9m5PUE8hNLvfC1R2JlJzXJg0V_-aUHDH3FZ4kOnY,9463
 MediLink/Soumit_api.py,sha256=5JfOecK98ZC6NpZklZW2AkOzkjvrbYxpJpZNH3rFxDw,497
-MediLink/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-MediLink/insurance_type_integration_test.py,sha256=5Ick4fEGzCnDxOm7C4eD_BtLutPX_reTVDLsgss5B1o,15446
+MediLink/__init__.py,sha256=RzjaFqYmxaCsZxj7-6XosL6P5tj2VIcQZ7ZxZ-n1HEk,50
+MediLink/insurance_type_integration_test.py,sha256=CiaMejWOjKwQ-FdhYIenCNwtjKSENkTJGUU5XjdrfGs,14273
 MediLink/openssl.cnf,sha256=76VdcGCykf0Typyiv8Wd1mMVKixrQ5RraG6HnfKFqTo,887
 MediLink/test.py,sha256=kSvvJRL_3fWuNS3_x4hToOnUljGLoeEw6SUTHQWQRJk,3108
 MediLink/test_cob_library.py,sha256=wUMv0-Y6fNsKcAs8Z9LwfmEBRO7oBzBAfWmmzwoNd1g,13841
 MediLink/test_validation.py,sha256=FJrfdUFK--xRScIzrHCg1JeGdm0uJEoRnq6CgkP2lwM,4154
 MediLink/webapp.html,sha256=JPKT559aFVBi1r42Hz7C77Jj0teZZRumPhBev8eSOLk,19806
-medicafe-0.250728.8.dist-info/LICENSE,sha256=65lb-vVujdQK7uMH3RRJSMwUW-WMrMEsc5sOaUn2xUk,1096
-medicafe-0.250728.8.dist-info/METADATA,sha256=-Je5odeb8Ascd4Pb_eCkZLD4HmjN4hBt5ve9x4IYsTA,5501
-medicafe-0.250728.8.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-medicafe-0.250728.8.dist-info/top_level.txt,sha256=3uOwR4q_SP8Gufk2uCHoKngAgbtdOwQC6Qjl7ViBa_c,17
-medicafe-0.250728.8.dist-info/RECORD,,
+medicafe-0.250728.9.dist-info/LICENSE,sha256=65lb-vVujdQK7uMH3RRJSMwUW-WMrMEsc5sOaUn2xUk,1096
+medicafe-0.250728.9.dist-info/METADATA,sha256=o_lCO6JP1efgXD2f3R6avtqIl4LkDwRPYjL1Gtu1_p8,5501
+medicafe-0.250728.9.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+medicafe-0.250728.9.dist-info/top_level.txt,sha256=3uOwR4q_SP8Gufk2uCHoKngAgbtdOwQC6Qjl7ViBa_c,17
+medicafe-0.250728.9.dist-info/RECORD,,