medicafe 0.251017.1__py3-none-any.whl → 0.251026.0__py3-none-any.whl

MediLink/MediLink_Deductible.py

@@ -549,6 +549,7 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
             # Enable verbose diagnostics in debug mode without config changes
             diagnostics_verbose = True
             sc_preflight_failed = False
+            # NOTE: No config flag mutation needed; OPTUMAI call now never auto-falls back
             
             # Get legacy response
             MediLink_ConfigLoader.log("Getting legacy get_eligibility_v3 API response", level="INFO")
@@ -569,8 +570,8 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
             else:
                 MediLink_ConfigLoader.log("API client does not support token authentication for Legacy API.", level="WARNING")
             
-            # Get Super Connector response for comparison
-            MediLink_ConfigLoader.log("Getting new get_eligibility_super_connector API response", level="INFO")
+            # Get OPTUMAI eligibility response for comparison (formerly Super Connector)
+            MediLink_ConfigLoader.log("Getting OPTUMAI eligibility API response", level="INFO")
             super_connector_eligibility = None
             try:
                 if not sc_preflight_failed:
@@ -580,32 +581,32 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
                 else:
                     super_connector_eligibility = None
             except Exception as e:
-                MediLink_ConfigLoader.log("Super Connector API failed: {}".format(e), level="ERROR")
+                MediLink_ConfigLoader.log("OPTUMAI eligibility 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')
+                    code, message = classify_api_failure(e, 'OPTUMAI eligibility 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"
+                        failure_reason = "OPTUMAI eligibility API connection failed"
                         detail = str(e)
                         if requests and hasattr(requests, 'exceptions') and isinstance(e, requests.exceptions.Timeout):
-                            failure_reason = "Super Connector API timeout"
+                            failure_reason = "OPTUMAI eligibility API timeout"
                         elif requests and hasattr(requests, 'exceptions') and isinstance(e, requests.exceptions.ConnectionError):
-                            failure_reason = "Super Connector API connection error"
+                            failure_reason = "OPTUMAI eligibility API connection error"
                         elif "Invalid payer_id" in detail:
-                            failure_reason = "Super Connector API rejected payer_id"
+                            failure_reason = "OPTUMAI eligibility API rejected payer_id"
                         elif ("No access token" in detail) or ("token" in detail.lower()):
-                            failure_reason = "Super Connector API authentication failed"
+                            failure_reason = "OPTUMAI eligibility 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"
+                            failure_reason = "OPTUMAI eligibility API endpoint misconfigured"
                         message = "{}: {}".format(failure_reason, detail)
                     except Exception:
-                        message = "Super Connector API failed: {}".format(str(e))
+                        message = "OPTUMAI eligibility API failed: {}".format(str(e))
                 sc_failure_info = {"message": message}
                 try:
                     error_messages_for_row.append(message)
@@ -629,22 +630,22 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
                     )
                     print("\nValidation report generated (legacy only): {}".format(validation_file_path))
                 elif super_connector_eligibility:
-                    # Only Super Connector API returned data
+                    # Only OPTUMAI eligibility API returned data
                     validation_report = MediLink_Deductible_Validator.run_validation_comparison(
                         None, super_connector_eligibility, validation_file_path
                     )
-                    print("\nValidation report generated (Super Connector only): {}".format(validation_file_path))
+                    print("\nValidation report generated (OPTUMAI only): {}".format(validation_file_path))
                 else:
                     # Neither API returned data
                     print("\nNo validation report generated - both APIs failed")
                     validation_file_path = None
                 
-                # Log any Super Connector API errors if we have that data
+                # Log any OPTUMAI eligibility API errors if we have that data
                 if super_connector_eligibility and "rawGraphQLResponse" in super_connector_eligibility:
                     raw_response = super_connector_eligibility.get('rawGraphQLResponse', {})
                     errors = raw_response.get('errors', [])
                     if errors:
-                        error_msg = "Super Connector API returned {} error(s):".format(len(errors))
+                        error_msg = "OPTUMAI eligibility API returned {} error(s):".format(len(errors))
                         if error_msg not in printed_messages:
                             print(error_msg)
                             printed_messages.add(error_msg)
@@ -676,21 +677,42 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
                                             error_messages_for_row.append("Extensions include {} detail record(s)".format(len(details)))
                                         except Exception:
                                             pass
+
+                        # Provide concise terminal hints for 401/403 outcomes (XP-safe)
+                        def _emit_hint(status_code):
+                            try:
+                                if status_code == '401':
+                                    h = "Hint: Authentication failed. Verify API credentials/token and endpoint configuration."
+                                    if h not in printed_messages:
+                                        print(h)
+                                        printed_messages.add(h)
+                                elif status_code == '403':
+                                    h = "Hint: Access denied. Verify provider TIN/NPI and account permissions/roles."
+                                    if h not in printed_messages:
+                                        print(h)
+                                        printed_messages.add(h)
+                            except Exception:
+                                pass
+
+                        try:
+                            _emit_hint(super_connector_eligibility.get('statuscode'))
+                        except Exception:
+                            pass
                 
                 # Check status code
                 if super_connector_eligibility:
                     status_code = super_connector_eligibility.get('statuscode')
                     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))
