Update app.py

app.py

@@ -1,10 +1,12 @@
 # -*- coding: utf-8 -*-
-# صفحتان ثابتتان + Submit لكل سؤال يعمل فعليًا + منع تغيّر أبعاد صفحة الإدخال
+# Question Generator — Final Publishable Build (Lite/Full)
+# صفحات ثابتة + Submit لكل سؤال فعليًا + منع تغيّر أبعاد صفحة الإدخال
+# طور "فراغ" + طور "فهم مباشر" (mT5) مع fallbacks، صعوبة، BM25، فلترة قوية للمشتّتات، وتنويع على مستوى الفقرات.
 
 import os, json, uuid, random, unicodedata
 from dataclasses import dataclass
 from pathlib import Path
-from typing import List, Tuple
+from typing import List, Tuple, Optional
 
 from PIL import Image
 from pypdf import PdfReader
@@ -13,21 +15,34 @@ import regex as re2
 import yake
 import gradio as gr
 
-# ------------------ إعدادات عامة ------------------
+# ------------------ إعدادات عامّة ------------------
 random.seed(42)
 DEFAULT_NUM_QUESTIONS = 6
 DEFAULT_TROCR_MODEL = "microsoft/trocr-base-printed"
 DEFAULT_TROCR_ZOOM   = 2.6
+QUESTION_MODES = ["فراغ", "فهم مباشر"]
+DIFFICULTY_MODES = ["سهل", "متوسط", "صعب"]
+
+# BM25 (اختياري)
+try:
+    from rank_bm25 import BM25Okapi
+    _HAS_BM25 = True
+except Exception:
+    _HAS_BM25 = False
 
 # ------------------ OCR (تحميل كسول) ------------------
 _OCR = {}
 def get_ocr(model_id: str):
-    from transformers import pipeline
-    import torch
-    dev = 0 if torch.cuda.is_available() else -1
-    if model_id not in _OCR:
-        _OCR[model_id] = pipeline("image-to-text", model=model_id, device=dev)
-    return _OCR[model_id]
+    try:
+        from transformers import pipeline
+        import torch
+        dev = 0 if torch.cuda.is_available() else -1
+        if model_id not in _OCR:
+            _OCR[model_id] = pipeline("image-to-text", model=model_id, device=dev)
+        return _OCR[model_id]
+    except Exception:
+        # بديل آمن: دالة تُعيد نصًا فارغًا
+        return lambda im: [{"generated_text": ""}]
 
 # ------------------ PDF/TXT → نص ------------------
 def extract_text_with_pypdf(path: str) -> str:
@@ -105,7 +120,7 @@ def postprocess(raw:str)->str:
     t = re2.sub(r"\[\d+\]", " ", t)
     return norm_ar(t)
 
-# ------------------ توليد أسئلة (تحسينات كبيرة داخليًا فقط) ------------------
+# ------------------ بنية السؤال ------------------
 SENT_SPLIT = re2.compile(r"(?<=[\.!؟\?])\s+")
 AR_STOP = set("""في على من إلى عن مع لدى ذلك هذه هذا الذين التي الذي أو أم إن أن كان تكون كانوا كانت كنت ثم قد لقد ربما بل لكن إلا سوى حتى حيث كما لما ما لماذا متى أين كيف أي هناك هنا هؤلاء أولئك نحن هو هي هم هن أنت أنتم أنتن""".split())
 
@@ -120,8 +135,8 @@ def split_sents(t:str)->List[str]:
     s=[x.strip() for x in SENT_SPLIT.split(t) if x.strip()]
     return [x for x in s if len(x)>=25]
 
-# ====== (1) عبارات مفتاحية أذكى: n=3 ثم 2 ثم 1، مع فلترة ======
-def yake_keywords(t: str, k: int = 160) -> List[str]:
+# ====== (1) عبارات مفتاحية (YAKE) ======
+def yake_keywords(t: str, k: int = 260) -> List[str]:
     phrases = []
     seen = set()
     for n in [3, 2, 1]:
@@ -144,7 +159,56 @@ def yake_keywords(t: str, k: int = 160) -> List[str]:
 def good_kw(kw:str)->bool:
     return kw and len(kw)>=2 and kw not in AR_STOP and not re2.match(r"^[\p{P}\p{S}\d_]+$", kw)
 
