medicafe 0.250909.0__py3-none-any.whl → 0.250920.0__py3-none-any.whl

MediBot/__init__.py

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

MediCafe/MediLink_ConfigLoader.py

@@ -33,6 +33,13 @@ def get_default_config():
                 'level': 'INFO',
                 'console_output': True
             },
+            'error_reporting': {
+                'enabled': False,
+                'endpoint_url': '',
+                'auth_token': '',
+                'insecure_http': False,
+                'max_bundle_bytes': 2097152
+            },
             # STRATEGIC NOTE (COB Configuration): COB library is fully implemented and ready
             # To enable COB functionality, add the following configuration:
             # 'cob_settings': {

MediCafe/__init__.py

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

MediCafe/error_reporter.py

@@ -0,0 +1,287 @@
+import os, sys, time, json, zipfile, hashlib, platform
+
+try:
+	import requests
+except Exception:
+	requests = None
+
+from MediCafe.MediLink_ConfigLoader import load_configuration, log as mc_log
+
+
+ASCII_SAFE_REPLACEMENTS = [
+	('"', '"'),
+	("'", "'"),
+]
+
+
+def _safe_ascii(text):
+	try:
+		if text is None:
+			return ''
+		if isinstance(text, bytes):
+			try:
+				text = text.decode('ascii', 'ignore')
+			except Exception:
+				text = text.decode('utf-8', 'ignore')
+		else:
+			text = str(text)
+		return text.encode('ascii', 'ignore').decode('ascii', 'ignore')
+	except Exception:
+		return ''
+
+
+def _tail_file(path, max_lines):
+	lines = []
+	try:
+		with open(path, 'r') as f:
+			for line in f:
+				lines.append(line)
+				if len(lines) > max_lines:
+					lines.pop(0)
+		return ''.join(lines)
+	except Exception:
+		return ''
+
+
+def _get_latest_log_path(local_storage_path):
+	try:
+		files = []
+		for name in os.listdir(local_storage_path or '.'):
+			if name.startswith('Log_') and name.endswith('.log'):
+				files.append(os.path.join(local_storage_path, name))
+		if not files:
+			return None
+		files.sort(key=lambda p: os.path.getmtime(p))
+		return files[-1]
+	except Exception:
+		return None
+
+
+def _redact(text):
+	# Best-effort ASCII redaction: mask obvious numeric IDs and bearer tokens
+	try:
+		text = _safe_ascii(text)
+		import re
+		patterns = [
+			(r'\b(\d{3}-?\d{2}-?\d{4})\b', '***-**-****'),
+			(r'\b(\d{9,11})\b', '*********'),
+			(r'Bearer\s+[A-Za-z0-9\-._~+/]+=*', 'Bearer ***'),
+			(r'Authorization:\s*[^\n\r]+', 'Authorization: ***'),
+		]
+		for pat, rep in patterns:
+			text = re.sub(pat, rep, text)
+		return text
+	except Exception:
+		return text
+
+
+def _ensure_dir(path):
+	try:
+		if not os.path.exists(path):
+			os.makedirs(path)
+		return True
+	except Exception:
+		return False
+
+
+def _compute_report_id(zip_path):
+	try:
+		h = hashlib.sha256()
+		with open(zip_path, 'rb') as f:
+			chunk = f.read(256 * 1024)
+			h.update(chunk)
+		return 'mc-{}-{}'.format(int(time.time()), h.hexdigest()[:12])
+	except Exception:
+		return 'mc-{}-{}'.format(int(time.time()), '000000000000')
+
+
+def collect_support_bundle(include_traceback=True, max_log_lines=2000):
+	config, _ = load_configuration()
+	medi = config.get('MediLink_Config', {})
+	local_storage_path = medi.get('local_storage_path', '.')
+	queue_dir = os.path.join(local_storage_path, 'reports_queue')
+	_ensure_dir(queue_dir)
+
+	stamp = time.strftime('%Y%m%d_%H%M%S')
+	bundle_name = 'support_report_{}.zip'.format(stamp)
+	zip_path = os.path.join(queue_dir, bundle_name)
+
+	latest_log = _get_latest_log_path(local_storage_path)
+	log_tail = _tail_file(latest_log, max_log_lines) if latest_log else ''
+	log_tail = _redact(log_tail)
+
+	traceback_txt = ''
+	if include_traceback:
+		try:
+			trace_path = os.path.join(local_storage_path, 'traceback.txt')
+			if os.path.exists(trace_path):
+				with open(trace_path, 'r') as tf:
+					traceback_txt = _redact(tf.read())
+		except Exception:
+			traceback_txt = ''
+
+	meta = {
+		'app_version': _safe_ascii(_get_version()),
+		'python_version': _safe_ascii(sys.version.split(' ')[0]),
+		'platform': _safe_ascii(platform.platform()),
+		'timestamp': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()),
+		'error_summary': _safe_ascii(_first_line(traceback_txt)),
+		'traceback_present': bool(traceback_txt),
+		'config_flags': {
+			'console_logging': bool(medi.get('logging', {}).get('console_output', False)),
+			'test_mode': bool(medi.get('TestMode', False))
+		}
+	}
+
+	try:
+		with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as z:
+			z.writestr('meta.json', json.dumps(meta, ensure_ascii=True, indent=2))
+			if latest_log and log_tail:
+				z.writestr('log_tail.txt', log_tail)
+			if traceback_txt:
+				z.writestr('traceback.txt', traceback_txt)
+			z.writestr('README.txt', _readme_text())
+		return zip_path
+	except Exception as e:
+		mc_log('Error creating support bundle: {}'.format(e), level='ERROR')
+		return None
+
+
+def _first_line(text):
+	try:
+		for line in (text or '').splitlines():
+			line = line.strip()
+			if line:
+				return line[:200]
+		return ''
+	except Exception:
+		return ''
+
+
+def _readme_text():
+	return (
+		"MediCafe Support Bundle\n\n"
+		"This archive contains a redacted log tail, optional traceback, and metadata.\n"
+		"You may submit this bundle automatically from the app or send it manually to support.\n"
+	)
+
+
+def _get_version():
+	try:
+		from MediCafe import __version__
+		return __version__
+	except Exception:
+		return 'unknown'
+
+
+def submit_support_bundle(zip_path):
+	config, _ = load_configuration()
+	medi = config.get('MediLink_Config', {})
+	rep = medi.get('error_reporting', {}) if isinstance(medi, dict) else {}
+	endpoint_url = _safe_ascii(rep.get('endpoint_url', ''))
+	auth_token = _safe_ascii(rep.get('auth_token', ''))
+	insecure = bool(rep.get('insecure_http', False))
+	max_bytes = int(rep.get('max_bundle_bytes', 2097152))
+
+	if not requests:
+		print("[ERROR] requests module not available; cannot submit report.")
+		return False
+	if not endpoint_url:
+		print("[ERROR] error_reporting.endpoint_url not configured.")
+		return False
+	if not os.path.exists(zip_path):
+		print("[ERROR] Bundle not found: {}".format(zip_path))
+		return False
+	try:
+		size = os.path.getsize(zip_path)
+		if size > max_bytes:
+			print("[INFO] Bundle size {} exceeds cap {}; rebuilding smaller not implemented here.".format(size, max_bytes))
+	except Exception:
+		pass
+
+	report_id = _compute_report_id(zip_path)
+	headers = {
+		'X-Auth-Token': auth_token or '',
+		'X-Report-Id': report_id,
+		'User-Agent': 'MediCafe-Reporter/1.0'
+	}
+
+	# Prepare meta.json stream derived from inside the zip for server convenience
+	meta_json = '{}'
+	try:
+		with zipfile.ZipFile(zip_path, 'r') as z:
+			if 'meta.json' in z.namelist():
+				meta_json = z.read('meta.json')
+	except Exception:
+		meta_json = '{}'
+
+	try:
+		bundle_fh = open(zip_path, 'rb')
+		files = {
+			'meta': ('meta.json', meta_json, 'application/json'),
+			'bundle': (os.path.basename(zip_path), bundle_fh, 'application/zip')
+		}
+		r = requests.post(endpoint_url, headers=headers, files=files, timeout=(10, 20), verify=(not insecure))
+		code = getattr(r, 'status_code', None)
+		if code == 200:
+			print("[SUCCESS] Report submitted. ID: {}".format(report_id))
+			return True
+		elif code == 401:
+			print("[ERROR] Unauthorized (401). Check error_reporting.auth_token.")
+			return False
+		elif code == 413:
+			print("[ERROR] Too large (413). Consider reducing max log lines.")
+			return False
+		else:
+			print("[ERROR] Submission failed with status {}".format(code))
+			return False
+	except Exception as e:
+		print("[ERROR] Submission exception: {}".format(e))
+		return False
+	finally:
+		try:
+			bundle_fh.close()
+		except Exception:
+			pass
+
+
+def flush_queued_reports():
+	config, _ = load_configuration()
+	medi = config.get('MediLink_Config', {})
+	local_storage_path = medi.get('local_storage_path', '.')
+	queue_dir = os.path.join(local_storage_path, 'reports_queue')
+	if not os.path.isdir(queue_dir):
+		return 0, 0
+	count_ok = 0
+	count_total = 0
+	for name in sorted(os.listdir(queue_dir)):
+		if not name.endswith('.zip'):
+			continue
+		zip_path = os.path.join(queue_dir, name)
+		count_total += 1
+		print("Attempting upload of queued report: {}".format(name))
+		ok = submit_support_bundle(zip_path)
+		if ok:
+			try:
+				os.remove(zip_path)
+			except Exception:
+				pass
+			count_ok += 1
+	return count_ok, count_total
+
+
+def capture_unhandled_traceback(exc_type, exc_value, exc_traceback):
+	try:
+		config, _ = load_configuration()
+		medi = config.get('MediLink_Config', {})
+		local_storage_path = medi.get('local_storage_path', '.')
+		trace_path = os.path.join(local_storage_path, 'traceback.txt')
+		import traceback
+		text = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+		text = _redact(text)
+		with open(trace_path, 'w') as f:
+			f.write(text)
+		print("An error occurred. A traceback was saved to {}".format(trace_path))
+	except Exception:
+		pass
+

