Upload 25 files

app.py

@@ -0,0 +1,29 @@
+from flask import Flask, render_template
+import config
+from extensions import mongo, mail
+
+app = Flask(__name__)
+app.config.from_object(config)
+
+# Initialize extensions
+mongo.init_app(app)
+mail.init_app(app)
+
+# Import blueprints after extensions
+from routes.auth import auth_bp
+from routes.test_routes import test_bp
+
+app.register_blueprint(auth_bp)
+app.register_blueprint(test_bp)
+
+from services.feedback_agent import build_feedback_agent
+
+app.feedback_agent = build_feedback_agent()
+
+@app.route("/")
+def home():
+    tests = list(mongo.db.tests.find({}, {"_id": 0}))
+    return render_template("home.html", tests=tests)
+
+if __name__ == "__main__":
+    app.run(debug=True)

config.py

@@ -0,0 +1,17 @@
+import os
+from dotenv import load_dotenv
+load_dotenv()
+
+SECRET_KEY = os.getenv("SECRET_KEY", "secret123")
+MONGO_URI = os.getenv("MONGO_URI", "mongodb://localhost:27017/assessment_db")
+
+# Hugging Face
+HF_API_KEY = os.getenv("HF_API_KEY", "")
+
+# Email
+MAIL_SERVER = os.getenv("MAIL_SERVER", "smtp.gmail.com")
+MAIL_PORT = int(os.getenv("MAIL_PORT", 587))
+MAIL_USE_TLS = True
+MAIL_USERNAME = os.getenv("MAIL_USERNAME")
+MAIL_PASSWORD = os.getenv("MAIL_PASSWORD")
+MAIL_DEFAULT_SENDER = os.getenv("MAIL_DEFAULT_SENDER", MAIL_USERNAME)

models.py

@@ -0,0 +1,55 @@
+# models.py
+from extensions import mongo
+import datetime
+
+def users_col():
+    return mongo.db.users
+
+def tests_col():
+    return mongo.db.tests
+
+def responses_col():
+    return mongo.db.responses
+
+def results_col():
+    return mongo.db.results
+
+def create_user(name, email, password_hash):
+    users_col().insert_one({
+        "name": name,
+        "email": email,
+        "password": password_hash,
+        "created_at": datetime.datetime.utcnow()
+    })
+
+def find_user_by_email(email):
+    return users_col().find_one({"email": email})
+
+def add_test(test_obj):
+    tests_col().insert_one(test_obj)
+
+def get_test_by_id(test_id):
+    return tests_col().find_one({"id": test_id}, {"_id": 0})
+
+def store_response(email, test_id, question_id, question_text, student_answer, score):
+    responses_col().insert_one({
+        "email": email,
+        "test_id": test_id,
+        "question_id": question_id,
+        "question_text": question_text,
+        "student_answer": student_answer,
+        "score": score,
+        "timestamp": datetime.datetime.utcnow()
+    })
+
+def store_result(email, test_id, total_score, per_question_scores):
+    results_col().insert_one({
+        "email": email,
+        "test_id": test_id,
+        "total_score": total_score,
+        "per_question_scores": per_question_scores,
+        "timestamp": datetime.datetime.utcnow()
+    })
+
+def get_user_results(email):
+    return list(results_col().find({"email": email}, {"_id": 0}))

requirements.txt

@@ -0,0 +1,8 @@
+Flask==2.2.5
+Flask-PyMongo==2.3.0
+Flask-Mail==0.9.1
+python-dotenv==1.0.0
+requests==2.31.0
+pymongo[srv]==4.4.0
+numpy==1.26.0
+gunicorn==21.2.0

routes/auth.py

