medicafe 0.250822.2__py3-none-any.whl → 0.250909.0__py3-none-any.whl

MediLink/test_cob_library.py

@@ -1,436 +0,0 @@
-# test_cob_library.py
-"""
-Test file for MediLink_837p_cob_library.py
-
-This file demonstrates the COB library functionality and provides test cases
-for various COB scenarios including Medicare secondary claims and 835 integration.
-"""
-
-import sys
-import os
-from datetime import datetime
-
-# Add parent directory to path
-project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
-if project_dir not in sys.path:
-    sys.path.append(project_dir)
-
-# Safe import to avoid circular dependencies
-try:
-    from MediLink import MediLink_837p_cob_library
-    from MediLink import MediLink_ConfigLoader
-except ImportError as e:
-    print("Warning: Could not import COB library: {}".format(e))
-    print("This may be due to circular import issues. Testing with mock data.")
-    # Create mock functions for testing
-    class MockCOBLibrary:
-        def process_cob_claim(self, *args, **kwargs):
-            return ["SBR*S*18*******MB~", "AMT*D*150.00~"]
-        
-        def extract_835_adjudication_data(self, *args, **kwargs):
-            return {'total_paid': '150.00', 'cas_adjustments': []}
-        
-        def validate_cob_configuration(self, *args, **kwargs):
-            return (True, [])
-        
-        def validate_cob_claim_integrity(self, *args, **kwargs):
-            return (True, [])
-        
-        def determine_medicare_payer_type(self, *args, **kwargs):
-            return "MB"
-    
-    MediLink_837p_cob_library = MockCOBLibrary()
-    MediLink_ConfigLoader = type('MockConfigLoader', (), {
-        'log': lambda msg, config=None, level="INFO": print("LOG [{}]: {}".format(level, msg))
-    })()
-
-def test_medicare_secondary_claim():
-    """Test Medicare secondary claim processing"""
-    print("Testing Medicare secondary claim processing...")
-    
-    # Sample patient data for Medicare secondary claim
-    patient_data = {
-        'claim_type': 'secondary',
-        'payer_id': '00850',
-        'medicare_advantage': False,
-        'primary_paid_amount': '150.00',
-        'cas_adjustments': [
-            {'group': 'CO', 'reason': '45', 'amount': '25.00'},
-            {'group': 'PR', 'reason': '1', 'amount': '10.00'}
-        ],
-        'prior_payer_name': 'MEDICARE',
-        'prior_payer_id': '00850',
-        'patient_is_subscriber': True,
-        'requires_attachment': False,
-        'CHART': 'TEST123',
-        'AMOUNT': '200.00',
-        'TOS': '1',
-        'claim_frequency': '1'
-    }
-    
-    # Mock configuration
-    config = {
-        'MediLink_Config': {
-            'cob_settings': {
-                'medicare_payer_ids': ['00850'],
-                'cob_mode': 'single_payer_only',
-                'validation_level': 3
-            },
-            'insurance_options': {
-                'MB': 'Medicare Part B',
-                'MA': 'Medicare Advantage'
-            }
-        }
-    }
-    
-    crosswalk = {}
-    client = None
-    
-    try:
-        # Test COB claim processing
-        cob_segments = MediLink_837p_cob_library.process_cob_claim(
-            patient_data, config, crosswalk, client
-        )
-        
-        print("✓ COB segments generated successfully")
-        print("Generated {} segments".format(len(cob_segments)))
-        
-        # Validate segments
-        for segment in cob_segments:
-            print("  - {}".format(segment))
-        
-        return True
-        
-    except Exception as e:
-        print("✗ Error processing COB claim: {}".format(e))
-        return False
-
-def test_medicare_advantage_claim():
-    """Test Medicare Advantage claim processing"""
-    print("\nTesting Medicare Advantage claim processing...")
-    
-    patient_data = {
-        'claim_type': 'secondary',
-        'payer_id': '00850',
-        'medicare_advantage': True,
-        'primary_paid_amount': '200.00',
-        'cas_adjustments': [
-            {'group': 'CO', 'reason': '45', 'amount': '30.00'}
-        ],
-        'prior_payer_name': 'MEDICARE ADVANTAGE',
-        'prior_payer_id': '00850',
-        'patient_is_subscriber': True,
-        'requires_attachment': False,
-        'CHART': 'TEST456',
-        'AMOUNT': '250.00',
-        'TOS': '1',
-        'claim_frequency': '1'
-    }
-    
-    config = {
-        'MediLink_Config': {
-            'cob_settings': {
-                'medicare_payer_ids': ['00850'],
-                'cob_mode': 'single_payer_only',
-                'validation_level': 3
-            }
-        }
-    }
-    
-    crosswalk = {}
-    client = None
-    
-    try:
-        cob_segments = MediLink_837p_cob_library.process_cob_claim(
-            patient_data, config, crosswalk, client
-        )
-        
-        print("✓ Medicare Advantage COB segments generated successfully")
-        print("Generated {} segments".format(len(cob_segments)))
-        
-        return True
-        
-    except Exception as e:
-        print("✗ Error processing Medicare Advantage claim: {}".format(e))
-        return False
-
-def test_service_level_adjudication():
-    """Test service-level adjudication with 835 data"""
-    print("\nTesting service-level adjudication...")
-    
-    patient_data = {
-        'claim_type': 'secondary',
-        'payer_id': '00850',
-        'medicare_advantage': False,
-        'primary_paid_amount': '300.00',
-        'service_adjudications': [
-            {
-                'payer_id': '00850',
-                'paid_amount': '150.00',
-                'revenue_code': '0001',
-                'units': '1',
-                'adjudication_date': '01-15-2024',
-                'adjustments': [
-                    {'group': 'CO', 'reason': '45', 'amount': '25.00'}
-                ]
-            },
-            {
-                'payer_id': '00850',
-                'paid_amount': '150.00',
-                'revenue_code': '0002',
-                'units': '1',
-                'adjudication_date': '01-15-2024',
-                'adjustments': []
-            }
-        ],
-        'prior_payer_name': 'MEDICARE',
-        'prior_payer_id': '00850',
-        'patient_is_subscriber': True,
-        'requires_attachment': False,
-        'CHART': 'TEST789',
-        'AMOUNT': '400.00',
-        'TOS': '1',
-        'claim_frequency': '1'
-    }
-    
-    config = {
-        'MediLink_Config': {
-            'cob_settings': {
-                'medicare_payer_ids': ['00850'],
-                'cob_mode': 'single_payer_only',
-                'validation_level': 3
-            }
-        }
-    }
-    
-    crosswalk = {}
-    client = None
-    
-    try:
-        cob_segments = MediLink_837p_cob_library.process_cob_claim(
-            patient_data, config, crosswalk, client
-        )
-        
-        print("✓ Service-level adjudication segments generated successfully")
-        print("Generated {} segments".format(len(cob_segments)))
-        
-        return True
-        
-    except Exception as e:
-        print("✗ Error processing service-level adjudication: {}".format(e))
-        return False
-
-def test_835_integration():
-    """Test 835 data integration"""
-    print("\nTesting 835 data integration...")
-    
-    patient_data = {
-        'claim_type': 'secondary',
-        'payer_id': '00850',
-        'medicare_advantage': False,
-        'clp02_amount': '250.00',
-        'cas_segments': [
-            {'group': 'CO', 'reason': '45', 'amount': '25.00'},
-            {'group': 'PR', 'reason': '1', 'amount': '15.00'}
-        ],
-        'svc_segments': [
-            {
-                'payer_id': '00850',
-                'paid_amount': '125.00',
-                'revenue_code': '0001',
-                'units': '1',
-                'adjudication_date': '01-15-2024',
-                'adjustments': []
-            },
-            {
-                'payer_id': '00850',
-                'paid_amount': '125.00',
-                'revenue_code': '0002',
-                'units': '1',
-                'adjudication_date': '01-15-2024',
-                'adjustments': []
-            }
-        ],
-        'prior_payer_name': 'MEDICARE',
-        'prior_payer_id': '00850',
-        'patient_is_subscriber': True,
-        'requires_attachment': False,
-        'CHART': 'TEST835',
-        'AMOUNT': '300.00',
-        'TOS': '1',
-        'claim_frequency': '1'
-    }
-    
-    config = {
-        'MediLink_Config': {
-            'cob_settings': {
-                'medicare_payer_ids': ['00850'],
-                'cob_mode': 'single_payer_only',
-                'validation_level': 3
-            }
-        }
-    }
-    
-    crosswalk = {}
-    client = None
-    
-    try:
-        # Test 835 data extraction
-        adjudication_data = MediLink_837p_cob_library.extract_835_adjudication_data(
-            patient_data, config
-        )
-        
-        if adjudication_data:
-            print("✓ 835 data extraction successful")
-            print("Total paid: {}".format(adjudication_data.get('total_paid')))
-            print("CAS adjustments: {}".format(len(adjudication_data.get('cas_adjustments', []))))
-            print("Service adjudications: {}".format(len(adjudication_data.get('service_paid_amounts', []))))
-        else:
-            print("✗ 835 data extraction failed")
-            return False
-        
-        # Test COB processing with 835 data
-        cob_segments = MediLink_837p_cob_library.process_cob_claim(
-            patient_data, config, crosswalk, client
-        )
-        
-        print("✓ 835-integrated COB segments generated successfully")
-        print("Generated {} segments".format(len(cob_segments)))
-        
-        return True
-        
-    except Exception as e:
-        print("✗ Error processing 835 integration: {}".format(e))
-        return False
-
-def test_validation():
-    """Test COB validation functionality"""
-    print("\nTesting COB validation...")
-    
-    # Test configuration validation
-    config = {
-        'MediLink_Config': {
-            'cob_settings': {
-                'medicare_payer_ids': ['00850'],
-                'cob_mode': 'single_payer_only',
-                'validation_level': 3
-            }
-        }
-    }
-    
-    is_valid, errors = MediLink_837p_cob_library.validate_cob_configuration(config)
-    
-    if is_valid:
-        print("✓ COB configuration validation passed")
-    else:
-        print("✗ COB configuration validation failed: {}".format(errors))
-        return False
-    
-    # Test claim integrity validation
-    patient_data = {
-        'claim_type': 'secondary',
-        'payer_id': '00850',
-        'medicare_advantage': False,
-        'primary_paid_amount': '200.00',
-        'service_adjudications': [
-            {'paid_amount': '100.00'},
-            {'paid_amount': '100.00'}
-        ],
-        'prior_payer_name': 'MEDICARE',
-        'prior_payer_id': '00850',
-        'claim_frequency': '1'
-    }
-    
-    is_valid, errors = MediLink_837p_cob_library.validate_cob_claim_integrity(
-        patient_data, config
-    )
-    
-    if is_valid:
-        print("✓ COB claim integrity validation passed")
-    else:
-        print("✗ COB claim integrity validation failed: {}".format(errors))
-        return False
-    
-    return True
-
-def test_medicare_payer_type_determination():
-    """Test Medicare payer type determination"""
-    print("\nTesting Medicare payer type determination...")
-    
-    config = {
-        'MediLink_Config': {
-            'cob_settings': {
-                'medicare_payer_ids': ['00850']
-            }
-        }
-    }
-    
-    # Test Medicare Part B
-    patient_data = {
-        'payer_id': '00850',
-        'medicare_advantage': False
-    }
-    
-    payer_type = MediLink_837p_cob_library.determine_medicare_payer_type(patient_data, config)
-    if payer_type == 'MB':
-        print("✓ Medicare Part B determination correct")
-    else:
-        print("✗ Medicare Part B determination failed: got {}".format(payer_type))
-        return False
-    
-    # Test Medicare Advantage
-    patient_data['medicare_advantage'] = True
-    payer_type = MediLink_837p_cob_library.determine_medicare_payer_type(patient_data, config)
-    if payer_type == 'MA':
-        print("✓ Medicare Advantage determination correct")
-    else:
-        print("✗ Medicare Advantage determination failed: got {}".format(payer_type))
-        return False
-    
-    # Test non-Medicare
-    patient_data['payer_id'] = '12345'
-    payer_type = MediLink_837p_cob_library.determine_medicare_payer_type(patient_data, config)
-    if payer_type is None:
-        print("✓ Non-Medicare determination correct")
-    else:
-        print("✗ Non-Medicare determination failed: got {}".format(payer_type))
-        return False
-    
-    return True
-
-def main():
-    """Run all COB library tests"""
-    print("MediLink COB Library Test Suite")
-    print("=" * 40)
-    
-    tests = [
-        test_medicare_secondary_claim,
-        test_medicare_advantage_claim,
-        test_service_level_adjudication,
-        test_835_integration,
-        test_validation,
-        test_medicare_payer_type_determination
-    ]
-    
-    passed = 0
-    total = len(tests)
-    
-    for test in tests:
-        try:
-            if test():
-                passed += 1
-        except Exception as e:
-            print("✗ Test {} failed with exception: {}".format(test.__name__, e))
-    
-    print("\n" + "=" * 40)
-    print("Test Results: {}/{} tests passed".format(passed, total))
-    
-    if passed == total:
-        print("✓ All tests passed!")
-        return True
-    else:
-        print("✗ Some tests failed")
-        return False
-
-if __name__ == "__main__":
-    main() 

