Spaces:

SHIKARICHACHA
/

Medical_Bot

Sleeping

App Files Files Community

SHIKARICHACHA commited on Jul 14, 2025

Commit

6ffc385

verified ·

1 Parent(s): 516f715

Update app.py

Browse files

Files changed (1) hide show

app.py +473 -384

app.py CHANGED Viewed

@@ -1,397 +1,486 @@
-"""
-Adaptive Music Exercise Generator – Integer Durations Only
-========================================================
-1 unit = 1 quarter-note (integer only)
-"""
-# ------------------------------------------------------------------
-# 0. Auto-install deps (unchanged)
-# ------------------------------------------------------------------
-import sys, subprocess
-from typing import Dict, Optional, Tuple, List
-def install(pkgs: List[str]):
-    for p in pkgs:
-        try: __import__(p)
-        except ImportError:
-            subprocess.check_call([sys.executable, "-m", "pip", "install", p])
-install(["mido", "midi2audio", "pydub", "gradio", "requests"])
-# ------------------------------------------------------------------
-# 1. Imports
-# ------------------------------------------------------------------
-import random, requests, json, tempfile, mido, re, os, shutil, gradio as gr
-from mido import Message, MidiFile, MidiTrack, MetaMessage
-from midi2audio import FluidSynth
-from pydub import AudioSegment
-# ------------------------------------------------------------------
-# 2. Config
-# ------------------------------------------------------------------
-MISTRAL_API_URL = "https://api.mistral.ai/v1/chat/completions"
 MISTRAL_API_KEY = "yQdfM8MLbX9uhInQ7id4iUTwN4h4pDLX"
-SOUNDFONT_URLS = {
-    "Trumpet": "https://github.com/FluidSynth/fluidsynth/raw/master/sf2/Trumpet.sf2",
-    "Piano": "https://musical-artifacts.com/artifacts/2719/GeneralUser_GS_1.471.sf2",
-    "Violin": "https://musical-artifacts.com/artifacts/2744/SalC5Light.sf2",
-    "Clarinet": "https://musical-artifacts.com/artifacts/2744/SalC5Light.sf2",
-    "Flute": "https://musical-artifacts.com/artifacts/2744/SalC5Light.sf2",
 }
-TICKS_PER_BEAT = 480
-TICKS_PER_UNIT = TICKS_PER_BEAT
-# ------------------------------------------------------------------
-# 3. Note helpers – fixed regex & cleaner
-# ------------------------------------------------------------------
-NOTE_MAP = {"C":0,"C#":1,"DB":1,"D":2,"D#":3,"EB":3,"E":4,"F":5,"F#":6,"GB":6,
-            "G":7,"G#":8,"AB":8,"A":9,"A#":10,"BB":10,"B":11}
-def sanitise_note_name(n: str) -> str:
-    """Convert common variations to canonical form."""
-    n = n.strip().upper()
-    # Map full words
-    n = re.sub(r'\bFLAT\b', 'B', n, flags=re.I)
-    n = re.sub(r'\bSHARP\b', '#', n, flags=re.I)
-    # Map dash/space forms
-    n = re.sub(r'([A-G])\s*-\s*FLAT',  r'\1B', n, flags=re.I)
-    n = re.sub(r'([A-G])\s*-\s*SHARP', r'\1#', n, flags=re.I)
-    return n
-def note_name_to_midi(n: str) -> int:
-    n = sanitise_note_name(n)
-    m = re.fullmatch(r"([A-G][#B]?)(\d)", n)
-    if not m:
-        raise ValueError(f"Invalid note: {n}")
-    pitch, octave = m.groups()
-    pitch = pitch.replace('B', 'B')  # keep BB as B-flat
-    if pitch not in NOTE_MAP:
-        raise ValueError(f"Invalid pitch: {pitch}")
-    return NOTE_MAP[pitch] + (int(octave) + 1) * 12
-# ------------------------------------------------------------------
-# 4. Integer-only scaler – unchanged
-# ------------------------------------------------------------------
-def scale_json_durations(json_data, target_units: int) -> list:
-    ints = [[n, max(1, int(round(d)))] for n, d in json_data]
-    total = sum(d for _, d in ints)
-    deficit = target_units - total
-    if deficit > 0:
-        for i in range(deficit):
-            ints[i % len(ints)][1] += 1
-    elif deficit < 0:
-        for i in range(-deficit):
-            if ints[i % len(ints)][1] > 1:
-                ints[i % len(ints)][1] -= 1
-    return ints
-# ------------------------------------------------------------------
-# 5. JSON → MIDI – unchanged
-# ------------------------------------------------------------------
-def json_to_midi(json_data, instrument, tempo, time_signature, measures):
-    mid = MidiFile(ticks_per_beat=TICKS_PER_BEAT)
-    track = MidiTrack(); mid.tracks.append(track)
-    program = INSTRUMENT_PROGRAMS.get(instrument, 56)
-    num, denom = map(int, time_signature.split('/'))
-    track.append(MetaMessage('time_signature', numerator=num, denominator=denom, time=0))
-    track.append(MetaMessage('set_tempo', tempo=mido.bpm2tempo(tempo), time=0))
-    track.append(Message('program_change', program=program, time=0))
-    for note_name, dur_units in json_data:
-        note_num = note_name_to_midi(note_name)
-        ticks = max(int(dur_units * TICKS_PER_UNIT), 1)
-        vel = random.randint(60, 100)
-        track.append(Message('note_on', note=note_num, velocity=vel, time=0))
-        track.append(Message('note_off', note=note_num, velocity=vel, time=ticks))
-    return mid
-# ------------------------------------------------------------------
-# 6. Prompt helpers – always include strict format
-# ------------------------------------------------------------------
-INSTRUMENT_PROGRAMS = {"Piano":0,"Trumpet":56,"Violin":40,"Clarinet":71,"Flute":73}
-def fallback(instrument, level, key, time_sig, measures):
-    patterns = {
-        "Trumpet":["C4","D4","E4","G4"],
-        "Piano":["C4","E4","G4","C5"],
-        "Violin":["G4","A4","B4","D5"],
-        "Clarinet":["E4","F4","G4","Bb4"],
-        "Flute":["A4","B4","C5","E5"],
     }
