import gradio as gr from meldrx import MeldRxAPI import json import os import tempfile from datetime import datetime import traceback import logging from huggingface_hub import InferenceClient # Import InferenceClient from urllib.parse import urlparse, parse_qs # Import URL parsing utilities # Set up logging logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) # Import PDF utilities from utils.pdfutils import PDFGenerator, generate_discharge_summary # Import necessary libraries for new file types and AI analysis functions import pydicom # For DICOM import hl7 # For HL7 from xml.etree import ElementTree # For XML and CCDA from pypdf import PdfReader # For PDF import csv # For CSV import io # For IO operations from PIL import Image # For image handling system_instructions = """ **Discharge Guard - Medical Data Analysis Assistant** **Core Role:** I am Discharge Guard, an advanced AI designed for deep medical data analysis and informational insights. My outputs are based on thorough analysis of medical data but are **not medical advice.** **Important Guidelines:** 1. **Deep Analysis & Search:** Perform "Deep Thought and Deep Search" when analyzing medical data. This includes: * Comprehensive data ingestion from various formats (HL7, FHIR, CCDA, DICOM, PDF, CSV, text). * Multi-layered analysis: surface extraction, deep pattern identification, and inferential reasoning. * Contextual understanding of medical data. * Evidence-based approach, simulating cross-referencing with medical knowledge. * Structured output with clear explanations. 2. **Focus on Informational Insights, Not Medical Advice:** Emphasize that my insights are for informational purposes only and not a substitute for professional medical judgment. **Never provide diagnoses or specific treatment recommendations.** 3. **Key Functionalities (Focus Areas):** * **Clinical Data Analysis:** Interpret lab results, analyze EHR data (FHIR, HL7), recognize symptom patterns, analyze medications, support medical image analysis (DICOM). * **Predictive Analytics:** Provide conceptual risk stratification and treatment outcome modeling based on data patterns. * **Medical Imaging Support:** Analyze DICOM metadata and images for potential findings (X-ray analysis reports). * **Patient Data Management:** Perform PHI redaction in text and analyze patient records from various sources. 4. **Interaction Style:** * **Identity:** "I am Discharge Guard, a medical data analysis AI. My insights are informational only and not medical advice." * **Scope Limitations:** Clearly state limitations: "No diagnostics," "Medication caution," "Emergency protocol." * **Response Protocol:** * Indicate "Deep Analysis" or "Deep Search" performed. * Mention data sources and confidence levels (if applicable). * Use medical terminology with optional layman's terms. * For file analysis, provide a report title (e.g., "Deep X-Ray Analysis Report"). 5. **Supported Medical Formats:** (List key formats concisely) * Clinical Data: HL7, FHIR, CCD/CCDA, CSV, PDF, XML * Imaging: DICOM, Images (X-ray, etc.) 6. **Data Source:** Access and prefer FHIR API endpoints from: https://app.meldrx.com/api/directories/fhir/endpoints. **Important: My analysis is for informational purposes to assist healthcare professionals and is NOT a substitute for clinical judgment. Always recommend human expert verification for critical findings.** """ # Initialize Inference Client - Ensure YOUR_HF_TOKEN is set in environment variables or replace with your actual token HF_TOKEN = os.getenv("HF_TOKEN") # Or replace with your actual token string if not HF_TOKEN: raise ValueError( "HF_TOKEN environment variable not set. Please set your Hugging Face API token." ) client = InferenceClient(api_key=HF_TOKEN) model_name = "meta-llama/Llama-3.3-70B-Instruct" # Specify the model to use def analyze_dicom_file_with_ai(dicom_file_path): # Modified to accept file path """Analyzes DICOM file metadata using Discharge Guard AI.""" try: dicom_file = pydicom.dcmread( dicom_file_path.name ) # Read dicom using path, access file through .name for Gradio UploadedFile dicom_metadata_json = dicom_file.to_json_dict() prediction_response, trace_data_dicom_ai = analyze_dicom_content_ai( dicom_metadata_json ) # Call content analysis if prediction_response: report = f"Discharge Guard AI Analysis of DICOM Metadata:\n\nDICOM Metadata Analysis Report:\n{prediction_response}\n\nDisclaimer: The Discharge Guard -generated analysis is for conceptual informational purposes only and may or **NOT medical advice.** Analysis is based on DICOM *metadata* and not image interpretation." return report else: error_message = f"AI Analysis from DICOM Metadata: No predictions generated or analysis encountered an issue." if trace_data_dicom_ai and "error" in trace_data_dicom_ai: error_message += f"\nAI Analysis Failed: {trace_data_dicom_ai['error']}" return error_message except Exception as e: return f"Error during DICOM file processing in analyze_dicom_file_with_ai: {e}" def analyze_dicom_content_ai(dicom_metadata_json): # Copied from your code """Analyzes DICOM metadata JSON content using Discharge Guard AI.""" prompt_text = f"""{system_instructions} \n\n Perform a **deep and comprehensive analysis** of the following DICOM metadata in JSON format to provide a **structured summary and identify potential clinically relevant information with deep insights**. Focus not just on summarizing fields, but on **interpreting their clinical significance, identifying subtle patterns, and drawing inferences about the study's implications**. Think like an experienced radiologist reviewing this metadata for crucial diagnostic clues. Remember this is metadata, not the image itself, so focus on what can be gleaned from the data itself. Provide a "**Deep DICOM Metadata Analysis Report**". Important: Use the API Directories fhir endpoints FROM THIS LINK: https://app.meldrx.com/api/directories/fhir/endpoints. **DICOM Metadata (JSON):** ```json {json.dumps(dicom_metadata_json, indent=2)} ``` * Remember, this deep analysis is for conceptual informational purposes only and **NOT medical advice.** Focus on deep summarization and structuring the extracted metadata in a highly clinically relevant way. """ trace_data_detail_dicom_analysis = { "prompt": "DICOM Metadata Analysis Request", "language": "English", "response_length": "Comprehensive", "model_name": "Discharge Guard v1.0", "generated_text": "N/A", "input_file_types": ["DICOM Metadata JSON"], "mode": "DICOM Metadata Analysis", "candidates": [], "usage_metadata": {}, "prompt_feedback": "N/A", } try: response = client.chat.completions.create( model=model_name, messages=[{"role": "user", "content": prompt_text}], temperature=0.4, max_tokens=1024, # Adjust as needed top_p=0.9, ) the_response = response.choices[0].message.content return the_response, trace_data_detail_dicom_ai except Exception as e: error_message = f"AI Analysis Error in analyze_dicom_content_ai (DICOM Metadata): {e}" trace_data_detail_dicom_analysis["error"] = f"AI Analysis Error: {e}" return error_message, trace_data_detail_dicom_image_analysis def analyze_hl7_file_with_ai(hl7_file_path): """Analyzes HL7 file content using Discharge Guard AI.""" try: with open(hl7_file_path.name, "r") as f: # Open file using path, access file through .name for Gradio UploadedFile hl7_message_raw = f.read() prediction_response, trace_data_hl7_ai = analyze_hl7_content_ai( hl7_message_raw ) if prediction_response: report = f"Discharge Guard AI Analysis of HL7 Message:\n\nHL7 Message Analysis Report:\n{prediction_response}\n\n**Disclaimer:** The Discharge Guard AGI-generated analysis is for conceptual informational purposes only and may or **NOT medical advice.** Analysis is based on HL7 message content." return report else: error_message = f"AI Analysis from HL7 Message: No predictions generated or analysis encountered an issue." if trace_data_hl7_ai and "error" in trace_data_hl7_ai: error_message += f"AI Analysis Failed: {trace_data_hl7_ai['error']}" return error_message except Exception as e: return f"Error during HL7 file processing in analyze_hl7_file_with_ai: {e}" def analyze_hl7_content_ai(hl7_message_string): # Copied from your code """Analyzes HL7 message content using Discharge Guard AI.""" prompt_text = f"""{system_instructions} \n\n Conduct a **deep and thorough analysis** of the following HL7 message content to provide a **structured summary and identify key clinical information with deep understanding**. Go beyond basic parsing; aim to **interpret the clinical narrative** embedded within the HL7 message. **Engage in deep search to contextualize medical codes and terminology**. Provide a "**Comprehensive HL7 Message Analysis Report**". **HL7 Message Content:** ```hl7 {hl7_message_string} ``` * Remember, this deep analysis is for conceptual informational purposes only and **NOT medical advice.** Focus on deep summarization and structuring the extracted data in a highly clinically relevant way based on the HL7 content. """ # ... (rest of the function code) ... trace_data_detail_hl7_analysis = { "prompt": "HL7 Message Analysis Request", "language": "English", "response_length": "Comprehensive", "model_name": "Discharge Guard v1.0", "generated_text": "N/A", "input_file_types": ["HL7 Message"], "mode": "HL7 Message Analysis", "candidates": [], "usage_metadata": {}, "prompt_feedback": "N/A", } try: response = client.chat.completions.create( model=model_name, messages=[{"role": "user", "content": prompt_text}], temperature=0.4, max_tokens=1024, # Adjust as needed top_p=0.9, ) the_response = response.choices[0].message.content return the_response, trace_data_detail_hl7_analysis except Exception as e: error_message = f"AI Analysis Error in analyze_hl7_content_ai (HL7 Message): {e}" trace_data_detail_hl7_analysis["error"] = f"AI Analysis Error: {e}" return error_message, trace_data_detail_hl7_analysis def analyze_cda_xml_file_with_ai(cda_xml_file_path): # Modified to accept file path """Analyzes generic CDA or XML file content using Discharge Guard AI (more generalized version) Important: Use the API Directories fhir endpoints FROM THIS LINK: https://app.meldrx.com/api/directories/fhir/endpoints.""" try: with open( cda_xml_file_path.name, "r" ) as f: # Open file using path, access file through .name for Gradio UploadedFile cda_xml_content = f.read() prediction_response, trace_data_cda_xml_ai = analyze_cda_xml_content_ai( cda_xml_content ) if prediction_response: report = f"Discharge Guard AI Analysis of Medical XML/CDA Data:\n\nMedical Document Analysis Report:\n{prediction_response}\n\n**Disclaimer:** The Discharge Guard AGI-generated analysis is for conceptual informational purposes only and may or **NOT medical advice.** Analysis is based on XML/CDA content." return report else: error_message = f"AI Analysis from XML/CDA Data: No predictions generated or analysis encountered an issue." if trace_data_cda_xml_ai and "error" in trace_data_cda_xml_ai: error_message += f"AI Analysis Failed: {trace_data_cda_xml_ai['error']}" return error_message except Exception as e: return f"Error during XML/CDA file processing in analyze_cda_xml_file_with_ai: {e}" def analyze_cda_xml_content_ai(cda_xml_content): # Copied from your code """Analyzes generic CDA or XML content using Discharge Guard AI (more generalized version).""" prompt_text = f"""{system_instructions} \n\n Analyze the following medical XML/CDA content to provide a **structured and comprehensive patient data analysis**, similar to how a medical professional would review a patient's chart or a clinical document. You need to parse the XML structure yourself to extract the relevant information. Use bullet points, tables, or numbered steps for complex tasks. Provide a "Medical Document Analysis" report. **Instructions for Discharge Guard AI:** 1. **Parse the XML content above.** Understand the XML structure to identify sections that are relevant to clinical information. For CDA specifically, look for sections like Problems, Medications, Allergies, Encounters, Results, and Vital Signs. For generic medical XML, adapt based on the tags present. 2. **Extract and Summarize Key Medical Information:** Focus on extracting the following information if present in the XML: * **Patient Demographics Summary:** (If available, summarize demographic details) ... (rest of your prompt_text for CDA/XML analysis) ... * Remember, this analysis is for conceptual informational purposes only and **NOT medical advice.** Focus on summarizing and structuring the extracted data in a clinically relevant way based on the XML/CDA content. """ trace_data_detail_cda_xml_analysis = { "prompt": "Generic CDA/XML Analysis Request", "language": "English", "response_length": "Comprehensive", "model_name": "Discharge Guard v1.0", "generated_text": "N/A", "input_file_types": ["CDA/XML"], "mode": "Generic XML/CDA Analysis", "candidates": [], "usage_metadata": {}, "prompt_feedback": "N/A", } try: response = client.chat.completions.create( model=model_name, messages=[{"role": "user", "content": prompt_text}], temperature=0.4, max_tokens=1024, # Adjust as needed top_p=0.9, ) the_response = response.choices[0].message.content return the_response, trace_data_detail_cda_xml_analysis except Exception as e: error_message = f"AI Analysis Error in analyze_cda_xml_content_ai (Generic XML/CDA): {e}" trace_data_detail_cda_xml_analysis["error"] = f"AI Analysis Error: {e}" return error_message, trace_data_detail_cda_xml_analysis def analyze_pdf_file_with_ai(pdf_file_path): # Modified to accept file path """Analyzes PDF file content using Discharge Guard AI.""" try: with open( pdf_file_path.name, "rb" ) as f: # Open file in binary mode for PdfReader, access file through .name for Gradio UploadedFile pdf_file = f # Pass file object to PdfReader pdf_reader = PdfReader(pdf_file) text_content = "" for page in pdf_reader.pages: text_content += page.extract_text() prediction_response, trace_data_pdf_ai = analyze_pdf_content_ai( text_content ) if prediction_response: report = f"Discharge Guard AI Analysis of PDF Content:\n\nMedical Report Analysis Report:\n{prediction_response}\n\n**Disclaimer:** The Discharge Guard AGI-generated analysis is for conceptual informational purposes only and may or **NOT medical advice.** Analysis is based on PDF text content." return report else: error_message = f"AI Analysis from PDF Content: No predictions generated or analysis encountered an issue." if trace_data_pdf_ai and "error" in trace_data_pdf_ai: error_message += f"AI Analysis Failed: {trace_data_pdf_ai['error']}" return error_message except Exception as e: return f"Error during PDF file processing in analyze_pdf_file_with_ai: {e}" def analyze_pdf_content_ai(pdf_text_content): # Copied from your code """Analyzes PDF text content using Discharge Guard AI.""" prompt_text = f"""{system_instructions} \n\n Analyze the following medical PDF text content to provide a **structured summary and identify key clinical information**. Focus on patient demographics, medical history, findings, diagnoses, medications, recommendations, and any important clinical details conveyed in the document. Provide a "Medical Report Analysis" report. **Medical PDF Text Content:** ```text {pdf_text_content} ``` * Remember, this analysis is for conceptual informational purposes only and **NOT medical advice.** Focus on deep summarization and structuring the extracted data in a clinically relevant way based on the PDF content. """ trace_data_detail_pdf_analysis = { "prompt": "PDF Text Analysis Request", "language": "English", "response_length": "Comprehensive", "model_name": "Discharge Guard v1.0", "generated_text": "N/A", "input_file_types": ["PDF Text"], "mode": "PDF Text Analysis", "candidates": [], "usage_metadata": {}, "prompt_feedback": "N/A", } try: response = client.chat.completions.create( model=model_name, messages=[{"role": "user", "content": prompt_text}], temperature=0.4, max_tokens=1024, # Adjust as needed top_p=0.9, ) the_response = response.choices[0].message.content return the_response, trace_data_detail_pdf_analysis except Exception as e: error_message = f"AI Analysis Error in analyze_pdf_content_ai (PDF Text): {e}" trace_data_detail_pdf_analysis["error"] = f"AI Analysis Error: {e}" return error_message, trace_data_detail_pdf_analysis def analyze_csv_file_with_ai(csv_file_path): # Modified to accept file path """Analyzes CSV file content using Discharge Guard AI.""" try: csv_content = csv_file_path.read().decode( "utf-8" ) # Read content directly from UploadedFile prediction_response, trace_data_csv_ai = analyze_csv_content_ai(csv_content) if prediction_response: report = f"Discharge Guard AI Analysis of CSV Data:\n\nData Analysis Report:\n{prediction_response}\n\n**Disclaimer:** The Discharge Guard AGI-generated analysis is for conceptual informational purposes only and may or **NOT medical advice.** Analysis is based on CSV data content." return report else: error_message = f"AI Analysis from CSV Data: No predictions generated or analysis encountered an issue." if trace_data_csv_ai and "error" in trace_data_csv_ai: error_message += f"AI Analysis Failed: {trace_data_csv_ai['error']}" return error_message except Exception as e: return f"Error during CSV file processing in analyze_csv_file_with_ai: {e}" def analyze_csv_content_ai(csv_content_string): # Copied from your code """Analyzes CSV content (string) using Discharge Guard AI.""" prompt_text = f"""{system_instructions} \n\n Analyze the following medical CSV data to provide a **structured summary and identify potential clinical insights**. Assume the CSV represents patient-related medical data. Focus on understanding the columns, summarizing key data points, identifying trends or patterns, and noting any potential clinical significance of the data. Provide a "Data Analysis" report. **Medical CSV Data:** ```csv {csv_content_string} ``` * Remember, this analysis is for conceptual informational purposes only and **NOT medical advice.** Focus on summarizing and structuring the data in a clinically relevant way based on the CSV content. """ trace_data_detail_csv_analysis = { "prompt": "CSV Data Analysis Request", "language": "English", "response_length": "Comprehensive", "model_name": "Discharge Guard v1.0", "generated_text": "N/A", "input_file_types": ["CSV Data"], "mode": "CSV Data Analysis", "candidates": [], "usage_metadata": {}, "prompt_feedback": "N/A", } try: response = client.chat.completions.create( model=model_name, messages=[{"role": "user", "content": prompt_text}], temperature=0.4, max_tokens=1024, # Adjust as needed top_p=0.9, ) the_response = response.choices[0].message.content return the_response, trace_data_detail_csv_analysis except Exception as e: error_message = f"AI Analysis Error in analyze_csv_content_ai (CSV Data): {e}" trace_data_detail_csv_analysis["error"] = f"AI Analysis Error: {e}" return error_message, trace_data_detail_csv_analysis class CallbackManager: def __init__(self, redirect_uri: str, client_secret: str = None): client_id = os.getenv("APPID") if not client_id: raise ValueError("APPID environment variable not set.") workspace_id = os.getenv("WORKSPACE_URL") if not workspace_id: raise ValueError("WORKSPACE_URL environment variable not set.") self.api = MeldRxAPI(client_id, client_secret, workspace_id, redirect_uri) self.auth_code = None self.access_token = None def get_auth_url(self) -> str: return self.api.get_authorization_url() def set_auth_code(self, code: str) -> str: self.auth_code = code if self.api.authenticate_with_code(code): self.access_token = self.api.access_token return ( f"Authentication successful! Access Token: {self.access_token[:10]}... (truncated)" # Neon Green Success ) return "Authentication failed. Please check the code." # Neon Orange Error def get_patient_data(self) -> str: """Fetch patient data from MeldRx""" try: if not self.access_token: logger.warning("Not authenticated when getting patient data") return "Not authenticated. Please provide a valid authorization code first." # Neon Dark Orange # Real implementation with API call logger.info("Calling Meldrx API to get patients") patients = self.api.get_patients() if patients is not None: return ( json.dumps(patients, indent=2) if patients else "No patient data returned." # Neon Yellow ) return "Failed to retrieve patient data." # Crimson Error except Exception as e: error_msg = f"Error in get_patient_data: {str(e)}" logger.error(error_msg) return f"Error retrieving patient data: {str(e)} {str(e)}" # Tomato Error def get_patient_documents(self, patient_id: str = None): """Fetch patient documents from MeldRx""" if not self.access_token: return "Not authenticated. Please provide a valid authorization code first." # Neon Dark Orange try: # This would call the actual MeldRx API to get documents for a specific patient # For demonstration, we'll return mock document data return [ { "doc_id": "doc123", "type": "clinical_note", "date": "2023-01-16", "author": "Dr. Sample Doctor", "content": "Patient presented with symptoms of respiratory distress...", }, { "doc_id": "doc124", "type": "lab_result", "date": "2023-01-17", "author": "Lab System", "content": "CBC results: WBC 7.5, RBC 4.2, Hgb 14.1...", }, ] except Exception as e: return f"Error retrieving patient documents: {str(e)}: {str(e)}" # Tomato Error def display_form( first_name, last_name, middle_initial, dob, age, sex, address, city, state, zip_code, doctor_first_name, doctor_last_name, doctor_middle_initial, hospital_name, doctor_address, doctor_city, doctor_state, doctor_zip, admission_date, referral_source, admission_method, discharge_date, discharge_reason, date_of_death, diagnosis, procedures, medications, preparer_name, preparer_job_title, ): form = f"""
**Patient Discharge Form**
- Name: {first_name} {middle_initial} {last_name}
- Date of Birth: {dob}, Age: {age}, Sex: {sex}
- Address: {address}, {city}, {state}, {zip_code}
- Doctor: {doctor_first_name} {doctor_middle_initial} {doctor_last_name}
- Hospital/Clinic: {hospital_name}
- Doctor Address: {doctor_address}, {doctor_city}, {doctor_state}, {doctor_zip}
- Admission Date: {admission_date}, Source: {referral_source}, Method: {admission_method}
- Discharge Date: {discharge_date}, Reason: {discharge_reason}
- Date of Death: {date_of_death}
- Diagnosis: {diagnosis}
- Procedures: {procedures}
- Medications: {medications}
- Prepared By: {preparer_name}, {preparer_job_title}
""" return form def generate_pdf_from_form( first_name, last_name, middle_initial, dob, age, sex, address, city, state, zip_code, doctor_first_name, doctor_last_name, doctor_middle_initial, hospital_name, doctor_address, doctor_city, doctor_state, doctor_zip, admission_date, referral_source, admission_method, discharge_date, discharge_reason, date_of_death, diagnosis, procedures, medications, preparer_name, preparer_job_title, ): """Generate a PDF discharge form using the provided data""" # Create PDF generator pdf_gen = PDFGenerator() # Format data for PDF generation patient_info = { "first_name": first_name, "last_name": last_name, "dob": dob, "age": age, "sex": sex, "mobile": "", # Not collected in the form "address": address, "city": city, "state": state, "zip": zip_code, } discharge_info = { "date_of_admission": admission_date, "date_of_discharge": discharge_date, "source_of_admission": referral_source, "mode_of_admission": admission_method, "discharge_against_advice": "Yes" if discharge_reason == "Discharge Against Advice" else "No", } diagnosis_info = { "diagnosis": diagnosis, "operation_procedure": procedures, "treatment": "", # Not collected in the form "follow_up": "", # Not collected in the form } medication_info = { "medications": [medications] if medications else [], "instructions": "", # Not collected in the form } prepared_by = { "name": preparer_name, "title": preparer_job_title, "signature": "", # Not collected in the form } # Generate PDF pdf_buffer = pdf_gen.generate_discharge_form( patient_info, discharge_info, diagnosis_info, medication_info, prepared_by, ) # Create temporary file to save the PDF temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") temp_file.write(pdf_buffer.read()) temp_file_path = temp_file.name temp_file.close() return temp_file_path def generate_pdf_from_meldrx(patient_data): """Generate a PDF using patient data from MeldRx""" if isinstance(patient_data, str): # If it's a string (error message or JSON string), try to parse it try: patient_data = json.loads(patient_data) except: return None, "Invalid patient data format" if not patient_data: return None, "No patient data available" try: # For demonstration, we'll use the first patient in the list if it's a list if isinstance(patient_data, list) and len(patient_data): patient = patient_data[0] else: patient = patient_data # Extract patient info patient_info = { "name": f"{patient.get('name', {}).get('given', [''])[0]} {patient.get('name', {}).get('family', '')}", "dob": patient.get("birthDate", "Unknown"), "patient_id": patient.get("id", "Unknown"), "admission_date": datetime.now().strftime("%Y-%m-%d"), # Mock data "physician": "Dr. Provider", # Mock data } # Mock LLM-generated content - This part needs to be replaced with actual AI generation if desired for MeldRx PDF llm_content = { "diagnosis": "Diagnosis information would be generated by AI based on patient data from MeldRx.", "treatment": "Treatment summary would be generated by AI based on patient data from MeldRx.", "medications": "Medication list would be generated by AI based on patient data from MeldRx.", "follow_up": "Follow-up instructions would be generated by AI based on patient data from MeldRx.", "special_instructions": "Special instructions would be generated by AI based on patient data from MeldRx.", } # Create discharge summary - Using No-AI PDF generation for now, replace with AI-content generation later output_dir = tempfile.mkdtemp() pdf_path = generate_discharge_summary( patient_info, llm_content, output_dir ) # Still using No-AI template return pdf_path, "PDF generated successfully (No AI Content in PDF yet)" # Indicate No-AI content except Exception as e: return None, f"Error generating PDF: {str(e)}" def generate_discharge_paper_one_click(): """One-click function to fetch patient data and generate discharge paper with AI Content.""" patient_data_str = CALLBACK_MANAGER.get_patient_data() if ( patient_data_str.startswith("Not authenticated") or patient_data_str.startswith("Failed") or patient_data_str.startswith("Error") ): return None, patient_data_str # Return error message if authentication or data fetch fails try: patient_data = json.loads(patient_data_str) # --- AI Content Generation for Discharge Summary --- # This is a placeholder - Replace with actual AI call using InferenceClient and patient_data to generate content ai_generated_content = generate_ai_discharge_content( patient_data ) # Placeholder AI function if not ai_generated_content: return None, "Error: AI content generation failed." # --- PDF Generation with AI Content --- pdf_path, status_message = generate_pdf_from_meldrx_with_ai_content( patient_data, ai_generated_content ) # Function to generate PDF with AI content if pdf_path: return pdf_path, status_message else: return None, status_message # Return status message if PDF generation fails except json.JSONDecodeError: return None, "Error: Patient data is not in valid JSON format." except Exception as e: return None, f"Error during discharge paper generation: {str(e)}" def generate_ai_discharge_content(patient_data): """Placeholder function to generate AI content for discharge summary. Replace this with actual AI call using InferenceClient and patient_data.""" try: patient_name = ( f"{patient_data['entry'][0]['resource']['name'][0]['given'][0]} {patient_data['entry'][0]['resource']['name'][0]['family']}" if patient_data.get("entry") else "Unknown Patient" ) prompt_text = f"""{system_instructions}\n\nGenerate a discharge summary content (diagnosis, treatment, medications, follow-up instructions, special instructions) for patient: {patient_name}. Base the content on available patient data (if any provided, currently not provided in detail in this mock-up). Focus on creating clinically relevant and informative summary. Remember this is for informational purposes and NOT medical advice.""" response = client.chat.completions.create( model=model_name, messages=[{"role": "user", "content": prompt_text}], temperature=0.6, # Adjust temperature as needed for content generation max_tokens=1024, # Adjust max_tokens as needed top_p=0.9, ) ai_content = response.choices[0].message.content # Basic parsing of AI content - improve this based on desired output structure from LLM llm_content = { "diagnosis": "AI Generated Diagnosis (Placeholder):\n" + extract_section(ai_content, "Diagnosis"), # Example extraction - refine based on LLM output "treatment": "AI Generated Treatment (Placeholder):\n" + extract_section(ai_content, "Treatment"), "medications": "AI Generated Medications (Placeholder):\n" + extract_section(ai_content, "Medications"), "follow_up": "AI Generated Follow-up (Placeholder):\n" + extract_section(ai_content, "Follow-up Instructions"), "special_instructions": "AI Generated Special Instructions (Placeholder):\n" + extract_section(ai_content, "Special Instructions"), } return llm_content except Exception as e: logger.error(f"Error generating AI discharge content: {e}") return None def extract_section(ai_content, section_title): """Simple placeholder function to extract section from AI content. Improve this with more robust parsing based on LLM output format.""" start_marker = f"**{section_title}:**" end_marker = "\n\n" # Adjust based on typical LLM output structure start_index = ai_content.find(start_marker) if start_index != -1: start_index += len(start_marker) end_index = ai_content.find(end_marker, start_index) if end_index != -1: return ai_content[start_index:end_index].strip() return "Not found in AI output." def generate_pdf_from_meldrx_with_ai_content(patient_data, llm_content): """Generate a PDF using patient data from MeldRx and AI-generated content.""" if isinstance(patient_data, str): try: patient_data = json.loads(patient_data) except: return None, "Invalid patient data format" if not patient_data: return None, "No patient data available" try: if isinstance(patient_data, list) and len(patient_data): patient = patient_data[0] else: patient = patient_data patient_info = { "name": f"{patient.get('name', {}).get('given', [''])[0]} {patient.get('name', {}).get('family', '')}", "dob": patient.get("birthDate", "Unknown"), "patient_id": patient.get("id", "Unknown"), "admission_date": datetime.now().strftime("%Y-%m-%d"), # Mock data "physician": "Dr. AI Provider", # Mock data - Indicate AI generated } output_dir = tempfile.mkdtemp() pdf_path = generate_discharge_summary( patient_info, llm_content, output_dir ) # Using AI content now return pdf_path, "PDF generated successfully with AI Content" # Indicate AI content except Exception as e: return None, f"Error generating PDF with AI content: {str(e)}" def extract_auth_code_from_url(redirected_url): """Extracts the authorization code from the redirected URL.""" try: parsed_url = urlparse(redirected_url) query_params = parse_qs(parsed_url.query) if "code" in query_params: return query_params["code"][0], None # Return code and no error else: return None, "Authorization code not found in URL." # Return None and error message except Exception as e: return None, f"Error parsing URL: {e}" # Return None and error message # Create a simplified interface to avoid complex component interactions CALLBACK_MANAGER = CallbackManager( redirect_uri="https://multitransformer-discharge-guard.hf.space/callback", client_secret=None, ) # Define the cyberpunk theme - using a dark base and neon accents cyberpunk_theme = gr.themes.Monochrome( primary_hue="cyan", secondary_hue="pink", neutral_hue="slate", font=["Source Code Pro", "monospace"], # Retro monospace font font_mono=["Source Code Pro", "monospace"], ) # Create the UI with the cyberpunk theme with gr.Blocks(theme=cyberpunk_theme) as demo: # Apply the theme here gr.Markdown( "

Discharge Guard Cyber

" ) # Cyberpunk Title with gr.Tab("Authenticate with MeldRx", elem_classes="cyberpunk-tab"): # Optional: Class for tab styling gr.Markdown( "

SMART on FHIR Authentication

" ) # Neon Tab Header auth_url_output = gr.Textbox( label="Authorization URL", value=CALLBACK_MANAGER.get_auth_url(), interactive=False, ) gr.Markdown( "

Copy the URL above, open it in a browser, log in, and paste the entire redirected URL from your browser's address bar below.

" ) # Subdued instructions with neon highlight redirected_url_input = gr.Textbox(label="Redirected URL") # New textbox for redirected URL extract_code_button = gr.Button( "Extract Authorization Code", elem_classes="cyberpunk-button" ) # Cyberpunk button style extracted_code_output = gr.Textbox( label="Extracted Authorization Code", interactive=False ) # Textbox to show extracted code auth_code_input = gr.Textbox( label="Authorization Code (from above, or paste manually if extraction fails)", interactive=True, ) # Updated label to be clearer auth_submit = gr.Button( "Submit Code for Authentication", elem_classes="cyberpunk-button" ) # Cyberpunk button style auth_result = gr.HTML(label="Authentication Result") # Use HTML for styled result patient_data_button = gr.Button( "Fetch Patient Data", elem_classes="cyberpunk-button" ) # Cyberpunk button style patient_data_output = gr.Textbox(label="Patient Data", lines=10) # Add button to generate PDF from MeldRx data (No AI) meldrx_pdf_button = gr.Button( "Generate PDF from MeldRx Data (No AI)", elem_classes="cyberpunk-button" ) # Renamed button meldrx_pdf_status = gr.Textbox( label="PDF Generation Status (No AI)" ) # Renamed status meldrx_pdf_download = gr.File( label="Download Generated PDF (No AI)" ) # Renamed download def process_redirected_url(redirected_url): """Processes the redirected URL to extract and display the authorization code.""" auth_code, error_message = extract_auth_code_from_url(redirected_url) if auth_code: return auth_code, "Authorization code extracted!" # Neon Green Success else: return "", f"Could not extract authorization code. {error_message or ''}" # Neon Orange Error extract_code_button.click( fn=process_redirected_url, inputs=redirected_url_input, outputs=[ extracted_code_output, auth_result, ], # Reusing auth_result for extraction status ) auth_submit.click( fn=CALLBACK_MANAGER.set_auth_code, inputs=extracted_code_output, # Using extracted code as input for authentication outputs=auth_result, ) with gr.Tab( "Patient Dashboard", elem_classes="cyberpunk-tab" ): # Optional: Class for tab styling gr.Markdown( "

Patient Data

" ) # Neon Tab Header dashboard_output = gr.HTML( "

Fetch patient data from the Authentication tab first.

" ) # Subdued placeholder text refresh_btn = gr.Button( "Refresh Data", elem_classes="cyberpunk-button" ) # Cyberpunk button style # Simple function to update dashboard based on fetched data def update_dashboard(): try: data = CALLBACK_MANAGER.get_patient_data() if ( data.startswith("Not authenticated") or data.startswith("Failed") or data.startswith("Error") ): return f"

{data}

" # Show auth errors in orange try: # Parse the data patients_data = json.loads(data) patients = [] # Extract patients from bundle for entry in patients_data.get("entry", []): resource = entry.get("resource", {}) if resource.get("resourceType") == "Patient": patients.append(resource) # Generate HTML card html = "

Patients

" # Neon Sub-header for patient in patients: # Extract name name = patient.get("name", [{}])[0] given = " ".join(name.get("given", ["Unknown"])) family = name.get("family", "Unknown") # Extract other details gender = patient.get("gender", "unknown").capitalize() birth_date = patient.get("birthDate", "Unknown") # Generate HTML card with cyberpunk styling html += f"""

