Update app.py

app.py

@@ -1,4 +1,4 @@
-import streamlit as st
+import gradio as gr
 import requests
 import json
 from datetime import datetime, date
@@ -19,19 +19,18 @@ TWILIO_ACCOUNT_SID = os.getenv("TWILIO_ACCOUNT_SID")
 TWILIO_AUTH_TOKEN = os.getenv("TWILIO_AUTH_TOKEN")
 TWILIO_PHONE = os.getenv("TWILIO_PHONE")
 CALENDLY_API_TOKEN = os.getenv("CALENDLY_API_TOKEN")
-
-# Salesforce REST API Configuration
 SALESFORCE_BASE_URL = os.getenv("SALESFORCE_INSTANCE_URL", "https://your_instance.salesforce.com/services/data/v60.0/")
-SALESFORCE_HEADERS = {
-    "Authorization": f"Bearer {SALESFORCE_ACCESS_TOKEN}",
-    "Content-Type": "application/json"
-}
 
 # Validate environment variables
 if not all([HF_API_TOKEN, SALESFORCE_ACCESS_TOKEN, TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, TWILIO_PHONE, CALENDLY_API_TOKEN]):
-    st.error("Missing environment variables. Please configure API tokens in Hugging Face Spaces secrets.")
     logging.error("Missing environment variables for API integrations.")
-    st.stop()
+    raise ValueError("Missing environment variables. Configure API tokens in Hugging Face Spaces secrets.")
+
+# Salesforce REST API Headers
+SALESFORCE_HEADERS = {
+    "Authorization": f"Bearer {SALESFORCE_ACCESS_TOKEN}",
+    "Content-Type": "application/json"
+}
 
 # Hugging Face Client
 class HuggingFaceClient:
@@ -158,116 +157,69 @@ class CalendlyClient:
             logging.error(f"Failed to schedule Calendly event: {str(e)}")
             return None
 
-# Streamlit App
-def main():
-    st.set_page_config(page_title="AI-Powered Patient Follow-up Agent", layout="wide", initial_sidebar_state="expanded")
-    
-    # Custom CSS for attractive UI
-    st.markdown("""
-        <style>
-        .stApp { background-color: #f0f2f6; }
-        .stButton>button { background-color: #4CAF50; color: white; border-radius: 5px; }
-        .stTextInput>label { font-weight: bold; }
-        .sidebar .sidebar-content { background-color: #ffffff; }
-        .stDataFrame { border: 1px solid #ddd; border-radius: 5px; }
-        </style>
-    """, unsafe_allow_html=True)
-
-    # Initialize clients
+# Gradio Interface Functions
+hf_client = HuggingFaceClient(HF_API_TOKEN)
+sf_client = SalesforceClient(SALESFORCE_BASE_URL, SALESFORCE_HEADERS)
+twilio_client = TwilioClient(TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, TWILIO_PHONE)
+calendly_client = CalendlyClient(CALENDLY_API_TOKEN)
+
+def register_patient(phone, email, language, consent_status):
     try:
-        hf_client = HuggingFaceClient(HF_API_TOKEN)
-        sf_client = SalesforceClient(SALESFORCE_BASE_URL, SALESFORCE_HEADERS)
-        twilio_client = TwilioClient(TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, TWILIO_PHONE)
-        calendly_client = CalendlyClient(CALENDLY_API_TOKEN)
+        name = f"PAT-{str(uuid.uuid4())[:6]}"  # Auto-generated
+        patient_data = {
+            "Name": name, "Phone__c": phone, "Email__c": email,
+            "Language__c": language, "ConsentGiven__c": consent_status
+        }
+        patient_id = sf_client.create_record("Patient__c", patient_data)
+        if patient_id:
+            logging.info(f"Registered patient: {name}")
+            return f"Patient {name} registered successfully!"
+        return "Failed to register patient."
     except Exception as e:
