add pronounciation

pron.py

@@ -0,0 +1,659 @@
+"""
+Pronunciation Trainer – FULL WORKING VERSION
+Coqui XTTS + Whisper + MFCC/DTW + Phonemizer
+Correct Feedback for:
+1. No audio
+2. Too short
+3. Too quiet
+4. Correct pronunciation
+5. Incorrect pronunciation
+"""
+
+import io
+import os
+import re
+import uuid
+import tempfile
+import numpy as np
+import librosa
+from difflib import SequenceMatcher
+from flask import Blueprint, request, jsonify, send_from_directory, abort, current_app, send_file
+from werkzeug.utils import secure_filename
+from pydub import AudioSegment
+from TTS.api import TTS
+
+# -------------------------------------------------------------------------
+# OPTIONAL MODULES
+# -------------------------------------------------------------------------
+try:
+    from phonemizer import phonemize
+    PHONEMIZER_AVAILABLE = True
+except:
+    PHONEMIZER_AVAILABLE = False
+
+try:
+    import whisper
+    WHISPER_AVAILABLE = True
+    _whisper_model = None
+    def _get_whisper_model(name="tiny.en"):
+        global _whisper_model
+        if _whisper_model is None:
+            _whisper_model = whisper.load_model(name)
+        return _whisper_model
+except:
+    WHISPER_AVAILABLE = False
+    _whisper_model = None
+
+# -------------------------------------------------------------------------
+# PATH SETUP
+# -------------------------------------------------------------------------
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+STATIC_DIR = os.path.join(BASE_DIR, "static")
+AUDIO_DIR = os.path.join(STATIC_DIR, "audio")
+REFS_DIR = os.path.join(STATIC_DIR, "references")
+
+os.makedirs(AUDIO_DIR, exist_ok=True)
+os.makedirs(REFS_DIR, exist_ok=True)
+
+DEFAULT_REFERENCE = os.path.join(REFS_DIR, "voice1.wav")
+
+pron_bp = Blueprint("pron", __name__)
+
+# -------------------------------------------------------------------------
+# LOAD XTTS MODEL (TEACHER VOICE)
+# -------------------------------------------------------------------------
+print("Loading XTTS...")
+try:
+    tts_model = TTS(model_name="tts_models/multilingual/multi-dataset/xtts_v2", gpu=False)
+    print("XTTS loaded ✔")
+except:
+    print("XTTS load failed.")
+    tts_model = None
+
+# -------------------------------------------------------------------------
+# HELPERS
+# -------------------------------------------------------------------------
+def normalize_text(t: str):
+    if not t:
+        return ""
+    t = t.lower().strip()
+    t = re.sub(r"[^\w\s]", "", t)   # remove punctuation
+    t = re.sub(r"\s+", " ", t).strip()
+    return t
+
+def save_uploaded_file(file, dest):
+    fn = secure_filename(file.filename)
+    new = f"{uuid.uuid4().hex}_{fn}"
+    path = os.path.join(dest, new)
+    file.save(path)
+    return path
+
+def convert_to_wav(path):
+    name, ext = os.path.splitext(path)
+    if ext == ".wav":
+        return path
+    audio = AudioSegment.from_file(path)
+    wav_path = f"{name}.wav"
+    audio.export(wav_path, format="wav")
+    os.remove(path)
+    return wav_path
+
+def read_audio_numpy(file, sr=16000):
+    file.stream.seek(0)
+    raw = file.stream.read()
+    bio = io.BytesIO(raw)
+
+    ext = os.path.splitext(file.filename)[1].replace(".", "")
+    try:
+        audio = AudioSegment.from_file(bio, format=ext)
+    except:
+        bio.seek(0)
+        audio = AudioSegment.from_file(bio)
+
+    audio = audio.set_channels(1).set_frame_rate(sr)
+    samples = np.array(audio.get_array_of_samples(), dtype=np.float32)
+    max_val = float(1 << (audio.sample_width * 8 - 1))
+    return samples / max_val, sr
+
+def detect_silence(y, sr, min_duration=0.30, amp_threshold=0.015):
+    if y is None or len(y) == 0:
+        return True, "no_audio"
+
+    duration = len(y) / sr
+    max_amp = float(np.max(np.abs(y)))
+
+    if duration < min_duration:
+        return True, "too_short"
+
+    if max_amp < amp_threshold:
+        return True, "too_quiet"
+
+    return False, None
+
+def compute_similarity(y_s, sr_s, teacher):
+    out = {"score": 0, "mean_dist": None, "error": None}
+    try:
+        y_t, sr_t = librosa.load(teacher, sr=sr_s)
+
+        if len(y_s) < 1024:
+            out["error"] = "too_short"
+            return out
+
+        y_s_trim, _ = librosa.effects.trim(y_s, top_db=20)
+        y_t_trim, _ = librosa.effects.trim(y_t, top_db=20)
+
+        if len(y_s_trim) == 0:
+            out["error"] = "quiet"
+            return out
+
+        mfcc_s = librosa.feature.mfcc(y=y_s_trim, sr=sr_s, n_mfcc=13)
+        mfcc_t = librosa.feature.mfcc(y=y_t_trim, sr=sr_t, n_mfcc=13)
+
+        def norm(m):
+            return (m - m.mean(axis=1, keepdims=True)) / (m.std(axis=1, keepdims=True) + 1e-6)
+
+        mfcc_s = norm(mfcc_s)
+        mfcc_t = norm(mfcc_t)
+
+        D, wp = librosa.sequence.dtw(mfcc_s, mfcc_t, metric="euclidean")
+        d = [np.linalg.norm(mfcc_s[:, i] - mfcc_t[:, j]) for i, j in wp]
+        mean_dist = np.mean(d)
+        out["mean_dist"] = float(mean_dist)
+        out["score"] = max(0, min(100, 100 - mean_dist * 6))
+
+    except Exception as e:
+        out["error"] = str(e)
+
+    return out
+
+def transcribe_audio(file):
+    if not WHISPER_AVAILABLE:
+        return ""
+    file.stream.seek(0)
+    data = file.read()
+    ext = os.path.splitext(file.filename)[1] or ".wav"
+
+    tmp = None
+    try:
+        with tempfile.NamedTemporaryFile(suffix=ext, delete=False) as t:
+            t.write(data)
+            tmp = t.name
+        model = _get_whisper_model("tiny.en")
+        result = model.transcribe(tmp, language="en")
+        return result.get("text", "").strip().lower()
+    finally:
+        if tmp and os.path.exists(tmp):
+            os.remove(tmp)
+
+def get_phonemes(t):
+    if not t:
+        return ""
+    if PHONEMIZER_AVAILABLE:
+        try:
+            p = phonemize(t, language="en-us", backend="espeak",
+                          strip=True, preserve_punctuation=False)
+            return " ".join(p.split())
+        except:
+            return t
+    return t
+
+def phoneme_sim(a, b):
+    if not a or not b:
+        return 0
+    return SequenceMatcher(None, a, b).ratio()
+
+# -------------------------------------------------------------------------
+# Small voice-cloning / tts wrapper to create teacher audio
+# -------------------------------------------------------------------------
+def clone_voice(reference_path: str, text: str, out_path: str, language: str = "en"):
+    """
+    Create a teacher audio file at out_path speaking `text`.
+    Uses the loaded `tts_model` if available. If a reference voice file is given
+    and the TTS API supports a speaker/reference argument we pass it along.
+    Raises a RuntimeError with a clear message if no TTS is available.
+    """
+    # If TTS model is not loaded, try a minimal fallback or raise
+    if tts_model is None:
+        # Try a simple local fallback (pyttsx3) if available
+        try:
+            import pyttsx3
+            engine = pyttsx3.init()
+            engine.save_to_file(text, out_path)
+            engine.runAndWait()
+            return out_path
+        except Exception as e:
+            raise RuntimeError("No TTS model available and pyttsx3 fallback failed: " + str(e))
+
+    # Use tts_model API. Different coqui-tts versions may accept different args.
+    try:
+        kwargs = {"language": language}
+        if reference_path and os.path.exists(reference_path):
+            # common parameter name in some TTS APIs
+            kwargs["speaker_wav"] = reference_path
+        # prefer named parameters
+        tts_model.tts_to_file(text=text, file_path=out_path, **kwargs)
+        return out_path
+    except TypeError:
+        # fallback for other signatures
+        try:
+            # try positional fallback: (text, out_path, reference_path, language)
+            if reference_path and os.path.exists(reference_path):
+                tts_model.tts_to_file(text, out_path, reference_path, language)
+            else:
+                tts_model.tts_to_file(text, out_path, language)
+            return out_path
+        except Exception as e:
+            raise RuntimeError("TTS failed: " + str(e))
+    except Exception as e:
+        raise RuntimeError("TTS failed: " + str(e))
+
+def clone_voice_to_bytes(reference_path: str, text: str, language: str = "en"):
+    """
+    Generate teacher audio into bytes without leaving persistent files.
+    Uses a temporary file for the TTS API, reads bytes, then deletes the temp file.
+    """
+    # create a named temporary file on disk (some TTS backends require a real path)
+    tmp = None
+    try:
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as t:
+            tmp = t.name
+        clone_voice(reference_path, text, tmp, language=language)
+        with open(tmp, "rb") as f:
+            data = f.read()
+        return data
+    finally:
+        if tmp and os.path.exists(tmp):
+            try:
+                os.remove(tmp)
+            except:
+                pass
+
+# -------------------------------------------------------------------------
+# REALISTIC FEEDBACK (ALL CASES)
+# -------------------------------------------------------------------------
+def generate_feedback(word, teacher_ph, student_ph, clean_asr, acoustic_score, sim_info):
+
+    if not student_ph:
+        return [
+            "No clear pronunciation detected.",
+            "Please say the word slowly and clearly."
+        ]
+
+    fb = []
+
+    vowels_t = [p for p in teacher_ph.split() if p[0] in "aeiou"]
+    vowels_s = [p for p in student_ph.split() if p[0] in "aeiou"]
+
+    if vowels_t != vowels_s:
+        fb.append("Your vowel sound is slightly different. Try opening your mouth a bit more.")
+    else:
+        fb.append("Your vowel sound is correct.")
+
+    cons_t = [p for p in teacher_ph.split() if p[0] not in "aeiou"]
+    cons_s = [p for p in student_ph.split() if p[0] not in "aeiou"]
+
+    if cons_t != cons_s:
+        fb.append("Your consonant clarity needs improvement. Focus on the starting and ending sounds.")
+    else:
+        fb.append("Your consonants are clear.")
+
+    if len(student_ph.split()) < len(teacher_ph.split()):
+        fb.append("Some sounds are missing. Try pronouncing each part of the word clearly.")
+
+    # ---------- NEW SMART ASR COMPARISON ----------
+    if clean_asr == word:
+        fb.append("Good pronunciation. The system understood the word correctly.")
+    elif word in clean_asr:
+        fb.append("Your pronunciation was clear but had slight extra noise.")
+    elif phoneme_sim(teacher_ph, student_ph) > 0.75:
+        fb.append("Almost correct pronunciation. Only a small clarity adjustment is needed.")
+    else:
+        fb.append(f"The system heard '{clean_asr}', which is different from '{word}'. Try pronouncing each sound clearly.")
+
+    if sim_info.get("mean_dist", 0) > 18:
+        fb.append("Your timing between sounds was uneven. Try speaking smoothly.")
+    else:
+        fb.append("Your speed and timing are good.")
+
+    if acoustic_score < 60:
+        fb.append("Your audio had noise or was unclear. Speak closer to the microphone.")
+    else:
+        fb.append("Your recording is clear.")
+
+    fb.append("Good effort. Listen to the teacher audio again and repeat.")
+
+    return fb
+
+
+def check_pronunciation_attributes(
+        word: str,
+        teacher_ph: str,
+        student_ph: str,
+        clean_asr: str,
+        acoustic_score: float,
+        sim_info: dict,
+        y_s: np.ndarray,
+        sr_s: int
+    ):
+    """
+    Return a list of structured feedback entries (dicts with 'title' and 'message').
+    Provides:
+      - Missing / extra / substituted phoneme information (diff on phoneme tokens)
+      - Vowel / consonant hints
+      - Volume / clarity / timing hints
+      - A final 'Tip' with how to pronounce (shows teacher phonemes)
+    """
+    feedback = []
+    tokens_t = [p for p in teacher_ph.split() if p.strip()]
+    tokens_s = [p for p in student_ph.split() if p.strip()]
+
+    # Helper to append a feedback dict without duplicate titles
+    def push(title: str, message: str):
+        title = title.strip()
+        message = message.strip()
+        # avoid duplicates by title
+        for f in feedback:
+            if f.get("title", "") == title:
+                # append to existing message for the same title
+                if message and message not in f.get("message", ""):
+                    f["message"] = f["message"] + " " + message
+                return
+        feedback.append({"title": title, "message": message})
+
+    # 1) Phoneme-level diff using SequenceMatcher
+    sm = SequenceMatcher(None, tokens_t, tokens_s)
+    missing = []
+    extra = []
+    substitutions = []
+
+    for tag, i1, i2, j1, j2 in sm.get_opcodes():
+        if tag == "delete":
+            missing.extend(tokens_t[i1:i2])
+        elif tag == "insert":
+            extra.extend(tokens_s[j1:j2])
+        elif tag == "replace":
+            substitutions.append({
+                "expected": tokens_t[i1:i2],
+                "heard": tokens_s[j1:j2]
+            })
+
+    if missing:
+        push(
+            "Missing Sounds",
+            f"You missed these sounds: {' '.join(missing)}. Try pronouncing each part; for example pronounce the teacher phonemes: {teacher_ph}"
+        )
+
+    if extra:
+        push(
+            "Extra Sounds",
+            f"You added extra sounds: {' '.join(extra)}. Avoid added fillers or extra syllables."
+        )
+
+    for sub in substitutions:
+        expected = " ".join(sub["expected"])
+        heard = " ".join(sub["heard"])
+        push(
+            "Sound Substitution",
+            f"Expected: {expected} but heard: {heard}. Try repeating the expected sound(s): {expected}"
+        )
+
+    # 2) Vowel vs consonant checks (more friendly phrasing)
+    vowels_t = [p for p in tokens_t if p and p[0] in "aeiou"]
+    vowels_s = [p for p in tokens_s if p and p[0] in "aeiou"]
+    cons_t = [p for p in tokens_t if p and p[0] not in "aeiou"]
+    cons_s = [p for p in tokens_s if p and p[0] not in "aeiou"]
+
+    if vowels_t != vowels_s:
+        push(
+            "Vowel",
+            f"Your vowel sounds differ from the teacher's. Teacher vowels: {' '.join(vowels_t)}. Try opening your mouth more and holding the vowel."
+        )
+    else:
+        push("Vowel", "Your vowel sounds match the teacher's pronunciation.")
+
+    if cons_t != cons_s:
+        push(
+            "Consonant",
+            f"Some consonant sounds differ. Teacher consonants: {' '.join(cons_t)}. Focus on the initial and final consonants."
+        )
+    else:
+        push("Consonant", "Your consonants match the teacher's pronunciation.")
+
+    # 3) Syllable / length checks
+    if len(tokens_s) < len(tokens_t):
+        push("Syllables", "Your pronunciation is shorter than expected. Try stretching middle sounds or pronouncing silent segments clearly.")
+    elif len(tokens_s) > len(tokens_t) + 2:
+        push("Syllables", "You pronounced extra syllables. Try a tighter pronunciation.")
+
+    # 4) Stress (approximate)
+    if len(tokens_t) > 2 and len(tokens_s) > 2:
+        if tokens_s[0] != tokens_t[0]:
+            push("Stress", "Try placing more emphasis on the first syllable or sound.")
+        else:
+            push("Stress", "Stress placement looks correct.")
+
+    # 5) Timing and pacing
+    if sim_info.get("mean_dist", 0) > 18:
+        push("Timing & Pace", "Timing between sounds is uneven. Try speaking more smoothly and evenly.")
+    else:
+        push("Timing & Pace", "Timing and pacing are acceptable.")
+
+    # 6) Clarity / noise
+    if sim_info.get("error") in ["quiet", "noise"]:
+        push("Clarity", "Recording appears unclear or too quiet. Record in a quieter place and speak closer to the mic.")
+    else:
+        push("Clarity", "Audio clarity is acceptable.")
+
+    # 7) Volume
+    try:
+        max_amp = float(np.max(np.abs(y_s)))
+    except:
+        max_amp = 0.0
+
+    if max_amp < 0.05:
+        push("Volume", "Your voice was quite soft. Try speaking a bit louder.")
+    elif max_amp > 0.85:
+        push("Volume", "Your voice was loud or clipped. Reduce volume slightly.")
+    else:
+        push("Volume", "Speaking volume is good.")
+
+    # 8) ASR / word match
+    if clean_asr == word:
+        push("Word Match", "Whisper understood your word correctly.")
+    elif word in clean_asr:
+        push("Word Match", "Whisper detected the word but with extra noise/words.")
+    else:
+        push("Word Match", f"Whisper heard: '{clean_asr}'. Try saying the word more clearly and slowly.")
+
+    # 9) Overall phoneme similarity summary
+    sim_val = phoneme_sim(teacher_ph, student_ph)
+    pct = round(sim_val * 100)
+    if pct >= 85:
+        push("Overall", f"Overall phoneme match: {pct}%. Very good.")
+    elif pct >= 60:
+        push("Overall", f"Overall phoneme match: {pct}%. Close — a few adjustments needed.")
+    else:
+        push("Overall", f"Overall phoneme match: {pct}%. Consider repeating after the teacher audio and focusing on the differences listed above.")
+
+    # 10) Explicit how-to example (say-it-like)
+    push("How to Say It", f"Listen to the teacher and try: {teacher_ph} — say each sound slowly and clearly.")
+
+    return feedback
+
+
+def compare_words_human(word, heard):
+    if not heard or heard.strip() == "":
+        return "No speech detected. Please try saying the word clearly."
+
+    word_clean = word.lower().strip()
+    heard_clean = heard.lower().strip()
+
+    if heard_clean == word_clean:
+        return f"Good job! You said the word '{word}' correctly."
+
+    sim = SequenceMatcher(None, word_clean, heard_clean).ratio()
+
+    if sim >= 0.85:
+        return (
+            f"You almost said the correct word '{word}'. "
+            f"The system heard '{heard_clean}'. "
+            "Improve the ending sound."
+        )
+
+    if sim >= 0.60:
+        return (
+            f"You said something close to '{word}', "
+            f"but the system heard '{heard_clean}'. "
+            "Try to pronounce each sound clearly."
+        )
+
+    return (
+        f"The system heard '{heard_clean}', which is different from '{word}'. "
+        "Try again more slowly and clearly."
+    )
+
+
+
+# -------------------------------------------------------------------------
+# ROUTES
+# -------------------------------------------------------------------------
+@pron_bp.route("/generate_teacher_audio", methods=["POST"])
+def generate_teacher_audio():
+    # Support both form-data (request.form) and JSON (application/json)
+    word = ""
+    # If JSON content-type, parse JSON payload
+    if request.content_type and request.content_type.startswith("application/json"):
+        data = request.get_json(silent=True) or {}
+        word = (data.get("word") or "").strip()
+    else:
+        # fallback to form (multipart/form-data)
+        word = (request.form.get("word") or "").strip()
+
+    if not word:
+        return jsonify({"error": "word required"}), 400
+
+    ref = DEFAULT_REFERENCE
+    if "reference" in request.files:
+        ref = save_uploaded_file(request.files["reference"], REFS_DIR)
+
+    out = os.path.join(AUDIO_DIR, f"teacher-{word}-{uuid.uuid4().hex}.wav")
+    clone_voice(ref, word, out)
+    rel = os.path.relpath(out, STATIC_DIR).replace("\\", "/")
+    return jsonify({"audio_url": rel})
+
+@pron_bp.route("/generate_teacher_audio_stream", methods=["POST"])
+def generate_teacher_audio_stream():
+    """
+    Generate teacher audio and return the WAV bytes directly (no persistent file in AUDIO_DIR).
+    Accepts:
+      - JSON payload: {"word": "..."}
+      - multipart/form-data: form field 'word' and optional file field 'reference'
+    Returns: audio/wav stream
+    """
+    word = ""
+    if request.content_type and request.content_type.startswith("application/json"):
+        data = request.get_json(silent=True) or {}
+        word = (data.get("word") or "").strip()
+    else:
+        word = (request.form.get("word") or "").strip()
+
+    if not word:
+        return jsonify({"error": "word required"}), 400
+
+    # Prepare reference: if user uploaded a reference file, write it to a temporary file
+    temp_ref = None
+    try:
+        if "reference" in request.files:
+            ref_file = request.files["reference"]
+            ext = os.path.splitext(ref_file.filename)[1] or ".wav"
+            with tempfile.NamedTemporaryFile(suffix=ext, delete=False) as t:
+                t.write(ref_file.read())
+                temp_ref = t.name
+            ref_path = temp_ref
+        else:
+            ref_path = DEFAULT_REFERENCE
+
+        audio_bytes = clone_voice_to_bytes(ref_path, word, language="en")
+        bio = io.BytesIO(audio_bytes)
+        bio.seek(0)
+        # stream the WAV directly
+        return send_file(bio, mimetype="audio/wav", as_attachment=False)
+    finally:
+        if temp_ref and os.path.exists(temp_ref):
+            try:
+                os.remove(temp_ref)
+            except:
+                pass
+
+@pron_bp.route("/audio/<path:filename>")
+def serve_audio(filename):
+    p1 = os.path.join(AUDIO_DIR, filename)
+    if os.path.exists(p1):
+        return send_from_directory(AUDIO_DIR, filename)
+    p2 = os.path.join(REFS_DIR, filename)
+    if os.path.exists(p2):
+        return send_from_directory(REFS_DIR, filename)
+    abort(404)
+
+@pron_bp.route("/check_pronunciation", methods=["POST"])
+def check_pronunciation():
+
+    if "audio" not in request.files:
+        return jsonify({"error": "audio required"}), 400
+
+    word = request.form.get("word", "").lower().strip()
+    if not word:
+        return jsonify({"error": "word required"}), 400
+
+    file = request.files["audio"]
+
+    y_s, sr_s = read_audio_numpy(file)
+
+    silent, reason = detect_silence(y_s, sr_s)
+    if silent:
+        if reason == "no_audio":
+            return jsonify({"suggestion": ["No audio detected. Please try again."], "silent": True})
+        if reason == "too_short":
+            return jsonify({"suggestion": ["Your recording was too short. Try again."], "silent": True})
+        if reason == "too_quiet":
+            return jsonify({"suggestion": ["Your voice was too quiet. Please speak louder."], "silent": True})
+
+    teacher = None
+    for f in os.listdir(AUDIO_DIR):
+        if f.startswith(f"teacher-{word}") and f.endswith(".wav"):
+            teacher = os.path.join(AUDIO_DIR, f)
+            break
+    teacher = teacher or DEFAULT_REFERENCE
+
+    sim_info = compute_similarity(y_s, sr_s, teacher)
+    acoustic_score = sim_info.get("score", 0)
+
+    asr_raw = transcribe_audio(file)
+    clean_asr = normalize_text(asr_raw)
+
+    teacher_ph = get_phonemes(word)
+    student_ph = get_phonemes(clean_asr)
+
+    suggestion = check_pronunciation_attributes(
+        word=word,
+        teacher_ph=teacher_ph,
+        student_ph=student_ph,
+        clean_asr=clean_asr,
+        acoustic_score=acoustic_score,
+        sim_info=sim_info,
+        y_s=y_s,
+        sr_s=sr_s
+    )
+
+    word_feedback = compare_words_human(word, clean_asr)
+    # Keep compatibility: insert the short human-friendly word result at index 0
+    suggestion.insert(0, word_feedback)
+
+    return jsonify({
+        "silent": False,
+        "word": word,
+        "heard_word": clean_asr,
+        "suggestion": suggestion,
+        "acoustic_score": acoustic_score,
+        "phoneme_similarity": phoneme_sim(teacher_ph, student_ph)
+    })

requirements.txt

@@ -46,3 +46,6 @@ Pillow==10.4.0
 pysqlite3-binary==0.5.3.post1
 tiktoken==0.11.0
 torchcodec
+phonemizer
+openai-whisper
+

static/references/voice1.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:09d064bc2bd4880ceb1c6c4a69cb941a1b5e2ea05b151b721aab4cc17c34f56b
+size 5364878

verification.py

@@ -494,7 +494,8 @@ from writting import writting_bp   # match the exact file name on Linux
 from vocabularyBuilder import vocab_bp
 from findingword import finding_bp
 from listen import listen_bp
-from ragg.app import rag_bp  
+from ragg.app import rag_bp 
+from pron import pron_bp
 from ragg.ingest_trigger import ingest_trigger_bp
 app.register_blueprint(movie_bp, url_prefix="/media")
 app.register_blueprint(questions_bp, url_prefix="/media")
@@ -505,6 +506,7 @@ app.register_blueprint(finding_bp, url_prefix="/media")
 app.register_blueprint(listen_bp, url_prefix="/media")
 app.register_blueprint(rag_bp, url_prefix="/rag")
 app.register_blueprint(ingest_trigger_bp, url_prefix="/rag")
+app.register_blueprint(pron_bp, url_prefix="")
 # app.register_blueprint(questions_bp, url_prefix="/media")  # <-- add this
 # ------------------------------------------------------------------------------
 # Local run (Gunicorn will import `verification:app` on Spaces)