medicafe 0.250723.5__tar.gz → 0.250725.0__tar.gz

{medicafe-0.250723.5 → medicafe-0.250725.0}/MediBot/MediBot.py

@@ -1,5 +1,5 @@
 #MediBot.py
-import subprocess, os, tempfile, traceback, re, sys
+import subprocess, os, tempfile, traceback, re, sys, time
 from collections import OrderedDict
 import MediBot_dataformat_library
 import MediBot_Preprocessor
@@ -187,8 +187,10 @@ def data_entry_loop(csv_data, field_mapping, reverse_mapping, fixed_values):
     # 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
+    # PERFORMANCE FIX: Cache list length to avoid repeated len() calls
+    csv_data_length = len(csv_data)
 
-    while current_row_index < len(csv_data):
+    while current_row_index < csv_data_length:
         row = csv_data[current_row_index]
         
         # PERFORMANCE FIX: Clear accumulating memory while preserving F11 menu context
@@ -394,9 +396,13 @@ if __name__ == "__main__":
             # Check if there are patients left to process
             if len(patients_to_process) == 0:
                 print("\nAll patients have been processed. Continue anyway?: ", end='', flush=True)
+                # Small delay for Windows XP console buffer synchronization
+                time.sleep(0.1)
                 proceed = input().lower().strip() in ['yes', 'y']
             else:
                 print("\nDo you want to proceed with the {} remaining patient(s)? (yes/no): ".format(len(patients_to_process)), end='', flush=True)
+                # Small delay for Windows XP console buffer synchronization
+                time.sleep(0.1)
                 proceed = input().lower().strip() in ['yes', 'y']
 
             # TODO: Here is where we need to add the step where we move to MediBot_Charges. 

{medicafe-0.250723.5 → medicafe-0.250725.0}/MediBot/MediBot_Preprocessor_lib.py

@@ -1,7 +1,7 @@
 #MediBot_Preprocessor_lib.py
 from collections import OrderedDict, defaultdict
 from datetime import datetime, timedelta
-import os, csv, sys
+import os, csv, sys, time
 import chardet  # Ensure chardet is imported
 
 # Add the parent directory of the project to the Python path
@@ -120,8 +120,8 @@ def load_csv_data(csv_file_path):
             # Clean the headers
             cleaned_headers = clean_header(reader.fieldnames)
 
-            # Create a mapping of cleaned headers to original headers (pre-compute once)
-            header_mapping = {cleaned_headers[i]: reader.fieldnames[i] for i in range(len(cleaned_headers))}
+            # PERFORMANCE FIX: Use zip() instead of range(len()) for header mapping
+            header_mapping = {clean: orig for clean, orig in zip(cleaned_headers, reader.fieldnames)}
 
             # Process the remaining rows - optimize by pre-allocating the list
             csv_data = []
@@ -129,9 +129,8 @@ def load_csv_data(csv_file_path):
             # csv_data = [None] * estimated_size  # if we had row count
             
             for row in reader:
-                # Use dict() constructor with generator expression for better performance
-                cleaned_row = dict((cleaned_headers[i], row[header_mapping[cleaned_headers[i]]]) 
-                                 for i in range(len(cleaned_headers)))
+                # PERFORMANCE FIX: Use zip() instead of range(len()) for row processing
+                cleaned_row = {clean: row[header_mapping[clean]] for clean in cleaned_headers}
                 csv_data.append(cleaned_row)
 
             return csv_data  # Return a list of dictionaries
@@ -161,9 +160,10 @@ def add_columns(csv_data, column_headers):
     elif not isinstance(column_headers, list):
         raise ValueError("column_headers should be a list or a string")
 
+    # PERFORMANCE FIX: Optimize column initialization to avoid nested loop
     for row in csv_data:
-        for header in column_headers:
-            row[header] = ''  # Initialize the column with empty values
+        # Use dict.update() to set multiple columns at once
+        row.update({header: '' for header in column_headers})
 
 # Extracting the list to a variable for future refactoring:
 def filter_rows(csv_data):
@@ -304,6 +304,17 @@ def NEW_update_insurance_ids(csv_data, config, crosswalk):
     processed_payer_ids = set()  # Track processed Payer IDs
     MediLink_ConfigLoader.log("Starting update of insurance IDs.", level="INFO")
 
+    # PERFORMANCE FIX: Pre-build flattened payer lookup cache to avoid nested dictionary access
+    payer_cache = {}
+    crosswalk_payers = crosswalk.get('payer_id', {})
+    for payer_id, details in crosswalk_payers.items():
+        payer_cache[payer_id] = {
+            'medisoft_id': details.get('medisoft_id', []),
+            'medisoft_medicare_id': details.get('medisoft_medicare_id', []),
+            'endpoint': details.get('endpoint', None)
+        }
+    MediLink_ConfigLoader.log("Built payer cache for {} payers".format(len(payer_cache)), level="DEBUG")
+
     # Load MAINS data to get mapping from Medisoft ID to MAINS names
     insurance_to_id = load_insurance_data_from_mains(config)  # Assuming it returns a dict mapping insurance names to IDs
     MediLink_ConfigLoader.log("Loaded MAINS data for insurance to ID mapping.", level="DEBUG")
@@ -313,7 +324,9 @@ def NEW_update_insurance_ids(csv_data, config, crosswalk):
     for insurance_name, medisoft_id in insurance_to_id.items():
         medisoft_to_mains_names[medisoft_id].append(insurance_name)
 
-    for row in csv_data:
+    for row_idx, row in enumerate(csv_data, 1):
+        # PERFORMANCE FIX: Store row index to avoid O(n) csv_data.index() calls later
+        row['_row_index'] = row_idx
         ins1_payer_id = row.get('Ins1 Payer ID', '').strip()
         MediLink_ConfigLoader.log("Processing row with Ins1 Payer ID: '{}'.".format(ins1_payer_id), level="DEBUG")
         
@@ -323,20 +336,24 @@ def NEW_update_insurance_ids(csv_data, config, crosswalk):
                 processed_payer_ids.add(ins1_payer_id)  # Add to set
                 MediLink_ConfigLoader.log("Marked Payer ID '{}' as processed.".format(ins1_payer_id), level="DEBUG")
                 
-                # Retrieve Medisoft IDs for the current Payer ID
-                medisoft_ids = crosswalk.get('payer_id', {}).get(ins1_payer_id, {}).get('medisoft_id', [])
+                # PERFORMANCE FIX: Use flattened cache instead of nested dictionary lookups
+                payer_info = payer_cache.get(ins1_payer_id, {})
+                medisoft_ids = payer_info.get('medisoft_id', [])
                 MediLink_ConfigLoader.log("Retrieved Medisoft IDs for Payer ID '{}': {}".format(ins1_payer_id, medisoft_ids), level="DEBUG")
 
         if not medisoft_ids:
             MediLink_ConfigLoader.log("No Medisoft IDs available for Payer ID '{}', creating placeholder entry.".format(ins1_payer_id), level="WARNING")