-    pat = patterns.get(instrument, patterns["Trumpet"])
-    numerator = int(time_sig.split('/')[0])
-    total = measures * numerator
-    notes, durs = [], []
-    i = 0
-    while sum(durs) < total:
-        notes.append(pat[i % len(pat)])
-        durs.append(1)
-        i += 1
-    if sum(durs) > total:
-        durs[-1] -= sum(durs) - total
-    return json.dumps([[n,d] for n,d in zip(notes,durs)])
-# ------------------------------------------------------------------
-# 7. Mistral query – strengthened prompt
-# ------------------------------------------------------------------
-def query_mistral(prompt, instrument, level, key, time_sig, measures):
-    headers = {"Authorization": f"Bearer {MISTRAL_API_KEY}", "Content-Type": "application/json"}
-    numerator = int(time_sig.split('/')[0])
-    target_units = measures * numerator
-    strict_format = (
-        "Use ONLY standard note names like 'C4', 'F#5', 'Bb3'. "
-        "Use ONLY integer durations representing quarter-note beats: "
-        "1 = quarter, 2 = half, 4 = whole. "
-        f"Sum MUST equal exactly {target_units}. "
-        "Output ONLY a JSON array of [note, integer_duration] pairs. "
-        "No prose, no explanation."
-    )
-    system = f"You are an expert {instrument.lower()} teacher."
-    if prompt.strip():
-        user = f"{prompt}\n\n{strict_format}"
     else:
