medicafe 0.250814.4__tar.gz → 0.250816.0__tar.gz

{medicafe-0.250814.4 → medicafe-0.250816.0}/MediBot/MediBot.py

@@ -11,6 +11,7 @@ try:
 except ImportError:
     msvcrt = None  # Not available on non-Windows systems
 from collections import OrderedDict
+from datetime import datetime # Added for primary surgery date logic
 
 # ============================================================================
 # MINIMAL PROTECTION: Import State Validation
@@ -171,6 +172,68 @@ def identify_field(header, field_mapping):
     # Add this print to a function that is calling identify_field
     #print("Warning: No matching field found for CSV header '{}'".format(header))
 
+def create_patient_entries_from_row(row, reverse_mapping):
+    """
+    Helper function to create patient entries from a row with surgery date handling.
+    
+    Args:
+        row: The CSV row containing patient data
+        reverse_mapping: The reverse mapping for field lookups
+        
+    Returns:
+        list: List of tuples (surgery_date, patient_name, patient_id, diagnosis_code, row)
+    """
+    patient_id = row.get(reverse_mapping['Patient ID #2'])
+    patient_name = row.get(reverse_mapping['Patient Name'])
+    
+    # Get all surgery dates for this patient
+    all_surgery_dates = row.get('_all_surgery_dates', [row.get('Surgery Date')])
+    surgery_date_to_diagnosis = row.get('_surgery_date_to_diagnosis', {})
+    
+    patient_entries = []
+    
+    # Sort surgery dates chronologically to ensure proper ordering
+    sorted_surgery_dates = []
+    for surgery_date in all_surgery_dates:
+        try:
+            if hasattr(surgery_date, 'strftime'):
+                # Already a datetime object
+                sorted_surgery_dates.append(surgery_date)
+            elif isinstance(surgery_date, str):
+                # Convert string to datetime for sorting
+                surgery_date_dt = datetime.strptime(surgery_date, '%m-%d-%Y')
+                sorted_surgery_dates.append(surgery_date_dt)
+            else:
+                # Fallback - use as is
+                sorted_surgery_dates.append(surgery_date)
+        except (ValueError, TypeError):
+            # If parsing fails, use the original value
+            sorted_surgery_dates.append(surgery_date)
+    
+    # Sort the dates chronologically
+    sorted_surgery_dates.sort()
+    
+    # Create entries for each surgery date in chronological order
+    # The enhanced table display will group by patient_id and show dashed lines for secondary dates
+    for surgery_date in sorted_surgery_dates:
+        try:
+            if hasattr(surgery_date, 'strftime'):
+                surgery_date_str = surgery_date.strftime('%m-%d-%Y')
+            elif isinstance(surgery_date, str):
+                surgery_date_str = surgery_date
+            else:
+                surgery_date_str = str(surgery_date)
+        except Exception:
+            surgery_date_str = str(surgery_date)
+        
+        # Get the diagnosis code for this surgery date
+        diagnosis_code = surgery_date_to_diagnosis.get(surgery_date_str, 'N/A')
+        
+        # Add entry for this surgery date
+        patient_entries.append((surgery_date, patient_name, patient_id, diagnosis_code, row))
+    
+    return patient_entries
+
 # Global flag to control AHK execution method - set to True to use optimized stdin method
 USE_AHK_STDIN_OPTIMIZATION = True
 
@@ -695,23 +758,9 @@ if __name__ == "__main__":
                         if patient_row is None:
                             raise ValueError("Patient row not found for patient ID: {}".format(patient_id))
                         
-                        # Get all surgery dates for this patient
-                        all_surgery_dates = patient_row.get('_all_surgery_dates', [patient_row.get('Surgery Date')])
-                        surgery_date_to_diagnosis = patient_row.get('_surgery_date_to_diagnosis', {})
-                        
-                        # Create entries for each surgery date with its specific diagnosis code
-                        for surgery_date in all_surgery_dates:
-                            # Convert surgery_date to string format for consistent lookup (XP SP3 + Py3.4.4 compatible)
-                            try:
-                                if hasattr(surgery_date, 'strftime'):
-                                    surgery_date_str = surgery_date.strftime('%m-%d-%Y')
-                                else:
-                                    surgery_date_str = str(surgery_date)
-                            except Exception:
-                                surgery_date_str = str(surgery_date)
-                            
-                            diagnosis_code = surgery_date_to_diagnosis.get(surgery_date_str, 'N/A')
-                            patient_info.append((surgery_date, patient_name, patient_id, diagnosis_code, patient_row))
+                        # Use helper function to create patient entries
+                        patient_entries = create_patient_entries_from_row(patient_row, reverse_mapping)
+                        patient_info.extend(patient_entries)
                             
                     except Exception as e:
                         MediLink_ConfigLoader.log("Warning: Error retrieving data for patient ID '{}': {}".format(patient_id, e), level="WARNING")
@@ -733,26 +782,9 @@ if __name__ == "__main__":
                 # Collect surgery dates and patient info for NEW patients
                 new_patient_info = []
                 for row in csv_data:
