medicafe 0.250813.2__tar.gz → 0.250814.4__tar.gz

medicafe-0.250814.4/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.2 → medicafe-0.250814.4}/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.2 → medicafe-0.250814.4}/MediBot/MediBot.py

@@ -12,6 +12,55 @@ except ImportError:
     msvcrt = None  # Not available on non-Windows systems
 from collections import OrderedDict
 
+# ============================================================================
+# MINIMAL PROTECTION: Import State Validation
+# ============================================================================
+
+def validate_critical_imports():
+    """Validate that critical imports are in expected state before proceeding"""
+    critical_modules = {
+        'MediBot_Preprocessor': None,
+        'MediBot_Preprocessor_lib': None,
+        'MediBot_UI': None,
+        'MediBot_Crosswalk_Library': None
+    }
+    
+    # Test imports and capture state
+    try:
+        print("Testing MediCafe.core_utils import...")
+        from MediCafe.core_utils import import_medibot_module_with_debug
+        print("MediCafe.core_utils import successful")
+        
+        for module_name in critical_modules.keys():
+            print("Testing {} import...".format(module_name))
+            try:
+                module = import_medibot_module_with_debug(module_name)
+                critical_modules[module_name] = module
+                if module is None:
+                    print("  WARNING: {} import returned None".format(module_name))
+                else:
+                    print("  SUCCESS: {} import successful".format(module_name))
+            except Exception as e:
+                print("  ERROR: {} import failed with exception: {}".format(module_name, e))
+                critical_modules[module_name] = None
+    except Exception as e:
+        print("CRITICAL: Failed to import core utilities: {}".format(e))
+        return False, critical_modules
+    
+    # Check for None imports (the specific failure pattern)
+    failed_imports = []
+    for module_name, module in critical_modules.items():
+        if module is None:
+            failed_imports.append(module_name)
+    
+    if failed_imports:
+        print("CRITICAL: Import failures detected:")
+        for failed in failed_imports:
+            print("  - {}: Import returned None".format(failed))
+        return False, critical_modules
+    
+    return True, critical_modules
+
 # Use core utilities for standardized imports
 from MediCafe.core_utils import (
     import_medibot_module_with_debug, 
@@ -512,6 +561,19 @@ if __name__ == "__main__":
     try:
         if PERFORMANCE_LOGGING:
             print("Initializing. Loading configuration and preparing environment...")
+        
+        # PROTECTION: Validate critical imports before proceeding
+        print("Validating critical imports...")
+        import_valid, import_state = validate_critical_imports()
+        if not import_valid:
+            print("CRITICAL: Import validation failed. Cannot continue.")
+            print("This indicates a fundamental system configuration issue.")
+            print("Please check:")
+            print("  1. All MediBot modules exist in the MediBot directory")
+            print("  2. Python path is correctly configured")
+            print("  3. No syntax errors in MediBot modules")
+            sys.exit(1)
+        
         # Use MediCafe configuration system
         try:
             config_loader = get_config_loader_with_fallback()
@@ -553,6 +615,22 @@ if __name__ == "__main__":
             print("Starting CSV preprocessing at: {}".format(time.strftime("%H:%M:%S")))
         MediLink_ConfigLoader.log("Starting CSV preprocessing at: {}".format(time.strftime("%H:%M:%S")), level="INFO")
         
+        # PROTECTION: Validate MediBot_Preprocessor before calling preprocess_csv_data
+        if MediBot_Preprocessor is None:
+            print("CRITICAL: MediBot_Preprocessor is None when trying to call preprocess_csv_data")
+            print("This indicates the import failed silently during execution.")
+            print("Import state at failure:")
+            for module_name, module in import_state.items():
+                status = "None" if module is None else "OK"
+                print("  - {}: {}".format(module_name, status))
+            print("Please check for syntax errors or missing dependencies in MediBot modules.")
+            sys.exit(1)
+        
+        if not hasattr(MediBot_Preprocessor, 'preprocess_csv_data'):
+            print("CRITICAL: MediBot_Preprocessor missing preprocess_csv_data function")
+            print("Available functions: {}".format([attr for attr in dir(MediBot_Preprocessor) if not attr.startswith('_')]))
+            sys.exit(1)
+        
         MediBot_Preprocessor.preprocess_csv_data(csv_data, e_state.crosswalk)  
         
         # TIMING: End CSV preprocessing timing
@@ -623,7 +701,16 @@ if __name__ == "__main__":
                         
                         # 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')
+                            # 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))
                             
                     except Exception as e:
@@ -633,7 +720,7 @@ if __name__ == "__main__":
                 # 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:",
+                    "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
                 )
 
