Update app.py

app.py

@@ -1,172 +1,396 @@
-import streamlit as st
+import gradio as gr
 import librosa
 import numpy as np
 import tensorflow as tf
 import matplotlib.pyplot as plt
 from datetime import datetime
+import json
+import os
+from PIL import Image
+import google.generativeai as genai
+from typing import Dict, List, Tuple, Optional
+
+# Configure Gemini AI
+# You'll need to set your API key: export GOOGLE_API_KEY="your_api_key_here"
+genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
+gemini_model = genai.GenerativeModel('gemini-1.5-flash')
 
 # Load the pre-trained ResNet model
-@st.cache_resource
-def load_model():
-    model = tf.keras.models.load_model('Heart_ResNet.h5')
-    return model
-
-model = load_model()
-
-# Initialize session state
-if 'page' not in st.session_state:
-    st.session_state.page = '🏠 Home'
-if 'theme' not in st.session_state:
-    st.session_state.theme = 'Light Green'
-if 'history' not in st.session_state:
-    st.session_state.history = []
-
-# Custom CSS for theme
-def apply_theme():
-    if st.session_state.theme == "Light Green":
-        st.markdown("""
-        <style>
-        body, .stApp { background-color: #e8f5e9; }
-        .stApp { color: #004d40; }
-        .stButton > button, .stFileUpload > div { 
-            background-color: #004d40; 
-            color: white; 
-        }
-        .stButton > button:hover, .stFileUpload > div:hover {
-            background-color: #00332c;
-        }
-        </style>
-        """, unsafe_allow_html=True)
-    else:
-        st.markdown("""
-        <style>
-        body, .stApp { background-color: #e0f7fa; }
-        .stApp { color: #006064; }
-        .stButton > button, .stFileUpload > div { 
-            background-color: #006064; 
-            color: white; 
-        }
-        .stButton > button:hover, .stFileUpload > div:hover {
-            background-color: #004d40;
-        }
-        </style>
-        """, unsafe_allow_html=True)
-
-# Sidebar navigation
-with st.sidebar:
-    st.title("Heartbeat Analysis 🩺")
-    st.session_state.page = st.radio(
-        "Navigation",
-        ["🏠 Home", "⚙️ Settings", "👤 Profile"],
-        index=["🏠 Home", "⚙️ Settings", "👤 Profile"].index(st.session_state.page)
-    )
-
-# Audio processing function
-def process_audio(file_path):
+@gr.utils.cache
+def load_heartbeat_model():
+    try:
+        model = tf.keras.models.load_model('Heart_ResNet.h5')
+        return model
+    except:
+        print("Warning: Heart_ResNet.h5 model not found. Using mock predictions.")
+        return None
+
+heartbeat_model = load_heartbeat_model()
+
+# Global storage for patient data (in production, use a proper database)
+patient_data = {}
+
+def process_audio(file_path: str) -> Tuple[np.ndarray, np.ndarray, int]:
+    """Process audio file and extract MFCC features."""
     SAMPLE_RATE = 22050
     DURATION = 10
     input_length = int(SAMPLE_RATE * DURATION)
     
-    X, sr = librosa.load(file_path, sr=SAMPLE_RATE, duration=DURATION)
+    try:
+        X, sr = librosa.load(file_path, sr=SAMPLE_RATE, duration=DURATION)
+        
+        if len(X) < input_length:
+            pad_width = input_length - len(X)
+            X = np.pad(X, (0, pad_width), mode='constant')
+        
+        mfccs = np.mean(librosa.feature.mfcc(y=X, sr=sr, n_mfcc=52,
+                                            n_fft=512, hop_length=256).T, axis=0)
+        return mfccs, X, sr
+    except Exception as e:
+        print(f"Error processing audio: {e}")
+        return None, None, None
+
+def analyze_heartbeat(audio_file) -> Tuple[Dict, str]:
+    """Analyze heartbeat audio and return results with visualization."""
+    if audio_file is None:
+        return {}, "No audio file provided"
     