-            # Create a placeholder entry in the crosswalk
-            if 'payer_id' not in crosswalk:
-                crosswalk['payer_id'] = {}
-            crosswalk['payer_id'][ins1_payer_id] = {
+            # Create a placeholder entry in the crosswalk and cache
+            placeholder_entry = {
                 'medisoft_id': [],  # Placeholder for future Medisoft IDs
                 'medisoft_medicare_id': [],  # Placeholder for future Medicare IDs
                 'endpoint': None  # Placeholder for future endpoint
             }
+            if 'payer_id' not in crosswalk:
+                crosswalk['payer_id'] = {}
+            crosswalk['payer_id'][ins1_payer_id] = placeholder_entry
+            # PERFORMANCE FIX: Update cache with placeholder entry
+            payer_cache[ins1_payer_id] = placeholder_entry
             continue  # Skip further processing for this Payer ID
 
         # If only one Medisoft ID is associated, assign it directly
@@ -344,7 +361,9 @@ def NEW_update_insurance_ids(csv_data, config, crosswalk):
             try:
                 medisoft_id = int(medisoft_ids[0])
                 row['Ins1 Insurance ID'] = medisoft_id
-                MediLink_ConfigLoader.log("Assigned Medisoft ID '{}' to row number {} with Payer ID '{}'.".format(medisoft_id, csv_data.index(row) + 1, ins1_payer_id), level="DEBUG")
+                # PERFORMANCE FIX: Use enumerate index instead of csv_data.index() which is O(n)
+                row_number = getattr(row, '_row_index', 'Unknown')
+                MediLink_ConfigLoader.log("Assigned Medisoft ID '{}' to row number {} with Payer ID '{}'.".format(medisoft_id, row_number, ins1_payer_id), level="DEBUG")
             except ValueError as e:
                 MediLink_ConfigLoader.log("Error converting Medisoft ID '{}' to integer for Payer ID '{}': {}".format(medisoft_ids[0], ins1_payer_id, e), level="ERROR")
                 row['Ins1 Insurance ID'] = None
@@ -398,9 +417,10 @@ def update_insurance_ids(csv_data, config, crosswalk):
             payer_id, medisoft_ids, medicare_ids), level="DEBUG")
 
     # PERFORMANCE FIX: Single pass through CSV data with optimized Medicare ID resolution
-    for row in csv_data:
+    for row_idx, row in enumerate(csv_data, 1):
         ins1_payer_id = row.get('Ins1 Payer ID', '').strip()
