medicafe 0.250722.0__py3-none-any.whl → 0.250723.0__py3-none-any.whl

MediBot/MediBot.py

@@ -40,8 +40,42 @@ 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
+                if stderr:
+                    print("AHK Error: {}".format(stderr.decode('utf-8', errors='ignore')))
+            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))
+            # 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
@@ -70,6 +104,8 @@ def run_ahk_script(script_content):
 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 +143,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 +176,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 +184,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 +210,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 +235,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):

MediBot/MediBot_Crosswalk_Library.py

@@ -481,13 +481,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 +519,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 +649,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")