medicafe 0.250816.0__py3-none-any.whl → 0.250819.0__py3-none-any.whl

MediBot/MediBot.py

@@ -662,6 +662,34 @@ if __name__ == "__main__":
         # Initialize constants from config
         MediBot_Preprocessor_lib.initialize(e_state.config)
         
+        # PERFORMANCE OPTIMIZATION: Load both Medicare and Private patient databases during startup
+        # Files are small (10K-20K rows each) so memory usage is minimal (~4MB total)
+        # This eliminates the 1-2 second delay from user workflow entirely
+        print("Loading patient databases...")
+        MediLink_ConfigLoader.log("Loading patient databases...", level="INFO")
+        
+        try:
+            medicare_path = e_state.config.get('MEDICARE_MAPAT_MED_PATH', "")
+            private_path = e_state.config.get('MAPAT_MED_PATH', "")
+            
+            # Load both databases into separate caches
+            medicare_cache = MediBot_Preprocessor.load_existing_patient_ids(medicare_path) if medicare_path else {}
+            private_cache = MediBot_Preprocessor.load_existing_patient_ids(private_path) if private_path else {}
+            
+            # Store both caches for later use
+            MediBot_Preprocessor.set_patient_caches(medicare_cache, private_cache)
+            
+            if PERFORMANCE_LOGGING:
+                print("Patient databases loaded: {} Medicare, {} Private patients".format(
+                    len(medicare_cache), len(private_cache)))
+            MediLink_ConfigLoader.log("Patient databases loaded: {} Medicare, {} Private patients".format(
+                len(medicare_cache), len(private_cache)), level="INFO")
+                
+        except Exception as e:
+            MediLink_ConfigLoader.log("Warning: Could not load patient databases: {}".format(e), level="WARNING")
+            if PERFORMANCE_LOGGING:
+                print("Warning: Could not load patient databases - will load on demand")
+        
         if PERFORMANCE_LOGGING:
             print("Loading CSV Data...")
         MediLink_ConfigLoader.log("Loading CSV Data...", level="INFO")
@@ -735,7 +763,7 @@ if __name__ == "__main__":
                         print(msg)
                 print("-" * 60)
         
-        proceed, selected_patient_ids, selected_indices, fixed_values = user_interaction(csv_data, interaction_mode, error_message, reverse_mapping)
+        proceed, selected_patient_ids, selected_indices, fixed_values, is_medicare = user_interaction(csv_data, interaction_mode, error_message, reverse_mapping)
 
         if proceed:
             # Filter csv_data for selected patients from Triage mode
@@ -745,7 +773,13 @@ if __name__ == "__main__":
             if (not _ac()) or (not _ac().get_mapat_med_path()) or (not os.path.exists(_ac().get_mapat_med_path())):
                 record_startup_warning("Warning: MAPAT.MED PATH is missing or invalid. Please check the path configuration.")
 
-            # Perform the existing patients check
+            # PERFORMANCE OPTIMIZATION: Select the appropriate pre-loaded patient cache
+            # Both caches were loaded during startup, now we just select the right one
+            MediBot_Preprocessor.select_active_cache(is_medicare)
+            if PERFORMANCE_LOGGING:
+                print("Using {} patient cache for existing patient check".format("Medicare" if is_medicare else "Private"))
+
+            # Perform the existing patients check (now uses cached data)
             existing_patients, patients_to_process = MediBot_Preprocessor.check_existing_patients(selected_patient_ids, _ac().get_mapat_med_path() if _ac() else '')
             
             if existing_patients:
@@ -767,9 +801,10 @@ if __name__ == "__main__":
                         patient_info.append(('Unknown Date', patient_name, patient_id, 'N/A', None))  # Append with 'Unknown Date' if there's an error
 
                 # Display existing patients table using the enhanced display function
+                patient_type = "MEDICARE" if is_medicare else "PRIVATE"
                 MediBot_UI.display_enhanced_patient_table(
                     patient_info, 
-                    "NOTE: The following patient(s) already EXIST in the system but may have new dates of service.\n      Their diagnosis codes may need to be updated manually by the user to the following list:",
+                    "{} PATIENTS - EXISTING: The following patient(s) already EXIST in the system but may have new dates of service.\n      Their diagnosis codes may need to be updated manually by the user to the following list:".format(patient_type),
                     show_line_numbers=False
                 )
 
@@ -787,9 +822,10 @@ if __name__ == "__main__":
                     new_patient_info.extend(patient_entries)
 
                 # Display new patients table using the enhanced display function
+                patient_type = "MEDICARE" if is_medicare else "PRIVATE"
                 MediBot_UI.display_enhanced_patient_table(
                     new_patient_info, 
-                    "NOTE: The following NEW patient(s) will be automatically entered into Medisoft:",
+                    "{} PATIENTS - NEW: The following patient(s) will be automatically entered into Medisoft:".format(patient_type),
                     show_line_numbers=True
                 )
 

MediBot/MediBot_Crosswalk_Utils.py

@@ -9,10 +9,7 @@ to improve code organization and maintainability.
 Compatible with Python 3.4.4 and Windows XP environments.
 """
 
-import json
-import os
-import sys
-import threading
+import json, os, sys
 
 # Set the project directory to the parent directory of the current file
 project_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))

MediBot/MediBot_Preprocessor.py

@@ -144,30 +144,104 @@ def preprocess_csv_data(csv_data, crosswalk):
         MediLink_ConfigLoader.log(message, level="ERROR")
         print(message)
 
-def check_existing_patients(selected_patient_ids, MAPAT_MED_PATH):
-    existing_patients = []
-    # Convert to set for O(1) lookup performance
-    selected_patient_ids_set = set(selected_patient_ids)
+# Global caches for existing patient IDs to avoid repeated file I/O
+_medicare_patients_cache = None
+_private_patients_cache = None
+_current_cache = None  # Points to the active cache based on user selection
 
+def load_existing_patient_ids(MAPAT_MED_PATH):
+    """
+    Load all existing patient IDs from MAPAT.MED file into memory cache.
+    
+    Args:
+        MAPAT_MED_PATH: Path to the MAPAT.MED file
+        
+    Returns:
+        dict: {patient_id: patient_name} mapping of all existing patients
+    """
+    patient_cache = {}
+    
+    if not MAPAT_MED_PATH:
+        MediLink_ConfigLoader.log("MAPAT.MED path not provided - returning empty cache", level="WARNING")
+        return patient_cache
+    
     try:
+        MediLink_ConfigLoader.log("Loading patient cache from: {}".format(MAPAT_MED_PATH), level="INFO")
         with open(MAPAT_MED_PATH, 'r') as file:
             next(file)  # Skip header row
             for line in file:
-                if line.startswith("0"): # 1 is a flag for a deleted record so it would need to be re-entered.
+                if line.startswith("0"):  # 1 is a flag for a deleted record so it would need to be re-entered.
                     patient_id = line[194:202].strip()  # Extract Patient ID (Columns 195-202)
                     patient_name = line[9:39].strip()  # Extract Patient Name (Columns 10-39)
                     
-                    if patient_id in selected_patient_ids_set:
-                        existing_patients.append((patient_id, patient_name))
-                        # Remove from set for O(1) operation
-                        selected_patient_ids_set.discard(patient_id)
+                    if patient_id:  # Only cache non-empty patient IDs
+                        patient_cache[patient_id] = patient_name
+        
+        MediLink_ConfigLoader.log("Loaded {} patients into cache from {}".format(len(patient_cache), MAPAT_MED_PATH), level="INFO")
+        
     except FileNotFoundError:
-        # Handle the case where MAPAT_MED_PATH is not found
-        print("MAPAT.med was not found at location indicated in config file.")
-        print("Skipping existing patient check and continuing...")
+        MediLink_ConfigLoader.log("MAPAT.med was not found at location: {}".format(MAPAT_MED_PATH), level="WARNING")
+        print("MAPAT.med was not found at location: {}".format(MAPAT_MED_PATH))
+        print("Continuing with empty patient cache...")
+    except Exception as e:
+        MediLink_ConfigLoader.log("Error loading patient cache: {}".format(e), level="ERROR")
+        print("Error loading patient cache: {}".format(e))
+    
+    return patient_cache
+
+def set_patient_caches(medicare_cache, private_cache):
+    """
+    Store both patient caches for later use based on user selection.
+    
+    Args:
+        medicare_cache: Dict of Medicare patient IDs and names
+        private_cache: Dict of Private patient IDs and names
+    """
+    global _medicare_patients_cache, _private_patients_cache
+    _medicare_patients_cache = medicare_cache
+    _private_patients_cache = private_cache
+
+def select_active_cache(is_medicare):
+    """
+    Select which patient cache to use based on Medicare selection.
+    
+    Args:
+        is_medicare: True for Medicare patients, False for Private patients
+    """
+    global _current_cache, _medicare_patients_cache, _private_patients_cache
+    _current_cache = _medicare_patients_cache if is_medicare else _private_patients_cache
+
+def check_existing_patients(selected_patient_ids, MAPAT_MED_PATH):
+    """
+    Check which selected patients already exist in the system using cached data.
+    This is now much faster as it uses in-memory cache instead of file I/O.
+    
+    Args:
+        selected_patient_ids: List of patient IDs to check
+        MAPAT_MED_PATH: Path to MAPAT.MED file (for fallback if cache not available)
         
