Upload app.py

app.py

@@ -358,54 +358,86 @@ def analyze_solution(question: str, solution: str):
     return final_verdict    
      
 def classify_solution_stream(question: str, solution: str):
-    # always yield exactly 3 outputs: (classification, explanation, status)
+    """
+    Streams (classification, explanation, status_markdown)
+    Status shows a growing checklist:
+      ⏳ Stage 1 ...
+      ✅ Stage 1 ... done
+      ⏳ Stage 2 ...
+      ✅ / 🟥 Stage 2 ... result
+    """
+    def render(log_lines):
+        # join as a bulleted list
+        return "\n".join(f"- {line}" for line in log_lines) or "*(idle)*"
+
+    log = []
+
+    # basic input check
     if not question.strip() or not solution.strip():
-        yield "Please fill in both fields", "", "⚠️ Provide a question and a solution."
+        log.append("⚠️ Provide a question and a solution.")
+        yield "Please fill in both fields", "", render(log)
         return
 
+    # lazy-load if needed
     if not models_ready():
-        yield "⏳ Loading models…", "", "Booting models…"
+        log.append("⏳ Loading models…")
+        yield "⏳ Working…", "", render(log)
         msg = load_model()
         if not models_ready():
-            yield "Models not loaded", "", f"❌ {msg}"
+            log[-1] = f"🟥 Failed to load models — {msg}"
+            yield "Models not loaded", "", render(log)
             return
+        log[-1] = "✅ Models loaded."
 
     try:
-        # Stage 1 — conceptual
-        yield "⏳ Working…", "Starting conceptual check…", "🔎 **Stage 1:** running classifier…"
+        # ---------- Stage 1: Conceptual ----------
+        log.append("⏳ **Stage 1: Conceptual check**")
+        yield "⏳ Working…", "Starting conceptual check…", render(log)
+
         conceptual = run_conceptual_check(question, solution, classifier_model, classifier_tokenizer)
-        conf = conceptual['probabilities'][conceptual['prediction']]
-        yield "⏳ Working…", f"Stage 1: **{conceptual['prediction']}** (p={conf:.2%}). Now checking calculations…", \
-              f"✅ **Stage 1 done** — prediction: **{conceptual['prediction']}** (p={conf:.2%})."
+        pred = conceptual["prediction"]
+        conf = conceptual["probabilities"][pred]
+        log[-1] = f"✅ **Stage 1: Conceptual check** — prediction **{pred}** (p={conf:.2%})"
+        yield "⏳ Working…", f"Stage 1: {pred} (p={conf:.2%}). Now checking calculations…", render(log)
+
+        # ---------- Stage 2: Computational ----------
+        log.append("⏳ **Stage 2: Computational check**")
+        yield "⏳ Working…", "Running computational check…", render(log)
 
-        # Stage 2 — computational
-        yield "⏳ Working…", "Running computational check…", "🧮 **Stage 2:** extracting & evaluating equations…"
         computational = run_computational_check(solution, gemma_model, gemma_tokenizer)
 
-        # Final verdict
+        # ---------- Final verdict ----------
         if computational["error"]:
+            # mark stage 2 as failed
+            line_txt = computational["line_text"]
+            corr = computational["correct_calc"]
+            log[-1] = f"🟥 **Stage 2: Computational check** — error on line “{line_txt}” (correct: `{corr}`)"
             classification = "computational_error"
             explanation = (
-                f"A calculation error was found.\n"
-                f"On the line: \"{computational['line_text']}\"\n"
-                f"The correct calculation should be: {computational['correct_calc']}"
+                "A calculation error was found.\n"
+                f'On the line: "{line_txt}"\n'
+                f"The correct calculation should be: {corr}"
             )
-            status = "🟥 **Final:** computational error detected."
         else:
-            if conceptual['prediction'] == 'correct':
-                classification = 'correct'
+            log[-1] = "✅ **Stage 2: Computational check** — no arithmetic issues found."
+            if pred == "correct":
+                classification = "correct"
                 explanation = "All calculations are correct and the overall logic appears to be sound."
-                status = "🟩 **Final:** correct."
             else:
-                classification = 'conceptual_error'
-                explanation = "All calculations are correct, but there appears to be a conceptual error in the logic or setup of the solution."
-                status = "🟨 **Final:** conceptual issue."
+                classification = "conceptual_error"
+                explanation = (
+                    "All calculations are correct, but there appears to be a conceptual error "
+                    "in the logic or setup of the solution."
+                )
 
-        yield classification, explanation, status
+        # final yield updates both result fields + the complete checklist
+        yield classification, explanation, render(log)
 
     except Exception as e:
         logger.exception("inference failed")
-        yield "Runtime error", f"{type(e).__name__}: {e}", "❌ Exception during inference."
+        log.append(f"🟥 Exception during inference: **{type(e).__name__}** — {e}")
+        yield "Runtime error", f"{type(e).__name__}: {e}", render(log)
+
 
         # ---------------- UI: streaming, no progress bars ----------------
 with gr.Blocks(title="Math Solution Classifier", theme=gr.themes.Soft()) as app: