index.py

import re
import warnings
import numpy as np
from flask import Flask, request, jsonify, render_template, session
from flask_cors import CORS
from langdetect import detect_langs, DetectorFactory
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, LSTM, Dense, Dropout
from tensorflow.keras.utils import to_categorical
from sklearn.preprocessing import LabelEncoder

warnings.filterwarnings('ignore')
DetectorFactory.seed = 0

app = Flask(__name__)
app.secret_key = "secret123"
CORS(app)

# ---------------- Disease Database ----------------
disease_info = {
    "Malaria": {
        "symptoms": "High fever, chills, headache, nausea, vomiting, muscle pain, fatigue, sweating",
        "symptoms_hi": "उच्च बुखार, ठंड लगना, सिर दर्द, मतली, उल्टी, मांसपेशियों में दर्द, थकान, पसीना",
        "symptoms_or": "ଉଚ୍ଚ ଜ୍ୱର, ଥଣ୍ଡା ଲାଗିବା, ମୁଣ୍ଡ ବେଥା, ବାମି, ଅଳସତା, ଶରୀର ଦୁଖ, ପସିନା",
        "prevention": {"en":"Use mosquito nets, insect repellent, wear long sleeves, eliminate standing water",
                       "hi":"मच्छरदानी, रिपेलेंट, लंबे कपड़े पहनें, खड़ा पानी हटाएँ",
                       "or":"ମଛ ଜାଲି, ଇନସେକ୍ଟ ରିପେଲେଣ୍ଟ, ଲମ୍ବା ପୋଷାକ ପିନ୍ଧନ୍ତୁ, ଜଳ ହଟାନ୍ତୁ"},
        "first_aid": {"en":"Seek medical attention, hydrate, manage fever with paracetamol",
                      "hi":"डॉक्टर से मिलें, पानी पीएँ, पैरासिटामोल से बुखार कम करें",
                      "or":"ଡାକ୍ତରଙ୍କ ସହ ଯାଆନ୍ତୁ, ପାଣି ପିଉନ୍ତୁ, ପାରାସିଟାମଲ୍ ଦ୍ୱାରା ଜ୍ୱର ନିୟନ୍ତ୍ରଣ କରନ୍ତୁ"},
        "medicine": "Artemisinin-based combination therapy (ACT), Chloroquine",
        "caution": {"en":"Avoid mosquito bites, monitor fever closely",
                    "hi":"मच्छर से बचें, बुखार पर ध्यान दें",
                    "or":"ମଛ କାଟିବା ରୋକନ୍ତୁ, ଜ୍ୱର ମାନିଟର୍ କରନ୍ତୁ"},
        "severity": "High",
        "category": "Infectious Disease"
    },
    "Dengue": {
        "symptoms": "High fever, severe headache, pain behind the eyes, rash, joint and muscle pain, mild bleeding",
        "symptoms_hi": "उच्च बुखार, तेज सिर दर्द, आंखों के पीछे दर्द, चकत्तेदार दाने, जोड़ों और मांसपेशियों में दर्द, हल्का रक्तस्राव",
        "symptoms_or": "ଉଚ୍ଚ ଜ୍ୱର, ମୁଣ୍ଡ ବେଥା, ଆଖି ପଛରେ ଦର୍ଦ୍ଦ, ଚକତ୍ତା, ସନ୍ଧି ଓ ପେଶୀ ଯନ୍ତ୍ରଣା, ହାଲୁକା ରକ୍ତସ୍ରାବ",
        "prevention": {"en":"Prevent mosquito bites, eliminate mosquito breeding sites",
                       "hi":"मच्छरों से बचें, मच्छर पालन स्थल हटाएँ",
                       "or":"ମଛ କାଟିବାରୁ ବଞ୍ଚନ୍ତୁ, ମଛ ପ୍ରଜନନ ସ୍ଥଳ ହଟାନ୍ତୁ"},
        "first_aid": {"en":"Rest, hydrate, paracetamol for fever, consult doctor",
                      "hi":"आराम करें, पानी पिएँ, बुखार में पैरासिटामोल लें, डॉक्टर से सलाह लें",
                      "or":"ବିଶ୍ରାମ କରନ୍ତୁ, ପାଣି ପିଉନ୍ତୁ, ଜ୍ୱର ପାଇଁ ପାରାସିଟାମଲ୍, ଡାକ୍ତରଙ୍କ ସହ ପରାମର୍ଶ କରନ୍ତୁ"},
        "medicine": "Paracetamol, avoid aspirin",
        "caution": {"en":"Watch for bleeding, seek urgent medical care if severe",
                    "hi":"रक्तस्राव पर ध्यान दें, गंभीर होने पर तुरंत डॉक्टर से मिलें",
                    "or":"ରକ୍ତସ୍ରାବ ଧ୍ୟାନ ଦିଅନ୍ତୁ, ଗମ୍ଭୀର ହେଲେ ତୁରନ୍ତ ଡାକ୍ତରଙ୍କ ସହ ଯାଆନ୍ତୁ"},
        "severity": "High",
        "category": "Infectious Disease"
    },
    "Typhoid": {
        "symptoms": "Fever, abdominal pain, headache, constipation or diarrhea",
        "symptoms_hi": "बुखार, पेट दर्द, सिर दर्द, कब्ज या दस्त",
        "symptoms_or": "ଜ୍ୱର, ପେଟ ବେଥା, ମୁଣ୍ଡ ବେଥା, କବ୍ଜ କିମ୍ବା ପାଖାପାଖି ଦସ୍ତ",
        "prevention": {"en":"Drink safe water, maintain hygiene, proper sanitation",
                       "hi":"सुरक्षित पानी पिएँ, स्वच्छता बनाएँ, उचित सैनिटेशन",
                       "or":"ସୁରକ୍ଷିତ ପାଣି ପିଉନ୍ତୁ, ସ୍ୱଚ୍ଛତା ରଖନ୍ତୁ, ସଠିକ୍ ସ୍ୟାନିଟେସନ୍"},
        "first_aid": {"en":"Hydrate, soft diet, seek medical attention for antibiotics",
                      "hi":"पानी पिएँ, हल्का भोजन लें, एंटीबायोटिक के लिए डॉक्टर से मिलें",
                      "or":"ପାଣି ପିଉନ୍ତୁ, ସହଜ ଖାଦ୍ୟ ଖାନ୍ତୁ, ଏଣ୍ଟିବାୟୋଟିକ୍ ପାଇଁ ଡାକ୍ତରଙ୍କ ସହ ଯାଆନ୍ତୁ"},
        "medicine": "Ciprofloxacin, Azithromycin",
        "caution": {"en":"Avoid contaminated food/water",
                    "hi":"संक्रमित भोजन/पानी से बचें",
                    "or":"ଦୂଷିତ ଖାଦ୍ୟ/ପାଣି ଏଡ଼ାନ୍ତୁ"},
        "severity": "High",
        "category": "Infectious Disease"
    },
    "Flu": {
        "symptoms": "Fever, cough, sore throat, runny or stuffy nose, body aches, fatigue",
        "symptoms_hi": "बुखार, खाँसी, गला खराब, नाक बहना या बंद, बदन में दर्द, थकान",
        "symptoms_or": "ଜ୍ୱର, କାଶି, ଗଳା ବେଥା, ନାକ ବହୁନି କିମ୍ବା ବନ୍ଦ, ଶରୀର ବେଥା, ଅଳସତା",
        "prevention": {"en":"Get flu vaccine, wash hands, avoid close contact with sick people",
                       "hi":"फ्लू का टीका लगाएँ, हाथ धोएँ, बीमार लोगों से दूरी बनाएँ",
                       "or":"ଫ୍ଲୁ ଟୀକା ନିଅନ୍ତୁ, ହାତ ଧୋନ୍ତୁ, ରୋଗୀଙ୍କ ସହ ଦୂରତା ରଖନ୍ତୁ"},
        "first_aid": {"en":"Rest, hydrate, take paracetamol for fever",
                      "hi":"आराम करें, पानी पिएँ, बुखार में पैरासिटामोल लें",
                      "or":"ବିଶ୍ରାମ କରନ୍ତୁ, ପାଣି ପିଉନ୍ତୁ, ଜ୍ୱର ପାଇଁ ପାରାସିଟାମଲ୍"},
        "medicine": "Oseltamivir, Paracetamol",
        "caution": {"en":"Seek medical attention if difficulty breathing occurs",
                    "hi":"साँस लेने में कठिनाई होने पर डॉक्टर से मिलें",
                    "or":"ଶ୍ଵାସ ଦୁଃଖ ହେଲେ ଡାକ୍ତରଙ୍କ ସହ ଯାଆନ୍ତୁ"},
        "severity": "Medium",
        "category": "Viral Infection"
    }
}