@@ -655,7 +742,16 @@ if __name__ == "__main__":
                     
                     # 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')
+                        # 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))
 
                 # Display new patients table using the enhanced display function
@@ -695,7 +791,41 @@ if __name__ == "__main__":
         if e_state:
             interaction_mode = 'error'  # Switch to error mode
             error_message = str(e)  # Capture the error message
-        print("An error occurred while running MediBot: {}".format(e))
+        
+        # ENHANCED ERROR DIAGNOSTICS
+        print("=" * 60)
+        print("MEDIBOT EXECUTION FAILURE")
+        print("=" * 60)
+        print("Error: {}".format(e))
+        print("Error type: {}".format(type(e).__name__))
+        
+        # Check for the specific failure pattern
+        if "'NoneType' object has no attribute" in str(e):
+            print("DIAGNOSIS: This is the import failure pattern.")
+            print("A module import returned None, causing a method call to fail.")
+            print("This typically indicates:")
+            print("  1. Syntax error in a MediBot module")
+            print("  2. Missing dependency")
+            print("  3. Import path issue")
+            print("  4. Circular import problem")
+            
+            # Show current import state
+            print("Current import state:")
+            try:
+                import_state = {
+                    'MediBot_Preprocessor': MediBot_Preprocessor,
+                    'MediBot_Preprocessor_lib': MediBot_Preprocessor_lib,
+                    'MediBot_UI': MediBot_UI,
+                    'MediBot_Crosswalk_Library': MediBot_Crosswalk_Library
+                }
+                for module_name, module in import_state.items():
+                    status = "None" if module is None else "OK"
+                    print("  - {}: {}".format(module_name, status))
+            except Exception as diag_e:
+                print("  - Unable to diagnose import state: {}".format(diag_e))
+        
+        print("=" * 60)
+        
         # Handle the error by calling user interaction with the error information
         if 'identified_fields' in locals():
             _ = user_interaction(csv_data, interaction_mode, error_message, reverse_mapping)

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

@@ -547,7 +547,18 @@ def sort_and_deduplicate(csv_data):
 
     # 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])
+        # 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
@@ -565,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)
@@ -1149,30 +1160,69 @@ def update_diagnosis_codes(csv_data):
                     MediLink_ConfigLoader.log("Patient ID: {}, Surgery Date: {}".format(patient_id, surgery_date_str), level="DEBUG")
 
                     if surgery_date_str in all_patient_data[patient_id]:
-                        diagnosis_code, left_or_right_eye, femto_yes_or_no = all_patient_data[patient_id][surgery_date_str]
+                        diagnosis_data = all_patient_data[patient_id][surgery_date_str]
+                        # XP SP3 + Py3.4.4 compatible tuple unpacking with safety check
+                        try:
+                            if isinstance(diagnosis_data, (list, tuple)) and len(diagnosis_data) >= 3:
+                                diagnosis_code, left_or_right_eye, femto_yes_or_no = diagnosis_data
+                            else:
+                                # Handle case where diagnosis_data is not a proper tuple
+                                diagnosis_code = diagnosis_data if diagnosis_data else None
+                                left_or_right_eye = None
+                                femto_yes_or_no = None
+                        except Exception as e:
+                            MediLink_ConfigLoader.log("Error unpacking diagnosis data for Patient ID: {}, Surgery Date: {}: {}".format(
+                                patient_id, surgery_date_str, str(e)), level="WARNING")
+                            diagnosis_code = None
+                            left_or_right_eye = None
+                            femto_yes_or_no = None
+                        
                         MediLink_ConfigLoader.log("Found diagnosis data for Patient ID: {}, Surgery Date: {}".format(patient_id, surgery_date_str), level="DEBUG")
                         
