app.py

import gradio as gr
import json
import os
from typing import Dict, List, Optional
import base64
from datetime import datetime
import uuid

# Mock medical test data structure
MEDICAL_TESTS = [
    {"name": "Hemoglobin", "unit": "g/dL", "normalRange": "13.8-17.2 g/dL", "category": "blood"},
    {"name": "White Blood Cells", "unit": "/μL", "normalRange": "4,500-11,000 /μL", "category": "blood"},
    {"name": "Platelets", "unit": "/μL", "normalRange": "150,000-450,000 /μL", "category": "blood"},
    {"name": "Glucose", "unit": "mg/dL", "normalRange": "70-100 mg/dL", "category": "metabolic"},
    {"name": "Creatinine", "unit": "mg/dL", "normalRange": "0.7-1.3 mg/dL", "category": "metabolic"},
    {"name": "BUN", "unit": "mg/dL", "normalRange": "7-20 mg/dL", "category": "metabolic"},
    {"name": "ALT", "unit": "U/L", "normalRange": "7-56 U/L", "category": "liver"},
    {"name": "AST", "unit": "U/L", "normalRange": "10-40 U/L", "category": "liver"},
    {"name": "Bilirubin", "unit": "mg/dL", "normalRange": "0.3-1.2 mg/dL", "category": "liver"},
    {"name": "Total Cholesterol", "unit": "mg/dL", "normalRange": "<200 mg/dL", "category": "lipids"},
    {"name": "HDL Cholesterol", "unit": "mg/dL", "normalRange": ">40 mg/dL", "category": "lipids"},
    {"name": "LDL Cholesterol", "unit": "mg/dL", "normalRange": "<100 mg/dL", "category": "lipids"},
    {"name": "Triglycerides", "unit": "mg/dL", "normalRange": "<150 mg/dL", "category": "lipids"},
    {"name": "TSH", "unit": "mIU/L", "normalRange": "0.4-4.0 mIU/L", "category": "thyroid"},
    {"name": "Vitamin D", "unit": "ng/mL", "normalRange": "30-100 ng/mL", "category": "vitamins"},
    {"name": "Vitamin B12", "unit": "pg/mL", "normalRange": "200-900 pg/mL", "category": "vitamins"},
    {"name": "Ferritin", "unit": "ng/mL", "normalRange": "15-150 ng/mL", "category": "blood"},
    {"name": "HbA1c", "unit": "%", "normalRange": "<5.7%", "category": "metabolic"},
    {"name": "Insulin", "unit": "mU/L", "normalRange": "2.6-24.9 mU/L", "category": "metabolic"},
    {"name": "Cortisol", "unit": "μg/dL", "normalRange": "6.2-19.4 μg/dL", "category": "metabolic"},
    {"name": "Testosterone", "unit": "ng/dL", "normalRange": "270-1070 ng/dL", "category": "metabolic"},
    {"name": "Estradiol", "unit": "pg/mL", "normalRange": "15-350 pg/mL", "category": "metabolic"},
    {"name": "Calcium", "unit": "mg/dL", "normalRange": "8.5-10.2 mg/dL", "category": "metabolic"},
    {"name": "Magnesium", "unit": "mg/dL", "normalRange": "1.7-2.2 mg/dL", "category": "metabolic"},
    {"name": "Phosphorus", "unit": "mg/dL", "normalRange": "2.5-4.5 mg/dL", "category": "metabolic"},
    {"name": "Uric Acid", "unit": "mg/dL", "normalRange": "3.4-7.0 mg/dL", "category": "metabolic"},
    {"name": "CRP", "unit": "mg/L", "normalRange": "<3.0 mg/L", "category": "blood"},
]

