medicafe 0.250813.1__tar.gz → 0.250813.2__tar.gz

{medicafe-0.250813.1 → medicafe-0.250813.2}/MediBot/MediBot.py

@@ -608,48 +608,68 @@ if __name__ == "__main__":
             existing_patients, patients_to_process = MediBot_Preprocessor.check_existing_patients(selected_patient_ids, _ac().get_mapat_med_path() if _ac() else '')
             
             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:
                     try:
-                        surgery_date = next((row.get('Surgery Date') for row in csv_data if row.get(reverse_mapping['Patient ID #2']) == patient_id), None)
-                        if surgery_date is None:
-                            raise ValueError("Surgery Date not found for patient ID: {}".format(patient_id))
-                        patient_info.append((surgery_date, patient_name, patient_id))
+                        # Find the row for this patient
+                        patient_row = next((row for row in csv_data if row.get(reverse_mapping['Patient ID #2']) == patient_id), None)
+                        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:
+                            diagnosis_code = surgery_date_to_diagnosis.get(surgery_date, 'N/A')
+                            patient_info.append((surgery_date, patient_name, patient_id, diagnosis_code, patient_row))
+                            
                     except Exception as e:
-                        MediLink_ConfigLoader.log("Warning: Error retrieving Surgery Date for patient ID '{}': {}".format(patient_id, e), level="WARNING")
-                        patient_info.append(('Unknown Date', patient_name, patient_id))  # Append with 'Unknown Date' if there's an error
-
-                # Sort by surgery date first and then by patient name
-                # NOTE: 'surgery_date' may be a string or a datetime depending on upstream data.
-                # We sort lexicographically which is stable for uniform string inputs. If mixed types
-                # are encountered, consider normalizing to string first or using a robust key function
-                # that attempts datetime parsing with a string fallback.
-                patient_info.sort(key=lambda x: (x[0], x[1]))
-
-                # Print the sorted patient info
-                for index, (surgery_date, patient_name, patient_id) in enumerate(patient_info):
-                    # Format surgery_date safely whether it's a datetime/date or a string
-                    # This guards the observed "'str' object has no attribute 'strftime'" error on XP.
-                    try:
-                        formatted_date = surgery_date.strftime('%m-%d')
-                    except Exception:
-                        formatted_date = str(surgery_date)
-                    print("{:03d}: {} (ID: {}) {}".format(index + 1, formatted_date, patient_id, patient_name))
+                        MediLink_ConfigLoader.log("Warning: Error retrieving data for patient ID '{}': {}".format(patient_id, e), level="WARNING")
+                        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
+                MediBot_UI.display_enhanced_patient_table(
+                    patient_info, 
+                    "NOTE: The following patient(s) already EXIST in the system but have new dates of service.\n      Their diagnosis codes will need to be updated manually by the user to the following list:",
+                    show_line_numbers=False
+                )
 
                 # Update csv_data to exclude existing patients
                 # TODO: Update this logic to handle patients that exist but need new charges added.
                 csv_data = [row for row in csv_data if row[reverse_mapping['Patient ID #2']] in patients_to_process]
-            else:
-                print("\nSelected patient(s) are NEW patients and will be processed.")
+            
+            # Show NEW patients that will be processed (if any)
+            if patients_to_process:
+                # 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:
+                        diagnosis_code = surgery_date_to_diagnosis.get(surgery_date, 'N/A')
+                        new_patient_info.append((surgery_date, patient_name, patient_id, diagnosis_code, row))
+
+                # Display new patients table using the enhanced display function
+                MediBot_UI.display_enhanced_patient_table(
+                    new_patient_info, 
+                    "NOTE: The following NEW patient(s) will be automatically entered into Medisoft:",
+                    show_line_numbers=True
+                )
 
             # Check if there are patients left to process
             if len(patients_to_process) == 0:
                 proceed = input("\nAll patients have been processed. Continue anyway?: ").lower().strip() in ['yes', 'y']
             else:
-                proceed = input("\nDo you want to proceed with the {} remaining patient(s)? (yes/no): ".format(len(patients_to_process))).lower().strip() in ['yes', 'y']
+                proceed = input("\nDo you want to proceed with entering {} new patient(s) into Medisoft? (yes/no): ".format(len(patients_to_process))).lower().strip() in ['yes', 'y']
 
             # TODO: Here is where we need to add the step where we move to MediBot_Charges. 
             # The return is an enriched dataset to be picked up by MediBot which means we need to return: 

{medicafe-0.250813.1 → medicafe-0.250813.2}/MediBot/MediBot_Crosswalk_Library.py

