medicafe 0.250813.0__tar.gz → 0.250813.2__tar.gz

{medicafe-0.250813.0 → medicafe-0.250813.2}/MediBot/MediBot.py

@@ -608,48 +608,68 @@ if __name__ == "__main__":
             existing_patients, patients_to_process = MediBot_Preprocessor.check_existing_patients(selected_patient_ids, _ac().get_mapat_med_path() if _ac() else '')
             
             if existing_patients:
-                print("\nNOTE: The following patient(s) already EXIST in the system and \n      will be excluded from processing:")
-                # BUG There a "ERROR:  'str' object has no attribute 'strftime'" that shows up after this somewhere.
                 # Collect surgery dates and patient info for existing patients
                 patient_info = []
                 for patient_id, patient_name in existing_patients:
                     try:
-                        surgery_date = next((row.get('Surgery Date') for row in csv_data if row.get(reverse_mapping['Patient ID #2']) == patient_id), None)
-                        if surgery_date is None:
-                            raise ValueError("Surgery Date not found for patient ID: {}".format(patient_id))
-                        patient_info.append((surgery_date, patient_name, patient_id))
+                        # Find the row for this patient
+                        patient_row = next((row for row in csv_data if row.get(reverse_mapping['Patient ID #2']) == patient_id), None)
+                        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))
+                            
                     except Exception as e:
-                        MediLink_ConfigLoader.log("Warning: Error retrieving Surgery Date for patient ID '{}': {}".format(patient_id, e), level="WARNING")
-                        patient_info.append(('Unknown Date', patient_name, patient_id))  # Append with 'Unknown Date' if there's an error
-
-                # Sort by surgery date first and then by patient name
-                # NOTE: 'surgery_date' may be a string or a datetime depending on upstream data.
-                # We sort lexicographically which is stable for uniform string inputs. If mixed types
-                # are encountered, consider normalizing to string first or using a robust key function
-                # that attempts datetime parsing with a string fallback.
-                patient_info.sort(key=lambda x: (x[0], x[1]))
-
-                # Print the sorted patient info
-                for index, (surgery_date, patient_name, patient_id) in enumerate(patient_info):
-                    # Format surgery_date safely whether it's a datetime/date or a string
-                    # This guards the observed "'str' object has no attribute 'strftime'" error on XP.
-                    try:
-                        formatted_date = surgery_date.strftime('%m-%d')
-                    except Exception:
-                        formatted_date = str(surgery_date)
-                    print("{:03d}: {} (ID: {}) {}".format(index + 1, formatted_date, patient_id, patient_name))
+                        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
+                MediBot_UI.display_enhanced_patient_table(
+                    patient_info, 
+                    "NOTE: The following patient(s) already EXIST in the system but have new dates of service.\n      Their diagnosis codes will need to be updated manually by the user to the following list:",
+                    show_line_numbers=False
+                )
 
                 # Update csv_data to exclude existing patients
                 # TODO: Update this logic to handle patients that exist but need new charges added.
                 csv_data = [row for row in csv_data if row[reverse_mapping['Patient ID #2']] in patients_to_process]
-            else:
-                print("\nSelected patient(s) are NEW patients and will be processed.")
+            
+            # Show NEW patients that will be processed (if any)
+            if patients_to_process:
+                # 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))
+
+                # Display new patients table using the enhanced display function
+                MediBot_UI.display_enhanced_patient_table(
+                    new_patient_info, 
+                    "NOTE: The following NEW patient(s) will be automatically entered into Medisoft:",
+                    show_line_numbers=True
+                )
 
             # Check if there are patients left to process
             if len(patients_to_process) == 0:
                 proceed = input("\nAll patients have been processed. Continue anyway?: ").lower().strip() in ['yes', 'y']
             else:
-                proceed = input("\nDo you want to proceed with the {} remaining patient(s)? (yes/no): ".format(len(patients_to_process))).lower().strip() in ['yes', 'y']
+                proceed = input("\nDo you want to proceed with entering {} new patient(s) into Medisoft? (yes/no): ".format(len(patients_to_process))).lower().strip() in ['yes', 'y']
 
             # TODO: Here is where we need to add the step where we move to MediBot_Charges. 
             # The return is an enriched dataset to be picked up by MediBot which means we need to return: 

