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

MediLink/MediLink_insurance_utils.py

@@ -0,0 +1,265 @@
+# MediLink_insurance_utils.py
+# Insurance type enhancement utilities extracted from enhanced implementations
+# Provides safe helper functions for production integration
+# Python 3.4.4 compatible implementation
+
+import time
+import json
+
+try:
+    from MediLink import MediLink_ConfigLoader
+    from MediLink import MediLink_UI
+except ImportError:
+    import MediLink_ConfigLoader
+    import MediLink_UI
+
+# Feature flag system
+def get_feature_flag(flag_name, default=False):
+    """Centralized feature flag management"""
+    try:
+        config, _ = MediLink_ConfigLoader.load_configuration()
+        feature_flags = config.get("MediLink_Config", {}).get("feature_flags", {})
+        return feature_flags.get(flag_name, default)
+    except Exception as e:
+        MediLink_ConfigLoader.log("Error reading feature flag {}: {}".format(flag_name, str(e)), level="WARNING")
+        return default
+
+# Enhanced insurance type validation
+def validate_insurance_type_from_config(insurance_type_code, payer_id=""):
+    """
+    Validate insurance type against configuration with proper logging.
+    Returns validated type or safe fallback.
+    """
+    try:
+        config, _ = MediLink_ConfigLoader.load_configuration()
+        insurance_options = config['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")
+            return '12'  # Default to PPO
+        
+        # Direct lookup - insurance type already 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(
+            insurance_type_code, payer_id), level="WARNING")
+        
+        return '12'  # Safe fallback to PPO
+        
+    except Exception as e:
+        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.
+    """
+    if not detailed_patient_data:
+        return {}
+    
+    # Collect statistics
+    source_counts = {}
+    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()
+    }
+    
+    # Log summary
+    MediLink_ConfigLoader.log("Insurance Assignment Summary: {}".format(json.dumps(summary)), level="INFO")
+    
+    return summary
+
+# Safe wrapper for insurance type selection
+def safe_insurance_type_selection(parsed_data, fallback_function):
+    """
+    Safe wrapper that attempts enhanced selection with fallback to original function.
+    Provides comprehensive error handling and logging.
+    """
+    patient_name = parsed_data.get('LAST', 'UNKNOWN')
+    
+    try:
+        # Check if enhanced mode is enabled
+        enhanced_mode = get_feature_flag('enhanced_insurance_selection', default=False)
+        
+        if enhanced_mode:
+            # Try enhanced selection (would be implemented here)
+            MediLink_ConfigLoader.log("Attempting enhanced insurance selection for {}".format(patient_name), 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')
+            return result
+        else:
+            # Use standard selection
+            result = fallback_function(parsed_data)
+            log_insurance_type_decision(patient_name, result, 'MANUAL')
+            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")
+        
+        log_insurance_type_decision(patient_name, '12', 'ERROR_FALLBACK', {'error': str(e)})
+        return '12'  # Safe fallback
+
+# Configuration validation
+def validate_insurance_configuration():
+    """
+    Validate insurance configuration for production readiness.
+    Returns True if valid, raises exception if invalid.
+    """
+    try:
+        config, _ = MediLink_ConfigLoader.load_configuration()
+        insurance_options = config['MediLink_Config'].get('insurance_options', {})
+        
+        if not insurance_options:
+            raise ValueError("Missing insurance_options in MediLink_Config")
+        
+        # Validate insurance options format
+        for code, description in insurance_options.items():
+            if not isinstance(code, str) or len(code) < 1:
+                raise ValueError("Invalid insurance code format: {}".format(code))
+            if not isinstance(description, str):
+                raise ValueError("Invalid insurance description for code: {}".format(code))
+        
+        MediLink_ConfigLoader.log("Insurance configuration validation passed: {} options loaded".format(
+            len(insurance_options)), level="INFO")
+        return True
+        
+    except Exception as e:
+        MediLink_ConfigLoader.log("Insurance configuration validation failed: {}".format(str(e)), level="ERROR")
+        raise e
+
+# Production readiness check
+def check_production_readiness():
+    """
+    Check if system is ready for production deployment.
+    Returns list of warnings/errors that need attention.
+    """
+    issues = []
+    
+    try:
+        # Check configuration
+        validate_insurance_configuration()
+    except Exception as e:
+        issues.append("Configuration invalid: {}".format(str(e)))
+    
+    # Check for test mode flags
+    try:
+        config, _ = MediLink_ConfigLoader.load_configuration()
+        test_mode = config.get("MediLink_Config", {}).get("TestMode", False)
+        if test_mode:
+            issues.append("TestMode is enabled - should be disabled for production")
+    except Exception as e:
+        issues.append("Cannot check test mode: {}".format(str(e)))
+    
+    return issues
+
+# Enhanced error handling wrapper
+def with_insurance_error_handling(func):
+    """
+    Decorator for insurance-related functions to add consistent error handling.
+    Python 3.4.4 compatible implementation.
+    """
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            MediLink_ConfigLoader.log("Insurance function error in {}: {}".format(func.__name__, str(e)), level="ERROR")
+            # Return safe defaults based on function type
+            if 'insurance_type' in func.__name__:
+                return '12'  # Default PPO for insurance type functions
+            else:
+                raise e  # Re-raise for non-insurance type functions
+    return wrapper
+
+# Utility for batch processing with progress tracking
+def process_patients_with_progress(patients, processing_function, description="Processing patients"):
+    """
+    Process patients with progress tracking and error collection.
+    Returns processed results and error summary.
+    """
+    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")
+    
+    for i, patient in enumerate(iterator):
+        try:
+            result = processing_function(patient)
+            processed_results.append(result)
+        except Exception as e:
+            error_info = {
+                'patient_index': i,
+                'patient_id': patient.get('patient_id', 'UNKNOWN'),
+                'error': str(e)
+            }
+            errors.append(error_info)
+            MediLink_ConfigLoader.log("Error processing patient {}: {}".format(
+                patient.get('patient_id', i), str(e)), level="ERROR")
+    
+    if errors:
+        MediLink_ConfigLoader.log("Batch processing completed with {} errors out of {} patients".format(
+            len(errors), len(patients)), level="WARNING")
+    
+    return processed_results, errors

MediLink/insurance_type_integration_test.py

@@ -0,0 +1,368 @@
+# insurance_type_integration_test.py
+# Integration testing and validation for insurance type selection enhancement
+# Python 3.4.4 compatible implementation
+
+import time
+import json
+
+try:
+    from MediLink import MediLink_ConfigLoader
+    from MediLink_API_v3_enhanced import (
+        validate_production_readiness,
+        validate_insurance_configuration,
+        get_feature_flag,
+        EnhancedAPIClient
+    )
+    from MediLink_enhanced import (
+        enrich_with_insurance_type,
+        monitor_insurance_type_assignments
+    )
+    from MediLink_837p_encoder_library_enhanced import (
+        insurance_type_selection,
+        insurance_type_selection_safe,
+        is_api_insurance_selection_available
+    )
+except ImportError as e:
+    print("Import error: {}".format(str(e)))
+    print("This module requires the enhanced insurance type components.")
+
+def run_insurance_type_integration_tests():
+    """
+    Run comprehensive integration tests for insurance type selection enhancement.
+    Python 3.4.4 compatible implementation.
+    """
+    print("=" * 60)
+    print("INSURANCE TYPE SELECTION ENHANCEMENT - INTEGRATION TESTS")
+    print("=" * 60)
+    
+    test_results = {
+        'total_tests': 0,
+        'passed_tests': 0,
+        'failed_tests': 0,
+        'test_details': []
+    }
+    
+    # Test 1: Production Readiness Validation
+    test_results['total_tests'] += 1
+    try:
+        print("\n1. Testing Production Readiness Validation...")
+        validate_production_readiness()
+        print("   ✅ 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)))
+        test_results['failed_tests'] += 1
+        test_results['test_details'].append({'test': 'production_readiness', 'status': 'FAILED', 'error': str(e)})
+    
+    # Test 2: Insurance Configuration Validation
+    test_results['total_tests'] += 1
+    try:
+        print("\n2. Testing Insurance Configuration Validation...")
+        validate_insurance_configuration()
+        print("   ✅ 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)))
+        test_results['failed_tests'] += 1
+        test_results['test_details'].append({'test': 'insurance_config', 'status': 'FAILED', 'error': str(e)})
+    
+    # Test 3: Feature Flag System
+    test_results['total_tests'] += 1
+    try:
+        print("\n3. Testing Feature Flag System...")
+        api_flag = get_feature_flag('api_insurance_selection', default=False)
+        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")
+        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)))
+        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_results['total_tests'] += 1
+    try:
+        print("\n4. Testing Enhanced API Client Initialization...")
+        api_client = EnhancedAPIClient()
+        print("   ✅ Enhanced 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)))
+        test_results['failed_tests'] += 1
+        test_results['test_details'].append({'test': 'api_client_init', 'status': 'FAILED', 'error': str(e)})
+    
+    # Test 5: Insurance Type Selection Backward Compatibility
+    test_results['total_tests'] += 1
+    try:
+        print("\n5. Testing Insurance Type Selection Backward Compatibility...")
+        test_parsed_data = {
+            'LAST': 'TESTPATIENT',
+            'FIRST': 'TEST',
+            'BDAY': '1980-01-01',
+            'insurance_type': '12'  # Pre-assigned
+        }
+        result = insurance_type_selection(test_parsed_data)
+        assert result == '12', "Should return pre-assigned insurance type"
+        print("   ✅ 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)))
+        test_results['failed_tests'] += 1
+        test_results['test_details'].append({'test': 'backward_compatibility', 'status': 'FAILED', 'error': str(e)})
+    
+    # Test 6: Patient Data Enrichment
+    test_results['total_tests'] += 1
+    try:
+        print("\n6. Testing Patient Data Enrichment...")
+        test_patient_data = [
+            {
+                'patient_id': 'TEST001',
+                'patient_name': 'Test Patient',
+                'primary_insurance_id': '87726'
+            }
+        ]
+        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")
+        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)))
+        test_results['failed_tests'] += 1
+        test_results['test_details'].append({'test': 'patient_enrichment', 'status': 'FAILED', 'error': str(e)})
+    
+    # Test 7: API Availability Check
+    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...")
+        test_patient_data = [
+            {
+                'patient_id': 'TEST001',
+                'insurance_type': '12',
+                'insurance_type_source': 'DEFAULT'
+            },
+            {
+                'patient_id': 'TEST002', 
+                'insurance_type': 'HM',
+                'insurance_type_source': 'API'
+            }
+        ]
+        monitor_insurance_type_assignments(test_patient_data)
+        print("   ✅ 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)))
+        test_results['failed_tests'] += 1
+        test_results['test_details'].append({'test': 'monitoring', 'status': 'FAILED', 'error': str(e)})
+    
+    # Print Test Summary
+    print("\n" + "=" * 60)
+    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']))
+    
+    if test_results['failed_tests'] == 0:
+        print("\n🎉 ALL TESTS PASSED! System ready for deployment.")
+    else:
+        print("\n⚠️  {} TESTS FAILED. 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')))
+    
+    return test_results
+
+def test_insurance_type_validation():
+    """Test insurance type validation with various scenarios"""
+    print("\n" + "=" * 50)
+    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',
+            'insurance_type': 'EP',
+            'payer_id': '87726',
+            'expected': 'EP'  # Should accept if format is valid
+        },
+        {
+            '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
+        }
+    ]
+    
+    passed = 0
+    failed = 0
+    
+    for test_case in test_cases:
+        try:
+            result = validate_insurance_type_from_super_connector(
+                test_case['plan_description'],
+                test_case['insurance_type'], 
+                test_case['payer_id']
+            )
+            
+            if result == test_case['expected']:
+                print("✅ {}: {} -> {}".format(test_case['name'], test_case['insurance_type'], result))
+                passed += 1
+            else:
+                print("❌ {}: Expected {}, got {}".format(test_case['name'], test_case['expected'], result))
+                failed += 1
+                
+        except Exception as e:
+            print("❌ {}: Exception - {}".format(test_case['name'], str(e)))
+            failed += 1
+    
+    print("\nValidation Tests Summary: {} passed, {} failed".format(passed, failed))
+    return passed, failed
+
+def create_test_configuration():
+    """Create test configuration for development and testing"""
+    print("\n" + "=" * 50)
+    print("CREATING TEST CONFIGURATION")
+    print("=" * 50)
+    
+    test_config = {
+        "MediLink_Config": {
+            "feature_flags": {
+                "api_insurance_selection": False,  # Start disabled
+                "enhanced_insurance_enrichment": False,  # Start disabled
+                "enhanced_insurance_selection": False  # Start disabled
+            },
+            "insurance_options": {
+                "12": "Preferred Provider Organization (PPO)",
+                "13": "Point of Service (POS)", 
+                "14": "Exclusive Provider Organization (EPO)",
+                "16": "Indemnity",
+                "HM": "Health Maintenance Organization (HMO)",
+                "BL": "Blue Cross/Blue Shield",
+                "CI": "Commercial Insurance",
+                "MA": "Medicare Advantage",
+                "MB": "Medicare Part B",
+                "MC": "Medicare Part C"
+            },
+            "default_insurance_type": "12",
+            "TestMode": False  # Must be False for production
+        }
+    }
+    
+    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")
+    
+    return test_config
+
+def deployment_checklist():
+    """Print deployment checklist for insurance type enhancement"""
+    print("\n" + "=" * 60)
+    print("DEPLOYMENT CHECKLIST")
+    print("=" * 60)
+    
+    checklist = [
+        "[ ] All integration tests pass",
+        "[ ] Production readiness validation passes",
+        "[ ] Insurance configuration validation passes", 
+        "[ ] TestMode is disabled in configuration",
+        "[ ] Feature flags are properly configured (default: disabled)",
+        "[ ] Enhanced API client initializes successfully",
+        "[ ] Backward compatibility verified with existing callers",
+        "[ ] Monitoring system is functional",
+        "[ ] Circuit breaker, caching, and rate limiting are active",
+        "[ ] Fallback mechanisms tested and working",
+        "[ ] Log rotation configured for increased logging volume",
+        "[ ] Documentation updated with new features",
+        "[ ] Team trained on new monitoring and feature flags"
+    ]
+    
+    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")
+
+if __name__ == "__main__":
+    print("Insurance Type Selection Enhancement - Integration Test Suite")
+    print("Python 3.4.4 Compatible Implementation")
+    
+    # Run all tests
+    test_results = run_insurance_type_integration_tests()
+    
+    # Run validation tests
+    validation_passed, validation_failed = test_insurance_type_validation()
+    
+    # Create test configuration
+    test_config = create_test_configuration()
+    
+    # Display deployment checklist
+    deployment_checklist()
+    
+    # Final summary
+    print("\n" + "=" * 60)
+    print("FINAL SUMMARY")
+    print("=" * 60)
+    total_passed = test_results['passed_tests'] + validation_passed
+    total_failed = test_results['failed_tests'] + validation_failed
+    total_tests = test_results['total_tests'] + validation_passed + validation_failed
+    
+    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.")
+    else:
+        print("⚠️  Address {} failed tests before deployment.".format(total_failed))

{medicafe-0.250728.6.dist-info → medicafe-0.250728.8.dist-info}/METADATA

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