+                        print("OPTUMAI eligibility 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))
+                        error_messages_for_row.append("Status code {} from OPTUMAI eligibility".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("OPTUMAI ELIGIBILITY 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")
@@ -720,7 +742,7 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
                         merged_data['error_messages'] = error_messages_for_row
                 except Exception:
                     pass
-                # Surface Super Connector failure prominently in user-facing diagnostics
+                # Surface OPTUMAI eligibility failure prominently in user-facing diagnostics
                 try:
                     if sc_failure_info and isinstance(merged_data, dict):
                         merged_data['super_connector_failed'] = True
@@ -922,7 +944,7 @@ if __name__ == "__main__":
         print("- Crosswalk-based payer ID resolution (O(N) complexity)")
     elif DEBUG_MODE:
         print("\nRunning in DEBUG MODE")
-        print("- Dual API calls (Legacy + Super Connector)")
+        print("- Dual API calls (Legacy + OPTUMAI eligibility)")
         print("- Validation reports and comparisons")
         print("- Detailed logging and error reporting")
         print("- Crosswalk-based payer ID resolution (O(N) complexity)")
@@ -1172,11 +1194,11 @@ if __name__ == "__main__":
                 output_file.write(table_header + "\n")
                 output_file.write("-" * len(table_header) + "\n")
 
-                # Global notice when Super Connector connection failed for any patients
+                # Global notice when OPTUMAI eligibility 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))
+                        output_file.write("NOTICE: OPTUMAI eligibility API connection failed for {} patient(s). Fallback data used when available.\n".format(sc_failed_count))
                 except Exception:
                     pass
                 
@@ -1239,7 +1261,7 @@ if __name__ == "__main__":
                 else:
                     print("No validation reports were generated.")
                     print("This may be because:")
-                    print("  - Super Connector API calls failed")
+                    print("  - OPTUMAI eligibility API calls failed")
                     print("  - Both APIs didn't return data for the same patients")
                     print("  - Validation report generation encountered errors")
                 print("=" * 80)

MediLink/MediLink_Gmail.py

@@ -84,6 +84,7 @@ SCOPES = ' '.join([
     'https://www.googleapis.com/auth/gmail.modify',
     'https://www.googleapis.com/auth/gmail.compose',
     'https://www.googleapis.com/auth/gmail.readonly',
+    'https://www.googleapis.com/auth/gmail.send',
     'https://www.googleapis.com/auth/script.external_request',
     'https://www.googleapis.com/auth/userinfo.email',
     'https://www.googleapis.com/auth/script.scriptapp',

MediLink/MediLink_Up.py

@@ -258,16 +258,22 @@ def submit_claims(detailed_patient_data_grouped_by_endpoint, config, crosswalk):
                             local_claims_path = cfg.get('local_claims_path', '.')
                             transmission_result = operate_winscp(operation_type, filtered_files, endpoint_cfg, local_claims_path, config)
                             success_dict = handle_transmission_result(transmission_result, config, operation_type, method)
+                            # If we attempted uploads but could not derive any status, emit explicit failures per file
+                            if (not success_dict) and filtered_files:
+                                success_dict = {fp: (False, "No transfer status found in WinSCP log") for fp in filtered_files}
                             submission_results[endpoint] = success_dict
                         except FileNotFoundError as e:
-                            print("Failed to transmit files to {}. Error: Log file not found - {}".format(endpoint, str(e)))
-                            submission_results[endpoint] = {"status": False, "error": "Log file not found - " + str(e)}
+                            msg = "Log file not found - {}".format(str(e))
+                            print("Failed to transmit files to {}. Error: {}".format(endpoint, msg))
+                            submission_results[endpoint] = {fp: (False, msg) for fp in (filtered_files or [])}
                         except IOError as e:
-                            print("Failed to transmit files to {}. Error: Input/output error - {}".format(endpoint, str(e)))
-                            submission_results[endpoint] = {"status": False, "error": "Input/output error - " + str(e)}
+                            msg = "Input/output error - {}".format(str(e))
+                            print("Failed to transmit files to {}. Error: {}".format(endpoint, msg))
+                            submission_results[endpoint] = {fp: (False, msg) for fp in (filtered_files or [])}
                         except Exception as e:
-                            print("Failed to transmit files to {}. Error: {}".format(endpoint, str(e)))
-                            submission_results[endpoint] = {"status": False, "error": str(e)}
+                            msg = str(e)
+                            print("Failed to transmit files to {}. Error: {}".format(endpoint, msg))
+                            submission_results[endpoint] = {fp: (False, msg) for fp in (filtered_files or [])}
                     elif method == 'api':
                         # Transmit files via API
                         try:
@@ -284,10 +290,14 @@ def submit_claims(detailed_patient_data_grouped_by_endpoint, config, crosswalk):
                                         response = {"error": "API module not available"}
                                     api_responses.append((file_path, response))
                             success_dict = handle_transmission_result(api_responses, config, "api", method)
+                            # If API call path yielded no status, emit explicit failures per file attempted
+                            if (not success_dict) and filtered_files:
+                                success_dict = {fp: (False, "No API response parsed") for fp in filtered_files}
                             submission_results[endpoint] = success_dict
                         except Exception as e:
-                            print("Failed to transmit files via API to {}. Error: {}".format(endpoint, str(e)))
-                            submission_results[endpoint] = {"status": False, "error": str(e)}
+                            msg = str(e)
+                            print("Failed to transmit files via API to {}. Error: {}".format(endpoint, msg))
+                            submission_results[endpoint] = {fp: (False, msg) for fp in (filtered_files or [])}
                 else:
                     print("No files were converted for transmission to {}.".format(endpoint))
             else:
@@ -495,29 +505,25 @@ def prepare_receipt_data(submission_results):
             log("File path: {}".format(file_path), level="DEBUG")
             log("File result: {}".format(file_result), level="DEBUG")
 
-            try:
-                # Unpack the tuple to get status and message
-                status, message = file_result
-            except ValueError as e:
-                file_result_length = len(file_result) if hasattr(file_result, '__len__') else 'Unknown'
-                error_msg = 'Too many values to unpack.' if 'too many values to unpack' in str(e) else \
-                            'Not enough values to unpack.' if 'not enough values to unpack' in str(e) else \
-                            'Value unpacking error.'
-                log("ValueError: {} for file_result: {} (Length: {})".format(error_msg, file_result, file_result_length), level="ERROR")
-                continue
-            except Exception as e:
-                tb = traceback.format_exc()
-                log("Unexpected error: {}. Traceback: {}".format(e, tb), level="ERROR")
-                continue
-
-            log("Status: {}, Message: {}".format(status, message), level="DEBUG")
-
+            # Ensure endpoint bucket exists even if result shape is unexpected
             if endpoint not in receipt_data:
                 receipt_data[endpoint] = {
                     "patients": [],
                     "date_of_submission": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
                 }
 
+            # Normalize result tuple shape; on unexpected shape, degrade to (False, stringified)
+            try:
+                status, message = file_result
+            except Exception:
+                status = False
+                try:
+                    message = str(file_result)
+                except Exception:
+                    message = "Unknown result"
+
+            log("Status: {}, Message: {}".format(status, message), level="DEBUG")
+
             # Parse patient details and add the result status and message
             patient_data, _ = parse_837p_file(file_path)
             for patient in patient_data:

MediLink/MediLink_main.py

@@ -22,7 +22,8 @@ if PERFORMANCE_LOGGING:
 
 # Now import core utilities after path setup
 from MediCafe.core_utils import get_shared_config_loader, setup_module_paths, extract_medilink_config
-from MediCafe.error_reporter import flush_queued_reports, collect_support_bundle, submit_support_bundle, capture_unhandled_traceback
+from MediCafe.error_reporter import collect_support_bundle, capture_unhandled_traceback
+from MediCafe.error_reporter import submit_support_bundle_email
 setup_module_paths(__file__)
 
 # Import modules after path setup
@@ -41,6 +42,20 @@ if PERFORMANCE_LOGGING:
 
 # NOTE: Configuration loading moved to function level to avoid import-time dependencies
 
+# --- Safe logging helpers (XP/3.4.4 compatible) ---
+def _safe_log(message, level="INFO"):
+    """Attempt to log via MediLink logger, fallback to print on failure."""
+    try:
+        MediLink_ConfigLoader.log(message, level=level)
+    except Exception:
+        try:
+            print(message)
+        except Exception:
+            pass
+
+def _safe_debug(message):
+    _safe_log(message, level="DEBUG")
+
 # TODO There needs to be a crosswalk auditing feature right alongside where all the names get fetched during initial startup maybe? 
 # Vision:
 # - Fast audit pass on startup with 3s timeout: report missing names/IDs, do not block.
@@ -58,8 +73,7 @@ def _tools_menu(config, medi):
         print("\nMaintenance Tools:")
         options = [
             "Rebuild submission index now",
-            "Submit Error Report (online)",
-            "Create Support Bundle (offline)",
+            "Submit Error Report (email)",
             "Back"
         ]
         MediLink_UI.display_menu(options)
@@ -79,26 +93,26 @@ def _tools_menu(config, medi):
                 print("Index rebuild error: {}".format(e))
         elif choice == '2':
             try:
-                print("\nSubmitting Error Report (online)...")
-                zip_path = collect_support_bundle(include_traceback=True)
-                if not zip_path:
-                    print("Failed to create support bundle.")
+                if submit_support_bundle_email is None:
+                    print("Email submission module not available.")
                 else:
-                    ok = submit_support_bundle(zip_path)
-                    if not ok:
-                        print("Submission failed. Bundle saved at {} for later retry.".format(zip_path))
+                    print("\nSubmitting Error Report (email)...")
+                    zip_path = collect_support_bundle(include_traceback=True)
+                    if not zip_path:
+                        print("Failed to create support bundle.")
+                    else:
+                        ok = submit_support_bundle_email(zip_path)
+                        if ok:
+                            # Optional: remove the file upon success to avoid re-sending on next startup
+                            try:
+                                os.remove(zip_path)
+                            except Exception:
+                                pass
+                        else:
+                            print("Submission failed. Bundle saved at {} for manual handling.".format(zip_path))
             except Exception as e:
-                print("Error during report submission: {}".format(e))
+                print("Error during email report submission: {}".format(e))
         elif choice == '3':
-            try:
-                zip_path = collect_support_bundle(include_traceback=True)
-                if zip_path:
-                    print("Support bundle created: {}".format(zip_path))
-                else:
-                    print("Failed to create support bundle.")
-            except Exception as e:
-                print("Error creating support bundle: {}".format(e))
-        elif choice == '4':
             break
         else:
             MediLink_UI.display_invalid_choice()
@@ -181,8 +195,8 @@ def main_menu():
     # Clear screen before showing menu header
     try:
         os.system('cls' if os.name == 'nt' else 'clear')
-    except Exception:
-        pass  # Fallback if cls/clear fails
+    except Exception as e:
+        _safe_debug("Clear screen failed: {}".format(e))  # Fallback if cls/clear fails
 
     # Display Welcome Message
     welcome_start = time.time()
@@ -191,14 +205,7 @@ def main_menu():
     if PERFORMANCE_LOGGING:
         print("Welcome display completed in {:.2f} seconds".format(welcome_end - welcome_start))
 
-    # Startup: flush any queued error reports (non-blocking style)
-    try:
-        print("\nChecking for queued error reports...")
-        uploaded, total = flush_queued_reports()
-        if total:
-            print("Queued reports: {} | Uploaded now: {}".format(total, uploaded))
-    except Exception:
-        pass
+    # Startup: (removed) automatic HTTP queue flush for error reports to simplify UX
 
     # Show message if new records were found during boot-time scan. TODO we need this to use the 'Last acknowledgements update:' timestamp to decide if it has already run in the last day so 
     # that we're not running it multiple times in rapid succession automatically. (user-initiated checks are fine like via selection of (1. Check for new remittances))
@@ -256,8 +263,8 @@ def main_menu():
                     _last_ack_updated_at = now_ts
                     # remove executed
                     _scheduled_ack_checks = [t for t in _scheduled_ack_checks if t > now_ts]
-        except Exception:
-            pass
+        except Exception as e:
+            _safe_log("Scheduled acknowledgements check skipped: {}".format(e), level="WARNING")
 
         # Define static menu options for consistent numbering
         options = ["Check for new remittances", "Submit claims", "Exit", "Tools"]
@@ -269,8 +276,8 @@ def main_menu():
             if _last_ack_updated_at:
                 ts_str = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(_last_ack_updated_at))
                 print("Last acknowledgements update: {}".format(ts_str))
-        except Exception:
-            pass
+        except Exception as e:
+            _safe_debug("Display of last ack update failed: {}".format(e))
         MediLink_UI.display_menu(options)
         menu_display_end = time.time()
         if PERFORMANCE_LOGGING:
@@ -483,33 +490,33 @@ if __name__ == "__main__":
         print("\nOperation cancelled by user.")
         exit_code = 1
     except Exception as e:
-        # Unexpected error: still avoid full traceback, present succinct notice
         sys.stderr.write("An unexpected error occurred; process halted.\n")
         sys.stderr.write(str(e) + "\n")
-        # Offer to create and submit an error report
-        try:
-            ans = input("Create and submit an error report now? (y/N): ").strip().lower()
-        except Exception:
-            ans = 'n'
-        if ans in ['y', 'yes']:
-            try:
-                from MediCafe.error_reporter import collect_support_bundle, submit_support_bundle
-                zip_path = collect_support_bundle(include_traceback=True)
-                if not zip_path:
-                    print("Failed to create support bundle.")
-                else:
-                    ok = submit_support_bundle(zip_path)
-                    if ok:
-                        print("Report submitted successfully.")
+        from MediCafe.error_reporter import collect_support_bundle
+        zip_path = collect_support_bundle(include_traceback=True)
+        if not zip_path:
+            print("Failed to create bundle - exiting.")
+            exit_code = 1
+        else:
+            from MediLink.MediLink_Up import check_internet_connection
+            online = check_internet_connection()
+            if online:
+                success = submit_support_bundle_email(zip_path)
+                if not success:
+                    print("Send failed - bundle discarded.")
+            else:
+                ans = input("Offline. Connect to internet, then press Y to retry or N to discard: ").strip().lower()
+                if ans == 'y':
+                    online = check_internet_connection()
+                    if online:
+                        success = submit_support_bundle_email(zip_path)
+                        if not success:
+                            print("Send failed - bundle discarded.")
                     else:
-                        print("Submission failed. Bundle saved at {} for later retry.".format(zip_path))
-            except Exception as _erre:
-                print("Error while creating/submitting report: {}".format(_erre))
-        sys.stderr.write("\nPress Enter to exit...\n")
-        try:
-            input()
-        except Exception:
-            pass
+                        print("Still offline - discarding.")
+                else:
+                    print("Discarding.")
+            os.remove(zip_path) if os.path.exists(zip_path) else None
         exit_code = 1
     finally:
         if exit_code == 0 and PERFORMANCE_LOGGING:

MediLink/MediLink_smart_import.py

@@ -55,8 +55,9 @@ except Exception as e:
         medilink_ui = None
         medilink_patient_processor = None
         print("[+] Fallback to core components")
-    except:
-        print("[-] Smart import system not available")
+    except Exception as e:
+        # Keep non-blocking behavior; include reason for easier debugging
+        print("[-] Smart import system not available: {}".format(e))
         api_core = None
         logging_config = None
         core_utils = None

MediLink/__init__.py

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

{medicafe-0.251017.1.dist-info → medicafe-0.251026.0.dist-info}/METADATA

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

{medicafe-0.251017.1.dist-info → medicafe-0.251026.0.dist-info}/RECORD

@@ -1,18 +1,18 @@
-MediBot/MediBot.bat,sha256=dWBZ2__t1uPvEuN76ETOD_mDo7368rP3tDrJd4MHCFY,26306
-MediBot/MediBot.py,sha256=9kpNZdNg3awxj0Oa5AszSZrcmyqhPZ0FHeYRHOeumBw,48750
+MediBot/MediBot.bat,sha256=vWcKZK7MdNIAnGpvpaSglN5DiAlKJVBpdtYwfQfpSQA,28234
+MediBot/MediBot.py,sha256=ABSqWikb_c1VSuR4n8Vh5YfOqzDCi2jnnp3sg_xOYg0,51092
 MediBot/MediBot_Charges.py,sha256=a28if_f_IoazIHiqlaFosFnfEgEoCwb9LQ6aOyk5-D0,10704
 MediBot/MediBot_Crosswalk_Library.py,sha256=6LrpRx2UKVeH3TspS9LpR93iw5M7nTqN6IYpC-6PPGE,26060
 MediBot/MediBot_Crosswalk_Utils.py,sha256=dFJRB_8q0iiAxZ2GY-2HsMl5Z7FvkXezzwx6LZoAglI,39589
 MediBot/MediBot_Notepad_Utils.py,sha256=fOsjyfoSpgmQyc8TcnLm53faLMOUUL18cspo5PZqJK4,8719
 MediBot/MediBot_Post.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 MediBot/MediBot_Preprocessor.py,sha256=gQRVAWbRHx_PMK6a7q93tp7Z-Dhjn5r0lJz3d0wAzeU,19067
-MediBot/MediBot_Preprocessor_lib.py,sha256=ELG0x8DSbByGbnoLOgiztzkYRBekiPb0BmxGw3cic1c,89210
+MediBot/MediBot_Preprocessor_lib.py,sha256=UsUUoleKvWsykIfOvOWwoPHNsWkxfegK20mtN8F4eLs,94583
 MediBot/MediBot_UI.py,sha256=tQISM2gULmQVc4JbeVsn4pjgOYsQZiJpx1_IU407rO8,25870
 MediBot/MediBot_dataformat_library.py,sha256=D46fdPtxcgfWTzaLBtSvjtozzZBNqNiODgu4vKMZrBg,10746
 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=tPc3GRS2hYeSa5NEwTCpUOiplwJyo9DZvaiQBvuaDzU,3192
+MediBot/__init__.py,sha256=n9eH1i-SUxoIZz_mxReofqPsZKeOCtWKIIL8cd9XbSg,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
@@ -21,16 +21,16 @@ MediBot/get_medicafe_version.py,sha256=uyL_UIE42MyFuJ3SRYxJp8sZx8xjTqlYZ3FdQuxLd
 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=ya-2HryLmR_NeJXCktxeWdfoFvaI3NK7obHmRu6-A5M,5721
+MediCafe/MediLink_ConfigLoader.py,sha256=5AWsiy99WFcESXkzKbftT5afAoMygmb5-d0bER9TZSU,11419
+MediCafe/__init__.py,sha256=_Eh2UabfrQ1hrTeW1LQA7ovRn13NBmR7jzzSmQwIK9c,5721
 MediCafe/__main__.py,sha256=mRNyk3D9Ilnu2XhgVI_rut7r5Ro7UIKtwV871giAHI8,12992
-MediCafe/api_core.py,sha256=r9cqa5-HU4A7iz3NLxzRwuxsxOfDiJn9SRgtPjT83qU,90764
+MediCafe/api_core.py,sha256=wLAdRNZdmovKReXvzsmAgKrbYon4-wbJbGCyOm_C3AU,89896
 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=-ixDYwI3JNAyACrFjKqoX_hD3Awzownq441U0PSrwXw,64932
-MediCafe/error_reporter.py,sha256=t9AAkkVsmZMxPMSA6DW7wDf2cxXpFfA9oJW5-thg5VQ,8176
-MediCafe/graphql_utils.py,sha256=3BYl4wrox40063RwCtIqsrxSMA5rdchCP69RGi-U4aY,51317
+MediCafe/error_reporter.py,sha256=TfRih7pOiopLoYKf--20-Q3q_FCFGEvUw85k3QmlzZ4,8413
+MediCafe/graphql_utils.py,sha256=jo4CboMb9i5_qD0jkfrLbL87_Q3aFiwOntZhjF9fMsI,51928
 MediCafe/logging_config.py,sha256=auT65LN5oDEXVhkMeLke63kJHTWxYf2o8YihAfQFgzU,5493
 MediCafe/logging_demo.py,sha256=TwUhzafna5pMdN3zSKGrpUWRqX96F1JGGsSUtr3dygs,1975
 MediCafe/migration_helpers.py,sha256=48GnP4xcgvDNNlzoWsKASCpF4H0KnyveHPbz6kjQy50,17737
@@ -47,31 +47,31 @@ 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=8Npibnv4p7HDGhz8t7bf760lbkGbV3fMVIfKjNgxYjA,68168
+MediLink/MediLink_Deductible.py,sha256=opGa5YQ6tfowurlf8xDWRtAtQMmoNYout0gYe3R5fUE,69537
 MediLink/MediLink_Deductible_Validator.py,sha256=x6tHJOi88TblUpDPSH6QhIdXXRgr3rXI7kYPVGZYCgU,24998
 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=KnTm7Z_Q5B1n9hNtCR00wDWWWmRVf86f-JtKdZKRKpA,28637
+MediLink/MediLink_Gmail.py,sha256=zJI-pD9cfOhI7M3jJMQ6rrwnzT5wWmSMrI9DcvtXjNw,28688
 MediLink/MediLink_Mailer.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 MediLink/MediLink_Parser.py,sha256=eRVZ4ckZ5gDOrcvtCUZP3DOd3Djly66rCIk0aYXLz14,12567
 MediLink/MediLink_PatientProcessor.py,sha256=9r2w4p45d30Tn0kbXL3j5574MYOehP83tDirNOw_Aek,19977
 MediLink/MediLink_Scan.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 MediLink/MediLink_Scheduler.py,sha256=UJvxhDvHraqra2_TlQVlGeh5jRFrrfK6nCVUHnKOEMY,38
 MediLink/MediLink_UI.py,sha256=ZEJ14EGh7pDu1XjAdORDFiay4UtTsLNWwNSJ0prHFWg,10381
-MediLink/MediLink_Up.py,sha256=uB6J63hWOn8Ot8iGtc2_OgcejNWVgnX7Se_e_UWBNho,38082
+MediLink/MediLink_Up.py,sha256=rzhzmWa4F_el37bDlSauFl_08m-dWz2xiflf-vVRkwg,38453
 MediLink/MediLink_insurance_utils.py,sha256=g741Fj2K26cMy0JX5d_XavMw9LgkK6hjaUJYfysT7t8,9301
-MediLink/MediLink_main.py,sha256=CAXu0IRzhra3ppIFDcCppFNAZp7kCuN6gPtJSdFqGzs,24857
-MediLink/MediLink_smart_import.py,sha256=B5SfBn_4bYEWJJDolXbjnwKx_-MaqGZ76LyXQwWDV80,9838
+MediLink/MediLink_main.py,sha256=bKCV_EDwc3DxQPFp5p0Lwy_cGXM3pexIA0HUhyAAtzw,25342
+MediLink/MediLink_smart_import.py,sha256=ZUXvAkIA2Pk2uuyLZazKfKK8YGdkZt1VAeZo_ZSUyxk,9942
 MediLink/Soumit_api.py,sha256=5JfOecK98ZC6NpZklZW2AkOzkjvrbYxpJpZNH3rFxDw,497
-MediLink/__init__.py,sha256=wN-T-InivqDJu-lk3TyAyx6-ozGaDOsqbqBSLQWo4zw,3888
+MediLink/__init__.py,sha256=AzRCYizAUAcX8EnSBzpU8dWGLewh3sx-S1ooKPtowGc,3888
 MediLink/gmail_http_utils.py,sha256=mYChIhkbA1oJaAJA-nY3XgHQY-H7zvZJUZPhUagomsI,4047
 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=DwDYjVvluGJ7eDdvEogfKN4t24ZJRoIUuSBfCYCL-3w,21252
-medicafe-0.251017.1.dist-info/LICENSE,sha256=65lb-vVujdQK7uMH3RRJSMwUW-WMrMEsc5sOaUn2xUk,1096
-medicafe-0.251017.1.dist-info/METADATA,sha256=55QUT57-HhWixs_lDUf-5pEre_oqUdEIJtvWJUPaL0M,3414
-medicafe-0.251017.1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-medicafe-0.251017.1.dist-info/entry_points.txt,sha256=m3RBUBjr-xRwEkKJ5W4a7NlqHZP_1rllGtjZnrRqKe8,52
-medicafe-0.251017.1.dist-info/top_level.txt,sha256=U6-WBJ9RCEjyIs0BlzbQq_PwedCp_IV9n1616NNV5zA,26
-medicafe-0.251017.1.dist-info/RECORD,,
+medicafe-0.251026.0.dist-info/LICENSE,sha256=65lb-vVujdQK7uMH3RRJSMwUW-WMrMEsc5sOaUn2xUk,1096
+medicafe-0.251026.0.dist-info/METADATA,sha256=_UOU1GmZO36NbpKgD7pwHoqyKolvBmDRgnj3FHQdLgo,3414
+medicafe-0.251026.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+medicafe-0.251026.0.dist-info/entry_points.txt,sha256=m3RBUBjr-xRwEkKJ5W4a7NlqHZP_1rllGtjZnrRqKe8,52
+medicafe-0.251026.0.dist-info/top_level.txt,sha256=U6-WBJ9RCEjyIs0BlzbQq_PwedCp_IV9n1616NNV5zA,26
+medicafe-0.251026.0.dist-info/RECORD,,