# ---------------- Multi-Language question sets ----------------
general_questions = [
    {
        "en": "Hello! What is your main symptom?",
        "hi": "नमस्ते! आपका मुख्य लक्षण क्या है?",
        "or": "ନମସ୍କାର! ଆପଣଙ୍କର ପ୍ରଧାନ ଲକ୍ଷଣ କ'ଣ?",
        "hinglish": "Hello! Aapka main symptom kya hai?"
    },
    {
        "en": "Do you have additional symptoms like fever, cough, or headache?",
        "hi": "क्या आपको बुखार, खांसी, या सिरदर्द जैसे अतिरिक्त लक्षण हैं?",
        "or": "ଆପଣଙ୍କୁ ଜ୍ୱର, କାଶ, କିମ୍ବା ମୁଣ୍ଡବଥା ଅଛି କି?",
        "hinglish": "Kya aapko bukhar, khansi, ya headache hai?"
    },
    {
        "en": "How many days have you had these symptoms?",
        "hi": "आपको ये लक्षण कितने दिन से हैं?",
        "or": "ଆପଣଙ୍କର ଏହି ଲକ୍ଷଣ କେତେ ଦିନ ହେବାକୁ ହେଲା?",
        "hinglish": "Ye symptoms kitne din se hain?"
    },
    {
        "en": "Have you traveled anywhere recently?",
        "hi": "क्या आपने हाल ही में कहीं यात्रा की है?",
        "or": "ଆପଣ ଏପର୍ଯ୍ୟନ୍ତ କେଉଁଠି ଯାତ୍ରା କରିଛନ୍ତି କି?",
        "hinglish": "Kya aapne recently kahi travel kiya hai?"
    },
    {
        "en": "Do you have any chronic health conditions like diabetes or heart disease?",
        "hi": "क्या आपको मधुमेह या हृदय रोग जैसी कोई पुरानी बीमारी है?",
        "or": "ଆପଣଙ୍କୁ ଡାୟାବେଟିଜ୍ କିମ୍ବା ହୃଦରୋଗ ଅଛି କି?",
        "hinglish": "Kya aapko diabetes ya heart disease hai?"
    }
]

