medicafe 0.250813.0__py3-none-any.whl → 0.250813.2__py3-none-any.whl

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: 

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 = {}
 

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")
 

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."""

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
 

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__))

MediBot/update_medicafe.py

@@ -292,7 +292,7 @@ def compare_versions(version1, version2):
 
 def upgrade_package(package, retries=4, delay=2, target_version=None):  # Updated retries to 4
     """
-    Attempts to upgrade the package multiple times with delays in between.
+    Attempts to upgrade the package multiple times with escalating techniques.
     """
     if not check_internet_connection():
         print_status("No internet connection detected. Please check your internet connection and try again.", "ERROR")
@@ -302,82 +302,94 @@ def upgrade_package(package, retries=4, delay=2, target_version=None):  # Update
     if target_version:
         print("Pinned target version: {}".format(target_version))
 
-    for attempt in range(1, retries + 1):
-        print("Attempt {}/{} to upgrade {}...".format(attempt, retries, package))
+    def get_installed_version_fresh(package):
+        """Get installed version using a fresh subprocess to avoid pkg_resources cache issues."""
+        try:
+            process = subprocess.Popen(
+                [sys.executable, '-m', 'pip', 'show', package],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE
+            )
+            stdout, stderr = process.communicate()
+            if process.returncode == 0:
+                for line in stdout.decode().splitlines():
+                    if line.startswith("Version:"):
+                        return line.split(":", 1)[1].strip()
+            return None
+        except Exception as e:
+            print("Warning: Could not get fresh version: {}".format(e))
+            return None
+
+    def try_upgrade_with_strategy(attempt, strategy_name, cmd_args):
+        """Try upgrade with specific strategy and return success status."""
+        print("Attempt {}/{}: Using {} strategy...".format(attempt, retries, strategy_name))
         
-        # Use a more compatible approach for Python 3.4
-        # Try with --no-deps first to avoid dependency resolution issues
         pkg_spec = package
         if target_version:
             pkg_spec = "{}=={}".format(package, target_version)
 
-        cmd = [
-            sys.executable, '-m', 'pip', 'install', '--upgrade',
-            '--no-deps', '--no-cache-dir', '--disable-pip-version-check', '-q', pkg_spec
-        ]
+        cmd = [sys.executable, '-m', 'pip', 'install'] + cmd_args + [pkg_spec]
         
-        print("Using pip upgrade with --no-deps and --no-cache-dir")
         process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         stdout, stderr = process.communicate()
         
         if process.returncode == 0:
             print(stdout.decode().strip())
-            new_version = get_installed_version(package)  # Get new version after upgrade
+            # Add delay to allow file system to settle
+            time.sleep(1)
+            new_version = get_installed_version_fresh(package)
             expected_version = target_version or get_latest_version(package)
-            if expected_version and compare_versions(new_version, expected_version) >= 0:  # Compare versions
-                if attempt == 1:
-                    print_status("Upgrade succeeded!", "SUCCESS")
-                else:
-                    print_status("Attempt {}: Upgrade succeeded!".format(attempt), "SUCCESS")
-                time.sleep(delay)
+            
+            if expected_version and new_version and compare_versions(new_version, expected_version) >= 0:
+                print_status("Attempt {}: Upgrade succeeded with {}!".format(attempt, strategy_name), "SUCCESS")
                 return True
             else:
-                print_status("Upgrade incomplete. Current version: {} Expected at least: {}".format(new_version, expected_version), "WARNING")
-                if attempt < retries:
-                    print("Retrying in {} seconds...".format(delay))
-                    try:
-                        time.sleep(delay + (random.random() * 0.5))
-                    except Exception:
-                        time.sleep(delay)
+                print_status("Upgrade incomplete. Current version: {} Expected at least: {}".format(
+                    new_version or "unknown", expected_version), "WARNING")
+                return False
         else:
             print(stderr.decode().strip())
-            print_status("Attempt {}: Upgrade failed with --no-deps.".format(attempt), "WARNING")
-            
-            # If --no-deps failed, try with --force-reinstall to bypass dependency issues
-            if attempt < retries:
-                print("Fallback this attempt: retrying with --force-reinstall...")
-                pkg_spec = package
-                if target_version:
-                    pkg_spec = "{}=={}".format(package, target_version)
-
-                cmd = [
-                    sys.executable, '-m', 'pip', 'install', '--upgrade',
-                    '--force-reinstall', '--no-cache-dir', '--disable-pip-version-check', '-q', pkg_spec
-                ]
-                
-                process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-                stdout, stderr = process.communicate()
-                
-                if process.returncode == 0:
-                    print(stdout.decode().strip())
-                    new_version = get_installed_version(package)
-                    expected_version = target_version or get_latest_version(package)
-                    if expected_version and compare_versions(new_version, expected_version) >= 0:
-                        print_status("Attempt {}: Upgrade succeeded with --force-reinstall!".format(attempt), "SUCCESS")
-                        time.sleep(delay)
-                        return True
-                    else:
-                        print_status("Upgrade incomplete. Current version: {} Expected at least: {}".format(new_version, expected_version), "WARNING")
-                else:
-                    print(stderr.decode().strip())
-                    print_status("Attempt {}: Upgrade failed with --force-reinstall.".format(attempt), "WARNING")
-                
-                if attempt < retries:
-                    print("Retrying in {} seconds...".format(delay))
-                    try:
-                        time.sleep(delay + (random.random() * 0.5))
-                    except Exception:
-                        time.sleep(delay)
+            print_status("Attempt {}: Upgrade failed with {}.".format(attempt, strategy_name), "WARNING")
+            return False
+
+    # Define escalation strategies for each attempt
+    strategies = {
+        1: [
+            ("Gentle Upgrade", ['--upgrade', '--no-deps', '--no-cache-dir', '--disable-pip-version-check', '-q']),
+            ("Force Reinstall", ['--upgrade', '--force-reinstall', '--no-cache-dir', '--disable-pip-version-check', '-q'])
+        ],
+        2: [
+            ("Clean Install", ['--upgrade', '--force-reinstall', '--no-cache-dir', '--disable-pip-version-check', '--ignore-installed', '-q']),
+            ("User Install", ['--upgrade', '--user', '--no-cache-dir', '--disable-pip-version-check', '-q'])
+        ],
+        3: [
+            ("Aggressive Clean", ['--upgrade', '--force-reinstall', '--no-cache-dir', '--disable-pip-version-check', '--ignore-installed', '--no-deps', '-q']),
+            ("Pre-download", ['--upgrade', '--force-reinstall', '--no-cache-dir', '--disable-pip-version-check', '--pre', '-q'])
+        ],
+        4: [
+            ("Nuclear Option", ['--upgrade', '--force-reinstall', '--no-cache-dir', '--disable-pip-version-check', '--ignore-installed', '--no-deps', '--pre', '-q']),
+            ("Last Resort", ['--upgrade', '--force-reinstall', '--no-cache-dir', '--disable-pip-version-check', '--ignore-installed', '--no-deps', '--pre', '--user', '-q'])
+        ]
+    }
+
+    for attempt in range(1, retries + 1):
+        print("Attempt {}/{} to upgrade {}...".format(attempt, retries, package))
+        
+        # Try each strategy for this attempt
+        for strategy_name, cmd_args in strategies[attempt]:
+            if try_upgrade_with_strategy(attempt, strategy_name, cmd_args):
+                time.sleep(delay)
+                return True
+        
+        # If we get here, all strategies for this attempt failed
+        if attempt < retries:
+            # Escalating delays: 2s, 3s, 5s
+            current_delay = delay + (attempt - 1)
+            print("All strategies failed for attempt {}. Retrying in {} seconds...".format(attempt, current_delay))
+            try:
+                time.sleep(current_delay + (random.random() * 1.0))
+            except Exception:
+                time.sleep(current_delay)
     
     print_status("All upgrade attempts failed.", "ERROR")
     return False

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:

MediLink/MediLink_Down.py

@@ -279,15 +279,23 @@ def main(desired_endpoint=None):
         return None, None
 
 
-def check_for_new_remittances(config=None):
+def check_for_new_remittances(config=None, is_boot_scan=False):
     """
     Function to check for new remittance files across all configured endpoints.
     Loads the configuration, validates it, and processes each endpoint to download and handle files.
     Accumulates results from all endpoints and processes them together at the end.