-    if len(X) < input_length:
-        pad_width = input_length - len(X)
-        X = np.pad(X, (0, pad_width), mode='constant')
+    try:
+        mfccs, waveform, sr = process_audio(audio_file)
+        if mfccs is None:
+            return {}, "Error processing audio file"
+        
+        if heartbeat_model is not None:
+            features = mfccs.reshape(1, 52, 1)
+            preds = heartbeat_model.predict(features)
+            class_names = ["artifact", "murmur", "normal"]
+            results = {name: float(preds[0][i]) for i, name in enumerate(class_names)}
+        else:
+            # Mock results for demonstration
+            results = {"artifact": 0.15, "murmur": 0.25, "normal": 0.60}
+        
+        # Create waveform visualization
+        fig, ax = plt.subplots(figsize=(12, 4))
+        librosa.display.waveshow(waveform, sr=sr, ax=ax)
+        ax.set_title("Heartbeat Waveform Analysis")
+        ax.set_xlabel("Time (seconds)")
+        ax.set_ylabel("Amplitude")
+        plt.tight_layout()
+        
+        # Save plot
+        plot_path = f"temp_waveform_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png"
+        plt.savefig(plot_path, dpi=150, bbox_inches='tight')
+        plt.close()
+        
+        return results, plot_path
+        
+    except Exception as e:
+        return {}, f"Error analyzing heartbeat: {str(e)}"
+
+def analyze_medical_image(image) -> str:
+    """Analyze medical images using Gemini Vision."""
+    if image is None:
+        return "No image provided"
     
-    mfccs = np.mean(librosa.feature.mfcc(y=X, sr=sr, n_mfcc=52,
-                                        n_fft=512, hop_length=256).T, axis=0)
-    return mfccs, X, sr
-
-def classify_audio(filepath):
-    mfccs, waveform, sr = process_audio(filepath)
-    features = mfccs.reshape(1, 52, 1)
-    preds = model.predict(features)
-    class_names = ["artifact", "murmur", "normal"]
-    result = {name: float(preds[0][i]) for i, name in enumerate(class_names)}
+    try:
+        # Convert to PIL Image if needed
+        if not isinstance(image, Image.Image):
+            image = Image.fromarray(image)
+        
+        prompt = """
+        Analyze this medical image/investigation result. Please provide:
+        1. Type of investigation/scan
+        2. Key findings visible in the image
+        3. Any abnormalities or areas of concern
+        4. Recommendations for follow-up if needed
+        
+        Please be thorough but remember this is for educational purposes and should not replace professional medical diagnosis.
+        """
+        
+        response = gemini_model.generate_content([prompt, image])
+        return response.text
+        
+    except Exception as e:
+        return f"Error analyzing image: {str(e)}"
+
+def generate_comprehensive_assessment(patient_info: Dict) -> str:
+    """Generate comprehensive medical assessment using Gemini AI."""
+    try:
+        # Prepare comprehensive prompt
+        prompt = f"""
+        Based on the following comprehensive patient data, provide a detailed medical assessment:
+
+        PATIENT DEMOGRAPHICS:
+        - Name: {patient_info.get('name', 'Not provided')}
+        - Age: {patient_info.get('age', 'Not provided')}
+        - Sex: {patient_info.get('sex', 'Not provided')}
+        - Weight: {patient_info.get('weight', 'Not provided')} kg
+        - Height: {patient_info.get('height', 'Not provided')} cm
+
+        CHIEF COMPLAINT:
+        {patient_info.get('complaint', 'Not provided')}
+
+        MEDICAL HISTORY:
+        {patient_info.get('medical_history', 'Not provided')}
+
+        PHYSICAL EXAMINATION:
+        {patient_info.get('examination', 'Not provided')}
+
+        HEART SOUNDS ANALYSIS:
+        {patient_info.get('heartbeat_analysis', 'Not performed')}
+
+        INVESTIGATIONS:
+        {patient_info.get('investigation_analysis', 'Not provided')}
+
+        Please provide a comprehensive medical assessment including:
+        1. Clinical Summary
+        2. Differential Diagnosis (list possible conditions)
+        3. Risk Factors Assessment
+        4. Recommended Treatment Plan
+        5. Follow-up Recommendations
+        6. Patient Education Points
+        7. Prognosis
+
+        Please structure your response professionally and remember this is for educational purposes.
+        """
+        
+        response = gemini_model.generate_content(prompt)
+        return response.text
+        
+    except Exception as e:
+        return f"Error generating assessment: {str(e)}"
+
+def save_patient_data(name, age, sex, weight, height, complaint, medical_history, 
+                     examination, heartbeat_results, investigation_analysis):
+    """Save all patient data to global storage."""
+    global patient_data
     