-# ====== (2) جيران دلاليًا + (3) FILL-MASK كبديل ======
+# ====== POS/NER اختياري ======
+_HAS_CAMEL = False
+try:
+    from camel_tools.morphology.analyzer import Analyzer
+    from camel_tools.ner import NERecognizer
+    _HAS_CAMEL = True
+    _AN = Analyzer.builtin_analyzer()
+    _NER = NERecognizer.pretrained()
+except Exception:
+    _HAS_CAMEL = False
+
+NER_TAGS = {"PER","LOC","ORG","MISC"}
+
+def ar_pos(word: str) -> str:
+    if not _HAS_CAMEL:
+        if re2.match(r"^(في|على|الى|إلى|من|عن|حتى|ثم|بل|لكن|أو|و)$", word): return "PART"
+        if re2.match(r"^[\p{N}]+$", word): return "NUM"
+        if re2.search(r"(ة|ات|ون|ين|ان)$", word): return "NOUN"
+        return "X"
+    try:
+        ana = _AN.analyze(word)
+        if not ana: return "X"
+        from collections import Counter
+        pos_candidates = [a.get('pos','X') for a in ana]
+        return Counter(pos_candidates).most_common(1)[0][0] if pos_candidates else "X"
+    except Exception:
+        return "X"
+
+def is_named_entity(token: str) -> bool:
+    if not _HAS_CAMEL:
+        return False
+    try:
+        tag = _NER.predict_sentence([token])[0]
+        return tag in NER_TAGS
+    except Exception:
+        return False
+
+def is_clean_sentence(s: str) -> bool:
+    if not (60 <= len(s) <= 240): return False
+    if re2.search(r"https?://|www\.", s): return False
+    if re2.search(r"\d{2,}", s): return False
+    return True
+
+def safe_keyword(k: str) -> bool:
+    if not good_kw(k): return False
+    if is_named_entity(k): return False
+    if ar_pos(k) in {"PRON","PART"}: return False
+    return True
+
+# ====== Embeddings/Masking/Cross-Encoder (اختياري) ======
 _EMB = None
 def get_embedder():
     global _EMB
@@ -153,10 +217,10 @@ def get_embedder():
             from sentence_transformers import SentenceTransformer
             _EMB = SentenceTransformer("sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2")
         except Exception:
-            _EMB = False  # تشير لتعطّل التحميل
+            _EMB = False
     return _EMB
 
-def nearest_terms(target: str, pool: List[str], k: int = 12) -> List[Tuple[str, float]]:
+def nearest_terms(target: str, pool: List[str], k: int = 24) -> List[Tuple[str, float]]:
     emb = get_embedder()
     if not emb:
         return []
