medicafe 0.250813.1__tar.gz → 0.250814.3__tar.gz

medicafe-0.250814.3/MANIFEST.in

@@ -0,0 +1,24 @@
+include MediBot/MediBot.bat
+include MediLink/openssl.cnf
+include MediLink/*.html
+include MediCafe/*.py
+
+# Exclude CSV files and other data files that slow down the build
+exclude *.csv
+exclude *.log
+exclude *.tmp
+exclude *.bak
+exclude __pycache__/*
+exclude *.pyc
+exclude *.pyo
+exclude .git/*
+exclude .gitignore
+exclude .DS_Store
+exclude Thumbs.db
+exclude archive/*
+exclude ERA_TEST_DUMP/*
+exclude input/*
+exclude tmpdl/*
+exclude json/*
+exclude docs/reports/*
+exclude Installers/*

{medicafe-0.250813.1 → medicafe-0.250814.3}/MediBot/MediBot.bat

@@ -772,7 +772,7 @@ if "!internet_available!"=="0" (
     pause >nul
     goto troubleshooting_menu
 )
-set "rollback_version=0.250529.2"
+set "rollback_version=0.250813.1"
 echo Forcing reinstall of %medicafe_package%==%rollback_version% with no dependencies...
 python -m pip install --no-deps --force-reinstall %medicafe_package%==%rollback_version%
 if errorlevel 1 (

{medicafe-0.250813.1 → medicafe-0.250814.3}/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 may have new dates of service.\n      Their diagnosis codes may 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.1 → medicafe-0.250814.3}/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.1 → medicafe-0.250814.3}/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,51 @@ 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():
+        # Convert surgery dates to strings for consistent storage
+        surgery_date_strings = []
+        for date in patient_surgery_dates[patient_id]:
+            if isinstance(date, datetime):
+                if date == datetime.min:
+                    surgery_date_strings.append('MISSING')
+                else:
+                    surgery_date_strings.append(date.strftime('%m-%d-%Y'))
+            else:
+                surgery_date_strings.append(str(date) if date else 'MISSING')
+        
+        row['_all_surgery_dates'] = sorted(surgery_date_strings)
+        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?
@@ -542,7 +576,7 @@ def combine_fields(csv_data):
                 if surgery_date == datetime.min:
                     row['Surgery Date'] = 'MISSING'
                 else:
-                    row['Surgery Date'] = surgery_date.strftime('%m/%d/%Y')
+                    row['Surgery Date'] = surgery_date.strftime('%m-%d-%Y')
             elif surgery_date:
                 # Already a non-empty string
                 row['Surgery Date'] = str(surgery_date)
@@ -1096,7 +1130,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 +1138,61 @@ 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")
+                    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_str] = 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_str] = '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')
+                # Convert primary surgery date to string for lookup
+                if isinstance(primary_surgery_date, datetime):
+                    primary_surgery_date_str = primary_surgery_date.strftime('%m-%d-%Y')
                 else:
-                    MediLink_ConfigLoader.log("No matching surgery date found for Patient ID: {} in row {}.".format(patient_id, row_num), level="INFO")
+                    primary_surgery_date_str = str(primary_surgery_date)
+                primary_diagnosis = surgery_date_to_diagnosis.get(primary_surgery_date_str, '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.1 → medicafe-0.250814.3}/MediBot/MediBot_UI.py

@@ -1,7 +1,8 @@
 #MediBot_UI.py
-import ctypes, time, re, os, sys
+import ctypes, time, re
 from ctypes import wintypes
 from sys import exit
+from datetime import datetime
 
 # Set up paths using core utilities
 
@@ -27,6 +28,80 @@ 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:
+            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
+        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.1 → medicafe-0.250814.3}/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.1 → medicafe-0.250814.3}/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.1 → medicafe-0.250814.3}/MediBot/__init__.py

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

{medicafe-0.250813.1 → medicafe-0.250814.3}/MediBot/update_medicafe.py

@@ -1,4 +1,5 @@
 #update_medicafe.py
+# Version: 1.0.0
 import subprocess, sys, time, platform, os, shutil, random
 
 # Safe import for pkg_resources with fallback
@@ -305,6 +306,7 @@ def upgrade_package(package, retries=4, delay=2, target_version=None):  # Update
     def get_installed_version_fresh(package):
         """Get installed version using a fresh subprocess to avoid pkg_resources cache issues."""
         try:
+            # First try pip show
             process = subprocess.Popen(
                 [sys.executable, '-m', 'pip', 'show', package],
                 stdout=subprocess.PIPE,
@@ -315,6 +317,21 @@ def upgrade_package(package, retries=4, delay=2, target_version=None):  # Update
                 for line in stdout.decode().splitlines():
                     if line.startswith("Version:"):
                         return line.split(":", 1)[1].strip()
+            
+            # If pip show fails, try pkg_resources in a fresh subprocess
+            try:
+                import subprocess
+                process = subprocess.Popen(
+                    [sys.executable, '-c', 'import pkg_resources; print(pkg_resources.get_distribution("{}").version)'.format(package)],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE
+                )
+                stdout, stderr = process.communicate()
+                if process.returncode == 0:
+                    return stdout.decode().strip()
+            except Exception:
+                pass
+                
             return None
         except Exception as e:
             print("Warning: Could not get fresh version: {}".format(e))
@@ -335,17 +352,40 @@ def upgrade_package(package, retries=4, delay=2, target_version=None):  # Update
         
         if process.returncode == 0:
             print(stdout.decode().strip())
-            # Add delay to allow file system to settle
-            time.sleep(1)
-            new_version = get_installed_version_fresh(package)
+            # Add longer delay to allow file system and package metadata to settle
+            print("Waiting for package metadata to update...")
+            time.sleep(3)
+            
+            # Try multiple times to get the new version with increasing delays
+            new_version = None
+            for retry in range(3):
+                # Clear pkg_resources cache before each attempt
+                if pkg_resources:
+                    try:
+                        pkg_resources.working_set = pkg_resources.WorkingSet()
+                    except Exception:
+                        pass
+                
+                new_version = get_installed_version_fresh(package)
+                if new_version:
+                    print("Detected new version: {}".format(new_version))
+                    break
+                print("Version detection attempt {} failed, retrying...".format(retry + 1))
+                time.sleep(2)
+            
             expected_version = target_version or get_latest_version(package)
             
             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
+            elif new_version:
+                print_status("Upgrade may have succeeded but version mismatch. Current: {} Expected: {}".format(
+                    new_version, expected_version), "WARNING")
+                # If we got a new version but it doesn't match expected, still consider it a success
+                # as the package was updated
+                return True
             else:
-                print_status("Upgrade incomplete. Current version: {} Expected at least: {}".format(
-                    new_version or "unknown", expected_version), "WARNING")
+                print_status("Upgrade incomplete. Could not detect new version.", "WARNING")
                 return False
         else:
             print(stderr.decode().strip())
@@ -604,10 +644,19 @@ def main():
         if upgrade_package(package, target_version=latest_version):
             # STEP 8: Verify upgrade
             debug_step(8, "Upgrade Verification")
+            
+            # Clear cache and wait for package metadata to settle
+            if pkg_resources:
+                try:
+                    pkg_resources.working_set = pkg_resources.WorkingSet()
+                except Exception:
+                    pass
+            
+            time.sleep(2)
             new_version = get_installed_version(package)
             print("New installed version: {}".format(new_version))
 
-            if compare_versions(new_version, latest_version) >= 0:
+            if new_version and compare_versions(new_version, latest_version) >= 0:
                 print_status("Upgrade successful. New version: {}".format(new_version), "SUCCESS")
 
                 # DEBUG STEP 9: Clear cache
@@ -619,8 +668,21 @@ def main():
                     print_status("Cache clearing failed, but update was successful.", "WARNING")
 
                 print_final_result(True, "Successfully upgraded to version {}".format(new_version))
+            elif new_version:
+                print_status("Upgrade completed but version verification unclear. New version: {}".format(new_version), "WARNING")
+                print_status("The package was updated, but version comparison failed. This may be due to caching issues.", "WARNING")
+                
+                # Still clear cache and exit successfully
+                debug_step(9, "Cache Clearing")
+                print_status("Clearing Python cache to prevent import issues...", "INFO")
+                if clear_python_cache():
+                    print_status("Cache cleared successfully. Update complete.", "SUCCESS")
+                else:
+                    print_status("Cache clearing failed, but update was successful.", "WARNING")
+
+                print_final_result(True, "Package updated (version verification unclear)")
             else:
-                print_status("Upgrade failed. Current version remains: {}".format(new_version), "ERROR")
+                print_status("Upgrade verification failed. Could not detect new version.", "ERROR")
                 print_final_result(False, "Upgrade verification failed")
         else:
             print_final_result(False, "Upgrade process failed")

{medicafe-0.250813.1 → medicafe-0.250814.3}/MediCafe/__init__.py

@@ -27,7 +27,7 @@ Smart Import System:
         api_suite = get_api_access()
 """
 
-__version__ = "0.250728.9"
+__version__ = "0.250814.3"
 __author__ = "Daniel Vidaud"
 __email__ = "daniel@personalizedtransformation.com"
 

{medicafe-0.250813.1 → medicafe-0.250814.3}/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:

{medicafe-0.250813.1 → medicafe-0.250814.3}/MediLink/__init__.py

@@ -22,7 +22,7 @@ Smart Import Integration:
         datamgmt = get_components('medilink_datamgmt')
 """
 
-__version__ = "0.250728.9"
+__version__ = "0.250814.3"
 __author__ = "Daniel Vidaud"
 __email__ = "daniel@personalizedtransformation.com"
 

{medicafe-0.250813.1/medicafe.egg-info → medicafe-0.250814.3}/PKG-INFO

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

{medicafe-0.250813.1 → medicafe-0.250814.3/medicafe.egg-info}/PKG-INFO

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

{medicafe-0.250813.1 → medicafe-0.250814.3}/setup.py

@@ -54,7 +54,7 @@ if long_description_text is None:
 
 setup(
     name='medicafe',
-    version="0.250813.1",
+    version="0.250814.3",
     description='MediCafe',
     long_description=long_description_text,
     long_description_content_type='text/markdown',
@@ -74,7 +74,7 @@ setup(
         'Operating System :: OS Independent',
     ],
     packages=find_packages(include=['MediCafe', 'MediCafe.*', 'MediBot', 'MediBot.*', 'MediLink', 'MediLink.*']),
-    include_package_data=True,
+    include_package_data=False,  # Disable automatic inclusion to prevent CSV files from being included
     package_data={
         'MediBot': ['MediBot.bat'],
         'MediLink': ['openssl.cnf', '*.html']

medicafe-0.250813.1/MANIFEST.in

@@ -1,4 +0,0 @@
-include MediBot/MediBot.bat
-include MediLink/openssl.cnf
-include MediLink/*.html
-include MediCafe/*.py