@@ -4,17 +4,13 @@ Core crosswalk library for MediBot
 Handles crosswalk operations and API interactions.
 """
 
-import os
 import sys
-import csv
-import json
-import re
-from datetime import datetime
 
 # Use core utilities for standardized imports
 from MediCafe.core_utils import (
     import_medibot_module,
-    get_config_loader_with_fallback
+    get_config_loader_with_fallback,
+    smart_import
 )
 
 # Initialize configuration loader with fallback
@@ -45,6 +41,10 @@ else:
     update_crosswalk_with_new_payer_id = None
     load_and_parse_z_data = None
 
+# Import API functions using centralized import pattern
+MediLink_API_v3 = smart_import(['MediCafe.api_core', 'MediCafe.api_core_backup'])
+fetch_payer_name_from_api = getattr(MediLink_API_v3, 'fetch_payer_name_from_api', None) if MediLink_API_v3 else None
+
 # Module-level cache to prevent redundant API calls
 _api_cache = {}
 

{medicafe-0.250813.1 → medicafe-0.250813.2}/MediBot/MediBot_Preprocessor_lib.py

@@ -262,7 +262,7 @@ def add_columns(csv_data, column_headers):
 
 # Extracting the list to a variable for future refactoring:
 def filter_rows(csv_data):
-    # TODO: This should be handled in the crosswalk.
+    # TODO: This should be written in the crosswalk and not hardcoded here.
     excluded_insurance = {'AETNA', 'AETNA MEDICARE', 'HUMANA MED HMO'}
     csv_data[:] = [row for row in csv_data if row.get('Patient ID') and row.get('Primary Insurance') not in excluded_insurance]
 
@@ -515,17 +515,40 @@ def convert_surgery_date(csv_data):
 def sort_and_deduplicate(csv_data):
     # Create a dictionary to hold unique patients based on Patient ID
     unique_patients = {}
+    # Create a dictionary to store multiple surgery dates per patient
+    patient_surgery_dates = {}
     
     # Iterate through the CSV data and populate the unique_patients dictionary
     for row in csv_data:
         patient_id = row.get('Patient ID')
+        surgery_date = row.get('Surgery Date')
+        
         if patient_id not in unique_patients:
             unique_patients[patient_id] = row
+            patient_surgery_dates[patient_id] = [surgery_date]
         else:
             # If the patient ID already exists, compare surgery dates
             existing_row = unique_patients[patient_id]
-            if row['Surgery Date'] < existing_row['Surgery Date']:
+            existing_date = existing_row['Surgery Date']
+            
+            # Keep the most current demographic data (later surgery date takes precedence)
+            if surgery_date > 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)
+                # 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]
+            else:
+                # Add this surgery date to the list for this patient
+                if surgery_date not in patient_surgery_dates[patient_id]:
+                    patient_surgery_dates[patient_id].append(surgery_date)
+
+    # Store the surgery dates information in the first row of each patient for later access
+    for patient_id, row in unique_patients.items():
+        row['_all_surgery_dates'] = sorted(patient_surgery_dates[patient_id])
+        row['_primary_surgery_date'] = row['Surgery Date']  # Keep track of which date has the demographics
 
     # 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?
@@ -1096,7 +1119,7 @@ def update_diagnosis_codes(csv_data):
         updated_count = 0
 
         # PERFORMANCE OPTIMIZATION: Single pass through CSV data with pre-processed lookups
-        # Update the "Default Diagnosis #1" column in the CSV data
+        # Update the "Default Diagnosis #1" column in the CSV data and store diagnosis codes for all surgery dates
         for row_num, row in enumerate(csv_data, start=1):
             patient_id = row.get('Patient ID', '').strip()
             # Use pre-processed patient ID lookup for efficiency
@@ -1104,31 +1127,56 @@ def update_diagnosis_codes(csv_data):
                 continue  # Skip rows that do not match any patient ID
 
             MediLink_ConfigLoader.log("Processing row number {}.".format(row_num), level="DEBUG")
-            # Use pre-converted surgery date string for efficient lookup
-            surgery_date_str = surgery_date_strings.get(patient_id, '')
-
-            MediLink_ConfigLoader.log("Patient ID: {}, Surgery Date: {}".format(patient_id, surgery_date_str), level="DEBUG")
-
+            
+            # Get all surgery dates for this patient
+            all_surgery_dates = row.get('_all_surgery_dates', [row.get('Surgery Date')])
+            
+            # Create a mapping of surgery dates to diagnosis codes for this patient
+            surgery_date_to_diagnosis = {}
+            
             if patient_id in all_patient_data:
-                if surgery_date_str in all_patient_data[patient_id]:
-                    diagnosis_code, left_or_right_eye, femto_yes_or_no = all_patient_data[patient_id][surgery_date_str]
-                    MediLink_ConfigLoader.log("Found diagnosis data for Patient ID: {}, Surgery Date: {}".format(patient_id, surgery_date_str), level="DEBUG")
-                    
-                    # Convert diagnosis code to Medisoft shorthand format.
-                    medisoft_shorthand = diagnosis_to_medisoft.get(diagnosis_code, None)
-                    if medisoft_shorthand is None and diagnosis_code:
-                        # Use fallback logic for missing mapping
-                        defaulted_code = diagnosis_code.lstrip('H').lstrip('T8').replace('.', '')[-5:]
-                        medisoft_shorthand = defaulted_code
-                        MediLink_ConfigLoader.log("Missing diagnosis mapping for '{}', using fallback code '{}'".format(
-                            diagnosis_code, medisoft_shorthand), level="WARNING")
-                    MediLink_ConfigLoader.log("Converted diagnosis code to Medisoft shorthand: {}".format(medisoft_shorthand), level="DEBUG")
+                # Process each surgery date for this patient
+                for surgery_date in all_surgery_dates:
+                    # Convert surgery date to string format for lookup
+                    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)
                     
-                    row['Default Diagnosis #1'] = medisoft_shorthand
-                    updated_count += 1
-                    MediLink_ConfigLoader.log("Updated row number {} with new diagnosis code.".format(row_num), level="INFO")
-                else:
-                    MediLink_ConfigLoader.log("No matching surgery date found for Patient ID: {} in row {}.".format(patient_id, row_num), level="INFO")
+                    MediLink_ConfigLoader.log("Patient ID: {}, Surgery Date: {}".format(patient_id, surgery_date_str), level="DEBUG")
+
+                    if surgery_date_str in all_patient_data[patient_id]:
+                        diagnosis_code, left_or_right_eye, femto_yes_or_no = all_patient_data[patient_id][surgery_date_str]
+                        MediLink_ConfigLoader.log("Found diagnosis data for Patient ID: {}, Surgery Date: {}".format(patient_id, surgery_date_str), level="DEBUG")
+                        
+                        # Convert diagnosis code to Medisoft shorthand format.
+                        medisoft_shorthand = diagnosis_to_medisoft.get(diagnosis_code, None)
+                        if medisoft_shorthand is None and diagnosis_code:
+                            # Use fallback logic for missing mapping
+                            defaulted_code = diagnosis_code.lstrip('H').lstrip('T8').replace('.', '')[-5:]
+                            medisoft_shorthand = defaulted_code
+                            MediLink_ConfigLoader.log("Missing diagnosis mapping for '{}', using fallback code '{}'".format(
+                                diagnosis_code, medisoft_shorthand), level="WARNING")
+                        MediLink_ConfigLoader.log("Converted diagnosis code to Medisoft shorthand: {}".format(medisoft_shorthand), level="DEBUG")
+                        
+                        surgery_date_to_diagnosis[surgery_date] = medisoft_shorthand
+                    else:
+                        MediLink_ConfigLoader.log("No matching surgery date found for Patient ID: {} on date {}.".format(patient_id, surgery_date_str), level="INFO")
+                        surgery_date_to_diagnosis[surgery_date] = 'N/A'
+                
+                # Store the diagnosis mapping for all surgery dates
+                row['_surgery_date_to_diagnosis'] = surgery_date_to_diagnosis
+                
+                # Set the primary diagnosis code (for the main surgery date)
+                primary_surgery_date = row.get('Surgery Date')
+                primary_diagnosis = surgery_date_to_diagnosis.get(primary_surgery_date, 'N/A')
+                row['Default Diagnosis #1'] = primary_diagnosis
+                
+                updated_count += 1
+                MediLink_ConfigLoader.log("Updated row number {} with diagnosis codes for {} surgery dates.".format(row_num, len(all_surgery_dates)), level="INFO")
             else:
                 MediLink_ConfigLoader.log("Patient ID: {} not found in DOCX data for row {}.".format(patient_id, row_num), level="INFO")
 

{medicafe-0.250813.1 → medicafe-0.250813.2}/MediBot/MediBot_UI.py

@@ -1,5 +1,5 @@
 #MediBot_UI.py
-import ctypes, time, re, os, sys
+import ctypes, time, re
 from ctypes import wintypes
 from sys import exit
 
@@ -27,6 +27,69 @@ except ImportError:
 from MediCafe.core_utils import create_config_cache
 _get_config, (_config_cache, _crosswalk_cache) = create_config_cache()
 
+def display_enhanced_patient_table(patient_info, title, show_line_numbers=True):
+    """
+    Display an enhanced patient table with multiple surgery dates and diagnosis codes.
+    
+    Args:
+        patient_info: List of tuples (surgery_date, patient_name, patient_id, diagnosis_code, patient_row)
+        title: Title for the table section
+        show_line_numbers: Whether to show line numbers (True for new patients, False for existing)
+    """
+    if not patient_info:
+        return
+    
+    print(title)
+    print()
+    
+    # Sort by surgery date first and then by patient name
+    patient_info.sort(key=lambda x: (x[0], x[1]))
+    
+    # Calculate column widths for proper alignment
+    max_patient_id_len = max(len(str(pid)) for _, _, pid, _, _ in patient_info)
+    max_patient_name_len = max(len(pname) for _, pname, _, _, _ in patient_info)
+    max_diagnosis_len = max(len(dcode) for _, _, _, dcode, _ in patient_info)
+    
+    # Ensure minimum widths for readability
+    max_patient_id_len = max(max_patient_id_len, 5)  # 5-digit ID max
+    max_patient_name_len = max(max_patient_name_len, 12)  # "Patient Name" header
+    max_diagnosis_len = max(max_diagnosis_len, 10)  # "Diagnosis" header
+    
+    # Print the sorted patient info with multiple surgery dates
+    current_patient = None
+    line_number = 1
+    
+    for surgery_date, patient_name, patient_id, diagnosis_code, patient_row in patient_info:
+        # Format surgery_date safely whether it's a datetime/date or a string
+        try:
+            formatted_date = surgery_date.strftime('%m-%d')
+        except Exception:
+            formatted_date = str(surgery_date)
+        
+        # Transform diagnosis code display: show "-Not Found-" instead of "N/A"
+        display_diagnosis = "-Not Found-" if diagnosis_code == "N/A" else diagnosis_code
+        
+        # Check if this is the same patient as the previous line
+        if current_patient == patient_id:
+            # Secondary surgery date - indent and show dashes for patient info
+            # Use exact character count matching for dashes
+            patient_id_dashes = '-' * len(str(patient_id))
+            patient_name_dashes = '-' * len(patient_name)
+            
+            secondary_format = "     {:<6} | {:<" + str(max_patient_id_len) + "} | {:<" + str(max_patient_name_len) + "} | {:<" + str(max_diagnosis_len) + "}"
+            print(secondary_format.format(formatted_date, patient_id_dashes, patient_name_dashes, display_diagnosis))
+        else:
+            # New patient - show full patient info
+            current_patient = patient_id
+            if show_line_numbers:
+                primary_format = "{:03d}: {:<6} | {:<" + str(max_patient_id_len) + "} | {:<" + str(max_patient_name_len) + "} | {:<" + str(max_diagnosis_len) + "}"
+                print(primary_format.format(line_number, formatted_date, str(patient_id), patient_name, display_diagnosis))
+                line_number += 1
+            else:
+                # For existing patients, don't show line numbers
+                primary_format = "     {:<6} | {:<" + str(max_patient_id_len) + "} | {:<" + str(max_patient_name_len) + "} | {:<" + str(max_diagnosis_len) + "}"
+                print(primary_format.format(formatted_date, str(patient_id), patient_name, display_diagnosis))
+
 # Function to check if a specific key is pressed
 def _get_vk_codes():
     """Get VK codes from config."""

{medicafe-0.250813.1 → medicafe-0.250813.2}/MediBot/MediBot_dataformat_library.py

@@ -6,8 +6,6 @@ Contains functions for formatting various data types and handling CSV operations
 
 import os
 import sys
-import csv
-import json
 import re
 from datetime import datetime
 

{medicafe-0.250813.1 → medicafe-0.250813.2}/MediBot/MediBot_smart_import.py

@@ -7,7 +7,7 @@ new centralized smart import system, eliminating sys.path manipulation
 and circular import risks.
 """
 
-import os, subprocess, tempfile, traceback, re, time, sys
+import os, sys
 
 # Add workspace directory to Python path for MediCafe imports
 current_dir = os.path.dirname(os.path.abspath(__file__))

{medicafe-0.250813.1 → medicafe-0.250813.2}/MediCafe/api_core.py

@@ -7,7 +7,6 @@ COMPATIBILITY: Python 3.4.4 and Windows XP compatible
 """
 
 import time, json, os, traceback, sys, requests
-from datetime import datetime, timedelta
 
 # Import centralized logging configuration
 try:

{medicafe-0.250813.1/medicafe.egg-info → medicafe-0.250813.2}/PKG-INFO

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

{medicafe-0.250813.1 → medicafe-0.250813.2/medicafe.egg-info}/PKG-INFO

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

{medicafe-0.250813.1 → medicafe-0.250813.2}/setup.py

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