medicafe 0.250806.10__tar.gz → 0.250806.13__tar.gz

{medicafe-0.250806.10 → medicafe-0.250806.13}/MediBot/MediBot.bat

@@ -2,16 +2,38 @@
 @echo off
 setlocal enabledelayedexpansion
 
-:: Define paths
+:: Define paths with local fallbacks for F: drive dependencies
 set "source_folder=C:\MEDIANSI\MediCare"
-set "local_storage_path=F:\Medibot\DOWNLOADS"
 set "target_folder=C:\MEDIANSI\MediCare\CSV"
-set "config_file=F:\Medibot\json\config.json"
 set "python_script=C:\Python34\Lib\site-packages\MediBot\update_json.py"
 set "python_script2=C:\Python34\Lib\site-packages\MediBot\Medibot.py"
 set "medicafe_package=medicafe"
-set upgrade_medicafe=F:\Medibot\update_medicafe.py
-set "temp_file=F:\Medibot\last_update_timestamp.txt"
+
+:: Priority order: 1) Local relative path, 2) F: drive path (legacy)
+set "upgrade_medicafe_local=MediBot\update_medicafe.py"
+set "upgrade_medicafe_legacy=F:\Medibot\update_medicafe.py"
+
+:: Storage and config paths with local fallbacks
+set "local_storage_legacy=F:\Medibot\DOWNLOADS"
+set "local_storage_local=MediBot\DOWNLOADS"
+set "config_file_legacy=F:\Medibot\json\config.json"
+set "config_file_local=MediBot\json\config.json"
+set "temp_file_legacy=F:\Medibot\last_update_timestamp.txt"
+set "temp_file_local=MediBot\last_update_timestamp.txt"
+
+:: Determine which paths to use based on availability
+if exist "F:\Medibot" (
+    set "local_storage_path=%local_storage_legacy%"
+    set "config_file=%config_file_legacy%"
+    set "temp_file=%temp_file_legacy%"
+) else (
+    set "local_storage_path=%local_storage_local%"
+    set "config_file=%config_file_local%"
+    set "temp_file=%temp_file_local%"
+    :: Ensure local directories exist
+    if not exist "MediBot\json" mkdir "MediBot\json" 2>nul
+    if not exist "MediBot\DOWNLOADS" mkdir "MediBot\DOWNLOADS" 2>nul
+)
 set "firefox_path=C:\Program Files\Mozilla Firefox\firefox.exe"
 set "claims_status_script=..\MediLink\MediLink_ClaimStatus.py"
 set "deductible_script=..\MediLink\MediLink_Deductible.py"