-        style = random.choice(["simple","jazzy","technical"])
-        tech = random.choice(["with long tones","with slurs","with double tonguing"])
-        user = f"Create a {style} {instrument.lower()} exercise in {key}, {time_sig}, {tech}. {strict_format}"
-    payload = {
-        "model":"mistral-medium",
-        "messages":[{"role":"system","content":system},{"role":"user","content":user}],
-        "max_tokens":800,
-        "temperature":0.6,
-    }
-    try:
-        r = requests.post(MISTRAL_API_URL, headers=headers, json=payload)
-        r.raise_for_status()
-        return r.json()["choices"][0]["message"]["content"].strip()
-    except Exception as e:
-        print("Mistral error:", e)
-        return fallback(instrument, level, key, time_sig, measures)
-# ------------------------------------------------------------------
-# 8. Safe JSON parse – unchanged
-# ------------------------------------------------------------------
-def safe_parse(text):
-    try:
-        text = text.replace("'",'"')
-        m = re.search(r"\[(\s*\[.*?\]\s*,?)*\]", text, re.DOTALL)
-        return json.loads(m.group(0) if m else text)
-    except Exception:
-        return None
-# ------------------------------------------------------------------
-# 9. Main generation – unchanged
-# ------------------------------------------------------------------
-def generate_exercise(instrument, level, key, tempo, ts, measures, custom_prompt, mode):
-    try:
-        prompt_in = custom_prompt if mode=="Exercise Prompt" else ""
-        raw = query_mistral(prompt_in, instrument, level, key, ts, measures)
-        parsed = safe_parse(raw)
-        if not parsed:
-            return "Invalid JSON", None, str(tempo), None, "0", ts
-        numerator = int(ts.split('/')[0])
-        target_units = measures * numerator
-        scaled = scale_json_durations(parsed, target_units)
-        midi = json_to_midi(scaled, instrument, tempo, ts, measures)
-        # MIDI → MP3
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".mid") as f:
-            midi.save(f.name)
-            wav = f.name.replace(".mid",".wav")
-            mp3 = f.name.replace(".mid",".mp3")
-        sf2 = get_soundfont(instrument)
-        import subprocess as sp
-        sp.run(["fluidsynth","-ni",sf2,f.name,"-F",wav,"-r","44100"], check=True, capture_output=True)
-        AudioSegment.from_wav(wav).export(mp3, format="mp3")
-        static_mp3 = os.path.join("static", os.path.basename(mp3))
-        shutil.move(mp3, static_mp3)
-        dur = AudioSegment.from_mp3(static_mp3).duration_seconds
-        return json.dumps(scaled, indent=2), static_mp3, str(tempo), midi, f"{dur:.2f}s", ts
-    except Exception as e:
-        return f"Error: {e}", None, str(tempo), None, "0", ts
-def get_soundfont(instrument):
-    os.makedirs("soundfonts", exist_ok=True)
-    sf2 = f"soundfonts/{instrument}.sf2"
-    if not os.path.exists(sf2):
-        open(sf2,"wb").write(requests.get(SOUNDFONT_URLS[instrument]).content)
-    return sf2
-# ------------------------------------------------------------------
-# 10. Chat helper – unchanged
-# ------------------------------------------------------------------
-def chat(msg, hist, instr, lvl):
-    if not msg.strip(): return "", hist
-    msgs=[{"role":"system","content":f"You are a {instr} teacher for {lvl} students."}]
-    for u,a in hist: msgs.extend([{"role":"user","content":u},{"role":"assistant","content":a}])
-    msgs.append({"role":"user","content":msg})
-    headers={"Authorization":f"Bearer {MISTRAL_API_KEY}","Content-Type":"application/json"}
-    payload={"model":"mistral-medium","messages":msgs,"max_tokens":500}
-    try:
-        r=requests.post(MISTRAL_API_URL,headers=headers,json=payload)
-        r.raise_for_status()
-        reply=r.json()["choices"][0]["message"]["content"]
-        hist.append((msg,reply))
-        return "", hist
-    except Exception as e:
-        hist.append((msg,f"Error: {e}"))
-        return "", hist
-# ------------------------------------------------------------------
-# 11. Gradio UI – unchanged
-# ------------------------------------------------------------------
-def ui():
-    with gr.Blocks(title="Adaptive Music Exercise Generator – Integer Durations") as demo:
-        gr.Markdown("# 🎼 Adaptive Music Exercise Generator – Integer Durations")
-        mode = gr.Radio(["Exercise Parameters","Exercise Prompt"], value="Exercise Parameters", label="Mode")
-        with gr.Row():
-            with gr.Column(scale=1):
-                with gr.Group(visible=True) as params_group:
-                    instrument=gr.Dropdown(["Trumpet","Piano","Violin","Clarinet","Flute"],value="Trumpet")
-                    level = gr.Radio(["Beginner","Intermediate","Advanced"], value="Intermediate")
-                    key = gr.Dropdown(["C Major","G Major","D Major","F Major","Bb Major","A Minor","E Minor"],value="C Major")
-                    ts = gr.Dropdown(["3/4","4/4"], value="4/4", label="Time Signature")
-                    measures = gr.Radio([4,8], value=4, label="Length (measures)")
-                with gr.Group(visible=False) as prompt_group:
-                    prompt_txt = gr.Textbox("", lines=3, label="Custom prompt")
-                    measures2 = gr.Radio([4,8], value=4, label="Length (measures)")
-                gen_btn = gr.Button("Generate Exercise", variant="primary")
-            with gr.Column(scale=2):
-                with gr.Tabs():
-                    with gr.TabItem("Player"):
-                        audio=gr.Audio(autoplay=True)
-                        bpm=gr.Textbox(label="Tempo (BPM)")
-                        ts_disp=gr.Textbox(label="Time Signature")
-                        dur=gr.Textbox(label="Duration")
-                    with gr.TabItem("Data"):
-                        js_out=gr.Code(language="json")
-                    with gr.TabItem("MIDI"):
-                        midi_file=gr.File()
-                        dl_btn=gr.Button("Download MIDI")
-                    with gr.TabItem("Chat"):
-                        chatbot=gr.Chatbot(height=400)
-                        chat_in=gr.Textbox(label="Ask the AI")
-                        chat_btn=gr.Button("Send")
-        mode.change(lambda m:{params_group:gr.update(visible=m=="Exercise Parameters"),
-                              prompt_group:gr.update(visible=m=="Exercise Prompt")},
-                    [mode],[params_group,prompt_group])
-        def caller(m,i,l,k,t,ms,p,ms2):
-            real_ms = ms2 if m=="Exercise Prompt" else ms
-            return generate_exercise(i,l,k,60,t,real_ms,p or "",m)
-        gen_btn.click(caller,[mode,instrument,level,key,ts,measures,prompt_txt,measures2],
-                      [js_out,audio,bpm,gr.State(),dur,ts_disp])
-        def save(json_txt,instr,ts):
-            data=safe_parse(json_txt)
-            if not data: return None
-            num=int(ts.split('/')[0])
-            target=sum(int(d) for _,d in data)
-            measures_est=max(1,round(target/num))
-            scaled=scale_json_durations(data,measures_est*num)
-            midi=json_to_midi(scaled,instr,60,ts,measures_est)
-            path="static/exercise.mid"
-            midi.save(path)
-            return path
-        dl_btn.click(save,[js_out,instrument,ts],[midi_file])
-        chat_btn.click(chat,[chat_in,chatbot,instrument,level],[chat_in,chatbot])
-    return demo
-if __name__ == "__main__":
-    ui().launch()            response += "⚠️ [When to Seek Medical Care]\n" + "\n".join(["• " + item for item in knowledge["warnings"]]) + "\n\n"
-            response += "📅 [Follow-up]\n• Re-evaluate in 2-3 days if not improving\n• See doctor if symptoms worsen or persist beyond 5 days"
-            return response
-    return None
-def query_mistral(prompt):
-    """Try API first, fallback to local knowledge"""
-    try:
-        headers = {"Authorization": f"Bearer {MISTRAL_API_KEY}", "Content-Type": "application/json"}
-        payload = {
-            "model": "mistral-tiny",
-            "messages": [{"role": "user", "content": prompt}],
-            "temperature": 0.7,
-            "max_tokens": 1024
         }