MediLink/MediLink_Deductible.py

@@ -390,17 +390,50 @@ def manual_deductible_lookup():
                     # Already processed data from merge_responses
                     enhanced_result = eligibility_data
                 elif convert_eligibility_to_enhanced_format is not None:
+                    # Attempt CSV backfill context for manual route
+                    csv_row = patient_row_index.get((formatted_dob, member_id))
+                    derived_patient_id = ""
+                    derived_service_date = ""
+                    if csv_row:
+                        try:
+                            derived_patient_id = str(csv_row.get('Patient ID #2', csv_row.get('Patient ID', '')))
+                            derived_service_date = str(csv_row.get('Service Date', ''))
+                        except Exception:
+                            derived_patient_id = ""
+                            derived_service_date = ""
                     # Raw API data needs conversion with patient info
-                    enhanced_result = convert_eligibility_to_enhanced_format(eligibility_data, formatted_dob, member_id, "", "")
+                    enhanced_result = convert_eligibility_to_enhanced_format(
+                        eligibility_data, formatted_dob, member_id, derived_patient_id, derived_service_date
+                    )
                 else:
                     # Fallback if utility function not available
                     enhanced_result = None
                 if enhanced_result:
                     try:
                         # Backfill with CSV row data when available
-                        enhanced_result = backfill_enhanced_result(enhanced_result, None)
+                        csv_row = patient_row_index.get((formatted_dob, member_id))
+                        enhanced_result = backfill_enhanced_result(enhanced_result, csv_row)
+                    except Exception:
+                        pass
+                    # Ensure patient_id present; warn/log and set surrogate if missing
+                    try:
+                        pid = str(enhanced_result.get('patient_id', '')).strip()
+                        if not pid:
+                            surrogate = "{}:{}".format(formatted_dob, member_id)
+                            enhanced_result['patient_id'] = surrogate
+                            print("Warning: Missing Patient ID; using surrogate key {}".format(surrogate))
+                            MediLink_ConfigLoader.log(
+                                "Manual lookup: Missing Patient ID; using surrogate key {}".format(surrogate),
+                                level="WARNING"
+                            )
                     except Exception:
                         pass