@@ -214,72 +236,175 @@ if exist "!alt_config_path!" (
 
 :config_check_complete
 
-:: Check if the file exists and attempt to move it
-:: Implementing a check with copy as a fallback if move fails
+:: Check if the file exists and attempt to copy it to the local directory
 echo Checking for the update script...
 ping -n 2 127.0.0.1 >nul
-if exist "C:\Python34\Lib\site-packages\MediBot\update_medicafe.py" (
-    echo Found update_medicafe.py. Attempting to move...
-    ping -n 2 127.0.0.1 >nul
-    move "C:\Python34\Lib\site-packages\MediBot\update_medicafe.py" "F:\Medibot\update_medicafe.py" >nul 2>&1
-    if %errorlevel% neq 0 (
-        echo Move failed. Attempting copy and delete as fallback...
-        ping -n 2 127.0.0.1 >nul
-        copy "C:\Python34\Lib\site-packages\MediBot\update_medicafe.py" "F:\Medibot\update_medicafe.py" >nul 2>&1
-        if %errorlevel% neq 0 (
-            echo Copy failed. Error Level: %errorlevel%
-            ping -n 2 127.0.0.1 >nul
+
+:: DIAGNOSTIC SECTION - Analyze F: drive accessibility
+echo.
+echo ==========================================
+echo F: DRIVE ACCESSIBILITY DIAGNOSTICS
+echo ==========================================
+echo.
+
+:: Check if F: drive exists at all
+echo [DIAGNOSTIC] Checking F: drive existence...
+if exist "F:\" (
+    echo [OK] F: drive is accessible
+    
+    :: Check F: drive properties
+    echo [DIAGNOSTIC] F: drive properties:
+    dir F:\ | find "Directory of" 2>nul || echo [!] Cannot read F: drive directory listing
+    
+    :: Check available space
+    echo [DIAGNOSTIC] F: drive free space:
+    dir F:\ | find "bytes free" 2>nul || echo [!] Cannot determine free space
+    
+    :: Check if F:\Medibot directory exists
+    echo [DIAGNOSTIC] Checking F:\Medibot directory...
+    if exist "F:\Medibot" (
+        echo [OK] F:\Medibot directory exists
+        
+        :: Check directory permissions by attempting to create a test file
+        echo [DIAGNOSTIC] Testing write permissions to F:\Medibot...
+        echo test > "F:\Medibot\permission_test.tmp" 2>nul
+        if exist "F:\Medibot\permission_test.tmp" (
+            echo [OK] Write permissions confirmed
+            del "F:\Medibot\permission_test.tmp" >nul 2>&1
         ) else (
-            del "C:\Python34\Lib\site-packages\MediBot\update_medicafe.py" >nul 2>&1
-            if %errorlevel% neq 0 (
-                echo Delete failed. Manual cleanup may be required.
-                ping -n 2 127.0.0.1 >nul
+            echo [ERROR] PERMISSION DENIED - Cannot write to F:\Medibot
+            echo [ERROR] This is likely the cause of the path error!
+        )
+        
+        :: List contents of F:\Medibot
+        echo [DIAGNOSTIC] F:\Medibot directory contents:
+        dir /b "F:\Medibot" 2>nul || echo [!] Cannot list directory contents (permission issue?)
+        
+        :: Check if update_medicafe.py specifically exists
+        echo [DIAGNOSTIC] Checking for update_medicafe.py...
+        if exist "F:\Medibot\update_medicafe.py" (
+            echo [OK] update_medicafe.py found at F:\Medibot\update_medicafe.py
+            echo [DIAGNOSTIC] File details:
+            dir "F:\Medibot\update_medicafe.py" 2>nul || echo [!] Cannot read file details
+            
+            :: Test file accessibility by attempting to read it
+            echo [DIAGNOSTIC] Testing file read permissions...
+            type "F:\Medibot\update_medicafe.py" | find "#update_medicafe.py" >nul 2>&1
+            if %errorlevel% equ 0 (
+                echo [OK] File is readable
             ) else (
-                echo File copied and original deleted successfully.
-                ping -n 2 127.0.0.1 >nul
+                                 echo [ERROR] FILE READ ERROR - Cannot read update_medicafe.py
+                echo [ERROR] File exists but is not accessible (permission/lock issue?)
             )
+        ) else (
+                         echo [ERROR] update_medicafe.py NOT FOUND at F:\Medibot\update_medicafe.py
         )
+        
     ) else (
-        echo File moved successfully.
-        ping -n 2 127.0.0.1 >nul
+                 echo [ERROR] F:\Medibot directory does NOT exist
+        echo [DIAGNOSTIC] Attempting to create F:\Medibot...
+        mkdir "F:\Medibot" 2>nul
+        if exist "F:\Medibot" (
+            echo [OK] Successfully created F:\Medibot directory
+        ) else (
+            echo [ERROR] FAILED to create F:\Medibot directory
+            echo [ERROR] Permission denied or F: drive is read-only
+        )
     )
+    
 ) else (
-    echo update_medicafe.py not detected. Checking for existing update_medicafe.py in F:\Medibot...
+    echo [ERROR] F: drive is NOT accessible
+    echo [ERROR] F: drive may be:
+    echo    - Disconnected network drive
+    echo    - Unmounted USB/external drive  
+    echo    - Mapped drive that's no longer available
+    echo    - Security policy blocking access
+    
+    :: Check what drives are actually available
+    echo [DIAGNOSTIC] Available drives on this system:
+    wmic logicaldisk get size,freespace,caption 2>nul || echo [!] Cannot enumerate drives
+)
+
+echo.
+echo ==========================================
+echo END F: DRIVE DIAGNOSTICS
+echo ==========================================
+echo.
+
+:: Continue with existing logic but with enhanced error reporting
+:: First check if we already have it locally
+if exist "%upgrade_medicafe_local%" (
+    echo Found update_medicafe.py in local directory. No action needed.
     ping -n 2 127.0.0.1 >nul
-    if exist "F:\Medibot\update_medicafe.py" (
-        echo update_medicafe.py already exists in F:\Medibot. No action needed.
+) else if exist "C:\Python34\Lib\site-packages\MediBot\update_medicafe.py" (
+    echo Found update_medicafe.py in site-packages. Copying to local directory...
+    ping -n 2 127.0.0.1 >nul
+    :: Ensure MediBot directory exists
+    if not exist "MediBot" mkdir "MediBot"
+    copy "C:\Python34\Lib\site-packages\MediBot\update_medicafe.py" "%upgrade_medicafe_local%" >nul 2>&1
+    if %errorlevel% neq 0 (
+        echo Copy to local directory failed. Error code: %errorlevel%
+        echo [DIAGNOSTIC] Attempting copy to F: drive (with detailed error reporting)...
         ping -n 2 127.0.0.1 >nul
-    ) else (
-        echo update_medicafe.py not detected in either location. Check path and filename.
-        echo.
-        echo Expected update script path: F:\Medibot\update_medicafe.py
-        echo.
-        echo Would you like to provide an alternate path for the update script?
-        set /p provide_alt_update="Enter 'Y' to provide alternate path, or any other key to continue: "
-        if /i "!provide_alt_update!"=="Y" (
-            echo.
-            echo Please enter the full path to your update_medicafe.py file.
-            echo Example: C:\MediBot\scripts\update_medicafe.py
-            echo Example with spaces: "G:\My Drive\MediBot\scripts\update_medicafe.py"
-            echo.
-            echo Note: If your path contains spaces, please include quotes around the entire path.
-            echo.
-            set /p alt_update_path="Enter update script path: "
-            :: Remove any surrounding quotes from user input and re-add them for consistency
-            set "alt_update_path=!alt_update_path:"=!"
-            if exist "!alt_update_path!" (
-                echo Update script found at: !alt_update_path!
-                set upgrade_medicafe=!alt_update_path!
-            ) else (
-                echo Update script not found at: !alt_update_path!
-                echo Continuing without update script...
-                ping -n 2 127.0.0.1 >nul
+        :: Ensure F:\Medibot directory exists (only if F: drive is accessible)
+        if exist "F:\" (
+            if not exist "F:\Medibot" (
+                echo [DIAGNOSTIC] Creating F:\Medibot directory...
+                mkdir "F:\Medibot" 2>nul
+                if not exist "F:\Medibot" (
+                    echo [ERROR] Failed to create F:\Medibot - Permission denied or read-only drive
+                )
+            )
+            if exist "F:\Medibot" (
+                echo [DIAGNOSTIC] Attempting file copy to F:\Medibot...
+                copy "C:\Python34\Lib\site-packages\MediBot\update_medicafe.py" "%upgrade_medicafe_legacy%" 2>nul
+                if %errorlevel% neq 0 (
+                    echo [ERROR] Copy to F:\Medibot failed with error code: %errorlevel%
+                    echo [ERROR] Possible causes:
+                    echo    - Permission denied (insufficient write access)
+                    echo    - Disk full
+                    echo    - File locked by another process
+                    echo    - Antivirus blocking the operation
+                ) else (
+                    echo [SUCCESS] File copied to F:\Medibot successfully
+                )
             )
         ) else (
-            echo Continuing without update script...
-            ping -n 2 127.0.0.1 >nul
+            echo [ERROR] F: drive not accessible - skipping F: drive copy attempt
         )
+    ) else (
+        echo File copied to local directory successfully.
+        ping -n 2 127.0.0.1 >nul
     )
+) else if exist "%upgrade_medicafe_legacy%" (
+    echo Found update_medicafe.py in legacy F: drive location.
+    echo [DIAGNOSTIC] Verifying F: drive file accessibility...
+    type "%upgrade_medicafe_legacy%" | find "#update_medicafe.py" >nul 2>&1
+    if %errorlevel% equ 0 (
+        echo [OK] F: drive file is accessible and readable
+    ) else (
+        echo [ERROR] F: drive file exists but cannot be read (permission/lock issue)
+    )
+    ping -n 2 127.0.0.1 >nul
+) else (
+    echo update_medicafe.py not detected in any known location.
+    echo.
+    echo Checked locations:
+    echo   - Site-packages: C:\Python34\Lib\site-packages\MediBot\update_medicafe.py
+    echo   - Local: %upgrade_medicafe_local%
+    echo   - Legacy: %upgrade_medicafe_legacy%
+    echo.
+    echo [DIAGNOSTIC] Current working directory:
+    cd
+    echo [DIAGNOSTIC] Current directory contents:
+    dir /b
+    echo.
+    echo [DIAGNOSTIC] MediBot directory contents:
+    dir /b MediBot\ 2>nul || echo MediBot directory not found
+    echo.
+    echo Continuing without update script...
+    ping -n 2 127.0.0.1 >nul
+)
 )
 
 :: Main menu
@@ -355,27 +480,27 @@ echo ========================================
 echo DEBUG STEP 1: Checking for update script
 echo ========================================
 echo.
-echo Checking if update script exists at: %upgrade_medicafe%
-if exist "%upgrade_medicafe%" (
-    echo [SUCCESS] Found update script at: %upgrade_medicafe%
+echo Checking for update script (priority: local first, then legacy path)...
+if exist "%upgrade_medicafe_local%" (
+    echo [SUCCESS] Found update script at: %upgrade_medicafe_local%
+    echo File size: 
+    dir "%upgrade_medicafe_local%" | find "update_medicafe.py"
+    set "upgrade_medicafe=%upgrade_medicafe_local%"
+) else if exist "%upgrade_medicafe_legacy%" (
+    echo [SUCCESS] Found update script at legacy location: %upgrade_medicafe_legacy%
     echo File size: 
-    dir "%upgrade_medicafe%" | find "update_medicafe.py"
+    dir "%upgrade_medicafe_legacy%" | find "update_medicafe.py"
+    set "upgrade_medicafe=%upgrade_medicafe_legacy%"
 ) else (
-    echo [FAILED] Update script not found at: %upgrade_medicafe%
+    echo [FAILED] Update script not found in either location:
+    echo   - Local: %upgrade_medicafe_local%
+    echo   - Legacy: %upgrade_medicafe_legacy%
     echo.
-    echo Checking alternative location: MediBot\update_medicafe.py
-    if exist "MediBot\update_medicafe.py" (
-        echo [SUCCESS] Found update script at: MediBot\update_medicafe.py
-        echo File size:
-        dir "MediBot\update_medicafe.py" | find "update_medicafe.py"
-    ) else (
-        echo [FAILED] Update script not found at: MediBot\update_medicafe.py
-        echo.
-        echo Available files in current directory:
-        dir /b
-        echo.
-        echo Available files in MediBot directory:
-        dir /b MediBot\ 2>nul || echo MediBot directory not found
+    echo Available files in current directory:
+    dir /b
+    echo.
+    echo Available files in MediBot directory:
+    dir /b MediBot\ 2>nul || echo MediBot directory not found
     )
 )
 echo.
@@ -477,48 +602,79 @@ echo.
 echo Starting update process...
 echo.
 
-:: Check if update_medicafe.py exists in the expected location, with fallback
-if exist "%upgrade_medicafe%" (
-    echo [INFO] Using update script at: %upgrade_medicafe%
-    echo Command: python "%upgrade_medicafe%" %package_version%
+:: Check if update_medicafe.py exists using the new priority system
+if exist "%upgrade_medicafe_local%" (
+    echo [INFO] Using local update script at: %upgrade_medicafe_local%
+    echo Command: python "%upgrade_medicafe_local%" %package_version%
+    
+    :: Pre-execution diagnostics
+    echo.
+    echo [DIAGNOSTIC] Pre-execution checks for local script:
+    echo [DIAGNOSTIC] File size and permissions:
+    dir "%upgrade_medicafe_local%" 2>nul || echo [!] Cannot read file details
+    echo [DIAGNOSTIC] Testing Python access to file:
+    python -c "import os; print('[OK] Python can access file') if os.path.exists('%upgrade_medicafe_local%') else print('[ERROR] Python cannot access file')" 2>nul || echo [!] Python test failed
+    
     echo.
     echo Press Enter to execute update command...
     pause >nul
     echo.
     echo Executing update command...
-    start "Medicafe Update" cmd /c "python \"%upgrade_medicafe%\" %package_version% & echo. & echo Update process completed. Press any key to close... & pause >nul" && (
-        echo %DATE% %TIME% Upgrade initiated successfully. >> "%temp_file%"
+    echo.
+    echo The update window will open and show detailed progress.
+    echo All output will be displayed on screen.
+    echo.
+    start "Medicafe Update" cmd /c "echo [DIAGNOSTIC] About to execute: python \"%upgrade_medicafe_local%\" %package_version% & echo. & python \"%upgrade_medicafe_local%\" %package_version% & echo. & echo [DIAGNOSTIC] Python exit code: %ERRORLEVEL% & echo Update process completed. Press any key to close... & pause >nul" && (
+        echo %DATE% %TIME% Upgrade initiated successfully (local). >> "%temp_file%"
         echo [SUCCESS] Update process started successfully
         echo All output will be displayed in the update window.
     ) || (
-        echo %DATE% %TIME% Update failed. >> "%temp_file%"
+        echo %DATE% %TIME% Update failed (local). >> "%temp_file%"
         echo [ERROR] Upgrade failed. Check the update window for details.
+        echo [DIAGNOSTIC] Possible causes for local script failure:
+        echo    - Python not in PATH
+        echo    - Script syntax error
+        echo    - Missing Python dependencies
+        echo    - File corruption
     )
-) else if exist "MediBot\update_medicafe.py" (
-    echo [INFO] Using update script at: MediBot\update_medicafe.py
-    echo Command: python "MediBot\update_medicafe.py" %package_version%
+) else if exist "%upgrade_medicafe_legacy%" (
+    echo [INFO] Using legacy update script at: %upgrade_medicafe_legacy%
+    echo Command: python "%upgrade_medicafe_legacy%" %package_version%
+    
+    :: Pre-execution diagnostics for F: drive
+    echo.
+    echo [DIAGNOSTIC] Pre-execution checks for F: drive script:
+    echo [DIAGNOSTIC] File size and permissions:
+    dir "%upgrade_medicafe_legacy%" 2>nul || echo [!] Cannot read file details
+    echo [DIAGNOSTIC] Testing Python access to F: drive file:
+    python -c "import os; print('[OK] Python can access F: drive file') if os.path.exists('%upgrade_medicafe_legacy%') else print('[ERROR] Python cannot access F: drive file')" 2>nul || echo [!] Python F: drive test failed
+    echo [DIAGNOSTIC] Testing file read permissions:
+    type "%upgrade_medicafe_legacy%" | find "#update_medicafe.py" >nul 2>&1 && echo [OK] File content readable || echo [ERROR] Cannot read file content
+    
     echo.
     echo Press Enter to execute update command...
     pause >nul
     echo.
     echo Executing update command...
-    echo.
-    echo The update window will open and show detailed progress.
-    echo All output will be displayed on screen.
-    echo.
-    start "Medicafe Update" cmd /c "python \"MediBot\update_medicafe.py\" %package_version% & echo. & echo Update process completed. Press any key to close... & pause >nul" && (
-        echo %DATE% %TIME% Upgrade initiated successfully. >> "%temp_file%"
+    start "Medicafe Update" cmd /c "echo [DIAGNOSTIC] About to execute: python \"%upgrade_medicafe_legacy%\" %package_version% & echo [DIAGNOSTIC] F: drive accessibility test... & dir F:\ ^| find \"Directory of\" ^>nul 2^>^&1 ^&^& echo [OK] F: drive accessible ^|^| echo [ERROR] F: drive access lost & echo. & python \"%upgrade_medicafe_legacy%\" %package_version% & echo. & echo [DIAGNOSTIC] Python exit code: %ERRORLEVEL% & echo Update process completed. Press any key to close... & pause >nul" && (
+        echo %DATE% %TIME% Upgrade initiated successfully (legacy). >> "%temp_file%"
         echo [SUCCESS] Update process started successfully
         echo All output will be displayed in the update window.
     ) || (
-        echo %DATE% %TIME% Update failed. >> "%temp_file%"
+        echo %DATE% %TIME% Update failed (legacy). >> "%temp_file%"
         echo [ERROR] Upgrade failed. Check the update window for details.
+        echo [DIAGNOSTIC] Possible causes for F: drive script failure:
+        echo    - F: drive disconnected during execution
+        echo    - Permission denied accessing F: drive
+        echo    - F: drive file locked by antivirus
+        echo    - Network drive timeout
+        echo    - Python cannot access network paths
     )
 ) else (
     echo [ERROR] update_medicafe.py not found in either location
     echo Expected locations:
-    echo   - %upgrade_medicafe%
-    echo   - MediBot\update_medicafe.py
+    echo   - Local: %upgrade_medicafe_local%
+    echo   - Legacy: %upgrade_medicafe_legacy%
     echo.
     echo Current directory contents:
     dir /b
@@ -728,18 +884,39 @@ echo Clearing Python cache for MediCafe...
 echo.
 cd /d "%~dp0.."
 
-:: Check if update_medicafe.py exists in the moved location first
-if exist "F:\Medibot\update_medicafe.py" (
-    echo Found update_medicafe.py in F:\Medibot\ - using moved location
-    python "F:\Medibot\update_medicafe.py" --clear-cache
-) else if exist "MediBot\update_medicafe.py" (
-    echo Found update_medicafe.py in original location - using relative path
-    python "MediBot\update_medicafe.py" --clear-cache
+:: Check if update_medicafe.py exists using priority system (local first)
+if exist "%upgrade_medicafe_local%" (
+    echo Found update_medicafe.py in local location - using relative path
+    echo [DIAGNOSTIC] Cache clearing with local script:
+    echo [DIAGNOSTIC] Command: python "%upgrade_medicafe_local%" --clear-cache
+    python "%upgrade_medicafe_local%" --clear-cache
+    if %errorlevel% neq 0 (
+        echo [ERROR] Cache clearing failed with local script, error code: %errorlevel%
+        echo [DIAGNOSTIC] Possible causes:
+        echo    - Python not in PATH
+        echo    - Script syntax error
+        echo    - Missing dependencies
+    )
+) else if exist "%upgrade_medicafe_legacy%" (
+    echo Found update_medicafe.py in legacy location - using F: drive path
+    echo [DIAGNOSTIC] Cache clearing with F: drive script:
+    echo [DIAGNOSTIC] Command: python "%upgrade_medicafe_legacy%" --clear-cache
+    echo [DIAGNOSTIC] Testing F: drive access before execution:
+    dir "F:\Medibot" >nul 2>&1 && echo [OK] F: drive accessible || echo [ERROR] F: drive access issue
+    python "%upgrade_medicafe_legacy%" --clear-cache
+    if %errorlevel% neq 0 (
+        echo [ERROR] Cache clearing failed with F: drive script, error code: %errorlevel%
+        echo [DIAGNOSTIC] Possible causes:
+        echo    - F: drive disconnected during execution
+        echo    - Permission denied accessing F: drive file
+        echo    - F: drive file locked
+        echo    - Python cannot access network paths
+    )
 ) else (
     echo ERROR: update_medicafe.py not found in either location
     echo Expected locations:
-    echo   - F:\Medibot\update_medicafe.py
-    echo   - MediBot\update_medicafe.py
+    echo   - Local: %upgrade_medicafe_local%
+    echo   - Legacy: %upgrade_medicafe_legacy%
     pause
     goto main_menu
 )

{medicafe-0.250806.10 → medicafe-0.250806.13}/MediBot/MediBot.py

@@ -462,7 +462,7 @@ if __name__ == "__main__":
             
             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:

{medicafe-0.250806.10 → medicafe-0.250806.13}/MediBot/MediBot_Crosswalk_Library.py

@@ -256,14 +256,33 @@ def crosswalk_update(client, config, crosswalk): # Upstream of this is only Medi
     api_cache = {}
 
     # Load insurance data from MAINS (optional - continue if not available)
+    # XP/Python34 Compatibility: Enhanced error handling with verbose output
     insurance_name_to_id = {}
     try:
         MediLink_ConfigLoader.log("Attempting to load insurance data from MAINS...", config, level="DEBUG")
-        insurance_name_to_id = MediBot_Preprocessor_lib.load_insurance_data_from_mains(config)
-        MediLink_ConfigLoader.log("Loaded insurance data from MAINS with {} entries.".format(len(insurance_name_to_id)), config, level="INFO")
+        
+        if MediBot_Preprocessor_lib and hasattr(MediBot_Preprocessor_lib, 'load_insurance_data_from_mains'):
+            insurance_name_to_id = MediBot_Preprocessor_lib.load_insurance_data_from_mains(config)
+            if insurance_name_to_id:
+                MediLink_ConfigLoader.log("Loaded insurance data from MAINS with {} entries.".format(len(insurance_name_to_id)), config, level="INFO")
+            else:
+                MediLink_ConfigLoader.log("load_insurance_data_from_mains returned empty data", config, level="WARNING")
+        else:
+            error_msg = "MediBot_Preprocessor_lib or load_insurance_data_from_mains not available"
+            MediLink_ConfigLoader.log(error_msg, config, level="WARNING")
+            print("Warning: {}".format(error_msg))
+            
+    except AttributeError as e:
+        error_msg = "AttributeError accessing load_insurance_data_from_mains: {}".format(str(e))
+        MediLink_ConfigLoader.log(error_msg, config, level="WARNING")
+        print("Warning: {}. Some crosswalk features may be limited.".format(error_msg))
+    except ImportError as e:
+        error_msg = "ImportError with MediBot_Preprocessor_lib: {}".format(str(e))
+        MediLink_ConfigLoader.log(error_msg, config, level="WARNING")
+        print("Warning: {}. Some crosswalk features may be limited.".format(error_msg))
     except Exception as e:
         MediLink_ConfigLoader.log("Error loading insurance data from MAINS: {}. Continuing without MAINS data.".format(e), config, level="WARNING")
-        print("Warning: MAINS data not available. Some crosswalk features may be limited.")
+        print("Warning: MAINS data not available ({}). Some crosswalk features may be limited.".format(str(e)))
         # Continue without MAINS data - don't return False
 
     # Load historical payer to patient mappings (optional - continue if not available)

{medicafe-0.250806.10 → medicafe-0.250806.13}/MediBot/MediBot_Crosswalk_Utils.py

@@ -459,13 +459,32 @@ def update_crosswalk_with_new_payer_id(client, insurance_name, payer_id, config,
         return False
     
     # Load the Medisoft ID for the given insurance name
+    # XP/Python34 Compatibility: Enhanced error handling with verbose output
     try:
         # Note: MediBot_Preprocessor_lib is imported at module level
-        medisoft_id = MediBot_Preprocessor_lib.load_insurance_data_from_mains(config).get(insurance_name)
+        if MediBot_Preprocessor_lib and hasattr(MediBot_Preprocessor_lib, 'load_insurance_data_from_mains'):
+            insurance_data = MediBot_Preprocessor_lib.load_insurance_data_from_mains(config)
+            medisoft_id = insurance_data.get(insurance_name) if insurance_data else None
+            MediLink_ConfigLoader.log("Successfully retrieved insurance data for {}".format(insurance_name), config, level="DEBUG")
+        else:
+            error_msg = "MediBot_Preprocessor_lib or load_insurance_data_from_mains not available"
+            MediLink_ConfigLoader.log(error_msg, config, level="WARNING")
+            print("Warning: {}".format(error_msg))
+            medisoft_id = None
+    except AttributeError as e:
+        error_msg = "AttributeError accessing load_insurance_data_from_mains: {}".format(str(e))
+        MediLink_ConfigLoader.log(error_msg, config, level="WARNING")
+        print("Warning: {}".format(error_msg))
+        medisoft_id = None
     except KeyError as e:  # Handle KeyError for config
         MediLink_ConfigLoader.log("KeyError while loading Medisoft ID: {}".format(e), config, level="ERROR")
         print("KeyError while loading Medisoft ID for insurance name {}: {}".format(insurance_name, e))
         return False
+    except Exception as e:
+        error_msg = "Unexpected error loading insurance data: {}".format(str(e))
+        MediLink_ConfigLoader.log(error_msg, config, level="ERROR")
+        print("Error: {}".format(error_msg))
+        medisoft_id = None
 
     MediLink_ConfigLoader.log("Retrieved Medisoft ID for insurance name {}: {}.".format(insurance_name, medisoft_id), config, level="DEBUG")
     

{medicafe-0.250806.10 → medicafe-0.250806.13}/MediBot/MediBot_Preprocessor_lib.py

@@ -66,6 +66,56 @@ try:
 except ImportError:
     # Fallback to local flag if centralized config is not available
     PERFORMANCE_LOGGING = False
+
+# XP Compatibility: Add robust fallback for configuration loading
+def get_cached_configuration_xp_safe():
+    """
+    XP-compatible version of get_cached_configuration with robust fallbacks.
+    """
+    global _config_cache, _crosswalk_cache
+    
+    # If we already have cached data, return it
+    if _config_cache is not None and _crosswalk_cache is not None:
+        return _config_cache, _crosswalk_cache
+    
+    # Try to load configuration using the standard method
+    try:
+        if MediLink_ConfigLoader and hasattr(MediLink_ConfigLoader, 'load_configuration'):
+            _config_cache, _crosswalk_cache = MediLink_ConfigLoader.load_configuration()
+            return _config_cache, _crosswalk_cache
+    except Exception as e:
+        print("Warning: Failed to load configuration via MediLink_ConfigLoader: {}".format(e))
+    
+    # Fallback: Try to load configuration files directly
+    try:
+        import json
+        project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+        
+        # Try to load config.json
+        config_path = os.path.join(project_dir, 'json', 'config.json')
+        if os.path.exists(config_path):
+            with open(config_path, 'r') as f:
+                _config_cache = json.load(f)
+        else:
+            _config_cache = {}
+        
+        # Try to load crosswalk.json
+        crosswalk_path = os.path.join(project_dir, 'json', 'crosswalk.json')
+        if os.path.exists(crosswalk_path):
+            with open(crosswalk_path, 'r') as f:
+                _crosswalk_cache = json.load(f)
+        else:
+            _crosswalk_cache = {}
+        
+        return _config_cache, _crosswalk_cache
+        
+    except Exception as e:
+        print("Warning: Failed to load configuration files directly: {}".format(e))
+        # Return empty defaults
+        _config_cache = {}
+        _crosswalk_cache = {}
+        return _config_cache, _crosswalk_cache
+
 class InitializationError(Exception):
     def __init__(self, message):
         self.message = message
@@ -91,12 +141,7 @@ def get_cached_configuration():
     """
     Returns cached configuration and crosswalk data to avoid repeated I/O operations.
     """
-    global _config_cache, _crosswalk_cache
-    
-    if _config_cache is None or _crosswalk_cache is None:
-        _config_cache, _crosswalk_cache = MediLink_ConfigLoader.load_configuration()
-    
-    return _config_cache, _crosswalk_cache
+    return get_cached_configuration_xp_safe()
 
 def open_csv_for_editing(csv_file_path):
     try:
@@ -1134,7 +1179,17 @@ def load_insurance_data_from_mains(config):
         dict: A dictionary mapping insurance names to insurance IDs.
     """
     # Use cached configuration to avoid repeated loading
-    config, crosswalk = get_cached_configuration()
+    try:
+        config, crosswalk = get_cached_configuration()
+    except Exception as e:
+        print("Warning: Failed to load cached configuration: {}".format(e))
+        # Return empty mapping if configuration loading fails
+        return {}
+    
+    # XP Compatibility: Check if MediLink_DataMgmt is available
+    if MediLink_DataMgmt is None:
+        print("Warning: MediLink_DataMgmt not available. Cannot load MAINS data.")
+        return {}
     
     # Retrieve MAINS path and slicing information from the configuration   
     # TODO (Low) For secondary insurance, this needs to be pulling from the correct MAINS (there are 2)
@@ -1142,8 +1197,12 @@ def load_insurance_data_from_mains(config):
     # Meh, this just has to be part of the new architecture plan where we make Medisoft a downstream 
     # recipient from the db.
     # TODO (High) The Medisoft Medicare flag needs to be brought in here.
-    mains_path = config['MAINS_MED_PATH']
-    mains_slices = crosswalk['mains_mapping']['slices']
+    try:
+        mains_path = config.get('MAINS_MED_PATH', '')
+        mains_slices = crosswalk.get('mains_mapping', {}).get('slices', {})
+    except (KeyError, AttributeError) as e:
+        print("Warning: Failed to get MAINS configuration: {}".format(e))
+        return {}
     
     # Initialize the dictionary to hold the insurance to insurance ID mappings
     insurance_to_id = {}
@@ -1152,7 +1211,8 @@ def load_insurance_data_from_mains(config):
         # Check if MAINS file exists before attempting to read
         if not os.path.exists(mains_path):
             error_msg = "CRITICAL: MAINS file not found at: {}. This file is required for insurance name to Medisoft ID mapping.".format(mains_path)
-            MediLink_ConfigLoader.log(error_msg, level="CRITICAL")
+            if hasattr(MediLink_ConfigLoader, 'log'):
+                MediLink_ConfigLoader.log(error_msg, level="CRITICAL")
             print("\n" + "="*80)
             print("CRITICAL ERROR: MAINS FILE MISSING")
             print("="*80)
@@ -1171,17 +1231,26 @@ def load_insurance_data_from_mains(config):
             print("="*80)
             return insurance_to_id
         
+        # XP Compatibility: Check if MediLink_DataMgmt has the required function
+        if not hasattr(MediLink_DataMgmt, 'read_general_fixed_width_data'):
+            print("Warning: MediLink_DataMgmt.read_general_fixed_width_data not available. Cannot load MAINS data.")
+            return insurance_to_id
+        
         # Read data from MAINS using a provided function to handle fixed-width data
         for record, line_number in MediLink_DataMgmt.read_general_fixed_width_data(mains_path, mains_slices):
             insurance_name = record['MAINSNAME']
             # Assuming line_number gives the correct insurance ID without needing adjustment
             insurance_to_id[insurance_name] = line_number
         
-        MediLink_ConfigLoader.log("Successfully loaded {} insurance records from MAINS".format(len(insurance_to_id)), level="INFO")
+        if hasattr(MediLink_ConfigLoader, 'log'):
+            MediLink_ConfigLoader.log("Successfully loaded {} insurance records from MAINS".format(len(insurance_to_id)), level="INFO")
+        else:
+            print("Successfully loaded {} insurance records from MAINS".format(len(insurance_to_id)))
         
     except FileNotFoundError:
         error_msg = "CRITICAL: MAINS file not found: {}. This file is required for insurance name to Medisoft ID mapping.".format(mains_path)
-        MediLink_ConfigLoader.log(error_msg, level="CRITICAL")
+        if hasattr(MediLink_ConfigLoader, 'log'):
+            MediLink_ConfigLoader.log(error_msg, level="CRITICAL")
         print("\n" + "="*80)
         print("CRITICAL ERROR: MAINS FILE MISSING")
         print("="*80)
@@ -1199,7 +1268,9 @@ def load_insurance_data_from_mains(config):
         print("3. The file should contain insurance company data from your Medisoft system")
         print("="*80)
     except Exception as e:
-        MediLink_ConfigLoader.log("Error loading MAINS data: {}. Continuing without MAINS data.".format(str(e)), level="ERROR")
+        error_msg = "Error loading MAINS data: {}. Continuing without MAINS data.".format(str(e))
+        if hasattr(MediLink_ConfigLoader, 'log'):
+            MediLink_ConfigLoader.log(error_msg, level="ERROR")
         print("Error loading MAINS data: {}. Continuing without MAINS data.".format(str(e)))
     
     return insurance_to_id

{medicafe-0.250806.10 → medicafe-0.250806.13}/MediCafe/api_core.py

@@ -138,24 +138,59 @@ class APIClient(BaseAPIClient):
         super().__init__(config)
         
         # Add enhanced features if available
+        # XP/Python34 Compatibility: Enhanced error handling with verbose output
         try:
             from MediCafe.api_utils import APICircuitBreaker, APICache, APIRateLimiter
+            MediLink_ConfigLoader.log("Successfully imported MediCafe.api_utils", level="DEBUG")
+        except ImportError as e:
+            MediLink_ConfigLoader.log("Warning: MediCafe.api_utils not available: {}".format(str(e)), level="WARNING")
+            print("Warning: MediCafe.api_utils import failed: {}".format(str(e)))
+            APICircuitBreaker = None
+            APICache = None
+            APIRateLimiter = None
+        except Exception as e:
+            MediLink_ConfigLoader.log("Unexpected error importing MediCafe.api_utils: {}".format(str(e)), level="ERROR")
+            print("Error: Unexpected MediCafe.api_utils import error: {}".format(str(e)))
+            APICircuitBreaker = None
+            APICache = None
+            APIRateLimiter = None
+        
+        try:
             from MediLink.MediLink_insurance_utils import get_feature_flag
-            
-            # Initialize enhancements if enabled
+            MediLink_ConfigLoader.log("Successfully imported MediLink.MediLink_insurance_utils", level="DEBUG")
+        except ImportError as e:
+            MediLink_ConfigLoader.log("Warning: MediLink.MediLink_insurance_utils not available: {}".format(str(e)), level="WARNING")
+            print("Warning: MediLink.MediLink_insurance_utils import failed: {}".format(str(e)))
+            # Provide fallback function
+            def get_feature_flag(flag_name, default=False):
+                MediLink_ConfigLoader.log("Using fallback get_feature_flag for '{}', returning default: {}".format(flag_name, default), level="DEBUG")
+                return default
+        except Exception as e:
+            MediLink_ConfigLoader.log("Unexpected error importing MediLink.MediLink_insurance_utils: {}".format(str(e)), level="ERROR")
+            print("Error: Unexpected MediLink.MediLink_insurance_utils import error: {}".format(str(e)))
+            # Provide fallback function
+            def get_feature_flag(flag_name, default=False):
+                MediLink_ConfigLoader.log("Using fallback get_feature_flag for '{}', returning default: {}".format(flag_name, default), level="DEBUG")
+                return default
+        
+        # Initialize enhancements with error handling
+        try:
             enable_circuit_breaker = get_feature_flag('api_circuit_breaker', default=False)
             enable_caching = get_feature_flag('api_caching', default=False)
             enable_rate_limiting = get_feature_flag('api_rate_limiting', default=False)
             
-            self.circuit_breaker = APICircuitBreaker() if enable_circuit_breaker else None
-            self.api_cache = APICache() if enable_caching else None
-            self.rate_limiter = APIRateLimiter() if enable_rate_limiting else None
+            self.circuit_breaker = APICircuitBreaker() if (enable_circuit_breaker and APICircuitBreaker) else None
+            self.api_cache = APICache() if (enable_caching and APICache) else None
+            self.rate_limiter = APIRateLimiter() if (enable_rate_limiting and APIRateLimiter) else None
             
             if any([enable_circuit_breaker, enable_caching, enable_rate_limiting]):
                 MediLink_ConfigLoader.log("Enhanced API client initialized with circuit_breaker={}, caching={}, rate_limiting={}".format(
                     enable_circuit_breaker, enable_caching, enable_rate_limiting), level="INFO")
-        except ImportError:
-            MediLink_ConfigLoader.log("API enhancements not available, using standard client", level="DEBUG")
+            else:
+                MediLink_ConfigLoader.log("API enhancements disabled or not available, using standard client", level="DEBUG")
+        except Exception as e:
+            MediLink_ConfigLoader.log("Error initializing API enhancements: {}. Using standard client.".format(str(e)), level="WARNING")
+            print("Warning: API enhancement initialization failed: {}".format(str(e)))
             self.circuit_breaker = None
             self.api_cache = None
             self.rate_limiter = None

{medicafe-0.250806.10 → medicafe-0.250806.13}/MediCafe/api_factory.py

@@ -181,7 +181,23 @@ class APIClientFactory:
             
             return client
         
-        return self.circuit_breaker.call(create_client)
+        # XP/Python34 Compatibility: Wrap circuit breaker call with error handling
+        try:
+            if self.circuit_breaker and hasattr(self.circuit_breaker, 'call'):
+                return self.circuit_breaker.call(create_client)
+            else:
+                MediLink_ConfigLoader.log("Circuit breaker not available, calling create_client directly", level="WARNING")
+                return create_client()
+        except Exception as e:
+            MediLink_ConfigLoader.log("Circuit breaker call failed: {}. Falling back to direct client creation.".format(str(e)), level="WARNING")
+            print("Warning: Circuit breaker error ({}), using fallback client creation".format(str(e)))
+            try:
+                return create_client()
+            except Exception as e2:
+                MediLink_ConfigLoader.log("Direct client creation also failed: {}".format(str(e2)), level="ERROR")
+                print("Error: Both circuit breaker and direct client creation failed: {}".format(str(e2)))
+                # Return a minimal fallback client
+                return ProductionAPIClient()
     
     @classmethod
     def get_shared_client(cls, **kwargs):

{medicafe-0.250806.10 → medicafe-0.250806.13}/MediLink/MediLink_837p_encoder_library.py

@@ -13,15 +13,42 @@ if project_dir not in sys.path:
     sys.path.append(project_dir)
 
 # Import MediBot modules conditionally to avoid circular imports
+# XP/Python34 Compatibility: Enhanced error handling with verbose output
 MediBot_Preprocessor_lib = None
 load_insurance_data_from_mains = None
 
 try:
     from MediBot import MediBot_Preprocessor_lib
+    MediLink_ConfigLoader.log("Successfully imported MediBot_Preprocessor_lib", level="DEBUG")
+    
     if hasattr(MediBot_Preprocessor_lib, 'load_insurance_data_from_mains'):
         load_insurance_data_from_mains = MediBot_Preprocessor_lib.load_insurance_data_from_mains
-except ImportError:
-    pass
+        MediLink_ConfigLoader.log("Successfully accessed load_insurance_data_from_mains function", level="DEBUG")
+    else:
+        MediLink_ConfigLoader.log("Warning: MediBot_Preprocessor_lib found but load_insurance_data_from_mains attribute missing", level="WARNING")
+        print("Warning: MediBot_Preprocessor_lib missing load_insurance_data_from_mains attribute")
+except ImportError as e:
+    MediLink_ConfigLoader.log("ImportError accessing MediBot_Preprocessor_lib: {}".format(str(e)), level="WARNING")
+    print("Warning: Cannot import MediBot_Preprocessor_lib: {}".format(str(e)))
+except AttributeError as e:
+    MediLink_ConfigLoader.log("AttributeError accessing load_insurance_data_from_mains: {}".format(str(e)), level="WARNING")
+    print("Warning: AttributeError with load_insurance_data_from_mains: {}".format(str(e)))
+except Exception as e:
+    MediLink_ConfigLoader.log("Unexpected error accessing MediBot_Preprocessor_lib: {}".format(str(e)), level="ERROR")
+    print("Error: Unexpected error with MediBot_Preprocessor_lib: {}".format(str(e)))
+
+# XP Compatibility: Add fallback function if import fails
+if load_insurance_data_from_mains is None:
+    def load_insurance_data_from_mains_fallback(config):
+        """
+        Fallback function for load_insurance_data_from_mains when MediBot_Preprocessor_lib is not available.
+        Returns empty dictionary to prevent AttributeError.
+        """
+        MediLink_ConfigLoader.log("Using fallback load_insurance_data_from_mains function", level="WARNING")
+        print("Warning: load_insurance_data_from_mains not available. Using empty insurance mapping.")
+        return {}
+    
+    load_insurance_data_from_mains = load_insurance_data_from_mains_fallback
 
 try:
     from MediBot import MediBot_Crosswalk_Library
@@ -71,9 +98,17 @@ except ImportError:
         update_crosswalk_with_new_payer_id = None
 
 # Import enhanced insurance selection with fallback
+# XP/Python34 Compatibility: Enhanced error handling with verbose output
 try:
     from MediLink_insurance_utils import safe_insurance_type_selection
-except ImportError:
+    MediLink_ConfigLoader.log("Successfully imported safe_insurance_type_selection from MediLink_insurance_utils", level="DEBUG")
+except ImportError as e:
+    MediLink_ConfigLoader.log("ImportError importing safe_insurance_type_selection: {}".format(str(e)), level="WARNING")
+    print("Warning: safe_insurance_type_selection not available: {}".format(str(e)))
+    safe_insurance_type_selection = None
+except Exception as e:
+    MediLink_ConfigLoader.log("Unexpected error importing safe_insurance_type_selection: {}".format(str(e)), level="ERROR")
+    print("Error: Unexpected error importing safe_insurance_type_selection: {}".format(str(e)))
     safe_insurance_type_selection = None
 
 # Import display utilities

{medicafe-0.250806.10 → medicafe-0.250806.13}/MediLink/MediLink_PatientProcessor.py

@@ -17,17 +17,59 @@ if project_dir not in sys.path:
     sys.path.append(project_dir)
 
 # Use dynamic import to avoid circular dependencies
+# XP/Python34 Compatibility: Enhanced error handling with verbose output
 def _get_load_insurance_function():
     """Dynamically import load_insurance_data_from_mains to avoid circular imports."""
     try:
         import MediBot_Preprocessor_lib
-        return MediBot_Preprocessor_lib.load_insurance_data_from_mains
-    except (ImportError, AttributeError) as e:
-        MediLink_ConfigLoader.log("Failed to import load_insurance_data_from_mains: {}".format(e), level="WARNING")
+        if MediLink_ConfigLoader and hasattr(MediLink_ConfigLoader, 'log'):
+            MediLink_ConfigLoader.log("Successfully imported MediBot_Preprocessor_lib", level="DEBUG")
+        
+        if hasattr(MediBot_Preprocessor_lib, 'load_insurance_data_from_mains'):
+            func = MediBot_Preprocessor_lib.load_insurance_data_from_mains
+            if MediLink_ConfigLoader and hasattr(MediLink_ConfigLoader, 'log'):
+                MediLink_ConfigLoader.log("Successfully accessed load_insurance_data_from_mains function", level="DEBUG")
+            return func
+        else:
+            error_msg = "MediBot_Preprocessor_lib imported but load_insurance_data_from_mains attribute missing"
+            if MediLink_ConfigLoader and hasattr(MediLink_ConfigLoader, 'log'):
+                MediLink_ConfigLoader.log(error_msg, level="WARNING")
+            print("Warning: {}".format(error_msg))
+            return None
+            
+    except ImportError as e:
+        error_msg = "ImportError accessing MediBot_Preprocessor_lib: {}".format(str(e))
+        if MediLink_ConfigLoader and hasattr(MediLink_ConfigLoader, 'log'):
+            MediLink_ConfigLoader.log(error_msg, level="WARNING")
+        print("Warning: {}".format(error_msg))
+        return None
+    except AttributeError as e:
+        error_msg = "AttributeError accessing load_insurance_data_from_mains: {}".format(str(e))
+        if MediLink_ConfigLoader and hasattr(MediLink_ConfigLoader, 'log'):
+            MediLink_ConfigLoader.log(error_msg, level="WARNING")
+        print("Warning: {}".format(error_msg))
+        return None
+    except Exception as e:
+        error_msg = "Unexpected error accessing MediBot_Preprocessor_lib: {}".format(str(e))
+        if MediLink_ConfigLoader and hasattr(MediLink_ConfigLoader, 'log'):
+            MediLink_ConfigLoader.log(error_msg, level="ERROR")
+        print("Error: {}".format(error_msg))
         return None
 
 load_insurance_data_from_mains = _get_load_insurance_function()
 
+# XP Compatibility: Add fallback function if import fails
+if load_insurance_data_from_mains is None:
+    def load_insurance_data_from_mains_fallback(config):
+        """
+        Fallback function for load_insurance_data_from_mains when MediBot_Preprocessor_lib is not available.
+        Returns empty dictionary to prevent AttributeError.
+        """
+        print("Warning: load_insurance_data_from_mains not available. Using empty insurance mapping.")
+        return {}
+    
+    load_insurance_data_from_mains = load_insurance_data_from_mains_fallback
+
 
 def collect_detailed_patient_data(selected_files, config, crosswalk):
     """
@@ -94,6 +136,7 @@ def enrich_with_insurance_type(detailed_patient_data, patient_insurance_type_map
     # Enhanced mode check with graceful degradation
     enhanced_mode = False
     
+    # XP/Python34 Compatibility: Enhanced error handling with verbose output
     try:
         from MediLink_insurance_utils import (
             get_feature_flag, 
@@ -103,9 +146,11 @@ def enrich_with_insurance_type(detailed_patient_data, patient_insurance_type_map
         MediLink_ConfigLoader.log("Insurance enhancement utilities loaded successfully", level="DEBUG")
     except ImportError as e:
         MediLink_ConfigLoader.log("Insurance utils not available: {}. Using legacy mode.".format(str(e)), level="INFO")
+        print("Info: Using legacy insurance processing mode due to: {}".format(str(e)))
         enhanced_mode = False
     except Exception as e:
         MediLink_ConfigLoader.log("Error initializing insurance enhancements: {}. Using legacy mode.".format(str(e)), level="ERROR")
+        print("Warning: Insurance enhancement error ({}), using legacy mode".format(str(e)))
         enhanced_mode = False
     
     if patient_insurance_type_mapping is None:

{medicafe-0.250806.10 → medicafe-0.250806.13}/PKG-INFO

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

{medicafe-0.250806.10 → medicafe-0.250806.13}/medicafe.egg-info/PKG-INFO

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

{medicafe-0.250806.10 → medicafe-0.250806.13}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='medicafe',
-    version="0.250806.10",
+    version="0.250806.13",
     description='MediCafe',
     long_description="""
     # Project Overview: MediCafe