Update app.py

app.py

@@ -1,70 +1,312 @@
-import gradio as gr
-import os
-import requests
-from datetime import datetime
+"""
+Adaptive Music Exercise Generator – Integer Durations Only
+========================================================
+1 unit = 1 quarter-note (integer only)
+"""
 
-# Mistral API setup
-MISTRAL_API_KEY = os.getenv("MISTRAL_API_KEY", "yQdfM8MLbX9uhInQ7id4iUTwN4h4pDLX")
+# ------------------------------------------------------------------
+# 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"
 
-# Local medical knowledge base
-MEDICAL_KNOWLEDGE = {
-    "headache": {
-        "assessment": "Could be tension-type, migraine, or other common headache",
-        "recommendations": [
-            "Rest in a quiet, dark room",
-            "Apply cold compress to forehead",
-            "Hydrate well (at least 8 glasses water/day)",
-            "Try gentle neck stretches",
-            "Consider OTC pain relievers (ibuprofen 200-400mg or paracetamol 500mg)"
-        ],
-        "warnings": [
-            "If sudden/severe 'thunderclap' headache",
-            "If with fever, stiff neck, or confusion",
-            "If following head injury"
-        ]
-    },
-    "fever": {
-        "assessment": "Common symptom of infection or inflammation",
-        "recommendations": [
-            "Rest and increase fluid intake",
-            "Use light clothing and keep room cool",
-            "Sponge with lukewarm water if uncomfortable",
-            "Paracetamol 500mg every 6 hours (max 4 doses/day)",
-            "Monitor temperature every 4 hours"
-        ],
-        "warnings": [
-            "Fever >39°C lasting >3 days",
-            "If with rash, difficulty breathing, or seizures",
-            "In infants <3 months with any fever"
-        ]
-    },
-    "sore throat": {
-        "assessment": "Often viral, but could be strep throat",
-        "recommendations": [
-            "Gargle with warm salt water 3-4 times daily",
-            "Drink warm liquids (tea with honey)",
-            "Use throat lozenges",
-            "Stay hydrated",
-            "Rest your voice"
-        ],
-        "warnings": [
-            "Difficulty swallowing or breathing",
-            "White patches on tonsils",
-            "Fever >38.5°C with throat pain"
-        ]
-    }
+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",
 }
 
-def get_local_advice(symptom):
-    """Get structured medical advice from local knowledge base"""
-    symptom_lower = symptom.lower()
-    for key in MEDICAL_KNOWLEDGE:
-        if key in symptom_lower:
-            knowledge = MEDICAL_KNOWLEDGE[key]
-            response = "🔍 [Assessment]\n- " + knowledge["assessment"] + "\n\n"
-            response += "💡 [Self-Care Recommendations]\n" + "\n".join(["• " + item for item in knowledge["recommendations"]]) + "\n\n"
-            response += "⚠️ [When to Seek Medical Care]\n" + "\n".join(["• " + item for item in knowledge["warnings"]]) + "\n\n"
+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