medicafe 0.250722.0__tar.gz → 0.250723.1__tar.gz

{medicafe-0.250722.0 → medicafe-0.250723.1}/MediBot/MediBot.py

@@ -40,8 +40,45 @@ def identify_field(header, field_mapping):
     # Add this print to a function that is calling identify_field
     #print("Warning: No matching field found for CSV header '{}'".format(header))
 
+# Global flag to control AHK execution method - set to True to use optimized stdin method
+USE_AHK_STDIN_OPTIMIZATION = True
+
 # Function to execute an AutoHotkey script
 def run_ahk_script(script_content):
+    """
+    Execute an AutoHotkey script using either optimized stdin method or traditional file method.
+    Automatically falls back to file method if stdin method fails.
+    """
+    if USE_AHK_STDIN_OPTIMIZATION:
+        try:
+            # Optimized method: Execute AHK script via stdin pipe - eliminates temporary file creation
+            # Compatible with Windows XP and AutoHotkey v1.0.48+
+            process = subprocess.Popen(
+                [AHK_EXECUTABLE, '/f', '*'],  # '/f *' tells AHK to read from stdin
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                shell=False
+            )
+            
+            # Send script content via stdin
+            stdout, stderr = process.communicate(input=script_content.encode('utf-8'))
+            
+            if process.returncode != 0:
+                print("AHK script failed with exit status: {}".format(process.returncode))  # Log the exit status of the failed script
+                MediLink_ConfigLoader.log("AHK script failed with exit status: {}".format(process.returncode), level="ERROR")
+                if stderr:
+                    print("AHK Error: {}".format(stderr.decode('utf-8', errors='ignore')))
+                    MediLink_ConfigLoader.log("AHK Error: {}".format(stderr.decode('utf-8', errors='ignore')), level="ERROR")
+            return  # Success - no file cleanup needed
+            
+        except Exception as e:
+            # If stdin method fails, fall back to traditional file method
+            print("AHK stdin execution failed, falling back to file method: {}".format(e))
+            MediLink_ConfigLoader.log("AHK stdin execution failed, falling back to file method: {}".format(e), level="ERROR")
+            # Continue to fallback implementation below
+    
+    # Traditional file-based method (fallback or when optimization disabled)
     temp_script_name = None  # Initialize variable to hold the name of the temporary script file
     try:
         # Create a temporary AHK script file
@@ -53,9 +90,12 @@ def run_ahk_script(script_content):
         subprocess.check_call([AHK_EXECUTABLE, temp_script_name])  # Execute the AHK script using the AutoHotkey executable
     except subprocess.CalledProcessError as e:
         print("AHK script failed with exit status: {}".format(e.returncode))  # Log the exit status of the failed script
+        MediLink_ConfigLoader.log("AHK script failed with exit status: {}".format(e.returncode), level="ERROR")
         print("Output from AHK script: {}".format(e.output))  # Log the output from the failed script
+        MediLink_ConfigLoader.log("Output from AHK script: {}".format(e.output), level="ERROR")
     except Exception as e:
         print("An unexpected error occurred while running the AHK script: {}".format(e))  # Log any unexpected errors
+        MediLink_ConfigLoader.log("An unexpected error occurred while running the AHK script: {}".format(e), level="ERROR")
         traceback.print_exc()  # Print the full traceback for debugging purposes
     finally:
         # Delete the temporary script file
@@ -64,12 +104,15 @@ def run_ahk_script(script_content):
                 os.unlink(temp_script_name)  # Attempt to delete the temporary script file
             except OSError as e:
                 print("Error deleting temporary script file: {}".format(e))  # Log any errors encountered while deleting the file
+                MediLink_ConfigLoader.log("Error deleting temporary script file: {}".format(e), level="ERROR")
                 # Future Improvement: Implement a cleanup mechanism to handle orphaned temporary files
 
 # Global variable to store the last processed entry
 last_processed_entry = None
 # Global variable to store temporarily parsed address components
 parsed_address_components = {}
+# Global variable to store patient context for F11 menu (preserved across patients)
+current_patient_context = None
 
 def process_field(medisoft_field, csv_row, parsed_address_components, reverse_mapping, csv_data, fixed_values):
     global last_processed_entry