+                    # Ensure patient_name not blank
+                    try:
+                        if not str(enhanced_result.get('patient_name', '')).strip():
+                            enhanced_result['patient_name'] = 'Unknown Patient'
+                    except Exception:
+                        enhanced_result['patient_name'] = 'Unknown Patient'
                     print("\n" + "=" * 60)
                     display_enhanced_deductible_table([enhanced_result], context="post_api", 
                                                     title="Manual Lookup Result")
@@ -441,7 +474,18 @@ def manual_deductible_lookup():
                         "Patient Name", "DOB", "Insurance Type", "PayID", "Policy Status", "Remaining Amt")
                     output_file.write(table_header + "\n")
                     output_file.write("-" * len(table_header) + "\n")
-                    display_eligibility_info(eligibility_data, formatted_dob, member_id, output_file)
+                    # Write directly from enhanced_result to ensure CSV backfill/defaults are preserved
+                    if enhanced_result:
+                        table_row = "{:<20} | {:<10} | {:<40} | {:<5} | {:<14} | {:<14}".format(
+                            enhanced_result['patient_name'][:20],
+                            enhanced_result['dob'],
+                            enhanced_result['insurance_type'][:40],
+                            enhanced_result['payer_id'][:5],
+                            enhanced_result['policy_status'][:14],
+                            enhanced_result['remaining_amount'][:14])
+                        output_file.write(table_row + "\n")
+                    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()