disease_questions = {
    "Malaria": [
        {
            "en": "Have you noticed mosquito bites before fever started?",
            "hi": "क्या बुखार से पहले मच्छरों के काटने पर ध्यान दिया?",
            "or": "ଜ୍ୱର ପୂର୍ବରୁ ମଛ କାଟିଥିଲେ କି?",
            "hinglish": "Bukhar se pehle mosquito bites hue the kya?"
        },
        {
            "en": "Do you have chills or excessive sweating?",
            "hi": "क्या आपको ठंड लगना या ज़्यादा पसीना आना हो रहा है?",
            "or": "ଆପଣଙ୍କୁ ଥଣ୍ଡା ଲାଗୁଛି କିମ୍ବା ବହୁତ ପସିନା ହେଉଛି କି?",
            "hinglish": "Kya aapko thand lagti hai ya zyada pasina aata hai?"
        }
    ],
    "Dengue": [
        {
            "en": "Do you have pain behind the eyes?",
            "hi": "क्या आपकी आँखों के पीछे दर्द है?",
            "or": "ଆପଣଙ୍କ ଆଖି ପଛରେ ଯନ୍ତ୍ରଣା ଅଛି କି?",
            "hinglish": "Aankhon ke peeche dard hai kya?"
        },
        {
            "en": "Have you noticed any rashes on your body?",
            "hi": "क्या आपने शरीर पर कोई दाने देखे हैं?",
            "or": "ଆପଣଙ୍କ ଦେହରେ କିଛି ଦାନା ଦେଖିଛନ୍ତି କି?",
            "hinglish": "Body par koi rashes hain kya?"
        }
    ],
    "Typhoid": [
        {
            "en": "Are you having abdominal pain or constipation?",
            "hi": "क्या आपको पेट में दर्द या कब्ज है?",
            "or": "ଆପଣଙ୍କୁ ପେଟରେ ବେଥା କିମ୍ବା କବ୍ଜ ଅଛି କି?",
            "hinglish": "Pet me dard ya kabj hai kya?"
        },
        {
            "en": "Do you have loss of appetite?",
            "hi": "क्या आपकी भूख कम हो गई है?",
            "or": "ଆପଣଙ୍କର ଭୋଜନ ଇଚ୍ଛା କମିଛି କି?",
            "hinglish": "Aapki bhookh kam ho gayi kya?"
        }
    ],
    "Flu": [
        {
            "en": "Do you have a runny nose or sore throat?",
            "hi": "क्या आपकी नाक बह रही है या गला खराब है?",
            "or": "ଆପଣଙ୍କର ନାକ ବହୁଛି କିମ୍ବା ଗଳା ବେଥା ଅଛି କି?",
            "hinglish": "Naak beh rahi hai ya gala kharab hai kya?"
        },
        {
            "en": "Do you feel extreme fatigue or body aches?",
            "hi": "क्या आपको अत्यधिक थकान या बदन दर्द है?",
            "or": "ଆପଣଙ୍କୁ ବହୁତ ଅଳସତା କିମ୍ବା ଶରୀର ବେଥା ଅଛି କି?",
            "hinglish": "Thakan ya body pain zyada hai kya?"
        }
    ]
}

