medicafe 0.250810.4__tar.gz → 0.250810.6__tar.gz

{medicafe-0.250810.4 → medicafe-0.250810.6}/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
@@ -557,7 +563,6 @@ if errorlevel 1 (
     pause
 )
 
-pause
 goto main_menu
 
 :: MediLink Flow
@@ -571,7 +576,6 @@ if errorlevel 1 (
     pause
 )
 
-pause
 goto main_menu
 
 :toggle_perf_logging

{medicafe-0.250810.4 → medicafe-0.250810.6}/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,41 +45,55 @@ 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:
         print("Starting MediBot...")
-        
-        # Set up command line arguments
+
+        # Resolve workspace root and MediBot.py path
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        workspace_root = os.path.dirname(current_dir)
+        medibot_path = os.path.join(workspace_root, 'MediBot', 'MediBot.py')
+
+        if not os.path.exists(medibot_path):
+            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:
-            sys.argv = ['MediBot.py', config_file]
+            args.append(config_file)
+
+        # Ensure subprocess can import project packages
+        env = os.environ.copy()
+        python_path = workspace_root
+        if 'PYTHONPATH' in env:
+            env['PYTHONPATH'] = python_path + os.pathsep + env['PYTHONPATH']
         else:
-            sys.argv = ['MediBot.py']
-            
-        # Import and run MediBot directly
-        try:
-            from MediBot import MediBot
-            # If MediBot has a main function, call it
-            if hasattr(MediBot, 'main'):
-                return MediBot.main()
-            else:
-                # Otherwise, just import it (it will run its own code)
-                return 0
-        except ImportError:
-            # Fallback: try to run the file directly
-            import subprocess
-            medibot_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'MediBot', 'MediBot.py')
-            if os.path.exists(medibot_path):
-                # Use subprocess.call for Python 3.4.4 compatibility
-                result = subprocess.call([sys.executable, medibot_path] + sys.argv[1:], 
-                                       cwd=os.path.dirname(medibot_path))
-                return result
-            else:
-                raise ImportError("MediBot.py not found at {}".format(medibot_path))
-        
-    except ImportError as e:
-        print("Error: Unable to import MediBot: {}".format(e))
-        return 1
+            env['PYTHONPATH'] = python_path
+
+        # Run MediBot as a script so its __main__ block executes
+        result = subprocess.call(args, cwd=os.path.dirname(medibot_path), env=env)
+        return result
+
     except Exception as e:
         print("Error running MediBot: {}".format(e))
         return 1
@@ -87,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.4 → medicafe-0.250810.6}/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.4/medicafe.egg-info → medicafe-0.250810.6}/PKG-INFO

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

{medicafe-0.250810.4 → medicafe-0.250810.6/medicafe.egg-info}/PKG-INFO

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

{medicafe-0.250810.4 → medicafe-0.250810.6}/setup.py

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