medicafe 0.251016.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.251016.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.251016.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

@@ -544,6 +544,11 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
             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")
@@ -568,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
@@ -642,10 +680,22 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
                 # Check status code
                 if super_connector_eligibility:
                     status_code = super_connector_eligibility.get('statuscode')
-                    if status_code is not None and str(status_code).strip() != '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):
@@ -670,6 +720,29 @@ 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
+                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")
@@ -772,24 +845,28 @@ def display_eligibility_info(data, dob, member_id, output_file, patient_id="", s
 
 # 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:
-        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
+        from MediCafe.deductible_utils import compute_error_reason
+        return compute_error_reason(record)
     except Exception:
-        return ""
+        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
@@ -1094,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:

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.251016.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.251016.0.dist-info → medicafe-0.251017.0.dist-info}/METADATA

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

{medicafe-0.251016.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=FZWJSZwXT7mV-SuC2nrJ4Bu8ihD-2ovcwi_cB_Q-wxE,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=836lZyypRMJOboD7D8PCWhdX1-qeiLYV8jIkOddN6ZU,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=zXywVRs5JuRVi_2e37vG25OR-0F8M4QPWjZtm7Oh9PE,62232
+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=HSxr33c98IfHHjLqOKA2edeqEaLPKTcjGDOyh4SbnCQ,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.251016.0.dist-info/LICENSE,sha256=65lb-vVujdQK7uMH3RRJSMwUW-WMrMEsc5sOaUn2xUk,1096
-medicafe-0.251016.0.dist-info/METADATA,sha256=azl9SAxSeR4LVnIoZ447V27-FdNaZO4KUddOKO2ofq4,3414
-medicafe-0.251016.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-medicafe-0.251016.0.dist-info/entry_points.txt,sha256=m3RBUBjr-xRwEkKJ5W4a7NlqHZP_1rllGtjZnrRqKe8,52
-medicafe-0.251016.0.dist-info/top_level.txt,sha256=U6-WBJ9RCEjyIs0BlzbQq_PwedCp_IV9n1616NNV5zA,26
-medicafe-0.251016.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,,