medicafe 0.250728.7__tar.gz → 0.250728.8__tar.gz

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

@@ -1,5 +1,5 @@
 # MediLink.py
-import os, sys
+import os, sys, time
 import MediLink_Down
 import MediLink_Up
 import MediLink_ConfigLoader
@@ -7,7 +7,12 @@ import MediLink_DataMgmt
 
 # For UI Functions
 import MediLink_UI  # Import UI module for handling all user interfaces
-from tqdm import tqdm
+try:
+    from tqdm import tqdm
+except ImportError:
+    # Fallback for when tqdm is not available
+    def tqdm(iterable, **kwargs):
+        return iterable
 
 # Add parent directory of the project to the Python path
 project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
@@ -49,6 +54,7 @@ def collect_detailed_patient_data(selected_files, config, crosswalk):
 def enrich_with_insurance_type(detailed_patient_data, patient_insurance_type_mapping=None):
     """
     Enriches the detailed patient data with insurance type based on patient ID.
+    Enhanced with optional API integration and comprehensive logging.
 
     Parameters:
     - detailed_patient_data: List of dictionaries containing detailed patient data.
@@ -64,14 +70,50 @@ 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
+    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")
+        enhanced_mode = False
+    
     if patient_insurance_type_mapping is None:
         MediLink_ConfigLoader.log("No Patient:Insurance-Type mapping available.", level="WARNING")
         patient_insurance_type_mapping = {}
     
-    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)
-        data['insurance_type'] = insurance_type
+    # Enhanced mode with metadata and 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)
+        
+    else:
+        # Legacy mode (preserve existing behavior exactly)
+        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)
+            data['insurance_type'] = insurance_type
+    
     return detailed_patient_data
 
 def extract_and_suggest_endpoint(file_path, config, crosswalk):

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

@@ -572,7 +572,8 @@ def create_sbr_segment(config, parsed_data, endpoint):
 
 def insurance_type_selection(parsed_data):
     """
-    Quick Fix: This funtion selects the insurance type for a patient based on predefined codes.
+    Enhanced insurance type selection with optional API integration and safe fallbacks.
+    Maintains exact same signature as existing implementation.
     
     TODO (HIGH SBR09) Finish making this function. 
     This should  eventually integrate into a menu upstream. This menu flow probably needs to be alongside the suggested endpoint flow.
@@ -602,6 +603,19 @@ def insurance_type_selection(parsed_data):
     """
     MediLink_ConfigLoader.log("insurance_type_selection(parsed_data): {}".format(parsed_data), level="DEBUG")
     
+    # Try enhanced selection with safe fallback
+    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")
+        return _original_insurance_type_selection_logic(parsed_data)
+
+def _original_insurance_type_selection_logic(parsed_data):
+    """
+    Original insurance type selection logic extracted to preserve exact behavior.
+    This ensures backward compatibility when enhanced features are not available.
+    """
     # Check if insurance type is already assigned and is valid
     insurance_type_code = parsed_data.get('insurance_type')
     if insurance_type_code and len(insurance_type_code) == 2 and insurance_type_code.isalnum():

{medicafe-0.250728.7 → medicafe-0.250728.8}/MediLink/MediLink_API_v3.py

@@ -112,6 +112,29 @@ class APIClient(BaseAPIClient):
     def __init__(self):
         config, _ = MediLink_ConfigLoader.load_configuration()
         super().__init__(config)
+        
+        # Add enhanced features if available
+        try:
+            from MediLink_api_utils import APICircuitBreaker, APICache, APIRateLimiter
+            from MediLink_insurance_utils import get_feature_flag
+            
+            # Initialize enhancements if enabled
+            enable_circuit_breaker = get_feature_flag('api_circuit_breaker', default=False)
+            enable_caching = get_feature_flag('api_caching', default=False)
+            enable_rate_limiting = get_feature_flag('api_rate_limiting', default=False)
+            
+            self.circuit_breaker = APICircuitBreaker() if enable_circuit_breaker else None
+            self.api_cache = APICache() if enable_caching else None
+            self.rate_limiter = APIRateLimiter() if enable_rate_limiting else None
+            
+            if any([enable_circuit_breaker, enable_caching, enable_rate_limiting]):
+                MediLink_ConfigLoader.log("Enhanced API client initialized with circuit_breaker={}, caching={}, rate_limiting={}".format(
+                    enable_circuit_breaker, enable_caching, enable_rate_limiting), level="INFO")
+        except ImportError:
+            MediLink_ConfigLoader.log("API enhancements not available, using standard client", level="DEBUG")
+            self.circuit_breaker = None
+            self.api_cache = None
+            self.rate_limiter = None
 
     def get_access_token(self, endpoint_name):
         MediLink_ConfigLoader.log("[Get Access Token] Called for {}".format(endpoint_name), level="DEBUG")
@@ -177,6 +200,45 @@ class APIClient(BaseAPIClient):
             return None
 
     def make_api_call(self, endpoint_name, call_type, url_extension="", params=None, data=None, headers=None):
+        # Try enhanced API call if available
+        if hasattr(self, 'circuit_breaker') and self.circuit_breaker:
+            try:
+                return self._make_enhanced_api_call(endpoint_name, call_type, url_extension, params, data, headers)
+            except Exception as e:
+                MediLink_ConfigLoader.log("Enhanced API call failed, falling back to standard: {}".format(str(e)), level="WARNING")
+        
+        # Standard API call logic
+        return self._make_standard_api_call(endpoint_name, call_type, url_extension, params, data, headers)
+    
+    def _make_enhanced_api_call(self, endpoint_name, call_type, url_extension="", params=None, data=None, headers=None):
+        """Enhanced API call with circuit breaker, caching, and rate limiting"""
+        # Check cache first (for GET requests)
+        if self.api_cache and call_type == 'GET':
+            cached_result = self.api_cache.get(endpoint_name, call_type, url_extension, params)
+            if cached_result is not None:
+                MediLink_ConfigLoader.log("Cache hit for {} {} {}".format(call_type, endpoint_name, url_extension), level="DEBUG")
+                return cached_result
+        
+        # Check rate limits
+        if self.rate_limiter:
+            self.rate_limiter.wait_if_needed()
+        
+        # Make call with circuit breaker protection
+        result = self.circuit_breaker.call_with_breaker(
+            self._make_standard_api_call, endpoint_name, call_type, url_extension, params, data, headers)
+        
+        # Record rate limit call
+        if self.rate_limiter:
+            self.rate_limiter.record_call()
+        
+        # Cache result (for GET requests)
+        if self.api_cache and call_type == 'GET':
+            self.api_cache.set(result, endpoint_name, call_type, url_extension, params)
+        
+        return result
+    
+    def _make_standard_api_call(self, endpoint_name, call_type, url_extension="", params=None, data=None, headers=None):
+        """Standard API call logic preserved for compatibility"""
         token = self.get_access_token(endpoint_name)
         if token:
             MediLink_ConfigLoader.log("[Make API Call] Token found for {}".format(endpoint_name), level="DEBUG")

{medicafe-0.250728.7 → medicafe-0.250728.8}/MediLink/MediLink_Up.py

@@ -1,7 +1,12 @@
 # MediLink_Up.py
 from datetime import datetime
 import os, re, subprocess, traceback
-from tqdm import tqdm
+try:
+    from tqdm import tqdm
+except ImportError:
+    # Fallback for when tqdm is not available
+    def tqdm(iterable, **kwargs):
+        return iterable
 import MediLink_837p_encoder
 from MediLink_ConfigLoader import log, load_configuration
 from MediLink_DataMgmt import operate_winscp

medicafe-0.250728.8/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