medicafe 0.250728.7__tar.gz → 0.250728.9__tar.gz

{medicafe-0.250728.7 → medicafe-0.250728.9}/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__), ".."))
@@ -28,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
@@ -49,9 +62,18 @@ 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.
+
+    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:
@@ -64,14 +86,62 @@ 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.
     """
+    # Enhanced mode check with graceful degradation
+    enhanced_mode = False
+    
+    try:
+        from MediLink_insurance_utils import (
+            get_feature_flag, 
+            validate_insurance_type_from_config
+        )
+        enhanced_mode = get_feature_flag('enhanced_insurance_enrichment', default=False)
+        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 = {}
     
-    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 validation
+    if enhanced_mode:
+        MediLink_ConfigLoader.log("Using enhanced insurance type enrichment", level="INFO")
+        
+        for data in 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:
+            # 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
 
 def extract_and_suggest_endpoint(file_path, config, crosswalk):
@@ -81,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.
@@ -135,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'),

{medicafe-0.250728.7 → medicafe-0.250728.9}/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,22 @@ 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 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):
+    """
+    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():
@@ -639,11 +656,24 @@ def insurance_type_selection(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
 

{medicafe-0.250728.7 → medicafe-0.250728.9}/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.9}/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

{medicafe-0.250728.7 → medicafe-0.250728.9}/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])
     )
 

{medicafe-0.250728.7 → medicafe-0.250728.9}/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