{medicafe-0.250813.0 → medicafe-0.250813.2}/MediBot/MediBot_Crosswalk_Library.py

@@ -4,17 +4,13 @@ Core crosswalk library for MediBot
 Handles crosswalk operations and API interactions.
 """
 
-import os
 import sys
-import csv
-import json
-import re
-from datetime import datetime
 
 # Use core utilities for standardized imports
 from MediCafe.core_utils import (
     import_medibot_module,
-    get_config_loader_with_fallback
+    get_config_loader_with_fallback,
+    smart_import
 )
 
 # Initialize configuration loader with fallback
@@ -45,6 +41,10 @@ else:
     update_crosswalk_with_new_payer_id = None
     load_and_parse_z_data = None
 
+# Import API functions using centralized import pattern
+MediLink_API_v3 = smart_import(['MediCafe.api_core', 'MediCafe.api_core_backup'])
+fetch_payer_name_from_api = getattr(MediLink_API_v3, 'fetch_payer_name_from_api', None) if MediLink_API_v3 else None
+
 # Module-level cache to prevent redundant API calls
 _api_cache = {}
 

{medicafe-0.250813.0 → medicafe-0.250813.2}/MediBot/MediBot_Preprocessor_lib.py

@@ -262,7 +262,7 @@ def add_columns(csv_data, column_headers):
 
 # Extracting the list to a variable for future refactoring:
 def filter_rows(csv_data):
-    # TODO: This should be handled in the crosswalk.
+    # TODO: This should be written in the crosswalk and not hardcoded here.
     excluded_insurance = {'AETNA', 'AETNA MEDICARE', 'HUMANA MED HMO'}
     csv_data[:] = [row for row in csv_data if row.get('Patient ID') and row.get('Primary Insurance') not in excluded_insurance]
 
@@ -515,17 +515,40 @@ def convert_surgery_date(csv_data):
 def sort_and_deduplicate(csv_data):
     # Create a dictionary to hold unique patients based on Patient ID
     unique_patients = {}
+    # Create a dictionary to store multiple surgery dates per patient
+    patient_surgery_dates = {}
     
     # Iterate through the CSV data and populate the unique_patients dictionary
     for row in csv_data:
         patient_id = row.get('Patient ID')
+        surgery_date = row.get('Surgery Date')
+        
         if patient_id not in unique_patients:
             unique_patients[patient_id] = row
+            patient_surgery_dates[patient_id] = [surgery_date]
         else:
             # If the patient ID already exists, compare surgery dates
             existing_row = unique_patients[patient_id]
-            if row['Surgery Date'] < existing_row['Surgery Date']:
+            existing_date = existing_row['Surgery Date']
+            
+            # Keep the most current demographic data (later surgery date takes precedence)
+            if surgery_date > 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)
+                # 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]
+            else:
+                # Add this surgery date to the list for this patient
+                if surgery_date not in patient_surgery_dates[patient_id]:
+                    patient_surgery_dates[patient_id].append(surgery_date)
+
+    # Store the surgery dates information in the first row of each patient for later access
+    for patient_id, row in unique_patients.items():
+        row['_all_surgery_dates'] = sorted(patient_surgery_dates[patient_id])
+        row['_primary_surgery_date'] = row['Surgery Date']  # Keep track of which date has the demographics
 
     # 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?
@@ -1096,7 +1119,7 @@ def update_diagnosis_codes(csv_data):
         updated_count = 0
 
         # PERFORMANCE OPTIMIZATION: Single pass through CSV data with pre-processed lookups
-        # Update the "Default Diagnosis #1" column in the CSV data
+        # Update the "Default Diagnosis #1" column in the CSV data and store diagnosis codes for all surgery dates
         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
@@ -1104,31 +1127,56 @@ def update_diagnosis_codes(csv_data):
                 continue  # Skip rows that do not match any patient ID
 
             MediLink_ConfigLoader.log("Processing row number {}.".format(row_num), level="DEBUG")
-            # 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")
-
+            
+            # Get all surgery dates for this patient
+            all_surgery_dates = row.get('_all_surgery_dates', [row.get('Surgery Date')])
+            
+            # Create a mapping of surgery dates to diagnosis codes for this patient
+            surgery_date_to_diagnosis = {}
+            
             if patient_id in all_patient_data:
-                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]
-                    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")
-                    MediLink_ConfigLoader.log("Converted diagnosis code to Medisoft shorthand: {}".format(medisoft_shorthand), level="DEBUG")
+                # Process each surgery date for this patient
+                for surgery_date in all_surgery_dates:
+                    # Convert surgery date to string format for lookup
+                    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)
                     
-                    row['Default Diagnosis #1'] = medisoft_shorthand
-                    updated_count += 1
-                    MediLink_ConfigLoader.log("Updated row number {} with new diagnosis code.".format(row_num), level="INFO")
-                else:
-                    MediLink_ConfigLoader.log("No matching surgery date found for Patient ID: {} in row {}.".format(patient_id, row_num), level="INFO")
+                    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]
+                        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")
+                        MediLink_ConfigLoader.log("Converted diagnosis code to Medisoft shorthand: {}".format(medisoft_shorthand), level="DEBUG")
+                        
+                        surgery_date_to_diagnosis[surgery_date] = medisoft_shorthand
+                    else:
+                        MediLink_ConfigLoader.log("No matching surgery date found for Patient ID: {} on date {}.".format(patient_id, surgery_date_str), level="INFO")
+                        surgery_date_to_diagnosis[surgery_date] = 'N/A'
+                
+                # Store the diagnosis mapping for all surgery dates
+                row['_surgery_date_to_diagnosis'] = surgery_date_to_diagnosis
+                
+                # Set the primary diagnosis code (for the main surgery date)
+                primary_surgery_date = row.get('Surgery Date')
+                primary_diagnosis = surgery_date_to_diagnosis.get(primary_surgery_date, 'N/A')
+                row['Default Diagnosis #1'] = primary_diagnosis
+                
+                updated_count += 1
+                MediLink_ConfigLoader.log("Updated row number {} with diagnosis codes for {} surgery dates.".format(row_num, len(all_surgery_dates)), level="INFO")
             else:
                 MediLink_ConfigLoader.log("Patient ID: {} not found in DOCX data for row {}.".format(patient_id, row_num), level="INFO")
 

{medicafe-0.250813.0 → medicafe-0.250813.2}/MediBot/MediBot_UI.py

@@ -1,5 +1,5 @@
 #MediBot_UI.py
-import ctypes, time, re, os, sys
+import ctypes, time, re
 from ctypes import wintypes
 from sys import exit
 
@@ -27,6 +27,69 @@ except ImportError:
 from MediCafe.core_utils import create_config_cache
 _get_config, (_config_cache, _crosswalk_cache) = create_config_cache()
 
+def display_enhanced_patient_table(patient_info, title, show_line_numbers=True):
+    """
+    Display an enhanced patient table with multiple surgery dates and diagnosis codes.
+    
+    Args:
+        patient_info: List of tuples (surgery_date, patient_name, patient_id, diagnosis_code, patient_row)
+        title: Title for the table section
+        show_line_numbers: Whether to show line numbers (True for new patients, False for existing)
+    """
+    if not patient_info:
+        return
+    
+    print(title)
+    print()
+    
+    # Sort by surgery date first and then by patient name
+    patient_info.sort(key=lambda x: (x[0], x[1]))
+    
+    # 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)
+    
+    # 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:
+            formatted_date = surgery_date.strftime('%m-%d')
+        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
+        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_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))
+                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))
+
 # Function to check if a specific key is pressed
 def _get_vk_codes():
     """Get VK codes from config."""

{medicafe-0.250813.0 → medicafe-0.250813.2}/MediBot/MediBot_dataformat_library.py

@@ -6,8 +6,6 @@ Contains functions for formatting various data types and handling CSV operations
 
 import os
 import sys
-import csv
-import json
 import re
 from datetime import datetime
 

{medicafe-0.250813.0 → medicafe-0.250813.2}/MediBot/MediBot_smart_import.py

@@ -7,7 +7,7 @@ new centralized smart import system, eliminating sys.path manipulation
 and circular import risks.
 """
 