@@ -0,0 +1,51 @@
+from flask import Blueprint, render_template, request, redirect, url_for, session, flash, current_app
+from werkzeug.security import generate_password_hash, check_password_hash
+import models
+
+auth_bp = Blueprint("auth", __name__, url_prefix="/auth")
+
+@auth_bp.route("/signup", methods=["GET","POST"])
+def signup():
+    if request.method == "POST":
+        name = request.form["name"].strip()
+        email = request.form["email"].strip().lower()
+        password = request.form["password"]
+        if models.find_user_by_email(email):
+            flash("Email already registered. Please login.", "warning")
+            return redirect(url_for("auth.login"))
+        hashed = generate_password_hash(password)
+        models.create_user(name, email, hashed)
+        flash("Signup successful. Please login.", "success")
+        return redirect(url_for("auth.login"))
+    return render_template("signup.html")
+
+@auth_bp.route("/login", methods=["GET","POST"])
+def login():
+    if request.method == "POST":
+        email = request.form["email"].strip().lower()
+        password = request.form["password"]
+        user = models.find_user_by_email(email)
+        if not user or not check_password_hash(user["password"], password):
+            flash("Invalid credentials", "danger")
+            return redirect(url_for("auth.login"))
+        
+        # Set session
+        session["user"] = {"name": user["name"], "email": user["email"]}
+        
+        # Redirect to the first available test
+        first_test = list(models.tests_col().find({}, {"id": 1}, limit=1))
+        if first_test:
+            test_id = first_test[0]["id"]
+            return redirect(url_for("test.start", test_id=test_id))
+        else:
+            flash("No tests available", "warning")
+            return redirect(url_for("home"))
+
+    return render_template("login.html")
+
+
+@auth_bp.route("/logout")
+def logout():
+    session.pop("user", None)
+    flash("Logged out", "info")
+    return redirect(url_for("home"))

routes/test_routes.py

@@ -0,0 +1,86 @@
+from flask import Blueprint, render_template, request, redirect, url_for, session, flash, current_app
+import models
+
+test_bp = Blueprint("test", __name__, url_prefix="/test")
+
+
+@test_bp.before_request
+def require_login():
+    # allow access to login/signup endpoints
+    if 'user' not in session and request.endpoint not in ("auth.login", "auth.signup", "home"):
+        # allow accessing home page / static etc
+        allowed = ["home", "auth.login", "auth.signup", "static"]
+        # simple guard: allow home and auth pages without login
+        if request.endpoint and not request.endpoint.startswith("auth"):
+            return redirect(url_for("auth.login"))
+
+
+@test_bp.route("/start/<test_id>", methods=["GET"])
+def start(test_id):
+    # clear any previous answers in session and load first question
+    test = models.get_test_by_id(test_id)
+    if not test:
+        flash("Test not found", "danger")
+        return redirect(url_for("home"))
+    session[f"answers_{test_id}"] = {}
+    session[f"current_q_{test_id}"] = 0
+    return redirect(url_for("test.question", test_id=test_id))
+
+
+@test_bp.route("/question/<test_id>", methods=["GET", "POST"])
+def question(test_id):
+    test = models.get_test_by_id(test_id)
+    if not test:
+        flash("Test not found", "danger")
+        return redirect(url_for("home"))
+    questions = test.get("questions", [])
+    current_index = session.get(f"current_q_{test_id}", 0)
+    answers = session.get(f"answers_{test_id}", {})
+
+    if request.method == "POST":
+        qid = request.form.get("qid")
+        answer_text = request.form.get("answer", "").strip()
+        # save answer in session
+        answers[qid] = answer_text
+        session[f"answers_{test_id}"] = answers
+        # move next
+        current_index += 1
+        session[f"current_q_{test_id}"] = current_index
+
+    # If finished
+    if current_index >= len(questions):
+        # All answers collected; run agent to evaluate and email
+        user = session.get("user")
+        if not user:
+            flash("Please login to submit test", "danger")
+            return redirect(url_for("auth.login"))
+
+        # Use LangGraph feedback agent instead of run_feedback_agent
+        result = current_app.feedback_agent.invoke({
+            "student_name": user["name"],
+            "student_email": user["email"],
+            "test_id": test_id,
+            "answers_map": answers,
+        })
+
+        flash(f"Test submitted. Overall Score: {result['overall']}", "success")
+        return redirect(url_for("test.dashboard"))
+
+    # render current question
+    q = questions[current_index]
+    return render_template(
+        "test_question.html",
+        question=q,
+        index=current_index + 1,
+        total=len(questions),
+        test_id=test_id,
+    )
+
+
+@test_bp.route("/dashboard")
+def dashboard():
+    user = session.get("user")
+    if not user:
+        return redirect(url_for("auth.login"))
+    results = models.get_user_results(user["email"])
+    return render_template("dashboard.html", results=results, user=user)

seed_test.py

@@ -0,0 +1,11 @@
+from app import app, mongo
+
+with app.app_context():
+    try:
+        db = mongo.db
+        # List collections to verify connection
+        collections = db.list_collection_names()
+        print("✅ MongoDB connected successfully!")
+        print("Existing collections:", collections)
+    except Exception as e:
+        print("❌ MongoDB connection failed:", str(e))

services/email_service.py