-                        # Convert diagnosis code to Medisoft shorthand format.
-                        medisoft_shorthand = diagnosis_to_medisoft.get(diagnosis_code, None)
-                        if medisoft_shorthand is None and diagnosis_code:
-                            # Use fallback logic for missing mapping
-                            defaulted_code = diagnosis_code.lstrip('H').lstrip('T8').replace('.', '')[-5:]
-                            medisoft_shorthand = defaulted_code
-                            MediLink_ConfigLoader.log("Missing diagnosis mapping for '{}', using fallback code '{}'".format(
-                                diagnosis_code, medisoft_shorthand), level="WARNING")
+                                                # Convert diagnosis code to Medisoft shorthand format.
+                        # XP SP3 + Py3.4.4 compatible null check
+                        if diagnosis_code is None:
+                            medisoft_shorthand = 'N/A'
+                            MediLink_ConfigLoader.log("Diagnosis code is None for Patient ID: {}, Surgery Date: {}".format(
+                                patient_id, surgery_date_str), level="WARNING")
+                        else:
+                            medisoft_shorthand = diagnosis_to_medisoft.get(diagnosis_code, None)
+                            if medisoft_shorthand is None and diagnosis_code:
+                                # Use fallback logic for missing mapping (XP SP3 + Py3.4.4 compatible)
+                                try:
+                                    defaulted_code = diagnosis_code.lstrip('H').lstrip('T8').replace('.', '')[-5:]
+                                    # Basic validation: ensure code is not empty and has reasonable length
+                                    if defaulted_code and len(defaulted_code) >= 3:
+                                        medisoft_shorthand = defaulted_code
+                                        MediLink_ConfigLoader.log("Missing diagnosis mapping for '{}', using fallback code '{}'".format(
+                                            diagnosis_code, medisoft_shorthand), level="WARNING")
+                                    else:
+                                        medisoft_shorthand = 'N/A'
+                                        MediLink_ConfigLoader.log("Fallback diagnosis code validation failed for '{}', using 'N/A'".format(
+                                            diagnosis_code), level="WARNING")
+                                except Exception as e:
+                                    medisoft_shorthand = 'N/A'
+                                    MediLink_ConfigLoader.log("Error in fallback diagnosis code generation for '{}': {}".format(
+                                        diagnosis_code, str(e)), level="WARNING")
+                        
                         MediLink_ConfigLoader.log("Converted diagnosis code to Medisoft shorthand: {}".format(medisoft_shorthand), level="DEBUG")
                         