-import os, subprocess, tempfile, traceback, re, time, sys
+import os, sys
 
 # Add workspace directory to Python path for MediCafe imports
 current_dir = os.path.dirname(os.path.abspath(__file__))

{medicafe-0.250813.0 → medicafe-0.250813.2}/MediBot/update_medicafe.py

@@ -292,7 +292,7 @@ def compare_versions(version1, version2):
 
 def upgrade_package(package, retries=4, delay=2, target_version=None):  # Updated retries to 4
     """
-    Attempts to upgrade the package multiple times with delays in between.
+    Attempts to upgrade the package multiple times with escalating techniques.
     """
     if not check_internet_connection():
         print_status("No internet connection detected. Please check your internet connection and try again.", "ERROR")
@@ -302,82 +302,94 @@ def upgrade_package(package, retries=4, delay=2, target_version=None):  # Update
     if target_version:
         print("Pinned target version: {}".format(target_version))
 
-    for attempt in range(1, retries + 1):
-        print("Attempt {}/{} to upgrade {}...".format(attempt, retries, package))
+    def get_installed_version_fresh(package):
+        """Get installed version using a fresh subprocess to avoid pkg_resources cache issues."""
+        try:
+            process = subprocess.Popen(
+                [sys.executable, '-m', 'pip', 'show', package],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE
+            )
+            stdout, stderr = process.communicate()
+            if process.returncode == 0:
+                for line in stdout.decode().splitlines():
+                    if line.startswith("Version:"):
+                        return line.split(":", 1)[1].strip()
+            return None
+        except Exception as e:
+            print("Warning: Could not get fresh version: {}".format(e))
+            return None
+
+    def try_upgrade_with_strategy(attempt, strategy_name, cmd_args):
+        """Try upgrade with specific strategy and return success status."""
+        print("Attempt {}/{}: Using {} strategy...".format(attempt, retries, strategy_name))
         