-        st.error(f"Failed to initialize clients: {str(e)}")
-        logging.error(f"Client initialization failed: {str(e)}")
-        st.stop()
-
-    # Sidebar navigation
-    pages = ["Patient Registration", "Consent Form", "Follow-up Messaging", "Risk Dashboard", 
-             "Appointment Scheduling", "Survey"]
-    choice = st.sidebar.selectbox("Navigate", pages, key="nav_select")
-
-    if choice == "Patient Registration":
-        st.header("Patient Registration")
-        with st.form("patient_form", clear_on_submit=True):
-            name = f"PAT-{str(uuid.uuid4())[:6]}"  # Auto-generated
-            st.write(f"Patient ID: {name}")
-            phone = st.text_input("Phone Number", placeholder="+1234567890")
-            email = st.text_input("Email", placeholder="patient@example.com")
-            language = st.selectbox("Language", ["English", "Spanish", "French"], key="patient_lang")
-            consent_status = st.selectbox("Consent Status", ["Approved", "Awaiting", "Denied"], key="patient_consent")
-            submit = st.form_submit_button("Register Patient")
-            if submit and phone and email:
-                patient_data = {
-                    "Name": name, "Phone__c": phone, "Email__c": email,
-                    "Language__c": language, "ConsentGiven__c": consent_status
-                }
-                patient_id = sf_client.create_record("Patient__c", patient_data)
-                if patient_id:
-                    st.success(f"Patient {name} registered successfully!")
-                    logging.info(f"Registered patient: {name}")
-                else:
-                    st.error("Failed to register patient.")
-                    logging.error("Failed to register patient.")
-
-    elif choice == "Consent Form":
-        st.header("Consent Form")
-        with st.form("consent_form", clear_on_submit=True):
-            patient_phone = st.text_input("Patient Phone Number", placeholder="+1234567890")
-            method = st.selectbox("Consent Method", ["SMS", "Email", "In-Person", "Phone"], key="consent_method")
-            submit = st.form_submit_button("Submit Consent")
-            if submit and patient_phone:
-                patients = sf_client.query_records(f"SELECT Id FROM Patient__c WHERE Phone__c = '{patient_phone}'")
-                if patients:
-                    consent_data = {"Method__c": method, "GivenOn__c": date.today().isoformat()}
-                    consent_id = sf_client.create_record("Consent__c", consent_data)
-                    if consent_id:
-                        st.success("Consent recorded successfully!")
-                        logging.info("Consent recorded.")
-                    else:
-                        st.error("Failed to record consent.")
-                        logging.error("Failed to record consent.")
-                else:
-                    st.error("Patient not found.")
-                    logging.error(f"Patient not found for phone: {patient_phone}")
-
-    elif choice == "Follow-up Messaging":
-        st.header("Follow-up Messaging")
-        with st.form("followup_form", clear_on_submit=True):
-            patient_phone = st.text_input("Patient Phone Number", placeholder="+1234567890")
-            message_template = st.text_area("Message Template", "How are you feeling today?")
-            follow_up_date = st.date_input("Follow-up Date", value=date.today())
-            submit = st.form_submit_button("Schedule Follow-up")
-            if submit and patient_phone:
-                patients = sf_client.query_records(f"SELECT Id, ConsentGiven__c, Language__c FROM Patient__c WHERE Phone__c = '{patient_phone}'")
-                if patients and patients[0]["ConsentGiven__c"] == "Approved":
-                    followup_data = {
-                        "Patient__c": patients[0]["Id"], "FollowUpDate__c": follow_up_date.isoformat(),
-                        "MessageTemplate__c": message_template, "Status__c": "Scheduled"
-                    }
-                    followup_id = sf_client.create_record("FollowUpPlan__c", followup_data)
-                    if followup_id:
-                        if twilio_client.send_message(patient_phone, message_template):
-                            sf_client.create_record("MessageLog__c", {
-                                "Patient__c": patients[0]["Id"], "MessageText__c": message_template,
-                                "Direction__c": "Outbound", "Timestamp__c": datetime.utcnow().isoformat()
-                            })
-                            st.success("Follow-up scheduled and message sent!")
-                            logging.info(f"Follow-up scheduled for patient: {patients[0]['Id']}")
-                        else:
-                            st.error("Failed to send message.")
-                            logging.error("Failed to send Twilio message.")
-                    else:
-                        st.error("Failed to schedule follow-up.")
-                        logging.error("Failed to create FollowUpPlan__c.")
-                else:
-                    st.error("Patient not found or consent not approved.")
-                    logging.error(f"Consent check failed for phone: {patient_phone}")
-
-    elif choice == "Risk Dashboard":
-        st.header("Risk Analysis Dashboard")
+        logging.error(f"Error registering patient: {str(e)}")
+        return f"Error: {str(e)}"
+
+def submit_consent(patient_phone, method):
+    try:
+        patients = sf_client.query_records(f"SELECT Id FROM Patient__c WHERE Phone__c = '{patient_phone}'")
+        if patients:
+            consent_data = {"Method__c": method, "GivenOn__c": date.today().isoformat()}
+            consent_id = sf_client.create_record("Consent__c", consent_data)
+            if consent_id:
+                logging.info("Consent recorded.")
+                return "Consent recorded successfully!"
+            return "Failed to record consent."
+        return "Patient not found."
+    except Exception as e:
+        logging.error(f"Error submitting consent: {str(e)}")
+        return f"Error: {str(e)}"
+
+def schedule_followup(patient_phone, message_template, follow_up_date):
+    try:
+        patients = sf_client.query_records(f"SELECT Id, ConsentGiven__c, Language__c FROM Patient__c WHERE Phone__c = '{patient_phone}'")
+        if patients and patients[0]["ConsentGiven__c"] == "Approved":
+            followup_data = {
+                "Patient__c": patients[0]["Id"], "FollowUpDate__c": follow_up_date.isoformat(),
+                "MessageTemplate__c": message_template, "Status__c": "Scheduled"
+            }
+            followup_id = sf_client.create_record("FollowUpPlan__c", followup_data)
+            if followup_id:
+                if twilio_client.send_message(patient_phone, message_template):
+                    sf_client.create_record("MessageLog__c", {
+                        "Patient__c": patients[0]["Id"], "MessageText__c": message_template,
+                        "Direction__c": "Outbound", "Timestamp__c": datetime.utcnow().isoformat()
+                    })
+                    logging.info(f"Follow-up scheduled for patient: {patients[0]['Id']}")
+                    return "Follow-up scheduled and message sent!"
+                return "Failed to send message."
+            return "Failed to schedule follow-up."
+        return "Patient not found or consent not approved."
+    except Exception as e:
+        logging.error(f"Error scheduling follow-up: {str(e)}")
+        return f"Error: {str(e)}"
+
+def view_risk_dashboard():
+    try:
         symptom_logs = sf_client.query_records("SELECT Patient__c, ResponseText__c, RiskScore__c, Severity__c, Sentiment__c FROM SymptomLog__c")
         if symptom_logs:
             df = pd.DataFrame([
@@ -275,86 +227,156 @@ def main():
                  "Risk Score": log["RiskScore__c"], "Severity": log["Severity__c"], 
                  "Sentiment": log["Sentiment__c"]} for log in symptom_logs
             ])