-        response = requests.post(MISTRAL_API_URL, headers=headers, json=payload, timeout=10)
-        response.raise_for_status()
-        return response.json()['choices'][0]['message']['content']
-    except:
-        return None
-def generate_response(name, message):
-    """Generate medical response with fallback"""
-    # First try local knowledge base
-    local_response = get_local_advice(message)
-    if local_response:
-        return f"Hello {name},\n\n{local_response}\n\nWishing you good health,\nDr. Alex"
-    # Then try API
-    prompt = f"""As Dr. Alex, provide structured advice for {name} who reports: "{message}"
-    Format response with these sections:
-    [Assessment] - Brief professional evaluation
-    [Self-Care Recommendations] - 3-5 specific actionable steps
-    [When to Seek Medical Care] - Clear warning signs
-    [Follow-up] - Monitoring advice
-    Use bullet points, professional yet compassionate tone."""
-    api_response = query_mistral(prompt)
-    if api_response:
-        return api_response
-    # Final fallback
-    common_conditions = "\n".join([f"- {cond}" for cond in MEDICAL_KNOWLEDGE.keys()])
-    return f"""Hello {name},
-I'm currently unable to access detailed medical databases. For general advice:
-Common conditions I can advise on:
-{common_conditions}
-For immediate concerns:
-• Contact your local healthcare provider
-• In emergencies, call your local emergency number
-Please try asking about one of these common conditions or consult a healthcare professional.
-Best regards,
-Dr. Alex"""
-# Gradio Interface
-with gr.Blocks(title="Dr. Alex Medical Advisor", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🩺 Dr. Alex - General Health Advisor")
-    name = gr.Textbox(label="Your Name", placeholder="Enter your name")
-    with gr.Tab("Health Consultation"):
-        gr.Markdown("## Describe your health concern")
-        msg = gr.Textbox(label="Symptoms/Question", lines=3)
-        submit_btn = gr.Button("Get Medical Advice")
-        output = gr.Textbox(label="Dr. Alex's Advice", lines=15, interactive=False)
-    submit_btn.click(
-        fn=lambda name, msg: generate_response(name, msg),
-        inputs=[name, msg],
-        outputs=output
-    )
-    gr.Markdown("### Common Health Topics")
-    with gr.Row():
-        for condition in MEDICAL_KNOWLEDGE:
-            gr.Button(condition.capitalize()).click(
-                fn=lambda name, cond=condition: generate_response(name, cond),
-                inputs=[name],
-                outputs=output
-            )
-demo.launch()

+import streamlit as st
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+import requests
+# Set page config
+st.set_page_config(
+    page_title="Heart Disease Prediction",
+    page_icon="❤️",
+    layout="wide"
+)
+# Mistral API Key
 MISTRAL_API_KEY = "yQdfM8MLbX9uhInQ7id4iUTwN4h4pDLX"
+# Feature information with medical ranges
+feature_info = {
+    "age": {"label": "Age", "desc": "Age in years", "min": 20, "max": 100, "value": 50,
+            "healthy_range": "20-60", "risk_range": "60+"},
+    "sex": {"label": "Sex", "desc": "Biological sex", "options": ["Female", "Male"]},
+    "cp": {"label": "Chest Pain Type", "desc": "Type of chest pain",
+           "options": ["Typical angina", "Atypical angina", "Non-anginal pain", "Asymptomatic"],
+           "healthy": "Typical angina", "risk": "Asymptomatic"},
+    "trestbps": {"label": "Resting BP", "desc": "Resting blood pressure (mm Hg)",
+                 "min": 80, "max": 200, "value": 120,
+                 "healthy_range": "90-120", "risk_range": "140+"},
+    "chol": {"label": "Cholesterol", "desc": "Serum cholesterol (mg/dl)",
+             "min": 100, "max": 600, "value": 200,
+             "healthy_range": "< 200", "risk_range": "240+"},
+    "fbs": {"label": "Fasting Blood Sugar", "desc": "> 120 mg/dl", "options": ["No", "Yes"],
+            "healthy": "No", "risk": "Yes"},
+    "restecg": {"label": "Resting ECG", "desc": "Resting electrocardiographic results",
+                "options": ["Normal", "ST-T wave abnormality", "Left ventricular hypertrophy"],
+                "healthy": "Normal", "risk": "Left ventricular hypertrophy"},
+    "thalach": {"label": "Max Heart Rate", "desc": "Maximum heart rate achieved",
+                "min": 60, "max": 220, "value": 150,
+                "healthy_range": "60-100 (resting)", "risk_range": "< 120 (exercise)"},
+    "exang": {"label": "Exercise Angina", "desc": "Exercise induced angina", "options": ["No", "Yes"],
+              "healthy": "No", "risk": "Yes"},
+    "oldpeak": {"label": "ST Depression", "desc": "ST depression induced by exercise",
+                "min": 0.0, "max": 6.0, "value": 1.0, "step": 0.1,
+                "healthy_range": "0-1", "risk_range": "2+"},
+    "slope": {"label": "ST Slope", "desc": "Slope of peak exercise ST segment",
+              "options": ["Upsloping", "Flat", "Downsloping"],
+              "healthy": "Upsloping", "risk": "Downsloping"},
+    "ca": {"label": "Major Vessels", "desc": "Number of major vessels colored by fluoroscopy",
+           "options": ["0", "1", "2", "3"],
+           "healthy": "0", "risk": "3"},
+    "thal": {"label": "Thalassemia", "desc": "Blood disorder called thalassemia",
+             "options": ["Normal", "Fixed defect", "Reversible defect"],
+             "healthy": "Normal", "risk": "Fixed defect"}
 }
+# Risk assessment thresholds
+RISK_THRESHOLDS = {
+    "Low": 0.3,
+    "Moderate": 0.6,
+    "High": 1.0
+}
+# Sample healthy and unhealthy profiles
+SAMPLE_PROFILES = {
+    "Healthy": {
+        "age": 45, "sex": "Female", "cp": "Typical angina",
+        "trestbps": 110, "chol": 180, "fbs": "No",
+        "restecg": "Normal", "thalach": 160, "exang": "No",
+        "oldpeak": 0.5, "slope": "Upsloping", "ca": "0",
+        "thal": "Normal"
+    },
+    "Moderate Risk": {
+        "age": 58, "sex": "Male", "cp": "Atypical angina",
+        "trestbps": 135, "chol": 230, "fbs": "No",
+        "restecg": "ST-T wave abnormality", "thalach": 140, "exang": "No",
+        "oldpeak": 1.5, "slope": "Flat", "ca": "1",
+        "thal": "Reversible defect"
+    },
+    "High Risk": {
+        "age": 65, "sex": "Male", "cp": "Asymptomatic",
+        "trestbps": 180, "chol": 280, "fbs": "Yes",
+        "restecg": "Left ventricular hypertrophy", "thalach": 120, "exang": "Yes",
+        "oldpeak": 3.0, "slope": "Downsloping", "ca": "3",
+        "thal": "Fixed defect"
     }
+}
+def calculate_risk(inputs):
+    """Calculate heart disease risk based on clinical parameters"""
+    risk_factors = 0
+    total_possible = 13  # Total parameters being evaluated
+    risk_details = []
+    risk_params = []
+    if inputs['age'] > 60:
+        risk_factors += 1
+        risk_details.append(f"- Age: {inputs['age']} (Risk: 60+)")
+        risk_params.append('age')
+    if inputs['sex'] == 'Male':
+        risk_factors += 1
+        risk_details.append("- Sex: Male (Higher risk)")
+        risk_params.append('sex')
+    if inputs['cp'] == 'Asymptomatic':
+        risk_factors += 1
+        risk_details.append("- Chest Pain: Asymptomatic (Highest risk)")
+        risk_params.append('cp')
+    elif inputs['cp'] in ['Atypical angina', 'Non-anginal pain']:
+        risk_factors += 0.5
+        risk_details.append(f"- Chest Pain: {inputs['cp']} (Moderate risk)")
+    if inputs['trestbps'] >= 140:
+        risk_factors += 1
+        risk_details.append(f"- Blood Pressure: {inputs['trestbps']} mmHg (Stage 2 Hypertension)")
+        risk_params.append('trestbps')
+    elif inputs['trestbps'] >= 130:
+        risk_factors += 0.5
+        risk_details.append(f"- Blood Pressure: {inputs['trestbps']} mmHg (Elevated)")
+    if inputs['chol'] >= 240:
+        risk_factors += 1
+        risk_details.append(f"- Cholesterol: {inputs['chol']} mg/dL (High)")
+        risk_params.append('chol')
+    elif inputs['chol'] >= 200:
+        risk_factors += 0.5
+        risk_details.append(f"- Cholesterol: {inputs['chol']} mg/dL (Borderline High)")
+    if inputs['fbs'] == 'Yes':
+        risk_factors += 1
+        risk_details.append("- Fasting Blood Sugar > 120 mg/dL")
+        risk_params.append('fbs')
+    if inputs['restecg'] == 'Left ventricular hypertrophy':
+        risk_factors += 1
+        risk_details.append("- ECG: Left Ventricular Hypertrophy")
+        risk_params.append('restecg')
+    elif inputs['restecg'] == 'ST-T wave abnormality':
+        risk_factors += 0.5
+        risk_details.append("- ECG: ST-T Wave Abnormality")
+    if inputs['thalach'] < 120:
+        risk_factors += 1
+        risk_details.append(f"- Max Heart Rate: {inputs['thalach']} (Low)")
+        risk_params.append('thalach')
+    if inputs['exang'] == 'Yes':
+        risk_factors += 1
+        risk_details.append("- Exercise Induced Angina: Yes")
+        risk_params.append('exang')
+    if inputs['oldpeak'] >= 2.0:
+        risk_factors += 1
+        risk_details.append(f"- ST Depression: {inputs['oldpeak']} (High)")
+        risk_params.append('oldpeak')
+    elif inputs['oldpeak'] >= 1.0:
+        risk_factors += 0.5
+        risk_details.append(f"- ST Depression: {inputs['oldpeak']} (Moderate)")
+    if inputs['slope'] == 'Downsloping':
+        risk_factors += 1
+        risk_details.append("- ST Slope: Downsloping (Highest risk)")
+        risk_params.append('slope')
+    elif inputs['slope'] == 'Flat':
+        risk_factors += 0.5
+        risk_details.append("- ST Slope: Flat (Moderate risk)")
+    if inputs['ca'] == '3':
+        risk_factors += 1
+        risk_details.append("- Major Vessels: 3 (Highest risk)")
+        risk_params.append('ca')
+    elif inputs['ca'] in ['1', '2']:
+        risk_factors += 0.5
+        risk_details.append(f"- Major Vessels: {inputs['ca']} (Moderate risk)")
+    if inputs['thal'] == 'Fixed defect':
+        risk_factors += 1
+        risk_details.append("- Thalassemia: Fixed Defect")
+        risk_params.append('thal')
+    elif inputs['thal'] == 'Reversible defect':
+        risk_factors += 0.5
+        risk_details.append("- Thalassemia: Reversible Defect")
+    probability = min(risk_factors / total_possible, 0.99)  # Cap at 99%
+    if probability <= RISK_THRESHOLDS['Low']:
+        risk_level = 'Low'
+        color = "green"
+        icon = "✅"
+        advice = "Maintain your healthy lifestyle with regular check-ups."
+    elif probability <= RISK_THRESHOLDS['Moderate']:
+        risk_level = 'Moderate'
+        color = "orange"
+        icon = "⚠️"
+        advice = "Consider lifestyle changes and consult your doctor."
     else:
+        risk_level = 'High'
+        color = "red"
+        icon = "❗"
+        advice = "Please consult a cardiologist immediately."
+    return risk_level, probability, color, icon, advice, risk_details, risk_params
+# App layout
+st.title("❤️ Heart Disease Risk Assessment")
+st.markdown("""
+This tool evaluates your heart disease risk based on clinical parameters and provides personalized insights.
+""")
+# Create tabs
+tab1, tab2, tab3 = st.tabs(["Risk Assessment", "Parameter Analysis", "Health Guidance"])
+with tab1:
+    with st.form("heart_form"):
+        st.subheader("Enter Your Health Parameters")
+        col1, col2, col3 = st.columns(3)
+        inputs = {}
+        # Column 1
+        with col1:
+            inputs["age"] = st.number_input(
+                feature_info["age"]["label"],
+                min_value=feature_info["age"]["min"],
+                max_value=feature_info["age"]["max"],
+                value=st.session_state.get("age", feature_info["age"]["value"]),
+                help=f"{feature_info['age']['desc']}. Healthy range: {feature_info['age']['healthy_range']}"
+            )
+            inputs["sex"] = st.selectbox(
+                feature_info["sex"]["label"],
+                feature_info["sex"]["options"],
+                index=feature_info["sex"]["options"].index(st.session_state.get("sex", feature_info["sex"]["options"][0])),
+                help=feature_info["sex"]["desc"]
+            )
+            inputs["cp"] = st.selectbox(
+                feature_info["cp"]["label"],
+                feature_info["cp"]["options"],
+                index=feature_info["cp"]["options"].index(st.session_state.get("cp", feature_info["cp"]["options"][0])),
+                help=f"{feature_info['cp']['desc']}. Healthy: {feature_info['cp']['healthy']}"
+            )
+            inputs["trestbps"] = st.number_input(
+                feature_info["trestbps"]["label"],
+                min_value=feature_info["trestbps"]["min"],
+                max_value=feature_info["trestbps"]["max"],
+                value=st.session_state.get("trestbps", feature_info["trestbps"]["value"]),
+                help=f"{feature_info['trestbps']['desc']}. Healthy: {feature_info['trestbps']['healthy_range']}"
+            )
+            inputs["chol"] = st.number_input(
+                feature_info["chol"]["label"],
+                min_value=feature_info["chol"]["min"],
+                max_value=feature_info["chol"]["max"],
+                value=st.session_state.get("chol", feature_info["chol"]["value"]),
+                help=f"{feature_info['chol']['desc']}. Healthy: {feature_info['chol']['healthy_range']}"
+            )
+        # Column 2
+        with col2:
+            inputs["fbs"] = st.selectbox(
+                feature_info["fbs"]["label"],
+                feature_info["fbs"]["options"],
+                index=feature_info["fbs"]["options"].index(st.session_state.get("fbs", feature_info["fbs"]["options"][0])),
+                help=f"{feature_info['fbs']['desc']}. Healthy: {feature_info['fbs']['healthy']}"
+            )
+            inputs["restecg"] = st.selectbox(
+                feature_info["restecg"]["label"],
+                feature_info["restecg"]["options"],
+                index=feature_info["restecg"]["options"].index(st.session_state.get("restecg", feature_info["restecg"]["options"][0])),
+                help=f"{feature_info['restecg']['desc']}. Healthy: {feature_info['restecg']['healthy']}"
+            )
+            inputs["thalach"] = st.number_input(
+                feature_info["thalach"]["label"],
+                min_value=feature_info["thalach"]["min"],
+                max_value=feature_info["thalach"]["max"],
+                value=st.session_state.get("thalach", feature_info["thalach"]["value"]),
+                help=f"{feature_info['thalach']['desc']}. Healthy: {feature_info['thalach']['healthy_range']}"
+            )
+            inputs["exang"] = st.selectbox(
+                feature_info["exang"]["label"],
+                feature_info["exang"]["options"],
+                index=feature_info["exang"]["options"].index(st.session_state.get("exang", feature_info["exang"]["options"][0])),
+                help=f"{feature_info['exang']['desc']}. Healthy: {feature_info['exang']['healthy']}"
+            )
+            inputs["oldpeak"] = st.number_input(
+                feature_info["oldpeak"]["label"],
+                min_value=feature_info["oldpeak"]["min"],
+                max_value=feature_info["oldpeak"]["max"],
+                value=st.session_state.get("oldpeak", feature_info["oldpeak"]["value"]),
+                step=feature_info["oldpeak"]["step"],
+                help=f"{feature_info['oldpeak']['desc']}. Healthy: {feature_info['oldpeak']['healthy_range']}"
+            )
+        # Column 3
+        with col3:
+            inputs["slope"] = st.selectbox(
+                feature_info["slope"]["label"],
+                feature_info["slope"]["options"],
+                index=feature_info["slope"]["options"].index(st.session_state.get("slope", feature_info["slope"]["options"][0])),
+                help=f"{feature_info['slope']['desc']}. Healthy: {feature_info['slope']['healthy']}"
+            )
+            inputs["ca"] = st.selectbox(
+                feature_info["ca"]["label"],
+                feature_info["ca"]["options"],
+                index=feature_info["ca"]["options"].index(st.session_state.get("ca", feature_info["ca"]["options"][0])),
+                help=f"{feature_info['ca']['desc']}. Healthy: {feature_info['ca']['healthy']}"
+            )
+            inputs["thal"] = st.selectbox(
+                feature_info["thal"]["label"],
+                feature_info["thal"]["options"],
+                index=feature_info["thal"]["options"].index(st.session_state.get("thal", feature_info["thal"]["options"][0])),
+                help=f"{feature_info['thal']['desc']}. Healthy: {feature_info['thal']['healthy']}"
+            )
+        submitted = st.form_submit_button("Assess My Heart Disease Risk")
+    if submitted:
+        risk_level, prediction_proba, color, icon, advice, risk_details, risk_params = calculate_risk(inputs)
+        st.subheader("Risk Assessment Results")
+        cols = st.columns(3)
+        with cols[1]:
+            st.metric("Heart Disease Risk", f"{prediction_proba * 100:.1f}%", f"{risk_level} Risk", delta_color="off")
+        risk_meter = st.progress(prediction_proba)
+        st.markdown(f"""
+        <div style="background-color:#f0f2f6;padding:15px;border-radius:10px">
+            <h4 style="color:{color};text-align:center">{icon} {risk_level} Risk Category</h4>
+            <p style="text-align:center">{advice}</p>
+        </div>
+        """, unsafe_allow_html=True)
+        st.subheader("Risk Factor Analysis")
+        total_factors = 13
+        risk_factors = len(risk_details)
+        st.write(f"**{risk_factors} out of {total_factors}** parameters show elevated risk:")
+        if risk_details:
+            st.markdown("\n".join(risk_details))
+        else:
+            st.success("All parameters are within healthy ranges!")
+        st.session_state.results = {
+            "risk_level": risk_level,
+            "probability": prediction_proba,
+            "risk_factors": risk_details,
+            "risk_params": risk_params,
+            "inputs": inputs
         }
+with tab2:
+    st.header("Parameter Analysis")
+    if "results" not in st.session_state:
+        st.warning("Please complete the risk assessment first.")
+    else:
+        st.subheader("Health Parameter Radar Chart")
+        radar_params = ["age", "trestbps", "chol", "thalach", "oldpeak"]
+        radar_labels = [feature_info[p]["label"] for p in radar_params]
+        radar_values = [st.session_state.results["inputs"][p] for p in radar_params]
+        max_values = {
+            "age": 100,
+            "trestbps": 200,
+            "chol": 600,
+            "thalach": 220,
+            "oldpeak": 6.0
+        }
+        normalized_values = [v / max_values[p] for v, p in zip(radar_values, radar_params)]
+        angles = np.linspace(0, 2 * np.pi, len(radar_labels), endpoint=False).tolist()
+        angles += angles[:1]
+        normalized_values += normalized_values[:1]
+        fig, ax = plt.subplots(figsize=(6, 6), subplot_kw=dict(polar=True))
+        ax.fill(angles, normalized_values, color='red', alpha=0.25)
+        ax.plot(angles, normalized_values, color='red', linewidth=2)
+        ax.set_xticks(angles[:-1])
+        ax.set_xticklabels(radar_labels)
+        ax.set_yticklabels([])
+        ax.set_title("Your Health Parameters (Normalized)", pad=20)
+        st.pyplot(fig)
+        st.subheader("Parameter Comparison")
+        comparison_data = []
+        for param in ["age", "trestbps", "chol", "thalach", "oldpeak"]:
+            info = feature_info[param]
+            status = "⚠️ Out of Range" if param in st.session_state.results["risk_params"] else "✅ Within Range"
+            comparison_data.append({
+                "Parameter": info["label"],
+                "Your Value": st.session_state.results["inputs"][param],
+                "Healthy Range": info.get("healthy_range", info.get("healthy", "")),
+                "Status": status
+            })
+        st.table(pd.DataFrame(comparison_data))
+with tab3:
+    st.header("Personalized Health Guidance")
+    if "results" not in st.session_state:
+        st.warning("Please complete the risk assessment first.")
+    else:
+        risk_level = st.session_state.results["risk_level"]
+        # Basic guidance
+        if risk_level == "Low":
+            st.success("""
+            **Your heart health looks good!**
+            Maintain these healthy habits:
+            - Continue regular exercise (150 mins/week moderate activity)
+            - Eat a balanced diet rich in fruits, vegetables, and whole grains
+            - Get 7-9 hours of quality sleep nightly
+            - Manage stress through relaxation techniques
+            - Annual check-ups with your doctor
+            """)
+        elif risk_level == "Moderate":
+            st.warning("""
+            **Your heart health needs attention**
+            Recommended actions:
+            - Increase physical activity (aim for 30 mins/day)
+            - Reduce sodium (<1500mg/day) and saturated fat intake
+            - Quit smoking if applicable
+            - Limit alcohol to 1 drink/day (women) or 2/day (men)
+            - Monitor blood pressure regularly
+            - Schedule a doctor's visit within 3 months
+            - Consider cholesterol screening
+            """)
+        else:
+            st.error("""
+            **Your heart health requires immediate attention**
+            Critical next steps:
+            - Consult a cardiologist within 1 month
+            - Begin a supervised exercise program
+            - Strict dietary modifications (Mediterranean diet recommended)
+            - Medication may be needed (doctor will advise)
+            - Regular monitoring of blood pressure and cholesterol
+            - Consider cardiac rehabilitation program
+            - Emergency care if chest pain or shortness of breath occurs
+            """)
+        # AI-Powered Recommendations
+        st.subheader("AI-Powered Recommendations")
+        if st.button("Get Personalized AI Advice"):
+            with st.spinner("Generating AI recommendations..."):
+                try:
+                    # Prepare the prompt for Mistral API
+                    prompt = f"""
+                    Provide detailed, personalized heart health recommendations for a patient with the following profile:
+                    - Age: {st.session_state.results["inputs"]["age"]}
+                    - Sex: {st.session_state.results["inputs"]["sex"]}
+                    - Risk Level: {risk_level}
+                    - Key Risk Factors: {', '.join(st.session_state.results["risk_params"])}
+                    Provide specific, actionable advice on:
+                    1. Lifestyle modifications
+                    2. Dietary recommendations
+                    3. Exercise suggestions
+                    4. Monitoring suggestions
+                    5. When to seek medical attention
+                    Format the response with clear headings and bullet points.
+                    """
+                    # Call Mistral API
+                    headers = {
+                        "Authorization": f"Bearer {MISTRAL_API_KEY}",
+                        "Content-Type": "application/json"
+                    }
+                    data = {
+                        "model": "mistral-tiny",
+                        "messages": [{"role": "user", "content": prompt}]
+                    }
+                    response = requests.post(
+                        "https://api.mistral.ai/v1/chat/completions",
+                        headers=headers,
+                        json=data
+                    )
+                    if response.status_code == 200:
+                        ai_response = response.json()["choices"][0]["message"]["content"]
+                        st.markdown("### AI Health Advisor Recommendations")
+                        st.write(ai_response)
+                    else:
+                        st.error(f"Failed to get AI recommendations. Status code: {response.status_code}")
+                except Exception as e:
+                    st.error(f"An error occurred: {str(e)}")
+# Sidebar with sample profiles
+st.sidebar.header("Quick Start")
+profile = st.sidebar.selectbox("Load sample profile:", list(SAMPLE_PROFILES.keys()))
+if st.sidebar.button("Load Profile"):
+    for key in list(st.session_state.keys()):
+        if key in feature_info:
+            del st.session_state[key]
+    for key, value in SAMPLE_PROFILES[profile].items():
+        st.session_state[key] = value
+    st.rerun()
+# Disclaimer
+st.sidebar.markdown("""
+### Important Disclaimer
+This tool provides risk assessment only and is not a substitute for professional medical advice.
+Always consult with a qualified healthcare provider for medical concerns.
+""")