medicafe 0.250814.4__tar.gz → 0.250818.0__tar.gz

{medicafe-0.250814.4 → medicafe-0.250818.0}/MediBot/MediBot.py

@@ -11,6 +11,7 @@ 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
@@ -171,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
 
@@ -672,7 +735,7 @@ if __name__ == "__main__":
                         print(msg)
                 print("-" * 60)
         
-        proceed, selected_patient_ids, selected_indices, fixed_values = user_interaction(csv_data, interaction_mode, error_message, reverse_mapping)
+        proceed, selected_patient_ids, selected_indices, fixed_values, is_medicare = user_interaction(csv_data, interaction_mode, error_message, reverse_mapping)
 
         if proceed:
             # Filter csv_data for selected patients from Triage mode
@@ -695,32 +758,19 @@ 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:
-                            # Convert surgery_date to string format for consistent lookup (XP SP3 + Py3.4.4 compatible)
-                            try:
-                                if hasattr(surgery_date, 'strftime'):
-                                    surgery_date_str = surgery_date.strftime('%m-%d-%Y')
-                                else:
-                                    surgery_date_str = str(surgery_date)
-                            except Exception:
-                                surgery_date_str = str(surgery_date)
-                            
-                            diagnosis_code = surgery_date_to_diagnosis.get(surgery_date_str, '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")
                         patient_info.append(('Unknown Date', patient_name, patient_id, 'N/A', None))  # Append with 'Unknown Date' if there's an error
 
                 # Display existing patients table using the enhanced display function
+                patient_type = "MEDICARE" if is_medicare else "PRIVATE"
                 MediBot_UI.display_enhanced_patient_table(
                     patient_info, 
-                    "NOTE: The following patient(s) already EXIST in the system but may have new dates of service.\n      Their diagnosis codes may need to be updated manually by the user to the following list:",
+                    "{} PATIENTS - EXISTING: The following patient(s) already EXIST in the system but may have new dates of service.\n      Their diagnosis codes may need to be updated manually by the user to the following list:".format(patient_type),
                     show_line_numbers=False
                 )
 
@@ -733,31 +783,15 @@ 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:
-                        # Convert surgery_date to string format for consistent lookup (XP SP3 + Py3.4.4 compatible)
-                        try:
-                            if hasattr(surgery_date, 'strftime'):
-                                surgery_date_str = surgery_date.strftime('%m-%d-%Y')
-                            else:
-                                surgery_date_str = str(surgery_date)
-                        except Exception:
-                            surgery_date_str = str(surgery_date)
-                        
-                        diagnosis_code = surgery_date_to_diagnosis.get(surgery_date_str, '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
+                patient_type = "MEDICARE" if is_medicare else "PRIVATE"
                 MediBot_UI.display_enhanced_patient_table(
                     new_patient_info, 
-                    "NOTE: The following NEW patient(s) will be automatically entered into Medisoft:",
+                    "{} PATIENTS - NEW: The following patient(s) will be automatically entered into Medisoft:".format(patient_type),
                     show_line_numbers=True
                 )
 

{medicafe-0.250814.4 → medicafe-0.250818.0}/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.
@@ -1288,6 +1378,35 @@ def map_payer_ids_to_insurance_ids(patient_id_to_insurance_id, payer_id_to_patie
             }
     return payer_id_to_details
 
+def _display_mains_file_error(mains_path):
+    """
+    Helper function to display the critical MAINS file error message.
+    
+    Args:
+        mains_path (str): The path where the MAINS file was expected to be found.
+    """
+    error_msg = "CRITICAL: MAINS file not found at: {}. This file is required for insurance name to Medisoft ID mapping.".format(mains_path)
+    if hasattr(MediLink_ConfigLoader, 'log'):
+        MediLink_ConfigLoader.log(error_msg, level="CRITICAL")
+    print("\n" + "="*80)
+    print("CRITICAL ERROR: MAINS FILE MISSING")
+    print("="*80)
+    print("\nThe MAINS file is required for the following critical functions:")
+    print("* Mapping insurance company names to Medisoft IDs")
+    print("* Converting insurance names to payer IDs for claim submission")
+    print("* Creating properly formatted 837p claim files")
+    print("\nWithout this file, claim submission will fail because:")
+    print("* Insurance names cannot be converted to payer IDs")
+    print("* 837p claim files cannot be generated")
+    print("* Claims cannot be submitted to insurance companies")
+    print("\nTO FIX THIS:")
+    print("1. Ensure the MAINS file exists at: {}".format(mains_path))
+    print("2. If the file is missing, llamar a Dani")
+    print("3. The file should contain insurance company data from your Medisoft system")
+    print("="*80)
+    time.sleep(3)  # 3 second pause to allow user to read critical error message
+
+
 def load_insurance_data_from_mains(config):
     """
     Loads insurance data from MAINS and creates a mapping from insurance names to their respective IDs.
@@ -1331,25 +1450,7 @@ def load_insurance_data_from_mains(config):
     try:
         # Check if MAINS file exists before attempting to read
         if not os.path.exists(mains_path):
-            error_msg = "CRITICAL: MAINS file not found at: {}. This file is required for insurance name to Medisoft ID mapping.".format(mains_path)
-            if hasattr(MediLink_ConfigLoader, 'log'):
-                MediLink_ConfigLoader.log(error_msg, level="CRITICAL")
-            print("\n" + "="*80)
-            print("CRITICAL ERROR: MAINS FILE MISSING")
-            print("="*80)
-            print("\nThe MAINS file is required for the following critical functions:")
-            print("* Mapping insurance company names to Medisoft IDs")
-            print("* Converting insurance names to payer IDs for claim submission")
-            print("* Creating properly formatted 837p claim files")
-            print("\nWithout this file, claim submission will fail because:")
-            print("* Insurance names cannot be converted to payer IDs")
-            print("* 837p claim files cannot be generated")
-            print("* Claims cannot be submitted to insurance companies")
-            print("\nTO FIX THIS:")
-            print("1. Ensure the MAINS file exists at: {}".format(mains_path))
-            print("2. If the file is missing, llamar a Dani")
-            print("3. The file should contain insurance company data from your Medisoft system")
-            print("="*80)
+            _display_mains_file_error(mains_path)
             return insurance_to_id
         
         # XP Compatibility: Check if MediLink_DataMgmt has the required function
@@ -1369,25 +1470,7 @@ def load_insurance_data_from_mains(config):
             print("Successfully loaded {} insurance records from MAINS".format(len(insurance_to_id)))
         
     except FileNotFoundError:
-        error_msg = "CRITICAL: MAINS file not found: {}. This file is required for insurance name to Medisoft ID mapping.".format(mains_path)
-        if hasattr(MediLink_ConfigLoader, 'log'):
-            MediLink_ConfigLoader.log(error_msg, level="CRITICAL")
-        print("\n" + "="*80)
-        print("CRITICAL ERROR: MAINS FILE MISSING")
-        print("="*80)
-        print("\nThe MAINS file is required for the following critical functions:")
-        print("* Mapping insurance company names to Medisoft IDs")
-        print("* Converting insurance names to payer IDs for claim submission")
-        print("* Creating properly formatted 837p claim files")
-        print("\nWithout this file, claim submission will fail because:")
-        print("* Insurance names cannot be converted to payer IDs")
-        print("* 837p claim files cannot be generated")
-        print("* Claims cannot be submitted to insurance companies")
-        print("\nTO FIX THIS:")
-        print("1. Ensure the MAINS file exists at: {}".format(mains_path))
-        print("2. If the file is missing, llamar a Dani")
-        print("3. The file should contain insurance company data from your Medisoft system")
-        print("="*80)
+        _display_mains_file_error(mains_path)
     except Exception as e:
         error_msg = "Error loading MAINS data: {}. Continuing without MAINS data.".format(str(e))
         if hasattr(MediLink_ConfigLoader, 'log'):

{medicafe-0.250814.4 → medicafe-0.250818.0}/MediBot/MediBot_UI.py

@@ -48,26 +48,29 @@ def display_enhanced_patient_table(patient_info, title, show_line_numbers=True):
     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
-        sort_key = None
+        current_date_dt = None
         try:
             if hasattr(surgery_date, 'strftime'):
                 display_date = surgery_date.strftime('%m-%d')
-                sort_key = surgery_date
+                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'
-                # Use the raw string as sort key fallback
-                sort_key = surgery_date or ''
+                    current_date_dt = None
             else:
                 display_date = str(surgery_date) if surgery_date is not None else 'Unknown Date'
-                sort_key = display_date
+                current_date_dt = None
         except Exception:
             display_date = str(surgery_date) if surgery_date is not None else 'Unknown Date'
-            sort_key = display_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
@@ -90,11 +93,72 @@ def display_enhanced_patient_table(patient_info, title, show_line_numbers=True):
                 # 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((sort_key, display_date, str(patient_name or ''), str(patient_id or ''), display_diagnosis))
+        normalized_info.append((composite_sort_key, display_date, str(patient_name or ''), str(patient_id or ''), display_diagnosis))
     
-    # Sort by normalized sort key then patient name
-    normalized_info.sort(key=lambda x: (x[0], x[2]))
+    # 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(pid) for _, _, _, pid, _ in normalized_info)
@@ -252,6 +316,10 @@ def display_patient_selection_menu(csv_data, reverse_mapping, proceed_as_medicar
     selected_patient_ids = []
     selected_indices = []
 
+    # TODO: Future enhancement - make this configurable via config file
+    # Example: config.get('silent_initial_selection', True)
+    SILENT_INITIAL_SELECTION = True  # Set to False to restore original interactive behavior
+
     def display_menu_header(title):
         print("\n" + "-" * 60)
         print(title)
@@ -284,7 +352,10 @@ def display_patient_selection_menu(csv_data, reverse_mapping, proceed_as_medicar
                 formatted_date = surgery_date.strftime('%m-%d')
             except Exception:
                 formatted_date = str(surgery_date)
-            print("{0:03d}: {3} (ID: {2}) {1} ".format(index+1, patient_name, patient_id, formatted_date))
+            
+            # Only display if not in silent mode
+            if not SILENT_INITIAL_SELECTION:
+                print("{0:03d}: {3} (ID: {2}) {1} ".format(index+1, patient_name, patient_id, formatted_date))
 
             displayed_indices.append(index)
             displayed_patient_ids.append(patient_id)
@@ -292,23 +363,44 @@ def display_patient_selection_menu(csv_data, reverse_mapping, proceed_as_medicar
         return displayed_indices, displayed_patient_ids
 
     if proceed_as_medicare:
-        display_menu_header("MEDICARE Patient Selection for Today's Data Entry")
+        if not SILENT_INITIAL_SELECTION:
+            display_menu_header("MEDICARE Patient Selection for Today's Data Entry")
         selected_indices, selected_patient_ids = display_patient_list(csv_data, reverse_mapping, medicare_filter=True)
     else:
-        display_menu_header("PRIVATE Patient Selection for Today's Data Entry")
+        if not SILENT_INITIAL_SELECTION:
+            display_menu_header("PRIVATE Patient Selection for Today's Data Entry")
         selected_indices, selected_patient_ids = display_patient_list(csv_data, reverse_mapping, exclude_medicare=True)
 
-    print("-" * 60)
-    proceed = input("\nDo you want to proceed with the selected patients? (yes/no): ").lower().strip() in ['yes', 'y']
+    if not SILENT_INITIAL_SELECTION:
+        print("-" * 60)
+        proceed = input("\nDo you want to proceed with the selected patients? (yes/no): ").lower().strip() in ['yes', 'y']
+    else:
+        # Auto-confirm in silent mode
+        proceed = True
 
     if not proceed:
-        display_menu_header("Patient Selection for Today's Data Entry")
-        selected_indices, selected_patient_ids = display_patient_list(csv_data, reverse_mapping)
-        print("-" * 60)
-        
-        while True:
+        if not SILENT_INITIAL_SELECTION:
+            display_menu_header("Patient Selection for Today's Data Entry")
+            selected_indices, selected_patient_ids = display_patient_list(csv_data, reverse_mapping)
+            print("-" * 60)
+            
             while True:
-                selection = input("\nEnter the number(s) of the patients you wish to proceed with\n(e.g., 1, 3, 5): ").strip()
+                while True:
+                    selection = input("\nEnter the number(s) of the patients you wish to proceed with\n(e.g., 1, 3, 5): ").strip()
+                    if not selection:
+                        print("Invalid entry. Please provide at least one number.")
+                        continue
+                    
+                    selection = selection.replace('.', ',')  # Replace '.' with ',' in the user input just in case
+                    selected_indices = [int(x.strip()) - 1 for x in selection.split(',') if x.strip().isdigit()]  
+                    
+                    if not selected_indices:
+                        print("Invalid entry. Please provide at least one integer.")
+                        continue
+                    
+                    proceed = True
+                    break
+                
                 if not selection:
                     print("Invalid entry. Please provide at least one number.")
                     continue
@@ -322,20 +414,6 @@ def display_patient_selection_menu(csv_data, reverse_mapping, proceed_as_medicar
                 
                 proceed = True
                 break
-            
-            if not selection:
-                print("Invalid entry. Please provide at least one number.")
-                continue
-            
-            selection = selection.replace('.', ',')  # Replace '.' with ',' in the user input just in case
-            selected_indices = [int(x.strip()) - 1 for x in selection.split(',') if x.strip().isdigit()]  
-            
-            if not selected_indices:
-                print("Invalid entry. Please provide at least one integer.")
-                continue
-            
-            proceed = True
-            break
 
     patient_id_header = reverse_mapping['Patient ID #2']
     selected_patient_ids = [csv_data[i][patient_id_header] for i in selected_indices if i < len(csv_data)]
@@ -434,6 +512,15 @@ def user_interaction(csv_data, interaction_mode, error_message, reverse_mapping)
             fixed_values.update(medicare_added_fixed_values)  # Add any medicare-specific fixed values from config
         
         proceed, selected_patient_ids, selected_indices = display_patient_selection_menu(csv_data, reverse_mapping, response in ['yes', 'y'])
-        return proceed, selected_patient_ids, selected_indices, fixed_values
-
-    return handle_user_interaction(interaction_mode, error_message)
+        is_medicare = response in ['yes', 'y']
+        return proceed, selected_patient_ids, selected_indices, fixed_values, is_medicare
+
+    # For non-triage modes (error, normal), return a compatible structure
+    # The is_medicare value is not relevant in these modes, so we'll use a default
+    result = handle_user_interaction(interaction_mode, error_message)
+    if isinstance(result, int):
+        # This is a control value (-1, 1, -2), return with default values
+        return False, [], [], {}, False  # proceed=False, empty lists, empty dict, is_medicare=False
+    else:
+        # Unexpected return type, handle gracefully
+        return False, [], [], {}, False

{medicafe-0.250814.4 → medicafe-0.250818.0}/MediBot/__init__.py

@@ -19,7 +19,7 @@ Smart Import Integration:
         medibot_main = get_components('medibot_main')
 """
 
-__version__ = "0.250814.4"
+__version__ = "0.250818.0"
 __author__ = "Daniel Vidaud"
 __email__ = "daniel@personalizedtransformation.com"