MediLink/test_timing.py

@@ -1,59 +0,0 @@
-#!/usr/bin/env python
-# test_timing.py - Test script to run MediLink with timing traces
-
-import sys
-import os
-import time
-
-# Add the parent directory to the path so we can import MediLink modules
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
-
-def test_medilink_timing():
-    """
-    Test function to run MediLink with timing traces and identify bottlenecks.
-    """
-    print("=" * 60)
-    print("MEDILINK TIMING ANALYSIS")
-    print("=" * 60)
-    print("This test will run MediLink with comprehensive timing traces")
-    print("to identify what's causing the slow startup.")
-    print("=" * 60)
-
-    try:
-        # Import and run the main menu
-        from MediLink.MediLink_main import main_menu
-
-        print("\nStarting MediLink timing test...")
-        start_time = time.time()
-
-        # Load configuration to test the caching
-        from MediCafe.MediLink_ConfigLoader import load_configuration
-        config, crosswalk = load_configuration()
-        print("Initial configuration load completed")
-        
-        # Test the caching by loading again
-        config2, crosswalk2 = load_configuration()
-        print("Cached configuration load completed")
-        
-        # Test file detection with cached config
-        from MediLink.MediLink_DataMgmt import detect_new_files
-        directory_path = config['MediLink_Config']['inputFilePath']
-        files, flagged = detect_new_files(directory_path)
-        print("File detection with cached config completed")
-
-        end_time = time.time()
-        print("\n" + "=" * 60)
-        print("TIMING TEST COMPLETED")
-        print("=" * 60)
-        print("Total execution time: {:.2f} seconds".format(end_time - start_time))
-        print("Configuration caching is working!")
-
-    except KeyboardInterrupt:
-        print("\nTest interrupted by user.")
-    except Exception as e:
-        print("\nError during timing test: {}".format(e))
-        import traceback
-        traceback.print_exc()
-
-if __name__ == "__main__":
-    test_medilink_timing() 

