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

MediLink/MediLink_api_utils.py

@@ -0,0 +1,305 @@
+# MediLink_api_utils.py
+# Enhanced API utilities for circuit breaker, caching, and rate limiting
+# Extracted from enhanced implementations for safe production integration
+# Python 3.4.4 compatible implementation
+
+import time
+
+try:
+    from MediLink import MediLink_ConfigLoader
+except ImportError:
+    import MediLink_ConfigLoader
+
+# Circuit breaker pattern for API resilience
+class APICircuitBreaker:
+    """Circuit breaker pattern for API resilience"""
+    def __init__(self, failure_threshold=5, timeout=300):
+        self.failure_count = 0
+        self.failure_threshold = failure_threshold
+        self.timeout = timeout
+        self.last_failure_time = None
+        self.state = 'CLOSED'  # CLOSED, OPEN, HALF_OPEN
+    
+    def can_execute(self):
+        """Check if circuit breaker allows execution"""
+        if self.state == 'OPEN':
+            if time.time() - self.last_failure_time > self.timeout:
+                self.state = 'HALF_OPEN'
+                MediLink_ConfigLoader.log("Circuit breaker moving to HALF_OPEN state", level="INFO")
+                return True
+            else:
+                return False
+        return True
+    
+    def record_success(self):
+        """Record successful API call"""
+        if self.state == 'HALF_OPEN':
+            self.state = 'CLOSED'
+            self.failure_count = 0
+            MediLink_ConfigLoader.log("Circuit breaker reset to CLOSED state", level="INFO")
+    
+    def record_failure(self):
+        """Record failed API call"""
+        self.failure_count += 1
+        self.last_failure_time = time.time()
+        if self.failure_count >= self.failure_threshold:
+            self.state = 'OPEN'
+            MediLink_ConfigLoader.log("Circuit breaker OPENED due to {} failures".format(self.failure_count), level="ERROR")
+    
+    def call_with_breaker(self, api_function, *args, **kwargs):
+        """Call API function with circuit breaker protection"""
+        if not self.can_execute():
+            raise Exception("API circuit breaker is OPEN - too many failures")
+        
+        try:
+            result = api_function(*args, **kwargs)
+            self.record_success()
+            return result
+        except Exception as e:
+            self.record_failure()
+            raise e
+
+# Cache for API responses to reduce redundant calls
+class APICache:
+    """Simple time-based cache for API responses"""
+    def __init__(self, cache_duration=3600):  # 1 hour cache
+        self.cache = {}
+        self.cache_duration = cache_duration
+    
+    def _generate_cache_key(self, *args, **kwargs):
+        """Generate cache key from function arguments"""
+        key_parts = []
+        for arg in args:
+            key_parts.append(str(arg))
+        for k, v in sorted(kwargs.items()):
+            key_parts.append("{}:{}".format(k, v))
+        return "|".join(key_parts)
+    
+    def get(self, *args, **kwargs):
+        """Get cached result if available and not expired"""
+        cache_key = self._generate_cache_key(*args, **kwargs)
+        if cache_key in self.cache:
+            cached_data = self.cache[cache_key]
+            if time.time() - cached_data['timestamp'] < self.cache_duration:
+                MediLink_ConfigLoader.log("Cache hit for key: {}".format(cache_key[:50]), level="DEBUG")
+                return cached_data['result']
+        return None
+    
+    def set(self, result, *args, **kwargs):
+        """Cache result"""
+        cache_key = self._generate_cache_key(*args, **kwargs)
+        self.cache[cache_key] = {
+            'result': result,
+            'timestamp': time.time()
+        }
+        MediLink_ConfigLoader.log("Cached result for key: {}".format(cache_key[:50]), level="DEBUG")
+    
+    def clear_expired(self):
+        """Remove expired cache entries"""
+        now = time.time()
+        expired_keys = []
+        for key, data in self.cache.items():
+            if now - data['timestamp'] >= self.cache_duration:
+                expired_keys.append(key)
+        
+        for key in expired_keys:
+            del self.cache[key]
+        
+        if expired_keys:
+            MediLink_ConfigLoader.log("Cleared {} expired cache entries".format(len(expired_keys)), level="DEBUG")
+
+# Rate limiter to prevent API overload
+class APIRateLimiter:
+    """Rate limiter to prevent API overload"""
+    def __init__(self, max_calls_per_minute=60):
+        self.max_calls = max_calls_per_minute
+        self.calls = []
+    
+    def can_make_call(self):
+        """Check if we can make another API call within rate limits"""
+        now = time.time()
+        # Remove calls older than 1 minute
+        self.calls = [call_time for call_time in self.calls if now - call_time < 60]
+        can_call = len(self.calls) < self.max_calls
+        if not can_call:
+            MediLink_ConfigLoader.log("Rate limit reached: {} calls in last minute".format(len(self.calls)), level="WARNING")
+        return can_call
+    
+    def record_call(self):
+        """Record that an API call was made"""
+        self.calls.append(time.time())
+    
+    def wait_if_needed(self):
+        """Wait if rate limit would be exceeded"""
+        if not self.can_make_call():
+            # Wait until oldest call expires
+            if self.calls:
+                wait_time = 60 - (time.time() - self.calls[0])
+                if wait_time > 0:
+                    MediLink_ConfigLoader.log("Rate limit reached, waiting {:.1f} seconds".format(wait_time), level="INFO")
+                    time.sleep(wait_time)
+
+# Enhanced API client wrapper
+class EnhancedAPIWrapper:
+    """Wrapper that adds circuit breaker, caching, and rate limiting to any API client"""
+    
+    def __init__(self, base_client, enable_circuit_breaker=True, enable_caching=True, enable_rate_limiting=True):
+        self.base_client = base_client
+        
+        # Initialize enhancement components
+        self.circuit_breaker = APICircuitBreaker() if enable_circuit_breaker else None
+        self.cache = APICache() if enable_caching else None
+        self.rate_limiter = APIRateLimiter() if enable_rate_limiting else None
+        
+        MediLink_ConfigLoader.log("Enhanced API wrapper initialized with circuit_breaker={}, caching={}, rate_limiting={}".format(
+            enable_circuit_breaker, enable_caching, enable_rate_limiting), level="INFO")
+    
+    def make_enhanced_call(self, method_name, *args, **kwargs):
+        """Make API call with all enhancements applied"""
+        # Check cache first
+        if self.cache:
+            cached_result = self.cache.get(method_name, *args, **kwargs)
+            if cached_result is not None:
+                return cached_result
+        
+        # Check rate limits
+        if self.rate_limiter:
+            self.rate_limiter.wait_if_needed()
+        
+        # Get the method from base client
+        if not hasattr(self.base_client, method_name):
+            raise AttributeError("Base client does not have method: {}".format(method_name))
+        
+        method = getattr(self.base_client, method_name)
+        
+        # Execute with circuit breaker protection
+        if self.circuit_breaker:
+            result = self.circuit_breaker.call_with_breaker(method, *args, **kwargs)
+        else:
+            result = method(*args, **kwargs)
+        
+        # Record rate limit call
+        if self.rate_limiter:
+            self.rate_limiter.record_call()
+        
+        # Cache result
+        if self.cache:
+            self.cache.set(result, method_name, *args, **kwargs)
+        
+        return result
+
+# Utility functions for API enhancement integration
+def create_enhanced_api_client(base_client_class, *args, **kwargs):
+    """
+    Factory function to create enhanced API client from base client class.
+    Returns base client wrapped with enhancements.
+    """
+    try:
+        # Create base client
+        base_client = base_client_class(*args, **kwargs)
+        
+        # Wrap with enhancements
+        enhanced_client = EnhancedAPIWrapper(base_client)
+        
+        MediLink_ConfigLoader.log("Created enhanced API client from {}".format(base_client_class.__name__), level="INFO")
+        return enhanced_client
+        
+    except Exception as e:
+        MediLink_ConfigLoader.log("Failed to create enhanced API client: {}".format(str(e)), level="ERROR")
+        # Return base client as fallback
+        return base_client_class(*args, **kwargs)
+
+def safe_api_call(api_function, *args, **kwargs):
+    """
+    Safe wrapper for any API call with error handling and fallback.
+    Returns (result, success_flag, error_message)
+    """
+    try:
+        result = api_function(*args, **kwargs)
+        return result, True, None
+    except Exception as e:
+        error_msg = str(e)
+        MediLink_ConfigLoader.log("API call failed: {}".format(error_msg), level="ERROR")
+        return None, False, error_msg
+
+def validate_api_response(response, required_fields=None):
+    """
+    Validate API response has required structure and fields.
+    Returns True if valid, False otherwise.
+    """
+    if not response:
+        return False
+    
+    if required_fields:
+        for field in required_fields:
+            if field not in response:
+                MediLink_ConfigLoader.log("Missing required field in API response: {}".format(field), level="WARNING")
+                return False
+    
+    return True
+
+# API health monitoring
+class APIHealthMonitor:
+    """Monitor API health and performance metrics"""
+    
+    def __init__(self):
+        self.metrics = {
+            'total_calls': 0,
+            'successful_calls': 0,
+            'failed_calls': 0,
+            'cache_hits': 0,
+            'circuit_breaker_trips': 0,
+            'rate_limit_hits': 0,
+            'start_time': time.time()
+        }
+    
+    def record_call(self, success=True):
+        """Record API call outcome"""
+        self.metrics['total_calls'] += 1
+        if success:
+            self.metrics['successful_calls'] += 1
+        else:
+            self.metrics['failed_calls'] += 1
+    
+    def record_cache_hit(self):
+        """Record cache hit"""
+        self.metrics['cache_hits'] += 1
+    
+    def record_circuit_breaker_trip(self):
+        """Record circuit breaker trip"""
+        self.metrics['circuit_breaker_trips'] += 1
+    
+    def record_rate_limit_hit(self):
+        """Record rate limit hit"""
+        self.metrics['rate_limit_hits'] += 1
+    
+    def get_health_summary(self):
+        """Get health summary statistics"""
+        total_calls = self.metrics['total_calls']
+        if total_calls == 0:
+            return {'status': 'NO_CALLS', 'metrics': self.metrics}
+        
+        success_rate = self.metrics['successful_calls'] / float(total_calls)
+        cache_hit_rate = self.metrics['cache_hits'] / float(total_calls)
+        
+        runtime = time.time() - self.metrics['start_time']
+        calls_per_minute = (total_calls / runtime) * 60 if runtime > 0 else 0
+        
+        summary = {
+            'status': 'HEALTHY' if success_rate > 0.95 else 'DEGRADED' if success_rate > 0.80 else 'UNHEALTHY',
+            'success_rate': success_rate,
+            'cache_hit_rate': cache_hit_rate,
+            'calls_per_minute': calls_per_minute,
+            'runtime_seconds': runtime,
+            'metrics': self.metrics
+        }
+        
+        MediLink_ConfigLoader.log("API Health Summary: {}".format(str(summary)), level="INFO")
+        return summary
+
+# Global API health monitor instance
+_global_health_monitor = APIHealthMonitor()
+
+def get_api_health_monitor():
+    """Get global API health monitor instance"""
+    return _global_health_monitor

