medicafe 0.250813.0__tar.gz → 0.250813.1__tar.gz

{medicafe-0.250813.0 → medicafe-0.250813.1}/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-0.250813.0 → medicafe-0.250813.1}/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()

{medicafe-0.250813.0 → medicafe-0.250813.1}/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/medicafe.egg-info → medicafe-0.250813.1}/PKG-INFO

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

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

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

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

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