Upload 14 files

README.md

@@ -4,7 +4,7 @@ emoji: 🩺
 colorFrom: blue
 colorTo: indigo
 sdk: gradio
-sdk_version: "4.16.0"
+sdk_version: "4.27.0"
 app_file: app.py
 pinned: false
 ---

add_reports.py

@@ -0,0 +1,32 @@
+import gradio as gr
+import csv
+import os
+
+FILE = "reports.csv"
+
+def init_file():
+    if not os.path.exists(FILE):
+        with open(FILE, 'w', newline='') as file:
+            writer = csv.writer(file)
+            writer.writerow(["Report ID", "Patient", "Report Type", "Details"])
+
+def write_report(patient, rtype, details):
+    init_file()
+    with open(FILE, 'r') as file:
+        rows = list(csv.reader(file))
+    idx = len(rows)
+    with open(FILE, 'a', newline='') as file:
+        writer = csv.writer(file)
+        writer.writerow([idx, patient, rtype, details])
+    return f"✅ Report #{idx} added for {patient}"
+
+def gradio_interface():
+    init_file()
+    with gr.Blocks() as demo:
+        gr.Markdown("## 📤 Add Medical Report")
+        pat = gr.Textbox(label="Patient")
+        typ = gr.Textbox(label="Report Type")
+        det = gr.Textbox(label="Details")
+        res = gr.Textbox(label="Result")
+        gr.Button("Upload").click(fn=write_report, inputs=[pat, typ, det], outputs=res)
+    return demo

app (1).py