@@ -0,0 +1,33 @@
+from flask import current_app
+from flask_mail import Message
+import logging
+
+logger = logging.getLogger(__name__)
+
+# CHANGE: Added optional html_content parameter
+def send_email(to_email, subject, body, html_content=None):
+    """
+    Sends an email using Flask-Mail, supporting both plain text (body) 
+    and optional HTML content (html_content).
+    """
+    try:
+        # Get the Mail instance and default sender from the Flask application context
+        mail = current_app.extensions.get('mail')
+        sender = current_app.config.get("MAIL_DEFAULT_SENDER")
+        
+        # CHANGE: Pass html_content to the 'html' parameter of Message
+        # The 'body' argument remains the plain text fallback.
+        msg = Message(
+            subject=subject, 
+            recipients=[to_email], 
+            body=body, 
+            html=html_content, # NEW: Pass the HTML content here
+            sender=sender
+        )
+        
+        mail.send(msg)
+        logger.info(f"Email sent to {to_email}")
+        return True
+    except Exception as e:
+        logger.exception("Failed to send email")
+        return False

services/evaluation.py

@@ -0,0 +1,99 @@
+import logging
+import os
+import nltk
+import torch
+from nltk.corpus import stopwords
+from nltk.stem import WordNetLemmatizer
+from nltk.tokenize import word_tokenize
+from sentence_transformers import SentenceTransformer, util
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+logger = logging.getLogger(__name__)
+
+# Download necessary NLTK resources
+nltk.download('punkt')
+nltk.download('stopwords')
+nltk.download('wordnet')
+
+# Initialize NLP tools
+lemmatizer = WordNetLemmatizer()
+stop_words = set(stopwords.words("english"))
+negation_words = {"not", "never", "no", "none", "cannot", "n't"}
+
+# SBERT Model for Similarity
+sbert_model = SentenceTransformer("all-MiniLM-L6-v2")
+
+# Cross-Encoder for Contextual Understanding
+cross_encoder_model = AutoModelForSequenceClassification.from_pretrained("cross-encoder/stsb-roberta-large")
+cross_encoder_tokenizer = AutoTokenizer.from_pretrained("cross-encoder/stsb-roberta-large")
+
+
+# -------------------------------
+# Preprocessing & Negation
+# -------------------------------
+def preprocess_text(text: str):
+    tokens = word_tokenize(text.lower())  # Lowercase & tokenize
+    tokens = [lemmatizer.lemmatize(word) for word in tokens if word not in stop_words]  # Remove stopwords & lemmatize
+    return " ".join(tokens)
+
+def contains_negation(text: str):
+    tokens = set(word_tokenize(text.lower()))
+    return any(word in negation_words for word in tokens)
+
+
+# -------------------------------
+# Evaluation Function
+# -------------------------------
+def evaluate_answer(student_ans: str, teacher_ans: str):
+    """
+    Returns score (0-100), and a dict breakdown.
+    Uses pre-loaded SBERT and Cross-Encoder models internally.
+    """
+    student = (student_ans or "").strip()
+    teacher = (teacher_ans or "").strip()
+    if not student:
+        return 0.0, {"reason": "Empty answer"}
+
+    try:
+        # Preprocess answers
+        student_clean = preprocess_text(student)
+        teacher_clean = preprocess_text(teacher)
+
+        # SBERT similarity
+        emb_student = sbert_model.encode(student_clean, convert_to_tensor=True)
+        emb_teacher = sbert_model.encode(teacher_clean, convert_to_tensor=True)
+        sbert_score = util.pytorch_cos_sim(emb_student, emb_teacher).item()  # 0..1
+
+        # Cross-Encoder score
+        inputs = cross_encoder_tokenizer(student_clean, teacher_clean, return_tensors="pt", truncation=True)
+        with torch.no_grad():
+            logits = cross_encoder_model(**inputs).logits
+        cross_score = torch.sigmoid(logits).item()  # 0..1
+
+        # Negation handling
+        student_neg = contains_negation(student)
+        teacher_neg = contains_negation(teacher)
+        if student_neg != teacher_neg:
+            sbert_score *= 0.5
+            cross_score *= 0.5
+            negation_penalty = 0.5
+        else:
+            negation_penalty = 0.0
+
+        # Weighted final score
+        final = 0.4 * sbert_score + 0.6 * cross_score
+        final = final * (1.0 - negation_penalty)
+        final_pct = round(final * 100, 2)
+
+        breakdown = {
+            "sbert_score": round(sbert_score * 100, 2),
+            "cross_score": round(cross_score * 100, 2),
+            "negation_penalty": negation_penalty,
+            "final_pct": final_pct
+        }
+
+        return final_pct, breakdown
+
+    except Exception as e:
+        logger.exception("Evaluation failed")
+        return 0.0, {"error": str(e)}

