Update callbackmanager.py

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"]
)

callbackmanager.py

@@ -6,8 +6,8 @@ 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
+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)
@@ -19,11 +19,11 @@ from 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
+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**
@@ -57,18 +57,25 @@ system_instructions = """
 """
 
 # 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
+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.")
+    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
+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
+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_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
+        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
@@ -81,7 +88,8 @@ def analyze_dicom_file_with_ai(dicom_file_path): # Modified to accept file path
     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
+
+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):**
@@ -109,7 +117,7 @@ def analyze_dicom_content_ai(dicom_metadata_json): # Copied from your code
             model=model_name,
             messages=[{"role": "user", "content": prompt_text}],
             temperature=0.4,
-            max_tokens=1024, # Adjust as needed
+            max_tokens=1024,  # Adjust as needed
             top_p=0.9,
         )
         the_response = response.choices[0].message.content
@@ -120,13 +128,16 @@ def analyze_dicom_content_ai(dicom_metadata_json): # Copied from your code
         trace_data_detail_dicom_analysis["error"] = f"AI Analysis Error: {e}"
         return error_message, trace_data_detail_dicom_analysis
 
+
 # ... (Paste other AI analysis functions: analyze_hl7_file_with_ai, analyze_cda_xml_file_with_ai, analyze_pdf_file_with_ai, analyze_csv_file_with_ai here - ensure to adapt file reading for Gradio file paths if necessary) ...
 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
+        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)
+        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."
@@ -140,7 +151,8 @@ def analyze_hl7_file_with_ai(hl7_file_path):
     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
+
+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:**
@@ -168,7 +180,7 @@ def analyze_hl7_content_ai(hl7_message_string): # Copied from your code
             model=model_name,
             messages=[{"role": "user", "content": prompt_text}],
             temperature=0.4,
-            max_tokens=1024, # Adjust as needed
+            max_tokens=1024,  # Adjust as needed
             top_p=0.9,
         )
         the_response = response.choices[0].message.content
@@ -180,10 +192,12 @@ def analyze_hl7_content_ai(hl7_message_string): # Copied from your code
         return error_message, trace_data_detail_hl7_analysis
 
 
-def analyze_cda_xml_file_with_ai(cda_xml_file_path): # Modified to accept file path
+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
+        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
@@ -200,7 +214,8 @@ def analyze_cda_xml_file_with_ai(cda_xml_file_path): # Modified to accept file p
     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
+
+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.
@@ -230,7 +245,7 @@ def analyze_cda_xml_content_ai(cda_xml_content): # Copied from your code
             model=model_name,
             messages=[{"role": "user", "content": prompt_text}],
             temperature=0.4,
-            max_tokens=1024, # Adjust as needed
+            max_tokens=1024,  # Adjust as needed
             top_p=0.9,
         )
         the_response = response.choices[0].message.content
@@ -242,17 +257,21 @@ def analyze_cda_xml_content_ai(cda_xml_content): # Copied from your code
         return error_message, trace_data_detail_cda_xml_analysis
 
 
-def analyze_pdf_file_with_ai(pdf_file_path): # Modified to accept file path
+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
+        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)
+        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."
@@ -266,7 +285,8 @@ def analyze_pdf_file_with_ai(pdf_file_path): # Modified to accept file path
     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
+
+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:**
@@ -294,7 +314,7 @@ def analyze_pdf_content_ai(pdf_text_content): # Copied from your code
             model=model_name,
             messages=[{"role": "user", "content": prompt_text}],
             temperature=0.4,
-            max_tokens=1024, # Adjust as needed
+            max_tokens=1024,  # Adjust as needed
             top_p=0.9,
         )
         the_response = response.choices[0].message.content
@@ -306,10 +326,12 @@ def analyze_pdf_content_ai(pdf_text_content): # Copied from your code
         return error_message, trace_data_detail_pdf_analysis
 
 
-def analyze_csv_file_with_ai(csv_file_path): # Modified to accept file path
+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
+        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:
@@ -324,7 +346,8 @@ def analyze_csv_file_with_ai(csv_file_path): # Modified to accept file path
     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