@@ -0,0 +1,138 @@
+import gradio as gr
+
+# Function to handle authentication
+def authenticate(hospital_name, username, password):
+    """Simple authentication logic."""
+    # You can replace this logic with actual authentication (e.g., checking against a database)
+    return True  # Bypassing actual authentication for simplicity
+
+def register_patient_page():
+    import register_patient
+    return register_patient.create_gradio_interface()
+
+def book_appointment_page():
+    import book_appointment
+    return book_appointment.create_gradio_interface()
+
+def consultation_page():
+    import consultation
+    return consultation.gradio_interface()
+
+def view_consultation_page():
+    import view_consultation
+    return view_consultation.gradio_interface()
+
+def view_appointments_page():
+    import view_appointments
+    return view_appointments.gradio_interface()
+
+def add_reports_page():
+    import add_reports
+    return add_reports.gradio_interface()
+
+def view_patient_reports_page():
+    import view_patient_reports
+    return view_patient_reports.create_gradio_interface()
+
+def connect_doctor_page():
+    import connect_doctor
+    return connect_doctor.create_gradio_interface()
+
+# Role selection interface
+def role_selection():
+    return gr.Radio(choices=["Doctor Management", "Patient Management"], label="Select Your Role")
+
+# Update visible tabs based on role
+def update_role(role):
+    if role == "Doctor Management":
+        return (
+            gr.update(visible=True),  # Doctor View Appointments Tab (Now First)
+            gr.update(visible=True),  # Doctor Consultation Tab (Now Second)
+            gr.update(visible=True),  # Doctor Add Reports Tab
+            gr.update(visible=False),  # Patient Register Tab
+            gr.update(visible=False),  # Patient Book Appointment Tab
+            gr.update(visible=False),  # Patient View Consultation Tab
+            gr.update(visible=False),  # Patient View Patient Reports Tab
+            gr.update(visible=True)   # Connect Doctor Tab
+        )
+    elif role == "Patient Management":
+        return (
+            gr.update(visible=False),  # Doctor View Appointments Tab
+            gr.update(visible=False),  # Doctor Consultation Tab
+            gr.update(visible=False),  # Doctor Add Reports Tab
+            gr.update(visible=True),   # Patient Register Tab
+            gr.update(visible=True),   # Patient Book Appointment Tab
+            gr.update(visible=True),   # Patient View Consultation Tab
+            gr.update(visible=True),   # Patient View Patient Reports Tab
+            gr.update(visible=True)    # Connect Doctor Tab
+        )
+
+# Define the app layout with login functionality
+with gr.Blocks() as app:
+    gr.Markdown("## Multi-Tenant Patient Management App")
+
+    # Multi-Tenant Login Section
+    hospital_name = gr.Dropdown(choices=["Hospital A", "Hospital B"], label="Select Hospital")
+    username = gr.Textbox(label="Username")
+    password = gr.Textbox(label="Password", type="password")
+    login_button = gr.Button("Login")
+    login_output = gr.Textbox(label="Login Status", interactive=False)
+    role_radio = gr.Radio(choices=["Doctor Management", "Patient Management"], label="Select Your Role", visible=False)
+
+    # Placeholder for showing/hiding the app sections
+    app_section = gr.Group(visible=False)
+
+    # Login Action
+    def login_action(hospital_name, username, password):
+        if authenticate(hospital_name, username, password):
+            return gr.update(visible=True), gr.update(visible=True), "Login successful!"
+        else:
+            return gr.update(visible=False), gr.update(visible=False), "Invalid credentials, please try again."
+
+    login_button.click(
+        login_action,
+        inputs=[hospital_name, username, password],
+        outputs=[app_section, role_radio, login_output]
+    )
+
+    # Doctor tabs
+    with app_section:
+        with gr.Tab("View Appointments", visible=False) as doctor_view_appt_tab:
+            view_appointments_page()
+
+        with gr.Tab("Consultation", visible=False) as doctor_consult_tab:
+            consultation_page()
+
+        with gr.Tab("Add Reports", visible=False) as doctor_add_reports_tab:
+            add_reports_page()
+
+        # Patient tabs
+        with gr.Tab("Register Patient", visible=False) as patient_reg_tab:
+            register_patient_page()
+
+        with gr.Tab("Book Appointment", visible=False) as patient_book_appt_tab:
+            book_appointment_page()
+
+        with gr.Tab("View Consultation", visible=False) as patient_view_consult_tab:
+            view_consultation_page()
+
+        with gr.Tab("View Patient Reports", visible=False) as patient_view_reports_tab:
+            view_patient_reports_page()
+
+        # Common tab for both roles
+        with gr.Tab("Connect Doctor", visible=False) as connect_doctor_tab:
+            connect_doctor_page()
+
+        # Function to update visible tabs based on role selection
+        role_radio.change(
+            fn=update_role,
+            inputs=role_radio,
+            outputs=[
+                doctor_view_appt_tab, doctor_consult_tab, doctor_add_reports_tab,
+                patient_reg_tab, patient_book_appt_tab, patient_view_consult_tab,
+                patient_view_reports_tab, connect_doctor_tab
+            ]
+        )
+
+if __name__ == "__main__":
+    app.launch()

app.py

@@ -9,6 +9,8 @@ import view_appointments
 import add_reports
 import view_patient_reports
 import connect_doctor
+import medbot_chat
+import symptom_checker
 
 # Authentication (simplified)
 def authenticate(hospital_name, username, password):
@@ -59,6 +61,10 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue")) as demo:
         ])
 
         with gr.Tabs():
+            with gr.Tab("💬 MedBot", elem_id="chat_tab", visible=True):
+                medbot_chat.create_gradio_interface()
+            with gr.Tab("🧠 Symptom Checker", elem_id="diagnosis_tab", visible=True):
+                symptom_checker.create_gradio_interface()
             with gr.Tab("📅 View Appointments", elem_id="view_appt_tab", visible=False):
                 view_appointments.gradio_interface()
             with gr.Tab("💬 Consultation", elem_id="consult_tab", visible=False):

book_appointment.py

@@ -0,0 +1,48 @@
+import gradio as gr
+import csv
+import os
+
+APPT_FILE = "appointments.csv"
+
+def init_storage():
+    if not os.path.exists(APPT_FILE):
+        with open(APPT_FILE, mode='w', newline='') as file:
+            writer = csv.writer(file)
+            writer.writerow(["Appointment ID", "Patient Name", "Doctor", "Date", "Time"])
+
+def generate_appointment_id():
+    with open(APPT_FILE, mode='r') as file:
+        rows = list(csv.reader(file))
+        return int(rows[-1][0]) + 1 if len(rows) > 1 else 1
+
+def save_appointment(record):
+    with open(APPT_FILE, mode='a', newline='') as file:
+        writer = csv.writer(file)
+        writer.writerow(record)
+
+def book_appointment(name, doctor, date, time):
+    init_storage()
+    appt_id = generate_appointment_id()
+    save_appointment([appt_id, name, doctor, date, time])
+    return f"✅ Appointment #{appt_id} booked for {name} with Dr. {doctor} on {date} at {time}."
+
+def create_gradio_interface():
+    init_storage()
+    with gr.Blocks() as demo:
+        gr.Markdown("## 📆 Book an Appointment")
+
+        with gr.Group():
+            with gr.Row():
+                with gr.Column():
+                    name = gr.Textbox(label="Patient Name", placeholder="Enter your full name")
+                    doctor = gr.Dropdown(["Dr. Smith", "Dr. Lee", "Dr. Patel"], label="Choose Doctor")
+                with gr.Column():
+                    date = gr.Textbox(label="Date (YYYY-MM-DD)", placeholder="e.g., 2025-05-20")
+                    time = gr.Textbox(label="Time (HH:MM)", placeholder="e.g., 10:00 AM")
+
+        result = gr.Textbox(label="Result", interactive=False)
+        btn = gr.Button("Book Appointment")
+
+        btn.click(fn=book_appointment, inputs=[name, doctor, date, time], outputs=result)
+
+    return demo

connect_doctor.py

@@ -0,0 +1,10 @@
+import gradio as gr
+
+def create_gradio_interface():
+    with gr.Blocks() as demo:
+        gr.Markdown("## 🔗 Connect with a Doctor")
+        gr.Markdown("This feature will include video/voice/chat in the future.")
+        gr.Textbox(label="Doctor Name")
+        gr.Textbox(label="Purpose")
+        gr.Button("Connect").click(fn=lambda: "🔔 Connection requested.", outputs="textbox")
+    return demo

consultation.py

@@ -0,0 +1,32 @@
+import gradio as gr
+import csv
+import os
+
+FILE = "consultations.csv"
+
+def init_file():
+    if not os.path.exists(FILE):
+        with open(FILE, 'w', newline='') as file:
+            writer = csv.writer(file)
+            writer.writerow(["ID", "Doctor", "Patient", "Notes"])
+
+def write_data(doctor, patient, notes):
+    init_file()
+    with open(FILE, 'r') as file:
+        rows = list(csv.reader(file))
+    idx = len(rows)
+    with open(FILE, 'a', newline='') as file:
+        writer = csv.writer(file)
+        writer.writerow([idx, doctor, patient, notes])
+    return f"✅ Consultation #{idx} saved."
+
+def gradio_interface():
+    init_file()
+    with gr.Blocks() as demo:
+        gr.Markdown("## 💬 Add Consultation")
+        doc = gr.Textbox(label="Doctor")
+        pat = gr.Textbox(label="Patient")
+        note = gr.Textbox(label="Notes")
+        result = gr.Textbox(label="Result")
+        gr.Button("Save").click(fn=write_data, inputs=[doc, pat, note], outputs=result)
+    return demo

medbot_chat.py