services/feedback_agent.py

@@ -0,0 +1,225 @@
+# services/feedback_agent.py
+
+from langgraph.graph import StateGraph, END
+from typing import Dict, Any, List
+import models
+from services.evaluation import evaluate_answer
+# NOTE: You MUST update services/email_service.py to accept and use the html_content argument
+from services.email_service import send_email 
+from services.huggingface_api import generate_feedback
+
+
+# ----------------------
+# Define State (Updated)
+# ----------------------
+class AgentState(dict):
+    student_name: str
+    student_email: str
+    test_id: str
+    answers_map: Dict[str, str]
+    per_question_scores: List[Dict[str, Any]]
+    overall: float
+    email_body: str
+    html_email_body: str  # NEW: Field for the HTML content
+    test: Dict[str, Any]
+
+
+# ----------------------
+# Agent Nodes
+# ----------------------
+def fetch_test(state: AgentState) -> AgentState:
+    """Fetch test data from DB."""
+    test = models.get_test_by_id(state["test_id"])
+    if not test:
+        raise ValueError("Test not found")
+    state["test"] = test
+    return state
+
+
+def evaluate_answers(state: AgentState) -> AgentState:
+    """Evaluate answers using evaluator + llama feedback and generate HTML body."""
+    test = state["test"]
+    student_email = state["student_email"]
+    test_id = state["test_id"]
+    answers_map = state["answers_map"]
+
+    questions = test.get("questions", [])
+    per_question_scores = []
+    
+    # OLD: email_parts will remain for the plain text version
+    email_parts = []
+    # NEW: List to collect HTML snippets for each question
+    question_html_parts = []
+    total = 0.0
+
+    # CHANGE: Use enumerate to get the question number
+    for idx, q in enumerate(questions):
+        q_num = idx + 1 # Calculate the question number
+        qid = q["id"]
+        qtext = q["text"]
+        ideal = q.get("ideal_answer", "")
+        student_ans = answers_map.get(qid, "")
+
+        # Step 1: Rule-based or ML evaluation
+        score, breakdown = evaluate_answer(student_ans, ideal)
+
+        # Step 2: Store raw response
+        models.store_response(student_email, test_id, qid, qtext, student_ans, score)
+
+        # Step 3: Generate AI feedback via LLaMA (Ensure services/huggingface_api.py is FIXED!)
+        feedback_text = generate_feedback(qtext, student_ans, score)
+        
+        # Prepare feedback for HTML (replace newlines with <br/>)
+        html_feedback = feedback_text.replace('\n', '<br/>')
+
+        per_question_scores.append({
+            "question_id": qid,
+            "question_text": qtext,
+            "student_answer": student_ans,
+            "score": score,
+            "breakdown": breakdown,
+            "feedback": feedback_text,
+        })
+
+        # Plain Text Part (Updated to include question number)
+        email_parts.append(
+            f"Q{q_num}: {qtext}\n"
+            f"A: {student_ans}\n"
+            f"Score: {score}/100\n"
+            f"Feedback: {feedback_text}\n\n"
+        )
+        
+        # NEW: Generate the HTML snippet for the current question
+        question_html_parts.append(
+            f"""
+            <div class="question-block">
+                <p style="font-size: 1.1em; font-weight: 600;">Q{q_num}: {qtext}</p>
+                <p style="margin-left: 10px;"><strong>Your Answer:</strong> {student_ans}</p>
+                <p style="margin-left: 10px;"><strong>Score:</strong> <span style="color: #007bff; font-weight: bold;">{score}/100</span></p>
+                <p style="margin-top: 10px;"><strong>Feedback:</strong></p>
+                <div class="feedback-box">
+                    {html_feedback}
+                </div>
+            </div>
+            """
+        )
+        total += score
+
+    # Compute overall
+    overall = round(total / max(1, len(questions)), 2)
+    models.store_result(student_email, test_id, overall, per_question_scores)
+
+    # Save results in state
+    state["per_question_scores"] = per_question_scores
+    state["overall"] = overall
+    
+    # Variables for templating
+    TEST_TITLE = test.get('title', 'Assessment')
+    STUDENT_NAME = state['student_name']
+    OVERALL_SCORE = str(overall)
+    QUESTION_FEEDBACK_HTML = "".join(question_html_parts)
+    
+    # Construct the Plain Text Body
+    state["email_body"] = (
+        f"Dear {STUDENT_NAME},\n\n"
+        f"Here is your assessment feedback for test: {TEST_TITLE}\n\n"
+        + "".join(email_parts)
+        + f"\nOverall Score: {overall}/100\n\nBest regards,\nAssessment Team"
+    )
+
+    # NEW: Construct the HTML Body
+    state["html_email_body"] = HTML_EMAIL_TEMPLATE.replace(
+        "{{ STUDENT_NAME }}", STUDENT_NAME
+    ).replace(
+        "{{ TEST_TITLE }}", TEST_TITLE
+    ).replace(
+        "{{ OVERALL_SCORE }}", OVERALL_SCORE
+    ).replace(
+        "{{ QUESTION_FEEDBACK_HTML }}", QUESTION_FEEDBACK_HTML
+    )
+    
+    return state
+
+
+def send_feedback_email(state: AgentState) -> AgentState:
+    """Send feedback email with results (passing HTML body)."""
+    # CHANGE: Pass the new html_email_body to the send_email function
+    send_email(
+        state["student_email"],
+        f"Assessment Feedback - {state['test'].get('title','')}",
+        state["email_body"], # Plain text content
+        html_content=state["html_email_body"] # HTML content
+    )
+    return state
+
+
+# ----------------------
+# Build LangGraph
+# ----------------------
+def build_feedback_agent():
+    workflow = StateGraph(AgentState)
+
+    workflow.add_node("fetch_test", fetch_test)
+    workflow.add_node("evaluate_answers", evaluate_answers)
+    workflow.add_node("send_feedback_email", send_feedback_email)
+
+    workflow.set_entry_point("fetch_test")
+    workflow.add_edge("fetch_test", "evaluate_answers")
+    workflow.add_edge("evaluate_answers", "send_feedback_email")
+    workflow.add_edge("send_feedback_email", END)
+
+    return workflow.compile()
+
+
+# ----------------------
+# HTML Email Template (Move this to a services/email_template.py file if possible)
+# ----------------------
+HTML_EMAIL_TEMPLATE = """
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Assessment Feedback</title>
+    <style>
+        /* CSS for the email template */
+        body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif; background-color: #f4f4f4; margin: 0; padding: 0; }
+        .container { max-width: 600px; margin: 20px auto; background-color: #ffffff; border-radius: 8px; box-shadow: 0 4px 8px rgba(0, 0, 0, 0.05); overflow: hidden; }
+        .header { background-color: #007bff; color: #ffffff; padding: 20px; text-align: center; }
+        .header h1 { margin: 0; font-size: 24px; }
+        .content { padding: 20px; color: #333333; }
+        .overall-score { text-align: center; margin: 20px 0; padding: 15px; border: 2px solid #28a745; background-color: #e9f7ef; border-radius: 5px; }
+        .overall-score h2 { margin: 0 0 5px 0; color: #28a745; }
+        .overall-score p { font-size: 2em; font-weight: bold; color: #28a745; margin: 0; }
+        .question-block { margin-bottom: 25px; padding: 15px; border: 1px solid #e0e0e0; border-radius: 5px; }
+        .question-block strong { color: #007bff; }
+        .feedback-box { margin-top: 10px; padding: 12px; background-color: #f8f9fa; border-left: 4px solid #007bff; border-radius: 3px; white-space: pre-wrap; }
+        .footer { padding: 20px; text-align: center; font-size: 0.8em; color: #999999; border-top: 1px solid #eeeeee; margin-top: 20px; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>Assessment Feedback: {{ TEST_TITLE }}</h1>
+        </div>
+        <div class="content">
+            <p>Dear {{ STUDENT_NAME }},</p>
+            <p>Please find your detailed assessment feedback below:</p>
+
+            <div class="overall-score">
+                <h2>Overall Score</h2>
+                <p>{{ OVERALL_SCORE }}/100</p>
+            </div>
+            
+            {{ QUESTION_FEEDBACK_HTML }}
+            
+            <p>We encourage you to review the suggested improvements to enhance your understanding of the material.</p>
+        </div>
+        <div class="footer">
+            Best regards,<br>
+            The Assessment Team
+        </div>
+    </div>
+</body>
+</html>
+"""