+
+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:**
@@ -352,7 +375,7 @@ def analyze_csv_content_ai(csv_content_string): # Copied from your code
             model=model_name,
             messages=[{"role": "user", "content": prompt_text}],
             temperature=0.4,
-            max_tokens=1024, # Adjust as needed
+            max_tokens=1024,  # Adjust as needed
             top_p=0.9,
         )
         the_response = response.choices[0].message.content
@@ -384,19 +407,21 @@ class CallbackManager:
         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)"
-        return "Authentication failed. Please check the code."
+            return (
+                f"<span style='color:#00FF7F;'>Authentication successful!</span> Access Token: {self.access_token[:10]}... (truncated)" # Neon Green Success
+            )
+        return "<span style='color:#FF4500;'>Authentication failed. Please check the code.</span>" # 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."
+                return "<span style='color:#FF8C00;'>Not authenticated. Please provide a valid authorization code first.</span>" # Neon Dark Orange
 
             # For demo purposes, if there's no actual API connected, return mock data
             # Remove this in production and use the real API call
-            if not hasattr(self.api, 'get_patients') or self.api.get_patients is None:
+            if not hasattr(self.api, "get_patients") or self.api.get_patients is None:
                 logger.info("Using mock patient data (no API connection)")
                 # Return mock FHIR bundle with patient data
                 mock_data = {
@@ -413,18 +438,14 @@ class CallbackManager:
                                     {
                                         "use": "official",
                                         "family": "Smith",
-                                        "given": ["John"]
+                                        "given": ["John"],
                                     }
                                 ],
                                 "gender": "male",
                                 "birthDate": "1970-01-01",
                                 "address": [
-                                    {
-                                        "city": "Boston",
-                                        "state": "MA",
-                                        "postalCode": "02108"
-                                    }
-                                ]
+                                    {"city": "Boston", "state": "MA", "postalCode": "02108"}
+                                ],
                             }
                         },
                         {
@@ -435,7 +456,7 @@ class CallbackManager:
                                     {
                                         "use": "official",
                                         "family": "Johnson",
-                                        "given": ["Jane"]
+                                        "given": ["Jane"],
                                     }
                                 ],
                                 "gender": "female",
@@ -444,12 +465,12 @@ class CallbackManager:
                                     {
                                         "city": "Cambridge",
                                         "state": "MA",
-                                        "postalCode": "02139"
+                                        "postalCode": "02139",
                                     }
-                                ]
+                                ],
                             }
-                        }
-                    ]
+                        },
+                    ],
                 }
                 return json.dumps(mock_data, indent=2)
 
@@ -457,17 +478,22 @@ class CallbackManager:
             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."
-            return "Failed to retrieve patient data."
+                return (
+                    json.dumps(patients, indent=2)
+                    if patients
+                    else "<span style='color:#FFFF00;'>No patient data returned.</span>" # Neon Yellow
+                )
+            return "<span style='color:#DC143C;'>Failed to retrieve patient data.</span>" # 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)}"
+            return f"<span style='color:#FF6347;'>Error retrieving patient data: {str(e)}</span> {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."
+            return "<span style='color:#FF8C00;'>Not authenticated. Please provide a valid authorization code first.</span>" # Neon Dark Orange
 
         try:
             # This would call the actual MeldRx API to get documents for a specific patient
@@ -486,42 +512,94 @@ class CallbackManager:
                     "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)}"
+            return f"<span style='color:#FF6347;'>Error retrieving patient documents: {str(e)}</span>: {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
+    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}
+    <div style='color:#00FFFF; font-family: monospace;'>
+    **Patient Discharge Form** <br>
+    - Name: {first_name} {middle_initial} {last_name} <br>
+    - Date of Birth: {dob}, Age: {age}, Sex: {sex} <br>
+    - Address: {address}, {city}, {state}, {zip_code} <br>
+    - Doctor: {doctor_first_name} {doctor_middle_initial} {doctor_last_name} <br>
+    - Hospital/Clinic: {hospital_name} <br>
+    - Doctor Address: {doctor_address}, {doctor_city}, {doctor_state}, {doctor_zip} <br>
+    - Admission Date: {admission_date}, Source: {referral_source}, Method: {admission_method} <br>
+    - Discharge Date: {discharge_date}, Reason: {discharge_reason} <br>
+    - Date of Death: {date_of_death} <br>
+    - Diagnosis: {diagnosis} <br>
+    - Procedures: {procedures} <br>
+    - Medications: {medications} <br>
     - Prepared By: {preparer_name}, {preparer_job_title}
+    </div>
     """
     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
+    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"""
 
@@ -539,7 +617,7 @@ def generate_pdf_from_form(
         "address": address,
         "city": city,
         "state": state,
-        "zip": zip_code
+        "zip": zip_code,
     }
 
     discharge_info = {
@@ -547,25 +625,27 @@ def generate_pdf_from_form(
         "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"
+        "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
+        "follow_up": "",  # Not collected in the form
     }
 
     medication_info = {
         "medications": [medications] if medications else [],
-        "instructions": ""  # Not collected in the form
+        "instructions": "",  # Not collected in the form
     }
 
     prepared_by = {
         "name": preparer_name,
         "title": preparer_job_title,
-        "signature": ""  # Not collected in the form
+        "signature": "",  # Not collected in the form
     }
 
     # Generate PDF
@@ -574,17 +654,18 @@ def generate_pdf_from_form(
         discharge_info,
         diagnosis_info,
         medication_info,
-        prepared_by
+        prepared_by,
     )
 
     # Create temporary file to save the PDF
-    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.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):
@@ -607,10 +688,10 @@ def generate_pdf_from_meldrx(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'),
+            "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
+            "physician": "Dr. Provider",  # Mock data
         }
 
         # Mock LLM-generated content -  This part needs to be replaced with actual AI generation if desired for MeldRx PDF
@@ -619,70 +700,91 @@ def generate_pdf_from_meldrx(patient_data):
             "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."
+            "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
+        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
+        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
+    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
+        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
+        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
+            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."""
+    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"
+        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
+            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")
+            "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
 
@@ -690,11 +792,12 @@ def generate_ai_discharge_content(patient_data):
         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."""
+    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
+    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)
@@ -723,60 +826,72 @@ def generate_pdf_from_meldrx_with_ai_content(patient_data, llm_content):
 
         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'),
+            "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
+            "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
+        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
+        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
+            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
+            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
+        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
+    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 gr.Blocks() as demo:
-    gr.Markdown("# Patient Discharge Form with MeldRx & Medical File Analysis + AI") # Updated title
+# Create the UI with the cyberpunk theme
+with gr.Blocks(theme=cyberpunk_theme) as demo: # Apply the theme here
+    gr.Markdown("<h1 style='color:#00FFFF; text-shadow: 0 0 5px #00FFFF;'>Discharge Guard <span style='color:#FF00FF; text-shadow: 0 0 5px #FF00FF;'>Cyber</span></h1>") # Cyberpunk Title
 
-    with gr.Tab("Authenticate with MeldRx"):
-        gr.Markdown("## SMART on FHIR Authentication")
+    with gr.Tab("Authenticate with MeldRx", elem_classes="cyberpunk-tab"): # Optional: Class for tab styling
+        gr.Markdown("<h2 style='color:#00FFFF; text-shadow: 0 0 3px #00FFFF;'>SMART on FHIR Authentication</h2>") # 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.") # Updated instructions
+        gr.Markdown("<p style='color:#A9A9A9;'>Copy the URL above, open it in a browser, log in, and paste the <span style='color:#00FFFF;'>entire redirected URL</span> from your browser's address bar below.</p>") # 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") # Button to extract code
+        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")
-        auth_result = gr.Textbox(label="Authentication Result")
+        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")
+        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)") # Renamed button
+        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
 