@@ -0,0 +1,67 @@
+import gradio as gr
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+import csv
+import os
+from datetime import datetime
+import pyttsx3
+
+MODEL_NAME = "tiiuae/falcon-rw-1b"
+tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+model = AutoModelForCausalLM.from_pretrained(MODEL_NAME)
+model.eval()
+
+CHAT_LOG_FILE = "chat_logs.csv"
+
+def init_log():
+    if not os.path.exists(CHAT_LOG_FILE):
+        with open(CHAT_LOG_FILE, 'w', newline='') as f:
+            writer = csv.writer(f)
+            writer.writerow(["Patient", "Timestamp", "User Message", "Bot Reply"])
+
+def chat_with_bot(message, history, patient_name, voice_enabled):
+    init_log()
+    full_prompt = ""
+    for user, bot in history:
+        full_prompt += f"User: {user}\nBot: {bot}\n"
+    full_prompt += f"User: {message}\nBot:"
+    inputs = tokenizer.encode(full_prompt, return_tensors="pt", truncation=True)
+    with torch.no_grad():
+        outputs = model.generate(inputs, max_new_tokens=100, do_sample=True, top_p=0.9, temperature=0.7)
+    decoded = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    bot_reply = decoded.split("Bot:")[-1].strip().split("User:")[0].strip()
+
+    # Save to log
+    with open(CHAT_LOG_FILE, 'a', newline='') as f:
+        writer = csv.writer(f)
+        writer.writerow([patient_name, datetime.now().isoformat(), message, bot_reply])
+
+    history.append((message, bot_reply))
+
+    audio = None
+    if voice_enabled and bot_reply:
+        tts = pyttsx3.init()
+        tts.save_to_file(bot_reply, "medbot_output.mp3")
+        tts.runAndWait()
+        audio = "medbot_output.mp3"
+
+    return history, history, audio
+
+def create_gradio_interface():
+    init_log()
+    with gr.Blocks() as demo:
+        gr.Markdown("## 💬 MedBot – AI Chat Assistant with Voice and Logging")
+        patient_name = gr.Textbox(label="Patient Name")
+        chatbot = gr.Chatbot()
+        message = gr.Textbox(label="Your Message")
+        voice_toggle = gr.Checkbox(label="Enable Voice Response", value=False)
+        audio_output = gr.Audio(label="Bot Audio", interactive=False)
+        state = gr.State([])
+
+        submit = gr.Button("Send")
+        clear = gr.Button("Clear Chat")
+
+        submit.click(chat_with_bot, inputs=[message, state, patient_name, voice_toggle], outputs=[chatbot, state, audio_output])
+        clear.click(lambda: ([], [], None), outputs=[chatbot, state, audio_output])
+
+    return demo

register_patient.py

@@ -0,0 +1,73 @@
+import gradio as gr
+import csv
+import os
+
+# Define the path to the CSV file
+patient_file_path = "patients.csv"
+
+def initialize_csv():
+    """Initialize the CSV file if it doesn't exist."""
+    if not os.path.exists(patient_file_path):
+        with open(patient_file_path, mode='w', newline='') as file:
+            writer = csv.writer(file)
+            writer.writerow(["Patient ID", "Name", "Age", "Age Unit", "Gender", "Address", "Contact Number"])
+
+def register_patient(name, age, age_unit, gender, contact):
+    """Register a new patient and return the registration status."""
+    address = "Hyderabad"
+    initialize_csv()  # Ensure the CSV is initialized
+    
+    # Read the last Patient ID and increment it
+    with open(patient_file_path, mode='r') as file:
+        reader = csv.reader(file)
+        rows = list(reader)
+        last_id = int(rows[-1][0]) if len(rows) > 1 else 0  # Get the last Patient ID
+    
+    new_id = last_id + 1
+    
+    # Write the new patient details to the CSV file
+    with open(patient_file_path, mode='a', newline='') as file:
+        writer = csv.writer(file)
+        writer.writerow([new_id, name, age, age_unit, gender, address, contact])
+    
+    return f"Patient ID: {new_id}, Name: {name} registered successfully."
+
+def create_gradio_interface():
+    """Create and return the Gradio interface for patient registration."""
+    initialize_csv()  # Ensure CSV is initialized before launching the interface
+    
+    with gr.Blocks() as demo:
+        gr.Markdown("## Register Patient")
+        
+        with gr.Row():
+            with gr.Column():
+                # Define Gradio inputs
+                name = gr.Textbox(label="Patient Name", placeholder="Enter patient name")
+                
+                # Age input with number and unit selection similar to gender buttons
+                age = gr.Number(label="Age", value=0)
+                age_unit = gr.Radio(["Years", "Months", "Days"], label="Age Unit", value="Years")
+                
+                contact_number = gr.Textbox(label="Contact Number", placeholder="Enter contact number")
+                
+            with gr.Column():
+                # Gender input
+                gender = gr.Radio(["Male", "Female", "Transgender"], label="Gender")
+
+        # Define result output
+        result = gr.Textbox(label="Result", interactive=False)
+        
+        # Define Register button
+        register_button = gr.Button("Register")
+        
+        # Define the registration logic
+        register_button.click(
+            fn=register_patient,
+            inputs=[name, age, age_unit, gender, contact_number],
+            outputs=result
+        )
+    
+    return demo
+
+if __name__ == "__main__":
+    create_gradio_interface().launch()