-        MediLink_ConfigLoader.log("Processing row #{} with Ins1 Payer ID '{}'.".format(csv_data.index(row) + 1, ins1_payer_id), level="DEBUG")
+        # PERFORMANCE FIX: Use enumerate index instead of csv_data.index() which is O(n)
+        MediLink_ConfigLoader.log("Processing row #{} with Ins1 Payer ID '{}'.".format(row_idx, ins1_payer_id), level="DEBUG")
         
         # Try Medicare ID first, then fall back to regular ID (optimized Medicare processing)
         insurance_id = (payer_id_to_medicare.get(ins1_payer_id) or 
@@ -517,19 +537,22 @@ def update_diagnosis_codes(csv_data):
 
         MediLink_ConfigLoader.log("BAD IDEA: Processing DOCX files modified between {} and {}.".format(threshold_start, threshold_end), level="INFO")
 
-        # PERFORMANCE OPTIMIZATION: Use os.scandir() for more efficient file system operations
-        # This reduces the number of file system calls and improves performance with large directories
+        # PERFORMANCE OPTIMIZATION: Batch file system operations with caching
+        # Pre-convert threshold timestamps for efficient comparison (Windows XP compatible)
+        threshold_start_ts = threshold_start.timestamp() if hasattr(threshold_start, 'timestamp') else time.mktime(threshold_start.timetuple())
+        threshold_end_ts = threshold_end.timestamp() if hasattr(threshold_end, 'timestamp') else time.mktime(threshold_end.timetuple())
+        
         valid_files = []
         try:
-            # Use os.scandir() for better performance (XP/3.4.4 compatible)
+            # Use os.scandir() with optimized timestamp comparison (XP/3.4.4 compatible)
             with os.scandir(local_storage_path) as entries:
                 for entry in entries:
                     if entry.name.endswith('.docx'):
                         # Get file modification time in single operation
                         try:
                             stat_info = entry.stat()
-                            mtime = stat_info.st_mtime
-                            if threshold_start <= datetime.fromtimestamp(mtime) <= threshold_end:
+                            # Direct timestamp comparison avoids datetime conversion overhead
+                            if threshold_start_ts <= stat_info.st_mtime <= threshold_end_ts:
                                 valid_files.append(entry.path)
                         except (OSError, ValueError):
                             # Skip files with invalid modification times
@@ -537,6 +560,9 @@ def update_diagnosis_codes(csv_data):
         except OSError:
             MediLink_ConfigLoader.log("Error accessing directory: {}".format(local_storage_path), level="ERROR")
             return
+            
+        # PERFORMANCE OPTIMIZATION: Log file count for debugging without processing overhead
+        MediLink_ConfigLoader.log("Found {} DOCX files within date threshold".format(len(valid_files)), level="INFO")
 
         # PERFORMANCE OPTIMIZATION: Pre-process patient IDs for efficient lookup
         # Create a set of patient IDs from CSV data for faster lookups
@@ -821,13 +847,12 @@ def capitalize_all_fields(csv_data):
     Returns:
     None: The function modifies the csv_data in place.
     """
+    # PERFORMANCE FIX: Optimize uppercase conversion using dict comprehension
     for row in csv_data:
-        for key, value in row.items():
-            if isinstance(value, str):
-                row[key] = value.upper()
-            elif isinstance(value, datetime):
-                # Keep datetime objects as they are
-                pass
-            elif value is not None:
-                # Convert any other non-None values to string and then uppercase
-                row[key] = str(value).upper()
+        # Single-pass update using dict comprehension
+        row.update({
+            key: (value.upper() if isinstance(value, str) 
+                  else str(value).upper() if value is not None and not isinstance(value, datetime)
+                  else value)
+            for key, value in row.items()
+        })

{medicafe-0.250723.5 → medicafe-0.250725.0}/MediBot/MediBot_UI.py

@@ -148,6 +148,8 @@ def display_patient_selection_menu(csv_data, reverse_mapping, proceed_as_medicar
 
     print("-" * 60)
     print("\nDo you want to proceed with the selected patients? (yes/no): ", end='', flush=True)
+    # Small delay for Windows XP console buffer synchronization
+    time.sleep(0.1)
     proceed = input().lower().strip() in ['yes', 'y']
 
     if not proceed:
@@ -158,6 +160,8 @@ def display_patient_selection_menu(csv_data, reverse_mapping, proceed_as_medicar
         while True:
             while True:
                 print("\nEnter the number(s) of the patients you wish to proceed with \n(e.g., 1,3,5): ", end='', flush=True)
+                # Small delay for Windows XP console buffer synchronization
+                time.sleep(0.1)
                 selection = input().strip()
                 if not selection:
                     print("Invalid entry. Please provide at least one number.")
@@ -233,6 +237,8 @@ def handle_user_interaction(interaction_mode, error_message):
         print("4: Exit script")
         print("-" * 60)
         print("Enter your choice (1/2/3/4): ", end='', flush=True)
+        # Small delay for Windows XP console buffer synchronization
+        time.sleep(0.1)
         choice = input().strip()
         
         if choice == '1':
@@ -267,6 +273,8 @@ def user_interaction(csv_data, interaction_mode, error_message, reverse_mapping)
             try:
                 # Use a more explicit prompt format for Windows XP
                 print("\nAm I processing Medicare patients? (yes/no): ", end='', flush=True)
+                # Small delay for Windows XP console buffer synchronization
+                time.sleep(0.1)
                 response = input().lower().strip()
                 if response:
                     if response in ['yes', 'y']:

{medicafe-0.250723.5 → medicafe-0.250725.0}/MediBot/MediBot_dataformat_library.py

@@ -78,14 +78,17 @@ def enforce_significant_length(output):
         # First line of defense: Replace ' APT ' or ' UNIT ' with ' #' if the original length is longer than 30 characters.
         temp_output = temp_output.replace(' APT ', ' #').replace(' UNIT ', ' #')
         
-        # Remove spaces in a controlled manner from right to left if still too long
-        while len(temp_output) > 30:
+        # PERFORMANCE FIX: Remove spaces in a controlled manner from right to left if still too long
+        # Cache length calculation to avoid repeated calls
+        temp_length = len(temp_output)
+        while temp_length > 30:
             # Find the last space
             last_space_index = temp_output.rfind(' ')
             if last_space_index == -1:
                 break
             # Remove the last space
             temp_output = temp_output[:last_space_index] + temp_output[last_space_index+7:]
+            temp_length = len(temp_output)  # Update cached length
 
         # If still greater than 30, truncate to 30 characters
         if len(temp_output) > 30:

{medicafe-0.250723.5 → medicafe-0.250725.0}/MediBot/MediBot_docx_decoder.py

@@ -407,9 +407,11 @@ def reassemble_year(text):
     
     # Handle the less common cases where the year might be split as (1,1,2) or (2,1,1) or (1,2,1)
     parts = _DIGIT_PARTS_PATTERN.findall(text)
-    if len(parts) >= 4:
-        # Early exit: only process if we have enough parts
-        for i in range(len(parts) - 3):
+    parts_len = len(parts)
+    if parts_len >= 4:
+        # PERFORMANCE FIX: Use direct indexing instead of range(len()) pattern
+        max_index = parts_len - 3
+        for i in range(max_index):
             candidate = ''.join(parts[i:i + 4])
             if len(candidate) == 4 and candidate.isdigit():
                 # More efficient pattern construction

{medicafe-0.250723.5 → medicafe-0.250725.0}/MediLink/MediLink_Decoder.py

@@ -204,20 +204,30 @@ def display_table(records):
         print("No records to display.")
         return
 
-    # Determine which fields have at least one non-empty value
-    used_fields = [field for field in new_fieldnames if any(str(record.get(field, '')).strip() for record in records)]
+    # PERFORMANCE FIX: Single-pass optimization - determine used fields and calculate widths in one pass
+    used_fields = []
+    col_widths = {}
+    
+    # First pass: identify used fields and initialize widths
+    for field in new_fieldnames:
+        col_widths[field] = len(field)  # Header width
+        
+    # Second pass: check for used fields and calculate max widths
+    for record in records:
+        for field in new_fieldnames:
+            value_str = str(record.get(field, ''))
+            if value_str.strip() and field not in used_fields:
+                used_fields.append(field)
+            if field in col_widths:
+                col_widths[field] = max(col_widths[field], len(value_str))
+    
+    # Filter col_widths to only used fields
+    col_widths = {field: col_widths[field] for field in used_fields}
 
     if not used_fields:
         print("No data to display.")
         return
 
-    # Calculate column widths based on the longest item in each used column
-    col_widths = {field: len(field) for field in used_fields}
-
-    for record in records:
-        for field in used_fields:
-            col_widths[field] = max(col_widths[field], len(str(record.get(field, ''))))
-
     # Create table header
     header = " | ".join("{:<{}}".format(field, col_widths[field]) for field in used_fields)
     print(header)
@@ -256,20 +266,30 @@ def display_consolidated_records(records):
         print("No valid records to display after filtering empty rows.")
         return
     
-    # Determine which fields have at least one non-empty value
-    used_fields = [field for field in new_fieldnames if any(str(record.get(field, '')).strip() for record in filtered_records)]
+    # PERFORMANCE FIX: Single-pass optimization - determine used fields and calculate widths in one pass
+    used_fields = []
+    col_widths = {}
+    
+    # First pass: initialize column widths with header lengths
+    for field in new_fieldnames:
+        col_widths[field] = len(field)
+        
+    # Second pass: check for used fields and calculate max widths
+    for record in filtered_records:
+        for field in new_fieldnames:
+            value_str = str(record.get(field, ''))
+            if value_str.strip() and field not in used_fields:
+                used_fields.append(field)
+            if field in col_widths:
+                col_widths[field] = max(col_widths[field], len(value_str))
+    
+    # Filter col_widths to only used fields
+    col_widths = {field: col_widths[field] for field in used_fields}
 
     if not used_fields:
         print("No data to display.")
         return
     
-    # Calculate column widths based on the longest item in each used column
-    col_widths = {field: len(field) for field in used_fields}
-    
-    for record in filtered_records:
-        for field in used_fields:
-            col_widths[field] = max(col_widths[field], len(str(record.get(field, ''))))
-    
     # Print header
     header = " | ".join("{:<{}}".format(field, col_widths[field]) for field in used_fields)
     print(header)

{medicafe-0.250723.5 → medicafe-0.250725.0}/MediLink/MediLink_Deductible.py

@@ -725,33 +725,39 @@ if __name__ == "__main__":
                 print(table_header)
                 print("-" * len(table_header))
 
-                # Set to keep track of processed patients
-                processed_patients = set()
-
-                # Loop through each payer_id and patient to call the API, then display the eligibility information
+                # PERFORMANCE FIX: Optimize patient-payer processing to avoid O(P×N) complexity
+                # Instead of nested loops, process each patient once and try payer_ids until success
+                # TODO: We should be able to determine the correct payer_id for each patient ahead of time
+                # by looking up their insurance information from the CSV data or crosswalk mapping.
+                # This would eliminate the need to try multiple payer_ids per patient and make this O(N).
                 errors = []
                 validation_reports = []
-                total_patients = len(patients) * len(payer_ids)
                 processed_count = 0
                 
-                for payer_id in payer_ids:
-                    for dob, member_id in patients:
-                        # Skip if this patient has already been processed
-                        if (dob, member_id) in processed_patients:
-                            continue
+                for dob, member_id in patients:
+                    processed_count += 1
+                    print("Processing patient {}/{}: Member ID {}, DOB {}".format(
+                        processed_count, len(patients), member_id, dob))
+                    
+                    # Try each payer_id for this patient until we get a successful response
+                    patient_processed = False
+                    for payer_id in payer_ids:
                         try:
-                            processed_count += 1
-                            print("Processing patient {}/{}: Member ID {}, DOB {}".format(
-                                processed_count, total_patients, member_id, dob))
-                            
                             # Run with validation enabled only in debug mode
                             run_validation = DEBUG_MODE
                             eligibility_data = get_eligibility_info(client, payer_id, provider_last_name, dob, member_id, npi, run_validation=run_validation)
                             if eligibility_data is not None:
-                                display_eligibility_info(eligibility_data, dob, member_id, output_file)  # Display as we get the result
-                                processed_patients.add((dob, member_id))  # Mark this patient as processed
+                                display_eligibility_info(eligibility_data, dob, member_id, output_file)
+                                patient_processed = True
+                                break  # Stop trying other payer_ids for this patient once we get a response
                         except Exception as e:
-                            errors.append((dob, member_id, str(e)))
+                            # Continue trying other payer_ids
+                            continue
+                    
+                    # If no payer_id worked for this patient, log the error
+                    if not patient_processed:
+                        error_msg = "No successful payer_id found for patient"
+                        errors.append((dob, member_id, error_msg))
 
                 # Display errors if any
                 if errors:

{medicafe-0.250723.5 → medicafe-0.250725.0}/MediLink/MediLink_Parser.py

@@ -1,7 +1,5 @@
 # MediLink_Parser.py
-
 import re
-from collections import defaultdict
 
 # Pre-compile regex patterns for better performance
 _EBT_KEY_VALUE_PATTERN = re.compile(r'([^:]+):\s*(.+?)(?=\s{2,}[^:]+:|$)')

{medicafe-0.250723.5 → medicafe-0.250725.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: medicafe
-Version: 0.250723.5
+Version: 0.250725.0
 Summary: MediCafe
 Home-page: https://github.com/katanada2
 Author: Daniel Vidaud

{medicafe-0.250723.5 → medicafe-0.250725.0}/medicafe.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: medicafe
-Version: 0.250723.5
+Version: 0.250725.0
 Summary: MediCafe
 Home-page: https://github.com/katanada2
 Author: Daniel Vidaud

{medicafe-0.250723.5 → medicafe-0.250725.0}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='medicafe',
-    version="0.250723.5",
+    version="0.250725.0",
     description='MediCafe',
     long_description="""
     # Project Overview: MediCafe