-        # Use a more compatible approach for Python 3.4
-        # Try with --no-deps first to avoid dependency resolution issues
         pkg_spec = package
         if target_version:
             pkg_spec = "{}=={}".format(package, target_version)
 
-        cmd = [
-            sys.executable, '-m', 'pip', 'install', '--upgrade',
-            '--no-deps', '--no-cache-dir', '--disable-pip-version-check', '-q', pkg_spec
-        ]
+        cmd = [sys.executable, '-m', 'pip', 'install'] + cmd_args + [pkg_spec]
         
-        print("Using pip upgrade with --no-deps and --no-cache-dir")
         process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         stdout, stderr = process.communicate()
         
         if process.returncode == 0:
             print(stdout.decode().strip())
-            new_version = get_installed_version(package)  # Get new version after upgrade
+            # Add delay to allow file system to settle
+            time.sleep(1)
+            new_version = get_installed_version_fresh(package)
             expected_version = target_version or get_latest_version(package)
-            if expected_version and compare_versions(new_version, expected_version) >= 0:  # Compare versions
-                if attempt == 1:
-                    print_status("Upgrade succeeded!", "SUCCESS")
-                else:
-                    print_status("Attempt {}: Upgrade succeeded!".format(attempt), "SUCCESS")
-                time.sleep(delay)
+            
+            if expected_version and new_version and compare_versions(new_version, expected_version) >= 0:
+                print_status("Attempt {}: Upgrade succeeded with {}!".format(attempt, strategy_name), "SUCCESS")
                 return True
             else:
-                print_status("Upgrade incomplete. Current version: {} Expected at least: {}".format(new_version, expected_version), "WARNING")
-                if attempt < retries:
-                    print("Retrying in {} seconds...".format(delay))
-                    try:
-                        time.sleep(delay + (random.random() * 0.5))
-                    except Exception:
-                        time.sleep(delay)
+                print_status("Upgrade incomplete. Current version: {} Expected at least: {}".format(
+                    new_version or "unknown", expected_version), "WARNING")
+                return False
         else:
             print(stderr.decode().strip())