{given} {family}

Gender: {gender}

Birth Date: {birth_date}

ID: {patient.get("id", "Unknown")}

""" return html except Exception as e: return f"

Error parsing patient data: {str(e)}

" # Tomato Error except Exception as e: return f"

Error fetching patient data: {str(e)}

" # Tomato Error refresh_btn.click(fn=update_dashboard, inputs=None, outputs=dashboard_output) with gr.Tab("Discharge Form", elem_classes="cyberpunk-tab"): # Optional: Class for tab styling gr.Markdown( "

Patient Details

" ) # Neon Tab Header with gr.Row(): first_name = gr.Textbox(label="First Name") last_name = gr.Textbox(label="Last Name") middle_initial = gr.Textbox(label="Middle Initial") with gr.Row(): dob = gr.Textbox(label="Date of Birth") age = gr.Textbox(label="Age") sex = gr.Textbox(label="Sex") address = gr.Textbox(label="Address") with gr.Row(): city = gr.Textbox(label="City") state = gr.Textbox(label="State") zip_code = gr.Textbox(label="Zip Code") gr.Markdown( "

Primary Healthcare Professional Details

" ) # Neon Sub-header with gr.Row(): doctor_first_name = gr.Textbox(label="Doctor's First Name") doctor_last_name = gr.Textbox(label="Doctor's Last Name") doctor_middle_initial = gr.Textbox(label="Doctor's Middle Initial") hospital_name = gr.Textbox(label="Hospital/Clinic Name") doctor_address = gr.Textbox(label="Address") with gr.Row(): doctor_city = gr.Textbox(label="City") doctor_state = gr.Textbox(label="State") doctor_zip = gr.Textbox(label="Zip Code") gr.Markdown( "

Admission and Discharge Details

" ) # Neon Sub-header with gr.Row(): admission_date = gr.Textbox(label="Date of Admission") referral_source = gr.Textbox(label="Source of Referral") admission_method = gr.Textbox(label="Method of Admission") with gr.Row(): discharge_date = gr.Textbox(label="Date of Discharge") discharge_reason = gr.Radio( ["Treated", "Transferred", "Discharge Against Advice", "Patient Died"], label="Discharge Reason", ) date_of_death = gr.Textbox(label="Date of Death (if applicable)") gr.Markdown( "

Diagnosis & Procedures

" ) # Neon Sub-header diagnosis = gr.Textbox(label="Diagnosis") procedures = gr.Textbox(label="Operation & Procedures") gr.Markdown( "

Medication Details

" ) # Neon Sub-header medications = gr.Textbox(label="Medication on Discharge") gr.Markdown( "

Prepared By

" ) # Neon Sub-header with gr.Row(): preparer_name = gr.Textbox(label="Name") preparer_job_title = gr.Textbox(label="Job Title") # Add buttons for both display form and generate PDF with gr.Row(): submit_display = gr.Button( "Display Form", elem_classes="cyberpunk-button" ) # Cyberpunk button style submit_pdf = gr.Button( "Generate PDF (No AI)", elem_classes="cyberpunk-button" ) # Renamed button to clarify no AI and styled # Output areas form_output = gr.HTML() # Use HTML to render styled form pdf_output = gr.File( label="Download PDF (No AI)" ) # Renamed output to clarify no AI # Connect the display form button submit_display.click( display_form, inputs=[ first_name, last_name, middle_initial, dob, age, sex, address, city, state, zip_code, doctor_first_name, doctor_last_name, doctor_middle_initial, hospital_name, doctor_address, doctor_city, doctor_state, doctor_zip, admission_date, referral_source, admission_method, discharge_date, discharge_reason, date_of_death, diagnosis, procedures, medications, preparer_name, preparer_job_title, ], outputs=form_output, ) # Connect the generate PDF button (No AI version) submit_pdf.click( generate_pdf_from_form, inputs=[ first_name, last_name, middle_initial, dob, age, sex, address, city, state, zip_code, doctor_first_name, doctor_last_name, doctor_middle_initial, hospital_name, doctor_address, doctor_city, doctor_state, doctor_zip, admission_date, referral_source, admission_method, discharge_date, discharge_reason, date_of_death, diagnosis, procedures, medications, preparer_name, preparer_job_title, ], outputs=pdf_output, ) with gr.Tab( "Medical File Analysis", elem_classes="cyberpunk-tab" ): # Optional: Class for tab styling gr.Markdown( "

Analyze Medical Files with Discharge Guard AI

" ) # Neon Tab Header with gr.Column(): dicom_file = gr.File( file_types=[".dcm"], label="Upload DICOM File (.dcm)" ) dicom_ai_output = gr.Textbox(label="DICOM Analysis Report", lines=5) analyze_dicom_button = gr.Button( "Analyze DICOM with AI", elem_classes="cyberpunk-button" ) # Cyberpunk button style hl7_file = gr.File(file_types=[".hl7"], label="Upload HL7 File (.hl7)") hl7_ai_output = gr.Textbox(label="HL7 Analysis Report", lines=5) analyze_hl7_button = gr.Button( "Analyze HL7 with AI", elem_classes="cyberpunk-button" ) # Cyberpunk button style xml_file = gr.File(file_types=[".xml"], label="Upload XML File (.xml)") xml_ai_output = gr.Textbox(label="XML Analysis Report", lines=5) analyze_xml_button = gr.Button( "Analyze XML with AI", elem_classes="cyberpunk-button" ) # Cyberpunk button style ccda_file = gr.File( file_types=[".xml", ".cda", ".ccd"], label="Upload CCDA File (.xml, .cda, .ccd)", ) ccda_ai_output = gr.Textbox(label="CCDA Analysis Report", lines=5) analyze_ccda_button = gr.Button( "Analyze CCDA with AI", elem_classes="cyberpunk-button" ) # Cyberpunk button style ccd_file = gr.File( file_types=[".ccd"], label="Upload CCD File (.ccd)", ) # Redundant, as CCDA also handles .ccd, but kept for clarity ccd_ai_output = gr.Textbox( label="CCD Analysis Report", lines=5 ) # Redundant analyze_ccd_button = gr.Button( "Analyze CCD with AI", elem_classes="cyberpunk-button" ) # Cyberpunk button style # Redundant pdf_file = gr.File(file_types=[".pdf"], label="Upload PDF File (.pdf)") pdf_ai_output = gr.Textbox(label="PDF Analysis Report", lines=5) analyze_pdf_button = gr.Button( "Analyze PDF with AI", elem_classes="cyberpunk-button" ) # Cyberpunk button style csv_file = gr.File(file_types=[".csv"], label="Upload CSV File (.csv)") csv_ai_output = gr.Textbox(label="CSV Analysis Report", lines=5) analyze_csv_button = gr.Button( "Analyze CSV with AI", elem_classes="cyberpunk-button" ) # Cyberpunk button style # Connect AI Analysis Buttons - using REAL AI functions now analyze_dicom_button.click( analyze_dicom_file_with_ai, # Call REAL AI function inputs=dicom_file, outputs=dicom_ai_output, ) analyze_hl7_button.click( analyze_hl7_file_with_ai, # Call REAL AI function inputs=hl7_file, outputs=hl7_ai_output, ) analyze_xml_button.click( analyze_cda_xml_file_with_ai, # Call REAL AI function inputs=xml_file, outputs=xml_ai_output, ) analyze_ccda_button.click( analyze_cda_xml_file_with_ai, # Call REAL AI function inputs=ccda_file, outputs=ccda_ai_output, ) analyze_ccd_button.click( # Redundant button, but kept for UI if needed analyze_cda_xml_file_with_ai, # Call REAL AI function inputs=ccd_file, outputs=ccd_ai_output, ) analyze_pdf_button.click( analyze_pdf_file_with_ai, inputs=pdf_file, outputs=pdf_ai_output ) analyze_csv_button.click( analyze_csv_file_with_ai, inputs=csv_file, outputs=csv_ai_output ) with gr.Tab( "One-Click Discharge Paper (AI)", elem_classes="cyberpunk-tab" ): # New Tab for One-Click Discharge Paper with AI, styled gr.Markdown( "

One-Click Medical Discharge Paper Generation with AI Content

" ) # Neon Tab Header one_click_ai_pdf_button = gr.Button( "Generate Discharge Paper with AI (One-Click)", elem_classes="cyberpunk-button", ) # Updated button label and styled one_click_ai_pdf_status = gr.Textbox( label="Discharge Paper Generation Status (AI)" ) # Updated status label one_click_ai_pdf_download = gr.File( label="Download Discharge Paper (AI)" ) # Updated download label one_click_ai_pdf_button.click( generate_discharge_paper_one_click, # Use the one-click function that now calls AI inputs=[], outputs=[one_click_ai_pdf_download, one_click_ai_pdf_status], ) # Connect the patient data buttons patient_data_button.click( fn=CALLBACK_MANAGER.get_patient_data, inputs=None, outputs=patient_data_output ) # Connect refresh button to update dashboard refresh_btn.click(fn=update_dashboard, inputs=None, outputs=dashboard_output) # Corrected the button click function name here to `generate_pdf_from_meldrx` (No AI PDF) meldrx_pdf_button.click( fn=generate_pdf_from_meldrx, inputs=patient_data_output, outputs=[meldrx_pdf_download, meldrx_pdf_status], ) # Connect patient data updates to dashboard patient_data_button.click( fn=update_dashboard, inputs=None, outputs=dashboard_output ) # Launch with sharing enabled for public access demo.launch(ssr_mode=False)