-            st.dataframe(df, use_container_width=True)
-            st.bar_chart(df.groupby("Severity__c").size())
-            for log in symptom_logs:
-                if log["Severity__c"] == "High":
-                    st.warning(f"High Risk: Patient {log['Patient__c']} - {log['ResponseText__c']}")
-                    if st.button(f"Escalate Case for Patient {log['Patient__c']}", key=f"escalate_{log['Patient__c']}"):
+            high_risk = df[df["Severity"] == "High"]
+            return df, high_risk.to_dict('records') if not high_risk.empty else "No high-risk cases."
+        return pd.DataFrame(), "No symptom logs available."
+    except Exception as e:
+        logging.error(f"Error loading risk dashboard: {str(e)}")
+        return pd.DataFrame(), f"Error: {str(e)}"
+
+def escalate_case(patient_id, response_text):
+    try:
+        case_data = {
+            "RelatedPatient__c": patient_id, "Priority__c": "High",
+            "Description__c": f"High-risk response: {response_text}"
+        }
+        case_id = sf_client.create_record("Case__c", case_data)
+        if case_id:
+            logging.info(f"Case created for patient: {patient_id}")
+            return "Case created successfully!"
+        return "Failed to create case."
+    except Exception as e:
+        logging.error(f"Error escalating case: {str(e)}")
+        return f"Error: {str(e)}"
+
+def schedule_appointment(patient_email, event_type_uuid):
+    try:
+        event_time = calendly_client.create_event(patient_email, event_type_uuid)
+        if event_time:
+            appointment_data = {"DateTime__c": event_time, "Status__c": "Scheduled"}
+            appointment_id = sf_client.create_record("Appointment__c", appointment_data)
+            if appointment_id:
+                logging.info(f"Appointment scheduled for {patient_email}")
+                return f"Appointment scheduled for {event_time}!"
+            return "Failed to create appointment record."
+        return "Failed to schedule appointment."
+    except Exception as e:
+        logging.error(f"Error scheduling appointment: {str(e)}")
+        return f"Error: {str(e)}"
+
+def submit_survey(patient_phone, question, answer):
+    try:
+        patients = sf_client.query_records(f"SELECT Id, Language__c FROM Patient__c WHERE Phone__c = '{patient_phone}'")
+        if patients:
+            survey_data = {"Question__c": question, "Answer__c": answer}
+            survey_id = sf_client.create_record("Survey__c", survey_data)
+            if survey_id:
+                analysis = hf_client.analyze_response(answer, patients[0]["Language__c"])
+                if analysis:
+                    symptom_data = {
+                        "Patient__c": patients[0]["Id"], "ResponseText__c": answer,
+                        "RiskScore__c": analysis["risk_level"], "Severity__c": analysis["severity_score"],
+                        "Sentiment__c": analysis["sentiment_score"]
+                    }
+                    symptom_id = sf_client.create_record("SymptomLog__c", symptom_data)
+                    if symptom_id and analysis["risk_level"] == "High":
                         case_data = {
-                            "RelatedPatient__c": log["Patient__c"], "Priority__c": "High",
-                            "Description__c": f"High-risk response: {log['ResponseText__c']}"
+                            "RelatedPatient__c": patients[0]["Id"], "Priority__c": "High",
+                            "Description__c": f"High-risk survey response: {answer}"
                         }