services/huggingface_api.py

@@ -0,0 +1,118 @@
+import os
+import time
+import logging
+import requests
+from openai import OpenAI
+
+logger = logging.getLogger(__name__)
+
+HF_HEADERS = {"Authorization": f"Bearer {os.getenv('HF_API_KEY', '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')}"}
+HF_BASE = "https://api-inference.huggingface.co/models"
+
+def hf_post(model, payload, retry=2):
+    url = f"{HF_BASE}/{model}"
+    for attempt in range(retry + 1):
+        resp = requests.post(url, headers=HF_HEADERS, json=payload, timeout=60)
+        if resp.status_code == 200:
+            return resp.json()
+        else:
+            logger.warning(f"HF call {model} status {resp.status_code} attempt {attempt}: {resp.text}")
+            time.sleep(1 + attempt)
+    raise Exception(f"Hugging Face API failed for {model}: {resp.status_code} {resp.text}")
+
+# -------------------------
+# Embeddings
+# -------------------------
+def get_embeddings(model, text):
+    """
+    Calls HF feature-extraction to get embeddings for a single text.
+    Returns 1D list of floats.
+    """
+    payload = {"inputs": text}
+    out = hf_post(model, payload)
+
+    if isinstance(out, list):
+        candidate = out[0]
+        if candidate and isinstance(candidate[0], list):
+            # Average token embeddings
+            import numpy as np
+            arr = np.array(candidate)
+            vec = arr.mean(axis=0).tolist()
+            return vec
+        elif candidate and isinstance(candidate[0], (float, int)):
+            return candidate
+    raise Exception("Unexpected HF embeddings response format")
+
+# -------------------------
+# Cross Encoder
+# -------------------------
+def get_cross_encoder_score(model, student, teacher):
+    """
+    Try different input formats to obtain a similarity/score between student and teacher.
+    Returns float between 0 and 1 (or raises).
+    """
+    try:
+        payload = {"inputs": [student, teacher]}
+        out = hf_post(model, payload)
+        if isinstance(out, list) and len(out) and isinstance(out[0], dict) and "score" in out[0]:
+            return float(out[0]["score"])
+        if isinstance(out, list) and len(out) and isinstance(out[0], (float, int)):
+            return float(out[0])
+    except Exception:
+        logger.exception("Format [student, teacher] failed")
+
+    try:
+        payload = {"inputs": {"text_pair": [student, teacher]}}
+        out = hf_post(model, payload)
+        if isinstance(out, dict) and "score" in out:
+            return float(out["score"])
+    except Exception:
+        logger.exception("Format text_pair failed")
+
+    try:
+        payload = {"inputs": f"{student}\n\n===\n\n{teacher}"}
+        out = hf_post(model, payload)
+        if isinstance(out, list) and len(out) and isinstance(out[0], dict) and "score" in out[0]:
+            top = max(out, key=lambda x: x.get("score", 0.0))
+            return float(top.get("score", 0.0))
+    except Exception:
+        logger.exception("Concatenation fallback failed")
+
+    raise Exception("Unable to parse cross-encoder output")
+
+# -------------------------
+# Feedback Generation
+# -------------------------
+def generate_feedback(question, answer, score, model="meta-llama/Llama-3.2-1B-Instruct:novita"):
+    try:
+        client = OpenAI(
+            base_url="https://router.huggingface.co/v1",
+            api_key=os.getenv("HF_API_KEY", "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"),
+        )
+        completion = client.chat.completions.create(
+                            model=model,
+                            messages=[
+                                {
+                                    "role": "user",
+                                    "content": f"""
+                        You are an educational assistant. Your task is to help students improve their understanding.
+                        Given a question, a student’s answer, and the score, generate constructive, encouraging feedback.
+
+                        Follow this format:
+                        Positive: <what the student did well>
+                        Improvement: <what is missing or could be improved>
+                        Suggestion: <what to study or focus on next>
+
+                        Question: {question}
+                        Student Answer: {answer}
+                        Score: {score}/100
+                        """
+                                }
+                            ],
+                        )
+
+        return completion.choices[0].message.content.strip()
+    except Exception as e:
+        print("error", e)
+        logger.warning(f"Feedback generation failed: {e}")
+        return f"Good attempt! You scored {score}/100."

