medicafe 0.250810.7__tar.gz → 0.250811.0__tar.gz

{medicafe-0.250810.7 → medicafe-0.250811.0}/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)

{medicafe-0.250810.7 → medicafe-0.250811.0}/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-0.250810.7 → medicafe-0.250811.0}/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