-                        case_id = sf_client.create_record("Case__c", case_data)
-                        if case_id:
-                            st.success("Case created!")
-                            logging.info(f"Case created for patient: {log['Patient__c']}")
-                        else:
-                            st.error("Failed to create case.")
-                            logging.error("Failed to create Case__c.")
-        else:
-            st.info("No symptom logs available.")
-            logging.info("No symptom logs found for dashboard.")
-
-    elif choice == "Appointment Scheduling":
-        st.header("Schedule Appointment")
-        with st.form("appointment_form", clear_on_submit=True):
-            patient_email = st.text_input("Patient Email", placeholder="patient@example.com")
-            event_type_uuid = st.text_input("Calendly Event Type UUID", placeholder="your_event_type_uuid")
-            submit = st.form_submit_button("Schedule Appointment")
-            if submit and patient_email and event_type_uuid:
-                event_time = calendly_client.create_event(patient_email, event_type_uuid)
-                if event_time:
-                    appointment_data = {"DateTime__c": event_time, "Status__c": "Scheduled"}
-                    appointment_id = sf_client.create_record("Appointment__c", appointment_data)
-                    if appointment_id:
-                        st.success(f"Appointment scheduled for {event_time}!")
-                        logging.info(f"Appointment scheduled for {patient_email}")
-                    else:
-                        st.error("Failed to create appointment record.")
-                        logging.error("Failed to create Appointment__c.")
-                else:
-                    st.error("Failed to schedule appointment.")
-                    logging.error("Failed to schedule Calendly event.")
-
-    elif choice == "Survey":
-        st.header("Patient Survey")
-        with st.form("survey_form", clear_on_submit=True):
-            patient_phone = st.text_input("Patient Phone Number", placeholder="+1234567890")
-            question = st.text_input("Question", placeholder="How satisfied are you with your visit?")
-            answer = st.text_area("Answer")
-            submit = st.form_submit_button("Submit Survey")
-            if submit and patient_phone and question and answer:
-                patients = sf_client.query_records(f"SELECT Id, Language__c FROM Patient__c WHERE Phone__c = '{patient_phone}'")
-                if patients:
-                    survey_data = {"Question__c": question, "Answer__c": answer}
-                    survey_id = sf_client.create_record("Survey__c", survey_data)
-                    if survey_id:
-                        analysis = hf_client.analyze_response(answer, patients[0]["Language__c"])
-                        if analysis:
-                            symptom_data = {
-                                "Patient__c": patients[0]["Id"], "ResponseText__c": answer,
-                                "RiskScore__c": analysis["risk_level"], "Severity__c": analysis["severity_score"],
-                                "Sentiment__c": analysis["sentiment_score"]
-                            }
-                            symptom_id = sf_client.create_record("SymptomLog__c", symptom_data)
-                            if symptom_id and analysis["risk_level"] == "High":
-                                case_data = {
-                                    "RelatedPatient__c": patients[0]["Id"], "Priority__c": "High",
-                                    "Description__c": f"High-risk survey response: {answer}"
-                                }
-                                sf_client.create_record("Case__c", case_data)
-                            st.success("Survey submitted and analyzed!")
-                            logging.info(f"Survey submitted for patient: {patients[0]['Id']}")
-                        else:
-                            st.error("Failed to analyze survey response.")
-                            logging.error("Failed to analyze survey response.")
-                    else:
-                        st.error("Failed to submit survey.")
-                        logging.error("Failed to create Survey__c.")
-                else:
-                    st.error("Patient not found.")
-                    logging.error(f"Patient not found for phone: {patient_phone}")
+                        sf_client.create_record("Case__c", case_data)
+                    logging.info(f"Survey submitted for patient: {patients[0]['Id']}")
+                    return "Survey submitted and analyzed!"
+                return "Failed to analyze survey response."
+            return "Failed to submit survey."
+        return "Patient not found."
+    except Exception as e:
+        logging.error(f"Error submitting survey: {str(e)}")
+        return f"Error: {str(e)}"
+
+# Gradio Interface
+with gr.Blocks(theme=gr.themes.Soft(), title="AI-Powered Patient Follow-up Agent") as demo:
+    gr.Markdown("# AI-Powered Patient Follow-up Agent for Clinics")
+    
+    with gr.Tabs():
+        with gr.Tab("Patient Registration"):
+            phone_input = gr.Textbox(label="Phone Number", placeholder="+1234567890")
+            email_input = gr.Textbox(label="Email", placeholder="patient@example.com")
+            language_input = gr.Dropdown(["English", "Spanish", "French"], label="Language")
+            consent_input = gr.Dropdown(["Approved", "Awaiting", "Denied"], label="Consent Status")
+            register_button = gr.Button("Register Patient")
+            register_output = gr.Textbox(label="Result")
+            register_button.click(
+                fn=register_patient,
+                inputs=[phone_input, email_input, language_input, consent_input],
+                outputs=register_output
+            )
+
+        with gr.Tab("Consent Form"):
+            consent_phone_input = gr.Textbox(label="Patient Phone Number", placeholder="+1234567890")
+            consent_method_input = gr.Dropdown(["SMS", "Email", "In-Person", "Phone"], label="Consent Method")
+            consent_button = gr.Button("Submit Consent")
+            consent_output = gr.Textbox(label="Result")
+            consent_button.click(
+                fn=submit_consent,
+                inputs=[consent_phone_input, consent_method_input],
+                outputs=consent_output
+            )
+
+        with gr.Tab("Follow-up Messaging"):
+            followup_phone_input = gr.Textbox(label="Patient Phone Number", placeholder="+1234567890")
+            message_template_input = gr.Textbox(label="Message Template", value="How are you feeling today?")
+            followup_date_input = gr.Textbox(label="Follow-up Date (YYYY-MM-DD)", value=date.today().isoformat())
+            followup_button = gr.Button("Schedule Follow-up")
+            followup_output = gr.Textbox(label="Result")
+            followup_button.click(
+                fn=schedule_followup,
+                inputs=[followup_phone_input, message_template_input, followup_date_input],
+                outputs=followup_output
+            )
+
+        with gr.Tab("Risk Dashboard"):
+            dashboard_button = gr.Button("Load Dashboard")
+            dashboard_table = gr.Dataframe(label="Symptom Logs")
+            high_risk_output = gr.Textbox(label="High-Risk Cases")
+            dashboard_button.click(
+                fn=view_risk_dashboard,
+                outputs=[dashboard_table, high_risk_output]
+            )
+            with gr.Row():
+                escalate_id_input = gr.Textbox(label="Patient ID (for escalation)")
+                escalate_response_input = gr.Textbox(label="Response Text")
+                escalate_button = gr.Button("Submit Case Escalation")
+                escalate_output = gr.Textbox(label="Result")
+                escalate_button.click(
+                    fn=escribe_case,
+                    inputs=[escalate_id_input, escalate_response_input],
+                    outputs=escalate_output
+                )
+
+        with gr.Tab("Appointment Scheduling"):
+            appt_email_input = gr.Textbox(label="Patient Email", placeholder="patient@example.com")
+            event_type_input = gr.Textbox(label="Calendly Event Type UUID", placeholder="your_event_type_uuid")
+            appt_button = gr.Button("Schedule Appointment")
+            appt_output = gr.Textbox(label="Result")
+            appt_button.click(
+                fn=schedule_appointment,
+                inputs=[appt_email_input, event_type_input],
+                outputs=appt_output
+            )
+
+        with gr.Tab("Survey"):
+            survey_phone_input = gr.Textbox(label="Patient Phone Number", placeholder="+1234567890")
+            survey_question_input = gr.Textbox(label="Question", placeholder="How satisfied are you with your visit?")
+            survey_answer_input = gr.Textbox(label="Answer", lines=4)
+            survey_button = gr.Button("Submit Survey")
+            survey_output = gr.Textbox(label="Result")
+            survey_button.click(
+                fn=submit_survey,
+                inputs=[survey_phone_input, survey_question_input, survey_answer_input],
+                outputs=survey_output
+            )
 
+# Launch Gradio app
 if __name__ == "__main__":
-    main()
+    demo.launch(server_name="0.0.0.0", server_port=7860)