MediLink/MediLink_Display_Utils.py

@@ -177,6 +177,20 @@ def _normalize_pre_api_data(row):
         member_id = row.get('Primary Policy Number', row.get('Ins1 Member ID', '')).strip()
         payer_id = row.get('Ins1 Payer ID', '')
         patient_id = row.get('Patient ID #2', row.get('Patient ID', ''))
+
+        # Surrogate key and warnings if patient_id missing/blank
+        if not str(patient_id).strip():
+            surrogate = "{}:{}".format(dob, member_id)
+            patient_id = surrogate
+            try:
+                # Print visible warning and log as WARNING event
+                print("Warning: Missing Patient ID in CSV row; using surrogate key {}".format(surrogate))
+                MediLink_ConfigLoader.log(
+                    "Missing Patient ID in CSV; using surrogate key {}".format(surrogate),
+                    level="WARNING"
+                )
+            except Exception:
+                pass
         
         return {
             'patient_id': str(patient_id),
@@ -200,7 +214,7 @@ def _normalize_post_api_data(eligibility_result):
     try:
         # Handle the enhanced format that comes from convert_eligibility_to_enhanced_format
         if isinstance(eligibility_result, dict):
-            return {
+            normalized = {
                 'patient_id': str(eligibility_result.get('patient_id', '')),
                 'patient_name': str(eligibility_result.get('patient_name', '')),
                 'dob': str(eligibility_result.get('dob', '')),
@@ -214,6 +228,28 @@ def _normalize_post_api_data(eligibility_result):
                 'remaining_amount': str(eligibility_result.get('remaining_amount', '')),
                 'data_source': str(eligibility_result.get('data_source', ''))
             }
+
+            # Default unknown patient name when blank
+            try:
+                if not normalized['patient_name'].strip():
+                    normalized['patient_name'] = 'Unknown Patient'
+            except Exception:
+                normalized['patient_name'] = 'Unknown Patient'
+
+            # Surrogate key and warnings if patient_id missing/blank
+            try:
+                if not normalized['patient_id'].strip():
+                    surrogate = "{}:{}".format(normalized.get('dob', ''), normalized.get('member_id', ''))
+                    normalized['patient_id'] = surrogate
+                    print("Warning: Missing Patient ID in eligibility result; using surrogate key {}".format(surrogate))
+                    MediLink_ConfigLoader.log(
+                        "Missing Patient ID in eligibility result; using surrogate key {}".format(surrogate),
+                        level="WARNING"
+                    )
+            except Exception:
+                pass
+
+            return normalized
         else:
             MediLink_ConfigLoader.log("Unexpected eligibility result format: {}".format(type(eligibility_result)), level="WARNING")
             return None

MediLink/MediLink_Gmail.py

@@ -185,10 +185,30 @@ class RequestHandler(BaseHTTPRequestHandler):
             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)
+            # Only delete files that actually downloaded successfully
+            downloaded_names = load_downloaded_emails()
+            successful_ids = []
+            try:
+                name_to_id = { (link.get('filename') or ''): link.get('fileId') for link in links if link.get('fileId') }
+                for name in downloaded_names:
+                    fid = name_to_id.get(name)
+                    if fid:
+                        successful_ids.append(fid)
+            except Exception as e:
+                log("Error computing successful file IDs for cleanup: {}".format(e))
+                successful_ids = file_ids  # Fallback: attempt all provided IDs
+            # Trigger cleanup in Apps Script with auth
+            try:
+                if successful_ids:
+                    send_delete_request_to_gas(successful_ids)
+                else:
+                    log("No successful file IDs to delete after download.")
+            except Exception as e:
+                log("Cleanup trigger failed: {}".format(e))
             self.send_response(200)
             self._set_headers()
             self.end_headers()
-            response = json.dumps({"status": "success", "message": "All files downloaded", "fileIds": file_ids})
+            response = json.dumps({"status": "success", "message": "All files downloaded", "fileIds": successful_ids})
             self.wfile.write(response.encode('utf-8'))
             shutdown_event.set()
             bring_window_to_foreground()
@@ -437,6 +457,38 @@ def handle_post_response(url, payload, headers):
         log("Unexpected error during link retrieval initiation: {}".format(e))
         shutdown_event.set()
 
+def send_delete_request_to_gas(file_ids):
+    """Send a delete_files action to the Apps Script web app for the provided Drive file IDs.
+    Relies on OAuth token previously obtained. Sends user notifications via GAS.
+    """
+    try:
+        medi = extract_medilink_config(config)
+        url = "https://script.google.com/macros/s/{}/exec".format(medi.get('webapp_deployment_id', ''))
+        access_token = get_access_token()
+        if not access_token:
+            log("Access token not found. Skipping cleanup request to GAS.")
+            return
+        headers = {'Authorization': 'Bearer {}'.format(access_token), 'Content-Type': 'application/json'}
+        payload = {"action": "delete_files", "fileIds": list(file_ids)}
+        log("Initiating cleanup request to GAS. Payload size: {} id(s)".format(len(file_ids)))
+        resp = requests.post(url, json=payload, headers=headers)
+        log("Cleanup response status: {}".format(resp.status_code))
+        # Print a concise console message
+        if resp.ok:
+            try:
+                body = resp.json()
+                msg = body.get('message', 'Files deleted successfully') if isinstance(body, dict) else 'Files deleted successfully'
+            except Exception:
+                msg = 'Files deleted successfully'
+            print("Cleanup complete: {} ({} file(s))".format(msg, len(file_ids)))
+        else:
+            print("Cleanup failed with status {}: {}".format(resp.status_code, resp.text))
+        if resp.status_code != 200:
+            raise RuntimeError("Cleanup request failed with status {}".format(resp.status_code))
+    except Exception as e:
+        log("Error sending delete request to GAS: {}".format(e))
+        print("Cleanup request error: {}".format(e))
+
 def inspect_token(access_token):
     return http_inspect_token(access_token, log, delete_token_file_fn=delete_token_file, stop_server_fn=stop_server)
 

MediLink/MediLink_main.py

@@ -22,6 +22,7 @@ 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
 setup_module_paths(__file__)
 
 # Import modules after path setup
@@ -57,6 +58,8 @@ def _tools_menu(config, medi):
         print("\nMaintenance Tools:")
         options = [
             "Rebuild submission index now",
+            "Submit Error Report (online)",
+            "Create Support Bundle (offline)",
             "Back"
         ]
         MediLink_UI.display_menu(options)
@@ -75,6 +78,27 @@ def _tools_menu(config, medi):
             except Exception as e:
                 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.")
+                else:
+                    ok = submit_support_bundle(zip_path)
+                    if not ok:
+                        print("Submission failed. Bundle saved at {} for later retry.".format(zip_path))
+            except Exception as e:
+                print("Error during 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()
@@ -167,6 +191,15 @@ 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
+
     # 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))
     if ack_result:
@@ -428,6 +461,11 @@ if __name__ == "__main__":
     total_start_time = time.time()
     exit_code = 0
     try:
+        # Install unhandled exception hook to capture tracebacks
+        try:
+            sys.excepthook = capture_unhandled_traceback
+        except Exception:
+            pass
         main_menu()
     except ValueError as e:
         # Graceful domain error: show concise message without traceback, then exit
@@ -448,6 +486,25 @@ if __name__ == "__main__":
         # 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.")
+                    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()

MediLink/__init__.py

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

MediLink/webapp.html

@@ -402,6 +402,7 @@
                         links: downloadLinks.map(link => ({
                             url: link.url,
                             filename: link.filename,
+                            fileId: link.fileId,
                         }))
                     }),
                     mode: 'cors'  // Ensure the request includes CORS headers

