medicafe 0.250806.10__tar.gz → 0.250806.12__tar.gz

{medicafe-0.250806.10 → medicafe-0.250806.12}/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.12}/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.12}/MediLink/MediLink_837p_encoder_library.py

@@ -23,6 +23,18 @@ try:
 except ImportError:
     pass
 
+# 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
+
 try:
     from MediBot import MediBot_Crosswalk_Library
 except ImportError:

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

@@ -23,11 +23,26 @@ def _get_load_insurance_function():
         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("Failed to import load_insurance_data_from_mains: {}".format(e), level="WARNING")
+        else:
+            print("Warning: Failed to import load_insurance_data_from_mains: {}".format(e))
         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):
     """

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

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

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

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

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

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