medicafe 0.250720.1__tar.gz → 0.250723.0__tar.gz

{medicafe-0.250720.1 → medicafe-0.250723.0}/MediBot/MediBot.bat

@@ -281,9 +281,11 @@ for %%f in ("%target_folder%\!latest_csv!") do set "latest_csv_name=%%~nxf"
 
 :: Compare the paths and prompt user if necessary
 if not "!current_csv_name!"=="!latest_csv_name!" (
+    echo.
     echo ALERT: Config file CSV path differs from the latest CSV. This can happen if a new CSV is downloaded.
     echo Current CSV: !current_csv_name!
     echo Latest CSV: !latest_csv_name!
+    echo.
     set /p update_choice="Do you want to update to the latest CSV? (Y/N): "
     if /i "!update_choice!"=="Y" (
         echo Updating config file with latest CSV...

{medicafe-0.250720.1 → medicafe-0.250723.0}/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):

{medicafe-0.250720.1 → medicafe-0.250723.0}/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")

{medicafe-0.250720.1 → medicafe-0.250723.0}/MediBot/MediBot_Preprocessor.py

@@ -25,7 +25,8 @@ except ImportError as e:
 
 # Load configuration
 # Should this also take args? Path for ./MediLink needed to be added for this to resolve
-config, crosswalk = MediLink_ConfigLoader.load_configuration()
+# Use cached configuration to avoid repeated I/O operations
+config, crosswalk = MediBot_Preprocessor_lib.get_cached_configuration()
 
 # CSV Preprocessor built for Carol
 def preprocess_csv_data(csv_data, crosswalk):
@@ -57,9 +58,7 @@ def preprocess_csv_data(csv_data, crosswalk):
         # and which haven't been yet. So, if the patient 'exists' in the system, the next quetion is about claims/billing status.
         # Eventually, we really want to get out of Medisoft... 
         
-        # Convert 'Surgery Date' back to string format if needed for further processing.
-        # Combine 'Patient First', 'Patient Middle', and 'Patient Last' into a single 'Patient Name' field.
-        # Combine 'Patient Address1' and 'Patient Address2' into a single 'Patient Street' field.
+        # Batch field operations: Convert dates, combine names/addresses, and apply replacements
         MediLink_ConfigLoader.log("CSV Pre-processor: Constructing Patient Name and Address for Medisoft...", level="INFO")
         MediBot_Preprocessor_lib.combine_fields(csv_data)
         
@@ -97,7 +96,8 @@ def preprocess_csv_data(csv_data, crosswalk):
 
 def check_existing_patients(selected_patient_ids, MAPAT_MED_PATH):
     existing_patients = []
-    patients_to_process = list(selected_patient_ids)  # Clone the selected patient IDs list
+    # Convert to set for O(1) lookup performance
+    selected_patient_ids_set = set(selected_patient_ids)
 
     try:
         with open(MAPAT_MED_PATH, 'r') as file:
@@ -107,17 +107,17 @@ def check_existing_patients(selected_patient_ids, MAPAT_MED_PATH):
                     patient_id = line[194:202].strip()  # Extract Patient ID (Columns 195-202)
                     patient_name = line[9:39].strip()  # Extract Patient Name (Columns 10-39)
                     
-                    if patient_id in selected_patient_ids:
+                    if patient_id in selected_patient_ids_set:
                         existing_patients.append((patient_id, patient_name))
-                        # Remove all occurrences of this patient_id from patients_to_process as a filter rather than .remove because 
-                        # then it only makes one pass and removes the first instance.
+                        # Remove from set for O(1) operation
+                        selected_patient_ids_set.discard(patient_id)
     except FileNotFoundError:
         # Handle the case where MAPAT_MED_PATH is not found
         print("MAPAT.med was not found at location indicated in config file.")
         print("Skipping existing patient check and continuing...")
         
-    # Filter out all instances of existing patient IDs
-    patients_to_process = [id for id in patients_to_process if id not in [patient[0] for patient in existing_patients]]
+    # Convert remaining set back to list for return
+    patients_to_process = list(selected_patient_ids_set)
     
     return existing_patients, patients_to_process
 
@@ -129,14 +129,25 @@ def intake_scan(csv_headers, field_mapping):
     MediLink_ConfigLoader.log("Intake Scan - Field Mapping: {}".format(field_mapping), level="DEBUG")
     MediLink_ConfigLoader.log("Intake Scan - CSV Headers: {}".format(csv_headers), level="DEBUG")
     
+    # Pre-compile regex patterns for better performance
+    compiled_patterns = {}
+    for medisoft_field, patterns in field_mapping.items():
+        compiled_patterns[medisoft_field] = [re.compile(pattern, re.IGNORECASE) for pattern in patterns]
+    
+    # Pre-compile the alphanumeric regex for policy number validation
+    alphanumeric_pattern = re.compile("^[a-zA-Z0-9]*$")
+    
     # Iterate over the Medisoft fields defined in field_mapping
     for medisoft_field in field_mapping.keys():
-        for pattern in field_mapping[medisoft_field]:
-            matched_headers = [header for header in csv_headers if re.search(pattern, header, re.IGNORECASE)]
-            if matched_headers:
-                # Assuming the first matched header is the desired one
-                identified_fields[matched_headers[0]] = medisoft_field
-                # MediLink_ConfigLoader.log("Found Header: {}".format(identified_fields[matched_headers[0]]))
+        matched = False
+        for pattern in compiled_patterns[medisoft_field]:
+            # Use early termination - find first match and break
+            for header in csv_headers:
+                if pattern.search(header):
+                    identified_fields[header] = medisoft_field
+                    matched = True
+                    break
+            if matched:
                 break
         else:
             # Check if the missing field is a required field before appending the warning
@@ -160,7 +171,7 @@ def intake_scan(csv_headers, field_mapping):
         if 'Insurance Policy Number' in field:
             policy_number = identified_fields.get(header)
             MediLink_ConfigLoader.log("Checking Insurance Policy Number '{}' for alphanumeric characters.".format(policy_number), level="DEBUG")
-            if not bool(re.match("^[a-zA-Z0-9]*$", policy_number)):
+            if not alphanumeric_pattern.match(policy_number):
                 missing_fields_warnings.append("WARNING: Insurance Policy Number '{}' contains invalid characters.".format(policy_number))
                 MediLink_ConfigLoader.log("Insurance Policy Number '{}' contains invalid characters.".format(policy_number), level="WARNING")
         # Additional checks can be added as needed for other fields
@@ -187,15 +198,19 @@ def main():
 
     args = parser.parse_args()
 
-    config, crosswalk = MediLink_ConfigLoader.load_configuration()
-    
-    client = APIClient()
-    
     # If no arguments provided, print usage instructions
     if not any(vars(args).values()):
         parser.print_help()
         return
 
+    # Load configuration only when needed
+    if args.update_crosswalk or args.init_crosswalk or args.load_csv or args.preprocess_csv or args.open_csv:
+        config, crosswalk = MediBot_Preprocessor_lib.get_cached_configuration()
+    
+    # Initialize API client only when needed
+    if args.update_crosswalk or args.init_crosswalk:
+        client = APIClient()
+    
     if args.update_crosswalk:
         print("Updating the crosswalk...")
         MediBot_Crosswalk_Library.crosswalk_update(client, config, crosswalk)