-    # Convert remaining set back to list for return
-    patients_to_process = list(selected_patient_ids_set)
+    Returns:
+        tuple: (existing_patients, patients_to_process)
+    """
+    global _current_cache
+    
+    # Use current cache if available, otherwise fallback to loading file
+    if _current_cache is not None:
+        existing_patients_dict = _current_cache
+    else:
+        # Fallback: load from file if cache not available
+        existing_patients_dict = load_existing_patient_ids(MAPAT_MED_PATH)
+    
+    existing_patients = []
+    patients_to_process = []
+    
+    # Use cached data for O(1) lookups instead of file I/O
+    for patient_id in selected_patient_ids:
+        if patient_id in existing_patients_dict:
+            patient_name = existing_patients_dict[patient_id]
+            existing_patients.append((patient_id, patient_name))
+        else:
+            patients_to_process.append(patient_id)
     
     return existing_patients, patients_to_process
 

MediBot/MediBot_Preprocessor_lib.py

@@ -309,6 +309,103 @@ def detect_date_format(date_str):
     
     return None
 
+class OptimizedDate:
+    """
+    Optimized date object that pre-computes all common format variations
+    to avoid redundant datetime conversions throughout the application.
+    """
+    def __init__(self, datetime_obj):
+        self.datetime = datetime_obj
+        # Pre-compute all common format variations
+        self._display_short = datetime_obj.strftime('%m-%d')  # For table display
+        self._display_full = datetime_obj.strftime('%m-%d-%Y')  # Full format
+        self._medisoft_format = datetime_obj.strftime('%m%d%Y')  # For Medisoft entry
+        self._iso_format = datetime_obj.strftime('%Y-%m-%d')  # For sorting/comparison
+        
+    @property
+    def display_short(self):
+        """Short display format: MM-DD"""
+        return self._display_short
+        
+    @property
+    def display_full(self):
+        """Full display format: MM-DD-YYYY"""
+        return self._display_full
+        
+    @property
+    def medisoft_format(self):
+        """Medisoft entry format: MMDDYYYY"""
+        return self._medisoft_format
+        
+    @property
+    def iso_format(self):
+        """ISO format for sorting: YYYY-MM-DD"""
+        return self._iso_format
+    
+    def __str__(self):
+        return self._display_full
+        
+    def __repr__(self):
+        return "OptimizedDate({})".format(self._display_full)
+        
+    def __eq__(self, other):
+        if isinstance(other, OptimizedDate):
+            return self.datetime == other.datetime
+        elif hasattr(other, 'strftime'):  # datetime object
+            return self.datetime == other
+        return False
+        
+    def __lt__(self, other):
+        if isinstance(other, OptimizedDate):
+            return self.datetime < other.datetime
+        elif hasattr(other, 'strftime'):  # datetime object
+            return self.datetime < other
+        return NotImplemented
+        
+    def __gt__(self, other):
+        if isinstance(other, OptimizedDate):
+            return self.datetime > other.datetime
+        elif hasattr(other, 'strftime'):  # datetime object
+            return self.datetime > other
+        return NotImplemented
+    
+    def strftime(self, format_str):
+        """Fallback for any custom format needs"""
+        return self.datetime.strftime(format_str)
+        
+    @classmethod
+    def from_string(cls, date_str, cleaned=False):
+        """
+        Create OptimizedDate from string, with optional pre-cleaning.
+        
+        Args:
+            date_str: Date string to parse
+            cleaned: If True, assumes string is already cleaned
+            
+        Returns:
+            OptimizedDate object or None if parsing fails
+        """
+        if not cleaned:
+            date_str = clean_surgery_date_string(date_str)
+            if not date_str:
+                return None
+        
+        # Try standard format first (most common)
+        try:
+            return cls(datetime.strptime(date_str, '%m/%d/%Y'))
+        except ValueError:
+            pass
+            
+        # Try alternative formats
+        formats = ['%m-%d-%Y', '%m/%d/%y', '%m-%d-%y', '%Y/%m/%d', '%Y-%m-%d']
+        for fmt in formats:
+            try:
+                return cls(datetime.strptime(date_str, fmt))
+            except ValueError:
+                continue
+                
+        return None
+
 def clean_surgery_date_string(date_str):
     """
     Cleans and normalizes surgery date strings to handle damaged data.
@@ -1378,6 +1475,35 @@ def map_payer_ids_to_insurance_ids(patient_id_to_insurance_id, payer_id_to_patie
             }
     return payer_id_to_details
 
+def _display_mains_file_error(mains_path):
+    """
+    Helper function to display the critical MAINS file error message.
+    
+    Args:
+        mains_path (str): The path where the MAINS file was expected to be found.
+    """
+    error_msg = "CRITICAL: MAINS file not found at: {}. This file is required for insurance name to Medisoft ID mapping.".format(mains_path)
+    if hasattr(MediLink_ConfigLoader, 'log'):
+        MediLink_ConfigLoader.log(error_msg, level="CRITICAL")
+    print("\n" + "="*80)
+    print("CRITICAL ERROR: MAINS FILE MISSING")
+    print("="*80)
+    print("\nThe MAINS file is required for the following critical functions:")
+    print("* Mapping insurance company names to Medisoft IDs")
+    print("* Converting insurance names to payer IDs for claim submission")
+    print("* Creating properly formatted 837p claim files")
+    print("\nWithout this file, claim submission will fail because:")
+    print("* Insurance names cannot be converted to payer IDs")
+    print("* 837p claim files cannot be generated")
+    print("* Claims cannot be submitted to insurance companies")
+    print("\nTO FIX THIS:")
+    print("1. Ensure the MAINS file exists at: {}".format(mains_path))
+    print("2. If the file is missing, llamar a Dani")
+    print("3. The file should contain insurance company data from your Medisoft system")
+    print("="*80)
+    time.sleep(3)  # 3 second pause to allow user to read critical error message
+
+
 def load_insurance_data_from_mains(config):
     """
     Loads insurance data from MAINS and creates a mapping from insurance names to their respective IDs.
@@ -1421,25 +1547,7 @@ def load_insurance_data_from_mains(config):
     try:
         # 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)
-            if hasattr(MediLink_ConfigLoader, 'log'):
-                MediLink_ConfigLoader.log(error_msg, level="CRITICAL")
-            print("\n" + "="*80)
-            print("CRITICAL ERROR: MAINS FILE MISSING")
-            print("="*80)
-            print("\nThe MAINS file is required for the following critical functions:")
-            print("* Mapping insurance company names to Medisoft IDs")
-            print("* Converting insurance names to payer IDs for claim submission")
-            print("* Creating properly formatted 837p claim files")
-            print("\nWithout this file, claim submission will fail because:")
-            print("* Insurance names cannot be converted to payer IDs")
-            print("* 837p claim files cannot be generated")
-            print("* Claims cannot be submitted to insurance companies")
-            print("\nTO FIX THIS:")
-            print("1. Ensure the MAINS file exists at: {}".format(mains_path))
-            print("2. If the file is missing, llamar a Dani")
-            print("3. The file should contain insurance company data from your Medisoft system")
-            print("="*80)
+            _display_mains_file_error(mains_path)
             return insurance_to_id
         
         # XP Compatibility: Check if MediLink_DataMgmt has the required function
@@ -1459,25 +1567,7 @@ def load_insurance_data_from_mains(config):
             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)
-        if hasattr(MediLink_ConfigLoader, 'log'):
-            MediLink_ConfigLoader.log(error_msg, level="CRITICAL")
-        print("\n" + "="*80)
-        print("CRITICAL ERROR: MAINS FILE MISSING")
-        print("="*80)
-        print("\nThe MAINS file is required for the following critical functions:")
-        print("* Mapping insurance company names to Medisoft IDs")
-        print("* Converting insurance names to payer IDs for claim submission")
-        print("* Creating properly formatted 837p claim files")
-        print("\nWithout this file, claim submission will fail because:")
-        print("* Insurance names cannot be converted to payer IDs")
-        print("* 837p claim files cannot be generated")
-        print("* Claims cannot be submitted to insurance companies")
-        print("\nTO FIX THIS:")
-        print("1. Ensure the MAINS file exists at: {}".format(mains_path))
-        print("2. If the file is missing, llamar a Dani")
-        print("3. The file should contain insurance company data from your Medisoft system")
-        print("="*80)
+        _display_mains_file_error(mains_path)
     except Exception as e:
         error_msg = "Error loading MAINS data: {}. Continuing without MAINS data.".format(str(e))
         if hasattr(MediLink_ConfigLoader, 'log'):

MediBot/MediBot_UI.py

@@ -316,6 +316,10 @@ def display_patient_selection_menu(csv_data, reverse_mapping, proceed_as_medicar
     selected_patient_ids = []
     selected_indices = []
 
+    # TODO: Future enhancement - make this configurable via config file
+    # Example: config.get('silent_initial_selection', True)
+    SILENT_INITIAL_SELECTION = True  # Set to False to restore original interactive behavior
+
     def display_menu_header(title):
         print("\n" + "-" * 60)
         print(title)
@@ -348,7 +352,10 @@ def display_patient_selection_menu(csv_data, reverse_mapping, proceed_as_medicar
                 formatted_date = surgery_date.strftime('%m-%d')
             except Exception:
                 formatted_date = str(surgery_date)
-            print("{0:03d}: {3} (ID: {2}) {1} ".format(index+1, patient_name, patient_id, formatted_date))
+            
+            # Only display if not in silent mode
+            if not SILENT_INITIAL_SELECTION:
+                print("{0:03d}: {3} (ID: {2}) {1} ".format(index+1, patient_name, patient_id, formatted_date))
 
             displayed_indices.append(index)
             displayed_patient_ids.append(patient_id)
@@ -356,23 +363,44 @@ def display_patient_selection_menu(csv_data, reverse_mapping, proceed_as_medicar
         return displayed_indices, displayed_patient_ids
 
     if proceed_as_medicare:
-        display_menu_header("MEDICARE Patient Selection for Today's Data Entry")
+        if not SILENT_INITIAL_SELECTION:
+            display_menu_header("MEDICARE Patient Selection for Today's Data Entry")
         selected_indices, selected_patient_ids = display_patient_list(csv_data, reverse_mapping, medicare_filter=True)
     else:
-        display_menu_header("PRIVATE Patient Selection for Today's Data Entry")
+        if not SILENT_INITIAL_SELECTION:
+            display_menu_header("PRIVATE Patient Selection for Today's Data Entry")
         selected_indices, selected_patient_ids = display_patient_list(csv_data, reverse_mapping, exclude_medicare=True)
 
-    print("-" * 60)
-    proceed = input("\nDo you want to proceed with the selected patients? (yes/no): ").lower().strip() in ['yes', 'y']
+    if not SILENT_INITIAL_SELECTION:
+        print("-" * 60)
+        proceed = input("\nDo you want to proceed with the selected patients? (yes/no): ").lower().strip() in ['yes', 'y']
+    else:
+        # Auto-confirm in silent mode
+        proceed = True
 
     if not proceed:
-        display_menu_header("Patient Selection for Today's Data Entry")
-        selected_indices, selected_patient_ids = display_patient_list(csv_data, reverse_mapping)
-        print("-" * 60)
-        
-        while True:
+        if not SILENT_INITIAL_SELECTION:
+            display_menu_header("Patient Selection for Today's Data Entry")
+            selected_indices, selected_patient_ids = display_patient_list(csv_data, reverse_mapping)
+            print("-" * 60)
+            
             while True:
-                selection = input("\nEnter the number(s) of the patients you wish to proceed with\n(e.g., 1, 3, 5): ").strip()
+                while True:
+                    selection = input("\nEnter the number(s) of the patients you wish to proceed with\n(e.g., 1, 3, 5): ").strip()
+                    if not selection:
+                        print("Invalid entry. Please provide at least one number.")
+                        continue
+                    
+                    selection = selection.replace('.', ',')  # Replace '.' with ',' in the user input just in case
+                    selected_indices = [int(x.strip()) - 1 for x in selection.split(',') if x.strip().isdigit()]  
+                    
+                    if not selected_indices:
+                        print("Invalid entry. Please provide at least one integer.")
+                        continue
+                    
+                    proceed = True
+                    break
+                
                 if not selection:
                     print("Invalid entry. Please provide at least one number.")
                     continue
@@ -386,20 +414,6 @@ def display_patient_selection_menu(csv_data, reverse_mapping, proceed_as_medicar
                 
                 proceed = True
                 break
-            
-            if not selection:
-                print("Invalid entry. Please provide at least one number.")
-                continue
-            
-            selection = selection.replace('.', ',')  # Replace '.' with ',' in the user input just in case
-            selected_indices = [int(x.strip()) - 1 for x in selection.split(',') if x.strip().isdigit()]  
-            
-            if not selected_indices:
-                print("Invalid entry. Please provide at least one integer.")
-                continue
-            
-            proceed = True
-            break
 
     patient_id_header = reverse_mapping['Patient ID #2']
     selected_patient_ids = [csv_data[i][patient_id_header] for i in selected_indices if i < len(csv_data)]
@@ -498,6 +512,15 @@ def user_interaction(csv_data, interaction_mode, error_message, reverse_mapping)
             fixed_values.update(medicare_added_fixed_values)  # Add any medicare-specific fixed values from config
         
         proceed, selected_patient_ids, selected_indices = display_patient_selection_menu(csv_data, reverse_mapping, response in ['yes', 'y'])
-        return proceed, selected_patient_ids, selected_indices, fixed_values
-
-    return handle_user_interaction(interaction_mode, error_message)
+        is_medicare = response in ['yes', 'y']
+        return proceed, selected_patient_ids, selected_indices, fixed_values, is_medicare
+
+    # For non-triage modes (error, normal), return a compatible structure
+    # The is_medicare value is not relevant in these modes, so we'll use a default
+    result = handle_user_interaction(interaction_mode, error_message)
+    if isinstance(result, int):
+        # This is a control value (-1, 1, -2), return with default values
+        return False, [], [], {}, False  # proceed=False, empty lists, empty dict, is_medicare=False
+    else:
+        # Unexpected return type, handle gracefully
+        return False, [], [], {}, False

MediBot/__init__.py

@@ -19,7 +19,7 @@ Smart Import Integration:
         medibot_main = get_components('medibot_main')
 """
 
-__version__ = "0.250816.0"
+__version__ = "0.250819.0"
 __author__ = "Daniel Vidaud"
 __email__ = "daniel@personalizedtransformation.com"