medicafe 0.250810.5__tar.gz → 0.250810.7__tar.gz

{medicafe-0.250810.5 → medicafe-0.250810.7}/MediBot/MediBot.bat

@@ -25,6 +25,8 @@ echo ========================================
 echo        DEBUG MODE (INTERACTIVE)
 echo ========================================
 echo Running full diagnostic suite...
+set "MEDICAFE_IMPORT_DEBUG=1"
+set "MEDICAFE_IMPORT_STRICT=0"
 echo.
 set "SKIP_CLS_AFTER_DEBUG=1"
 call "%~dp0full_debug_suite.bat" /interactive
@@ -37,6 +39,8 @@ echo ========================================
 echo     DEBUG MODE (NON-INTERACTIVE)
 echo ========================================
 echo Running full diagnostic suite...
+set "MEDICAFE_IMPORT_DEBUG=1"
+set "MEDICAFE_IMPORT_STRICT=0"
 echo.
 set "SKIP_CLS_AFTER_DEBUG=1"
 call "%~dp0full_debug_suite.bat"
@@ -45,6 +49,8 @@ goto normal_mode
 
 :start_normal_mode
 echo Starting Normal Mode...
+set "MEDICAFE_IMPORT_DEBUG=0"
+set "MEDICAFE_IMPORT_STRICT=1"
 goto normal_mode
 
 :normal_mode