@@ -784,37 +899,39 @@ with gr.Blocks() as demo:
             """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!"
+                return auth_code, "<span style='color:#00FF7F;'>Authorization code extracted!</span>" # Neon Green Success
             else:
-                return "", error_message or "Could not extract authorization code."
+                return "", f"<span style='color:#FF4500;'>Could not extract authorization code.</span> {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
+            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
+            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("<h2 style='color:#00FFFF; text-shadow: 0 0 3px #00FFFF;'>Patient Data</h2>") # Neon Tab Header
+        dashboard_output = gr.HTML("<p style='color:#A9A9A9;'>Fetch patient data from the Authentication tab first.</p>") # Subdued placeholder text
 
-    with gr.Tab("Patient Dashboard"):
-        gr.Markdown("## Patient Data")
-        dashboard_output = gr.HTML("<p>Fetch patient data from the Authentication tab first.</p>")
-
-        refresh_btn = gr.Button("Refresh Data")
+        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"<p>{data}</p>"
+                if (
+                    data.startswith("<span style='color:#FF8C00;'>Not authenticated")
+                    or data.startswith("<span style='color:#DC143C;'>Failed")
+                    or data.startswith("<span style='color:#FF6347;'>Error")
+                ):
+                    return f"<p style='color:#FF8C00;'>{data}</p>" # Show auth errors in orange
 
                 try:
                     # Parse the data
@@ -828,7 +945,7 @@ with gr.Blocks() as demo:
                             patients.append(resource)
 
                     # Generate HTML card
-                    html = "<h3>Patients</h3>"
+                    html = "<h3 style='color:#00FFFF; text-shadow: 0 0 2px #00FFFF;'>Patients</h3>" # Neon Sub-header
                     for patient in patients:
                         # Extract name
                         name = patient.get("name", [{}])[0]
@@ -839,24 +956,25 @@ with gr.Blocks() as demo:
                         gender = patient.get("gender", "unknown").capitalize()
                         birth_date = patient.get("birthDate", "Unknown")
 
-                        # Generate HTML card
+                        # Generate HTML card with cyberpunk styling
                         html += f"""
