medicafe 0.250818.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")
@@ -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:

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.

MediBot/__init__.py

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

MediCafe/__init__.py

@@ -27,7 +27,7 @@ Smart Import System:
         api_suite = get_api_access()
 """
 
-__version__ = "0.250818.0"
+__version__ = "0.250819.0"
 __author__ = "Daniel Vidaud"
 __email__ = "daniel@personalizedtransformation.com"
 

MediLink/MediLink_837p_encoder.py

@@ -202,7 +202,7 @@ def write_output_file(document_segments, output_directory, endpoint_key, input_f
 
     # Write the document to the output file
     try:
-        with open(new_output_file_path, 'w') as output_file:
+        with open(new_output_file_path, 'w', encoding='utf-8') as output_file:
             output_file.write('\n'.join(document_segments))
         MediLink_ConfigLoader.log("Successfully converted and saved to {}".format(new_output_file_path), config, level="INFO")
         return new_output_file_path