-            print_status("Attempt {}: Upgrade failed with --no-deps.".format(attempt), "WARNING")
-            
-            # If --no-deps failed, try with --force-reinstall to bypass dependency issues
-            if attempt < retries:
-                print("Fallback this attempt: retrying with --force-reinstall...")
-                pkg_spec = package
-                if target_version:
-                    pkg_spec = "{}=={}".format(package, target_version)
-
-                cmd = [
-                    sys.executable, '-m', 'pip', 'install', '--upgrade',
-                    '--force-reinstall', '--no-cache-dir', '--disable-pip-version-check', '-q', pkg_spec
-                ]
-                
-                process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-                stdout, stderr = process.communicate()
-                
-                if process.returncode == 0:
-                    print(stdout.decode().strip())
-                    new_version = get_installed_version(package)
-                    expected_version = target_version or get_latest_version(package)
-                    if expected_version and compare_versions(new_version, expected_version) >= 0:
-                        print_status("Attempt {}: Upgrade succeeded with --force-reinstall!".format(attempt), "SUCCESS")
-                        time.sleep(delay)
-                        return True
-                    else:
-                        print_status("Upgrade incomplete. Current version: {} Expected at least: {}".format(new_version, expected_version), "WARNING")
-                else:
-                    print(stderr.decode().strip())
-                    print_status("Attempt {}: Upgrade failed with --force-reinstall.".format(attempt), "WARNING")
-                
-                if attempt < retries:
-                    print("Retrying in {} seconds...".format(delay))
-                    try:
-                        time.sleep(delay + (random.random() * 0.5))
-                    except Exception:
-                        time.sleep(delay)
+            print_status("Attempt {}: Upgrade failed with {}.".format(attempt, strategy_name), "WARNING")
+            return False
+
+    # Define escalation strategies for each attempt
+    strategies = {
+        1: [
+            ("Gentle Upgrade", ['--upgrade', '--no-deps', '--no-cache-dir', '--disable-pip-version-check', '-q']),
+            ("Force Reinstall", ['--upgrade', '--force-reinstall', '--no-cache-dir', '--disable-pip-version-check', '-q'])
+        ],
+        2: [
+            ("Clean Install", ['--upgrade', '--force-reinstall', '--no-cache-dir', '--disable-pip-version-check', '--ignore-installed', '-q']),
+            ("User Install", ['--upgrade', '--user', '--no-cache-dir', '--disable-pip-version-check', '-q'])
+        ],
+        3: [
+            ("Aggressive Clean", ['--upgrade', '--force-reinstall', '--no-cache-dir', '--disable-pip-version-check', '--ignore-installed', '--no-deps', '-q']),
+            ("Pre-download", ['--upgrade', '--force-reinstall', '--no-cache-dir', '--disable-pip-version-check', '--pre', '-q'])
+        ],
+        4: [
+            ("Nuclear Option", ['--upgrade', '--force-reinstall', '--no-cache-dir', '--disable-pip-version-check', '--ignore-installed', '--no-deps', '--pre', '-q']),
+            ("Last Resort", ['--upgrade', '--force-reinstall', '--no-cache-dir', '--disable-pip-version-check', '--ignore-installed', '--no-deps', '--pre', '--user', '-q'])
+        ]
+    }
+
+    for attempt in range(1, retries + 1):
+        print("Attempt {}/{} to upgrade {}...".format(attempt, retries, package))
+        
+        # Try each strategy for this attempt
+        for strategy_name, cmd_args in strategies[attempt]:
+            if try_upgrade_with_strategy(attempt, strategy_name, cmd_args):
+                time.sleep(delay)
+                return True
+        
+        # If we get here, all strategies for this attempt failed
+        if attempt < retries:
+            # Escalating delays: 2s, 3s, 5s
+            current_delay = delay + (attempt - 1)
+            print("All strategies failed for attempt {}. Retrying in {} seconds...".format(attempt, current_delay))
+            try:
+                time.sleep(current_delay + (random.random() * 1.0))
+            except Exception:
+                time.sleep(current_delay)
     
     print_status("All upgrade attempts failed.", "ERROR")
     return False

{medicafe-0.250813.0 → medicafe-0.250813.2}/MediCafe/api_core.py

@@ -7,7 +7,6 @@ COMPATIBILITY: Python 3.4.4 and Windows XP compatible
 """
 
 import time, json, os, traceback, sys, requests
-from datetime import datetime, timedelta
 
 # Import centralized logging configuration
 try: