import gradio as gr
import os
import sys
import json
import re
# Ensure the current directory is in the path
current_dir = os.path.dirname(os.path.abspath(__file__))
sys.path.append(current_dir)
from smart_tutor_core import crew
# ----------------------------------------------------------------------
# Helper: Parse Output
# ----------------------------------------------------------------------
def parse_agent_output(raw_output: str):
"""
Tries to parse JSON from the raw string output.
Returns (data_dict, is_json).
"""
data = None
try:
data = json.loads(raw_output)
return data, True
except json.JSONDecodeError:
# Try finding JSON block
match = re.search(r"(\{.*\})", raw_output, re.DOTALL)
if match:
try:
data = json.loads(match.group(1))
return data, True
except:
pass
return raw_output, False
def clean_text(text: str) -> str:
"""
Aggressively removes markdown formatting to ensure clean text display.
Removes: **bold**, __bold__, *italic*, _italic_, `code`
"""
if not text:
return ""
text = str(text)
# Remove bold/italic markers
text = re.sub(r"\*\*|__|`", "", text)
text = re.sub(r"^\s*\*\s+", "", text) # Remove leading list asterisks if any
return text.strip()
# ----------------------------------------------------------------------
# Helper: Format Text Output for Display
# ----------------------------------------------------------------------
def format_text_output(raw_text):
"""
Converts raw agent text (markdown-ish) into
beautifully styled HTML inside a summary-box.
"""
if not raw_text:
return ""
text = str(raw_text).strip()
# Convert markdown headings to HTML
text = re.sub(r"^### (.+)$", r"
\1
", text, flags=re.MULTILINE)
text = re.sub(r"^## (.+)$", r"
\1
", text, flags=re.MULTILINE)
text = re.sub(r"^# (.+)$", r"
\1
", text, flags=re.MULTILINE)
# Convert **bold** to
text = re.sub(r"\*\*(.+?)\*\*", r"\1", text)
# Convert bullet lists (- item or * item)
lines = text.split("\n")
result = []
in_list = False
for line in lines:
stripped = line.strip()
is_bullet = (
stripped.startswith("- ")
or stripped.startswith("* ")
or re.match(r"^\d+\.\s", stripped)
)
if is_bullet:
if not in_list:
tag = "ul" # Always use bullets as requested
result.append(f"<{tag}>")
in_list = tag
# Remove both -/* and 1. from the start of the line
content = re.sub(r"^[-*]\s+|^\d+\.\s+", "", stripped)
result.append(f"
{content}
")
else:
if in_list:
result.append(f"")
in_list = False
if stripped.startswith("{stripped}")
if in_list:
result.append(f"")
html = "\n".join(result)
return f"
{html}
"
# ----------------------------------------------------------------------
# Logic: Run Agent
# ----------------------------------------------------------------------
def run_agent(file, user_text):
if not user_text and not file:
return (
gr.update(
visible=True,
value="
⚠️ Please enter a request or upload a file.
",
),
gr.update(visible=False), # Quiz Group
None, # State
)
full_request = user_text
# Check if user wants a quiz but didn't upload a file (common error)
if "quiz" in user_text.lower() and not file:
return (
gr.update(
visible=True,
value="
⚠️ To generate a quiz, please upload a document first.
",
),
gr.update(visible=False),
None,
)
if file:
# file is a filepath string because type='filepath'
full_request = f"""USER REQUEST: {user_text}
IMPORTANT: The file to process is located at this EXACT path:
{file}
You MUST use this exact path when calling tools (process_file, store_quiz, etc.)."""
# SYSTEM PROMPT INJECTION to force JSON format from the agent
system_instruction = "\n\n(SYSTEM NOTE: If generating a quiz, you MUST call the store_quiz tool and return its VALID JSON output including 'quiz_id'. Do NOT return just the questions text.)"
try:
inputs = {"user_request": full_request + system_instruction}
result = crew.kickoff(inputs=inputs)
raw_output = str(result)
print(f"\n{'='*60}")
print(f"[DEBUG] raw_output (first 500 chars):")
print(raw_output[:500])
print(f"{'='*60}")
data, is_json = parse_agent_output(raw_output)
print(f"[DEBUG] is_json={is_json}")
if is_json:
print(
f"[DEBUG] keys={list(data.keys()) if isinstance(data, dict) else 'not a dict'}"
)
if isinstance(data, dict) and "questions" in data:
print(f"[DEBUG] num questions={len(data['questions'])}")
# Case 1: Quiz Output (Success)
if is_json and "questions" in data:
# We accept it even if quiz_id is missing, but grading might fail.
return (
gr.update(visible=False), # Hide Summary
gr.update(visible=True), # Show Quiz
data, # Store Data
)
# Case 2: Grade Result (Standard JSON from grade_quiz) - Handled nicely
if is_json and "score" in data:
markdown = format_grade_result(data)
return (
gr.update(visible=True, value=markdown),
gr.update(visible=False),
None,
)
# Case 3: Normal Text / Summary / Explanation
html_content = format_text_output(raw_output)
return (
gr.update(visible=True, value=html_content),
gr.update(visible=False),
None,
)
except Exception as e:
error_msg = f"
❌ Error: {str(e)}
"
return (
gr.update(visible=True, value=error_msg),
gr.update(visible=False),
None,
)
# ----------------------------------------------------------------------
# Logic: Quiz Render & Grading
# ----------------------------------------------------------------------
def render_quiz(quiz_data):
"""
Renders the quiz questions dynamically.
Returns updates for: [Radios x10] + [Feedbacks x10] + [CheckBtn] (Total 21)
"""
updates = []
if not quiz_data:
# Hide everything
return [gr.update(visible=False)] * 21
questions = quiz_data.get("questions", [])
# 1. Update Radios (10 slots)
for i in range(10):
if i < len(questions):
q = questions[i]
q_txt = clean_text(q.get("question", "Question text missing"))
question_text = f"{i+1}. {q_txt}"
# Ensure options are a dict and sorted
raw_options = q.get("options", {})
if not isinstance(raw_options, dict):
# Fallback if options came as a list or string
raw_options = {"A": "Error loading options"}
# Sort by key A, B, C, D...
# We strictly enforce the "Key. Value" format
choices = []
for key in sorted(raw_options.keys()):
val = clean_text(raw_options[key])
choices.append(f"{key}. {val}")
updates.append(
gr.update(
visible=True,
label=question_text,
choices=choices,
value=None,
interactive=True,
)
)
else:
updates.append(gr.update(visible=False, choices=[], value=None))
# 2. Update Feedbacks (10 slots) - Hide them initially
for i in range(10):
updates.append(gr.update(visible=False, value=""))
# 3. Show Grid/Check Button
updates.append(gr.update(visible=True))
return updates
def grade_quiz_ui(quiz_data, *args):
"""
Collects answers, calls agent (or tool), and returns graded results designed for UI.
Input args: [Radio1_Val, Radio2_Val, ..., Radio10_Val] (Length 10)
Output: [Radios x10] + [Feedbacks x10] + [ResultMsg] (Total 21)
"""
# args tuple contains the values of the 10 radios
answers_list = args[0:10]
updates = []
# Validation
if not quiz_data or "quiz_id" not in quiz_data:
# Fallback if ID is missing
error_updates = [gr.update()] * 10 + [gr.update()] * 10
error_updates.append(
gr.update(
visible=True,
value="
⚠️ Error: Quiz ID not found. Cannot grade this quiz.
",
)
)
return error_updates
quiz_id = quiz_data["quiz_id"]
# Construct answer map {"1": "A", ...}
user_answers = {}
for i, ans in enumerate(answers_list):
if ans:
# ans is like "A. Option Text" -> extract "A"
selected_opt = ans.split(".")[0]
# Use qid from data if available, else i+1
qid = str(i + 1)
# Try to match qid from quiz_data if possible
if i < len(quiz_data.get("questions", [])):
q = quiz_data["questions"][i]
qid = str(q.get("qid", i + 1))
user_answers[qid] = selected_opt
# Construct the JSON for the agent
answers_json = json.dumps(user_answers)
grading_request = f"Grade quiz {quiz_id} with answers {answers_json}\n(SYSTEM: Return valid JSON matching GradeQuizResult schema.)"
try:
inputs = {"user_request": grading_request}
result = crew.kickoff(inputs=inputs)
raw_output = str(result)
data, is_json = parse_agent_output(raw_output)
if is_json and "score" in data:
return format_grade_result_interactive(data, answers_list)
else:
# Fallback error in result box
error_updates = [gr.update()] * 10 + [gr.update()] * 10
error_updates.append(
gr.update(
visible=True,
value=f"