@@ -166,7 +230,7 @@ def nearest_terms(target: str, pool: List[str], k: int = 12) -> List[Tuple[str,
     vecs = emb.encode([target] + cand, normalize_embeddings=True)
     t, C = vecs[0], vecs[1:]
     import numpy as np
-    sims = (C @ t)  # cosine لأن المتجهات مُطبّعة
+    sims = (C @ t)
     idx = np.argsort(-sims)[:k]
     return [(cand[i], float(sims[i])) for i in idx]
 
@@ -181,19 +245,19 @@ def get_masker():
             _MLM = False
     return _MLM
 
-def mlm_distractors(sentence_with_blank: str, correct: str, k: int = 8) -> List[str]:
+def mlm_distractors(sentence_with_blank: str, correct: str, k: int = 18) -> List[str]:
     masker = get_masker()
     if not masker:
         return []
     masked = sentence_with_blank.replace("_____", masker.tokenizer.mask_token)
     try:
-        outs = masker(masked, top_k=max(15, k+5))
+        outs = masker(masked, top_k=max(25, k+7))
         cands = []
         for o in outs:
             tok = o["token_str"].strip()
             if tok and tok != correct and len(tok) >= 2 and not re2.match(r"^[\p{P}\p{S}\d_]+$", tok):
                 cands.append(tok)
-        seen = set(); uniq = []
+        uniq, seen = [], set()
         for w in cands:
             if w not in seen:
                 uniq.append(w); seen.add(w)
@@ -201,127 +265,487 @@ def mlm_distractors(sentence_with_blank: str, correct: str, k: int = 8) -> List[
     except Exception:
         return []
 
-def legacy_distractors(correct:str, pool:List[str], k:int=3)->List[str]:
-    # النسخة القديمة كنسخة احتياط
-    L=len(correct.strip()); cand=[]
-    for w in pool:
-        w=w.strip()
-        if not w or w==correct or w in AR_STOP: continue
-        if re2.match(r"^[\p{P}\p{S}\d_]+$", w): continue
-        if abs(len(w)-L)<=3: cand.append(w)
-    random.shuffle(cand)
-    out=cand[:k]
-    while len(out)<k: out.append("—")
-    return out
-
-def smart_distractors(correct: str, phrase_pool: List[str], sentence: str, k: int = 3) -> List[str]:
-    # 1) جيران دلاليًا
-    neigh = nearest_terms(correct, phrase_pool, k=12)
-    neigh = [w for w,sim in neigh if w != correct][:k+4]
-
-    # 2) FILL-MASK على الجملة (بديل)
-    if len(neigh) < k:
-        mlm = mlm_distractors(sentence.replace(correct, "_____"), correct, k=10)
-        for w in mlm:
-            if w not in neigh and w != correct:
-                neigh.append(w)
-            if len(neigh) >= k+4:
-                break
-
-    # 3) فلترة خفيفة
-    out = []
-    L = len(correct)
-    for w in neigh:
-        if w in AR_STOP: 
+_CE = None
+def get_cross_encoder():
+    global _CE
+    if _CE is None:
+        try:
+            from sentence_transformers import CrossEncoder
+            _CE = CrossEncoder("cross-encoder/ms-marco-MiniLM-L-6-v2")
+        except Exception:
+            _CE = False
+    return _CE
+
+def rank_by_ce(sentence_with_blank: str, candidates: List[str]) -> List[str]:
+    ce = get_cross_encoder()
+    if not ce or not candidates:
+        return candidates
+    pairs = [(sentence_with_blank.replace("_____", c), c) for c in candidates]
+    try:
+        scores = ce.predict([p[0] for p in pairs])
+        ranked = [c for _, c in sorted(zip(scores, [p[1] for p in pairs]), key=lambda x:-x[0])]
+        return ranked
+    except Exception:
+        return candidates
+
+# --------- أدوات مساعدة للمشتّتات ---------
+def word_tokens(s: str) -> List[str]:
+    s = norm_ar(s)
+    return re2.findall(r"\p{L}+", s)
+
+def token_set(s: str) -> set:
+    return set([t for t in word_tokens(s) if t not in AR_STOP])
+
+def jaccard(a: str, b: str) -> float:
+    A, B = token_set(a), token_set(b)
+    if not A or not B: return 0.0
+    return len(A & B) / max(1, len(A | B))
+
+def is_sub_or_super(a: str, b: str) -> bool:
+    A, B = norm_ar(a), norm_ar(b)
+    return (A in B) or (B in A)
+
+def appears_as_long_fragment_in_sentence(w: str, sentence: str) -> bool:
+    toks = word_tokens(w)
+    if len(toks) < 3: 
+        return False
+    return re2.search(rf"(?<!\p{{L}}){re2.escape(norm_ar(w))}(?!\p{{L}})", norm_ar(sentence)) is not None
+
+def choice_length_ok(w: str) -> bool:
+    n = len(word_tokens(w))
+    return 1 <= n <= 6
+
+def paragraph_index_map(text: str, sentences: List[str]) -> dict:
+    paras = [norm_ar(p) for p in re2.split(r"\n{2,}", text) if p.strip()]
+    mapping = {}
+    for i, s in enumerate(sentences):
+        ns = norm_ar(s)
+        pid = None
+        for j, p in enumerate(paras):
+            if ns and ns in p:
+                pid = j; break
+        mapping[s] = pid if pid is not None else -1
+    return mapping
+
+def looks_like_title_fragment(s: str) -> bool:
+    return ":" in s and s.index(":") < max(10, len(s)//6)
+
+def is_nouny_phrase(w: str) -> bool:
+    toks = word_tokens(w)
+    if not (1 <= len(toks) <= 4): return False
+    if re2.search(r"(يفعل|تفعل|يشهد|تقوم|يمكن|قد|سوف)$", w): return False
+    return True
+
+def best_keyword_in_sentence(sentence: str, global_text: str) -> Optional[str]:
+    if looks_like_title_fragment(sentence):
+        parts = sentence.split(":", 1)
+        sentence = parts[1] if len(parts) > 1 else sentence
+    try:
+        ex = yake.KeywordExtractor(lan='ar', n=3, top=24)
+        pairs = ex.extract_keywords(sentence)
+    except Exception:
+        pairs = []
+    cands = []
+    for w, _ in pairs:
+        w = re2.sub(r"\s+", " ", w.strip())
+        if not w or not good_kw(w) or not safe_keyword(w): 
             continue
-        if abs(len(w) - L) > max(6, L//2):
+        if not is_nouny_phrase(w): 
             continue
-        if norm_ar(w) == norm_ar(correct):
+        if not re2.search(rf"(?<!\p{{L}}){re2.escape(w)}(?!\p{{L}})", sentence):
             continue
-        out.append(w)
+        freq_weight = global_text.count(w)
+        cands.append((w, len(w) + 0.7*freq_weight))
+    if not cands:
+        toks = [t for t in re2.findall(r"\p{L}+", sentence) if good_kw(t) and safe_keyword(t)]
+        toks = [t for t in toks if is_nouny_phrase(t)]
+        toks.sort(key=len, reverse=True)
+        return toks[0] if toks else None
+    cands.sort(key=lambda x: -x[1])
+    return cands[0][0]
+
+def similarity_caps(difficulty: str):
+    if difficulty == "سهل":
+        return 0.88
+    if difficulty == "صعب":
+        return 0.95
+    return 0.92
+
+def tokenize_ar(s: str) -> List[str]:
+    s = norm_ar(s)
+    toks = re2.findall(r"\p{L}+", s)
+    return [t for t in toks if len(t) >= 2 and t not in AR_STOP]
+
+def bm25_build(sentences: List[str]):
+    if not _HAS_BM25 or not sentences:
+        return None, []
+    corpus_tokens = [tokenize_ar(s) for s in sentences]
+    bm = BM25Okapi(corpus_tokens)
+    return bm, corpus_tokens
+
+def bm25_candidates(correct: str, sentences: List[str], bm, corpus_tokens, top: int = 20) -> List[str]:
+    if not bm: return []
+    q = tokenize_ar(correct)
+    scores = bm.get_scores(q)
+    idxs = sorted(range(len(scores)), key=lambda i: -scores[i])[:min(top, len(scores))]
+    pool = set()
+    for i in idxs:
+        for tok in corpus_tokens[i]:
+            if tok != correct and good_kw(tok):
+                pool.add(tok)
+    return list(pool)
+
+def typo_like_variants(answer: str, k: int = 4) -> List[str]:
+    """مشتّتات شكلية: تعريف/تنكير، ي/ى، ة/ه، حذف حرف."""
+    a = norm_ar(answer)
+    vars = set()
+    if a.startswith("ال"):
+        vars.add(a[2:])
+    else:
+        vars.add("ال" + a)
+    vars.add(a.replace("ي", "ى"))
+    vars.add(a.replace("ى", "ي"))
+    vars.add(a.replace("ة", "ه"))
+    vars.add(a.replace("ه", "ة"))
+    if len(a) > 5:
+        mid = len(a)//2
+        vars.add(a[:mid] + a[mid+1:])
+    out = [v for v in vars if v and norm_ar(v) != norm_ar(a)]
+    return out[:k]
+
+# ====== مشتّتات ذكية ======
+def pos_compatible(a: str, b: str) -> bool:
+    pa, pb = ar_pos(a), ar_pos(b)
+    if "X" in (pa, pb): 
+        return True
+    return pa == pb
+
+def length_close(a: str, b: str) -> bool:
+    return abs(len(a) - len(b)) <= max(6, len(b)//2)
+
+def smart_distractors(correct: str, phrase_pool: List[str], sentence: str, k: int = 3,
+                      all_sentences: Optional[List[str]] = None, difficulty: str = "متوسط") -> List[str]:
+    base: List[str] = []
+
+    # (0) مشتّتات شكلية أولاً
+    base.extend(typo_like_variants(correct, k=4))
+
+    # (أ) جيران دلاليين
+    base.extend([w for w,_ in nearest_terms(correct, phrase_pool, k=24)])
+
+    # (ب) FILL-MASK
+    for w in mlm_distractors(sentence.replace(correct, "_____"), correct, k=18):
+        if w not in base:
+            base.append(w)
+
+    # (ج) BM25
+    if all_sentences:
+        bm, corp = bm25_build(all_sentences)
+        for w in bm25_candidates(correct, all_sentences, bm, corp, top=18):
+            if w not in base:
+                base.append(w)
+
+    # فلترة صارمة
+    clean: List[str] = []
+    for w in base:
+        w = (w or "").strip()
+        if not w or w == correct:
+            continue
+        if not choice_length_ok(w):
+            continue
+        if appears_as_long_fragment_in_sentence(w, sentence):
+            continue
+        if is_named_entity(w):
+            continue
+        if not pos_compatible(w, correct):
+            continue
+        if not length_close(w, correct):
+            continue
+        if is_sub_or_super(w, correct):
+            continue
+        if jaccard(w, correct) >= 0.5:
+            continue
+        clean.append(w)
+
+    # ترتيب (اختياري) + فلتر قرب دلالي
+    clean = rank_by_ce(sentence.replace(correct, "_____"), clean)[:max(k*4, k)]
+    cap = similarity_caps(difficulty)
+    try:
+        emb = get_embedder()
+        if emb and clean:
+            vecs = emb.encode([correct] + clean, normalize_embeddings=True)
+            c, others = vecs[0], vecs[1:]
+            import numpy as np
+            sims = others @ c
+            filtered = [w for w, s in zip(clean, sims) if s < cap]
+            if len(filtered) >= k:
+                clean = filtered
+    except Exception:
+        pass
+
+    # تجميع أخير
+    out, seen = [], set()
+    for w in clean:
+        if w in seen: 
+            continue
+        seen.add(w); out.append(w)
         if len(out) >= k:
             break
 
-    # 4) رجوع للخطة القديمة إذا ما كفى
+    # تعويض إذا لزم
     if len(out) < k:
-        extra = legacy_distractors(correct, phrase_pool, k=k-len(out))
-        out.extend(extra)
+        extras = [w for w in phrase_pool 
+                  if w not in out and w != correct and choice_length_ok(w) 
+                  and not appears_as_long_fragment_in_sentence(w, sentence)
+                  and not is_sub_or_super(w, correct)
+                  and jaccard(w, correct) < 0.5]
+        out.extend(extras[:(k-len(out))])
+    if len(out) < k:
+        out.extend([w for w in ["…"]*(k-len(out))])  # لن تُقبل لاحقًا إن لم نكمل 4 خيارات
+    return out[:k]
+
+# ====== mT5 (اختياري) ======
+_MT5 = {"tok": None, "model": None, "ok": False}
+def get_mt5():
+    if _MT5["tok"] is not None or _MT5["model"] is not None or _MT5["ok"]:
+        return _MT5["tok"], _MT5["model"], _MT5["ok"]
+    try:
+        from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+        _MT5["tok"] = AutoTokenizer.from_pretrained("google/mt5-small")
+        _MT5["model"] = AutoModelForSeq2SeqLM.from_pretrained("google/mt5-small")
+        _MT5["ok"] = True
+    except Exception:
+        _MT5["tok"] = None; _MT5["model"] = None; _MT5["ok"] = False
+    return _MT5["tok"], _MT5["model"], _MT5["ok"]
 
-    while len(out) < k:
-        out.append("—")
-    return out
+def parse_json_block(s: str) -> Optional[dict]:
+    try:
+        return json.loads(s)
+    except Exception:
+        pass
+    m = re2.search(r"\{.*\}", s, flags=re2.DOTALL)
+    if m:
+        try:
+            return json.loads(m.group(0))
+        except Exception:
+            return None
+    return None
+
+def comp_prompt(sentence: str) -> str:
+    return (
+        "أنت منشئ أسئلة متعددة الخيارات باللغة العربية.\n"
+        "من الجملة التالية، أنشئ سؤال فهم مباشر واحدًا مع أربع خيارات وإشارة للجواب الصحيح.\n"
+        "أعد فقط JSON بهذا الشكل:\n"
+        "{\n"
+        "\"question\": \"...\",\n"
+        "\"choices\": [\"...\",\"...\",\"...\",\"...\"],\n"
+        "\"answer_index\": 0\n"
+        "}\n\n"
+        f"الجملة: {sentence}"
+    )
+
+def gen_one_comp_q(sentence: str, tok, model, max_new_tokens=128) -> Optional[MCQ]:
+    try:
+        import torch
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        model = model.to(device)
+        inp = tok(comp_prompt(sentence), return_tensors="pt").to(device)
+        out = model.generate(
+            **inp,
+            max_new_tokens=max_new_tokens,
+            do_sample=True,
+            temperature=0.8,
+            top_p=0.9,
+            num_return_sequences=1,
+            eos_token_id=tok.eos_token_id
+        )
+        text = tok.decode(out[0], skip_special_tokens=True)
+        data = parse_json_block(text) or {}
+        q = str(data.get("question","")).strip()
+        choices = data.get("choices", [])
+        ai = data.get("answer_index", 0)
+        if not q or not isinstance(choices, list) or len(choices) < 4:
+            return None
+        choices = [str(c).strip() for c in choices][:4]
+        ai = ai if isinstance(ai, int) and 0 <= ai < 4 else 0
+        return MCQ(id=str(uuid.uuid4())[:8], question=q, choices=choices, answer_index=ai)
+    except Exception:
+        return None
+
+def make_comp_mcqs(text: str, n: int = 6, difficulty: str = "متوسط") -> List[MCQ]:
+    tok, model, ok = get_mt5()
+    if not ok:
+        return make_mcqs(text, n, difficulty=difficulty)
+
+    sents_all = split_sents(text)
+    sents = [s for s in sents_all if is_clean_sentence(s)] or sents_all[:]
+    if not sents:
+        return make_mcqs(text, n, difficulty=difficulty)
+
+    # دمج جمل قصيرة لمقاطع مفيدة
+    def make_chunks(sents, max_len=220):
+        chunks = []
+        i = 0
+        while i < len(sents):
+            cur = sents[i]
+            j = i + 1
+            while j < len(sents) and len(cur) + 1 + len(sents[j]) <= max_len:
+                cur = cur + " " + sents[j]
+                j += 1
+            chunks.append(cur)
+            i = j
+        return chunks
+
+    candidates = sents[:] + make_chunks(sents, max_len=220)
+    random.shuffle(candidates)
+
+    items: List[MCQ] = []
+    tried = 0
+    for s in candidates:
+        if len(items) >= n: break
+        mcq = gen_one_comp_q(s, tok, model)
+        tried += 1
+        if mcq:
+            q = re2.sub(r"\s+", " ", mcq.question).strip()
+            if not (12 <= len(q) <= 220): 
+                continue
+            choices = [re2.sub(r"\s+", " ", c).strip() for c in mcq.choices]
+            seen=set(); clean=[]
+            for c in choices:
+                if c and c not in seen:
+                    seen.add(c); clean.append(c)
+            clean = (clean + ["…","…","…","…"])[:4]
+            ai = mcq.answer_index if isinstance(mcq.answer_index,int) and 0<=mcq.answer_index<4 else 0
+            items.append(MCQ(id=str(uuid.uuid4())[:8], question=q, choices=clean, answer_index=ai))
+        if tried >= n * 12:
+            break
 
-# ====== (4) مُولِّد أسئلة جديد بمحافظته على نفس الواجهة تمامًا ======
-def make_mcqs(text:str, n:int=6)->List[MCQ]:
-    sents=split_sents(text)
-    if not sents: 
+    if not items:
+        return make_mcqs(text, n, difficulty=difficulty)
+    return items[:n]
+
+# ------------------ مُولّد أسئلة "فراغ" (نهائي) ------------------
+def make_mcqs(text: str, n: int = 6, difficulty: str = "متوسط") -> List[MCQ]:
+    all_sents = split_sents(text)
+    sents = [s for s in all_sents if is_clean_sentence(s)] or all_sents[:]
+    if not sents:
         raise ValueError("النص قصير أو غير صالح.")
 
-    # عبارات مفتاحية 1–3 كلمات
-    keyphrases = yake_keywords(text, k=160)
-    keyphrases = [kp for kp in keyphrases if good_kw(kp) and 2 <= len(kp) <= 40]
+    keyphrases = yake_keywords(text, k=260)
+    keyphrases = [kp for kp in keyphrases if safe_keyword(kp) and 2 <= len(kp) <= 40]
 
-    # ربط العبارة بجملة مناسبة (طول معقول ≥ 60) لضمان سياق واضح
-    sent_for={}
+    sent_for: dict = {}
     for s in sents:
-        if len(s) < 60:
-            continue
         for kp in keyphrases:
-            if kp in sent_for: 
+            if kp in sent_for:
                 continue
             if re2.search(rf"(?<!\p{{L}}){re2.escape(kp)}(?!\p{{L}})", s):
-                sent_for[kp]=s
-
-    if not sent_for:
-        # fallback: لو ما لقينا مطابقات جيدة، نرجع للمفردات العامة من النص
-        tokens = [t for t in re2.findall(r"[\p{L}\p{N}_]+", text) if good_kw(t)]
-        freq = [w for w,_ in sorted(((t, text.count(t)) for t in tokens), key=lambda x:-x[1])]
-        keyphrases = freq[:120]
-        for s in sents:
-            if len(s) < 60:
+                sent_for[kp] = s
+        if len(sent_for) >= n * 5:
+            break
+
+    para_map = paragraph_index_map(text, sents)
+    used_sentences: set = set()
+    items: List[MCQ] = []
+
+    MAX_PER_PARA = 2
+    para_count: dict = {}
+
+    def add_item_from_pair(sentence: str, kp: str) -> bool:
+        nonlocal items, used_sentences, para_count
+        pid = para_map.get(sentence, -1)
+        if para_count.get(pid, 0) >= MAX_PER_PARA:
+            return False
+        if not re2.search(rf"(?<!\p{{L}}){re2.escape(kp)}(?!\p{{L}})", sentence):
+            return False
+        q = re2.sub(rf"(?<!\p{{L}}){re2.escape(kp)}(?!\p{{L}})", "_____", sentence, count=1)
+        pool = [x for x in keyphrases if x != kp] or keyphrases[:]
+        ch = smart_distractors(kp, pool, sentence, k=3,
+                               all_sentences=all_sents, difficulty=difficulty) + [kp]
+
+        choices, seen = [], set()
+        for c in ch:
+            c = (c or "").strip()
+            if not c or c in seen:
+                continue
+            if not choice_length_ok(c):
                 continue
-            for kp in keyphrases:
-                if kp in sent_for:
-                    continue
-                if re2.search(rf"(?<!\p{{L}}){re2.escape(kp)}(?!\p{{L}})", s):
-                    sent_for[kp]=s
-            if len(sent_for)>=n*2:
-                break
-
-    if not sent_for:
-        raise RuntimeError("تعذّر توليد أسئلة من هذا النص.")
-
-    # نعطي أولوية للعبارات الأطول (أكثر إعلامية)
-    items=[]; used_sents=set(); used_keys=set()
+            if appears_as_long_fragment_in_sentence(c, sentence):
+                continue
+            if is_sub_or_super(c, kp) or jaccard(c, kp) >= 0.5:
+                continue
+            seen.add(c); choices.append(c)
+
+        if kp not in choices:
+            choices.append(kp); seen.add(kp)
+        if len(choices) < 4:
+            return False
+
+        choices = choices[:4]
+        random.shuffle(choices)
+        ans = choices.index(kp)
+
+        items.append(MCQ(id=str(uuid.uuid4())[:8], question=q, choices=choices, answer_index=ans))
+        used_sentences.add(sentence)
+        para_count[pid] = para_count.get(pid, 0) + 1
+        return True
+
+    # تمريرة أولى: تنويع على الفقرات
     for kp in sorted(sent_for.keys(), key=lambda x: (-len(x), x)):
-        if len(items)>=n: break
-        s=sent_for[kp]
-        if s in used_sents or kp in used_keys: 
+        if len(items) >= n: break
+        s = sent_for[kp]
+        if s in used_sentences: 
             continue
+        _ = add_item_from_pair(s, kp)
 
-        # ابنِ سؤال الفراغ
-        q=re2.sub(rf"(?<!\p{{L}}){re2.escape(kp)}(?!\p{{L}})", "_____", s, count=1)
-
-        # مشتتات أذكى (مع رجوع تلقائي لو النماذج مش متاحة)
-        pool = [x for x in keyphrases if x != kp]
-        ch = smart_distractors(kp, pool, s, k=3) + [kp]
-        random.shuffle(ch); ans=ch.index(kp)
+    def fill_from_sentences(candidates: List[str]):
+        for s in candidates:
+            if len(items) >= n: break
+            if s in used_sentences: 
+                continue
+            kp = None
+            for kpp, ss in sent_for.items():
+                if ss == s:
+                    kp = kpp; break
+            if kp is None:
+                kp = best_keyword_in_sentence(s, text)
+            if not kp:
+                continue
+            _ = add_item_from_pair(s, kp)
 
-        items.append(MCQ(id=str(uuid.uuid4())[:8], question=q, choices=ch, answer_index=ans))
-        used_sents.add(s); used_keys.add(kp)
+    if len(items) < n:
+        remaining_new_para = [s for s in sents if para_count.get(para_map.get(s, -1), 0) < MAX_PER_PARA]
+        fill_from_sentences(remaining_new_para)
+    if len(items) < n:
+        leftovers = [s for s in sents if s not in used_sentences]
+        fill_from_sentences(leftovers)
 
-    if not items: 
+    if not items:
         raise RuntimeError("تعذّر توليد أسئلة.")
-    return items
+    return items[:n]
+
+# ------------------ تحويل إلى سجلات العرض ------------------
+def clean_option_text(t: str) -> str:
+    t = (t or "").strip()
+    t = re2.sub(AR_DIAC, "", t)
+    t = re2.sub(r"\s+", " ", t)
+    t = re2.sub(r"^[\p{P}\p{S}_-]+|[\p{P}\p{S}_-]+$", "", t)
+    # قصّ لطول معقول
+    t = re2.sub(r"^(.{,60})(?:\s.*)?$", r"\1", t)
+    return t or "…"
 
 def to_records(items:List[MCQ])->List[dict]:
     recs=[]
     for it in items:
         opts=[]
+        used=set()
         for i,lbl in enumerate(["A","B","C","D"]):
-            txt=(it.choices[i] if i<len(it.choices) else "—").strip()
-            txt=txt.replace(",", "،").replace("?", "؟").replace(";", "؛")
-            opts.append({"id":lbl,"text":txt or "—","is_correct":(i==it.answer_index)})
+            txt=(it.choices[i] if i<len(it.choices) else "…")
+            txt=clean_option_text(txt.replace(",", "،").replace("?", "؟").replace(";", "؛"))
+            if txt in used:
+                txt = f"{txt}‌{i+1}"
+            used.add(txt)
+            opts.append({"id":lbl,"text":txt,"is_correct":(i==it.answer_index)})
         recs.append({"id":it.id,"question":it.question.strip(),"options":opts})
     return recs
 
@@ -358,19 +782,32 @@ def render_quiz_html(records: List[dict]) -> str:
         """)
     return f"""<div id="quiz" class="quiz-wrap">{''.join(parts)}</div>"""
 
-# ------------------ توليد الامتحان وتبديل الصفحات ------------------
-def build_quiz(text_area, file_path, n, model_id, zoom):
+# ------------------ بناء الامتحان وتبديل الصفحات ------------------
+def build_quiz(text_area, file_path, n, model_id, zoom, mode, difficulty):
     text_area = (text_area or "").strip()
     if not text_area and not file_path:
         return "", gr.update(visible=True), gr.update(visible=False), "🛈 الصق نصًا أو ارفع ملفًا أولًا."
-    if text_area:
-        raw = text_area
-    else:
-        raw, _ = file_to_text(file_path, model_id=model_id, zoom=float(zoom))
+    raw = text_area if text_area else file_to_text(file_path, model_id=model_id, zoom=float(zoom))[0]
     cleaned = postprocess(raw)
-    items   = make_mcqs(cleaned, n=int(n))
-    recs    = to_records(items)
-    return render_quiz_html(recs), gr.update(visible=False), gr.update(visible=True), ""
+
+    used_mode = mode
+    try:
+        if mode == "فهم مباشر":
+            tok, model, ok = get_mt5()
+            if ok:
+                items = make_comp_mcqs(cleaned, n=int(n), difficulty=difficulty)
+            else:
+                items = make_mcqs(cleaned, n=int(n), difficulty=difficulty)
+                used_mode = "فراغ (fallback)"
+        else:
+            items = make_mcqs(cleaned, n=int(n), difficulty=difficulty)
+    except Exception:
+        items = make_mcqs(cleaned, n=int(n), difficulty=difficulty)
+        used_mode = "فراغ (fallback)"
+
+    recs = to_records(items)
+    warn = f"نمط مُستخدَم: **{used_mode}** — عدد الأسئلة: {len(items)}"
+    return render_quiz_html(recs), gr.update(visible=False), gr.update(visible=True), warn
 
 # ------------------ CSS ------------------
 CSS = """
@@ -382,12 +819,12 @@ body{direction:rtl; font-family:system-ui,'Cairo','IBM Plex Arabic',sans-serif;
 .gradio-container{max-width:980px;margin:0 auto;padding:12px 12px 40px;}
 h2.top{color:#eaeaf2;margin:6px 0 16px}
 
-/* صفحة الإدخال ثابتة الارتفاع ولا تتغير بعد الرفع */
+/* صفحة الإدخال ثابتة الارتفاع ولا تتغير أبعادها */
 .input-panel{background:var(--panel);border:1px solid var(--border);border-radius:14px;padding:16px;
   box-shadow:0 16px 38px rgba(0,0,0,.35); min-height:360px; display:flex; flex-direction:column; gap:12px;}
 .small{opacity:.9;color:#d9dee8}
 
-/* منع لوحة المعاينة الخاصة بالملفات التي تغيّر التخطيط */
+/* إخفاء معاينة الملف */
 [data-testid="file"] .file-preview, [data-testid="file"] .file-preview * { display:none !important; }
 [data-testid="file"] .grid-wrap { display:block !important; }
 .upload-like{border:2px dashed #3b3f52;background:#121318;border-radius:12px;padding:12px;color:#cfd5e3;min-height:90px}
@@ -404,7 +841,7 @@ textarea{min-height:120px}
 .q-badge.ok{background:#083a2a;color:#b6f4db;border:1px solid #145b44}
 .q-badge.err{background:#3a0d14;color:#ffd1d6;border:1px solid #6a1e2b}
 
-.q-text{color:var(--text);font-size:1.06rem;line-height:1.8;margin:8px 0 12px}
+.q-text{color:#eaeaf2;font-size:1.06rem;line-height:1.8;margin:8px 0 12px}
 .opts{display:flex;flex-direction:column;gap:8px}
 .opt{display:flex;gap:10px;align-items:center;background:#14161c;border:1px solid #2a2d3a;border-radius:12px;padding:10px;transition:background .15s,border-color .15s}
 .opt input{accent-color:var(--accent2)}
@@ -415,17 +852,16 @@ textarea{min-height:120px}
 
 .q-actions{display:flex;gap:10px;align-items:center;margin-top:10px}
 .q-actions .q-submit{
-  background:#2dd4bf;border:none;color:#0b0d10;font-weight:800;border-radius:10px;padding:8px 14px;cursor:pointer;
+  background:#2dd4bf;border:none;color:#0b0د10;font-weight:800;border-radius:10px;padding:8px 14px;cursor:pointer;
 }
 .q-actions .q-submit:disabled{opacity:.5;cursor:not-allowed}
 .q-note{color:#ffd1d6}
 .q-note.warn{color:#ffd1d6}
 """
 
-# ------------------ JS: ربط Submit بعد الرندر (مع Output مخفي لضمان التنفيذ) ------------------
+# ------------------ JS: ربط Submit + إبراز الصح ------------------
 ATTACH_LISTENERS_JS = """
 () => {
-  // اربط مرة واحدة فقط
   if (window.__q_submit_bound_multi2) { return 'already'; }
   window.__q_submit_bound_multi2 = true;
 
@@ -448,22 +884,30 @@ ATTACH_LISTENERS_JS = """
 
     const chosenLabel = chosen.closest('.opt');
 
-    // حالة صحيحة: لوّن أخضر وأقفل السؤال كاملاً
     if (chosen.value === correct) {
       chosenLabel.classList.add('ok');
       if (badge){ badge.hidden=false; badge.className='q-badge ok'; badge.textContent='Correct!'; }
-      // أقفل هذا السؤال فقط بعد الصح
       card.querySelectorAll('input[type="radio"]').forEach(i => i.disabled = true);
       e.target.disabled = true;
       if (note) note.textContent = '';
+
+      const qNode = card.querySelector('.q-text');
+      if (qNode){
+        const full = qNode.textContent || qNode.innerText || '';
+        const correctText = [...card.querySelectorAll('.opt')].find(o =>
+          o.querySelector('input').value === correct
+        )?.querySelector('.opt-text')?.textContent || '';
+        if (full && correctText && full.includes('_____')){
+          const highlighted = full.replace('_____', `<mark style="background:#2dd4bf22;border:1px solid #2dd4bf55;border-radius:6px;padding:0 4px">${correctText}</mark>`);
+          qNode.innerHTML = highlighted;
+        }
+      }
       return;
     }
 
-    // حالة خاطئة: لوّن أحمر فقط، ولا تعطل أي شيء — ليقدر يجرّب خيار آخر
-    chosenLabel.classList.add('err');         // اتركه أحمر
+    chosenLabel.classList.add('err');
     if (badge){ badge.hidden=false; badge.className='q-badge err'; badge.textContent='Incorrect.'; }
     if (note) note.textContent = '';
-    // مهم: لا تعطّل الراديو ولا الزر
   });
 
   return 'wired-multi2';
@@ -474,7 +918,6 @@ ATTACH_LISTENERS_JS = """
 with gr.Blocks(title="Question Generator", css=CSS) as demo:
     gr.Markdown("<h2 class='top'>Question Generator</h2>")
 
-    # الصفحة 1: إدخال ثابت لا تتغير أبعاده
     page1 = gr.Group(visible=True, elem_classes=["input-panel"])
     with page1:
         gr.Markdown("اختر **أحد** الخيارين ثم اضغط الزر.", elem_classes=["small"])
@@ -482,6 +925,10 @@ with gr.Blocks(title="Question Generator", css=CSS) as demo:
         file_comp = gr.File(label="أو ارفع ملف (PDF / TXT)", file_count="single",
                             file_types=[".pdf",".txt"], type="filepath", elem_classes=["upload-like"])
         num_q = gr.Slider(4, 20, value=DEFAULT_NUM_QUESTIONS, step=1, label="عدد الأسئلة")
+
+        mode_radio = gr.Radio(choices=QUESTION_MODES, value="فراغ", label="نوع السؤال")
+        difficulty_radio = gr.Radio(choices=DIFFICULTY_MODES, value="متوسط", label="درجة الصعوبة")
+
         with gr.Accordion("خيارات PDF المصوّر (اختياري)", open=False):
             trocr_model = gr.Dropdown(
                 choices=[
@@ -493,19 +940,18 @@ with gr.Blocks(title="Question Generator", css=CSS) as demo:
                 value=DEFAULT_TROCR_MODEL, label="نموذج TrOCR"
             )
             trocr_zoom = gr.Slider(2.0, 3.5, value=DEFAULT_TROCR_ZOOM, step=0.1, label="Zoom OCR")
+
         btn_build = gr.Button("generate quistion", elem_classes=["button-primary"])
         warn = gr.Markdown("", elem_classes=["small"])
 
-    # الصفحة 2: الأسئلة
     page2 = gr.Group(visible=False)
     with page2:
         quiz_html = gr.HTML("")
-        js_wired  = gr.Textbox(visible=False)   # Output مخفي لضمان تنفيذ JS
+        js_wired  = gr.Textbox(visible=False)
 
-    # بناء الامتحان + تبديل الصفحات + ربط الـJS
     btn_build.click(
         build_quiz,
-        inputs=[text_area, file_comp, num_q, trocr_model, trocr_zoom],
+        inputs=[text_area, file_comp, num_q, trocr_model, trocr_zoom, mode_radio, difficulty_radio],
         outputs=[quiz_html, page1, page2, warn]
     ).then(
         None, inputs=None, outputs=[js_wired], js=ATTACH_LISTENERS_JS