medicafe 0.250723.4__tar.gz → 0.250724.0__tar.gz

{medicafe-0.250723.4 → medicafe-0.250724.0}/MediBot/MediBot.py

@@ -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

{medicafe-0.250723.4 → medicafe-0.250724.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,30 +537,54 @@ def update_diagnosis_codes(csv_data):
 
         MediLink_ConfigLoader.log("BAD IDEA: Processing DOCX files modified between {} and {}.".format(threshold_start, threshold_end), level="INFO")
 
-        # Gather all relevant DOCX files in the specified directory
-        # Optimize by combining file gathering and filtering in one pass
+        # 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:
-            for filename in os.listdir(local_storage_path):
-                if filename.endswith(".docx"):
-                    filepath = os.path.join(local_storage_path, filename)
-                    # Check modification time only once per file
-                    try:
-                        mtime = os.path.getmtime(filepath)
-                        if threshold_start <= datetime.fromtimestamp(mtime) <= threshold_end:
-                            valid_files.append(filepath)
-                    except (OSError, ValueError):
-                        # Skip files with invalid modification times
-                        continue
+            # 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()
+                            # 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
+                            continue
         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
+        patient_ids_in_csv = {row.get('Patient ID', '').strip() for row in csv_data}
+
+        # PERFORMANCE OPTIMIZATION: Pre-convert surgery dates to string format
+        # Convert all surgery dates to string format once to avoid repeated conversions in loops
+        surgery_date_strings = {}
+        for row in csv_data:
+            patient_id = row.get('Patient ID', '').strip()
+            surgery_date = row.get('Surgery Date')
+            if surgery_date != datetime.min:
+                surgery_date_strings[patient_id] = surgery_date.strftime("%m-%d-%Y")
+            else:
+                surgery_date_strings[patient_id] = ''
 
         # Process valid DOCX files
         for filepath in valid_files:
             MediLink_ConfigLoader.log("Processing DOCX file: {}".format(filepath), level="INFO")
             try:
                 patient_data = parse_docx(filepath, surgery_dates)  # Pass surgery_dates to parse_docx
+                # PERFORMANCE OPTIMIZATION: Use defaultdict for more efficient dictionary operations
                 for patient_id, service_dates in patient_data.items():
                     if patient_id not in all_patient_data:
                         all_patient_data[patient_id] = {}
@@ -556,9 +600,6 @@ def update_diagnosis_codes(csv_data):
         # Debug logging for all_patient_data
         MediLink_ConfigLoader.log("All patient data collected from DOCX files: {}".format(all_patient_data), level="DEBUG")
         
-        # Extract patient IDs from csv_data for efficient matching
-        patient_ids_in_csv = {row.get('Patient ID', '').strip() for row in csv_data}
-
         # Check if any patient data was collected
         if not all_patient_data or not patient_ids_in_csv.intersection(all_patient_data.keys()):
             MediLink_ConfigLoader.log("No patient data collected or no matching Patient IDs found. Skipping further processing.", level="INFO")
@@ -570,20 +611,17 @@ def update_diagnosis_codes(csv_data):
         # Initialize counter for updated rows
         updated_count = 0
 
+        # PERFORMANCE OPTIMIZATION: Single pass through CSV data with pre-processed lookups
         # Update the "Default Diagnosis #1" column in the CSV data
         for row_num, row in enumerate(csv_data, start=1):
             patient_id = row.get('Patient ID', '').strip()
+            # Use pre-processed patient ID lookup for efficiency
             if patient_id not in patient_ids_in_csv:
                 continue  # Skip rows that do not match any patient ID
 
             MediLink_ConfigLoader.log("Processing row number {}.".format(row_num), level="DEBUG")
-            surgery_date = row.get('Surgery Date', '')
-
-            # Convert surgery_date to string format for lookup
-            if surgery_date != datetime.min:
-                surgery_date_str = surgery_date.strftime("%m-%d-%Y")
-            else:
-                surgery_date_str = ''
+            # Use pre-converted surgery date string for efficient lookup
+            surgery_date_str = surgery_date_strings.get(patient_id, '')
 
             MediLink_ConfigLoader.log("Patient ID: {}, Surgery Date: {}".format(patient_id, surgery_date_str), level="DEBUG")
 
@@ -809,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.4 → medicafe-0.250724.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.4 → medicafe-0.250724.0}/MediBot/MediBot_docx_decoder.py

@@ -1,7 +1,7 @@
 #MediBot_docx_decoder.py
 from datetime import datetime
 from collections import OrderedDict
-import os, re, sys, zipfile
+import os, re, sys, zipfile, pprint
 from docx import Document
 from lxml import etree
 
@@ -14,6 +14,56 @@ try:
 except ImportError:
     from MediLink import MediLink_ConfigLoader
 
+# Pre-compile regex patterns for better performance (XP/3.4.4 compatible)
+_DIAGNOSIS_CODE_PATTERN = re.compile(r'H\d{2}\.\d+')
+_DAY_WEEK_PATTERN = re.compile(r"(MONDAY|TUESDAY|WEDNESDAY|THURSDAY|FRIDAY|SATURDAY|SUNDAY)")
+_MONTH_DAY_PATTERN = re.compile(r"(JANUARY|FEBRUARY|MARCH|APRIL|MAY|JUNE|JULY|AUGUST|SEPTEMBER|OCTOBER|NOVEMBER|DECEMBER) \d{1,2}")
+_YEAR_PATTERN = re.compile(r"\d{4}")
+_YEAR_SPLIT_PATTERNS = [
+    re.compile(r'(\d{3}) (\d{1})'),
+    re.compile(r'(\d{1}) (\d{3})'),
+    re.compile(r'(\d{2}) (\d{2})')
+]
+_DIGIT_PARTS_PATTERN = re.compile(r'\b(\d{1,2})\b')
+_COMMA_PATTERN = re.compile(r',')
+
+# Pre-compile abbreviation patterns for normalize_text optimization
+_MONTH_ABBR_PATTERNS = {
+    'JAN': re.compile(r'\bJAN\b', re.IGNORECASE),
+    'FEB': re.compile(r'\bFEB\b', re.IGNORECASE),
+    'MAR': re.compile(r'\bMAR\b', re.IGNORECASE),
+    'APR': re.compile(r'\bAPR\b', re.IGNORECASE),
+    'MAY': re.compile(r'\bMAY\b', re.IGNORECASE),
+    'JUN': re.compile(r'\bJUN\b', re.IGNORECASE),
+    'JUL': re.compile(r'\bJUL\b', re.IGNORECASE),
+    'AUG': re.compile(r'\bAUG\b', re.IGNORECASE),
+    'SEP': re.compile(r'\bSEP\b', re.IGNORECASE),
+    'OCT': re.compile(r'\bOCT\b', re.IGNORECASE),
+    'NOV': re.compile(r'\bNOV\b', re.IGNORECASE),
+    'DEC': re.compile(r'\bDEC\b', re.IGNORECASE)
+}
+
+_DAY_ABBR_PATTERNS = {
+    'MON': re.compile(r'\bMON\b', re.IGNORECASE),
+    'TUE': re.compile(r'\bTUE\b', re.IGNORECASE),
+    'WED': re.compile(r'\bWED\b', re.IGNORECASE),
+    'THU': re.compile(r'\bTHU\b', re.IGNORECASE),
+    'FRI': re.compile(r'\bFRI\b', re.IGNORECASE),
+    'SAT': re.compile(r'\bSAT\b', re.IGNORECASE),
+    'SUN': re.compile(r'\bSUN\b', re.IGNORECASE)
+}
+
+# Month and day mapping dictionaries
+_MONTH_MAP = {
+    'JAN': 'JANUARY', 'FEB': 'FEBRUARY', 'MAR': 'MARCH', 'APR': 'APRIL', 
+    'MAY': 'MAY', 'JUN': 'JUNE', 'JUL': 'JULY', 'AUG': 'AUGUST', 
+    'SEP': 'SEPTEMBER', 'OCT': 'OCTOBER', 'NOV': 'NOVEMBER', 'DEC': 'DECEMBER'
+}
+_DAY_MAP = {
+    'MON': 'MONDAY', 'TUE': 'TUESDAY', 'WED': 'WEDNESDAY', 'THU': 'THURSDAY', 
+    'FRI': 'FRIDAY', 'SAT': 'SATURDAY', 'SUN': 'SUNDAY'
+}
+
 
 def parse_docx(filepath, surgery_dates):  # Accept surgery_dates as a parameter
     try:
@@ -186,10 +236,15 @@ def find_text_in_xml(extract_dir, target_text):
                     root = tree.getroot()
                     namespaces = root.nsmap
                     MediLink_ConfigLoader.log("Processing file: {}".format(file_path), level="DEBUG")
+                    # More efficient: collect all text first, then search
+                    all_text = []
                     for elem in root.xpath('//w:t', namespaces=namespaces):
-                        if elem.text and target_pattern.search(elem.text):
-                            MediLink_ConfigLoader.log("Found target text '{}' in file: {}".format(target_text, file_path), level="DEBUG")
-                            return file_path
+                        if elem.text:
+                            all_text.append(elem.text)
+                    combined_text = ' '.join(all_text)
+                    if target_pattern.search(combined_text):
+                        MediLink_ConfigLoader.log("Found target text '{}' in file: {}".format(target_text, file_path), level="DEBUG")
+                        return file_path
                 except etree.XMLSyntaxError as e:
                     MediLink_ConfigLoader.log("XMLSyntaxError parsing file {}: {}".format(file_path, e), level="ERROR")
                 except Exception as e:
@@ -211,18 +266,14 @@ def extract_date_from_file(file_path):
         combined_text = ' '.join(collected_text)
         combined_text = reassemble_year(combined_text)  # Fix OCR splitting years
         combined_text = normalize_text(combined_text)  # Normalize abbreviations
-        combined_text = re.sub(r',', '', combined_text)  # Remove commas if they exist
+        combined_text = _COMMA_PATTERN.sub('', combined_text)  # Remove commas if they exist
 
         # Log the combined text
         MediLink_ConfigLoader.log("Combined text from file '{}': {}".format(file_path, combined_text[:200]), level="DEBUG")
         
-        day_week_pattern = r"(MONDAY|TUESDAY|WEDNESDAY|THURSDAY|FRIDAY|SATURDAY|SUNDAY)"
-        month_day_pattern = r"(JANUARY|FEBRUARY|MARCH|APRIL|MAY|JUNE|JULY|AUGUST|SEPTEMBER|OCTOBER|NOVEMBER|DECEMBER) \d{1,2}"
-        year_pattern = r"\d{4}"
-
-        day_of_week = re.search(day_week_pattern, combined_text, re.IGNORECASE)
-        month_day = re.search(month_day_pattern, combined_text, re.IGNORECASE)
-        year_match = re.search(year_pattern, combined_text, re.IGNORECASE)
+        day_of_week = _DAY_WEEK_PATTERN.search(combined_text, re.IGNORECASE)
+        month_day = _MONTH_DAY_PATTERN.search(combined_text, re.IGNORECASE)
+        year_match = _YEAR_PATTERN.search(combined_text, re.IGNORECASE)
 
         # Log the results of the regex searches
         MediLink_ConfigLoader.log("Day of week found: {}".format(day_of_week.group() if day_of_week else 'None'), level="DEBUG")
@@ -276,18 +327,14 @@ def extract_date_from_content(xml_content):
         combined_text = ' '.join(collected_text)
         combined_text = reassemble_year(combined_text)  # Fix OCR splitting years
         combined_text = normalize_text(combined_text)    # Normalize abbreviations
-        combined_text = re.sub(r',', '', combined_text)   # Remove commas if they exist
+        combined_text = _COMMA_PATTERN.sub('', combined_text)   # Remove commas if they exist
 
         # Log the combined text
         MediLink_ConfigLoader.log("Combined text: {}".format(combined_text[:200]), level="DEBUG")  # Log first 200 characters
 
-        day_week_pattern = r"(MONDAY|TUESDAY|WEDNESDAY|THURSDAY|FRIDAY|SATURDAY|SUNDAY)"
-        month_day_pattern = r"(JANUARY|FEBRUARY|MARCH|APRIL|MAY|JUNE|JULY|AUGUST|SEPTEMBER|OCTOBER|NOVEMBER|DECEMBER) \d{1,2}"
-        year_pattern = r"\d{4}"
-
-        day_of_week = re.search(day_week_pattern, combined_text, re.IGNORECASE)
-        month_day = re.search(month_day_pattern, combined_text, re.IGNORECASE)
-        year_match = re.search(year_pattern, combined_text, re.IGNORECASE)
+        day_of_week = _DAY_WEEK_PATTERN.search(combined_text, re.IGNORECASE)
+        month_day = _MONTH_DAY_PATTERN.search(combined_text, re.IGNORECASE)
+        year_match = _YEAR_PATTERN.search(combined_text, re.IGNORECASE)
 
         MediLink_ConfigLoader.log("Day of week found: {}".format(day_of_week.group() if day_of_week else 'None'), level="DEBUG")
         MediLink_ConfigLoader.log("Month and day found: {}".format(month_day.group() if month_day else 'None'), level="DEBUG")
@@ -342,40 +389,36 @@ def remove_directory(path):
 
 
 def normalize_text(text):
-    month_map = {
-        'JAN': 'JANUARY', 'FEB': 'FEBRUARY', 'MAR': 'MARCH', 'APR': 'APRIL', 
-        'MAY': 'MAY', 'JUN': 'JUNE', 'JUL': 'JULY', 'AUG': 'AUGUST', 
-        'SEP': 'SEPTEMBER', 'OCT': 'OCTOBER', 'NOV': 'NOVEMBER', 'DEC': 'DECEMBER'
-    }
-    day_map = {
-        'MON': 'MONDAY', 'TUE': 'TUESDAY', 'WED': 'WEDNESDAY', 'THU': 'THURSDAY', 
-        'FRI': 'FRIDAY', 'SAT': 'SATURDAY', 'SUN': 'SUNDAY'
-    }
-    
-    for abbr, full in month_map.items():
-        text = re.sub(r'\b' + abbr + r'\b', full, text, flags=re.IGNORECASE)
-    for abbr, full in day_map.items():
-        text = re.sub(r'\b' + abbr + r'\b', full, text, flags=re.IGNORECASE)
+    # Optimized single-pass processing to avoid O(n²) complexity
+    # Process all abbreviations in one pass instead of multiple regex calls
+    for abbr, pattern in _MONTH_ABBR_PATTERNS.items():
+        text = pattern.sub(_MONTH_MAP[abbr], text)
+    for abbr, pattern in _DAY_ABBR_PATTERNS.items():
+        text = pattern.sub(_DAY_MAP[abbr], text)
     
     return text
 
 
 def reassemble_year(text):
-    # First, handle the most common case where a 4-digit year is split as (3,1), (1,3), or (2,2)
-    text = re.sub(r'(\d{3}) (\d{1})', r'\1\2', text)
-    text = re.sub(r'(\d{1}) (\d{3})', r'\1\2', text)
-    text = re.sub(r'(\d{2}) (\d{2})', r'\1\2', text)
+    # Optimized year reassembly with early exit conditions
+    # First, handle the most common cases with pre-compiled patterns
+    for pattern in _YEAR_SPLIT_PATTERNS:
+        text = pattern.sub(r'\1\2', 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 = re.findall(r'\b(\d{1,2})\b', text)
-    if len(parts) >= 4:
-        for i in range(len(parts) - 3):
+    parts = _DIGIT_PARTS_PATTERN.findall(text)
+    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():
-                combined_year = candidate
-                pattern = r'\b' + r'\s+'.join(parts[i:i + 4]) + r'\b'
-                text = re.sub(pattern, combined_year, text)
-                break
+                # More efficient pattern construction
+                pattern_parts = [r'\b' + part + r'\b' for part in parts[i:i + 4]]
+                pattern = r'\s+'.join(pattern_parts)
+                text = re.sub(pattern, candidate, text)
+                break  # Early exit after first successful combination
     
     return text
 
@@ -390,9 +433,8 @@ def parse_patient_id(text):
 
 def parse_diagnosis_code(text):
     try:
-        # Regular expression to find all ICD-10 codes starting with 'H' and containing a period
-        pattern = re.compile(r'H\d{2}\.\d+')
-        matches = pattern.findall(text)
+        # Use pre-compiled pattern for better performance
+        matches = _DIAGNOSIS_CODE_PATTERN.findall(text)
         
         if matches:
             return matches[0]  # Return the first match
@@ -432,27 +474,72 @@ def parse_femto_yes_or_no(text):
         return False
 
 
-def rotate_docx_files(directory):
-    # List all files in the directory
-    files = os.listdir(directory)
+def rotate_docx_files(directory, surgery_dates=None):
+    """
+    Process all DOCX files in the specified directory that contain "DR" and "SS" in their filename.
+    
+    Parameters:
+    - directory (str): Path to the directory containing DOCX files
+    - surgery_dates (set, optional): Set of surgery dates to filter by. If None, processes all files.
+    
+    Returns:
+    - dict: Combined patient data from all processed files
+    """
+    # 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
+    valid_files = []
+    try:
+        # Use os.scandir() for better performance (XP/3.4.4 compatible)
+        with os.scandir(directory) as entries:
+            for entry in entries:
+                # Filter files that contain "DR" and "SS" in the filename
+                if (entry.name.endswith('.docx') and 
+                    "DR" in entry.name and 
+                    "SS" in entry.name):
+                    valid_files.append(entry.path)
+    except OSError as e:
+        print("Error accessing directory '{}': {}".format(directory, e))
+        return {}
 
-    # Filter files that contain "DR" and "SS" in the filename
-    filtered_files = [file for file in files if "DR" in file and "SS" in file]
+    if not valid_files:
+        print("No valid DOCX files found in directory: {}".format(directory))
+        return {}
+
+    # Initialize combined patient data dictionary
+    combined_patient_data = {}
+    
+    # Process each valid DOCX file
+    for filepath in valid_files:
+        filename = os.path.basename(filepath)  # Extract filename for display
+        print("Processing file: {}".format(filename))
+        
+        try:
+            # Parse the document with surgery_dates parameter
+            patient_data_dict = parse_docx(filepath, surgery_dates or set())
+            
+            # Combine patient data from this file with overall results
+            for patient_id, service_dates in patient_data_dict.items():
+                if patient_id not in combined_patient_data:
+                    combined_patient_data[patient_id] = {}
+                combined_patient_data[patient_id].update(service_dates)
+            
+            # Print results for this file
+            print("Data from file '{}':".format(filename))
+            pprint.pprint(patient_data_dict)
+            print()
+            
+        except Exception as e:
+            print("Error processing file '{}': {}".format(filename, e))
+            MediLink_ConfigLoader.log("Error processing DOCX file '{}': {}".format(filepath, e), level="ERROR")
+            continue  # Continue with next file instead of crashing
 
-    # Iterate through filtered files
-    for filename in filtered_files:
-        filepath = os.path.join(directory, filename)
-        # Parse each document and print the resulting dictionary
-        patient_data_dict = parse_docx(filepath)
-        print("Data from file '{}':".format(filename))
-        import pprint
-        pprint.pprint(patient_data_dict)
-        print()
+    return combined_patient_data
 
 
 def main():
     # Call the function with the directory containing your .docx files
     directory = "C:\\Users\\danie\\Downloads\\"
+    # Note: surgery_dates parameter is now optional
     rotate_docx_files(directory)
 
 

{medicafe-0.250723.4 → medicafe-0.250724.0}/MediLink/MediLink_API_v3.py

@@ -640,6 +640,13 @@ def submit_uhc_claim(client, x12_request_data):
     it returns a simulated response. If Test Mode is not enabled, it submits the claim and then retrieves 
     the claim acknowledgement details using the transaction ID from the initial response.
 
+    NOTE: This function uses endpoints that may not be available in the new swagger version:
+    - /Claims/api/claim-submission/v1 (claim submission)
+    - /Claims/api/claim-details/v1 (claim acknowledgement)
+    
+    If these endpoints are deprecated in the new swagger, this function will need to be updated
+    to use the new available endpoints.
+
     :param client: An instance of APIClient
     :param x12_request_data: The x12 837p data as a string
     :return: The final response containing the claim acknowledgement details or a dummy response if in Test Mode

{medicafe-0.250723.4 → medicafe-0.250724.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.4 → medicafe-0.250724.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.4 → medicafe-0.250724.0}/MediLink/MediLink_Parser.py

@@ -1,10 +1,14 @@
 # MediLink_Parser.py
-
 import re
 
+# Pre-compile regex patterns for better performance
+_EBT_KEY_VALUE_PATTERN = re.compile(r'([^:]+):\s*(.+?)(?=\s{2,}[^:]+:|$)')
+_ERA_SEGMENT_PATTERN = re.compile(r'\*')
+_277_SEGMENT_PATTERN = re.compile(r'\*')
+
 def parse_era_content(content, debug=False):
     extracted_data = []
-    normalized_content = content.replace('~\n', '~')
+    normalized_content = content.replace('~\n', '~')  # Normalize line endings
     lines = normalized_content.split('~')
 
     record = {}
@@ -13,25 +17,27 @@ def parse_era_content(content, debug=False):
     is_payer_section = False
 
     for line in lines:
-        segments = line.split('*')
+        segments = _ERA_SEGMENT_PATTERN.split(line)
 
         if segments[0] == 'TRN' and len(segments) > 2:
-            check_eft = segments[2]
+            check_eft = segments[2]  # Extract check/EFT number
 
         if segments[0] == 'N1':
             if segments[1] == 'PR':
-                is_payer_section = True
+                is_payer_section = True  # Enter payer section
             elif segments[1] == 'PE':
-                is_payer_section = False
+                is_payer_section = False  # Exit payer section
 
         if is_payer_section and segments[0] == 'N3' and len(segments) > 1:
-            payer_address = segments[1]
+            payer_address = segments[1]  # Extract payer address
 
         if segments[0] == 'CLP' and len(segments) >= 5:
             if record:
+                # Calculate adjustment amount if not explicitly provided
                 if adjustment_amount == 0 and (write_off > 0 or patient_responsibility > 0):
                     adjustment_amount = write_off + patient_responsibility
 
+                # Update record with calculated amounts
                 record.update({
                     'Payer Address': payer_address,
                     'Allowed Amount': allowed_amount,
@@ -41,8 +47,10 @@ def parse_era_content(content, debug=False):
                 })
                 extracted_data.append(record)
 
+                # Reset counters for next record
                 allowed_amount, write_off, patient_responsibility, adjustment_amount = 0, 0, 0, 0
 
+            # Start new record
             record = {
                 'Check EFT': check_eft,
                 'Chart Number': segments[1],
@@ -52,19 +60,28 @@ def parse_era_content(content, debug=False):
             }
 
         elif segments[0] == 'CAS':
-            if segments[1] == 'CO':
-                write_off += float(segments[3])
-            elif segments[1] == 'PR':
-                patient_responsibility += float(segments[3])
-            elif segments[1] == 'OA':
-                adjustment_amount += float(segments[3])
+            try:
+                if segments[1] == 'CO':
+                    write_off += float(segments[3])  # Contractual obligation
+                elif segments[1] == 'PR':
+                    patient_responsibility += float(segments[3])  # Patient responsibility
+                elif segments[1] == 'OA':
+                    adjustment_amount += float(segments[3])  # Other adjustments
+            except (ValueError, IndexError):
+                # Skip malformed CAS segments
+                continue
 
         elif segments[0] == 'AMT' and segments[1] == 'B6':
-            allowed_amount += float(segments[2])
+            try:
+                allowed_amount += float(segments[2])  # Allowed amount
+            except (ValueError, IndexError):
+                # Skip malformed AMT segments
+                continue
 
         elif segments[0] == 'DTM' and (segments[1] == '232' or segments[1] == '472'):
-            record['Date of Service'] = segments[2]
+            record['Date of Service'] = segments[2]  # Service date
 
+    # Process final record
     if record:
         if adjustment_amount == 0 and (write_off > 0 or patient_responsibility > 0):
             adjustment_amount = write_off + patient_responsibility
@@ -87,36 +104,36 @@ def parse_277_content(content, debug=False):
     segments = content.split('~')
     records = []
     current_record = {}
+    
     for segment in segments:
-        parts = segment.split('*')
+        parts = _277_SEGMENT_PATTERN.split(segment)
         if parts[0] == 'HL':
             if current_record:
-                records.append(current_record)
-                current_record = {}
+                records.append(current_record)  # Save completed record
+                current_record = {}  # Start new record
         elif parts[0] == 'NM1':
-            if parts[1] == 'QC':
-                current_record['Patient'] = parts[3] + ' ' + parts[4]
-            elif parts[1] == '41':
-                current_record['Clearing House'] = parts[3]
-            elif parts[1] == 'PR':
-                current_record['Payer'] = parts[3]
-        elif parts[0] == 'TRN':
-            current_record['Claim #'] = parts[2]
-        elif parts[0] == 'STC':
-            current_record['Status'] = parts[1]
+            if parts[1] == 'QC' and len(parts) > 4:
+                current_record['Patient'] = ' '.join([parts[3], parts[4]])  # Patient name
+            elif parts[1] == '41' and len(parts) > 3:
+                current_record['Clearing House'] = parts[3]  # Clearing house
+            elif parts[1] == 'PR' and len(parts) > 3:
+                current_record['Payer'] = parts[3]  # Payer name
+        elif parts[0] == 'TRN' and len(parts) > 2:
+            current_record['Claim #'] = parts[2]  # Claim number
+        elif parts[0] == 'STC' and len(parts) > 1:
+            current_record['Status'] = parts[1]  # Claim status
             if len(parts) > 4:
-                current_record['Paid'] = parts[4]
-        elif parts[0] == 'DTP':
+                current_record['Paid'] = parts[4]  # Paid amount
+        elif parts[0] == 'DTP' and len(parts) > 3:
             if parts[1] == '472':
-                current_record['Serv.'] = parts[3]
+                current_record['Serv.'] = parts[3]  # Service date
             elif parts[1] == '050':
-                current_record['Proc.'] = parts[3]
-        elif parts[0] == 'AMT':
-            if parts[1] == 'YU':
-                current_record['Charged'] = parts[2]
+                current_record['Proc.'] = parts[3]  # Process date
+        elif parts[0] == 'AMT' and parts[1] == 'YU' and len(parts) > 2:
+            current_record['Charged'] = parts[2]  # Charged amount
 
     if current_record:
-        records.append(current_record)
+        records.append(current_record)  # Add final record
 
     if debug:
         print("Parsed 277 Content:")
@@ -135,17 +152,22 @@ def parse_dpt_content(content, debug=False):
     extracted_data = []
     lines = content.splitlines()
     record = {}
+    
     for line in lines:
         if 'Patient Account Number:' in line:
             if record:
-                extracted_data.append(record)
-            record = {}
-        parts = line.split(':')
-        if len(parts) == 2:
-            key, value = parts[0].strip(), parts[1].strip()
-            record[key] = value
+                extracted_data.append(record)  # Save completed record
+            record = {}  # Start new record
+        
+        # More efficient split - only split on first occurrence
+        colon_pos = line.find(':')
+        if colon_pos != -1:
+            key = line[:colon_pos].strip()
+            value = line[colon_pos + 1:].strip()
+            record[key] = value  # Add key-value pair to current record
+    
     if record:
-        extracted_data.append(record)
+        extracted_data.append(record)  # Add final record
 
     if debug:
         print("Parsed DPT Content:")
@@ -158,10 +180,7 @@ def parse_ebt_content(content, debug=False):
     extracted_data = []  # List to hold all extracted records
     lines = content.splitlines()  # Split the content into individual lines
     record = {}  # Dictionary to hold the current record being processed
-
-    # Regular expression pattern to match key-value pairs in the format "Key: Value"
-    key_value_pattern = re.compile(r'([^:]+):\s*(.+?)(?=\s{2,}[^:]+?:|$)')
-
+    
     for line in lines:
         # Check for the start of a new record based on the presence of 'Patient Name'
         if 'Patient Name:' in line and record:
@@ -170,7 +189,7 @@ def parse_ebt_content(content, debug=False):
             record = {}  # Reset the record for the next entry
 
         # Find all key-value pairs in the current line
-        matches = key_value_pattern.findall(line)
+        matches = _EBT_KEY_VALUE_PATTERN.findall(line)
         for key, value in matches:
             key = key.strip()  # Remove leading/trailing whitespace from the key
             value = value.strip()  # Remove leading/trailing whitespace from the value
@@ -200,17 +219,22 @@ def parse_ibt_content(content, debug=False):
     extracted_data = []
     lines = content.splitlines()
     record = {}
+    
     for line in lines:
         if 'Submitter Batch ID:' in line:
             if record:
-                extracted_data.append(record)
-            record = {}
-        parts = line.split(':')
-        if len(parts) == 2:
-            key, value = parts[0].strip(), parts[1].strip()
-            record[key] = value
+                extracted_data.append(record)  # Save completed record
+            record = {}  # Start new record
+        
+        # More efficient split - only split on first occurrence
+        colon_pos = line.find(':')
+        if colon_pos != -1:
+            key = line[:colon_pos].strip()
+            value = line[colon_pos + 1:].strip()
+            record[key] = value  # Add key-value pair to current record
+    
     if record:
-        extracted_data.append(record)
+        extracted_data.append(record)  # Add final record
 
     if debug:
         print("Parsed IBT Content:")

{medicafe-0.250723.4 → medicafe-0.250724.0}/PKG-INFO

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

{medicafe-0.250723.4 → medicafe-0.250724.0}/medicafe.egg-info/PKG-INFO

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

{medicafe-0.250723.4 → medicafe-0.250724.0}/setup.py

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