MediLink/MediLink_insurance_utils.py

@@ -0,0 +1,231 @@
+# 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
+
+# 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):
+    """Get feature flag from config or return default"""
+    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.
+    Returns validated type or safe fallback.
+    """
+    try:
+        config, _ = MediLink_ConfigLoader.load_configuration()
+        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="INFO")
+            return '12'  # Default to PPO
+        
+        # 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(
+            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'
+
+# Monitoring and statistics
+def generate_insurance_assignment_summary(detailed_patient_data):
+    """Generate basic summary statistics for insurance type assignments"""
+    if not detailed_patient_data:
+        return {}
+    
+    # Collect basic statistics
+    insurance_type_counts = {}
+    
+    for data in detailed_patient_data:
+        insurance_type = data.get('insurance_type', 'UNKNOWN')
+        insurance_type_counts[insurance_type] = insurance_type_counts.get(insurance_type, 0) + 1
+    
+    summary = {
+        'total_patients': len(detailed_patient_data),
+        'insurance_types': insurance_type_counts
+    }
+    
+    # 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", level="DEBUG")
+            # For now, just call fallback - actual enhancement would go here
+            result = fallback_function(parsed_data)
+            MediLink_ConfigLoader.log("Insurance decision: type={}, method=ENHANCED".format(result), level="INFO")
+            return result
+        else:
+            # Use standard selection
+            result = fallback_function(parsed_data)
+            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: {}. Using PPO default.".format(str(e)), level="ERROR")
+        
+        MediLink_ConfigLoader.log("Insurance decision: type=12, method=ERROR_FALLBACK, error={}".format(str(e)), level="INFO")
+        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 = []
+    
+    iterator = tqdm(patients, desc=description)
+    
+    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/__init__.py

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