@@ -329,7 +335,7 @@ if exist "%upgrade_medicafe_local%" (
 cls
 echo Version: %medicafe_version%
 echo --------------------------------------------------------------
-echo              .//*  Welcome to MediBot  *\\. 
+echo              .//*  Welcome to MediCafe  *\\. 
 echo --------------------------------------------------------------
 echo. 
 

{medicafe-0.250810.5 → medicafe-0.250810.7}/MediBot/MediBot_Crosswalk_Utils.py

@@ -83,15 +83,44 @@ def check_crosswalk_health(crosswalk):
 
 def prompt_user_for_api_calls(crosswalk, config):
     """
-    Prompts user with a 3-second timeout to skip API calls if crosswalk looks healthy.
-    Windows XP compatible version using threading instead of select.
-    
+    Prompt user with a short timeout to optionally run API validation when the crosswalk looks healthy.
+
+    Implementation notes and rationale
+    ----------------------------------
+    A previous implementation attempted to capture a quick ENTER press using a background thread that
+    called ``input()`` and then ``join(timeout=...)``. When the timeout elapsed, the thread often
+    remained blocked inside ``input()``. That stray, still-waiting ``input()`` subsequently consumed
+    the next ENTER the user typed at a later prompt (e.g., the Medicare question), producing a blank,
+    unlabeled input step before the real prompt. This manifested as “press Enter once to get the next
+    prompt,” which is undesirable and confusing.
+
+    To avoid leaving a pending console read, this implementation uses Windows' non-blocking console
+    polling (``msvcrt.kbhit()/getwch()``) for up to ~2 seconds to detect an ENTER press without ever
+    invoking ``input()``. Non-ENTER keys are discarded to avoid leaking keystrokes into subsequent
+    prompts. If ENTER is not pressed during the window, we skip API validation with no lingering input
+    state.
+
+    If threading must be used in future
+    -----------------------------------
+    Do not call ``input()`` in a background thread and leave it running after a timeout. Instead:
+    - Use a worker thread that performs non-blocking polling (e.g., ``msvcrt.kbhit()/getwch()``) and
+      sets a threading.Event when ENTER is detected.
+    - The main thread waits on the Event with a timeout. On timeout, signal the worker to stop.
+    - Before returning, drain any buffered keystrokes with a short loop while ``msvcrt.kbhit()`` to
+      ensure no characters (including ENTER) carry over to the next prompt.
+    - This avoids dangling reads and preserves a clean console state.
+
+    Compatibility
+    -------------
+    - Targets Python 3.4.4 / Windows XP constraints; avoids ``selectors``/``select`` on stdin and
+      avoids advanced console APIs. Falls back to a non-interactive skip on non-Windows platforms.
+
     Args:
         crosswalk (dict): The crosswalk dictionary to check.
         config (dict): Configuration settings for logging.
-    
+
     Returns:
-        bool: True if should proceed with API calls, False if should skip
+        bool: True to proceed with API calls; False to skip
     """
     
     is_healthy, missing_names, missing_medisoft_ids, missing_names_list, missing_medisoft_ids_list = check_crosswalk_health(crosswalk)
@@ -103,31 +132,47 @@ def prompt_user_for_api_calls(crosswalk, config):
         print("  - All payers have names")
         print("  - All payers have medisoft IDs")
         print("\nPress ENTER to run API validation, or wait 2 seconds to skip...")
-        
-        # Use threading for timeout on Windows
-        user_input = [None]  # Use list to store result from thread
-        
-        def get_input():
-            try:
-                user_input[0] = input()
-            except (EOFError, KeyboardInterrupt):
-                user_input[0] = ""
-        
-        # Start input thread
-        input_thread = threading.Thread(target=get_input)
-        input_thread.daemon = True
-        input_thread.start()
-        
-        # Wait for 2 seconds or until input is received
-        input_thread.join(timeout=2.0)
-        
-        if user_input[0] is not None:
-            print("Running API validation calls...")
-            MediLink_ConfigLoader.log("User pressed ENTER - proceeding with API calls", config, level="INFO")
-            return True
-        else:
-            print("Timed out - skipping API calls")
-            MediLink_ConfigLoader.log("Timeout - skipping API calls", config, level="INFO")
+
+        # Windows-safe, non-blocking ENTER detection without leaving a stray input() pending
+        try:
+            import os, time
+            msvcrt = None
+            if os.name == 'nt':
+                try:
+                    import msvcrt  # Windows-only
+                except ImportError:
+                    msvcrt = None
+
+            if msvcrt is not None:
+                start_time = time.time()
+                pressed_enter = False
+                # Consume keys for up to 2 seconds, act only if ENTER is hit
+                while time.time() - start_time < 2.0:
+                    if msvcrt.kbhit():
+                        ch = msvcrt.getwch()
+                        if ch in ('\r', '\n'):
+                            pressed_enter = True
+                            break
+                        # Discard any other keys so they don't leak into later prompts
+                    time.sleep(0.01)
+
+                if pressed_enter:
+                    print("Running API validation calls...")
+                    MediLink_ConfigLoader.log("User pressed ENTER - proceeding with API calls", config, level="INFO")
+                    return True
+                else:
+                    print("Timed out - skipping API calls")
+                    MediLink_ConfigLoader.log("Timeout - skipping API calls", config, level="INFO")
+                    return False
+            else:
+                # Fallback for non-Windows: avoid interactive wait to prevent stdin conflicts
+                print("(Skipping interactive API validation prompt on this platform)")
+                MediLink_ConfigLoader.log("Skipped interactive API validation prompt (unsupported platform)", config, level="INFO")
+                return False
+        except Exception:
+            # On any error, default to skipping to avoid dangling input states
+            print("(Error during prompt; skipping API validation)")
+            MediLink_ConfigLoader.log("Error during API validation prompt; skipping", config, level="WARNING")
             return False
     else:
         print("\nCrosswalk needs attention:")

{medicafe-0.250810.5 → medicafe-0.250810.7}/MediCafe/__main__.py

@@ -25,6 +25,7 @@ import sys
 import os
 import argparse
 import subprocess
+from MediCafe.core_utils import import_medilink_module, require_functions, print_import_diagnostics
 
 # Set up module paths for proper imports
 def setup_entry_point_paths():
@@ -44,6 +45,21 @@ def setup_entry_point_paths():
         while pkg_dir in sys.path:
             sys.path.remove(pkg_dir)
 
+def validate_critical_imports():
+    """Validate key modules and capabilities before launching subprocesses.
+    - Ensures we resolve the in-repo MediLink_DataMgmt and it exposes required functions.
+    Behavior depends on env flags handled inside core_utils.require_functions.
+    """
+    try:
+        datamgmt = import_medilink_module('MediLink_DataMgmt')
+        if datamgmt is not None:
+            print_import_diagnostics('MediLink_DataMgmt', datamgmt)
+            # These are used by both MediBot and MediLink flows
+            require_functions(datamgmt, ['read_general_fixed_width_data', 'read_fixed_width_data', 'parse_fixed_width_data'])
+    except Exception as e:
+        # Fail fast only if strict mode is enabled (exception originates from require_functions)
+        print("Import validation warning: {}".format(e))
+
 def run_medibot(config_file=None):
     """Run MediBot application"""
     try:
@@ -58,6 +74,9 @@ def run_medibot(config_file=None):
             print("Error: MediBot.py not found at {}".format(medibot_path))
             return 1
 
+        # Pre-flight import validation (no-op unless strict/debug enabled)
+        validate_critical_imports()
+
         # Build subprocess arguments
         args = [sys.executable, medibot_path]
         if config_file:
@@ -83,6 +102,8 @@ def run_medilink():
     """Run MediLink application"""
     try:
         print("Starting MediLink...")
+        # Pre-flight import validation (no-op unless strict/debug enabled)
+        validate_critical_imports()
         # Use subprocess.call for Python 3.4.4 compatibility
         
         # Get the path to MediLink_main.py

{medicafe-0.250810.5 → medicafe-0.250810.7}/MediCafe/core_utils.py

@@ -29,6 +29,62 @@ for _p in list(sys.path):
 DEFAULT_CONFIG_PATH = os.path.join(project_dir, 'json', 'config.json')
 DEFAULT_CROSSWALK_PATH = os.path.join(project_dir, 'json', 'crosswalk.json')
 
+# Environment flags controlling import behavior
+_STRICT_IMPORT = os.environ.get('MEDICAFE_IMPORT_STRICT', '0').strip().lower() in ('1', 'true', 'yes', 'y')
+_DEBUG_IMPORT = os.environ.get('MEDICAFE_IMPORT_DEBUG', '0').strip().lower() in ('1', 'true', 'yes', 'y')
+
+# Simple memoization cache for resolved imports
+_IMPORT_CACHE = {}
+
+def _cache_get(key):
+    try:
+        return _IMPORT_CACHE.get(key)
+    except Exception:
+        return None
+
+def _cache_set(key, value):
+    try:
+        _IMPORT_CACHE[key] = value
+    except Exception:
+        pass
+
+def _module_provenance_ok(module):
+    """Return True if module appears to come from this workspace."""
+    try:
+        module_file = getattr(module, '__file__', '') or ''
+        return os.path.abspath(project_dir) in os.path.abspath(module_file)
+    except Exception:
+        return False
+
+def require_functions(module, names):
+    """Ensure the module exposes all required attributes; raise RuntimeError on failure in strict mode; return bool otherwise."""
+    missing = [name for name in names if not hasattr(module, name)]
+    if missing:
+        message = "Missing required symbols {} in module {}".format(missing, getattr(module, '__name__', 'unknown'))
+        if _STRICT_IMPORT:
+            raise RuntimeError(message)
+        if _DEBUG_IMPORT:
+            try:
+                print("[IMPORT DIAG] {} (file: {})".format(message, getattr(module, '__file__', 'unknown')))
+            except Exception:
+                pass
+        return False
+    return True
+
+def print_import_diagnostics(label, module):
+    """Print a single-line diagnostic about a resolved module (debug only)."""
+    if not _DEBUG_IMPORT:
+        return
+    try:
+        print("[IMPORT DIAG] {} -> name={} file={} workspace_provenance={}".format(
+            label,
+            getattr(module, '__name__', 'unknown'),
+            getattr(module, '__file__', 'unknown'),
+            _module_provenance_ok(module)
+        ))
+    except Exception:
+        pass
+
 def setup_project_path(file_path=None):
     """
     Standard project path setup function used by all entry points.
@@ -122,12 +178,26 @@ def smart_import(import_specs, default_value=None):
         try:
             if isinstance(spec, str):
                 # Simple string - direct import
-                return __import__(spec)
+                # If dotted path, ensure we get the submodule, not just the top-level package
+                cached = _cache_get(('str', spec))
+                if cached is not None:
+                    return cached
+                if '.' in spec:
+                    result = __import__(spec, fromlist=['*'])
+                else:
+                    result = __import__(spec)
+                _cache_set(('str', spec), result)
+                return result
             elif isinstance(spec, tuple):
                 # Tuple - (path, function_name)
                 path, function_name = spec
+                cached = _cache_get(('tuple', path, function_name))
+                if cached is not None:
+                    return cached
                 module = __import__(path, fromlist=[function_name])
-                return getattr(module, function_name)
+                result = getattr(module, function_name)
+                _cache_set(('tuple', path, function_name), result)
+                return result
             elif isinstance(spec, dict):
                 # Dict with fallback
                 path = spec['path']
@@ -135,19 +205,38 @@ def smart_import(import_specs, default_value=None):
                 fallback = spec.get('fallback')
                 
                 try:
+                    cache_key = ('dict', path, function_name)
+                    cached = _cache_get(cache_key)
+                    if cached is not None:
+                        return cached
                     if function_name:
                         module = __import__(path, fromlist=[function_name])
-                        return getattr(module, function_name)
+                        result = getattr(module, function_name)
                     else:
-                        return __import__(path)
+                        # If dotted, use fromlist to return the submodule
+                        if '.' in path:
+                            result = __import__(path, fromlist=['*'])
+                        else:
+                            result = __import__(path)
+                    _cache_set(cache_key, result)
+                    return result
                 except ImportError:
                     if fallback:
                         try:
+                            cache_key = ('dict_fallback', fallback, function_name)
+                            cached = _cache_get(cache_key)
+                            if cached is not None:
+                                return cached
                             if function_name:
                                 module = __import__(fallback, fromlist=[function_name])
-                                return getattr(module, function_name)
+                                result = getattr(module, function_name)
                             else:
-                                return __import__(fallback)
+                                if '.' in fallback:
+                                    result = __import__(fallback, fromlist=['*'])
+                                else:
+                                    result = __import__(fallback)
+                            _cache_set(cache_key, result)
+                            return result
                         except ImportError:
                             continue
                     continue
@@ -252,14 +341,16 @@ def import_medilink_module(module_name, function_name=None):
     Returns:
         The imported module/function or None
     """
+    # Prefer importing from the in-repo MediLink package first to avoid
+    # accidentally picking up a similarly named top-level/site-packages module.
     import_specs = [
-        # Direct import first
-        module_name,
-        # Then try with MediLink prefix
+        # Prefer package-qualified import first (local codebase)
         'MediLink.{}'.format(module_name),
+        # Then try direct import (legacy/installed module)
+        module_name,
         # Then try relative import
         '.{}'.format(module_name),
-        # Finally try as a submodule
+        # Finally try as a submodule with fallback
         {'path': 'MediLink.{}'.format(module_name), 'fallback': module_name}
     ]
     
@@ -275,9 +366,22 @@ def import_medilink_module(module_name, function_name=None):
                     'function': function_name,
                     'fallback': spec.get('fallback')
                 })
-        return smart_import(function_specs)
+        result = smart_import(function_specs)
+        if result is not None and _DEBUG_IMPORT:
+            try:
+                print_import_diagnostics('import_medilink_module:{}:function'.format(module_name), result)
+            except Exception:
+                pass
+        return result
     else:
-        return smart_import(import_specs)
+        result = smart_import(import_specs)
+        if result is not None:
+            # In strict mode, verify provenance and capabilities if demanded by callers
+            if _STRICT_IMPORT and not _module_provenance_ok(result):
+                raise RuntimeError("Imported module '{}' from outside workspace: {}".format(
+                    module_name, getattr(result, '__file__', 'unknown')))
+            print_import_diagnostics('import_medilink_module:{}'.format(module_name), result)
+        return result
 
 def get_shared_config_loader():
     """

{medicafe-0.250810.5/medicafe.egg-info → medicafe-0.250810.7}/PKG-INFO

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

{medicafe-0.250810.5 → medicafe-0.250810.7/medicafe.egg-info}/PKG-INFO

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

{medicafe-0.250810.5 → medicafe-0.250810.7}/setup.py

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