@@ -107,8 +150,19 @@ def process_field(medisoft_field, csv_row, parsed_address_components, reverse_ma
         return handle_error(e, medisoft_field, last_processed_entry, csv_data)
 
 def handle_error(error, medisoft_field, last_processed_entry, csv_data):
+    global current_patient_context
     MediLink_ConfigLoader.log("Error in process_field: ", e)
     print("An error occurred while processing {0}: {1}".format(medisoft_field, error))
+    
+    # Update patient context with current error information for F11 menu
+    if current_patient_context is None:
+        current_patient_context = {}
+    current_patient_context.update({
+        'last_field': medisoft_field,
+        'error_occurred': True,
+        'error_message': str(error)
+    })
+    
     # Assuming the interaction mode is 'error' in this case
     interaction_mode = 'error'
     response = user_interaction(csv_data, interaction_mode, error, reverse_mapping)
@@ -129,7 +183,7 @@ def iterate_fields(csv_row, field_mapping, parsed_address_components, reverse_ma
     return 0 # Default action to continue
 
 def data_entry_loop(csv_data, field_mapping, reverse_mapping, fixed_values):
-    global last_processed_entry, parsed_address_components
+    global last_processed_entry, parsed_address_components, current_patient_context
     # last_processed_entry, parsed_address_components = None, {} // BUG should this just be this line rather than the global line above?
     error_message = ''  # Initialize error_message once
     current_row_index = 0
@@ -137,6 +191,23 @@ def data_entry_loop(csv_data, field_mapping, reverse_mapping, fixed_values):
     while current_row_index < len(csv_data):
         row = csv_data[current_row_index]
         
+        # PERFORMANCE FIX: Clear accumulating memory while preserving F11 menu context
+        # Store patient context before clearing last_processed_entry for F11 "Retry last entry" functionality
+        if last_processed_entry is not None:
+            patient_name = row.get(reverse_mapping.get('Patient Name', ''), 'Unknown Patient')
+            surgery_date = row.get('Surgery Date', 'Unknown Date')
+            current_patient_context = {
+                'patient_name': patient_name,
+                'surgery_date': surgery_date,
+                'last_field': last_processed_entry[0] if last_processed_entry else None,
+                'last_value': last_processed_entry[1] if last_processed_entry else None,
+                'row_index': current_row_index
+            }
+        
+        # Clear memory-accumulating structures while preserving F11 context above
+        last_processed_entry = None
+        parsed_address_components = {}
+        
         # Handle script pause at the start of each row (patient record). 
         manage_script_pause(csv_data, error_message, reverse_mapping)
         error_message = ''  # Clear error message for the next iteration
@@ -146,8 +217,9 @@ def data_entry_loop(csv_data, field_mapping, reverse_mapping, fixed_values):
 
         # I feel like this is overwriting what would have already been idenfitied in the mapping. 
         # This probably needs to be initialized differently.
+        # Note: parsed_address_components is now explicitly cleared above for performance
         # parsed_address_components = {'City': '', 'State': '', 'Zip Code': ''}
-        parsed_address_components = {}
+        # parsed_address_components = {}  # Moved to top of loop for memory management
 
         # Process each field in the row
         action = iterate_fields(row, field_mapping, parsed_address_components, reverse_mapping, csv_data, fixed_values)
@@ -170,6 +242,14 @@ def data_entry_loop(csv_data, field_mapping, reverse_mapping, fixed_values):
         # Code to handle the end of a patient record
         # TODO One day this can just not pause...
         app_control.set_pause_status(True)  # Pause at the end of processing each patient record
+        
+        # PERFORMANCE FIX: Explicit cleanup at end of patient processing
+        # Clear global state to prevent accumulation over processing sessions
+        # Note: current_patient_context is preserved for F11 menu functionality
+        if current_row_index != len(csv_data) - 1:  # Not the last patient
+            last_processed_entry = None
+            parsed_address_components.clear()
+            
         current_row_index += 1  # Move to the next row by default
 
 def open_medisoft(shortcut_path):

{medicafe-0.250722.0 → medicafe-0.250723.1}/MediBot/MediBot_Crosswalk_Library.py

@@ -279,19 +279,22 @@ def check_crosswalk_health(crosswalk):
         crosswalk (dict): The crosswalk dictionary to check.
     
     Returns:
-        tuple: (is_healthy, missing_names_count, missing_medisoft_ids_count)
+        tuple: (is_healthy, missing_names_count, missing_medisoft_ids_count, missing_names_list, missing_medisoft_ids_list)
     """
     if 'payer_id' not in crosswalk or not crosswalk['payer_id']:
-        return False, 0, 0
+        return False, 0, 0, [], []
 
     missing_names = 0
     missing_medisoft_ids = 0
+    missing_names_list = []
+    missing_medisoft_ids_list = []
     
     for payer_id, details in crosswalk['payer_id'].items():
         # Check if name is missing or "Unknown"
         name = details.get('name', '')
         if not name or name == 'Unknown':
             missing_names += 1
+            missing_names_list.append(payer_id)
 
         # Check if at least one medisoft ID exists in either field
         medisoft_id = details.get('medisoft_id', [])
@@ -306,10 +309,11 @@ def check_crosswalk_health(crosswalk):
         # If both are empty, count as missing; if either has at least one, it's healthy
         if not medisoft_id and not medisoft_medicare_id:
             missing_medisoft_ids += 1
+            missing_medisoft_ids_list.append(payer_id)
 
     # Consider healthy if no missing names and no missing medisoft IDs
     is_healthy = (missing_names == 0 and missing_medisoft_ids == 0)
-    return is_healthy, missing_names, missing_medisoft_ids
+    return is_healthy, missing_names, missing_medisoft_ids, missing_names_list, missing_medisoft_ids_list
 
 def prompt_user_for_api_calls(crosswalk, config):
     """
@@ -324,7 +328,7 @@ def prompt_user_for_api_calls(crosswalk, config):
         bool: True if should proceed with API calls, False if should skip
     """
     
-    is_healthy, missing_names, missing_medisoft_ids = check_crosswalk_health(crosswalk)
+    is_healthy, missing_names, missing_medisoft_ids, missing_names_list, missing_medisoft_ids_list = check_crosswalk_health(crosswalk)
     total_payers = len(crosswalk.get('payer_id', {}))
     
     if is_healthy:
@@ -362,13 +366,27 @@ def prompt_user_for_api_calls(crosswalk, config):
     else:
         print("\nCrosswalk needs attention:")
         print("  - {} payers found".format(total_payers))
+        
+        # Show detailed information about missing names
         if missing_names > 0:
-            print("  - {} payers missing names".format(missing_names))
+            print("  - {} payers missing names: {}".format(missing_names, ", ".join(missing_names_list)))
+        
+        # Show detailed information about missing medisoft IDs
         if missing_medisoft_ids > 0:
-            print("  - {} payers missing medisoft IDs".format(missing_medisoft_ids))
-        print("Proceeding with API validation calls...")
-        MediLink_ConfigLoader.log("Crosswalk unhealthy - proceeding with API calls", config, level="INFO")
-        return True
+            print("  - {} payers missing medisoft IDs: {}".format(missing_medisoft_ids, ", ".join(missing_medisoft_ids_list)))
+            # API validation CANNOT resolve missing medisoft IDs
+            print("    TODO: Need user interface to manually input medisoft IDs for these payers")
+        
+        # Only proceed with API calls if there are missing names (API can help with those)
+        if missing_names > 0:
+            print("Proceeding with API validation calls to resolve missing names...")
+            MediLink_ConfigLoader.log("Crosswalk has missing names - proceeding with API calls", config, level="INFO")
+            return True
+        else:
+            print("No missing names to resolve via API. Skipping API validation calls.")
+            print("TODO: Manual intervention needed for missing medisoft IDs")
+            MediLink_ConfigLoader.log("Crosswalk has missing medisoft IDs but no missing names - skipping API calls", config, level="INFO")
+            return False
 
 def crosswalk_update(client, config, crosswalk, skip_known_payers=True): # Upstream of this is only MediBot_Preprocessor.py and MediBot.py
     """
@@ -481,13 +499,15 @@ def crosswalk_update(client, config, crosswalk, skip_known_payers=True): # Upstr
 
                 crosswalk['payer_id'][payer_id] = {
                     'endpoint': selected_endpoint,
-                    'medisoft_id': set(),  # Use set to store multiple IDs
-                    'medisoft_medicare_id': set()
+                    'medisoft_id': [],  # PERFORMANCE FIX: Use list instead of set to avoid conversions
+                    'medisoft_medicare_id': []  # PERFORMANCE FIX: Use list instead of set to avoid conversions
                 }
                 MediLink_ConfigLoader.log("Initialized payer ID {} in crosswalk with endpoint '{}'.".format(payer_id, selected_endpoint), config, level="DEBUG")
 
-            # Add the insurance ID to the payer ID entry
-            crosswalk['payer_id'][payer_id]['medisoft_id'].add(str(insurance_id))  # Ensure IDs are strings
+            # Add the insurance ID to the payer ID entry (PERFORMANCE FIX: Use list operations)
+            insurance_id_str = str(insurance_id)  # Ensure ID is string
+            if insurance_id_str not in crosswalk['payer_id'][payer_id]['medisoft_id']:
+                crosswalk['payer_id'][payer_id]['medisoft_id'].append(insurance_id_str)  # Avoid duplicates
             MediLink_ConfigLoader.log(
                 "Added new insurance ID {} to payer ID {}.".format(insurance_id, payer_id),
                 config,
@@ -517,14 +537,26 @@ def crosswalk_update(client, config, crosswalk, skip_known_payers=True): # Upstr
         fetch_and_store_payer_name(client, payer_id, crosswalk, config)
         MediLink_ConfigLoader.log("Successfully fetched and stored payer name for unknown payer_id: {}".format(payer_id), config, level="INFO")
 
-    # Ensure multiple medisoft_id values are preserved by converting sets to sorted lists
+    # PERFORMANCE FIX: Optimized list management - avoid redundant set/list conversions
+    # Ensure multiple medisoft_id values are preserved and deduplicated efficiently
     for payer_id, details in crosswalk.get('payer_id', {}).items():
-        if isinstance(details.get('medisoft_id'), set):
-            crosswalk['payer_id'][payer_id]['medisoft_id'] = sorted(list(details['medisoft_id']))
-            MediLink_ConfigLoader.log("Converted medisoft_id for payer ID {} to sorted list.".format(payer_id), config, level="DEBUG")
-        if isinstance(details.get('medisoft_medicare_id'), set):
-            crosswalk['payer_id'][payer_id]['medisoft_medicare_id'] = sorted(list(details['medisoft_medicare_id']))
-            MediLink_ConfigLoader.log("Converted medisoft_medicare_id for payer ID {} to sorted list.".format(payer_id), config, level="DEBUG")
+        # Handle medisoft_id - convert sets to lists or deduplicate existing lists
+        medisoft_id = details.get('medisoft_id', [])
+        if isinstance(medisoft_id, set):
+            crosswalk['payer_id'][payer_id]['medisoft_id'] = sorted(list(medisoft_id))
+            MediLink_ConfigLoader.log("Converted medisoft_id set to sorted list for payer ID {}.".format(payer_id), config, level="DEBUG")
+        elif isinstance(medisoft_id, list) and medisoft_id:
+            # Remove duplicates using dict.fromkeys() - preserves order, O(n) performance
+            crosswalk['payer_id'][payer_id]['medisoft_id'] = list(dict.fromkeys(medisoft_id))
+        
+        # Handle medisoft_medicare_id - convert sets to lists or deduplicate existing lists  
+        medicare_id = details.get('medisoft_medicare_id', [])
+        if isinstance(medicare_id, set):
+            crosswalk['payer_id'][payer_id]['medisoft_medicare_id'] = sorted(list(medicare_id))
+            MediLink_ConfigLoader.log("Converted medisoft_medicare_id set to sorted list for payer ID {}.".format(payer_id), config, level="DEBUG")
+        elif isinstance(medicare_id, list) and medicare_id:
+            # Remove duplicates using dict.fromkeys() - preserves order, O(n) performance
+            crosswalk['payer_id'][payer_id]['medisoft_medicare_id'] = list(dict.fromkeys(medicare_id))
 
     MediLink_ConfigLoader.log("Crosswalk update process completed. Processed {} payer IDs.".format(len(patient_id_to_payer_id)), config, level="INFO")
     return save_crosswalk(client, config, crosswalk)
@@ -635,7 +667,7 @@ def update_crosswalk_with_new_payer_id(client, insurance_name, payer_id, config,
             # Ensure the 'payer_id' key exists in the crosswalk
             crosswalk['payer_id'][payer_id] = {
                 'endpoint': selected_endpoint,
-                'medisoft_id': set(),
+                'medisoft_id': [],  # PERFORMANCE FIX: Use list instead of set to avoid conversions
                 'medisoft_medicare_id': []
             }
             MediLink_ConfigLoader.log("Initialized payer ID {} in crosswalk with endpoint '{}'.".format(payer_id, selected_endpoint), config, level="DEBUG")