# ---------------- Preprocessing ----------------
def clean_text(text):
    return re.sub(r'[^a-zA-Z\s\u0900-\u097F]', '', text.lower())

texts, labels = [], []
for disease, info in disease_info.items():
    for key in ['symptoms','symptoms_hi','symptoms_or']:
        if key in info:
            texts.append(clean_text(info[key]))
            labels.append(disease)

# Tokenizer
tokenizer = Tokenizer(num_words=5000, oov_token="<OOV>")
tokenizer.fit_on_texts(texts)
sequences = tokenizer.texts_to_sequences(texts)
max_len = max(len(seq) for seq in sequences) if sequences else 20
padded_sequences = pad_sequences(sequences, maxlen=max_len, padding='post') if sequences else np.zeros((1,20))

# Encode labels
le = LabelEncoder()
y = le.fit_transform(labels) if labels else np.array([0])
y_categorical = to_categorical(y)

# ---------------- TensorFlow Model ----------------
model = Sequential()
model.add(Embedding(input_dim=5000, output_dim=64, input_length=max_len))
model.add(LSTM(64))
model.add(Dropout(0.3))
model.add(Dense(len(le.classes_), activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
# Train only if we have training data
if len(padded_sequences) > 0 and len(y_categorical) > 0:
    model.fit(padded_sequences, y_categorical, epochs=50, batch_size=8, verbose=0)
print("TensorFlow model trained!")

# ---------------- Language Detection ----------------
def detect_language(text):
    try:
        langs = detect_langs(text)
        if not langs:
            return 'en','English'
        lang_code = langs[0].lang.split('-')[0].lower()
        text_lower = text.lower()
        # Hindi keyword set
        hi_kw = ['hai','mera','mujhe','ka','se','kya','kaise','bukhar','khansi','bukhaar']
        en_kw = ['and','the','is','have','my','pain','fever','cough']
        if any(w in text_lower for w in hi_kw):
            if any(w in text_lower for w in en_kw):
                return 'hinglish','Hinglish'
            return 'hi','Hindi'
        if lang_code in ['en','hi','or']:
            return lang_code, {'en':'English','hi':'Hindi','or':'Odia'}[lang_code]
        return 'en','English'
    except:
        return 'en','English'

# ---------------- Prediction utility ----------------
def predict_disease(symptoms_text):
    seq = tokenizer.texts_to_sequences([clean_text(symptoms_text)])
    padded = pad_sequences(seq, maxlen=max_len, padding='post')
    pred = model.predict(padded, verbose=0)
    pred_idx = int(np.argmax(pred, axis=1)[0])
    disease = le.inverse_transform([pred_idx])[0]
    return disease, float(np.max(pred))

# ---------------- Flask Routes ----------------
@app.route("/")
def home():
    return render_template("frontend.html")

@app.route("/chat", methods=["POST"])
def chat():
    data = request.json
    text = data.get("message", "").strip()
    if not text:
        return jsonify({"error":"No message provided"}), 400

    # If new session, detect language and initialize
    if "phase" not in session:
        lang, _ = detect_language(text)
        session['lang'] = lang
        session['phase'] = 'general'   # phases: general -> specific -> done
        session['g_step'] = 0
        session['s_step'] = 0
        session['answers_general'] = []
        session['answers_specific'] = []
        # The first user message is treated as answer to first general question
        # so we append it and then return next general question below.
        session['answers_general'].append(text)
    else:
        # Existing session: depending on phase, append answers
        if session.get('phase') == 'general':
            # if user sent initial message but we already appended at creation, skip duplicate append
            if session.get('g_step') > 0:
                session['answers_general'].append(text)
        elif session.get('phase') == 'specific':
            session['answers_specific'].append(text)

    lang = session.get('lang', 'en')

    # --- General question flow ---
    if session['phase'] == 'general':
        if session['g_step'] < len(general_questions):
            # If g_step == 0 and we already consumed first user message as answer, we still need to ask next question
            q = general_questions[session['g_step']].get(lang, general_questions[session['g_step']]['en'])
            session['g_step'] += 1
            return jsonify({"reply": q})
        else:
            # finished general questions -> make preliminary prediction and move to specific phase
            all_general = " ".join(session.get('answers_general', []))
            predicted_disease, confidence = predict_disease(all_general)
            session['predicted_disease'] = predicted_disease
            session['phase'] = 'specific'
            session['s_step'] = 0

            # If we have specific questions for predicted disease, ask first one
            spec_qs = disease_questions.get(predicted_disease, [])
            if spec_qs:
                q = spec_qs[0].get(lang, spec_qs[0]['en'])
                session['s_step'] = 1
                return jsonify({"reply": f"Preliminary suggestion: {predicted_disease} (confidence {confidence:.2f}).\n" + q})
            else:
                # no specific qs, directly produce final prediction
                info = disease_info.get(predicted_disease, {})
                symptoms_key = 'symptoms' if lang == 'en' else f"symptoms_{lang}"
                prevention = info.get('prevention', {}).get(lang, info.get('prevention',''))
                first_aid = info.get('first_aid', {}).get(lang, info.get('first_aid',''))
                reply = (f"Based on your answers, you may have {predicted_disease} (confidence {confidence:.2f}).\n"
                         f"Category: {info.get('category')}\nSeverity: {info.get('severity')}\n"
                         f"Symptoms: {info.get(symptoms_key, info.get('symptoms'))}\n"
                         f"Prevention: {prevention}\nFirst Aid: {first_aid}\nConsult a doctor.")
                session.clear()
                return jsonify({"reply": reply, "disease": predicted_disease})

    # --- Specific question flow ---
    if session['phase'] == 'specific':
        pred = session.get('predicted_disease')
        spec_qs = disease_questions.get(pred, [])
        # We already asked first specific question when entering phase; s_step counts next to ask
        if session['s_step'] < len(spec_qs):
            q = spec_qs[session['s_step']].get(lang, spec_qs[session['s_step']]['en'])
            session['s_step'] += 1
            return jsonify({"reply": q})
        else:
            # finished specific questions -> final prediction using all collected answers
            all_text = " ".join(session.get('answers_general', []) + session.get('answers_specific', []))
            final_disease, final_conf = predict_disease(all_text)
            info = disease_info.get(final_disease, {})
            symptoms_key = 'symptoms' if lang == 'en' else f"symptoms_{lang}"
            prevention = info.get('prevention', {}).get(lang, info.get('prevention',''))
            first_aid = info.get('first_aid', {}).get(lang, info.get('first_aid',''))
            reply = (f"Based on all your answers, you may have {final_disease} (confidence {final_conf:.2f}).\n"
                     f"Category: {info.get('category')}\nSeverity: {info.get('severity')}\n"
                     f"Symptoms: {info.get(symptoms_key, info.get('symptoms'))}\n"
                     f"Prevention: {prevention}\nFirst Aid: {first_aid}\nConsult a doctor.")
            session.clear()
            return jsonify({"reply": reply, "disease": final_disease})

    # Fallback
    session.clear()
    return jsonify({"reply":"Something went wrong. Let's start again."})

if __name__ == "__main__":
    app.run(debug=True, host="0.0.0.0", port=5000)