Update app.py

app.py

@@ -270,41 +270,87 @@ def _responses_for_student_stage(uri, db, responses_coll, student: str, stage: s
         return [d for d in docs if (d.get("answer") or "").strip()]
     except Exception:
         return []
-
 import re
 
+def _answer_total_score(resp: dict) -> float:
+    skills = resp.get("skills") or {}
+    total = 0.0
+    for v in skills.values():
+        try:
+            total += float(v)
+        except Exception:
+            pass
+    return total
+
+def _norm_text(s: str) -> str:
+    # lower, collapse whitespace, strip surrounding punctuation/dots
+    return re.sub(r"\s+", " ", (s or "").lower()).strip(" .,\"'`”’“‘-–—()[]{}")
+
+def _fragments_in_order(answer_norm: str, frags_norm: list[str]) -> bool:
+    """Return True if all fragments appear in order anywhere in the answer."""
+    start = 0
+    for frag in frags_norm:
+        idx = answer_norm.find(frag, start)
+        if idx == -1:
+            return False
+        start = idx + len(frag)
+    return True
+
 def _fix_cutoff_quotes(quotes: list[str], responses: list[dict]) -> list[str]:
     """
-    Replace truncated quotes with full answers from responses_IFE_2025 
-    when the original quote is found as a substring.
+    Replace truncated quotes with full answers when possible.
+    Works for:
+      - '...' ellipsis in the middle (checks fragments in order, anywhere)
+      - plain middle fragments (substring match)
+    If multiple matches, pick the response with highest total skill score.
     """
     if not quotes:
         return []
-    
+    # Precompute normalized answers + scores
+    norm_answers = []
+    for r in responses:
+        ans = (r.get("answer") or "").strip()
+        if not ans:
+            continue
+        norm_answers.append((
+            _norm_text(ans),
+            ans,
+            _answer_total_score(r)
+        ))
+
     fulls = []
     for q in quotes:
-        q_clean = (q or "").strip()
-        if not q_clean:
+        q_raw = (q or "").strip()
+        if not q_raw:
             continue
-        
-        # Check if it looks truncated
-        is_truncated = "..." in q_clean or len(q_clean) < 80  # tweak len threshold if needed
-        
-        replaced = False
-        if is_truncated:
-            # Normalize for matching
-            q_norm = re.sub(r"\s+", " ", q_clean.lower()).strip(" .")
-            for r in responses:
-                ans = (r.get("answer") or "").strip()
-                ans_norm = re.sub(r"\s+", " ", ans.lower()).strip(" .")
-                if q_norm in ans_norm:
-                    fulls.append(ans)  # use the full original answer
-                    replaced = True
-                    break
-        
-        if not replaced:
-            fulls.append(q_clean)  # fallback to given quote
-    
+
+        q_norm = _norm_text(q_raw)
+        candidates = []
+
+        if "..." in q_raw:
+            # split on ellipses, keep non-empty normalized fragments
+            parts = [p.strip() for p in re.split(r"\.\.\.|…", q_raw)]
+            parts_norm = [_norm_text(p) for p in parts if _norm_text(p)]
+            if parts_norm:
+                for ans_norm, ans_full, score in norm_answers:
+                    if _fragments_in_order(ans_norm, parts_norm):
+                        candidates.append((score, ans_full))
+        else:
+            # plain substring anywhere in the answer
+            for ans_norm, ans_full, score in norm_answers:
+                if q_norm and q_norm in ans_norm:
+                    candidates.append((score, ans_full))
+
+        if candidates:
+            # pick highest scoring answer
+            candidates.sort(key=lambda x: x[0], reverse=True)
+            fulls.append(candidates[0][1])
+        else:
+            # no match found → keep original
+            fulls.append(q_raw)
+
+    return fulls
+
     return fulls
 
 def _top3_answers_by_skill_sum(responses: list[dict]) -> list[str]: