medicafe 0.250814.3__py3-none-any.whl → 0.250816.0__py3-none-any.whl

MediBot/MediBot.py

@@ -11,6 +11,56 @@ try:
 except ImportError:
     msvcrt = None  # Not available on non-Windows systems
 from collections import OrderedDict
+from datetime import datetime # Added for primary surgery date logic
+
+# ============================================================================
+# MINIMAL PROTECTION: Import State Validation
+# ============================================================================
+
+def validate_critical_imports():
+    """Validate that critical imports are in expected state before proceeding"""
+    critical_modules = {
+        'MediBot_Preprocessor': None,
+        'MediBot_Preprocessor_lib': None,
+        'MediBot_UI': None,
+        'MediBot_Crosswalk_Library': None
+    }
+    
+    # Test imports and capture state
+    try:
+        print("Testing MediCafe.core_utils import...")
+        from MediCafe.core_utils import import_medibot_module_with_debug
+        print("MediCafe.core_utils import successful")
+        
+        for module_name in critical_modules.keys():
+            print("Testing {} import...".format(module_name))
+            try:
+                module = import_medibot_module_with_debug(module_name)
+                critical_modules[module_name] = module
+                if module is None:
+                    print("  WARNING: {} import returned None".format(module_name))
+                else:
+                    print("  SUCCESS: {} import successful".format(module_name))
+            except Exception as e:
+                print("  ERROR: {} import failed with exception: {}".format(module_name, e))
+                critical_modules[module_name] = None
+    except Exception as e:
+        print("CRITICAL: Failed to import core utilities: {}".format(e))
+        return False, critical_modules
+    
+    # Check for None imports (the specific failure pattern)
+    failed_imports = []
+    for module_name, module in critical_modules.items():
+        if module is None:
+            failed_imports.append(module_name)
+    
+    if failed_imports:
+        print("CRITICAL: Import failures detected:")
+        for failed in failed_imports:
+            print("  - {}: Import returned None".format(failed))
+        return False, critical_modules
+    
+    return True, critical_modules
 
 # Use core utilities for standardized imports
 from MediCafe.core_utils import (
@@ -122,6 +172,68 @@ 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))
 
+def create_patient_entries_from_row(row, reverse_mapping):
+    """
+    Helper function to create patient entries from a row with surgery date handling.
+    
+    Args:
+        row: The CSV row containing patient data
+        reverse_mapping: The reverse mapping for field lookups
+        
+    Returns:
+        list: List of tuples (surgery_date, patient_name, patient_id, diagnosis_code, row)
+    """
+    patient_id = row.get(reverse_mapping['Patient ID #2'])
+    patient_name = row.get(reverse_mapping['Patient Name'])
+    
+    # Get all surgery dates for this patient
+    all_surgery_dates = row.get('_all_surgery_dates', [row.get('Surgery Date')])
+    surgery_date_to_diagnosis = row.get('_surgery_date_to_diagnosis', {})
+    
+    patient_entries = []
+    
+    # Sort surgery dates chronologically to ensure proper ordering
+    sorted_surgery_dates = []
+    for surgery_date in all_surgery_dates:
+        try:
+            if hasattr(surgery_date, 'strftime'):
+                # Already a datetime object
+                sorted_surgery_dates.append(surgery_date)
+            elif isinstance(surgery_date, str):
+                # Convert string to datetime for sorting
+                surgery_date_dt = datetime.strptime(surgery_date, '%m-%d-%Y')
+                sorted_surgery_dates.append(surgery_date_dt)
+            else:
+                # Fallback - use as is
+                sorted_surgery_dates.append(surgery_date)
+        except (ValueError, TypeError):
+            # If parsing fails, use the original value
+            sorted_surgery_dates.append(surgery_date)
+    
+    # Sort the dates chronologically
+    sorted_surgery_dates.sort()
+    
+    # Create entries for each surgery date in chronological order
+    # The enhanced table display will group by patient_id and show dashed lines for secondary dates
+    for surgery_date in sorted_surgery_dates:
+        try:
+            if hasattr(surgery_date, 'strftime'):
+                surgery_date_str = surgery_date.strftime('%m-%d-%Y')
+            elif isinstance(surgery_date, str):
+                surgery_date_str = surgery_date
+            else:
+                surgery_date_str = str(surgery_date)
+        except Exception:
+            surgery_date_str = str(surgery_date)
+        
+        # Get the diagnosis code for this surgery date
+        diagnosis_code = surgery_date_to_diagnosis.get(surgery_date_str, 'N/A')
+        
+        # Add entry for this surgery date
+        patient_entries.append((surgery_date, patient_name, patient_id, diagnosis_code, row))
+    
+    return patient_entries
+
 # Global flag to control AHK execution method - set to True to use optimized stdin method
 USE_AHK_STDIN_OPTIMIZATION = True
 
@@ -512,6 +624,19 @@ if __name__ == "__main__":
     try:
         if PERFORMANCE_LOGGING:
             print("Initializing. Loading configuration and preparing environment...")
+        
+        # PROTECTION: Validate critical imports before proceeding
+        print("Validating critical imports...")
+        import_valid, import_state = validate_critical_imports()
+        if not import_valid:
+            print("CRITICAL: Import validation failed. Cannot continue.")
+            print("This indicates a fundamental system configuration issue.")
+            print("Please check:")
+            print("  1. All MediBot modules exist in the MediBot directory")
+            print("  2. Python path is correctly configured")
+            print("  3. No syntax errors in MediBot modules")
+            sys.exit(1)
+        
         # Use MediCafe configuration system
         try:
             config_loader = get_config_loader_with_fallback()
@@ -553,6 +678,22 @@ if __name__ == "__main__":
             print("Starting CSV preprocessing at: {}".format(time.strftime("%H:%M:%S")))
         MediLink_ConfigLoader.log("Starting CSV preprocessing at: {}".format(time.strftime("%H:%M:%S")), level="INFO")
         
+        # PROTECTION: Validate MediBot_Preprocessor before calling preprocess_csv_data
+        if MediBot_Preprocessor is None:
+            print("CRITICAL: MediBot_Preprocessor is None when trying to call preprocess_csv_data")
+            print("This indicates the import failed silently during execution.")
+            print("Import state at failure:")
+            for module_name, module in import_state.items():
+                status = "None" if module is None else "OK"
+                print("  - {}: {}".format(module_name, status))
+            print("Please check for syntax errors or missing dependencies in MediBot modules.")
+            sys.exit(1)
+        
+        if not hasattr(MediBot_Preprocessor, 'preprocess_csv_data'):
+            print("CRITICAL: MediBot_Preprocessor missing preprocess_csv_data function")
+            print("Available functions: {}".format([attr for attr in dir(MediBot_Preprocessor) if not attr.startswith('_')]))
+            sys.exit(1)
+        
         MediBot_Preprocessor.preprocess_csv_data(csv_data, e_state.crosswalk)  
         
         # TIMING: End CSV preprocessing timing
@@ -617,14 +758,9 @@ if __name__ == "__main__":
                         if patient_row is None:
                             raise ValueError("Patient row not found for patient ID: {}".format(patient_id))
                         
-                        # Get all surgery dates for this patient
-                        all_surgery_dates = patient_row.get('_all_surgery_dates', [patient_row.get('Surgery Date')])
-                        surgery_date_to_diagnosis = patient_row.get('_surgery_date_to_diagnosis', {})
-                        
-                        # Create entries for each surgery date with its specific diagnosis code
-                        for surgery_date in all_surgery_dates:
-                            diagnosis_code = surgery_date_to_diagnosis.get(surgery_date, 'N/A')
-                            patient_info.append((surgery_date, patient_name, patient_id, diagnosis_code, patient_row))
+                        # Use helper function to create patient entries
+                        patient_entries = create_patient_entries_from_row(patient_row, reverse_mapping)
+                        patient_info.extend(patient_entries)
                             
                     except Exception as e:
                         MediLink_ConfigLoader.log("Warning: Error retrieving data for patient ID '{}': {}".format(patient_id, e), level="WARNING")
@@ -646,17 +782,9 @@ if __name__ == "__main__":
                 # Collect surgery dates and patient info for NEW patients
                 new_patient_info = []
                 for row in csv_data:
-                    patient_id = row.get(reverse_mapping['Patient ID #2'])
-                    patient_name = row.get(reverse_mapping['Patient Name'])
-                    
-                    # Get all surgery dates for this patient
-                    all_surgery_dates = row.get('_all_surgery_dates', [row.get('Surgery Date')])
-                    surgery_date_to_diagnosis = row.get('_surgery_date_to_diagnosis', {})
-                    
-                    # Create entries for each surgery date with its specific diagnosis code
-                    for surgery_date in all_surgery_dates:
-                        diagnosis_code = surgery_date_to_diagnosis.get(surgery_date, 'N/A')
-                        new_patient_info.append((surgery_date, patient_name, patient_id, diagnosis_code, row))
+                    # Use helper function to create patient entries
+                    patient_entries = create_patient_entries_from_row(row, reverse_mapping)
+                    new_patient_info.extend(patient_entries)
 
                 # Display new patients table using the enhanced display function
                 MediBot_UI.display_enhanced_patient_table(
@@ -695,7 +823,41 @@ if __name__ == "__main__":
         if e_state:
             interaction_mode = 'error'  # Switch to error mode
             error_message = str(e)  # Capture the error message
-        print("An error occurred while running MediBot: {}".format(e))
+        
+        # ENHANCED ERROR DIAGNOSTICS
+        print("=" * 60)
+        print("MEDIBOT EXECUTION FAILURE")
+        print("=" * 60)
+        print("Error: {}".format(e))
+        print("Error type: {}".format(type(e).__name__))
+        
+        # Check for the specific failure pattern
+        if "'NoneType' object has no attribute" in str(e):
+            print("DIAGNOSIS: This is the import failure pattern.")
+            print("A module import returned None, causing a method call to fail.")
+            print("This typically indicates:")
+            print("  1. Syntax error in a MediBot module")
+            print("  2. Missing dependency")
+            print("  3. Import path issue")
+            print("  4. Circular import problem")
+            
+            # Show current import state
+            print("Current import state:")
+            try:
+                import_state = {
+                    'MediBot_Preprocessor': MediBot_Preprocessor,
+                    'MediBot_Preprocessor_lib': MediBot_Preprocessor_lib,
+                    'MediBot_UI': MediBot_UI,
+                    'MediBot_Crosswalk_Library': MediBot_Crosswalk_Library
+                }
+                for module_name, module in import_state.items():
+                    status = "None" if module is None else "OK"
+                    print("  - {}: {}".format(module_name, status))
+            except Exception as diag_e:
+                print("  - Unable to diagnose import state: {}".format(diag_e))
+        
+        print("=" * 60)
+        
         # Handle the error by calling user interaction with the error information
         if 'identified_fields' in locals():
             _ = user_interaction(csv_data, interaction_mode, error_message, reverse_mapping)

MediBot/MediBot_Preprocessor_lib.py

@@ -531,17 +531,41 @@ def sort_and_deduplicate(csv_data):
             existing_row = unique_patients[patient_id]
             existing_date = existing_row['Surgery Date']
             
+            # Ensure both dates are comparable by converting to datetime objects
+            def normalize_date_for_comparison(date_value):
+                if isinstance(date_value, datetime):
+                    return date_value
+                elif isinstance(date_value, str) and date_value.strip():
+                    try:
+                        # Try to parse the string as a date
+                        return datetime.strptime(date_value, '%m/%d/%Y')
+                    except ValueError:
+                        try:
+                            return datetime.strptime(date_value, '%m-%d-%Y')
+                        except ValueError:
+                            # If parsing fails, return minimum datetime
+                            return datetime.min
+                else:
+                    # Empty or invalid values get minimum datetime
+                    return datetime.min
+            
+            normalized_surgery_date = normalize_date_for_comparison(surgery_date)
+            normalized_existing_date = normalize_date_for_comparison(existing_date)
+            
             # Keep the most current demographic data (later surgery date takes precedence)
-            if surgery_date > existing_date:
+            if normalized_surgery_date > normalized_existing_date:
                 # Store the old row's surgery date before replacing
                 old_date = existing_row['Surgery Date']
-                patient_surgery_dates[patient_id].append(old_date)
+                # Add the old date to the list if it's not already there
+                if old_date not in patient_surgery_dates[patient_id]:
+                    patient_surgery_dates[patient_id].append(old_date)
                 # Replace with newer row (better demographics)
                 unique_patients[patient_id] = row
-                # Update the surgery dates list to reflect the new primary date
-                patient_surgery_dates[patient_id] = [surgery_date] + [d for d in patient_surgery_dates[patient_id] if d != surgery_date]
+                # Add the new surgery date to the list if it's not already there
+                if surgery_date not in patient_surgery_dates[patient_id]:
+                    patient_surgery_dates[patient_id].append(surgery_date)
             else:
-                # Add this surgery date to the list for this patient
+                # Add this surgery date to the list for this patient if it's not already there
                 if surgery_date not in patient_surgery_dates[patient_id]:
                     patient_surgery_dates[patient_id].append(surgery_date)
 
@@ -558,11 +582,77 @@ def sort_and_deduplicate(csv_data):
             else:
                 surgery_date_strings.append(str(date) if date else 'MISSING')
         
-        row['_all_surgery_dates'] = sorted(surgery_date_strings)
+        # Remove duplicates and sort
+        unique_surgery_dates = list(set(surgery_date_strings))
+        sorted_surgery_dates = sorted(unique_surgery_dates, key=lambda x: datetime.strptime(x, '%m-%d-%Y') if x != 'MISSING' else datetime.min)
+        row['_all_surgery_dates'] = sorted_surgery_dates
         row['_primary_surgery_date'] = row['Surgery Date']  # Keep track of which date has the demographics
+        # Compute and store earliest surgery date for emission sort
+        earliest_dt = None
+        earliest_str = None
+        for d in sorted_surgery_dates:
+            if d and d != 'MISSING':
+                try:
+                    earliest_dt = datetime.strptime(d, '%m-%d-%Y')
+                    earliest_str = d
+                    break
+                except Exception:
+                    pass
+        # Fallback to demographics date if earliest could not be determined
+        if earliest_str is None:
+            try:
+                sd = row.get('Surgery Date')
+                if isinstance(sd, datetime) and sd != datetime.min:
+                    earliest_dt = sd
+                    earliest_str = sd.strftime('%m-%d-%Y')
+                elif isinstance(sd, str) and sd.strip():
+                    try:
+                        earliest_dt = datetime.strptime(sd, '%m/%d/%Y')
+                    except Exception:
+                        try:
+                            earliest_dt = datetime.strptime(sd, '%m-%d-%Y')
+                        except Exception:
+                            earliest_dt = None
+                    earliest_str = sd
+            except Exception:
+                earliest_dt = None
+                earliest_str = None
+        row['_earliest_surgery_date'] = earliest_str
+        
+
 
     # Convert the unique_patients dictionary back to a list and sort it
-    csv_data[:] = sorted(unique_patients.values(), key=lambda x: (x['Surgery Date'], x.get('Patient Last', '').strip())) # TODO Does this need to be sorted twice? once before and once after?
+    # Use the same normalization function for consistent sorting
+    def sort_key(row):
+        # Prefer earliest surgery date across all known dates for the patient
+        earliest = row.get('_earliest_surgery_date')
+        if isinstance(earliest, str) and earliest and earliest != 'MISSING':
+            try:
+                normalized_date = datetime.strptime(earliest, '%m-%d-%Y')
+            except Exception:
+                normalized_date = datetime.min
+        else:
+            # Fallback to the single Surgery Date field
+            surgery_date = row.get('Surgery Date')
+            if isinstance(surgery_date, datetime):
+                normalized_date = surgery_date
+            elif isinstance(surgery_date, str) and surgery_date.strip():
+                try:
+                    normalized_date = datetime.strptime(surgery_date, '%m/%d/%Y')
+                except ValueError:
+                    try:
+                        normalized_date = datetime.strptime(surgery_date, '%m-%d-%Y')
+                    except ValueError:
+                        normalized_date = datetime.min
+            else:
+                normalized_date = datetime.min
+        # Tie-break per requirement: last name (case-insensitive), then first name, then patient id
+        last_name = ((row.get('Patient Last') or '')).strip().upper()
+        first_name = ((row.get('Patient First') or '')).strip().upper()
+        patient_id_tiebreak = str(row.get('Patient ID') or '')
+        return (normalized_date, last_name, first_name, patient_id_tiebreak)
+    
+    csv_data[:] = sorted(unique_patients.values(), key=sort_key) # TODO Does this need to be sorted twice? once before and once after?
     
     # TODO: Consider adding an option in the config to sort based on Surgery Schedules when available.
     # If no schedule is available, the current sorting strategy will be used.
@@ -1160,17 +1250,51 @@ def update_diagnosis_codes(csv_data):
                     MediLink_ConfigLoader.log("Patient ID: {}, Surgery Date: {}".format(patient_id, surgery_date_str), level="DEBUG")
 
                     if surgery_date_str in all_patient_data[patient_id]:
-                        diagnosis_code, left_or_right_eye, femto_yes_or_no = all_patient_data[patient_id][surgery_date_str]
+                        diagnosis_data = all_patient_data[patient_id][surgery_date_str]
+                        # XP SP3 + Py3.4.4 compatible tuple unpacking with safety check
+                        try:
+                            if isinstance(diagnosis_data, (list, tuple)) and len(diagnosis_data) >= 3:
+                                diagnosis_code, left_or_right_eye, femto_yes_or_no = diagnosis_data
+                            else:
+                                # Handle case where diagnosis_data is not a proper tuple
+                                diagnosis_code = diagnosis_data if diagnosis_data else None
+                                left_or_right_eye = None
+                                femto_yes_or_no = None
+                        except Exception as e:
+                            MediLink_ConfigLoader.log("Error unpacking diagnosis data for Patient ID: {}, Surgery Date: {}: {}".format(
+                                patient_id, surgery_date_str, str(e)), level="WARNING")
+                            diagnosis_code = None
+                            left_or_right_eye = None
+                            femto_yes_or_no = None
+                        
                         MediLink_ConfigLoader.log("Found diagnosis data for Patient ID: {}, Surgery Date: {}".format(patient_id, surgery_date_str), level="DEBUG")
                         
-                        # Convert diagnosis code to Medisoft shorthand format.
-                        medisoft_shorthand = diagnosis_to_medisoft.get(diagnosis_code, None)
-                        if medisoft_shorthand is None and diagnosis_code:
-                            # Use fallback logic for missing mapping
-                            defaulted_code = diagnosis_code.lstrip('H').lstrip('T8').replace('.', '')[-5:]
-                            medisoft_shorthand = defaulted_code
-                            MediLink_ConfigLoader.log("Missing diagnosis mapping for '{}', using fallback code '{}'".format(
-                                diagnosis_code, medisoft_shorthand), level="WARNING")
+                                                # Convert diagnosis code to Medisoft shorthand format.
+                        # XP SP3 + Py3.4.4 compatible null check
+                        if diagnosis_code is None:
+                            medisoft_shorthand = 'N/A'
+                            MediLink_ConfigLoader.log("Diagnosis code is None for Patient ID: {}, Surgery Date: {}".format(
+                                patient_id, surgery_date_str), level="WARNING")
+                        else:
+                            medisoft_shorthand = diagnosis_to_medisoft.get(diagnosis_code, None)
+                            if medisoft_shorthand is None and diagnosis_code:
+                                # Use fallback logic for missing mapping (XP SP3 + Py3.4.4 compatible)
+                                try:
+                                    defaulted_code = diagnosis_code.lstrip('H').lstrip('T8').replace('.', '')[-5:]
+                                    # Basic validation: ensure code is not empty and has reasonable length
+                                    if defaulted_code and len(defaulted_code) >= 3:
+                                        medisoft_shorthand = defaulted_code
+                                        MediLink_ConfigLoader.log("Missing diagnosis mapping for '{}', using fallback code '{}'".format(
+                                            diagnosis_code, medisoft_shorthand), level="WARNING")
+                                    else:
+                                        medisoft_shorthand = 'N/A'
+                                        MediLink_ConfigLoader.log("Fallback diagnosis code validation failed for '{}', using 'N/A'".format(
+                                            diagnosis_code), level="WARNING")
+                                except Exception as e:
+                                    medisoft_shorthand = 'N/A'
+                                    MediLink_ConfigLoader.log("Error in fallback diagnosis code generation for '{}': {}".format(
+                                        diagnosis_code, str(e)), level="WARNING")
+                        
                         MediLink_ConfigLoader.log("Converted diagnosis code to Medisoft shorthand: {}".format(medisoft_shorthand), level="DEBUG")
                         
                         surgery_date_to_diagnosis[surgery_date_str] = medisoft_shorthand
@@ -1488,12 +1612,28 @@ def capitalize_all_fields(csv_data):
     Returns:
     None: The function modifies the csv_data in place.
     """
-    # PERFORMANCE FIX: Optimize uppercase conversion using dict comprehension
+    # PERFORMANCE FIX: Optimize uppercase conversion while preserving complex types
     for row in csv_data:
-        # 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()
-        })
+        updated_row = {}
+        for key, value in row.items():
+            # Preserve internal/derived fields intact (e.g., `_all_surgery_dates`, `_surgery_date_to_diagnosis`)
+            if isinstance(key, str) and key.startswith('_'):
+                updated_row[key] = value
+                continue
+            # Uppercase plain strings
+            if isinstance(value, str):
+                updated_row[key] = value.upper()
+                continue
+            # Preserve complex containers; optionally uppercase their string contents
+            if isinstance(value, list):
+                updated_row[key] = [elem.upper() if isinstance(elem, str) else elem for elem in value]
+                continue
+            if isinstance(value, dict):
+                updated_row[key] = {k: (v.upper() if isinstance(v, str) else v) for k, v in value.items()}
+                continue
+            # Leave datetimes as-is; coerce simple scalars to string upper for consistency
+            if isinstance(value, datetime):
+                updated_row[key] = value
+            else:
+                updated_row[key] = str(value).upper() if value is not None else value
+        row.update(updated_row)

MediBot/MediBot_UI.py

@@ -43,64 +43,151 @@ def display_enhanced_patient_table(patient_info, title, show_line_numbers=True):
     print(title)
     print()
     
-    # Sort by surgery date first and then by patient name
-    patient_info.sort(key=lambda x: (x[0], x[1]))
+    # Normalize data to avoid None and unexpected container types in sort key
+    normalized_info = []
+    for surgery_date, patient_name, patient_id, diagnosis_code, patient_row in patient_info:
+        # Normalize date into comparable key and display string
+        display_date = None
+        current_date_dt = None
+        try:
+            if hasattr(surgery_date, 'strftime'):
+                display_date = surgery_date.strftime('%m-%d')
+                current_date_dt = surgery_date
+            elif isinstance(surgery_date, str):
+                # Date strings may be MM-DD-YYYY or already MM-DD
+                parts = surgery_date.split('-') if surgery_date else []
+                if len(parts) == 3 and all(parts):
+                    display_date = "{}-{}".format(parts[0], parts[1])
+                    try:
+                        current_date_dt = datetime.strptime(surgery_date, '%m-%d-%Y')
+                    except Exception:
+                        current_date_dt = None
+                else:
+                    display_date = surgery_date or 'Unknown Date'
+                    current_date_dt = None
+            else:
+                display_date = str(surgery_date) if surgery_date is not None else 'Unknown Date'
+                current_date_dt = None
+        except Exception:
+            display_date = str(surgery_date) if surgery_date is not None else 'Unknown Date'
+            current_date_dt = None
+        
+        # Normalize diagnosis display: only show "-Not Found-" when explicitly flagged as N/A
+        # XP SP3 + Py3.4.4 compatible error handling
+        display_diagnosis = diagnosis_code
+        try:
+            if diagnosis_code == "N/A":
+                display_diagnosis = "-Not Found-"
+            elif diagnosis_code is None:
+                display_diagnosis = "-Not Found-"
+            elif isinstance(diagnosis_code, str) and diagnosis_code.strip() == "":
+                display_diagnosis = "-Not Found-"
+            else:
+                display_diagnosis = str(diagnosis_code)
+        except (TypeError, ValueError) as e:
+            # Log the specific error for debugging (ASCII-only compatible)
+            try:
+                error_msg = "Error converting diagnosis code to string: {}".format(str(e))
+                MediLink_ConfigLoader.log(error_msg, level="WARNING")
+            except Exception:
+                # Fallback logging if string formatting fails
+                MediLink_ConfigLoader.log("Error converting diagnosis code to string", level="WARNING")
+            display_diagnosis = "-Not Found-"
+
+        # Grouping: place all dates for a patient together under their earliest date
+        primary_date_dt = None
+        within_index = 0
+        last_name_key = ''
+        first_name_key = ''
+        try:
+            all_dates = []
+            if patient_row is not None:
+                raw_dates = patient_row.get('_all_surgery_dates', [])
+                # Convert to datetime list and find primary
+                for d in raw_dates:
+                    try:
+                        if hasattr(d, 'strftime'):
+                            all_dates.append(d)
+                        elif isinstance(d, str):
+                            all_dates.append(datetime.strptime(d, '%m-%d-%Y'))
+                    except Exception:
+                        pass
+                if all_dates:
+                    all_dates.sort()
+                    primary_date_dt = all_dates[0]
+                    # Determine within-patient index of current date
+                    if current_date_dt is not None:
+                        # Find matching index by exact date
+                        for idx, ad in enumerate(all_dates):
+                            if current_date_dt == ad:
+                                within_index = idx
+                                break
+                # Prefer explicit last/first from row for sorting
+                try:
+                    ln = patient_row.get('Patient Last')
+                    fn = patient_row.get('Patient First')
+                    if isinstance(ln, str):
+                        last_name_key = ln.strip().upper()
+                    if isinstance(fn, str):
+                        first_name_key = fn.strip().upper()
+                except Exception:
+                    pass
+        except Exception:
+            primary_date_dt = None
+            within_index = 0
+
+        # Fallbacks if parsing failed
+        if primary_date_dt is None:
+            primary_date_dt = current_date_dt
+        # If last/first not available from row, parse from display name "LAST, FIRST ..."
+        if not last_name_key and isinstance(patient_name, str):
+            try:
+                parts = [p.strip() for p in patient_name.split(',')]
+                if len(parts) >= 1:
+                    last_name_key = parts[0].upper()
+                if len(parts) >= 2:
+                    first_name_key = parts[1].split()[0].upper() if parts[1] else ''
+            except Exception:
+                last_name_key = ''
+                first_name_key = ''
+
+        # Build composite sort key per requirement: by earliest date, then last name within date,
+        # while keeping same patient's additional dates directly under the first line
+        composite_sort_key = (primary_date_dt, last_name_key, first_name_key, str(patient_id or ''), within_index)
+        
+        normalized_info.append((composite_sort_key, display_date, str(patient_name or ''), str(patient_id or ''), display_diagnosis))
+    
+    # Sort so that all entries for a patient are grouped under their earliest date
+    normalized_info.sort(key=lambda x: x[0])
     
     # Calculate column widths for proper alignment
-    max_patient_id_len = max(len(str(pid)) for _, _, pid, _, _ in patient_info)
-    max_patient_name_len = max(len(pname) for _, pname, _, _, _ in patient_info)
-    max_diagnosis_len = max(len(dcode) for _, _, _, dcode, _ in patient_info)
+    max_patient_id_len = max(len(pid) for _, _, _, pid, _ in normalized_info)
+    max_patient_name_len = max(len(pname) for _, _, pname, _, _ in normalized_info)
+    max_diagnosis_len = max(len(dcode) for _, _, _, _, dcode in normalized_info)
     
     # Ensure minimum widths for readability
     max_patient_id_len = max(max_patient_id_len, 5)  # 5-digit ID max
     max_patient_name_len = max(max_patient_name_len, 12)  # "Patient Name" header
     max_diagnosis_len = max(max_diagnosis_len, 10)  # "Diagnosis" header
     
-    # Print the sorted patient info with multiple surgery dates
     current_patient = None
     line_number = 1
     
-    for surgery_date, patient_name, patient_id, diagnosis_code, patient_row in patient_info:
-        # Format surgery_date safely whether it's a datetime/date or a string
-        try:
-            if isinstance(surgery_date, datetime):
-                formatted_date = surgery_date.strftime('%m-%d')
-            else:
-                # Handle string dates - this should be the Surgery Date Display field
-                formatted_date = str(surgery_date)
-                # If it's a date string like "12-25-2023", format it as "12-25"
-                if '-' in formatted_date and len(formatted_date.split('-')) == 3:
-                    try:
-                        parts = formatted_date.split('-')
-                        formatted_date = "{}-{}".format(parts[0], parts[1])
-                    except:
-                        pass  # Use original string if parsing fails
-        except Exception:
-            formatted_date = str(surgery_date)
-        
-        # Transform diagnosis code display: show "-Not Found-" instead of "N/A"
-        display_diagnosis = "-Not Found-" if diagnosis_code == "N/A" else diagnosis_code
-        
-        # Check if this is the same patient as the previous line
+    for sort_key, formatted_date, patient_name, patient_id, display_diagnosis in normalized_info:
         if current_patient == patient_id:
-            # Secondary surgery date - indent and show dashes for patient info
-            # Use exact character count matching for dashes
-            patient_id_dashes = '-' * len(str(patient_id))
+            patient_id_dashes = '-' * len(patient_id)
             patient_name_dashes = '-' * len(patient_name)
-            
             secondary_format = "     {:<6} | {:<" + str(max_patient_id_len) + "} | {:<" + str(max_patient_name_len) + "} | {:<" + str(max_diagnosis_len) + "}"
             print(secondary_format.format(formatted_date, patient_id_dashes, patient_name_dashes, display_diagnosis))
         else:
-            # New patient - show full patient info
             current_patient = patient_id
             if show_line_numbers:
                 primary_format = "{:03d}: {:<6} | {:<" + str(max_patient_id_len) + "} | {:<" + str(max_patient_name_len) + "} | {:<" + str(max_diagnosis_len) + "}"
-                print(primary_format.format(line_number, formatted_date, str(patient_id), patient_name, display_diagnosis))
+                print(primary_format.format(line_number, formatted_date, patient_id, patient_name, display_diagnosis))
                 line_number += 1
             else:
-                # For existing patients, don't show line numbers
                 primary_format = "     {:<6} | {:<" + str(max_patient_id_len) + "} | {:<" + str(max_patient_name_len) + "} | {:<" + str(max_diagnosis_len) + "}"
-                print(primary_format.format(formatted_date, str(patient_id), patient_name, display_diagnosis))
+                print(primary_format.format(formatted_date, patient_id, patient_name, display_diagnosis))
 
 # Function to check if a specific key is pressed
 def _get_vk_codes():