+    
+    Args:
+        config: Configuration object
+        is_boot_scan: If True, suppresses "No records" message for boot-time scans
+    
+    Returns:
+        bool: True if new records were found, False otherwise
     """
     # Start the process and log the initiation
     log("Starting check_for_new_remittances function")
-    print("\nChecking for new files across all endpoints...")
+    if not is_boot_scan:
+        print("\nChecking for new files across all endpoints...")
     log("Checking for new files across all endpoints...")
 
     # Step 1: Load and validate the configuration
@@ -297,44 +305,95 @@ def check_for_new_remittances(config=None):
     medi = extract_medilink_config(config)
     if not medi or 'endpoints' not in medi:
         log("Error: Config is missing necessary sections. Aborting...", level="ERROR")
-        return
+        return False
 
     endpoints = medi.get('endpoints')
     if not isinstance(endpoints, dict):
         log("Error: 'endpoints' is not a dictionary. Aborting...", level="ERROR")
-        return
+        return False
+
+    # DIAGNOSTIC: Log endpoint configuration details
+    log("Found {} configured endpoints: {}".format(len(endpoints), list(endpoints.keys())), level="INFO")
+    for endpoint_key, endpoint_info in endpoints.items():
+        log("Endpoint '{}': session_name={}, remote_directory_down={}, has_filemask={}".format(
+            endpoint_key,
+            endpoint_info.get('session_name', 'NOT_SET'),
+            endpoint_info.get('remote_directory_down', 'NOT_SET'),
+            'filemask' in endpoint_info
+        ), level="DEBUG")
 
     # Lists to accumulate all consolidated records and translated files across all endpoints
     all_consolidated_records = []
     all_translated_files = []
+    endpoint_results = {}  # Track results per endpoint for diagnostics
 
     # Step 2: Process each endpoint and accumulate results
     for endpoint_key, endpoint_info in tqdm(endpoints.items(), desc="Processing endpoints"):
+        log("=== Processing endpoint: {} ===".format(endpoint_key), level="INFO")
+        
         # Validate endpoint structure
         if not endpoint_info or not isinstance(endpoint_info, dict):
             log("Error: Invalid endpoint structure for {}. Skipping...".format(endpoint_key), level="ERROR")
+            endpoint_results[endpoint_key] = {"status": "error", "reason": "invalid_structure"}
             continue
 
         if 'remote_directory_down' in endpoint_info:
             # Process the endpoint and handle the files
-            log("Processing endpoint: {}".format(endpoint_key))
+            log("Processing endpoint: {} with remote_directory_down: {}".format(
+                endpoint_key, endpoint_info.get('remote_directory_down')), level="INFO")
+            
             consolidated_records, translated_files = process_endpoint(endpoint_key, endpoint_info, config)
             
+            # Track results for diagnostics
+            endpoint_results[endpoint_key] = {
+                "status": "processed",
+                "records_found": len(consolidated_records) if consolidated_records else 0,
+                "files_translated": len(translated_files) if translated_files else 0
+            }
+            
             # Accumulate the results for later processing
             if consolidated_records:
                 all_consolidated_records.extend(consolidated_records)
+                log("Added {} records from endpoint {}".format(len(consolidated_records), endpoint_key), level="INFO")
             if translated_files:
                 all_translated_files.extend(translated_files)
+                log("Added {} translated files from endpoint {}".format(len(translated_files), endpoint_key), level="INFO")
         else:
             log("Skipping endpoint '{}'. 'remote_directory_down' not configured.".format(endpoint_info.get('name', 'Unknown')), level="WARNING")
+            endpoint_results[endpoint_key] = {"status": "skipped", "reason": "no_remote_directory_down"}
+
+    # DIAGNOSTIC: Log summary of endpoint processing
+    log("=== Endpoint Processing Summary ===", level="INFO")
+    for endpoint_key, result in endpoint_results.items():
+        if result["status"] == "processed":
+            log("Endpoint '{}': {} records found, {} files translated".format(
+                endpoint_key, result["records_found"], result["files_translated"]), level="INFO")
+        else:
+            log("Endpoint '{}': {} ({})".format(
+                endpoint_key, result["status"], result.get("reason", "unknown")), level="WARNING")
 
     # Step 3: After processing all endpoints, handle the accumulated results
     if all_consolidated_records:
+        log("Total records found across all endpoints: {}".format(len(all_consolidated_records)), level="INFO")
         display_consolidated_records(all_consolidated_records)  # Ensure this is called only once
         prompt_csv_export(all_consolidated_records, medi.get('local_storage_path', '.'))
+        return True
     else:
         log("No records to display after processing all endpoints.", level="WARNING")
-        print("No records to display after processing all endpoints.")
+        # Enhanced diagnostic message when no records found
+        if not is_boot_scan:
+            print("No records to display after processing all endpoints.")
+            print("\nDiagnostic Information:")
+            print("- Total endpoints configured: {}".format(len(endpoints)))
+            print("- Endpoints with remote_directory_down: {}".format(
+                sum(1 for ep in endpoints.values() if 'remote_directory_down' in ep)))
+            print("- Endpoints processed: {}".format(
+                sum(1 for result in endpoint_results.values() if result["status"] == "processed")))
+            print("- Endpoints skipped: {}".format(
+                sum(1 for result in endpoint_results.values() if result["status"] == "skipped")))
+            print("- Endpoints with errors: {}".format(
+                sum(1 for result in endpoint_results.values() if result["status"] == "error")))
+        return False
 
 
 def process_endpoint(endpoint_key, endpoint_info, config):
@@ -347,19 +406,205 @@ def process_endpoint(endpoint_key, endpoint_info, config):
         medi = extract_medilink_config(config)
         local_storage_path = medi.get('local_storage_path', '.')
         log("[Process Endpoint] Local storage path set to {}".format(local_storage_path))
+        
+        # DIAGNOSTIC: Check WinSCP availability and configuration
+        try:
+            from MediLink_DataMgmt import get_winscp_path
+            winscp_path = get_winscp_path(config)
+            if os.path.exists(winscp_path):
+                log("[Process Endpoint] WinSCP found at: {}".format(winscp_path), level="INFO")
+            else:
+                log("[Process Endpoint] WinSCP not found at: {}".format(winscp_path), level="ERROR")
+                return [], []
+        except Exception as e:
+            log("[Process Endpoint] Error checking WinSCP path: {}".format(e), level="ERROR")
+            return [], []
+        
+        # DIAGNOSTIC: Log endpoint configuration details
+        log("[Process Endpoint] Endpoint config - session_name: {}, remote_directory_down: {}, filemask: {}".format(
+            endpoint_info.get('session_name', 'NOT_SET'),
+            endpoint_info.get('remote_directory_down', 'NOT_SET'),
+            endpoint_info.get('filemask', 'NOT_SET')
+        ), level="DEBUG")
+        
+        # DIAGNOSTIC: Check if we're in test mode
+        if config.get("MediLink_Config", {}).get("TestMode", False):
+            log("[Process Endpoint] Test mode is enabled - simulating download", level="WARNING")
+        
         downloaded_files = operate_winscp("download", None, endpoint_info, local_storage_path, config)
         
         if downloaded_files:
             log("[Process Endpoint] WinSCP Downloaded the following files: \n{}".format(downloaded_files))
-            return handle_files(local_storage_path, downloaded_files)
+            consolidated_records, translated_files = handle_files(local_storage_path, downloaded_files)
+            log("[Process Endpoint] File processing complete - {} records, {} translated files".format(
+                len(consolidated_records) if consolidated_records else 0,
+                len(translated_files) if translated_files else 0
+            ), level="INFO")
+            return consolidated_records, translated_files
         else:
-            log("[Process Endpoint]No files were downloaded for endpoint: {}.".format(endpoint_key), level="WARNING")
+            log("[Process Endpoint] No files were downloaded for endpoint: {}.".format(endpoint_key), level="WARNING")
+            
+            # DIAGNOSTIC: Check if WinSCP log exists and analyze it
+            try:
+                log_filename = "winscp_download.log"
+                log_path = os.path.join(local_storage_path, log_filename)
+                if os.path.exists(log_path):
+                    log("[Process Endpoint] WinSCP log exists at: {}".format(log_path), level="INFO")
+                    # Read last few lines of log for diagnostics
+                    try:
+                        with open(log_path, 'r') as f:
+                            lines = f.readlines()
+                            if lines:
+                                last_lines = lines[-5:]  # Last 5 lines
+                                log("[Process Endpoint] Last 5 lines of WinSCP log:", level="DEBUG")
+                                for line in last_lines:
+                                    log("[Process Endpoint] Log: {}".format(line.strip()), level="DEBUG")
+                    except Exception as e:
+                        log("[Process Endpoint] Error reading WinSCP log: {}".format(e), level="ERROR")
+                else:
+                    log("[Process Endpoint] WinSCP log not found at: {}".format(log_path), level="WARNING")
+            except Exception as e:
+                log("[Process Endpoint] Error checking WinSCP log: {}".format(e), level="ERROR")
+            
             return [], []
 
     except Exception as e:
         # Handle any exceptions that occur during the processing
         log("Error processing endpoint {}: {}".format(endpoint_key, e), level="ERROR")
+        import traceback
+        log("Full traceback: {}".format(traceback.format_exc()), level="DEBUG")
         return [], []
 
+def test_endpoint_connectivity(config=None, endpoint_key=None):
+    """
+    Test basic connectivity to a specific endpoint or all endpoints.
+    This is a diagnostic function to help identify connection issues.
+    
+    Args:
+        config: Configuration object
+        endpoint_key: Specific endpoint to test, or None for all endpoints
+    
+    Returns:
+        dict: Results of connectivity tests
+    """
+    if config is None:
+        config, _ = load_configuration()
+    
+    medi = extract_medilink_config(config)
+    if not medi or 'endpoints' not in medi:
+        log("Error: Config is missing necessary sections.", level="ERROR")
+        return {}
+    
+    endpoints = medi.get('endpoints')
+    results = {}
+    
+    # Determine which endpoints to test
+    if endpoint_key:
+        if endpoint_key in endpoints:
+            test_endpoints = {endpoint_key: endpoints[endpoint_key]}
+        else:
+            log("Error: Endpoint '{}' not found in configuration.".format(endpoint_key), level="ERROR")
+            return {}
+    else:
+        test_endpoints = endpoints
+    
+    log("Testing connectivity for {} endpoint(s)...".format(len(test_endpoints)), level="INFO")
+    
+    for ep_key, ep_info in test_endpoints.items():
+        log("Testing endpoint: {}".format(ep_key), level="INFO")
+        result = {"status": "unknown", "details": []}
+        
+        # Check basic configuration
+        if not ep_info.get('session_name'):
+            result["status"] = "error"
+            result["details"].append("Missing session_name")
+        elif not ep_info.get('remote_directory_down'):
+            result["status"] = "error"
+            result["details"].append("Missing remote_directory_down")
+        else:
+            result["details"].append("Configuration appears valid")
+            
+            # Check WinSCP availability
+            try:
+                from MediLink_DataMgmt import get_winscp_path
+                winscp_path = get_winscp_path(config)
+                if os.path.exists(winscp_path):
+                    result["details"].append("WinSCP found at: {}".format(winscp_path))
+                else:
+                    result["status"] = "error"
+                    result["details"].append("WinSCP not found at: {}".format(winscp_path))
+            except Exception as e:
+                result["status"] = "error"
+                result["details"].append("Error checking WinSCP: {}".format(e))
+            
+            # Check test mode
+            if config.get("MediLink_Config", {}).get("TestMode", False):
+                result["details"].append("Test mode is enabled - no real connection will be made")
+                result["status"] = "test_mode"
+        
+        results[ep_key] = result
+    
+    return results
+
+
 if __name__ == "__main__":
-    main()
+    import sys
+    
+    print("=" * 60)
+    print("MediLink_Down Standalone Testing Tool")
+    print("=" * 60)
+    print()
+    
+    # Check if endpoint was provided as command line argument
+    if len(sys.argv) > 1:
+        desired_endpoint = sys.argv[1]
+        print("Testing specific endpoint: {}".format(desired_endpoint))
+        print()
+        main(desired_endpoint)
+    else:
+        # No specific endpoint provided - run connectivity diagnostics
+        print("No specific endpoint provided.")
+        print("Running connectivity diagnostics for all endpoints...")
+        print()
+        
+        try:
+            config, _ = load_configuration()
+            connectivity_results = test_endpoint_connectivity(config)
+            
+            if connectivity_results:
+                print("Connectivity Test Results:")
+                print("-" * 40)
+                
+                for endpoint, result in connectivity_results.items():
+                    status = result["status"]
+                    details = result["details"]
+                    
+                    if status == "error":
+                        print("[ERROR] {}: {}".format(endpoint, status))
+                    elif status == "test_mode":
+                        print("[TEST] {}: {} (Test Mode)".format(endpoint, status))
+                    else:
+                        print("[OK] {}: {}".format(endpoint, status))
+                    
+                    for detail in details:
+                        print("    - {}".format(detail))
+                    print()
+                
+                # Show available endpoints for testing
+                medi = extract_medilink_config(config)
+                endpoints = medi.get('endpoints', {})
+                if endpoints:
+                    print("Available endpoints for testing:")
+                    print("-" * 30)
+                    for endpoint in endpoints.keys():
+                        print("  - {}".format(endpoint))
+                    print()
+                    print("To test a specific endpoint, run:")
+                    print("  python MediLink_Down.py <endpoint_name>")
+            else:
+                print("ERROR: No connectivity test results returned.")
+                
+        except Exception as e:
+            print("ERROR: Failed to run diagnostics: {}".format(e))
+            import traceback
+            traceback.print_exc()

MediLink/MediLink_main.py

@@ -140,6 +140,21 @@ def main_menu():
     if PERFORMANCE_LOGGING:
         print("Test mode check completed in {:.2f} seconds".format(test_mode_end - test_mode_start))
     
+    # Boot-time one-time ack poll (silent policy: just show summary output)
+    try:
+        print("\nChecking acknowledgements (boot-time scan)...")
+        ack_result = MediLink_Down.check_for_new_remittances(config, is_boot_scan=True)
+        _last_ack_updated_at = int(time.time())
+    except Exception:
+        ack_result = False
+        pass
+
+    # Clear screen before showing menu header
+    try:
+        os.system('cls' if os.name == 'nt' else 'clear')
+    except Exception:
+        pass  # Fallback if cls/clear fails
+
     # Display Welcome Message
     welcome_start = time.time()
     MediLink_UI.display_welcome()
@@ -147,6 +162,11 @@ def main_menu():
     if PERFORMANCE_LOGGING:
         print("Welcome display completed in {:.2f} seconds".format(welcome_end - welcome_start))
 
+    # Show message if new records were found during boot-time scan
+    if ack_result:
+        print("\n[INFO] New records were found during the boot-time acknowledgement scan.")
+        print("You can view them by selecting 'Check for new remittances' from the menu.")
+
     # Normalize the directory path for file operations.
     path_norm_start = time.time()
     medi = extract_medilink_config(config)
@@ -205,14 +225,6 @@ def main_menu():
     end_date_str = end_date.strftime('%m/%d/%Y')
     start_date_str = start_date.strftime('%m/%d/%Y')
 
-    # Boot-time one-time ack poll (silent policy: just show summary output)
-    try:
-        print("\nChecking acknowledgements (boot-time scan)...")
-        MediLink_Down.check_for_new_remittances(config)
-        _last_ack_updated_at = int(time.time())
-    except Exception:
-        pass
-
     while True:
         # Run any due scheduled ack checks before showing menu
         try:
@@ -221,7 +233,7 @@ def main_menu():
                 due = [t for t in _scheduled_ack_checks if t <= now_ts]
                 if due:
                     print("\nAuto-checking acknowledgements (scheduled)...")
-                    MediLink_Down.check_for_new_remittances(config)
+                    MediLink_Down.check_for_new_remittances(config, is_boot_scan=False)
                     _last_ack_updated_at = now_ts
                     # remove executed
                     _scheduled_ack_checks = [t for t in _scheduled_ack_checks if t > now_ts]
@@ -255,11 +267,30 @@ def main_menu():
         if choice == '1':
             # Handle remittance checking.
             remittance_start = time.time()
-            MediLink_Down.check_for_new_remittances(config)
+            result = MediLink_Down.check_for_new_remittances(config, is_boot_scan=False)
             _last_ack_updated_at = int(time.time())
             remittance_end = time.time()
             if PERFORMANCE_LOGGING:
                 print("Remittance check completed in {:.2f} seconds".format(remittance_end - remittance_start))
+            
+            # If no records found, offer connectivity diagnostics
+            if not result:
+                print("\nNo records found. Would you like to run connectivity diagnostics? (y/n): ", end="")
+                try:
+                    diagnostic_choice = input().strip().lower()
+                    if diagnostic_choice in ['y', 'yes']:
+                        print("\nRunning connectivity diagnostics...")
+                        connectivity_results = MediLink_Down.test_endpoint_connectivity(config)
+                        print("\nConnectivity Test Results:")
+                        for endpoint, result in connectivity_results.items():
+                            print("  {}: {} - {}".format(
+                                endpoint, 
+                                result["status"], 
+                                "; ".join(result["details"])
+                            ))
+                except Exception:
+                    pass  # Ignore input errors
+            
             # UX hint: suggest deeper United details
             try:
                 print("Tip: For United details, run the United Claims Status option for the same date window.")

{medicafe-0.250813.0.dist-info → medicafe-0.250813.2.dist-info}/METADATA

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

{medicafe-0.250813.0.dist-info → medicafe-0.250813.2.dist-info}/RECORD

@@ -1,25 +1,25 @@
 MediBot/MediBot.bat,sha256=el_8wWuikLkL-cmMX63L3VC0EqcuulkIFaT4xv7suzY,26687
-MediBot/MediBot.py,sha256=sHE2vqaXvjiISKuvTvymhur3Ho9smVKuvvPvHbgnluc,36019
+MediBot/MediBot.py,sha256=9u22KWhA7S3gKEXdo_4jnUFXpKqQb2lEeqsVIVSI62k,37089
 MediBot/MediBot_Charges.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-MediBot/MediBot_Crosswalk_Library.py,sha256=K_cz2o1e86qKKRRDcjb6eu5T6rtBgOK-R1nA8t8Z8QA,24957
+MediBot/MediBot_Crosswalk_Library.py,sha256=jIaYdoxfT9YgQ5dWZC4jmTYxRX1Y14X-AJ6YEjR58Gc,25158
 MediBot/MediBot_Crosswalk_Utils.py,sha256=KVq2budurwdHB7dglOuPZEQGup-hjD1SeSPyySLpy9M,39015
 MediBot/MediBot_Post.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 MediBot/MediBot_Preprocessor.py,sha256=zAcfyuE8wl9JRzLGsUnnXiHxAr-hbCCIB2M-Jb3LUqI,16203
-MediBot/MediBot_Preprocessor_lib.py,sha256=oHQ6_3RUR-X6tikKPpVjOMwHjIRgZ9IKARgje8tj8l0,73162
-MediBot/MediBot_UI.py,sha256=h-vcf5zMPgbK2uiwOFaqUDHqgZ-sKZJ5VvaoTdpjMtE,14305
-MediBot/MediBot_dataformat_library.py,sha256=dxh_SQQMEd9nCEeuBr-6E_Uu6enjLXeoyLpd45nUcZk,10771
+MediBot/MediBot_Preprocessor_lib.py,sha256=BiVbbDTSHXLYVxxSxr7oo7Z6-Jqjsb49YWKoTO7fzTU,76110
+MediBot/MediBot_UI.py,sha256=DjdSSljLnbaoij04AA8F55JQ5xmp5PYMrlyrnWEZ6D8,17659
+MediBot/MediBot_dataformat_library.py,sha256=D46fdPtxcgfWTzaLBtSvjtozzZBNqNiODgu4vKMZrBg,10746
 MediBot/MediBot_docx_decoder.py,sha256=gn7I7Ng5khVIzU0HTTOqi31YSSn1yW8Pyk-i_P9r1oA,32472
-MediBot/MediBot_smart_import.py,sha256=_ggP0I9djNwMGck04U6fNahrH7frVkoM8OzjtHbLUc0,6727
+MediBot/MediBot_smart_import.py,sha256=Emvz7NwemHGCHvG5kZcUyXMcCheidbGKaPfOTg-YCEs,6684
 MediBot/MediPost.py,sha256=C1hZJFr65rN6F_dckjdBxFC0vL2CoqY9W3YFqU5HXtE,336
 MediBot/PDF_to_CSV_Cleaner.py,sha256=ZZphmq-5K04DkrZNlcwNAIoZPOD_ROWvS3PMkKFxeiM,8799
 MediBot/__init__.py,sha256=6IdVLXaWxV5ZdpefonWrC1R8RsJn4V26K0PmUEZ_vU8,3192
 MediBot/get_medicafe_version.py,sha256=uyL_UIE42MyFuJ3SRYxJp8sZx8xjTqlYZ3FdQuxLduY,728
 MediBot/update_json.py,sha256=vvUF4mKCuaVly8MmoadDO59M231fCIInc0KI1EtDtPA,3704
-MediBot/update_medicafe.py,sha256=KuoGOsSvnNis9EgpAZe_j0Ny6ExVav3fnRQCAu4evnk,28560
+MediBot/update_medicafe.py,sha256=VTcQA_tfVILSAV29DM8nG-X4RJAQYdEiXY6oaeZfy4I,29072
 MediCafe/MediLink_ConfigLoader.py,sha256=Ia79dZQBvgbc6CtOaNZVlFHaN-fvUmJRpmmVHz_MFv8,8205
 MediCafe/__init__.py,sha256=DF0XUu3G43AejXvEmd5aCyy0GDQahQD0pMwexmxem-E,5477
 MediCafe/__main__.py,sha256=mRNyk3D9Ilnu2XhgVI_rut7r5Ro7UIKtwV871giAHI8,12992
-MediCafe/api_core.py,sha256=rF-8XNc6ILSsoD_YQV-L9R_nW9_XAd0D4VMgqAMY5U4,66420
+MediCafe/api_core.py,sha256=IZaBXnP4E7eHzxVbCk2HtxywiVBuhaUyHeaqss8llgY,66378
 MediCafe/api_core_backup.py,sha256=Oy_Fqt0SEvGkQN1Oqw5iUPVFxPEokyju5CuPEb9k0OY,18686
 MediCafe/api_factory.py,sha256=I5AeJoyu6m7oCrjc2OvVvO_4KSBRutTsR1riiWhTZV0,12086
 MediCafe/api_utils.py,sha256=KWQB0q1k5E6frOFFlKWcFpHNcqfrS7KJ_82672wbupw,14041
@@ -49,7 +49,7 @@ MediLink/MediLink_Decoder.py,sha256=1gzdybNg4Vv69s5PNbX8bPNrXT_N_kPpFpt2HpkauWA,
 MediLink/MediLink_Deductible.py,sha256=fLBDQHDcTk86JtJUtUwrVl-o0KfNackFrWosMxr7qHU,45559
 MediLink/MediLink_Deductible_Validator.py,sha256=2g-lZd-Y5fJ1mfP87vM6oABg0t5Om-7EkEkilVvDWYY,22888
 MediLink/MediLink_Display_Utils.py,sha256=QyHk23VU1rJtNZr_QhtL76Avo66CEc7MZU84uIs-1Lo,4187
-MediLink/MediLink_Down.py,sha256=us3xKM5AcGpvqnbrKkV8iEt7MmLCkSU7CDFfCoqXO4o,16201
+MediLink/MediLink_Down.py,sha256=q4ByEh1h1WSHUyRy68e8wT8pXMXP6q8NaqS1LKveMFo,28093
 MediLink/MediLink_ERA_decoder.py,sha256=MiOtDcXnmevPfHAahIlTLlUc14VcQWAor9Xa7clA2Ts,8710
 MediLink/MediLink_Gmail.py,sha256=8iQjqcJMSa_Zfr5azR0dShKAQeXqt-9C-s8seYB9pic,23961
 MediLink/MediLink_GraphQL.py,sha256=O6OCaumT0zIC7YcIAwLOOYxiQnYhoMc48UL8ilNIBec,45720
@@ -64,7 +64,7 @@ MediLink/MediLink_Up.py,sha256=QFdUtpEySc7ceZfFJ2q9XWClnhYJssG-UywFFedlv9w,34899
 MediLink/MediLink_api_utils.py,sha256=dsGLRPRvSwfXPLrrfgnkIKGDIF00wE93TrDB6HMDPQU,11857
 MediLink/MediLink_batch.bat,sha256=nqL5QwCLyRQFSPdv6kgtcV_cpky7FXSOWVl6OxjRXb4,118
 MediLink/MediLink_insurance_utils.py,sha256=g741Fj2K26cMy0JX5d_XavMw9LgkK6hjaUJYfysT7t8,9301
-MediLink/MediLink_main.py,sha256=iyMcEToFl2aPHP6xE51OnHQqqbGBh0owRqUfFV1F01M,21745
+MediLink/MediLink_main.py,sha256=Y26Bl_7KNIbz18lbgK-18dkqANfWK6QO4sQLFFRQGGw,23337
 MediLink/MediLink_smart_import.py,sha256=B5SfBn_4bYEWJJDolXbjnwKx_-MaqGZ76LyXQwWDV80,9838
 MediLink/Soumit_api.py,sha256=5JfOecK98ZC6NpZklZW2AkOzkjvrbYxpJpZNH3rFxDw,497
 MediLink/__init__.py,sha256=Z4Uxt4XZk4n-GwAkUoEeFiL-D7xHbttYiiWGjgKT_ng,3391
@@ -77,9 +77,9 @@ MediLink/test_cob_library.py,sha256=wUMv0-Y6fNsKcAs8Z9LwfmEBRO7oBzBAfWmmzwoNd1g,
 MediLink/test_timing.py,sha256=yH2b8QPLDlp1Zy5AhgtjzjnDHNGhAD16ZtXtZzzESZw,2042
 MediLink/test_validation.py,sha256=FJrfdUFK--xRScIzrHCg1JeGdm0uJEoRnq6CgkP2lwM,4154
 MediLink/webapp.html,sha256=JPKT559aFVBi1r42Hz7C77Jj0teZZRumPhBev8eSOLk,19806
-medicafe-0.250813.0.dist-info/LICENSE,sha256=65lb-vVujdQK7uMH3RRJSMwUW-WMrMEsc5sOaUn2xUk,1096
-medicafe-0.250813.0.dist-info/METADATA,sha256=0dCrp1oFMB5Y1CdIUbqVjsuXrm0JFUionXfh9D7TuKk,3384
-medicafe-0.250813.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-medicafe-0.250813.0.dist-info/entry_points.txt,sha256=m3RBUBjr-xRwEkKJ5W4a7NlqHZP_1rllGtjZnrRqKe8,52
-medicafe-0.250813.0.dist-info/top_level.txt,sha256=U6-WBJ9RCEjyIs0BlzbQq_PwedCp_IV9n1616NNV5zA,26
-medicafe-0.250813.0.dist-info/RECORD,,
+medicafe-0.250813.2.dist-info/LICENSE,sha256=65lb-vVujdQK7uMH3RRJSMwUW-WMrMEsc5sOaUn2xUk,1096
+medicafe-0.250813.2.dist-info/METADATA,sha256=2sZpkNcltzPkLNnx5QqEFpnZbYEd9vQT16cyBqGPWmc,3384
+medicafe-0.250813.2.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+medicafe-0.250813.2.dist-info/entry_points.txt,sha256=m3RBUBjr-xRwEkKJ5W4a7NlqHZP_1rllGtjZnrRqKe8,52
+medicafe-0.250813.2.dist-info/top_level.txt,sha256=U6-WBJ9RCEjyIs0BlzbQq_PwedCp_IV9n1616NNV5zA,26
+medicafe-0.250813.2.dist-info/RECORD,,