-                        <div style="border: 1px solid #ddd; padding: 10px; margin: 10px 0; border-radius: 5px;">
-                            <h4>{given} {family}</h4>
-                            <p><strong>Gender:</strong> {gender}</p>
-                            <p><strong>Birth Date:</strong> {birth_date}</p>
-                            <p><strong>ID:</strong> {patient.get("id", "Unknown")}</p>
+                        <div style="border: 1px solid #00FFFF; padding: 10px; margin: 10px 0; border-radius: 5px; background-color: #222; box-shadow: 0 0 5px #00FFFF;">
+                            <h4 style='color:#00FFFF;'>{given} {family}</h4>
+                            <p style='color:#A9A9A9;'><strong>Gender:</strong> <span style='color:#00FFFF;'>{gender}</span></p>
+                            <p style='color:#A9A9A9;'><strong>Birth Date:</strong> <span style='color:#00FFFF;'>{birth_date}</span></p>
+                            <p style='color:#A9A9A9;'><strong>ID:</strong> <span style='color:#00FFFF;'>{patient.get("id", "Unknown")}</span></p>
                         </div>
                         """
 
                     return html
                 except Exception as e:
-                    return f"<p>Error parsing patient data: {str(e)}</p>"
+                    return f"<p style='color:#FF6347;'>Error parsing patient data: {str(e)}</p>" # Tomato Error
             except Exception as e:
-                return f"<p>Error fetching patient data: {str(e)}</p>"
+                return f"<p style='color:#FF6347;'>Error fetching patient data: {str(e)}</p>" # Tomato Error
 
-    with gr.Tab("Discharge Form"):
-        gr.Markdown("## Patient Details")
+
+    with gr.Tab("Discharge Form", elem_classes="cyberpunk-tab"): # Optional: Class for tab styling
+        gr.Markdown("<h2 style='color:#00FFFF; text-shadow: 0 0 3px #00FFFF;'>Patient Details</h2>") # Neon Tab Header
         with gr.Row():
             first_name = gr.Textbox(label="First Name")
             last_name = gr.Textbox(label="Last Name")
@@ -870,174 +988,244 @@ with gr.Blocks() as demo:
             city = gr.Textbox(label="City")
             state = gr.Textbox(label="State")
             zip_code = gr.Textbox(label="Zip Code")
-        gr.Markdown("## Primary Healthcare Professional Details")
+        gr.Markdown("<h2 style='color:#00FFFF; text-shadow: 0 0 3px #00FFFF;'>Primary Healthcare Professional Details</h2>") # 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="Middle Initial")
+            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")
+        gr.Markdown("<h2 style='color:#00FFFF; text-shadow: 0 0 3px #00FFFF;'>Admission and Discharge Details</h2>") # 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")
+            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")
+        gr.Markdown("<h2 style='color:#00FFFF; text-shadow: 0 0 3px #00FFFF;'>Diagnosis & Procedures</h2>") # Neon Sub-header
         diagnosis = gr.Textbox(label="Diagnosis")
         procedures = gr.Textbox(label="Operation & Procedures")
-        gr.Markdown("## Medication Details")
+        gr.Markdown("<h2 style='color:#00FFFF; text-shadow: 0 0 3px #00FFFF;'>Medication Details</h2>") # Neon Sub-header
         medications = gr.Textbox(label="Medication on Discharge")
-        gr.Markdown("## Prepared By")
+        gr.Markdown("<h2 style='color:#00FFFF; text-shadow: 0 0 3px #00FFFF;'>Prepared By</h2>") # 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")
-            submit_pdf = gr.Button("Generate PDF (No AI)") # Renamed button to clarify no AI
+            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.Markdown()
-        pdf_output = gr.File(label="Download PDF (No AI)") # Renamed output to clarify no AI
+        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
+                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
+            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
+                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
+            outputs=pdf_output,
         )
 
-    with gr.Tab("Medical File Analysis"):
-        gr.Markdown("## Analyze Medical Files with Discharge Guard AI")
+    with gr.Tab("Medical File Analysis", elem_classes="cyberpunk-tab"): # Optional: Class for tab styling
+        gr.Markdown("<h2 style='color:#00FFFF; text-shadow: 0 0 3px #00FFFF;'>Analyze Medical Files with Discharge Guard AI</h2>") # Neon Tab Header
         with gr.Column():
-            dicom_file = gr.File(file_types=['.dcm'], label="Upload DICOM File (.dcm)")
+            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")
+            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_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")
+            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_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")
+            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_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")
-
-            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") # Redundant
-            pdf_file = gr.File(file_types=['.pdf'], label="Upload PDF File (.pdf)")
+            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")
+            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_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")
-
+            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_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_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_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_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_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_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
+            analyze_csv_file_with_ai, inputs=csv_file, outputs=csv_ai_output
         )
 
-
-    with gr.Tab("One-Click Discharge Paper (AI)"): # New Tab for One-Click Discharge Paper with AI
-        gr.Markdown("## One-Click Medical Discharge Paper Generation with AI Content") # Updated title
-        one_click_ai_pdf_button = gr.Button("Generate Discharge Paper with AI (One-Click)") # Updated button label
-        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
+    with gr.Tab(
+        "One-Click Discharge Paper (AI)", elem_classes="cyberpunk-tab"
+    ):  # New Tab for One-Click Discharge Paper with AI, styled
+        gr.Markdown("<h2 style='color:#00FFFF; text-shadow: 0 0 3px #00FFFF;'>One-Click Medical Discharge Paper Generation with AI Content</h2>") # 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
+            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]
+            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
+        outputs=patient_data_output,
     )
 
     # Connect refresh button to update dashboard
     refresh_btn.click(
-        fn=update_dashboard,
-        inputs=None,
-        outputs=dashboard_output
+        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]
+        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
+        fn=update_dashboard, inputs=None, outputs=dashboard_output
     )
 
 # Launch with sharing enabled for public access