MediLink/test_validation.py

@@ -1,127 +0,0 @@
-"""
-Test script to demonstrate the validation system
-"""
-
-import os
-import sys
-import json
-
-# Add the current directory to the path
-sys.path.append(os.path.dirname(__file__))
-
-try:
-    from MediLink_Deductible_Validator import run_validation_comparison
-except ImportError:
-    print("Could not import MediLink_Deductible_Validator")
-    sys.exit(1)
-
-def create_sample_responses():
-    """Create sample legacy and Super Connector responses for testing"""
-    
-    # Sample legacy API response
-    legacy_response = {
-        "memberPolicies": [
-            {
-                "policyInfo": {
-                    "coverageType": "Medical",
-                    "policyStatus": "Active"
-                },
-                "patientInfo": [
-                    {
-                        "lastName": "Smith",
-                        "firstName": "John",
-                        "middleName": "A"
-                    }
-                ],
-                "insuranceInfo": {
-                    "insuranceType": "PPO",
-                    "insuranceTypeCode": "PPO",
-                    "memberId": "123456789",
-                    "payerId": "87726"
-                },
-                "deductibleInfo": {
-                    "individual": {
-                        "inNetwork": {
-                            "remainingAmount": "500.00"
-                        }
-                    }
-                }
-            }
-        ]
-    }
-    
-    # Sample Super Connector API response (with some values in different locations)
-    super_connector_response = {
-        "lastName": "Smith",
-        "firstName": "John", 
-        "middleName": "A",
-        "policyStatus": "Active",
-        "planTypeDescription": "PPO",
-        "productServiceCode": "PPO",
-        "subscriberId": "123456789",
-        "payerId": "87726",
-        "metYearToDateAmount": "500.00",
-        "rawGraphQLResponse": {
-            "data": {
-                "checkEligibility": {
-                    "eligibility": [
-                        {
-                            "serviceLevels": [
-                                {
-                                    "individual": [
-                                        {
-                                            "services": [
-                                                {
-                                                    "service": "deductible",
-                                                    "remainingAmount": "500.00"
-                                                }
-                                            ]
-                                        }
-                                    ]
-                                }
-                            ]
-                        }
-                    ]
-                }
-            }
-        }
-    }
-    
-    return legacy_response, super_connector_response
-
-def main():
-    """Test the validation system"""
-    print("Testing MediLink Deductible Validation System")
-    print("=" * 50)
-    
-    # Create sample responses
-    legacy_response, super_connector_response = create_sample_responses()
-    
-    # Create output file path
-    output_file_path = os.path.join(os.getenv('TEMP', '.'), 'test_validation_report.txt')
-    
-    # Run validation
-    print("Running validation comparison...")
-    validation_report = run_validation_comparison(
-        legacy_response, 
-        super_connector_response, 
-        output_file_path
-    )
-    
-    print("Validation completed!")
-    print("Report saved to: {}".format(output_file_path))
-    
-    # Print summary
-    print("\nSummary:")
-    print("Total legacy values: {}".format(len(validation_report['legacy_values'])))
-    print("Found in Super Connector: {}".format(len(validation_report['found_values'])))
-    print("Missing from Super Connector: {}".format(len(validation_report['missing_values'])))
-    
-    # Open the report
-    try:
-        os.system('notepad.exe "{}"'.format(output_file_path))
-    except:
-        print("Could not open report in Notepad")
-
-if __name__ == "__main__":
-    main()