Update app_prince.py

app_prince.py

@@ -1,942 +1,169 @@
-import uuid
-from collections import Counter
-import pickle
-from typing import Tuple
-from flask import Flask, request, jsonify, Response
-from flask_cors import CORS
-import os
-import json
-from datetime import datetime
-import random
-# from gradio_api import call_layoutlm_api
-from gradio_api_prince import call_yolo_api
-
-"""
-===========================================================
-
-
-MODEL OPTIONS
-
-
-===========================================================
-"""
-app = Flask(__name__)
-CORS(app)
-
-from collections import OrderedDict
-
-"""
-====================================================================
-
-Helper Functions
-
-====================================================================
-"""
-
-from vector_db_prince import store_mcqs, fetch_mcqs, fetch_random_mcqs, store_test_session, fetch_test_by_testId, \
-    test_sessions_by_userId, store_submitted_test, submitted_tests_by_userId, add_single_question, \
-    update_single_question, delete_single_question, store_mcqs_for_manual_creation, delete_mcq_bank, \
-    delete_submitted_test_by_id, delete_test_session_by_id, update_test_session, update_question_bank_metadata, \
-    fetch_submitted_test_by_testId, delete_submitted_test_attempt, update_answer_flag_in_qdrant
-from werkzeug.utils import secure_filename
-
-
-def format_mcq(mcq):
-    return {
-        "question": mcq.get("question") or mcq.get("ques") or mcq.get("q"),
-        "noise": mcq.get("noise"),
-        "image": mcq.get("image") or mcq.get("img"),
-        "options": mcq.get("options") or mcq.get("opts"),
-        "answer": mcq.get("answer") or mcq.get("ans") or mcq.get("correct")
-    }
-# ===================================================
-# uncomment the text below to use gemini pipeline instead of the pre-trained model
-# ===================================================
-
-class Vocab:
-    """Vocabulary class for serialization and lookup."""
-
-    def __init__(self, min_freq=1, unk_token="<UNK>", pad_token="<PAD>"):
-        self.min_freq = min_freq
-        self.unk_token = unk_token
-        self.pad_token = pad_token
-        self.freq = Counter()
-        self.itos = []
-        self.stoi = {}
-
-    def __len__(self):
-        return len(self.itos)
-
-    def __getitem__(self, token: str) -> int:
-        """Allows lookup using word_vocab[token]. Returns UNK index if token is not found."""
-        # Returns the index of the token, or the index of <UNK> if not found.
-        return self.stoi.get(token, self.stoi[self.unk_token])
-
-    # Methods for pickle serialization
-    def __getstate__(self):
-        return {
-            'min_freq': self.min_freq,
-            'unk_token': self.unk_token,
-            'pad_token': self.pad_token,
-            'itos': self.itos,
-            'stoi': self.stoi,
-        }
-
-    def __setstate__(self, state):
-        self.min_freq = state['min_freq']
-        self.unk_token = state['unk_token']
-        self.pad_token = state['pad_token']
-        self.itos = state['itos']
-        self.stoi = state['stoi']
-        self.freq = Counter()
-
-
-def load_vocabs(path: str) -> Tuple[Vocab, Vocab]:
-    """Loads word and character vocabularies from a pickle file."""
-    try:
-        with open(path, "rb") as f:
-            word_vocab, char_vocab = pickle.load(f)
-
-        if len(word_vocab) <= 2 or len(char_vocab) <= 2:
-            raise IndexError("Vocabulary file loaded but sizes are suspiciously small.")
-
-        return word_vocab, char_vocab
-    except FileNotFoundError:
-        raise FileNotFoundError(f"Vocab file not found at {path}. Please check the path.")
-    except Exception as e:
-        raise RuntimeError(f"Error loading vocabs from {path}: {e}")
-
-
-UPLOAD_FOLDER = "/tmp"
-os.makedirs(UPLOAD_FOLDER, exist_ok=True)
-
-
-# ==============================
-#
-# API
-#
-# ===============================
-
-@app.route("/create_question_bank", methods=["POST"])
-def upload_pdf():
-    print("\n[START] /create_question_bank request received")
-
-    # 1. Validate inputs
-    user_id = request.form.get("userId")
-    title = request.form.get("title")
-    description = request.form.get("description")
-    pdf_file = request.files.get("pdf")
-
-    print(f"[INFO] Received form-data: userId={user_id}, title={title}, description={description}")
-    if not pdf_file:
-        return jsonify({"error": "PDF file not provided"}), 400
-
-    if not all([user_id, title, description]):
-        return jsonify({"error": "userId, title, description are required"}), 400
-
-    # 2. Keep PDF in memory (no Drive)
-    print("[STEP] Reading PDF into memory...")
-    pdf_bytes = pdf_file.read()
-    pdf_name = secure_filename(pdf_file.filename)
-
-    # 3. Directly call model
-    print("[STEP] Calling LayoutLM model directly (no Drive)...")
-    # final_data = call_layoutlm_api(pdf_bytes, pdf_name)
-    final_data = call_yolo_api(pdf_bytes, pdf_name)
-    print(f"[SUCCESS] LayoutLM returned {len(final_data)} MCQs")
-
-    # 4. Add index to MCQs
-    indexed_mcqs = [
-        {
-            **mcq,
-            "documentIndex": i,
-            "questionId": str(uuid.uuid4())  # ✅ assign unique ID
-        }
-        for i, mcq in enumerate(final_data)
-    ]
-
-    # 5. Store in vector DB
-    print("[STEP] Storing Question Bank in vector database...")
-    createdAtTimestamp = datetime.now().isoformat()
-    stored_id, all_have_answers = store_mcqs(
-        user_id, title, description, indexed_mcqs, pdf_name, createdAtTimestamp
-    )
-    print(f"[SUCCESS] Stored with generatedQAId={stored_id}")
-
-    print("[END] Request complete\n")
-    return Response(
-        json.dumps({
-            "generatedQAId": stored_id,
-            "userId": user_id,
-            "fileName": pdf_name,
-            "createdAt": createdAtTimestamp,
-            "answerFound": all_have_answers
-        }, ensure_ascii=False),
-        mimetype="application/json"
-    )
-
-
-@app.route("/create_question_bank_image", methods=["POST"])
-def upload_image():
-    print("\n[START] /create_question_bank request received")
-
-    # 1. Validate inputs
-    user_id = request.form.get("userId")
-    title = request.form.get("title")
-    description = request.form.get("description")
-    image_files = request.files.getlist("image")  # ✅ multiple images
-
-    print(f"[INFO] Received form-data: userId={user_id}, title={title}, description={description}")
-    if not image_files or len(image_files) == 0:
-        return jsonify({"error": "No image file(s) provided"}), 400
-
-    if not all([user_id, title, description]):
-        return jsonify({"error": "userId, title, description are required"}), 400
-
-    all_results = []
-
-    # 2. Loop through each image
-    for idx, img_file in enumerate(image_files, start=1):
-        print(f"[STEP] Reading image {idx}/{len(image_files)} into memory...")
-        file_bytes = img_file.read()
-        filename = secure_filename(img_file.filename)
-
-        # 3. Directly call model for each image
-        print(f"[STEP] Calling LayoutLM model for {filename} ...")
-        try:
-            result = call_yolo_api(file_bytes, filename)
-            print(f"[SUCCESS] Model returned result for {filename}")
-            if isinstance(result, list):
-                all_results.extend(result)
-            else:
-                all_results.append(result)
-        except Exception as e:
-            print(f"[ERROR] Failed on {filename}: {e}")
-
-    # 4. Add index to MCQs
-    indexed_mcqs = [
-        {**mcq, "documentIndex": i}
-        for i, mcq in enumerate(all_results)
-    ]
-
-    # 5. Store in vector DB
-    print("[STEP] Storing Question Bank in vector database...")
-    createdAtTimestamp = datetime.now().isoformat()
-    stored_id = store_mcqs(
-        user_id, title, description, indexed_mcqs, "multiple_images.zip", createdAtTimestamp
-    )
-    print(f"[SUCCESS] Stored with generatedQAId={stored_id}")
-
-    print("[END] Request complete\n")
-    return Response(
-        json.dumps({
-            "generatedQAId": stored_id,
-            "userId": user_id,
-            "fileCount": len(image_files),
-            "createdAt": createdAtTimestamp,
-        }, ensure_ascii=False),
-        mimetype="application/json"
-    )
-@app.route("/question_bank_by_user", methods=["POST"])
-def paper_sets_by_userID():
-    data = request.get_json(silent=True) or request.form.to_dict()
-    userId = data.get("userId")
-
-    mcqs_data = fetch_mcqs(userId=userId)
-    if not mcqs_data:
-        return jsonify({"message": "No Paper Sets found"})
-
-    # FIX: Iterate through each paper set and sort its MCQs list
-    for paper_set in mcqs_data:
-        # Check if the 'mcqs' list exists and is iterable
-        if paper_set.get('metadata', {}).get('mcqs'):
-            mcqs_list = paper_set['metadata']['mcqs']
-
-            # This handles older data that might have missing or None 'documentIndex' values.
-            paper_set['metadata']['mcqs'] = sorted(
-                mcqs_list,
-                key=lambda x: int(x['documentIndex'])
-                if x.get('documentIndex') is not None else float('inf')
-            )
-            # ===============================================
-
-    return Response(
-        json.dumps(mcqs_data, ensure_ascii=False, indent=4),
-        mimetype="application/json"
-    )
-@app.route("/question_bank_by_id", methods=["POST"])
-def paper_sets_by_generatedQAId():
-    data = request.get_json(silent=True) or request.form.to_dict()
-    generatedQAId = data.get("generatedQAId")
-
-    if not generatedQAId:
-        return jsonify({"error": "generatedQAId is required"}), 400
-
-    results = fetch_mcqs(generatedQAId=generatedQAId)
-
-    if not results:
-        return jsonify({"error": "No MCQs found for the provided ID"}), 200
-
-    if results and results[0].get('metadata', {}).get('mcqs'):
-        mcqs_list = results[0]['metadata']['mcqs']
-        # Sort by the 'documentIndex' field.
-        # Fall back to 0 if the index is missing, though it shouldn't be.
-        results[0]['metadata']['mcqs'] = sorted(
-            mcqs_list,
-            key=lambda x: x.get('documentIndex', 0)
-        )
-    # ===============================================
-    # Return the full list of results, as generated by fetch_mcqs
-    return jsonify(results)
-
-
-@app.route("/generate_test", methods=["POST"])
-def generate_test():
-    """
-    API to fetch MCQs by generated-qa-Id and marks (limit),
-    and also to create a new test entry.
-    """
-    data = request.get_json(silent=True) or request.form
-
-    generatedQAId = data.get("generatedQAId")
-    marks = data.get("marks")
-    userId = data.get("userId")
-    testTitle = data.get("testTitle")
-    totalTime = data.get("totalTime")
-
-    if not generatedQAId:
-        return jsonify({"error": "generatedQAId is required"}), 400
-    # ... (other validation checks)
-
-    try:
-        marks = int(marks)
-    except ValueError:
-        return jsonify({"error": "marks must be an integer"}), 400
-
-    testId = str(uuid.uuid4())
-    createdAt = datetime.now().isoformat()
-
-    # 1. Fetch random sample
-    test_data_results = fetch_random_mcqs(generatedQAId, num_questions=marks)
-
-    if not test_data_results:
-        return jsonify({"message": "No MCQs found"}), 200
-
-    mcqs_data = test_data_results[0].get("metadata", {}).get("mcqs", [])
-
-    # The list mcqs_data is now in the final, random order for the test.
-
-    # 2. ASSIGN NEW SEQUENTIAL INDEX (testIndex)
-    final_mcqs_for_storage = []
-    for i, mcq in enumerate(mcqs_data):
-        # Assign a sequential index starting from 1 for the client/storage
-        mcq['testIndex'] = i + 1
-        final_mcqs_for_storage.append(mcq)
-
-    # 3. Store the session using the indexed list
-    if userId:
-        is_stored = store_test_session(userId, testId, testTitle, totalTime, createdAt, final_mcqs_for_storage)
-        if not is_stored:
-            return jsonify({"error": "Failed to store test session"}), 500
-
-    # 4. Return the result
-    return jsonify({
-        "message": "Test created and stored successfully",
-        "userId": userId,
-        "testId": testId,
-        "totalTime": totalTime,
-        "createdAt": createdAt,
-        "questions": final_mcqs_for_storage  # Return the indexed list
-    }), 200
-
-
-@app.route("/combined_paperset", methods=["POST"])
-def combined_test():
-    data = request.get_json(silent=True) or request.form
-
-    userId = data.get("userId")
-    testTitle = data.get("testTitle")
-    totalTime = data.get("totalTime")
-    total_questions = data.get("total_questions")
-    sources = data.get("sources")
-
-    # Validate required inputs
-    if not all([userId, testTitle, totalTime, total_questions, sources]) or not isinstance(sources, list):
-        return jsonify(
-            {"error": "userId, testTitle, total_questions, totalTime, and a list of sources are required"}), 400
-
-    try:
-        total_questions = int(total_questions)
-        if sum(s.get("percentage", 0) for s in sources) != 100:
-            return jsonify({"error": "Percentages must sum to 100"}), 400
-    except (ValueError, TypeError):
-        return jsonify({"error": "total_questions must be an integer and percentages must be numbers"}), 400
-
-    all_mcqs = []
-
-    for source in sources:
-        qa_id = source.get("generatedQAId")
-        percentage = source.get("percentage")
-
-        if not qa_id or not percentage:
-            return jsonify({"error": "Each source must have 'generatedQAId' and 'percentage'"}), 400
-
-        # Calculate the number of questions for this source
-        num_questions = round(total_questions * (percentage / 100))
-
-        # Fetch a random sample from this source
-        # Note: fetch_random_mcqs returns a list containing a dict with metadata/mcqs
-        mcqs_record = fetch_random_mcqs(generatedQAId=qa_id, num_questions=num_questions)
-
-        if mcqs_record:
-            # Extract the list of questions and combine them
-            all_mcqs.extend(mcqs_record[0].get("metadata", {}).get("mcqs", []))
-
-    # Shuffle the combined list of all MCQs to finalize the test order
-    random.shuffle(all_mcqs)
-
-    if not all_mcqs:
-        return jsonify({"message": "No MCQs found for the provided IDs"}), 200
-
-    # Assign a new, sequential index (testIndex) to each question
-    final_mcqs_for_storage = []
-    for i, mcq in enumerate(all_mcqs):
-        # Assign a sequential index starting from 1
-        mcq['testIndex'] = i + 1
-        final_mcqs_for_storage.append(mcq)
-
-    # Generate test metadata
-    testId = str(uuid.uuid4())
-    createdAt = datetime.now().isoformat()
-
-    # Store the test session with the indexed list
-    store_test_session(userId, testId, testTitle, totalTime, createdAt, final_mcqs_for_storage)
-
-    return jsonify({
-        "userId": userId,
-        "testId": testId,
-        "testTitle": testTitle,
-        "totalTime": totalTime,
-        "createdAt": createdAt,
-        "questions": final_mcqs_for_storage  # Return the correctly indexed list
-    }), 200
-
-
-@app.route("/paper_set/<testId>", methods=["GET"])
-def testId(testId):
-    """
-
-    API to fetch a specific test session by its ID.
-    """
-    test_data = fetch_test_by_testId(testId)
-    if not test_data:
-        return jsonify({"error": "Test  not found"}), 200
-    for q in test_data.get("questions", []):
-        q.pop("answer", None)
-
-    return jsonify(test_data), 200
-
-
-@app.route("/paper_sets_by_user/<userId>", methods=["GET"])
-def test_history_by_userId(userId):
-    test_history = test_sessions_by_userId(userId)
-    if not test_history:
-        return jsonify({"message": "No test sessions found"}), 200
-
-    # remove answers before sending to frontend
-    for test in test_history:
-        for q in test.get("questions", []):
-            q.pop("answer", None)  # removes if present
-
-    return jsonify(test_history), 200
-
-
-@app.route("/submit_test", methods=["POST"])
-def submit_test():
-    """
-    API to submit student answers, check correctness,
-    calculate score, and store submission data.
-    Frontend sends: userId, testId, testTitle, timeSpent, totalTime, answers[]
-    """
-    data = request.get_json(silent=True) or {}
-
-    userId = data.get("userId")
-    testId = data.get("testId")
-    testTitle = data.get("testTitle")
-    timeSpent = data.get("timeSpent")
-    totalTime = data.get("totalTime")
-    answers = data.get("answers")
-
-    if not all([userId, testId, answers]):
-        return jsonify({"error": "Missing required fields: userId, testId, answers"}), 400
-    if not isinstance(answers, list):
-        return jsonify({"error": "Answers must be a list"}), 400
-
-    submittedAt = datetime.now().isoformat()
-
-    # 🧠 Fetch original test data (includes correct answers)
-    test_data = fetch_test_by_testId(testId)
-    if not test_data:
-        return jsonify({"error": "Test not found"}), 404
-
-    questions = test_data.get("questions", [])
-    if isinstance(questions, str):
-        try:
-            questions = json.loads(questions)
-        except Exception:
-            questions = []
-
-    # Build quick lookup of correct answers
-    correct_map = {q.get("questionId"): q.get("answer") for q in questions}
-
-    totalQuestions = len(correct_map)
-    total_correct = 0
-    results = []
-
-    # ✅ Compare each submitted answer
-    for ans in answers:
-        qid = ans.get("questionId")
-        qtext = ans.get("question")
-        user_ans = ans.get("your_answer")
-
-        # Try to get correct answer using questionId first, then question text
-        correct_ans = None
-        if qid and qid in correct_map:
-            correct_ans = correct_map.get(qid)
-        elif qtext:
-            for q in questions:
-                if qtext.strip().lower() == q.get("question", "").strip().lower():
-                    correct_ans = q.get("answer")
-                    qid = q.get("questionId")
-                    break
-
-        is_correct = (user_ans == correct_ans)
-
-        if is_correct:
-            total_correct += 1
-
-        results.append(OrderedDict([
-            ("questionId", qid),
-            ("your_answer", user_ans),
-            ("correct_answer", correct_ans),
-            ("is_correct", is_correct)
-        ]))
-
-    # 🧮 Calculate score
-    score = round((total_correct / totalQuestions) * 100, 2) if totalQuestions > 0 else 0.0
-
-    # 💾 Store submission attempt in Qdrant or DB
-    is_stored, attemptId = store_submitted_test(
-        userId=userId,
-        testId=testId,
-        testTitle=testTitle,
-        timeSpent=timeSpent,
-        totalTime=totalTime,
-        submittedAt=submittedAt,
-        detailed_results=results,
-        score=score,
-        total_questions=totalQuestions,
-        total_correct=total_correct
-    )
-
-    if not is_stored:
-        return jsonify({"error": "Failed to store submission"}), 500
-
-    # 📦 Final response
-    response = OrderedDict([
-        ("attemptId", attemptId),
-        ("userId", userId),
-        ("testId", testId),
-        ("testTitle", testTitle),
-        ("submittedAt", submittedAt),
-        ("timeSpent", timeSpent),
-        ("total_questions", totalQuestions),
-        ("total_correct", total_correct),
-        ("score", score),
-        ("detailed_results", results)
-    ])
-
-    return jsonify(response)
-
-@app.route("/submitted_tests/<userId>", methods=["GET"])
-def submitted_tests_history(userId):
-    """
-    API to fetch a list of all submitted test sessions for a given user.
-    """
-    if not userId:
-        return jsonify({"error": "userId is required"}), 400
-
-    submitted_tests = submitted_tests_by_userId(userId)
-
-    if submitted_tests is None:
-        return jsonify({"error": "An error occurred while fetching submitted tests"}), 500
-
-    if not submitted_tests:
-        return jsonify({"message": "No submitted tests found for this user"}), 200
-
-    return jsonify(submitted_tests), 200
-
-
-@app.route("/submitted_test/<testId>", methods=["GET"])
-def get_single_submitted_test(testId):
-    """
-    Fetch details of one submitted test by testId.
-    """
-    if not testId:
-        return jsonify({"error": "testId is required"}), 400
-
-    result = fetch_submitted_test_by_testId(testId)
-
-    if not result:
-        return jsonify({"message": "No submitted test found"}), 404
-
-    return jsonify(result), 200
-
-
-@app.route("/question_bank/<generatedQAId>", methods=["PUT"])
-def edit_question_bank(generatedQAId):
-    """
-    Unified API to perform add, edit, or delete operations on questions,
-    and update the question bank's Title and Description.
-
-    Accepts both:
-    1. {
-          "title": "English Test",
-          "description": "Updated chapter 1 test",
-          "edits": [ { "operation": "edit", "data": {...}} ]
-       }
-    2. [ { "operation": "edit", "data": {...}} ]  ← Legacy (frontend-only edits)
-    """
-
-    # Step 1: Parse request JSON
-    payload = request.get_json(silent=True) or {}
-
-    # Handle both dict and list payloads
-    if isinstance(payload, list):
-        edits = payload
-        new_title = None
-        new_description = None
-    else:
-        edits = payload.get("edits")
-        new_title = payload.get("title")
-        new_description = payload.get("description")
-
-    metadata_update_status = {
-        "title_updated": False,
-        "description_updated": False,
-        "success": True
-    }
-
-    # --- Step 2: Update Metadata (Title / Description) ---
-    try:
-        if new_title is not None or new_description is not None:
-            metadata_update_status = update_question_bank_metadata(
-                generatedQAId=generatedQAId,
-                title=new_title,
-                description=new_description
-            )
-
-            # Handle metadata update failure
-            if not metadata_update_status.get("success", True):
-                return jsonify({
-                    "error": f"Failed to update metadata for Question Bank ID: {generatedQAId}"
-                }), 500
-    except Exception as e:
-        print(f"[ERROR] Metadata update failed: {str(e)}")
-        metadata_update_status["success"] = False
-
-    # --- Step 3: Process Question-Level Edits ---
-    if edits and isinstance(edits, list):
-        for edit in edits:
-            try:
-                operation = edit.get("operation")
-                data = edit.get("data")
-
-                if not operation or not data:
-                    continue
-
-                if operation == "add":
-                    add_single_question(generatedQAId, data)
-
-                elif operation == "edit":
-                    questionId = data.get("questionId")
-                    if questionId:
-                        update_single_question(questionId, data)
-
-                elif operation == "delete":
-                    questionId = data.get("questionId")
-                    if questionId:
-                        delete_single_question(questionId)
-
-                else:
-                    print(f"[WARN] Unknown operation '{operation}' ignored.")
-
-            except Exception as e:
-                print(f"[ERROR] Failed to process edit operation: {str(e)}")
-                continue
-
-    # --- Step 4: Fetch Updated Data for Response ---
-    try:
-        updated_data = fetch_mcqs(generatedQAId=generatedQAId)
-    except Exception as e:
-        print(f"[ERROR] Failed to fetch updated question bank: {str(e)}")
-        updated_data = None
-
-    if not updated_data:
-        return jsonify({
-            "error": "Update processed, but the question bank was not found.",
-            "generatedQAId_used": generatedQAId
-        }), 404
-
-        # ✅ --- Step 5: Compute answerFound flag ---
-    mcqs = updated_data[0]["metadata"].get("mcqs", [])
-    all_have_answers = True
-    for q in mcqs:
-        ans = q.get("answer")
-        if not (ans and str(ans).strip()):
-            all_have_answers = False
-            break
-
-    # ✅ --- Step 6: Update Qdrant MCQ bank with answerFound flag ---
-    update_answer_flag_in_qdrant(generatedQAId, all_have_answers)
-
-    updated_questions_count = len(mcqs)
-
-    # ✅ --- Step 7: Return Success Response ---
-    return jsonify({
-        "message": "Question bank updated successfully",
-        "title_updated": metadata_update_status.get("title_updated", False),
-        "description_updated": metadata_update_status.get("description_updated", False),
-        "updated_questions_count": updated_questions_count,
-        "answerFound": all_have_answers
-    }), 200
-
-
-@app.route("/create_manual_question_bank", methods=["POST"])
-def create_manual_question_bank():
-    """
-    API to create a new question bank and populate it with a list of questions
-    in a single request for a smoother user experience.
-    """
-    data = request.get_json(silent=True) or request.form.to_dict()
-    user_id = data.get("userId")
-    title = data.get("title")
-    description = data.get("description")
-    raw_mcqs = data.get("questions", [])  # Expects a list of question objects
-
-    if not all([user_id, title, description]) or not isinstance(raw_mcqs, list):
-        return jsonify({"error": "userId, title, description, and a list of 'questions' are required"}), 400
-
-    if not raw_mcqs:
-        return jsonify({"error": "Question bank must contain at least one question."}), 400
-
-    indexed_mcqs = []
-
-    # 1. Format and Index MCQs (similar to your upload_pdf route logic)
-    for i, mcq in enumerate(raw_mcqs):
-        # Ensure options are properly formatted (if they come as a dict from the client)
-        if 'options' in mcq and isinstance(mcq['options'], dict):
-            # We need to ensure the options are stored as a JSON string
-            # as required by the ChromaDB metadata constraint (as discovered earlier).
-            mcq['options'] = json.dumps(mcq['options'])
-
-        # NOTE: If your database requires questionId/documentIndex, they must be set here.
-        # However, we will assume 'store_mcqs_for_manual_creation' handles questionId and documentIndex assignment.
-        mcq['documentIndex'] = i
-        mcq['questionId'] = str(uuid.uuid4())
-        indexed_mcqs.append(mcq)
-
-    # 2. Store Metadata and Questions (using a modified store function)
-    try:
-        # Create a function similar to store_mcqs but for manual data
-        generated_qa_id = store_mcqs_for_manual_creation(
-            user_id,
-            title,
-            description,
-            indexed_mcqs
-        )
-    except Exception as e:
-        print(f"Error storing manual question bank: {e}")
-        return jsonify({"error": "Failed to create and store question bank"}), 500
-
-    return jsonify({
-        "message": "Question bank created and populated successfully",
-        "generatedQAId": generated_qa_id,
-        "userId": user_id,
-        "title": title,
-        "questions_count": len(indexed_mcqs)
-    }), 201
-
-
-@app.route("/question_bank/<generatedQAId>", methods=["DELETE"])
-def delete_question_bank(generatedQAId):
-    """
-    API to delete an entire question bank (metadata and all associated questions).
-    """
-    if not generatedQAId:
-        return jsonify({"error": "generatedQAId is required"}), 400
-
-    # Assume this function handles the deletion from both the main
-    # and the questions collection using the generatedQAId.
-    success = delete_mcq_bank(generatedQAId)
-
-    if success:
-        return jsonify({
-            "message": f"Question bank '{generatedQAId}' and all associated questions deleted successfully."
-        }), 200
-    else:
-        # Return 404 if the bank wasn't found to delete, or 500 on database error
-        return jsonify({
-            "error": f"Failed to delete question bank '{generatedQAId}'. It may not exist."
-        }), 200
-
-
-@app.route("/submitted_test/<testId>", methods=["DELETE"])
-def delete_submitted_test(testId):
-    """
-    API to delete a specific submitted test session result by its ID.
-    """
-    if not testId:
-        return jsonify({"error": "testId is required"}), 400
-
-    success = delete_submitted_test_by_id(testId)
-
-    if success:
-        return jsonify({
-            "message": f"Submitted test result '{testId}' deleted successfully."
-        }), 200
-    else:
-        return jsonify({
-            "error": f"Failed to delete submitted test result '{testId}'. It may not exist."
-        }), 404
-
-
-@app.route("/paper_sets/<testId>", methods=["DELETE"])
-def delete_test_session(testId):
-    """
-    API to delete a specific test session by its ID.
-    """
-    if not testId:
-        return jsonify({"error": "testId is required"}), 400
-
-    # Assume this function handles the deletion from test_sessions_collection
-    success = delete_test_session_by_id(testId)
-
-    if success:
-        return jsonify({
-            "message": f"Test '{testId}' deleted successfully."
-        }), 200
-    else:
-        return jsonify({
-            "message": f"Failed to delete '{testId}' "
-        }), 200
-
-
-@app.route("/test_attempt/<attemptId>", methods=["DELETE"])
-def delete_submitted_test_attempt_api(attemptId):
-    """
-    API to delete a specific submitted test attempt by attemptId.
-    """
-    if not attemptId:
-        return jsonify({"error": "attemptId is required"}), 400
-
-    success = delete_submitted_test_attempt(attemptId)
-    if not success:
-        return jsonify({"error": "Failed to delete attempt"}), 200
-
-    return jsonify({
-        "message": f"Attempt {attemptId} deleted successfully"
-    }), 200
-
-
-@app.route("/paper_sets/<testId>", methods=["PUT"])
-def edit_paperset(testId):
-    """
-    Update specific fields of a test session.
-    Allows partial updates for test metadata and individual questions.
-    """
-    payload = request.get_json(silent=True) or {}
-
-    if not testId:
-        return jsonify({"error": "testId is required"}), 400
-
-    # 1️⃣ Fetch existing test session
-    existing_record = fetch_test_by_testId(testId)
-    if not existing_record:
-        return jsonify({"error": f"Test session '{testId}' not found"}), 404
-
-    updated_data = existing_record.copy()
-
-    # Extract fields
-    edits = payload.get("edits", [])
-    new_title = payload.get("testTitle")
-    new_total_time = payload.get("totalTime")
-
-    # --- Step 2: Update Top-Level Fields ---
-    if new_title is not None:
-        updated_data["testTitle"] = new_title
-
-    if new_total_time is not None:
-        updated_data["totalTime"] = new_total_time
-
-    # --- Step 3: Question Operations ---
-    existing_questions = {q["questionId"]: q for q in updated_data.get("questions", [])}
-
-    for edit in edits:
-        operation = edit.get("operation")
-        data = edit.get("data")
-
-        if not operation or not data:
-            continue
-
-        # ---------- ADD ----------
-        if operation == "add":
-            qid = data.get("questionId")
-            if not qid:
-                continue
-
-            # Set default fields for new question
-            data.setdefault("documentIndex", len(existing_questions))
-            data.setdefault("testIndex", len(existing_questions) + 1)
-            data.setdefault("userId", updated_data.get("userId"))
-            data.setdefault("generatedQAId", updated_data.get("generatedQAId"))
-            data.setdefault("passage", "")
-            data.setdefault("image", None)
-            data.setdefault("noise", "")
-
-            existing_questions[qid] = data
-
-        # ---------- EDIT ----------
-        elif operation == "edit":
-            qid = data.get("questionId")
-            if qid and qid in existing_questions:
-                for key, value in data.items():
-                    existing_questions[qid][key] = value
-
-        # ---------- DELETE ----------
-        elif operation == "delete":
-            qid = data.get("questionId")
-            if qid in existing_questions:
-                del existing_questions[qid]
-
-    # Sort after update
-    updated_data["questions"] = sorted(
-        list(existing_questions.values()),
-        key=lambda q: q.get("documentIndex", 999999)
-    )
-
-    # --- Step 4: Save back ---
-    success = update_test_session(testId, updated_data)
-
-    if success:
-        return jsonify({
-            "message": "Test session updated successfully",
-            "testId": testId,
-            "updated_fields": list(payload.keys())
-        }), 200
-    else:
-        return jsonify({"error": "Failed to update test session"}), 500
-
-
-if __name__ == '__main__':
-    app.run(host="0.0.0.0", port=10000, debug=True)
+import os
+import json
+import re
+import torch
+import gradio as gr
+import google.generativeai as genai
+from sentence_transformers import SentenceTransformer, util
+
+# ============================================================
+# CONFIG
+# ============================================================
+GEMINI_API_KEY = "AIzaSyBrbLGXkSdXReb0lUucYqcNCNBkvS-RBFw"
+if not GEMINI_API_KEY:
+    raise RuntimeError("Set GEMINI_API_KEY environment variable")
+
+genai.configure(api_key=GEMINI_API_KEY)
+
+MODEL = genai.GenerativeModel("gemini-pro")
+
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+EMBED_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
+SIM_THRESHOLD = 0.55
+
+print("Loading embedding model...")
+embedder = SentenceTransformer(EMBED_MODEL, device=DEVICE)
+print("✅ Ready")
+
+# ============================================================
+# UTILS
+# ============================================================
+def split_sentences(text):
+    return [s.strip() for s in re.split(r'(?<=[.!?])\s+', text) if len(s.strip()) > 5]
+
+def gemini(prompt, max_tokens=256):
+    response = MODEL.generate_content(
+        prompt,
+        generation_config=genai.types.GenerationConfig(
+            temperature=0.0,
+            max_output_tokens=max_tokens
+        )
+    )
+    return response.text.strip()
+
+def safe_json(text):
+    try:
+        return json.loads(text)
+    except:
+        start, end = text.find("{"), text.rfind("}") + 1
+        if start != -1 and end != -1:
+            try:
+                return json.loads(text[start:end])
+            except:
+                return None
+    return None
+
+# ============================================================
+# STEP 1: INTENT
+# ============================================================
+def detect_intent(question):
+    prompt = f"""
+Classify the question intent. Choose ONE:
+FACTUAL, EXPLANATORY, CHARACTER_ARC, PROCESS, COMPARISON
+
+Question:
+{question}
+
+Output ONLY the label.
+"""
+    out = gemini(prompt, 20)
+    return out if out in {
+        "FACTUAL","EXPLANATORY","CHARACTER_ARC","PROCESS","COMPARISON"
+    } else "EXPLANATORY"
+
+# ============================================================
+# STEP 2: RUBRIC GENERATION
+# ============================================================
+def generate_rubric(kb, question, intent):
+    prompt = f"""
+You are an examiner.
+
+Using ONLY the knowledge base, create a grading rubric for the question.
+Each item must be an atomic idea a student must mention.
+
+Rules:
+- 3 to 6 criteria
+- No paraphrasing the question
+- No explanations
+- Capture progression if relevant
+- STRICT JSON ONLY
+
+Format:
+{{ "criteria": ["criterion 1", "criterion 2"] }}
+
+Knowledge Base:
+{kb}
+
+Question:
+{question}
+
+Intent:
+{intent}
+"""
+    raw = gemini(prompt, 300)
+    parsed = safe_json(raw)
+    return parsed["criteria"] if parsed and "criteria" in parsed else []
+
+# ============================================================
+# STEP 3: SEMANTIC MATCHING
+# ============================================================
+def score(answer, criteria):
+    sents = split_sentences(answer)
+    ans_emb = embedder.encode(sents, convert_to_tensor=True)
+
+    results = []
+    for crit in criteria:
+        crit_emb = embedder.encode(crit, convert_to_tensor=True)
+        sims = util.cos_sim(crit_emb, ans_emb)[0]
+        best = float(torch.max(sims)) if sims.numel() else 0.0
+
+        results.append({
+            "criterion": crit,
+            "score": round(best, 3),
+            "satisfied": best >= SIM_THRESHOLD
+        })
+    return results
+
+# ============================================================
+# FINAL VERDICT
+# ============================================================
+def verdict(scored):
+    hit = sum(c["satisfied"] for c in scored)
+    total = len(scored)
+
+    if hit == total:
+        return "✅ CORRECT"
+    if hit >= max(1, total // 2):
+        return "⚠️ PARTIALLY CORRECT"
+    return "❌ INCORRECT"
+
+# ============================================================
+# PIPELINE
+# ============================================================
+def evaluate(answer, question, kb):
+    intent = detect_intent(question)
+    rubric = generate_rubric(kb, question, intent)
+    scored = score(answer, rubric) if rubric else []
+
+    return {
+        "intent": intent,
+        "rubric": rubric,
+        "scoring": scored,
+        "final_verdict": verdict(scored) if rubric else "⚠️ NO RUBRIC"
+    }
+
+# ============================================================
+# UI
+# ============================================================
+with gr.Blocks() as demo:
+    gr.Markdown("## 🧠 Gemini-powered Answer Grader")
+
+    kb = gr.Textbox(label="Knowledge Base", lines=8)
+    q = gr.Textbox(label="Question")
+    a = gr.Textbox(label="Student Answer", lines=6)
+
+    out = gr.JSON(label="Evaluation")
+
+    gr.Button("Evaluate").click(evaluate, [a, q, kb], out)
+
+demo.launch()