-                        surgery_date_to_diagnosis[surgery_date] = medisoft_shorthand
+                        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] = 'N/A'
+                        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')
-                primary_diagnosis = surgery_date_to_diagnosis.get(primary_surgery_date, 'N/A')
+                # 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:
+                    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
@@ -1472,12 +1522,28 @@ def capitalize_all_fields(csv_data):
     Returns:
     None: The function modifies the csv_data in place.
     """
-    # PERFORMANCE FIX: Optimize uppercase conversion using dict comprehension
+    # PERFORMANCE FIX: Optimize uppercase conversion while preserving complex types
     for row in csv_data:
-        # Single-pass update using dict comprehension
-        row.update({
-            key: (value.upper() if isinstance(value, str) 
-                  else str(value).upper() if value is not None and not isinstance(value, datetime)
-                  else value)
-            for key, value in row.items()
-        })
+        updated_row = {}
+        for key, value in row.items():
+            # Preserve internal/derived fields intact (e.g., `_all_surgery_dates`, `_surgery_date_to_diagnosis`)
+            if isinstance(key, str) and key.startswith('_'):
+                updated_row[key] = value
+                continue
+            # Uppercase plain strings
+            if isinstance(value, str):
+                updated_row[key] = value.upper()
+                continue
+            # Preserve complex containers; optionally uppercase their string contents
+            if isinstance(value, list):
+                updated_row[key] = [elem.upper() if isinstance(elem, str) else elem for elem in value]
+                continue
+            if isinstance(value, dict):
+                updated_row[key] = {k: (v.upper() if isinstance(v, str) else v) for k, v in value.items()}
+                continue
+            # Leave datetimes as-is; coerce simple scalars to string upper for consistency
+            if isinstance(value, datetime):
+                updated_row[key] = value
+            else:
+                updated_row[key] = str(value).upper() if value is not None else value
+        row.update(updated_row)

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

@@ -2,6 +2,7 @@
 import ctypes, time, re
 from ctypes import wintypes
 from sys import exit
+from datetime import datetime
 
 # Set up paths using core utilities
 
@@ -42,53 +43,87 @@ def display_enhanced_patient_table(patient_info, title, show_line_numbers=True):
     print(title)
     print()
     
-    # Sort by surgery date first and then by patient name
-    patient_info.sort(key=lambda x: (x[0], x[1]))
+    # Normalize data to avoid None and unexpected container types in sort key
+    normalized_info = []
+    for surgery_date, patient_name, patient_id, diagnosis_code, patient_row in patient_info:
+        # Normalize date into comparable key and display string
+        display_date = None
+        sort_key = None
+        try:
+            if hasattr(surgery_date, 'strftime'):
+                display_date = surgery_date.strftime('%m-%d')
+                sort_key = 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])
+                else:
+                    display_date = surgery_date or 'Unknown Date'
+                # Use the raw string as sort key fallback
+                sort_key = surgery_date or ''
+            else:
+                display_date = str(surgery_date) if surgery_date is not None else 'Unknown Date'
+                sort_key = display_date
+        except Exception:
+            display_date = str(surgery_date) if surgery_date is not None else 'Unknown Date'
+            sort_key = display_date
+        
+        # Normalize diagnosis display: only show "-Not Found-" when explicitly flagged as N/A
+        # XP SP3 + Py3.4.4 compatible error handling
+        display_diagnosis = diagnosis_code
+        try:
+            if diagnosis_code == "N/A":
+                display_diagnosis = "-Not Found-"
+            elif diagnosis_code is None:
+                display_diagnosis = "-Not Found-"
+            elif isinstance(diagnosis_code, str) and diagnosis_code.strip() == "":
+                display_diagnosis = "-Not Found-"
+            else:
+                display_diagnosis = str(diagnosis_code)
+        except (TypeError, ValueError) as e:
+            # Log the specific error for debugging (ASCII-only compatible)
+            try:
+                error_msg = "Error converting diagnosis code to string: {}".format(str(e))
+                MediLink_ConfigLoader.log(error_msg, level="WARNING")
+            except Exception:
+                # Fallback logging if string formatting fails
+                MediLink_ConfigLoader.log("Error converting diagnosis code to string", level="WARNING")
+            display_diagnosis = "-Not Found-"
+        
+        normalized_info.append((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]))
     
     # Calculate column widths for proper alignment
-    max_patient_id_len = max(len(str(pid)) for _, _, pid, _, _ in patient_info)
-    max_patient_name_len = max(len(pname) for _, pname, _, _, _ in patient_info)
-    max_diagnosis_len = max(len(dcode) for _, _, _, dcode, _ in patient_info)
+    max_patient_id_len = max(len(pid) for _, _, _, pid, _ in normalized_info)
+    max_patient_name_len = max(len(pname) for _, _, pname, _, _ in normalized_info)
+    max_diagnosis_len = max(len(dcode) for _, _, _, _, dcode in normalized_info)
     
     # Ensure minimum widths for readability
     max_patient_id_len = max(max_patient_id_len, 5)  # 5-digit ID max
     max_patient_name_len = max(max_patient_name_len, 12)  # "Patient Name" header
     max_diagnosis_len = max(max_diagnosis_len, 10)  # "Diagnosis" header
     
-    # Print the sorted patient info with multiple surgery dates
     current_patient = None
     line_number = 1
     
-    for surgery_date, patient_name, patient_id, diagnosis_code, patient_row in patient_info:
-        # Format surgery_date safely whether it's a datetime/date or a string
-        try:
-            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
+    for sort_key, formatted_date, patient_name, patient_id, display_diagnosis in normalized_info:
         if current_patient == patient_id:
-            # Secondary surgery date - indent and show dashes for patient info
-            # Use exact character count matching for dashes
-            patient_id_dashes = '-' * len(str(patient_id))
+            patient_id_dashes = '-' * len(patient_id)
             patient_name_dashes = '-' * len(patient_name)
-            
             secondary_format = "     {:<6} | {:<" + str(max_patient_id_len) + "} | {:<" + str(max_patient_name_len) + "} | {:<" + str(max_diagnosis_len) + "}"
             print(secondary_format.format(formatted_date, patient_id_dashes, patient_name_dashes, display_diagnosis))
         else:
-            # New patient - show full patient info
             current_patient = patient_id
             if show_line_numbers:
                 primary_format = "{:03d}: {:<6} | {:<" + str(max_patient_id_len) + "} | {:<" + str(max_patient_name_len) + "} | {:<" + str(max_diagnosis_len) + "}"
-                print(primary_format.format(line_number, formatted_date, str(patient_id), patient_name, display_diagnosis))
+                print(primary_format.format(line_number, formatted_date, patient_id, patient_name, display_diagnosis))
                 line_number += 1
             else:
-                # For existing patients, don't show line numbers
                 primary_format = "     {:<6} | {:<" + str(max_patient_id_len) + "} | {:<" + str(max_patient_name_len) + "} | {:<" + str(max_diagnosis_len) + "}"
-                print(primary_format.format(formatted_date, str(patient_id), patient_name, display_diagnosis))
+                print(primary_format.format(formatted_date, patient_id, patient_name, display_diagnosis))
 
 # Function to check if a specific key is pressed
 def _get_vk_codes():

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

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