medicafe 0.251015.0__py3-none-any.whl → 0.251017.0__py3-none-any.whl

MediBot/__init__.py

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

MediCafe/__init__.py

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

MediCafe/deductible_utils.py

@@ -37,6 +37,62 @@ IMPLEMENTATION NOTES:
 import os, sys, json
 from datetime import datetime
 
+# =============================================================================
+# LIGHTWEIGHT DIAGNOSTICS HELPERS (3.4.4 compatible)
+# =============================================================================
+
+def classify_api_failure(exc, context):
+    """
+    Classify common API failure cases into a short (code, message) tuple.
+    Codes: TIMEOUT, CONN_ERR, AUTH_FAIL, INVALID_PAYER, MISCONFIG, NON_200, NO_DATA, UNKNOWN
+    """
+    code = 'UNKNOWN'
+    try:
+        detail = str(exc)
+    except Exception:
+        detail = ''
+    try:
+        ctx = str(context)
+    except Exception:
+        ctx = 'API'
+    try:
+        # Lazy import to avoid hard dependency if requests missing
+        try:
+            import requests  # noqa
+        except Exception:
+            requests = None  # type: ignore
+
+        if requests and hasattr(requests, 'exceptions'):
+            if isinstance(exc, requests.exceptions.Timeout):
+                code = 'TIMEOUT'
+            elif isinstance(exc, requests.exceptions.ConnectionError):
+                code = 'CONN_ERR'
+            elif isinstance(exc, requests.exceptions.HTTPError):
+                # HTTPError: try to extract status
+                try:
+                    status = getattr(getattr(exc, 'response', None), 'status_code', None)
+                except Exception:
+                    status = None
+                code = 'NON_200' if status and status != 200 else 'UNKNOWN'
+        # String heuristics as fallbacks
+        if 'Invalid payer_id' in detail:
+            code = 'INVALID_PAYER'
+        elif ('No access token' in detail) or ('token' in detail.lower()):
+            code = 'AUTH_FAIL'
+        elif ('Eligibility endpoint not configured' in detail) or ('endpoint' in detail.lower() and 'configured' in detail.lower()):
+            code = 'MISCONFIG'
+    except Exception:
+        code = 'UNKNOWN'
+    message = "{} failure [{}]: {}".format(ctx or 'API', code, detail)
+    return code, message
+
+def is_ok_200(value):
+    """Return True if value represents HTTP 200 in either int or string form."""
+    try:
+        return str(value).strip() == '200'
+    except Exception:
+        return False
+
 # Use core utilities for standardized imports
 try:
     from MediCafe.core_utils import get_shared_config_loader
@@ -1287,4 +1343,30 @@ def backfill_enhanced_result(enhanced_result, csv_row=None):
     except Exception as e:
         if MediLink_ConfigLoader:
             MediLink_ConfigLoader.log("Error in backfill_enhanced_result: {}".format(str(e)), level="WARNING")
-        return enhanced_result
+        return enhanced_result
+
+
+# =============================================================================
+# ROW ERROR REASON COMPUTATION (centralized)
+# =============================================================================
+
+def compute_error_reason(record):
+    """Compute a user-friendly error reason for an eligibility result row."""
+    try:
+        if not isinstance(record, dict):
+            return ""
+        reason = str(record.get('error_reason', '')).strip()
+        name_unknown = (not str(record.get('patient_name', '')).strip()) or (record.get('patient_name') == 'Unknown Patient')
+        has_error = (str(record.get('status', '')) == 'Error') or (str(record.get('data_source', '')) in ['None', 'Error'])
+        amount_missing = (str(record.get('remaining_amount', '')) == 'Not Found')
+
+        if not reason:
+            if name_unknown:
+                reason = 'Patient name could not be determined from API responses or CSV backfill'
+            elif amount_missing:
+                reason = 'Deductible remaining amount not found in eligibility response'
+            elif has_error:
+                reason = 'Eligibility lookup encountered an error; see logs for details'
+        return reason
+    except Exception:
+        return ""

MediLink/MediLink_Deductible.py

@@ -375,12 +375,16 @@ def manual_deductible_lookup():
 
         # Fetch eligibility data
         found_data = False
+        printed_messages = set()
         for i, payer_id in enumerate(payer_ids, 1):
             print("Checking Payer ID {} ({}/{}): {}".format(payer_id, i, len(payer_ids), payer_id))
             
             # Use the current mode setting for validation
             run_validation = DEBUG_MODE