-    # Store in history
-    st.session_state.history.append({
-        'date': datetime.now().strftime("%Y-%m-%d %H:%M"),
-        'file': filepath,
-        'result': result
-    })
+    patient_data = {
+        'name': name,
+        'age': age,
+        'sex': sex,
+        'weight': weight,
+        'height': height,
+        'complaint': complaint,
+        'medical_history': medical_history,
+        'examination': examination,
+        'heartbeat_analysis': heartbeat_results,
+        'investigation_analysis': investigation_analysis,
+        'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+    }
     
-    return result, waveform, sr
+    return "Patient data saved successfully!"
 
-# Page rendering functions
-def home_page():
-    st.title("Heartbeat Analysis")
-    uploaded_file = st.file_uploader("Upload your heartbeat audio", type=["wav", "mp3"])
+def process_complete_consultation(name, age, sex, weight, height, complaint, 
+                                medical_history, examination, audio_file, 
+                                investigation_image):
+    """Process complete medical consultation."""
     
-    if uploaded_file is not None:
-        st.audio(uploaded_file.read(), format='audio/wav')
-        uploaded_file.seek(0)
-        
-        if st.button("Analyze Now"):
-            with st.spinner('Analyzing...'):
-                with open("temp.wav", "wb") as f:
-                    f.write(uploaded_file.getbuffer())
-                
-                results, waveform, sr = classify_audio("temp.wav")
-                
-                st.subheader("Analysis Results")
-                cols = st.columns(3)
-                labels = {
-                    'artifact': "🚨 Artifact",
-                    'murmur': "💔 Murmur",
-                    'normal': "❤️ Normal"
-                }
+    # Analyze heartbeat if audio provided
+    heartbeat_results = ""
+    waveform_plot = None
+    if audio_file is not None:
+        results, plot_path = analyze_heartbeat(audio_file)
+        if results:
+            heartbeat_results = f"""
+            Heartbeat Analysis Results:
+            - Normal: {results.get('normal', 0)*100:.1f}%
+            - Murmur: {results.get('murmur', 0)*100:.1f}%
+            - Artifact: {results.get('artifact', 0)*100:.1f}%
+            """
+            waveform_plot = plot_path
+    
+    # Analyze investigation image if provided
+    investigation_analysis = ""
+    if investigation_image is not None:
+        investigation_analysis = analyze_medical_image(investigation_image)
+    
+    # Save patient data
+    save_patient_data(name, age, sex, weight, height, complaint, medical_history,
+                     examination, heartbeat_results, investigation_analysis)
+    
+    # Generate comprehensive assessment
+    comprehensive_assessment = generate_comprehensive_assessment(patient_data)
+    
+    return comprehensive_assessment, waveform_plot, heartbeat_results, investigation_analysis
+
+# Create Gradio interface
+def create_interface():
+    with gr.Blocks(title="Comprehensive Medical Consultation System", theme=gr.themes.Soft()) as demo:
+        
+        gr.Markdown("""
+        # 🏥 Comprehensive Medical Consultation System
+        ### Integrated AI-Powered Medical Assessment Platform
+        """)
+        
+        with gr.Tab("📋 Patient Information"):
+            gr.Markdown("## Patient Demographics")
+            
+            with gr.Row():
+                with gr.Column():
+                    name = gr.Textbox(label="Full Name", placeholder="Enter patient's full name")
+                    age = gr.Number(label="Age (years)", minimum=0, maximum=120)
+                    sex = gr.Radio(["Male", "Female", "Other"], label="Sex")
                 
-                for (label, value), col in zip(results.items(), cols):
-                    with col:
-                        st.metric(labels[label], f"{value*100:.2f}%")
+                with gr.Column():
+                    weight = gr.Number(label="Weight (kg)", minimum=0, maximum=300)
+                    height = gr.Number(label="Height (cm)", minimum=0, maximum=250)
+            
+            gr.Markdown("## Chief Complaint")
+            complaint = gr.Textbox(
+                label="Chief Complaint", 
+                placeholder="Describe the main symptoms or reason for consultation...",
+                lines=3
+            )
+            
+            gr.Markdown("## Medical History")
+            medical_history = gr.Textbox(
+                label="Past Medical History",
+                placeholder="Include previous illnesses, surgeries, medications, allergies, family history...",
+                lines=5
+            )
+        
+        with gr.Tab("🩺 Physical Examination"):
+            gr.Markdown("## Physical Examination Findings")
+            
+            examination = gr.Textbox(
+                label="Examination Findings",
+                placeholder="General appearance, vital signs, systemic examination findings...",
+                lines=6
+            )
+            
+            gr.Markdown("## Heart Sounds Analysis")
+            audio_file = gr.Audio(
+                label="Heart Sounds Recording",
+                type="filepath",
+                sources=["upload", "microphone"]
+            )
+            
+            heartbeat_analyze_btn = gr.Button("🔍 Analyze Heart Sounds", variant="secondary")
+            heartbeat_results = gr.Textbox(label="Heart Sounds Analysis Results", lines=4)
+            waveform_plot = gr.Image(label="Heart Sounds Waveform")
+            
+            heartbeat_analyze_btn.click(
+                fn=analyze_heartbeat,
+                inputs=[audio_file],
+                outputs=[heartbeat_results, waveform_plot]
+            )
+        
+        with gr.Tab("🔬 Investigations"):
+            gr.Markdown("## Medical Investigations & Imaging")
+            
+            investigation_image = gr.Image(
+                label="Upload Investigation Results (X-ray, ECG, Lab reports, etc.)",
+                type="pil"
+            )
+            
+            investigate_btn = gr.Button("🔍 Analyze Investigation", variant="secondary")
+            investigation_results = gr.Textbox(
+                label="Investigation Analysis", 
+                lines=6,
+                placeholder="AI analysis of uploaded investigation will appear here..."
+            )
+            
+            investigate_btn.click(
+                fn=analyze_medical_image,
+                inputs=[investigation_image],
+                outputs=[investigation_results]
+            )
+        
+        with gr.Tab("🤖 AI Assessment"):
+            gr.Markdown("## Comprehensive Medical Assessment")
+            
+            generate_btn = gr.Button(
+                "🧠 Generate Comprehensive Assessment", 
+                variant="primary",
+                size="lg"
+            )
+            
+            assessment_output = gr.Textbox(
+                label="AI-Generated Medical Assessment",
+                lines=15,
+                placeholder="Complete medical assessment will be generated here based on all provided information..."
+            )
+            
+            # Hidden outputs to collect all data
+            hidden_heartbeat = gr.Textbox(visible=False)
+            hidden_investigation = gr.Textbox(visible=False)
+            hidden_waveform = gr.Image(visible=False)
+            
+            generate_btn.click(
+                fn=process_complete_consultation,
+                inputs=[name, age, sex, weight, height, complaint, medical_history,
+                       examination, audio_file, investigation_image],
+                outputs=[assessment_output, hidden_waveform, hidden_heartbeat, 
+                        hidden_investigation]
+            )
+        
+        with gr.Tab("📊 Patient Summary"):
+            gr.Markdown("## Patient Data Summary")
+            
+            refresh_btn = gr.Button("🔄 Refresh Patient Data", variant="secondary")
+            
+            with gr.Row():
+                with gr.Column():
+                    summary_demographics = gr.JSON(label="Demographics")
+                    summary_clinical = gr.JSON(label="Clinical Data")
                 
-                st.subheader("Heartbeat Waveform")
-                fig, ax = plt.subplots(figsize=(10, 3))
-                librosa.display.waveshow(waveform, sr=sr, ax=ax)
-                ax.set_title("Audio Waveform Analysis")
-                st.pyplot(fig)
-
-def settings_page():
-    st.title("Settings")
-    new_theme = st.selectbox(
-        "Select Theme",
-        ["Light Green", "Light Blue"],
-        index=0 if st.session_state.theme == "Light Green" else 1
-    )
+                with gr.Column():
+                    summary_results = gr.JSON(label="Investigation Results")
+            
+            def refresh_patient_summary():
+                if patient_data:
+                    demographics = {
+                        "Name": patient_data.get('name', 'N/A'),
+                        "Age": patient_data.get('age', 'N/A'),
+                        "Sex": patient_data.get('sex', 'N/A'),
+                        "Weight": f"{patient_data.get('weight', 'N/A')} kg",
+                        "Height": f"{patient_data.get('height', 'N/A')} cm"
+                    }
+                    
+                    clinical = {
+                        "Chief Complaint": patient_data.get('complaint', 'N/A'),
+                        "Medical History": patient_data.get('medical_history', 'N/A')[:100] + "..." if len(patient_data.get('medical_history', '')) > 100 else patient_data.get('medical_history', 'N/A'),
+                        "Examination": patient_data.get('examination', 'N/A')[:100] + "..." if len(patient_data.get('examination', '')) > 100 else patient_data.get('examination', 'N/A')
+                    }
+                    
+                    results = {
+                        "Heartbeat Analysis": "Completed" if patient_data.get('heartbeat_analysis') else "Not performed",
+                        "Investigation Analysis": "Completed" if patient_data.get('investigation_analysis') else "Not performed",
+                        "Last Updated": patient_data.get('timestamp', 'N/A')
+                    }
+                    
+                    return demographics, clinical, results
+                else:
+                    return {}, {}, {}
+            
+            refresh_btn.click(
+                fn=refresh_patient_summary,
+                outputs=[summary_demographics, summary_clinical, summary_results]
+            )
+        
+        gr.Markdown("""
+        ---
+        ### 📝 Important Notes:
+        - This system is for educational and research purposes only
+        - Always consult qualified healthcare professionals for medical decisions  
+        - Ensure patient privacy and data protection compliance
+        - AI assessments should supplement, not replace, clinical judgment
+        """)
     
-    if new_theme != st.session_state.theme:
-        st.session_state.theme = new_theme
-        st.experimental_rerun()
-
-def profile_page():
-    st.title("Medical Profile")
-    with st.expander("Personal Information", expanded=True):
-        col1, col2 = st.columns(2)
-        with col1:
-            st.write("**Name:** Kpetaa Patrick")
-            st.write("**Age:** 35")
-        with col2:
-            st.write("**Blood Type:** O+")
-            st.write("**Last Checkup:** 2025-06-17")
+    return demo
+
+# Launch the application
+if __name__ == "__main__":
+    # Check if required environment variables are set
+    if not os.getenv("GOOGLE_API_KEY"):
+        print("Warning: GOOGLE_API_KEY not set. Gemini AI features will not work.")
+        print("Set your API key with: export GOOGLE_API_KEY='your_api_key_here'")
     
-    st.subheader("Analysis History")
-    if not st.session_state.history:
-        st.write("No previous analyses found")
-    else:
-        for analysis in reversed(st.session_state.history):
-            with st.expander(f"Analysis from {analysis['date']}"):
-                st.write(f"File: {analysis['file']}")
-                st.write("Results:")
-                for label, value in analysis['result'].items():
-                    st.progress(value, text=f"{label.capitalize()}: {value*100:.2f}%")
-
-# Main app logic
-apply_theme()
-
-if st.session_state.page == "🏠 Home":
-    home_page()
-elif st.session_state.page == "⚙️ Settings":
-    settings_page()
-elif st.session_state.page == "👤 Profile":
-    profile_page()
+    demo = create_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+        debug=True
+    )