-                    patient_id = row.get(reverse_mapping['Patient ID #2'])
-                    patient_name = row.get(reverse_mapping['Patient Name'])
-                    
-                    # Get all surgery dates for this patient
-                    all_surgery_dates = row.get('_all_surgery_dates', [row.get('Surgery Date')])
-                    surgery_date_to_diagnosis = row.get('_surgery_date_to_diagnosis', {})
-                    
-                    # Create entries for each surgery date with its specific diagnosis code
-                    for surgery_date in all_surgery_dates:
-                        # Convert surgery_date to string format for consistent lookup (XP SP3 + Py3.4.4 compatible)
-                        try:
-                            if hasattr(surgery_date, 'strftime'):
-                                surgery_date_str = surgery_date.strftime('%m-%d-%Y')
-                            else:
-                                surgery_date_str = str(surgery_date)
-                        except Exception:
-                            surgery_date_str = str(surgery_date)
-                        
-                        diagnosis_code = surgery_date_to_diagnosis.get(surgery_date_str, 'N/A')
-                        new_patient_info.append((surgery_date, patient_name, patient_id, diagnosis_code, row))
+                    # Use helper function to create patient entries
+                    patient_entries = create_patient_entries_from_row(row, reverse_mapping)
+                    new_patient_info.extend(patient_entries)
 
                 # Display new patients table using the enhanced display function
                 MediBot_UI.display_enhanced_patient_table(

{medicafe-0.250814.4 → medicafe-0.250816.0}/MediBot/MediBot_Preprocessor_lib.py

@@ -531,17 +531,41 @@ def sort_and_deduplicate(csv_data):
             existing_row = unique_patients[patient_id]
             existing_date = existing_row['Surgery Date']
             
+            # Ensure both dates are comparable by converting to datetime objects
+            def normalize_date_for_comparison(date_value):
+                if isinstance(date_value, datetime):
+                    return date_value
+                elif isinstance(date_value, str) and date_value.strip():
+                    try:
+                        # Try to parse the string as a date
+                        return datetime.strptime(date_value, '%m/%d/%Y')
+                    except ValueError:
+                        try:
+                            return datetime.strptime(date_value, '%m-%d-%Y')
+                        except ValueError:
+                            # If parsing fails, return minimum datetime
+                            return datetime.min
+                else:
+                    # Empty or invalid values get minimum datetime
+                    return datetime.min
+            
+            normalized_surgery_date = normalize_date_for_comparison(surgery_date)
+            normalized_existing_date = normalize_date_for_comparison(existing_date)
+            
             # Keep the most current demographic data (later surgery date takes precedence)
-            if surgery_date > existing_date:
+            if normalized_surgery_date > normalized_existing_date:
                 # Store the old row's surgery date before replacing
                 old_date = existing_row['Surgery Date']
-                patient_surgery_dates[patient_id].append(old_date)
+                # Add the old date to the list if it's not already there
+                if old_date not in patient_surgery_dates[patient_id]:
+                    patient_surgery_dates[patient_id].append(old_date)
                 # Replace with newer row (better demographics)
                 unique_patients[patient_id] = row
-                # Update the surgery dates list to reflect the new primary date
-                patient_surgery_dates[patient_id] = [surgery_date] + [d for d in patient_surgery_dates[patient_id] if d != surgery_date]
+                # Add the new surgery date to the list if it's not already there
+                if surgery_date not in patient_surgery_dates[patient_id]:
+                    patient_surgery_dates[patient_id].append(surgery_date)
             else:
-                # Add this surgery date to the list for this patient
+                # Add this surgery date to the list for this patient if it's not already there
                 if surgery_date not in patient_surgery_dates[patient_id]:
                     patient_surgery_dates[patient_id].append(surgery_date)
 
@@ -558,11 +582,77 @@ def sort_and_deduplicate(csv_data):
             else:
                 surgery_date_strings.append(str(date) if date else 'MISSING')
         
-        row['_all_surgery_dates'] = sorted(surgery_date_strings)
+        # Remove duplicates and sort
+        unique_surgery_dates = list(set(surgery_date_strings))
+        sorted_surgery_dates = sorted(unique_surgery_dates, key=lambda x: datetime.strptime(x, '%m-%d-%Y') if x != 'MISSING' else datetime.min)
+        row['_all_surgery_dates'] = sorted_surgery_dates
         row['_primary_surgery_date'] = row['Surgery Date']  # Keep track of which date has the demographics
+        # Compute and store earliest surgery date for emission sort
+        earliest_dt = None
+        earliest_str = None
+        for d in sorted_surgery_dates:
+            if d and d != 'MISSING':
+                try:
+                    earliest_dt = datetime.strptime(d, '%m-%d-%Y')
+                    earliest_str = d
+                    break
+                except Exception:
+                    pass
+        # Fallback to demographics date if earliest could not be determined
+        if earliest_str is None:
+            try:
+                sd = row.get('Surgery Date')
+                if isinstance(sd, datetime) and sd != datetime.min:
+                    earliest_dt = sd
+                    earliest_str = sd.strftime('%m-%d-%Y')
+                elif isinstance(sd, str) and sd.strip():
+                    try:
+                        earliest_dt = datetime.strptime(sd, '%m/%d/%Y')
+                    except Exception:
+                        try:
+                            earliest_dt = datetime.strptime(sd, '%m-%d-%Y')
+                        except Exception:
+                            earliest_dt = None
+                    earliest_str = sd
+            except Exception:
+                earliest_dt = None
+                earliest_str = None
+        row['_earliest_surgery_date'] = earliest_str
+        
+
 
     # Convert the unique_patients dictionary back to a list and sort it
-    csv_data[:] = sorted(unique_patients.values(), key=lambda x: (x['Surgery Date'], x.get('Patient Last', '').strip())) # TODO Does this need to be sorted twice? once before and once after?
+    # Use the same normalization function for consistent sorting
+    def sort_key(row):
+        # Prefer earliest surgery date across all known dates for the patient
+        earliest = row.get('_earliest_surgery_date')
+        if isinstance(earliest, str) and earliest and earliest != 'MISSING':
+            try:
+                normalized_date = datetime.strptime(earliest, '%m-%d-%Y')
+            except Exception:
+                normalized_date = datetime.min
+        else:
+            # Fallback to the single Surgery Date field
+            surgery_date = row.get('Surgery Date')
+            if isinstance(surgery_date, datetime):
+                normalized_date = surgery_date
+            elif isinstance(surgery_date, str) and surgery_date.strip():
+                try:
+                    normalized_date = datetime.strptime(surgery_date, '%m/%d/%Y')
+                except ValueError:
+                    try:
+                        normalized_date = datetime.strptime(surgery_date, '%m-%d-%Y')
+                    except ValueError:
+                        normalized_date = datetime.min
+            else:
+                normalized_date = datetime.min
+        # Tie-break per requirement: last name (case-insensitive), then first name, then patient id
+        last_name = ((row.get('Patient Last') or '')).strip().upper()
+        first_name = ((row.get('Patient First') or '')).strip().upper()
+        patient_id_tiebreak = str(row.get('Patient ID') or '')
+        return (normalized_date, last_name, first_name, patient_id_tiebreak)
+    
+    csv_data[:] = sorted(unique_patients.values(), key=sort_key) # TODO Does this need to be sorted twice? once before and once after?
     
     # TODO: Consider adding an option in the config to sort based on Surgery Schedules when available.
     # If no schedule is available, the current sorting strategy will be used.

{medicafe-0.250814.4 → medicafe-0.250816.0}/MediBot/MediBot_UI.py

@@ -48,26 +48,29 @@ def display_enhanced_patient_table(patient_info, title, show_line_numbers=True):
     for surgery_date, patient_name, patient_id, diagnosis_code, patient_row in patient_info:
         # Normalize date into comparable key and display string
         display_date = None
-        sort_key = None
+        current_date_dt = None
         try:
             if hasattr(surgery_date, 'strftime'):
                 display_date = surgery_date.strftime('%m-%d')
-                sort_key = surgery_date
+                current_date_dt = surgery_date
             elif isinstance(surgery_date, str):
                 # Date strings may be MM-DD-YYYY or already MM-DD
                 parts = surgery_date.split('-') if surgery_date else []
                 if len(parts) == 3 and all(parts):
                     display_date = "{}-{}".format(parts[0], parts[1])
+                    try:
+                        current_date_dt = datetime.strptime(surgery_date, '%m-%d-%Y')
+                    except Exception:
+                        current_date_dt = None
                 else:
                     display_date = surgery_date or 'Unknown Date'
-                # Use the raw string as sort key fallback
-                sort_key = surgery_date or ''
+                    current_date_dt = None
             else:
                 display_date = str(surgery_date) if surgery_date is not None else 'Unknown Date'
-                sort_key = display_date
+                current_date_dt = None
         except Exception:
             display_date = str(surgery_date) if surgery_date is not None else 'Unknown Date'
-            sort_key = display_date
+            current_date_dt = None
         
         # Normalize diagnosis display: only show "-Not Found-" when explicitly flagged as N/A
         # XP SP3 + Py3.4.4 compatible error handling
@@ -90,11 +93,72 @@ def display_enhanced_patient_table(patient_info, title, show_line_numbers=True):
                 # Fallback logging if string formatting fails
                 MediLink_ConfigLoader.log("Error converting diagnosis code to string", level="WARNING")
             display_diagnosis = "-Not Found-"
+
+        # Grouping: place all dates for a patient together under their earliest date
+        primary_date_dt = None
+        within_index = 0
+        last_name_key = ''
+        first_name_key = ''
+        try:
+            all_dates = []
+            if patient_row is not None:
+                raw_dates = patient_row.get('_all_surgery_dates', [])
+                # Convert to datetime list and find primary
+                for d in raw_dates:
+                    try:
+                        if hasattr(d, 'strftime'):
+                            all_dates.append(d)
+                        elif isinstance(d, str):
+                            all_dates.append(datetime.strptime(d, '%m-%d-%Y'))
+                    except Exception:
+                        pass
+                if all_dates:
+                    all_dates.sort()
+                    primary_date_dt = all_dates[0]
+                    # Determine within-patient index of current date
+                    if current_date_dt is not None:
+                        # Find matching index by exact date
+                        for idx, ad in enumerate(all_dates):
+                            if current_date_dt == ad:
+                                within_index = idx
+                                break
+                # Prefer explicit last/first from row for sorting
+                try:
+                    ln = patient_row.get('Patient Last')
+                    fn = patient_row.get('Patient First')
+                    if isinstance(ln, str):
+                        last_name_key = ln.strip().upper()
+                    if isinstance(fn, str):
+                        first_name_key = fn.strip().upper()
+                except Exception:
+                    pass
+        except Exception:
+            primary_date_dt = None
+            within_index = 0
+
+        # Fallbacks if parsing failed
+        if primary_date_dt is None:
+            primary_date_dt = current_date_dt
+        # If last/first not available from row, parse from display name "LAST, FIRST ..."
+        if not last_name_key and isinstance(patient_name, str):
+            try:
+                parts = [p.strip() for p in patient_name.split(',')]
+                if len(parts) >= 1:
+                    last_name_key = parts[0].upper()
+                if len(parts) >= 2:
+                    first_name_key = parts[1].split()[0].upper() if parts[1] else ''
+            except Exception:
+                last_name_key = ''
+                first_name_key = ''
+
+        # Build composite sort key per requirement: by earliest date, then last name within date,
+        # while keeping same patient's additional dates directly under the first line
+        composite_sort_key = (primary_date_dt, last_name_key, first_name_key, str(patient_id or ''), within_index)
         
-        normalized_info.append((sort_key, display_date, str(patient_name or ''), str(patient_id or ''), display_diagnosis))
+        normalized_info.append((composite_sort_key, display_date, str(patient_name or ''), str(patient_id or ''), display_diagnosis))
     
-    # Sort by normalized sort key then patient name
-    normalized_info.sort(key=lambda x: (x[0], x[2]))
+    # Sort so that all entries for a patient are grouped under their earliest date
+    normalized_info.sort(key=lambda x: x[0])
     
     # Calculate column widths for proper alignment
     max_patient_id_len = max(len(pid) for _, _, _, pid, _ in normalized_info)

{medicafe-0.250814.4 → medicafe-0.250816.0}/MediBot/__init__.py

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

{medicafe-0.250814.4 → medicafe-0.250816.0}/MediCafe/MediLink_ConfigLoader.py

@@ -18,6 +18,32 @@ except ImportError:
     # Fallback to local flag if centralized config is not available
     PERFORMANCE_LOGGING = False
 
+def get_default_config():
+    """Provide a default configuration when config files are missing."""
+    return {
+        'MediLink_Config': {
+            'local_storage_path': '.',
+            'receiptsRoot': './receipts',
+            'api_endpoints': {
+                'base_url': 'https://api.example.com',
+                'timeout': 30
+            },
+            'logging': {
+                'level': 'INFO',
+                'console_output': True
+            }
+        }
+    }
+
+def get_default_crosswalk():
+    """Provide a default crosswalk when crosswalk files are missing."""
+    return {
+        'insurance_types': {},
+        'diagnosis_codes': {},
+        'procedure_codes': {},
+        'payer_mappings': {}
+    }
+
 """
 This function should be generalizable to have a initialization script over all the Medi* functions
 """
@@ -62,6 +88,10 @@ def load_configuration(config_path=os.path.join(os.path.dirname(__file__), '..',
     if PERFORMANCE_LOGGING:
         print("Path resolution completed in {:.2f} seconds".format(path_check_end - path_check_start))
     
+    # Load configuration with graceful fallback
+    config = None
+    crosswalk = None
+    
     try:
         config_load_start = time.time()
         with open(config_path, 'r') as config_file:
@@ -88,30 +118,47 @@ def load_configuration(config_path=os.path.join(os.path.dirname(__file__), '..',
         if PERFORMANCE_LOGGING:
             print("Crosswalk file loading completed in {:.2f} seconds".format(crosswalk_load_end - crosswalk_load_start))
 
-        config_end = time.time()
-        if PERFORMANCE_LOGGING:
-            print("Total configuration loading completed in {:.2f} seconds".format(config_end - config_start))
+    except FileNotFoundError:
+        # Graceful fallback to default configurations
+        print("Configuration files not found. Using default configurations.")
+        print("Config path: {}, Crosswalk path: {}".format(config_path, crosswalk_path))
+        print("To use custom configurations, create the 'json' directory and add config.json and crosswalk.json files.")
         
-        # Cache the loaded configuration
-        _CONFIG_CACHE = config
-        _CROSSWALK_CACHE = crosswalk
+        config = get_default_config()
+        crosswalk = get_default_crosswalk()
         
-        return config, crosswalk
+        # Log the fallback for debugging
+        if PERFORMANCE_LOGGING:
+            print("Using default configurations due to missing files")
+            
     except ValueError as e:
         if isinstance(e, UnicodeDecodeError):
             print("Error decoding file: {}".format(e))
         else:
             print("Error parsing file: {}".format(e))
-        sys.exit(1)  # Exit the script due to a critical error in configuration loading
-    except FileNotFoundError:
-        print("One or both configuration files not found. Config: {}, Crosswalk: {}".format(config_path, crosswalk_path))
-        raise
+        print("Falling back to default configurations...")
+        config = get_default_config()
+        crosswalk = get_default_crosswalk()
     except KeyError as e:
         print("Critical configuration is missing: {}".format(e))
-        raise
+        print("Falling back to default configurations...")
+        config = get_default_config()
+        crosswalk = get_default_crosswalk()
     except Exception as e:
         print("An unexpected error occurred while loading the configuration: {}".format(e))
-        raise
+        print("Falling back to default configurations...")
+        config = get_default_config()
+        crosswalk = get_default_crosswalk()
+
+    config_end = time.time()
+    if PERFORMANCE_LOGGING:
+        print("Total configuration loading completed in {:.2f} seconds".format(config_end - config_start))
+    
+    # Cache the loaded configuration
+    _CONFIG_CACHE = config
+    _CROSSWALK_CACHE = crosswalk
+    
+    return config, crosswalk
 
 def clear_config_cache():
     """Clear the configuration cache to force reloading on next call."""

{medicafe-0.250814.4 → medicafe-0.250816.0}/MediCafe/__init__.py

@@ -27,7 +27,7 @@ Smart Import System:
         api_suite = get_api_access()
 """
 
-__version__ = "0.250814.4"
+__version__ = "0.250816.0"
 __author__ = "Daniel Vidaud"
 __email__ = "daniel@personalizedtransformation.com"
 
@@ -83,8 +83,11 @@ try:
     from . import logging_config
     from . import core_utils
     __legacy_imports_available__ = True
-except Exception:
+except Exception as e:
     __legacy_imports_available__ = False
+    # Don't fail the entire package import if legacy imports fail
+    print("Warning: Some legacy imports failed: {}".format(e))
+    print("This is expected when configuration files are missing. The package will continue to function.")
 
 # Package information
 __all__ = [

{medicafe-0.250814.4 → medicafe-0.250816.0}/MediCafe/smart_import.py

@@ -162,6 +162,18 @@ class ComponentRegistry:
         module_path = component_mappings[name]
         try:
             module = importlib.import_module(module_path)
+            
+            # Special handling for components that may fail due to missing config files
+            if name in ['api_core', 'logging_config', 'core_utils']:
+                try:
+                    # Test if the module can initialize properly
+                    if hasattr(module, 'load_configuration'):
+                        # This will use our new graceful fallback
+                        module.load_configuration()
+                except Exception as config_error:
+                    # Log the config error but don't fail the import
+                    warnings.warn("Component '{}' loaded but configuration failed: {}".format(name, config_error))
+            
             return module
         except ImportError as e:
             raise ImportError("Failed to load component '{}' from '{}': {}".format(name, module_path, e))

{medicafe-0.250814.4 → medicafe-0.250816.0}/MediLink/__init__.py

@@ -22,7 +22,7 @@ Smart Import Integration:
         datamgmt = get_components('medilink_datamgmt')
 """
 
-__version__ = "0.250814.4"
+__version__ = "0.250816.0"
 __author__ = "Daniel Vidaud"
 __email__ = "daniel@personalizedtransformation.com"
 
@@ -98,6 +98,7 @@ except Exception as e:
     # Handle any other import errors
     import sys
     print("Warning: Unexpected error importing MediLink_insurance_utils: {}".format(e))
+    print("This may be due to missing configuration files. MediLink will continue to function.")
     MediLink_insurance_utils = None
 
 # Optional: Show guide on import (can be disabled)

{medicafe-0.250814.4 → medicafe-0.250816.0}/PKG-INFO

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

{medicafe-0.250814.4 → medicafe-0.250816.0}/medicafe.egg-info/PKG-INFO

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

{medicafe-0.250814.4 → medicafe-0.250816.0}/setup.py

@@ -54,7 +54,7 @@ if long_description_text is None:
 
 setup(
     name='medicafe',
-    version="0.250814.4",
+    version="0.250816.0",
     description='MediCafe',
     long_description=long_description_text,
     long_description_content_type='text/markdown',