requirements.txt

@@ -1,2 +1,7 @@
 gradio
 pandas
+
+transformers
+torch
+
+pyttsx3

symptom_checker.py

@@ -0,0 +1,21 @@
+import gradio as gr
+
+def mock_diagnosis(symptoms, age, gender):
+    # Placeholder logic
+    if "fever" in symptoms.lower():
+        return "🩺 Likely Diagnosis: Viral Infection\n📋 Suggested: General Physician\n⚠️ Urgency: Low"
+    elif "pain" in symptoms.lower():
+        return "🩺 Likely Diagnosis: Musculoskeletal issue\n📋 Suggested: Orthopedic\n⚠️ Urgency: Medium"
+    return "🩺 Diagnosis not clear\n📋 Suggested: General Checkup"
+
+def create_gradio_interface():
+    with gr.Blocks() as demo:
+        gr.Markdown("## 🧠 Symptom Checker")
+        with gr.Row():
+            symptoms = gr.Textbox(label="Describe your symptoms")
+            age = gr.Number(label="Age", value=30)
+            gender = gr.Radio(["Male", "Female", "Other"], label="Gender")
+        result = gr.Textbox(label="AI Diagnosis")
+        btn = gr.Button("Analyze")
+        btn.click(fn=mock_diagnosis, inputs=[symptoms, age, gender], outputs=result)
+    return demo

view_appointments.py

@@ -0,0 +1,20 @@
+import gradio as gr
+import csv
+import os
+
+APPT_FILE = "appointments.csv"
+
+def load_appointments():
+    if not os.path.exists(APPT_FILE):
+        return [["No appointments found"]]
+    with open(APPT_FILE, mode='r') as file:
+        reader = list(csv.reader(file))
+    return reader[1:] if len(reader) > 1 else [["No appointments available"]]
+
+def gradio_interface():
+    with gr.Blocks() as demo:
+        gr.Markdown("## 📅 View Appointments")
+        output = gr.Dataframe(headers=["Appointment ID", "Patient Name", "Doctor", "Date", "Time"], datatype="str")
+        refresh = gr.Button("🔄 Refresh")
+        refresh.click(fn=load_appointments, outputs=output)
+    return demo

view_consultation.py

@@ -0,0 +1,19 @@
+import gradio as gr
+import csv
+import os
+
+FILE = "consultations.csv"
+
+def load_consults():
+    if not os.path.exists(FILE):
+        return [["No consultation data"]]
+    with open(FILE, mode='r') as file:
+        reader = list(csv.reader(file))
+    return reader[1:] if len(reader) > 1 else [["No data"]]
+
+def gradio_interface():
+    with gr.Blocks() as demo:
+        gr.Markdown("## 💬 View Consultations")
+        df = gr.Dataframe(headers=["ID", "Doctor", "Patient", "Notes"], datatype="str")
+        gr.Button("🔄 Load Data").click(fn=load_consults, outputs=df)
+    return demo

view_patient_reports.py

@@ -0,0 +1,19 @@
+import gradio as gr
+import csv
+import os
+
+FILE = "reports.csv"
+
+def load_reports():
+    if not os.path.exists(FILE):
+        return [["No reports available"]]
+    with open(FILE, mode='r') as file:
+        reader = list(csv.reader(file))
+    return reader[1:] if len(reader) > 1 else [["No data"]]
+
+def create_gradio_interface():
+    with gr.Blocks() as demo:
+        gr.Markdown("## 📄 Patient Reports")
+        df = gr.Dataframe(headers=["Report ID", "Patient", "Report Type", "Details"], datatype="str")
+        gr.Button("🔄 Refresh").click(fn=load_reports, outputs=df)
+    return demo