# Mock prediction function - replace with actual Hugging Face model
def predict_medical_tests(image, first_name: str, last_name: str, age: int, gender: str, medical_history: str = ""):
    """
    Placeholder function for AI-powered medical test prediction.
    In production, this would integrate with your Hugging Face model.
    """
    import random
    random.seed(hash(f"{first_name}{last_name}{age}"))  # Consistent results for same input
    
    predictions = []
    for test in MEDICAL_TESTS:
        # Generate realistic values based on test type
        if test["category"] == "blood":
            if test["name"] == "Hemoglobin":
                value = round(random.uniform(12.0, 16.0), 1)
            elif test["name"] == "White Blood Cells":
                value = f"{random.randint(5000, 10000):,}"
            elif test["name"] == "Platelets":
                value = f"{random.randint(200000, 400000):,}"
            else:
                value = round(random.uniform(50, 150), 1)
        elif test["category"] == "metabolic":
            value = round(random.uniform(80, 120), 1)
        elif test["category"] == "liver":
            value = round(random.uniform(20, 40), 1)
        elif test["category"] == "lipids":
            value = round(random.uniform(150, 200), 1)
        elif test["category"] == "thyroid":
            value = round(random.uniform(1.0, 3.0), 1)
        elif test["category"] == "vitamins":
            value = round(random.uniform(25, 50), 1)
        else:
            value = round(random.uniform(1.0, 10.0), 1)
        
        # Determine status
        status = random.choice(["normal", "normal", "normal", "slightly_high", "slightly_low"])
        
        predictions.append({
            "name": test["name"],
            "value": str(value),
            "unit": test["unit"],
            "normalRange": test["normalRange"],
            "status": status,
            "category": test["category"]
        })
    
    return predictions

def process_patient_info(image, first_name, last_name, age, gender, medical_history):
    """Process patient information and generate predictions"""
    if not image or not first_name or not last_name or not age:
        return "Please fill in all required fields and upload a photo.", None
    
    # Generate predictions
    predictions = predict_medical_tests(image, first_name, last_name, age, gender, medical_history)
    
    # Format results for display
    results_text = f"## AI Analysis Results for {first_name} {last_name}\n\n"
    results_text += f"**Patient Info:** {age} years old, {gender}\n"
    results_text += f"**Analysis Date:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"
    
    # Group by category
    categories = {}
    for pred in predictions:
        cat = pred["category"].title()
        if cat not in categories:
            categories[cat] = []
        categories[cat].append(pred)
    
    for category, tests in categories.items():
        results_text += f"### {category} Tests\n\n"
        for test in tests:
            status_emoji = "✅" if test["status"] == "normal" else "⚠️"
            results_text += f"**{test['name']}:** {test['value']} {test['unit']} {status_emoji}\n"
            results_text += f"*Normal range: {test['normalRange']}*\n\n"
    
    # Save session data
    session_id = str(uuid.uuid4())
    session_data = {
        "id": session_id,
        "patient": {
            "firstName": first_name,
            "lastName": last_name,
            "age": age,
            "gender": gender,
            "medicalHistory": medical_history
        },
        "predictions": predictions,
        "timestamp": datetime.now().isoformat()
    }
    
    # In production, save to database
    # For now, save to local file for demo
    os.makedirs("sessions", exist_ok=True)
    with open(f"sessions/{session_id}.json", "w") as f:
        json.dump(session_data, f, indent=2)
    
    return results_text, session_data

def compare_with_lab_results(session_data, lab_report_file):
    """Compare AI predictions with uploaded lab results"""
    if not session_data or not lab_report_file:
        return "Please complete the AI analysis first and upload a lab report."
    
    # In production, this would use OCR/PDF parsing to extract lab values
    # For demo, we'll simulate some comparisons
    predictions = session_data.get("predictions", [])
    
    comparison_text = "## Lab Results Comparison\n\n"
    comparison_text += "### Accuracy Summary\n"
    comparison_text += "- **Overall Accuracy:** 82%\n"
    comparison_text += "- **Exact Matches:** 22/27 tests\n"
    comparison_text += "- **Close Matches:** 3/27 tests\n"
    comparison_text += "- **Significant Variations:** 2/27 tests\n\n"
    
    comparison_text += "### Sample Comparisons\n\n"
    
    # Show a few sample comparisons
    sample_comparisons = [
        {"test": "Hemoglobin", "ai": "14.2", "lab": "14.2", "match": "Exact", "unit": "g/dL"},
        {"test": "Glucose", "ai": "95", "lab": "98", "match": "Close", "unit": "mg/dL"},
        {"test": "Vitamin D", "ai": "28", "lab": "22", "match": "Different", "unit": "ng/mL"},
    ]
    
    for comp in sample_comparisons:
        match_emoji = "✅" if comp["match"] == "Exact" else "🟡" if comp["match"] == "Close" else "🔄"
        comparison_text += f"**{comp['test']}** {match_emoji}\n"
        comparison_text += f"- AI Prediction: {comp['ai']} {comp['unit']}\n"
        comparison_text += f"- Lab Result: {comp['lab']} {comp['unit']}\n"
        comparison_text += f"- Match: {comp['match']}\n\n"
    
    comparison_text += "### Recommendations\n"
    comparison_text += "- Consult your physician about Vitamin D supplementation\n"
    comparison_text += "- Overall health parameters are within normal ranges\n"
    comparison_text += "- Consider follow-up testing in 6 months\n"
    
    return comparison_text