{medicafe-0.250909.0.dist-info → medicafe-0.250920.0.dist-info}/METADATA

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

{medicafe-0.250909.0.dist-info → medicafe-0.250920.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=S5Y80QAjAxFKJn6Uz9KNzNHXEHjCU0boj0joB8JcPlc,3192
+MediBot/__init__.py,sha256=YeIJIhZaVER4TBToGej_8967Kliu4v7zuGGsLVF9DTo,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,14 +21,15 @@ 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=zzI3cFe2_TdwgIW_UAVmY_LFFlLLdlmpCokouUqx6u0,10898
-MediCafe/__init__.py,sha256=U8Vg_cQIvjHI-ynz8513QPOIAUsTvWRlj0aYnbvSAWQ,5721
+MediCafe/MediLink_ConfigLoader.py,sha256=NoLb2YiJwlkrRYCt2PHvcFJ7yTIRWQCrsvkZIJWreM4,11141
+MediCafe/__init__.py,sha256=21mCrtgBzffbvGpa_eKEEE_BZTwlO1XygnJFKk3Xa7I,5721
 MediCafe/__main__.py,sha256=mRNyk3D9Ilnu2XhgVI_rut7r5Ro7UIKtwV871giAHI8,12992
 MediCafe/api_core.py,sha256=yNFfLO70bF91NNBLSUADYWZFkR5yh8NctxnT98fkAxk,78515
 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=bsI5YRO8QzaEU-sxi2F5zIx6k4D53rYUt0mlg-6-Jc8,57644
+MediCafe/error_reporter.py,sha256=t9AAkkVsmZMxPMSA6DW7wDf2cxXpFfA9oJW5-thg5VQ,8176
 MediCafe/graphql_utils.py,sha256=xrREl0mqktEBkV6SZeAImuuDc8Sp2Q80rWxKIh-zD7Q,44499
 MediCafe/logging_config.py,sha256=auT65LN5oDEXVhkMeLke63kJHTWxYf2o8YihAfQFgzU,5493
 MediCafe/logging_demo.py,sha256=TwUhzafna5pMdN3zSKGrpUWRqX96F1JGGsSUtr3dygs,1975
@@ -46,11 +47,11 @@ MediLink/MediLink_Charges.py,sha256=82fnqHGvT7tfdfjucnFHiLdUE0WhHDXrcS0k_Ln3c8U,
 MediLink/MediLink_ClaimStatus.py,sha256=75LzWfYaxrLWelId-8rHHN_lchHXxAe34pRgvKPdP2o,22118
 MediLink/MediLink_DataMgmt.py,sha256=9hc5jyWU65nYT66afDybOyYAcW-DvEYuHpWTun96U50,52407
 MediLink/MediLink_Decoder.py,sha256=1gzdybNg4Vv69s5PNbX8bPNrXT_N_kPpFpt2HpkauWA,16430
-MediLink/MediLink_Deductible.py,sha256=e_Oi5c55g4fTcPf-2hLnIRJ_Q_pBAyyXnTKiciQULd8,55208
+MediLink/MediLink_Deductible.py,sha256=8EaJpJICcWcWL_Oge646bXE9STJhvbfIEmHl-5y-DMo,57937
 MediLink/MediLink_Deductible_Validator.py,sha256=1h5GJ9jbcVarxd6a-lKPEOhJYz4QkeeBlHw0Zdd9vUU,24855
-MediLink/MediLink_Display_Utils.py,sha256=a0t1VU9Mm_vhsXVTEA1EpUlElrnyie4XaCeif7GwRgw,21213
+MediLink/MediLink_Display_Utils.py,sha256=pZqd3KRck27zzwnGh_qN1NN1Q-2FF6NFBtRPSO-syiI,22899
 MediLink/MediLink_Down.py,sha256=s4_z-RaqHYanjwbQCl-OSkg4XIpcIQ2Q6jXa8-q_QXw,28111
-MediLink/MediLink_Gmail.py,sha256=8iQjqcJMSa_Zfr5azR0dShKAQeXqt-9C-s8seYB9pic,23961
+MediLink/MediLink_Gmail.py,sha256=muqZI3girXDu92KT5Nft7dLHtpnQAjH-QfvdcGo28_Y,26801
 MediLink/MediLink_Mailer.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 MediLink/MediLink_Parser.py,sha256=eRVZ4ckZ5gDOrcvtCUZP3DOd3Djly66rCIk0aYXLz14,12567
 MediLink/MediLink_PatientProcessor.py,sha256=9r2w4p45d30Tn0kbXL3j5574MYOehP83tDirNOw_Aek,19977
@@ -59,18 +60,18 @@ MediLink/MediLink_Scheduler.py,sha256=UJvxhDvHraqra2_TlQVlGeh5jRFrrfK6nCVUHnKOEM
 MediLink/MediLink_UI.py,sha256=ZEJ14EGh7pDu1XjAdORDFiay4UtTsLNWwNSJ0prHFWg,10381
 MediLink/MediLink_Up.py,sha256=uB6J63hWOn8Ot8iGtc2_OgcejNWVgnX7Se_e_UWBNho,38082
 MediLink/MediLink_insurance_utils.py,sha256=g741Fj2K26cMy0JX5d_XavMw9LgkK6hjaUJYfysT7t8,9301
-MediLink/MediLink_main.py,sha256=ZVK2UsgSxC9UqgIYfgVu95ugULcH6-11l67jsf4vdJc,22132
+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=Lr3cT-xyO8eyyoxqaKxcjR2CHxNL340JEdIHe_l1rd4,3888
+MediLink/__init__.py,sha256=CuY5EOeMChTnQRw-QptzIPfhDnczINCnApf9KKMC9bw,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=JPKT559aFVBi1r42Hz7C77Jj0teZZRumPhBev8eSOLk,19806
-medicafe-0.250909.0.dist-info/LICENSE,sha256=65lb-vVujdQK7uMH3RRJSMwUW-WMrMEsc5sOaUn2xUk,1096
-medicafe-0.250909.0.dist-info/METADATA,sha256=cWgYebKSTCUb2V3c-2TnjmCtUiG0lX8KxVY8g6OlY1g,3414
-medicafe-0.250909.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-medicafe-0.250909.0.dist-info/entry_points.txt,sha256=m3RBUBjr-xRwEkKJ5W4a7NlqHZP_1rllGtjZnrRqKe8,52
-medicafe-0.250909.0.dist-info/top_level.txt,sha256=U6-WBJ9RCEjyIs0BlzbQq_PwedCp_IV9n1616NNV5zA,26
-medicafe-0.250909.0.dist-info/RECORD,,
+MediLink/webapp.html,sha256=MI9zZ4y1_h5Ji3nz2fmm6Q29AsPunks-wR-R8Ct73-w,19856
+medicafe-0.250920.0.dist-info/LICENSE,sha256=65lb-vVujdQK7uMH3RRJSMwUW-WMrMEsc5sOaUn2xUk,1096
+medicafe-0.250920.0.dist-info/METADATA,sha256=hv7aYi-Y8jj_SHLywtNK3h63araet2cTqAEiiOZF3qc,3414
+medicafe-0.250920.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+medicafe-0.250920.0.dist-info/entry_points.txt,sha256=m3RBUBjr-xRwEkKJ5W4a7NlqHZP_1rllGtjZnrRqKe8,52
+medicafe-0.250920.0.dist-info/top_level.txt,sha256=U6-WBJ9RCEjyIs0BlzbQq_PwedCp_IV9n1616NNV5zA,26
+medicafe-0.250920.0.dist-info/RECORD,,