static/style.css

@@ -0,0 +1,6 @@
+/* style.css (mostly for elements not styled by Tailwind or for overrides) */
+
+/* The flashes classes are now handled directly in base.html using Tailwind's utility classes. */
+/* The body and nav styles are also handled by Tailwind in base.html. */
+
+/* Keeping it almost empty as Tailwind is doing the heavy lifting */

templates/base.html

@@ -0,0 +1,42 @@
+<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <title>{{ title or "Assessment" }}</title>
+  <script src="https://cdn.tailwindcss.com"></script>
+  <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
+</head>
+<body class="bg-gray-50 min-h-screen">
+  <nav class="bg-white shadow-md p-4 flex justify-between items-center">
+    <a href="{{ url_for('home') }}" class="text-xl font-bold text-indigo-600 hover:text-indigo-800 transition duration-300">Assessment Platform</a>
+    <div class="flex items-center space-x-4">
+      {% if session.user %}
+        <span class="text-gray-600 font-medium">Welcome, {{ session.user.name }}</span>
+        <a href="{{ url_for('test.dashboard') }}" class="text-gray-600 hover:text-indigo-600 font-medium transition duration-300">Dashboard</a>
+        <a href="{{ url_for('auth.logout') }}" class="px-3 py-1 bg-red-500 text-white rounded-md hover:bg-red-600 transition duration-300">Logout</a>
+      {% else %}
+        <a href="{{ url_for('auth.login') }}" class="text-gray-600 hover:text-indigo-600 font-medium transition duration-300">Login</a>
+        <a href="{{ url_for('auth.signup') }}" class="px-3 py-1 bg-indigo-600 text-white rounded-md hover:bg-indigo-700 transition duration-300">Signup</a>
+      {% endif %}
+    </div>
+  </nav>
+
+  <main class="container mx-auto mt-8 p-4">
+    {# Flash Messages with Tailwind classes #}
+    {% with messages = get_flashed_messages(with_categories=true) %}
+      {% if messages %}
+        <ul class="mb-6 space-y-2">
+        {% for category, msg in messages %}
+          {% set color_class = 'bg-green-100 border-green-400 text-green-700' if category == 'success' else 'bg-red-100 border-red-400 text-red-700' %}
+          <li class="{{ color_class }} border-l-4 p-4 rounded-md font-medium" role="alert">
+            {{ msg }}
+          </li>
+        {% endfor %}
+        </ul>
+      {% endif %}
+    {% endwith %}
+
+    {% block content %}{% endblock %}
+  </main>
+</body>
+</html>

templates/dashboard.html

@@ -0,0 +1,22 @@
+{% extends "base.html" %}
+{% block content %}
+<div class="bg-white p-6 rounded-lg shadow-xl">
+  <h2 class="text-3xl font-extrabold text-gray-800 mb-4 border-b pb-2">Dashboard — {{ user.name }}</h2>
+  <h3 class="text-2xl font-semibold text-gray-700 mt-6 mb-4">Your Test Results</h3>
+  
+  <ul class="space-y-4">
+    {# The key change is here: sorting 'results' by 'timestamp' in reverse (descending) order #}
+    {% for r in results | sort(attribute='timestamp', reverse=True) %}
+      <li class="p-4 bg-gray-50 rounded-lg border border-gray-200 hover:shadow-md transition duration-300 flex justify-between items-center">
+        <div class="flex-grow">
+          <span class="font-bold text-indigo-600">Test: {{ r.test_id }}</span>
+          <span class="ml-4 text-gray-600">Score: <span class="font-extrabold text-xl">{{ r.total_score }}</span></span>
+        </div>
+        <span class="text-sm text-gray-500">{{ r.timestamp }}</span>
+      </li>
+    {% else %}
+      <li class="p-4 text-gray-500 italic bg-gray-100 rounded-lg">No results yet. Start a test today!</li>
+    {% endfor %}
+  </ul>
+</div>
+{% endblock %}

templates/home.html

@@ -0,0 +1,22 @@
+{% extends "base.html" %}
+{% block content %}
+<div class="bg-white p-6 rounded-lg shadow-xl">
+  <h1 class="text-3xl font-extrabold text-gray-800 mb-6">Available Tests</h1>
+  
+  <ul class="space-y-4">
+    {% for t in tests %}
+      <li class="p-5 bg-gray-50 rounded-lg border border-gray-200 shadow-sm flex flex-col sm:flex-row justify-between items-start sm:items-center hover:bg-gray-100 transition duration-300">
+        <div class="mb-2 sm:mb-0">
+          <strong class="text-xl font-semibold text-indigo-700">{{ t.title }}</strong>
+          <p class="text-gray-600 mt-1">{{ t.description or 'No description provided.' }}</p>
+        </div>
+        <a href="{{ url_for('test.start', test_id=t.id) }}" class="px-4 py-2 bg-green-500 text-white font-medium rounded-md shadow-md hover:bg-green-600 transition duration-300 whitespace-nowrap">
+          Take test
+        </a>
+      </li>
+    {% else %}
+      <li class="p-4 text-gray-500 italic bg-gray-100 rounded-lg">No tests available yet. Please check back later!</li>
+    {% endfor %}
+  </ul>
+</div>
+{% endblock %}

templates/login.html

@@ -0,0 +1,25 @@
+{% extends "base.html" %}
+{% block content %}
+<div class="max-w-md mx-auto bg-white p-8 rounded-xl shadow-2xl">
+  <h2 class="text-3xl font-extrabold text-gray-800 mb-6 text-center">Login</h2>
+  <form method="post" class="space-y-6">
+    <div>
+      <label for="email" class="block text-sm font-medium text-gray-700 mb-1">Email</label>
+      <input id="email" name="email" type="email" required 
+             class="w-full px-4 py-2 border border-gray-300 rounded-lg focus:ring-indigo-500 focus:border-indigo-500 transition duration-150" 
+             placeholder="you@example.com" />
+    </div>
+    
+    <div>
+      <label for="password" class="block text-sm font-medium text-gray-700 mb-1">Password</label>
+      <input id="password" name="password" type="password" required 
+             class="w-full px-4 py-2 border border-gray-300 rounded-lg focus:ring-indigo-500 focus:border-indigo-500 transition duration-150" 
+             placeholder="••••••••" />
+    </div>
+    
+    <button type="submit" class="w-full flex justify-center py-3 px-4 border border-transparent rounded-lg shadow-sm text-lg font-medium text-white bg-indigo-600 hover:bg-indigo-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500 transition duration-300">
+      Login
+    </button>
+  </form>
+</div>
+{% endblock %}

templates/signup.html

@@ -0,0 +1,32 @@
+{% extends "base.html" %}
+{% block content %}
+<div class="max-w-md mx-auto bg-white p-8 rounded-xl shadow-2xl">
+  <h2 class="text-3xl font-extrabold text-gray-800 mb-6 text-center">Signup</h2>
+  <form method="post" class="space-y-6">
+    <div>
+      <label for="name" class="block text-sm font-medium text-gray-700 mb-1">Name</label>
+      <input id="name" name="name" required 
+             class="w-full px-4 py-2 border border-gray-300 rounded-lg focus:ring-indigo-500 focus:border-indigo-500 transition duration-150" 
+             placeholder="Your Full Name" />
+    </div>
+    
+    <div>
+      <label for="email" class="block text-sm font-medium text-gray-700 mb-1">Email</label>
+      <input id="email" name="email" type="email" required 
+             class="w-full px-4 py-2 border border-gray-300 rounded-lg focus:ring-indigo-500 focus:border-indigo-500 transition duration-150" 
+             placeholder="you@example.com" />
+    </div>
+    
+    <div>
+      <label for="password" class="block text-sm font-medium text-gray-700 mb-1">Password</label>
+      <input id="password" name="password" type="password" required 
+             class="w-full px-4 py-2 border border-gray-300 rounded-lg focus:ring-indigo-500 focus:border-indigo-500 transition duration-150" 
+             placeholder="Create a strong password" />
+    </div>
+    
+    <button type="submit" class="w-full flex justify-center py-3 px-4 border border-transparent rounded-lg shadow-sm text-lg font-medium text-white bg-indigo-600 hover:bg-indigo-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500 transition duration-300">
+      Signup
+    </button>
+  </form>
+</div>
+{% endblock %}

templates/test_question.html

@@ -0,0 +1,27 @@
+{% extends "base.html" %}
+{% block content %}
+<div class="bg-white p-8 rounded-xl shadow-2xl max-w-2xl mx-auto">
+  <h2 class="text-2xl font-extrabold text-gray-700 mb-4">Question <span class="text-indigo-600">{{ index }}</span> / {{ total }}</h2>
+  
+  <div class="bg-indigo-50 p-6 rounded-lg border-l-4 border-indigo-500 mb-6">
+    <p class="text-xl font-semibold text-gray-800">{{ question.text }}</p>
+  </div>
+  
+  <form method="post" class="space-y-4">
+    <input type="hidden" name="qid" value="{{ question.id }}" />
+    
+    <div>
+      <label for="answer" class="block text-sm font-medium text-gray-700 mb-1">Your Descriptive Answer:</label>
+      <textarea id="answer" name="answer" rows="8" required 
+                class="w-full p-3 border border-gray-300 rounded-lg focus:ring-indigo-500 focus:border-indigo-500 transition duration-150" 
+                placeholder="Write your descriptive answer here..."></textarea>
+    </div>
+    
+    <div class="pt-4">
+      <button type="submit" class="w-full sm:w-auto px-6 py-3 bg-indigo-600 text-white font-semibold rounded-lg shadow-md hover:bg-indigo-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500 transition duration-300">
+        Submit & Next
+      </button>
+    </div>
+  </form>
+</div>
+{% endblock %}