-            eligibility_data = get_eligibility_info(client, payer_id, provider_last_name, formatted_dob, member_id, npi, run_validation=run_validation, is_manual_lookup=True)
+            eligibility_data = get_eligibility_info(
+                client, payer_id, provider_last_name, formatted_dob, member_id, npi,
+                run_validation=run_validation, is_manual_lookup=True, printed_messages=printed_messages
+            )
             if eligibility_data:
                 found_data = True
                 
@@ -484,13 +488,28 @@ def manual_deductible_lookup():
                             enhanced_result['policy_status'][:14],
                             enhanced_result['remaining_amount'][:14])
                         output_file.write(table_row + "\n")
+
+                        # Persist per-row error diagnostics in a user-friendly way
+                        try:
+                            row_reason = _compute_error_reason(enhanced_result)
+                            row_messages = enhanced_result.get('error_messages', []) or []
+                            if row_reason or row_messages:
+                                output_file.write("  >> Errors:" + "\n")
+                                if row_reason:
+                                    output_file.write("  >> - {}\n".format(row_reason))
+                                for msg in row_messages:
+                                    # Avoid duplicating the reason message if identical
+                                    if not row_reason or msg.strip() != row_reason.strip():
+                                        output_file.write("  >> - {}\n".format(str(msg)))
+                        except Exception:
+                            pass
                     else:
                         display_eligibility_info(eligibility_data, formatted_dob, member_id, output_file)
                 
                 # Ask if user wants to open the report
                 open_report = input("\nEligibility data found! Open the report? (Y/N): ").strip().lower()
                 if open_report in ['y', 'yes']:
-                    os.system('notepad.exe "{}"'.format(output_file_path))
+                    os.startfile(output_file_path)
                 print("Manual eligibility report generated: {}\n".format(output_file_path))
                 break  # Assuming one payer ID per manual lookup
             else:
@@ -523,6 +542,13 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
         if run_validation:
             # Debug mode: Call both APIs and run validation
             MediLink_ConfigLoader.log("Running in DEBUG MODE - calling both APIs", level="INFO")
+            # Always initialize row-level error messages for diagnostics
+            error_messages_for_row = []
+            # Track Super Connector connection failure (for user-facing diagnostics)
+            sc_failure_info = None
+            # Enable verbose diagnostics in debug mode without config changes
+            diagnostics_verbose = True
+            sc_preflight_failed = False
             
             # Get legacy response
             MediLink_ConfigLoader.log("Getting legacy get_eligibility_v3 API response", level="INFO")
@@ -547,11 +573,44 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
             MediLink_ConfigLoader.log("Getting new get_eligibility_super_connector API response", level="INFO")
             super_connector_eligibility = None
             try:
-                super_connector_eligibility = api_core.get_eligibility_super_connector(
-                    client, payer_id, provider_last_name, 'MemberIDDateOfBirth', date_of_birth, member_id, npi
-                )
+                if not sc_preflight_failed:
+                    super_connector_eligibility = api_core.get_eligibility_super_connector(
+                        client, payer_id, provider_last_name, 'MemberIDDateOfBirth', date_of_birth, member_id, npi
+                    )
+                else:
+                    super_connector_eligibility = None
             except Exception as e:
                 MediLink_ConfigLoader.log("Super Connector API failed: {}".format(e), level="ERROR")
+                # Best-effort triage classification for clearer downstream messaging
+                try:
+                    # Use centralized classifier when available
+                    from MediCafe.deductible_utils import classify_api_failure
+                    code, message = classify_api_failure(e, 'Super Connector API')
+                    # Sticky preflight failure for subsequent patients in this run
+                    if code in ['TIMEOUT', 'CONN_ERR', 'AUTH_FAIL', 'MISCONFIG']:
+                        sc_preflight_failed = True
+                except Exception:
+                    try:
+                        failure_reason = "Super Connector API connection failed"
+                        detail = str(e)
+                        if requests and hasattr(requests, 'exceptions') and isinstance(e, requests.exceptions.Timeout):
+                            failure_reason = "Super Connector API timeout"
+                        elif requests and hasattr(requests, 'exceptions') and isinstance(e, requests.exceptions.ConnectionError):
+                            failure_reason = "Super Connector API connection error"
+                        elif "Invalid payer_id" in detail:
+                            failure_reason = "Super Connector API rejected payer_id"
+                        elif ("No access token" in detail) or ("token" in detail.lower()):
+                            failure_reason = "Super Connector API authentication failed"
+                        elif ("Eligibility endpoint not configured" in detail) or ("endpoint" in detail.lower() and "configured" in detail.lower()):
+                            failure_reason = "Super Connector API endpoint misconfigured"
+                        message = "{}: {}".format(failure_reason, detail)
+                    except Exception:
+                        message = "Super Connector API failed: {}".format(str(e))
+                sc_failure_info = {"message": message}
+                try:
+                    error_messages_for_row.append(message)
+                except Exception:
+                    pass
             
             # Run validation if we have at least one response
             # Generate validation report even if one API fails - this helps with debugging
@@ -596,6 +655,11 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
                             if detail_msg not in printed_messages:
                                 print(detail_msg)
                                 printed_messages.add(detail_msg)
+                            # Accumulate per-row messages for persistence in reports
+                            try:
+                                error_messages_for_row.append("{} - {}".format(error_code, error_desc))
+                            except Exception:
+                                pass
                             
                             # Check for data in error extensions (some APIs return data here)
                             extensions = error.get('extensions', {})
@@ -607,20 +671,37 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
                                     if details:
                                         first_detail = details[0]
                                         print("    First detail: {}".format(first_detail))
+                                        # Persist a brief extension note without dumping raw objects
+                                        try:
+                                            error_messages_for_row.append("Extensions include {} detail record(s)".format(len(details)))
+                                        except Exception:
+                                            pass
                 
                 # Check status code
                 if super_connector_eligibility:
                     status_code = super_connector_eligibility.get('statuscode')
-                    if status_code and status_code != '200':
+                    from MediCafe.deductible_utils import is_ok_200
+                    if status_code is not None and not is_ok_200(status_code):
                         print("Super Connector API status code: {} (non-200 indicates errors)".format(status_code))
+                        # Record status code for the row diagnostics
+                        error_messages_for_row.append("Status code {} from Super Connector".format(status_code))
+                # If Super Connector failed entirely, append a triage note to the validation report (if created)
+                try:
+                    if sc_failure_info and validation_file_path and os.path.exists(validation_file_path):
+                        with open(validation_file_path, 'a') as vf:
+                            vf.write("\n" + "-" * 80 + "\n")
+                            vf.write("SUPER CONNECTOR CONNECTION FAILURE NOTE\n")
+                            vf.write("-" * 80 + "\n")
+                            vf.write(sc_failure_info['message'] + "\n")
+                            vf.write("Recommendation: Verify network connectivity, credentials, payer ID validity, and endpoint configuration.\n")
+                except Exception:
+                    pass
                 
                 # Open validation report in Notepad (only for manual lookups, not batch processing)
                 if validation_file_path and os.path.exists(validation_file_path):
                     # Only open in manual mode - batch processing will handle this separately
                     if is_manual_lookup:  # Check if we're in manual lookup mode
-                        ret = os.system('notepad.exe "{}"'.format(validation_file_path))
-                        if ret != 0:
-                            print("Failed to open Notepad (exit code: {}). Please open manually: {}".format(ret, validation_file_path))
+                        os.startfile(validation_file_path)
                 elif validation_file_path:
                     print("\nValidation report file was not created: {}".format(validation_file_path))
             except Exception as e:
@@ -628,7 +709,40 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
             
             # After validation, merge responses
             try:
-                merged_data = merge_responses(super_connector_eligibility, legacy_eligibility, date_of_birth, member_id)
+                if merge_responses is not None:
+                    merged_data = merge_responses(super_connector_eligibility, legacy_eligibility, date_of_birth, member_id)
+                else:
+                    MediLink_ConfigLoader.log("merge_responses utility not available; returning raw API response", level="WARNING")
+                    merged_data = super_connector_eligibility or legacy_eligibility or {}
+                # Attach accumulated row-level messages for downstream display/persistence
+                try:
+                    if isinstance(merged_data, dict) and error_messages_for_row:
+                        merged_data['error_messages'] = error_messages_for_row
+                except Exception:
+                    pass
+                # Surface Super Connector failure prominently in user-facing diagnostics
+                try:
+                    if sc_failure_info and isinstance(merged_data, dict):
+                        merged_data['super_connector_failed'] = True
+                        # Prefer explaining the connection failure over generic name/amount messages
+                        if (not merged_data.get('error_reason')) or (merged_data.get('data_source') in ['None', 'Error']) or (not merged_data.get('is_successful', False)):
+                            merged_data['error_reason'] = sc_failure_info['message']
+                        # Ensure the failure message is included in error_messages
+                        if 'error_messages' not in merged_data or merged_data['error_messages'] is None:
+                            merged_data['error_messages'] = []
+                        if sc_failure_info['message'] not in merged_data['error_messages']:
+                            merged_data['error_messages'].append(sc_failure_info['message'])
+                        # Attach diagnostics envelope (minimal) without breaking existing schema
+                        try:
+                            if diagnostics_verbose:
+                                if 'diagnostics' not in merged_data or merged_data['diagnostics'] is None:
+                                    merged_data['diagnostics'] = []
+                                if sc_failure_info['message'] not in merged_data['diagnostics']:
+                                    merged_data['diagnostics'].append(sc_failure_info['message'])
+                        except Exception:
+                            pass
+                except Exception:
+                    pass
                 return merged_data
             except Exception as e:
                 MediLink_ConfigLoader.log("Error in merge_responses: {}".format(e), level="ERROR")
@@ -713,8 +827,10 @@ def display_eligibility_info(data, dob, member_id, output_file, patient_id="", s
     if data is None:
         return
 
-    # Convert to enhanced format
-    enhanced_data = convert_eligibility_to_enhanced_format(data, dob, member_id, patient_id, service_date)
+    # Convert to enhanced format (guard if utility missing)
+    enhanced_data = None
+    if convert_eligibility_to_enhanced_format is not None:
+        enhanced_data = convert_eligibility_to_enhanced_format(data, dob, member_id, patient_id, service_date)
     if enhanced_data:
         # Write to output file in legacy format for compatibility
         table_row = "{:<20} | {:<10} | {:<40} | {:<5} | {:<14} | {:<14}".format(
@@ -727,6 +843,31 @@ def display_eligibility_info(data, dob, member_id, output_file, patient_id="", s
         output_file.write(table_row + "\n")
         print(table_row)  # Print to console for progressive display
 
+# Helper to compute a user-friendly error explanation for a result row
+def _compute_error_reason(record):
+    # Delegate to centralized helper to avoid duplication
+    try:
+        from MediCafe.deductible_utils import compute_error_reason
+        return compute_error_reason(record)
+    except Exception:
+        try:
+            if not isinstance(record, dict):
+                return ""
+            reason = str(record.get('error_reason', '')).strip()
+            name_unknown = (not str(record.get('patient_name', '')).strip()) or (record.get('patient_name') == 'Unknown Patient')
+            has_error = (str(record.get('status', '')) == 'Error') or (str(record.get('data_source', '')) in ['None', 'Error'])
+            amount_missing = (str(record.get('remaining_amount', '')) == 'Not Found')
+            if not reason:
+                if name_unknown:
+                    reason = 'Patient name could not be determined from API responses or CSV backfill'
+                elif amount_missing:
+                    reason = 'Deductible remaining amount not found in eligibility response'
+                elif has_error:
+                    reason = 'Eligibility lookup encountered an error; see logs for details'
+            return reason
+        except Exception:
+            return ""
+
 # Global mode flags (will be set in main)
 LEGACY_MODE = False
 DEBUG_MODE = False
@@ -1030,6 +1171,14 @@ if __name__ == "__main__":
                     "Patient Name", "DOB", "Insurance Type Code", "PayID", "Policy Status", "Remaining Amt")
                 output_file.write(table_header + "\n")
                 output_file.write("-" * len(table_header) + "\n")
+
+                # Global notice when Super Connector connection failed for any patients
+                try:
+                    sc_failed_count = sum(1 for r in eligibility_results if isinstance(r, dict) and r.get('super_connector_failed'))
+                    if sc_failed_count:
+                        output_file.write("NOTICE: Super Connector API connection failed for {} patient(s). Fallback data used when available.\n".format(sc_failed_count))
+                except Exception:
+                    pass
                 
                 # Write all results to file
                 for result in eligibility_results:
@@ -1042,6 +1191,20 @@ if __name__ == "__main__":
                         result['remaining_amount'][:14])
                     output_file.write(table_row + "\n")
 
+                    # Persist per-row error diagnostics in a user-friendly way
+                    try:
+                        row_reason = _compute_error_reason(result)
+                        row_messages = result.get('error_messages', []) or []
+                        if row_reason or row_messages:
+                            output_file.write("  >> Errors:" + "\n")
+                            if row_reason:
+                                output_file.write("  >> - {}\n".format(row_reason))
+                            for msg in row_messages:
+                                if not row_reason or msg.strip() != row_reason.strip():
+                                    output_file.write("  >> - {}\n".format(str(msg)))
+                    except Exception:
+                        pass
+
                 # Write enhanced error summary to file
                 if errors:
                     error_msg = "\nErrors encountered during API calls:\n"
@@ -1053,7 +1216,7 @@ if __name__ == "__main__":
             # Ask if user wants to open the report
             open_report = input("\nBatch processing complete! Open the eligibility report? (Y/N): ").strip().lower()
             if open_report in ['y', 'yes']:
-                os.system('notepad.exe "{}"'.format(output_file_path))
+                os.startfile(output_file_path)
             
             # Print summary of validation reports only in debug mode
             if DEBUG_MODE:
@@ -1072,9 +1235,7 @@ if __name__ == "__main__":
                     if open_validation in ['y', 'yes']:
                         for file_path in validation_files_created:
                             print("Opening: {}".format(os.path.basename(file_path)))
-                            ret = os.system('notepad.exe "{}"'.format(file_path))
-                            if ret != 0:
-                                print("Failed to open Notepad for: {}".format(os.path.basename(file_path)))
+                            os.startfile(file_path)
                 else:
                     print("No validation reports were generated.")
                     print("This may be because:")

MediLink/MediLink_Display_Utils.py

@@ -518,7 +518,14 @@ def _maybe_display_error_row(record, context):
             elif has_error:
                 reason = 'Eligibility lookup encountered an error; see logs for details'
 
-        if reason:
+        # Prefer diagnostics lines when present; otherwise fall back to reason
+        diagnostics = record.get('diagnostics', []) or []
+        if diagnostics:
+            # Only show first 1-2 lines to avoid noise in XP console
+            to_show = diagnostics[:2]
+            for line in to_show:
+                print("     >> {}".format(line))
+        elif reason:
             print("     >> Error: {}".format(reason))
     except Exception:
         # Never let diagnostics break table rendering

MediLink/MediLink_Gmail.py

@@ -174,6 +174,14 @@ class RequestHandler(BaseHTTPRequestHandler):
         self.send_response(200)
         self._set_headers()
         self.end_headers()
+        try:
+            origin = self.headers.get('Origin')
+        except Exception:
+            origin = None
+        try:
+            print("[CORS] Preflight {0} from {1}".format(self.path, origin))
+        except Exception:
+            pass
 
     def do_POST(self):
         if self.path == '/download':
@@ -182,6 +190,10 @@ class RequestHandler(BaseHTTPRequestHandler):
             data = json.loads(post_data.decode('utf-8'))
             links = data.get('links', [])
             log("Received links: {}".format(links))
+            try:
+                print("[Handshake] Received {0} link(s) from webapp".format(len(links)))
+            except Exception:
+                pass
             file_ids = [link.get('fileId', None) for link in links if link.get('fileId')]
             log("File IDs received from client: {}".format(file_ids))
             download_docx_files(links)
@@ -210,6 +222,10 @@ class RequestHandler(BaseHTTPRequestHandler):
             self.end_headers()
             response = json.dumps({"status": "success", "message": "All files downloaded", "fileIds": successful_ids})
             self.wfile.write(response.encode('utf-8'))
+            try:
+                print("[Handshake] Completed. Returning success for {0} fileId(s)".format(len(successful_ids)))
+            except Exception:
+                pass
             shutdown_event.set()
             bring_window_to_foreground()
         elif self.path == '/shutdown':
@@ -244,6 +260,19 @@ class RequestHandler(BaseHTTPRequestHandler):
 
     def do_GET(self):
         log("Full request path: {}".format(self.path))
+        if self.path == '/_health':
+            try:
+                print("[Health] Probe OK")
+            except Exception:
+                pass
+            self.send_response(200)
+            self._set_headers()
+            self.end_headers()
+            try:
+                self.wfile.write(json.dumps({"status": "ok"}).encode('ascii'))
+            except Exception:
+                self.wfile.write(b'{"status":"ok"}')
+            return
         if self.path.startswith("/?code="):
             auth_code = self.path.split('=')[1].split('&')[0]
             auth_code = requests.utils.unquote(auth_code)
@@ -329,6 +358,10 @@ def run_server():
         httpd = HTTPServer(('0.0.0.0', server_port), RequestHandler)
         httpd.socket = ssl.wrap_socket(httpd.socket, certfile=cert_file, keyfile=key_file, server_side=True)
         log("Starting HTTPS server on port {}".format(server_port))
+        try:
+            print("[Server] HTTPS server ready at https://127.0.0.1:{0}".format(server_port))
+        except Exception:
+            pass
         httpd.serve_forever()
     except Exception as e:
         log("Error in serving: {}".format(e))

MediLink/__init__.py

@@ -22,7 +22,7 @@ Smart Import Integration:
         datamgmt = get_components('medilink_datamgmt')
 """
 
-__version__ = "0.251015.0"
+__version__ = "0.251017.0"
 __author__ = "Daniel Vidaud"
 __email__ = "daniel@personalizedtransformation.com"
 

MediLink/webapp.html

@@ -172,6 +172,8 @@
             <div id="loadingMessage" class="loading-message" style="display:none;">
                 <span>⏳</span> Loading DOCX results...
             </div>
+
+            
         </main>
     <script>
         document.addEventListener("DOMContentLoaded", () => {
@@ -393,11 +395,13 @@
                 return;
             }
 
+            const baseUrl = 'https://127.0.0.1:8000';
+            console.log("Python server URL:", baseUrl);
             console.log("Sending download links to Python server:", downloadLinks);
             try {
-                const response = await fetch('https://127.0.0.1:8000/download', {
+                const response = await fetch(baseUrl + '/download', {
                     method: 'POST',
-                    headers: {'Content-Type': 'application/json'},
+                    headers: { 'Content-Type': 'application/json' },
                     body: JSON.stringify({
                         links: downloadLinks.map(link => ({
                             url: link.url,
@@ -405,30 +409,54 @@
                             fileId: link.fileId,
                         }))
                     }),
-                    mode: 'cors'  // Ensure the request includes CORS headers
+                    mode: 'cors'
                 });
 
-                // Log the response status and headers for debugging
-                console.log("Response status:", response.status);
-                console.log("Response headers:", response.headers);
-
                 if (!response.ok) {
-                    const errorText = await response.text(); // Get the error message from the response
-                    console.error('Network response was not ok:', errorText);
+                    const errorText = await response.text().catch(() => '');
                     throw new Error(`Network response was not ok: ${response.status} - ${errorText}`);
                 }
 
-                const data = await response.json();
+                const data = await response.json().catch(() => ({}));
                 console.log("Python server response:", data);
                 if (data.status === 'success') {
-                    console.log("Download links successfully sent to Python server.");
+                    console.log('Python server handshake complete. Accepted ' + downloadLinks.length + ' link(s).');
                 } else {
                     console.error("Error from Python server:", data.message);
-                    displayErrorMessage('Error: ' + data.message);
+                    displayErrorMessage('Error: ' + (data.message || 'Unexpected server response'));
                 }
             } catch (error) {
                 console.error('Error sending download links to Python server:', error);
-                displayErrorMessage('Unable to send download links to the server. Error: ' + error.message);
+                await diagnoseAfterFailure(baseUrl, error);
+            }
+        }
+
+        async function diagnoseAfterFailure(baseUrl, originalError) {
+            try {
+                if (!navigator.onLine) {
+                    displayErrorMessage('You appear to be offline. Please check your internet connection.');
+                    return;
+                }
+                // Probe server reachability
+                let healthOk = false;
+                let healthStatus = null;
+                try {
+                    const res = await fetch(baseUrl + '/_health', { method: 'GET', mode: 'cors', cache: 'no-store', credentials: 'omit' });
+                    healthOk = !!res && res.ok;
+                    healthStatus = res ? (res.status + ' ' + (res.statusText || '')) : null;
+                } catch (e) {
+                    // ignore, handled below
+                }
+
+                if (healthOk) {
+                    displayErrorMessage('The Python server is reachable, but the download request failed. Please try again or restart the Python tool.');
+                } else {
+                    // Generic but actionable guidance
+                    displayErrorMessage('Unable to reach the local Python server at https://127.0.0.1:8000. Ensure it is running and trusted by your browser (open the URL once if needed).');
+                }
+            } catch (diagErr) {
+                // Fallback to original error message
+                displayErrorMessage('Unable to send download links to the server. Error: ' + (originalError && originalError.message ? originalError.message : String(originalError)));
             }
         }
 

{medicafe-0.251015.0.dist-info → medicafe-0.251017.0.dist-info}/METADATA

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

{medicafe-0.251015.0.dist-info → medicafe-0.251017.0.dist-info}/RECORD

@@ -12,7 +12,7 @@ MediBot/MediBot_dataformat_library.py,sha256=D46fdPtxcgfWTzaLBtSvjtozzZBNqNiODgu
 MediBot/MediBot_debug.bat,sha256=F5Lfi3nFEEo4Ddx9EbX94u3fNAMgzMp3wsn-ULyASTM,6017
 MediBot/MediBot_docx_decoder.py,sha256=9BSjV-kB90VHnqfL_5iX4zl5u0HcHvHuL7YNfx3gXpQ,33143
 MediBot/MediBot_smart_import.py,sha256=Emvz7NwemHGCHvG5kZcUyXMcCheidbGKaPfOTg-YCEs,6684
-MediBot/__init__.py,sha256=RZDruyBkYuWNTwJuX6TMpymOyX3V6jq-jUTBwV249rE,3192
+MediBot/__init__.py,sha256=Gj1gmPtY2Ua-T9wxwcjl2OXVo7dMcZI4FkOg-YVWvLg,3192
 MediBot/clear_cache.bat,sha256=F6-VhETWw6xDdGWG2wUqvtXjCl3lY4sSUFqF90bM8-8,1860
 MediBot/crash_diagnostic.bat,sha256=j8kUtyBg6NOWbXpeFuEqIRHOkVzgUrLOqO3FBMfNxTo,9268
 MediBot/f_drive_diagnostic.bat,sha256=4572hZaiwZ5wVAarPcZJQxkOSTwAdDuT_X914noARak,6878
@@ -22,13 +22,13 @@ MediBot/process_csvs.bat,sha256=3tI7h1z9eRj8rUUL4wJ7dy-Qrak20lRmpAPtGbUMbVQ,3489
 MediBot/update_json.py,sha256=vvUF4mKCuaVly8MmoadDO59M231fCIInc0KI1EtDtPA,3704
 MediBot/update_medicafe.py,sha256=G1lyvVOHYuho1d-TJQNN6qaB4HBWaJ2PpXqemBoPlRQ,17937
 MediCafe/MediLink_ConfigLoader.py,sha256=NoLb2YiJwlkrRYCt2PHvcFJ7yTIRWQCrsvkZIJWreM4,11141
-MediCafe/__init__.py,sha256=DGCg0jShqGBlX0QwzU-oOvl21DxN0Yadu1qEYVTFVtU,5721
+MediCafe/__init__.py,sha256=5NhwImtNbn5vzqKaqRB0It076F7C2Zmb0REd1jY4BxE,5721
 MediCafe/__main__.py,sha256=mRNyk3D9Ilnu2XhgVI_rut7r5Ro7UIKtwV871giAHI8,12992
 MediCafe/api_core.py,sha256=r9cqa5-HU4A7iz3NLxzRwuxsxOfDiJn9SRgtPjT83qU,90764
 MediCafe/api_factory.py,sha256=I5AeJoyu6m7oCrjc2OvVvO_4KSBRutTsR1riiWhTZV0,12086
 MediCafe/api_utils.py,sha256=KWQB0q1k5E6frOFFlKWcFpHNcqfrS7KJ_82672wbupw,14041
 MediCafe/core_utils.py,sha256=XKUpyv7yKjIQ8iNrhD76PIURyt6GZxb98v0daiI7aaw,27303
-MediCafe/deductible_utils.py,sha256=Qpp5joZ0KxSWbN6qQU1OM0fE-n__v5jtzdOV4UR0CT8,61446
+MediCafe/deductible_utils.py,sha256=-ixDYwI3JNAyACrFjKqoX_hD3Awzownq441U0PSrwXw,64932
 MediCafe/error_reporter.py,sha256=t9AAkkVsmZMxPMSA6DW7wDf2cxXpFfA9oJW5-thg5VQ,8176
 MediCafe/graphql_utils.py,sha256=3BYl4wrox40063RwCtIqsrxSMA5rdchCP69RGi-U4aY,51317
 MediCafe/logging_config.py,sha256=auT65LN5oDEXVhkMeLke63kJHTWxYf2o8YihAfQFgzU,5493
@@ -47,11 +47,11 @@ MediLink/MediLink_Charges.py,sha256=82fnqHGvT7tfdfjucnFHiLdUE0WhHDXrcS0k_Ln3c8U,
 MediLink/MediLink_ClaimStatus.py,sha256=nKX7QymhCULiaGfISYw_P0Eqy0TP6qKG4C2d3TdGFVo,22720
 MediLink/MediLink_DataMgmt.py,sha256=9hc5jyWU65nYT66afDybOyYAcW-DvEYuHpWTun96U50,52407
 MediLink/MediLink_Decoder.py,sha256=1gzdybNg4Vv69s5PNbX8bPNrXT_N_kPpFpt2HpkauWA,16430
-MediLink/MediLink_Deductible.py,sha256=jr-TrfOTxQDc4dwvwUy4jSSb_AnsU0pWLq_kyktAgZk,57942
+MediLink/MediLink_Deductible.py,sha256=8Npibnv4p7HDGhz8t7bf760lbkGbV3fMVIfKjNgxYjA,68168
 MediLink/MediLink_Deductible_Validator.py,sha256=x6tHJOi88TblUpDPSH6QhIdXXRgr3rXI7kYPVGZYCgU,24998
-MediLink/MediLink_Display_Utils.py,sha256=wWGbqhGL_6vZrVE4_7-xYg7fdjVbTR1149VJTS3deI0,24513
+MediLink/MediLink_Display_Utils.py,sha256=MonsX6VPbdvqwY_V8sHUYrXCS0fMKc4toJvG0oyr-V4,24872
 MediLink/MediLink_Down.py,sha256=s4_z-RaqHYanjwbQCl-OSkg4XIpcIQ2Q6jXa8-q_QXw,28111
-MediLink/MediLink_Gmail.py,sha256=muqZI3girXDu92KT5Nft7dLHtpnQAjH-QfvdcGo28_Y,26801
+MediLink/MediLink_Gmail.py,sha256=hMHgseSi58qPMivZpEhZbY6k-tyxC-hHcWaS7xVNFbI,28011
 MediLink/MediLink_Mailer.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 MediLink/MediLink_Parser.py,sha256=eRVZ4ckZ5gDOrcvtCUZP3DOd3Djly66rCIk0aYXLz14,12567
 MediLink/MediLink_PatientProcessor.py,sha256=9r2w4p45d30Tn0kbXL3j5574MYOehP83tDirNOw_Aek,19977
@@ -63,15 +63,15 @@ MediLink/MediLink_insurance_utils.py,sha256=g741Fj2K26cMy0JX5d_XavMw9LgkK6hjaUJY
 MediLink/MediLink_main.py,sha256=CAXu0IRzhra3ppIFDcCppFNAZp7kCuN6gPtJSdFqGzs,24857
 MediLink/MediLink_smart_import.py,sha256=B5SfBn_4bYEWJJDolXbjnwKx_-MaqGZ76LyXQwWDV80,9838
 MediLink/Soumit_api.py,sha256=5JfOecK98ZC6NpZklZW2AkOzkjvrbYxpJpZNH3rFxDw,497
-MediLink/__init__.py,sha256=pUz0lDh96t0FYdCxUQlawfKMvDiib088-00IsHgRwfk,3888
+MediLink/__init__.py,sha256=xK9uzY41kqKgKT5uxifwKQd001nXnAzeHPJdwjB4Yeo,3888
 MediLink/gmail_http_utils.py,sha256=gtqCCrzJC7e8JFQzMNrf7EbK8na2h4sfTu-NMaZ_UHc,4006
 MediLink/gmail_oauth_utils.py,sha256=Ugr-DEqs4_RddRMSCJ_dbgA3TVeaxpbAor-dktcTIgY,3713
 MediLink/openssl.cnf,sha256=76VdcGCykf0Typyiv8Wd1mMVKixrQ5RraG6HnfKFqTo,887
 MediLink/test.py,sha256=DM_E8gEbhbVfTAm3wTMiNnK2GCD1e5eH6gwTk89QIc4,3116
-MediLink/webapp.html,sha256=MI9zZ4y1_h5Ji3nz2fmm6Q29AsPunks-wR-R8Ct73-w,19856
-medicafe-0.251015.0.dist-info/LICENSE,sha256=65lb-vVujdQK7uMH3RRJSMwUW-WMrMEsc5sOaUn2xUk,1096
-medicafe-0.251015.0.dist-info/METADATA,sha256=AVt3fFn191rtXLPHcmal5udTp73FL8RTu8fu-YpMndU,3414
-medicafe-0.251015.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-medicafe-0.251015.0.dist-info/entry_points.txt,sha256=m3RBUBjr-xRwEkKJ5W4a7NlqHZP_1rllGtjZnrRqKe8,52
-medicafe-0.251015.0.dist-info/top_level.txt,sha256=U6-WBJ9RCEjyIs0BlzbQq_PwedCp_IV9n1616NNV5zA,26
-medicafe-0.251015.0.dist-info/RECORD,,
+MediLink/webapp.html,sha256=DwDYjVvluGJ7eDdvEogfKN4t24ZJRoIUuSBfCYCL-3w,21252
+medicafe-0.251017.0.dist-info/LICENSE,sha256=65lb-vVujdQK7uMH3RRJSMwUW-WMrMEsc5sOaUn2xUk,1096
+medicafe-0.251017.0.dist-info/METADATA,sha256=d86uW7sAJWTEBOxVF00UdawI9PmXuNoMuiE7iGCTYE0,3414
+medicafe-0.251017.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+medicafe-0.251017.0.dist-info/entry_points.txt,sha256=m3RBUBjr-xRwEkKJ5W4a7NlqHZP_1rllGtjZnrRqKe8,52
+medicafe-0.251017.0.dist-info/top_level.txt,sha256=U6-WBJ9RCEjyIs0BlzbQq_PwedCp_IV9n1616NNV5zA,26
+medicafe-0.251017.0.dist-info/RECORD,,