# Create Gradio interface
def create_interface():
    with gr.Blocks(
        title="HealthPredict AI - Medical Test Prediction",
        theme=gr.themes.Base(
            primary_hue="green",
            secondary_hue="purple",
            neutral_hue="gray"
        ).set(
            body_background_fill="#ffffff",
            block_background_fill="#f6f6f6",
            button_primary_background_fill="#c4f82a",
            button_primary_text_color="#000000"
        )
    ) as demo:
        
        gr.Markdown("""
        # 🏥 HealthPredict AI
        ## AI-Powered Medical Test Prediction from Face Analysis
        
        Welcome to HealthPredict AI! Upload your photo and provide some basic information to get AI-powered predictions for 27 common medical tests.
        
        ⚠️ **Important:** This is for educational purposes only and does not replace professional medical advice.
        """)
        
        with gr.Tab("📋 Patient Information & AI Analysis"):
            with gr.Row():
                with gr.Column(scale=1):
                    gr.Markdown("### Upload Your Photo")
                    image_input = gr.Image(
                        label="Face Photo for Analysis",
                        type="pil",
                        height=300
                    )
                    
                with gr.Column(scale=1):
                    gr.Markdown("### Personal Information")
                    first_name = gr.Textbox(label="First Name", placeholder="Enter your first name")
                    last_name = gr.Textbox(label="Last Name", placeholder="Enter your last name")
                    age = gr.Number(label="Age", value=30, minimum=1, maximum=120)
                    gender = gr.Dropdown(
                        label="Gender",
                        choices=["male", "female", "other"],
                        value="male"
                    )
                    medical_history = gr.Textbox(
                        label="Medical History (Optional)",
                        placeholder="Any relevant medical history, allergies, or current medications...",
                        lines=3
                    )
            
            analyze_btn = gr.Button("🧠 Analyze with AI", variant="primary", size="lg")
            
            with gr.Row():
                results_output = gr.Markdown(label="AI Predictions")
                session_state = gr.State()
            
            analyze_btn.click(
                process_patient_info,
                inputs=[image_input, first_name, last_name, age, gender, medical_history],
                outputs=[results_output, session_state]
            )
        
        with gr.Tab("🔬 Lab Results Comparison"):
            gr.Markdown("""
            ### Upload Your Lab Report
            Upload your actual lab results to compare with AI predictions and see accuracy metrics.
            """)
            
            lab_file = gr.File(
                label="Lab Report",
                file_types=[".pdf", ".jpg", ".jpeg", ".png"],
                type="filepath"
            )
            
            compare_btn = gr.Button("📊 Compare Results", variant="primary")
            comparison_output = gr.Markdown(label="Comparison Results")
            
            compare_btn.click(
                compare_with_lab_results,
                inputs=[session_state, lab_file],
                outputs=[comparison_output]
            )
        
        with gr.Tab("ℹ️ About"):
            gr.Markdown("""
            ## About HealthPredict AI
            
            This application demonstrates AI-powered medical test prediction using facial analysis. The system predicts values for 27 common medical tests including:
            
            - **Blood Tests:** Hemoglobin, White Blood Cells, Platelets, etc.
            - **Metabolic Panel:** Glucose, Creatinine, BUN, etc.
            - **Liver Function:** ALT, AST, Bilirubin
            - **Lipid Profile:** Cholesterol, HDL, LDL, Triglycerides
            - **Thyroid Function:** TSH
            - **Vitamins:** Vitamin D, Vitamin B12
            - **Hormones:** Insulin, Cortisol, Testosterone, Estradiol
            
            ### How It Works
            1. **Upload Photo:** Provide a clear face photo for analysis
            2. **Enter Information:** Fill in basic demographic information
            3. **AI Analysis:** Get predictions for 27 medical tests
            4. **Compare Results:** Upload actual lab results to see accuracy
            
            ### Technology Stack
            - **Frontend:** Gradio for interactive web interface
            - **Backend:** Python with machine learning models
            - **AI Model:** Face-based medical prediction (placeholder for Hugging Face model)
            
            ### Disclaimer
            This tool is for educational and research purposes only. Always consult with healthcare professionals for medical advice.
            """)
    
    return demo

if __name__ == "__main__":
    # Create the interface
    demo = create_interface()
    
    # Launch the app
    demo.launch(
        server_name="0.0.0.0",
        server_port=7860,
        share=True,
        show_api=True
    )