medicafe 0.250810.7__py3-none-any.whl → 0.250811.1__py3-none-any.whl

MediBot/MediBot.bat

@@ -469,68 +469,54 @@ if %errorlevel% neq 0 (
 echo [OK] Internet connection available
 echo.
 
-:: Step 5: Start update process
-echo [5/5] Starting update process...
+:: Step 5: Start update process (self-update orchestrator)
+echo [5/5] Preparing self-update...
 echo.
 echo ========================================
-echo           UPDATE WINDOW
+echo           UPDATE PREPARATION
 echo ========================================
-echo The update process will open in a new window.
-echo Please wait for it to complete.
+echo The application will close to allow safe replacement of files.
+echo A separate updater will run and reopen MediBot when finished.
 echo.
 echo Update script: %upgrade_medicafe%
 echo.
 
-:: Execute the update script with better error handling
-if exist "%upgrade_medicafe_local%" (
-    echo Starting local update script...
-    start "MediCafe Update" cmd /v:on /c "python %upgrade_medicafe_local% %package_version% & echo. & echo Update process completed. Press any key to close... & pause >nul"
-    if %errorlevel% equ 0 (
-        echo %DATE% %TIME% Upgrade initiated successfully - local. >> "%temp_file%"
-        echo [SUCCESS] Update process started successfully
-    ) else (
-        echo %DATE% %TIME% Update failed - local. >> "%temp_file%"
-        echo [ERROR] Failed to start update process
-        echo Please check the update window for error details.
-    )
-) else (
-    if exist "%upgrade_medicafe_legacy%" (
-        echo Starting legacy update script...
-        start "MediCafe Update" cmd /v:on /c "python %upgrade_medicafe_legacy% %package_version% & echo. & echo Update process completed. Press any key to close... & pause >nul"
-        if %errorlevel% equ 0 (
-            echo %DATE% %TIME% Upgrade initiated successfully - legacy. >> "%temp_file%"
-            echo [SUCCESS] Update process started successfully
-        ) else (
-            echo %DATE% %TIME% Update failed - legacy. >> "%temp_file%"
-            echo [ERROR] Failed to start update process
-            echo Please check the update window for error details.
-        )
-    ) else (
-        echo [ERROR] Update script not found
-        echo Expected locations:
-        echo   - Local: %upgrade_medicafe_local%
-        echo   - Legacy: %upgrade_medicafe_legacy%
-        echo.
-        echo Press Enter to return to main menu...
-        pause >nul
-        goto main_menu
-    )
-)
-
-echo.
-echo ========================================
-echo           UPDATE STATUS
-echo ========================================
-echo.
-echo The update process has been initiated in a new window.
-echo Please wait for it to complete before continuing.
-echo.
-echo If the update window closes quickly, there may be an error.
-echo Check the update window output for details.
-echo.
-echo Press Enter to return to main menu...
-pause >nul
-goto main_menu
+:: Build a temporary updater to run after this window exits
+set "_MEDIBOT_PATH=%~f0"
+set "_UPD_RUNNER=%TEMP%\medicafe_update_runner.cmd"
+
+(
+  echo @echo off
+  echo setlocal enabledelayedexpansion
+  echo set "UPD_PY=%upgrade_medicafe%"
+  echo set "MEDIBOT_PATH=%_MEDIBOT_PATH%"
+  echo rem Wait briefly to ensure the main window has exited and released file locks
+  echo ping 127.0.0.1 -n 3 ^>nul
+  echo echo Starting MediCafe updater...
+  echo where python ^>nul 2^>^&1
+  echo if errorlevel 1 (
+  echo   echo [ERROR] Python not found in PATH. Aborting update.
+  echo   goto :eof
+  echo )
+  echo python "%%UPD_PY%%"
+  echo set "RET=%%ERRORLEVEL%%"
+  echo echo Update process exited with code %%RET%%
+  echo rem Relaunch MediBot if available
+  echo if exist "%%MEDIBOT_PATH%%" start "MediBot" "%%MEDIBOT_PATH%%"
+  echo exit /b %%RET%%
+) > "%_UPD_RUNNER%"
+
+if not exist "%_UPD_RUNNER%" (
+  echo [ERROR] Failed to create updater script at %_UPD_RUNNER%
+  echo Press Enter to return to main menu...
+  pause >nul
+  goto main_menu
+)
+
+echo.
+echo Launching updater and closing this window...
+start "MediCafe Update" "%_UPD_RUNNER%"
+exit /b 0
 
 :: Download Carol's Emails
 :download_emails

MediBot/MediBot.py

@@ -33,6 +33,12 @@ if MediBot_UI:
     app_control = getattr(MediBot_UI, 'app_control', None)
     manage_script_pause = getattr(MediBot_UI, 'manage_script_pause', None)
     user_interaction = getattr(MediBot_UI, 'user_interaction', None)
+    get_app_control = getattr(MediBot_UI, '_get_app_control', None)
+    def _ac():
+        try:
+            return get_app_control() if get_app_control else getattr(MediBot_UI, 'app_control', None)
+        except Exception:
+            return getattr(MediBot_UI, 'app_control', None)
 else:
     app_control = None
     manage_script_pause = None
@@ -345,7 +351,7 @@ def data_entry_loop(csv_data, field_mapping, reverse_mapping, fixed_values):
         manage_script_pause(csv_data, error_message, reverse_mapping)
         error_message = ''  # Clear error message for the next iteration
         
-        if app_control.get_pause_status():
+        if _ac() and _ac().get_pause_status():
             continue  # Skip processing this row if the script is paused
 
         # I feel like this is overwriting what would have already been idenfitied in the mapping. 
@@ -374,7 +380,8 @@ def data_entry_loop(csv_data, field_mapping, reverse_mapping, fixed_values):
 
         # Code to handle the end of a patient record
         # TODO One day this can just not pause...
-        app_control.set_pause_status(True)  # Pause at the end of processing each patient record
+        if _ac():
+            _ac().set_pause_status(True)  # Pause at the end of processing each patient record
         
         # PERFORMANCE FIX: Explicit cleanup at end of patient processing
         # Clear global state to prevent accumulation over processing sessions
@@ -548,11 +555,11 @@ if __name__ == "__main__":
             csv_data = [row for index, row in enumerate(csv_data) if index in selected_indices]
             
             # Check if MAPAT_MED_PATH is missing or invalid
-            if not app_control.get_mapat_med_path() or not os.path.exists(app_control.get_mapat_med_path()):
+            if (not _ac()) or (not _ac().get_mapat_med_path()) or (not os.path.exists(_ac().get_mapat_med_path())):
                 print("Warning: MAPAT.MED PATH is missing or invalid. Please check the path configuration.")
 
             # Perform the existing patients check
-            existing_patients, patients_to_process = MediBot_Preprocessor.check_existing_patients(selected_patient_ids, app_control.get_mapat_med_path())
+            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:")
@@ -610,8 +617,9 @@ if __name__ == "__main__":
                 print("\n*** Press [Enter] when ready to begin! ***")
                 input()
                 MediLink_ConfigLoader.log("Opening Medisoft...")
-                open_medisoft(app_control.get_medisoft_shortcut())
-                app_control.set_pause_status(True)
+                open_medisoft(_ac().get_medisoft_shortcut() if _ac() else '')
+                if _ac():
+                    _ac().set_pause_status(True)
                 _ = manage_script_pause(csv_data, error_message, reverse_mapping)
                 data_entry_loop(csv_data, MediBot_Preprocessor_lib.field_mapping, reverse_mapping, fixed_values)
                 cleanup()                

MediBot/MediBot_Preprocessor_lib.py

@@ -31,6 +31,12 @@ MediLink_DataMgmt = import_medilink_module('MediLink_DataMgmt')
 MediBot_UI = import_medibot_module('MediBot_UI')
 if MediBot_UI:
     app_control = getattr(MediBot_UI, 'app_control', None)
+    get_app_control = getattr(MediBot_UI, '_get_app_control', None)
+    def _ac():
+        try:
+            return get_app_control() if get_app_control else getattr(MediBot_UI, 'app_control', None)
+        except Exception:
+            return getattr(MediBot_UI, 'app_control', None)
 else:
     app_control = None
 
@@ -1299,7 +1305,8 @@ def load_insurance_data_from_mapat(config, crosswalk):
         dict: A dictionary mapping patient IDs to insurance IDs.
     """
     # Retrieve MAPAT path and slicing information from the configuration
-    mapat_path = app_control.get_mapat_med_path()
+    ac = _ac()
+    mapat_path = ac.get_mapat_med_path() if ac else ''
     mapat_slices = crosswalk['mapat_mapping']['slices']
     
     # Initialize the dictionary to hold the patient ID to insurance ID mappings

MediBot/MediBot_UI.py

@@ -45,7 +45,13 @@ class AppControl:
         # PERFORMANCE FIX: Add configuration caching to reduce lookup overhead
         self._config_cache = {}  # Cache for Medicare vs Private configuration lookups
         # Load initial paths from config when instance is created
-        self.load_paths_from_config()
+        try:
+            self.load_paths_from_config()
+        except Exception:
+            # Defer configuration loading until first access if config is unavailable
+            self._deferred_load = True
+        else:
+            self._deferred_load = False
 
     def get_pause_status(self):
         return self.script_paused
@@ -91,8 +97,29 @@ class AppControl:
         self.mapat_med_path = cached['mapat_path']
         self.medisoft_shortcut = cached['shortcut']
 
-app_control = AppControl()
-
+def _get_app_control():
+    global app_control
+    try:
+        ac = app_control
+    except NameError:
+        ac = None
+    if ac is None:
+        ac = AppControl()
+    # If deferred, attempt first load now
+    try:
+        if getattr(ac, '_deferred_load', False):
+            ac.load_paths_from_config()
+            ac._deferred_load = False
+    except Exception:
+        pass
+    globals()['app_control'] = ac
+    return ac
+
+# Lazily initialize app_control to avoid config load at import time
+try:
+    app_control
+except NameError:
+    app_control = None
 
 
 def is_key_pressed(key_code):
@@ -105,15 +132,16 @@ def manage_script_pause(csv_data, error_message, reverse_mapping):
     user_action = 0 # initialize as 'continue'
     VK_END, VK_PAUSE = _get_vk_codes()
     
-    if not app_control.get_pause_status() and is_key_pressed(VK_PAUSE):
-        app_control.set_pause_status(True)
+    ac = _get_app_control()
+    if not ac.get_pause_status() and is_key_pressed(VK_PAUSE):
+        ac.set_pause_status(True)
         print("Script paused. Opening menu...")
         interaction_mode = 'normal'  # Assuming normal interaction mode for script pause
         user_action = user_interaction(csv_data, interaction_mode, error_message, reverse_mapping)
     
-    while app_control.get_pause_status():
+    while ac.get_pause_status():
         if is_key_pressed(VK_END):
-            app_control.set_pause_status(False)
+            ac.set_pause_status(False)
             print("Continuing...")
         elif is_key_pressed(VK_PAUSE):
             user_action = user_interaction(csv_data, 'normal', error_message, reverse_mapping)
@@ -276,6 +304,10 @@ def user_interaction(csv_data, interaction_mode, error_message, reverse_mapping)
     if interaction_mode == 'triage':
         display_menu_header("            =(^.^)= Welcome to MediBot! =(^.^)=")
         
+        # Ensure app_control is initialized before using it in triage
+        ac = _get_app_control()
+        app_control = ac
+
         while True:
             try:
                 response = input("\nAm I processing Medicare patients? (yes/no): ").lower().strip()    
@@ -285,10 +317,10 @@ def user_interaction(csv_data, interaction_mode, error_message, reverse_mapping)
                     continue
                 
                 if response in ['yes', 'y']:
-                    app_control.load_paths_from_config(medicare=True)
+                    ac.load_paths_from_config(medicare=True)
                     break
                 elif response in ['no', 'n']:
-                    app_control.load_paths_from_config(medicare=False)
+                    ac.load_paths_from_config(medicare=False)
                     break
                 else:
                     print("Invalid entry. Please enter 'yes' or 'no'.")

MediBot/MediBot_dataformat_library.py

@@ -42,6 +42,12 @@ MediBot_UI = import_medibot_module('MediBot_UI')
 if MediBot_UI:
     manage_script_pause = getattr(MediBot_UI, 'manage_script_pause', None)
     app_control = getattr(MediBot_UI, 'app_control', None)
+    get_app_control = getattr(MediBot_UI, '_get_app_control', None)
+    def _ac():
+        try:
+            return get_app_control() if get_app_control else getattr(MediBot_UI, 'app_control', None)
+        except Exception:
+            return getattr(MediBot_UI, 'app_control', None)
 else:
     manage_script_pause = None
     app_control = None
@@ -146,7 +152,8 @@ def enforce_significant_length(output):
 def format_street(value, csv_data, reverse_mapping, parsed_address_components):
     _ensure_initialized()
     # Temporarily disable script pause status
-    app_control.set_pause_status(False)
+    if _ac():
+        _ac().set_pause_status(False)
     
     # Remove period characters.
     value = value.replace('.', '')
@@ -197,8 +204,12 @@ def format_street(value, csv_data, reverse_mapping, parsed_address_components):
         except Exception as e:
             # Handle exceptions by logging and offering to correct data manually
             print("Address format error: Unable to parse address '{}'. Error: {}".format(value, e))
-            app_control.set_pause_status(True)
-            open_csv_for_editing(CSV_FILE_PATH)
+            if _ac():
+                _ac().set_pause_status(True)
+            if MediBot_Preprocessor_lib and hasattr(MediBot_Preprocessor_lib, 'CSV_FILE_PATH'):
+                open_csv_for_editing(MediBot_Preprocessor_lib.CSV_FILE_PATH)
+            else:
+                open_csv_for_editing('')
             manage_script_pause(csv_data, e, reverse_mapping)
             # Return original value with spaces formatted, enforcing significant length
             return enforce_significant_length(value.replace(' ', '{Space}'))

MediCafe/MediLink_ConfigLoader.py

@@ -105,13 +105,13 @@ def load_configuration(config_path=os.path.join(os.path.dirname(__file__), '..',
         sys.exit(1)  # Exit the script due to a critical error in configuration loading
     except FileNotFoundError:
         print("One or both configuration files not found. Config: {}, Crosswalk: {}".format(config_path, crosswalk_path))
-        sys.exit(1)  # Exit the script due to a critical error in configuration loading
+        raise
     except KeyError as e:
         print("Critical configuration is missing: {}".format(e))
-        sys.exit(1)  # Exit the script due to a critical error in configuration loading
+        raise
     except Exception as e:
         print("An unexpected error occurred while loading the configuration: {}".format(e))
-        sys.exit(1)  # Exit the script due to a critical error in configuration loading
+        raise
 
 def clear_config_cache():
     """Clear the configuration cache to force reloading on next call."""
@@ -124,14 +124,23 @@ def log(message, config=None, level="INFO", error_type=None, claim=None, verbose
     
     # If config is not provided, use cached config or load it
     if config is None:
-        if _CONFIG_CACHE is None:
-            config, _ = load_configuration()
-        else:
-            config = _CONFIG_CACHE
+        try:
+            if _CONFIG_CACHE is None:
+                config, _ = load_configuration()
+            else:
+                config = _CONFIG_CACHE
+        except BaseException:
+            # Configuration unavailable; fall back to minimal console logging
+            config = {}
     
     # Setup logger if not already configured
     if not logging.root.handlers:
-        local_storage_path = config['MediLink_Config'].get('local_storage_path', '.') if isinstance(config, dict) else '.'
+        local_storage_path = '.'
+        if isinstance(config, dict):
+            try:
+                local_storage_path = config.get('MediLink_Config', {}).get('local_storage_path', '.')
+            except Exception:
+                local_storage_path = '.'
         log_filename = datetime.now().strftime("Log_%m%d%Y.log")
         log_filepath = os.path.join(local_storage_path, log_filename)
         
@@ -141,12 +150,15 @@ def log(message, config=None, level="INFO", error_type=None, claim=None, verbose
         # Create formatter
         formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
         
-        # Create file handler
-        file_handler = logging.FileHandler(log_filepath, mode='a')
-        file_handler.setFormatter(formatter)
-        
-        # Create handlers list - always include file handler
-        handlers = [file_handler]
+        handlers = []
+        try:
+            # Create file handler when path is usable
+            file_handler = logging.FileHandler(log_filepath, mode='a')
+            file_handler.setFormatter(formatter)
+            handlers.append(file_handler)
+        except Exception:
+            # Fall back to console-only if file handler cannot be created
+            pass
         
         # Add console handler only if console_output is True
         if console_output:
@@ -154,7 +166,12 @@ def log(message, config=None, level="INFO", error_type=None, claim=None, verbose
             console_handler.setFormatter(formatter)
             handlers.append(console_handler)
         
-        # Configure root logger
+        # If no handlers could be added (e.g., file path invalid and console_output False), add a console handler
+        if not handlers:
+            console_handler = logging.StreamHandler()
+            console_handler.setFormatter(formatter)
+            handlers.append(console_handler)
+        
         logging.basicConfig(level=logging_level, handlers=handlers)
     
     # Prepare log message

MediCafe/core_utils.py

@@ -513,16 +513,17 @@ def get_api_client_factory():
         config_loader = get_shared_config_loader()
         if config_loader:
             try:
+                # Be resilient to SystemExit raised inside loaders
                 config, _ = config_loader.load_configuration()
-                factory_config = config.get('API_Factory_Config', {})
+                factory_config = config.get('API_Factory_Config', {}) if isinstance(config, dict) else {}
                 return APIClientFactory(factory_config)
-            except Exception:
-                # Fall back to default configuration
+            except BaseException:
+                # Fall back to default configuration on any loader failure (including SystemExit)
                 return APIClientFactory()
         else:
             return APIClientFactory()
-    except Exception as e:
-        # Don't log error here - just return None silently
+    except BaseException:
+        # Do not allow API client factory acquisition to crash callers during import time
         return None
 
 def get_api_client(**kwargs):
@@ -555,4 +556,154 @@ def get_api_core_client(**kwargs):
         return APIClient(**kwargs)
     except ImportError:
         # Don't log error here - just return None silently
-        return None
+        return None
+
+# --- Compatibility & Process Utilities (Python 3.4.4 / Windows XP friendly) ---
+
+def is_python_34_compatible(version_info=None):
+    """
+    Return True if the interpreter is Python 3.4.4+ (as required in XP env).
+    This consolidates scattered version checks into a single function so
+    call sites remain concise and intention-revealing.
+    """
+    try:
+        if version_info is None:
+            version_info = sys.version_info
+        major = getattr(version_info, 'major', version_info[0])
+        minor = getattr(version_info, 'minor', version_info[1])
+        micro = getattr(version_info, 'micro', version_info[2])
+        return (major, minor, micro) >= (3, 4, 4)
+    except Exception:
+        # Be conservative if we cannot determine
+        return False
+
+def format_py34(template, *args, **kwargs):
+    """
+    Safe stand-in for f-strings (not available in Python 3.4).
+    Centralized to avoid ad-hoc "format_string" helpers scattered around.
+    """
+    try:
+        return template.format(*args, **kwargs)
+    except Exception:
+        # If formatting fails, return template unmodified to avoid crashes
+        return template
+
+def _decode_bytes(data, encoding_list=None):
+    """
+    Decode bytes to text using a tolerant strategy.
+    We avoid relying on platform defaults (XP may vary) and try multiple
+    encodings to reduce boilerplate at call sites.
+    """
+    if data is None:
+        return ''
+    if isinstance(data, str):
+        return data
+    if encoding_list is None:
+        encoding_list = ['utf-8', 'latin-1', 'ascii']
+    for enc in encoding_list:
+        try:
+            return data.decode(enc, 'ignore')
+        except Exception:
+            continue
+    # Last resort: str() on bytes
+    try:
+        return str(data)
+    except Exception:
+        return ''
+
+def run_cmd(cmd, timeout=None, input_text=None, shell=False, cwd=None, env=None):
+    """
+    Cross-version subprocess runner for Python 3.4/XP environments.
+    - Uses subprocess.Popen (subprocess.run is 3.5+)
+    - Returns (returncode, stdout_text, stderr_text)
+    - Accepts optional timeout (best-effort with polling for 3.4)
+    - Accepts optional input_text (string) which will be encoded to bytes
+    This consolidates repetitive Popen/communicate/decode blocks.
+    """
+    import subprocess
+    try:
+        # Prepare stdin if input is provided
+        stdin_pipe = subprocess.PIPE if input_text is not None else None
+        p = subprocess.Popen(
+            cmd,
+            stdin=stdin_pipe,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            shell=shell,
+            cwd=cwd,
+            env=env
+        )
+        if timeout is None:
+            out_bytes, err_bytes = p.communicate(
+                input=input_text.encode('utf-8') if isinstance(input_text, str) else input_text
+            )
+            return p.returncode, _decode_bytes(out_bytes), _decode_bytes(err_bytes)
+        # Implement simple timeout loop compatible with 3.4
+        import time
+        start_time = time.time()
+        while True:
+            if p.poll() is not None:
+                out_bytes, err_bytes = p.communicate()
+                return p.returncode, _decode_bytes(out_bytes), _decode_bytes(err_bytes)
+            if time.time() - start_time > timeout:
+                try:
+                    p.kill()
+                except Exception:
+                    try:
+                        p.terminate()
+                    except Exception:
+                        pass
+                out_bytes, err_bytes = p.communicate()
+                return 124, _decode_bytes(out_bytes), _decode_bytes(err_bytes)
+            time.sleep(0.05)
+    except Exception as e:
+        # Standardize failure surface
+        return 1, '', str(e)
+
+def file_is_ascii(file_path):
+    """
+    Return True if the given file can be read as ASCII-only.
+    Consolidates repeated try/open/decode blocks into one helper.
+    """
+    try:
+        if not os.path.exists(file_path):
+            return False
+        # Use strict ASCII to detect any non-ASCII characters
+        f = open(file_path, 'r')
+        try:
+            # Explicit codec arg not supported in some XP Python builds for text mode
+            # so we emulate by checking ordinals while reading
+            data = f.read()
+        finally:
+            try:
+                f.close()
+            except Exception:
+                pass
+        try:
+            data.encode('ascii')
+            return True
+        except Exception:
+            return False
+    except Exception:
+        return False
+
+def check_ascii_files(paths):
+    """
+    Given a list of paths (absolute or relative), return a list of those that
+    contain non-ASCII characters or could not be checked. This replaces
+    duplicated loops in various verification scripts.
+    """
+    problematic = []
+    try:
+        for p in paths:
+            # Normalize relative to current working directory for consistency
+            if not os.path.isabs(p):
+                abs_p = os.path.abspath(p)
+            else:
+                abs_p = p
+            if not file_is_ascii(abs_p):
+                problematic.append(p)
+    except Exception:
+        # If a failure occurs mid-scan, return what we have so far
+        return problematic
+    return problematic