PDF service deprecated

README.md

@@ -13,7 +13,6 @@ A complete GATE exam preparation platform.
 - Admin panel (users, tests, series, checklist)
 - GATE-style test interface (fullscreen, tab detection, scientific calculator)
 - MCQ, MSQ, NAT question types
-- PDF auto-extraction
 - Question images via Cloudinary
 - Timed tests with auto-submit
 - Leaderboard (first attempt only)
@@ -72,7 +71,6 @@ UPLOAD_DIR=uploads
 AUTH_COOKIE_SECURE=false
 AUTH_COOKIE_SAMESITE=lax
 
-# Cloudinary (cloudinary.com - free 25GB)
 CLOUDINARY_CLOUD_NAME=your_cloud_name
 CLOUDINARY_API_KEY=your_api_key
 CLOUDINARY_API_SECRET=your_api_secret
@@ -105,13 +103,6 @@ for remote Postgres hosts.
 3. Use the pooler URL on port `6543`.
 4. URL-encode the database password before adding it to `DATABASE_URL`.
 
-Example:
-
-```
-DATABASE_URL=postgresql+psycopg2://postgres.<project-ref>:<URL_ENCODED_PASSWORD>@aws-1-ap-south-1.pooler.supabase.com:6543/postgres?sslmode=require
-```
-
-Do not commit real passwords or secrets.
 
 ### Backend: Hugging Face Spaces
 Create a Docker Space using the repository root. The root `Dockerfile` runs the

backend/alembic/versions/710e0c970c16_remove_pdf_filename.py

@@ -0,0 +1,40 @@
+"""remove_pdf_filename
+
+Revision ID: 710e0c970c16
+Revises: c4b2f2f8e91d
+Create Date: 2026-06-16 13:32:02.174814
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision: str = "710e0c970c16"
+down_revision: Union[str, Sequence[str], None] = "c4b2f2f8e91d"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def _has_column(table_name: str, column_name: str) -> bool:
+    inspector = sa.inspect(op.get_bind())
+    return any(
+        column["name"] == column_name for column in inspector.get_columns(table_name)
+    )
+
+
+def upgrade() -> None:
+    """Drop the legacy PDF filename column from tests."""
+    if _has_column("tests", "pdf_filename"):
+        op.drop_column("tests", "pdf_filename")
+
+
+def downgrade() -> None:
+    """Restore the legacy PDF filename column."""
+    if not _has_column("tests", "pdf_filename"):
+        op.add_column(
+            "tests",
+            sa.Column("pdf_filename", sa.String(length=500), nullable=True),
+        )

backend/app/api/routes/admin.py

@@ -36,25 +36,9 @@ from app.services.answer_utils import (
     split_answer_tokens,
 )
 from app.services.cloudinary_service import delete_image, upload_image
-from app.services.pdf_service import extract_questions_from_pdf
 
 router = APIRouter(prefix="/admin", tags=["Admin"])
 
-MAX_PDF_UPLOAD_SIZE_BYTES = 1 * 1024 * 1024 * 1024
-PDF_UPLOAD_CHUNK_SIZE_BYTES = 8192
-
-PDF_IMPORT_BLOCKING_WARNINGS = {
-    "missing_question_text",
-    "missing_answer",
-    "missing_options",
-    "too_few_options",
-    "too_many_options",
-    "nat_has_non_numeric_answer",
-    "mcq_has_multiple_answers",
-    "invalid_choice_answer",
-    "ambiguous_answer_key",
-}
-
 
 def _utcnow() -> datetime:
     return datetime.now(timezone.utc)
@@ -83,64 +67,6 @@ def _parse_user_cursor(cursor: str) -> tuple[datetime, int]:
         raise HTTPException(status_code=400, detail="Invalid cursor") from exc
 
 
-async def _save_pdf_upload(pdf_file: UploadFile, path: str) -> None:
-    file_size = 0
-
-    try:
-        with open(path, "wb") as f:
-            while chunk := await pdf_file.read(PDF_UPLOAD_CHUNK_SIZE_BYTES):
-                file_size += len(chunk)
-                if file_size > MAX_PDF_UPLOAD_SIZE_BYTES:
-                    raise HTTPException(status_code=413, detail="File too large")
-                f.write(chunk)
-    except HTTPException:
-        try:
-            os.remove(path)
-        except OSError:
-            pass
-        raise
-
-
-def _pdf_blocking_warnings(question: dict) -> list[str]:
-    warnings = question.get("warnings") or []
-    return [warning for warning in warnings if warning in PDF_IMPORT_BLOCKING_WARNINGS]
-
-
-def _pdf_review_detail(questions: list[dict]) -> str:
-    blocked = []
-    review_only = []
-    for idx, question in enumerate(questions, start=1):
-        label = (
-            question.get("question_number")
-            or question.get("global_question_number")
-            or idx
-        )
-        warnings = question.get("warnings") or []
-        blocking = _pdf_blocking_warnings(question)
-        if blocking:
-            blocked.append(f"Q{label}: {', '.join(blocking)}")
-        elif question.get("needs_review"):
-            review_only.append(
-                f"Q{label}: {', '.join(warnings) if warnings else 'needs_review'}"
-            )
-
-    if not blocked:
-        return ""
-
-    preview = "; ".join(blocked[:8])
-    remaining = len(blocked) - 8
-    if remaining > 0:
-        preview += f"; and {remaining} more"
-
-    suffix = ""
-    if review_only:
-        suffix = f" Non-blocking review warnings: {len(review_only)} question(s)."
-
-    return (
-        f"PDF extraction found {len(questions)} question(s), but {len(blocked)} have blocking issues. "
-        f"{preview}. Fix these or upload JSON with corrected fields.{suffix}"
-    )
-
 
 # ── Users ─────────────────────────────────────────────────────────
 
@@ -347,92 +273,46 @@ def get_test(test_id: int, db: Session = Depends(get_db), _=Depends(require_admi
     }
 
 
+class TestCreate(BaseModel):
+    title: str = Field(...)
+    description: Optional[str] = None
+    duration_minutes: int = 180
+    series_id: Optional[int] = None
+    series_order: int = 0
+    category: Optional[str] = None
+    series_name: Optional[str] = None
+    test_type: Optional[str] = None
+    subject: Optional[str] = None
+
+
 @router.post("/tests", status_code=201)
-async def create_test(
-    title: str = Form(...),
-    description: str = Form(None),
-    duration_minutes: int = Form(180),
-    series_id: int = Form(None),
-    series_order: int = Form(0),
-    category: str = Form(None),
-    series_name: str = Form(None),
-    test_type: str = Form(None),
-    subject: str = Form(None),
-    pdf_file: UploadFile = File(None),
+def create_test(
+    payload: TestCreate,
     db: Session = Depends(get_db),
     current=Depends(require_admin),
 ):
-    pdf_filename = None
-    extracted = []
-
-    if pdf_file and pdf_file.filename:
-        if not pdf_file.filename.lower().endswith(".pdf"):
-            raise HTTPException(status_code=400, detail="Only PDF files accepted")
-        safe_filename = f"{uuid.uuid4().hex}.pdf"
-        os.makedirs(settings.UPLOAD_DIR, exist_ok=True)
-        path = os.path.join(settings.UPLOAD_DIR, safe_filename)
-        await _save_pdf_upload(pdf_file, path)
-        pdf_filename = safe_filename
-        extracted = await run_in_threadpool(extract_questions_from_pdf, path)
-        if not extracted:
-            try:
-                os.remove(path)
-            except OSError:
-                pass
-            raise HTTPException(
-                status_code=400, detail="No questions could be extracted from PDF."
-            )
-
-        review_detail = _pdf_review_detail(extracted)
-        if review_detail:
-            try:
-                os.remove(path)
-            except OSError:
-                pass
-            raise HTTPException(status_code=400, detail=review_detail)
-
-    total_marks = sum(q["marks"] for q in extracted) if extracted else 0.0
     test = Test(
-        title=title,
-        description=description,
-        duration_minutes=duration_minutes,
-        pdf_filename=pdf_filename,
-        total_marks=total_marks,
-        series_id=series_id,
-        series_order=series_order,
-        category=category,
-        series_name=series_name,
-        test_type=test_type,
-        subject=subject,
+        title=payload.title,
+        description=payload.description,
+        duration_minutes=payload.duration_minutes,
+        total_marks=0.0,
+        series_id=payload.series_id,
+        series_order=payload.series_order,
+        category=payload.category,
+        series_name=payload.series_name,
+        test_type=payload.test_type,
+        subject=payload.subject,
         created_by=current.id,
     )
     db.add(test)
     db.commit()
     db.refresh(test)
 
-    for idx, q in enumerate(extracted):
-        db.add(
-            Question(
-                test_id=test.id,
-                question_type=QuestionType(q["question_type"]),
-                question_text=q["question_text"],
-                options=q["options"],
-                correct_answer=q["correct_answer"],
-                marks=q["marks"],
-                negative_marks=q["negative_marks"],
-                subject=q.get("subject"),
-                topic=q.get("topic"),
-                order_index=idx,
-            )
-        )
-    if extracted:
-        db.commit()
-
     return {
         "id": test.id,
         "title": test.title,
-        "question_count": len(extracted),
-        "total_marks": total_marks,
+        "question_count": 0,
+        "total_marks": 0.0,
     }
 
 

backend/app/models/models.py

@@ -103,7 +103,6 @@ class Test(Base):
     description: Mapped[str | None] = mapped_column(Text, nullable=True)
     duration_minutes: Mapped[int] = mapped_column(Integer, default=180)
     total_marks: Mapped[float] = mapped_column(Float, default=0.0)
-    pdf_filename: Mapped[str | None] = mapped_column(String(500), nullable=True)
     is_published: Mapped[bool] = mapped_column(Boolean, default=True)
     series_id: Mapped[int | None] = mapped_column(Integer, ForeignKey("test_series.id"), nullable=True, index=True)
     series_order: Mapped[int] = mapped_column(Integer, default=0)

backend/app/services/PDF_PARSER.md

@@ -1,86 +0,0 @@
-# PDF Parser Notes
-
-## Supported Structures
-
-The parser is deterministic and layout-agnostic. It supports common exam formats such as:
-
-- `Q.1 ...`, `Q1 ...`, `Question 1 ...`
-- `1. [MCQ] ...`
-- `[MSQ] 1. ...`
-- `Q.1 MCQ | +2 -0`
-- `Q.1 NAT | +1 -0`
-- question types written as `MCQ`, `MSQ`, `NAT`, `Single correct`, `Multiple correct`, or `Numerical answer type`
-- options written as `(a)`, `(A)`, `a)`, `A.`, and options split across lines or compacted onto one line
-- inline answer lines such as `Answer: B` or `Correct Answer: A;C`
-- separate `Answer Key` / `Answers` / `Solutions` sections with numbered answers
-- NAT answers as numbers, decimals, negative numbers, ranges, or comma/semicolon-separated accepted values
-- marks written as `+2 -0.67`, `[2 marks]`, `(1 mark)`, or range rules like `Q.1 to Q.5 carry one mark each`
-
-## Pipeline
-
-`extract_questions_from_pdf()` runs these stages:
-
-1. Extract text page by page using `pdfplumber`, falling back to PyMuPDF.
-2. Normalize text and line endings.
-3. Select structural parser profiles from document patterns.
-4. Parse answer key / solutions sections.
-5. Parse section-level marks rules.
-6. Detect question blocks and preserve page, section, local number, and global number.
-7. Parse question type, marks, options, inline answers, and answer-key answers.
-8. Validate each question and attach warnings.
-9. Assign confidence and `needs_review`.
-10. Return app-compatible question dictionaries with optional metadata.
-
-## Confidence
-
-Confidence is a `0.0` to `1.0` score based on:
-
-- question text presence
-- explicit question type
-- expected options for MCQ/MSQ
-- valid answer shape
-- marks found or defaulted
-- obvious parsing problems
-
-Questions below `0.7` get `low_confidence` and `needs_review`.
-
-## Review Warnings
-
-Common warnings include:
-
-- `missing_answer`
-- `missing_options`
-- `too_few_options`
-- `too_many_options`
-- `nat_has_non_numeric_answer`
-- `mcq_has_multiple_answers`
-- `msq_has_single_answer_but_allowed`
-- `image_context_required`
-- `duplicate_question_number_in_same_section`
-- `low_confidence`
-
-The parser never guesses missing answers. Missing answers are returned as an empty string with `missing_answer`.
-
-## Upload Behavior
-
-The parser can return low-confidence questions for review, but the current database schema has no columns for parser review metadata. The admin PDF upload endpoint therefore rejects PDFs containing review-needed questions instead of saving uncertain questions into a live test.
-
-## Limitations
-
-- It does not perform OCR.
-- It does not extract embedded diagrams or rendered page images.
-- Two-column text is handled only when the PDF text extraction preserves option markers.
-- Ambiguous answer keys with repeated question numbers may require manual review.
-- Image-dependent questions are flagged with `has_image` / `image_context_required`; image extraction can be added later using existing question image fields.
-
-## Adding Patterns
-
-Add structural support by extending regexes in `pdf_service.py`:
-
-- question starts: `_parse_question_boundary`
-- type aliases: `TYPE_ALIASES`
-- answer key pairs: `ANSWER_PAIR_RE` / `ANSWER_PAIR_SPACE_RE`
-- marks: `MARKS_INLINE_RE`, `MARKS_WORD_RE`, `MARK_RULE_RE`
-- image-context phrases: `IMAGE_CONTEXT_RE`
-
-Add synthetic fixtures in `backend/tests/test_pdf_service.py` for every new pattern.

backend/app/services/pdf_service.py

@@ -1,959 +0,0 @@
-"""
-Deterministic PDF question extraction.
-
-The public entry point remains extract_questions_from_pdf(pdf_path). Internally
-the parser runs a staged pipeline: page text extraction, normalization, profile
-detection, section/question block detection, answer-key extraction, question
-field parsing, validation, confidence scoring, and compatibility shaping.
-"""
-
-from __future__ import annotations
-
-import logging
-import os
-import re
-from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional
-
-from app.services.answer_utils import (is_valid_nat_answer,
-                                       normalize_choice_answer, parse_float,
-                                       split_answer_tokens)
-
-logger = logging.getLogger(__name__)
-
-DEFAULT_MARKS = {"mcq": 1.0, "msq": 2.0, "nat": 2.0}
-DEFAULT_NEGATIVE = {"mcq": 0.33, "msq": 0.0, "nat": 0.0}
-
-TYPE_ALIASES = [
-    (re.compile(r"\bMSQ\b|\bmultiple\s+correct\b", re.IGNORECASE), "msq"),
-    (re.compile(r"\bNAT\b|\bnumerical\s+answer(?:\s+type)?\b", re.IGNORECASE), "nat"),
-    (re.compile(r"\bMCQ\b|\bsingle\s+correct\b", re.IGNORECASE), "mcq"),
-]
-TYPE_TOKEN_RE = r"(?:MCQ|MSQ|NAT|single\s+correct|multiple\s+correct|numerical\s+answer(?:\s+type)?)"
-QUESTION_HEADER_RE = re.compile(
-    rf"^\s*(?:\[?\s*(?P<type>{TYPE_TOKEN_RE})\s*\]?)?"
-    r"\s*(?:\|\s*)?"
-    r"(?:(?:\+?(?P<marks>\d+(?:\.\d+)?)\s*-\s*(?P<negative>\d+(?:\.\d+)?))|"
-    r"(?P<bracket_marks>[\[(]\s*\d+(?:\.\d+)?\s*marks?\s*[\])]))?"
-    r"\s*(?P<rest>.*)$",
-    re.IGNORECASE,
-)
-Q_PREFIX_RE = re.compile(
-    r"^\s*(?:Q\.?\s*|Question\s+)(?P<num>\d{1,4})\s*[\).:\-]?\s*(?P<rest>.*)$",
-    re.IGNORECASE,
-)
-TYPE_BEFORE_NUM_RE = re.compile(
-    rf"^\s*\[?\s*(?P<type>{TYPE_TOKEN_RE})\s*\]?\s*"
-    r"(?:Q\.?\s*|Question\s+)?(?P<num>\d{1,4})\s*[\).:\-]?\s*(?P<rest>.*)$",
-    re.IGNORECASE,
-)
-NUMBERED_RE = re.compile(r"^\s*(?P<num>\d{1,4})\s*[\).:]\s*(?P<rest>.*)$")
-OPTION_MARKER_RE = re.compile(
-    r"(?<![A-Za-z0-9])(?:[\(\[]\s*([A-Da-d])\s*[\)\]]|([A-Da-d])[\).])\s*"
-)
-ANSWER_LINE_RE = re.compile(
-    r"\b(?:Correct\s+Answer|Answer|Ans)\s*[:.)\-]\s*(?P<answer>.+)$", re.IGNORECASE
-)
-ANSWER_KEY_TITLE_RE = re.compile(
-    r"^\s*(?:answer\s*key|answers?|solutions?)\s*[:\-]?\s*$", re.IGNORECASE
-)
-CHOICE_ANSWER_VALUE_RE = (
-    r"(?:option\s*)?[\(\[]?\s*[A-Da-d]\s*[\)\].]?"
-    r"(?:\s*(?:[,;/&]|\band\b|\bor\b)\s*(?:option\s*)?[\(\[]?\s*[A-Da-d]\s*[\)\].]?)*"
-)
-ANSWER_VALUE_RE = (
-    rf"(?:{CHOICE_ANSWER_VALUE_RE}|"
-    r"[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?"
-    r"(?:\s*-\s*[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?)?"
-    r"(?:\s*[,;/]\s*[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?"
-    r"(?:\s*-\s*[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?)?)*)"
-)
-CHOICE_TOKEN_RE = re.compile(
-    r"(?<![A-Za-z0-9])(?:option\s*)?[\(\[]?\s*([A-Da-d])\s*[\)\].]?(?![A-Za-z0-9])",
-    re.IGNORECASE,
-)
-LEADING_CHOICE_ANSWER_RE = re.compile(
-    rf"^\s*(?P<choices>{CHOICE_ANSWER_VALUE_RE})(?=\s|$)",
-    re.IGNORECASE,
-)
-NAT_VALUE_RE = re.compile(
-    r"[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?"
-    r"(?:\s*(?:-|to)\s*[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?)?",
-    re.IGNORECASE,
-)
-ANSWER_PAIR_RE = re.compile(
-    rf"(?:Q\.?\s*|Question\s+)?(?P<num>\d{{1,4}})\s*[\).:\-]\s*"
-    rf"(?:(?:Correct\s+Answer|Answer|Ans)\s*[:\-]?\s*)?(?P<answer>{ANSWER_VALUE_RE})(?=\s|$)",
-    re.IGNORECASE,
-)
-ANSWER_PAIR_SPACE_RE = re.compile(
-    rf"(?:Q\.?\s*|Question\s+)?(?P<num>\d{{1,4}})\s+"
-    rf"(?:(?:Correct\s+Answer|Answer|Ans)\s*[:\-]?\s*)?(?P<answer>{ANSWER_VALUE_RE})(?=\s|$)",
-    re.IGNORECASE,
-)
-SOLUTION_ANSWER_RE = re.compile(
-    rf"\b(?:Solution|Sol)\s*(?P<num>\d{{1,4}})\b.*?"
-    rf"(?:(?:Correct\s+Answer|Answer|Ans)\s*[:\-]?\s*)?(?P<answer>{ANSWER_VALUE_RE})(?=\s|$)",
-    re.IGNORECASE,
-)
-MARKS_INLINE_RE = re.compile(
-    r"\+?(?P<marks>\d+(?:\.\d+)?)\s*-\s*(?P<negative>\d+(?:\.\d+)?)"
-)
-MARKS_WORD_RE = re.compile(
-    r"[\[(]\s*(?P<marks>\d+(?:\.\d+)?)\s*marks?\s*[\])]", re.IGNORECASE
-)
-MARK_RULE_RE = re.compile(
-    r"(?:Q\.?\s*)?(?P<start>\d{1,4})\s*(?:to|\-|through)\s*(?:Q\.?\s*)?(?P<end>\d{1,4})"
-    r".*?\bcarry\s+(?P<marks>one|two|three|four|five|\d+(?:\.\d+)?)\s+marks?\s+each",
-    re.IGNORECASE,
-)
-IMAGE_CONTEXT_RE = re.compile(
-    r"\b(following\s+(?:figure|diagram)|shown\s+below|given\s+circuit|truth\s+table|"
-    r"hasse\s+diagram|automaton|graph)\b",
-    re.IGNORECASE,
-)
-
-WORD_NUMBERS = {"one": 1.0, "two": 2.0, "three": 3.0, "four": 4.0, "five": 5.0}
-REVIEW_WARNINGS = {
-    "missing_answer",
-    "missing_options",
-    "too_few_options",
-    "too_many_options",
-    "nat_has_non_numeric_answer",
-    "mcq_has_multiple_answers",
-    "image_context_required",
-    "duplicate_question_number_in_same_section",
-    "ambiguous_answer_key",
-    "low_confidence",
-}
-
-
-@dataclass
-class PageText:
-    page_number: int
-    text: str
-
-
-@dataclass
-class SourceLine:
-    text: str
-    page_number: int
-    index: int
-
-
-@dataclass
-class QuestionBoundary:
-    number: int
-    declared_type: Optional[str]
-    rest: str
-
-
-@dataclass
-class QuestionBlock:
-    question_number: int
-    global_question_number: int
-    section_title: Optional[str]
-    source_page_start: int
-    source_page_end: int
-    declared_type: Optional[str]
-    lines: List[SourceLine] = field(default_factory=list)
-    occurrence_index: int = 1
-
-
-@dataclass
-class MarkRule:
-    start: int
-    end: int
-    marks: float
-
-
-@dataclass
-class AnswerKeys:
-    by_number: Dict[int, List[str]] = field(default_factory=dict)
-    by_section: Dict[tuple[str, int], List[str]] = field(default_factory=dict)
-    line_indexes: set[int] = field(default_factory=set)
-
-
-def extract_questions_from_pdf(pdf_path: str) -> List[Dict[str, Any]]:
-    pages = _extract_pages(pdf_path)
-    if not any(page.text.strip() for page in pages):
-        logger.error("Could not extract any text from PDF")
-        return []
-
-    questions = _parse_pages(pages, source_filename=os.path.basename(pdf_path))
-    return questions
-
-
-def _extract_text(pdf_path: str) -> str:
-    return "\n".join(page.text for page in _extract_pages(pdf_path))
-
-
-def _extract_pages(pdf_path: str) -> List[PageText]:
-    """Extract text page by page using existing PDF libraries."""
-    try:
-        import pdfplumber
-
-        with pdfplumber.open(pdf_path) as pdf:
-            pages = [
-                PageText(i + 1, page.extract_text() or "")
-                for i, page in enumerate(pdf.pages)
-            ]
-            if any(page.text.strip() for page in pages):
-                logger.info("Extracted %s pages with pdfplumber", len(pages))
-                return pages
-    except Exception as exc:
-        logger.warning("pdfplumber failed: %s", exc)
-
-    try:
-        import fitz
-
-        doc = fitz.open(pdf_path)
-        pages = [PageText(i + 1, page.get_text() or "") for i, page in enumerate(doc)]
-        doc.close()
-        logger.info("Extracted %s pages with PyMuPDF", len(pages))
-        return pages
-    except Exception as exc:
-        logger.warning("PyMuPDF failed: %s", exc)
-
-    return []
-
-
-def _parse_gate_questions(text: str) -> List[Dict[str, Any]]:
-    """Compatibility helper used by tests and older call sites."""
-    return _parse_pages([PageText(1, text)], source_filename=None)
-
-
-def _parse_pages(
-    pages: List[PageText], source_filename: Optional[str]
-) -> List[Dict[str, Any]]:
-    normalized_pages = [
-        PageText(page.page_number, _normalize_text(page.text)) for page in pages
-    ]
-    lines = _page_lines(normalized_pages)
-    profiles = _select_profiles(lines)
-    answer_keys = _parse_answer_key_sections(lines)
-    mark_rules = _parse_mark_rules(lines)
-    blocks = _detect_question_blocks(lines, answer_keys.line_indexes)
-
-    question_number_counts: Dict[int, int] = {}
-    for block in blocks:
-        question_number_counts[block.question_number] = (
-            question_number_counts.get(block.question_number, 0) + 1
-        )
-
-    seen_in_section: set[tuple[str, int]] = set()
-    questions: List[Dict[str, Any]] = []
-    for block in blocks:
-        parsed = _parse_question_block(
-            block, answer_keys, mark_rules, question_number_counts, source_filename
-        )
-        duplicate_key = (parsed.get("section_title") or "", parsed["question_number"])
-        duplicate = duplicate_key in seen_in_section
-        seen_in_section.add(duplicate_key)
-        questions.append(_validate_and_score(parsed, duplicate=duplicate))
-
-    needs_review = sum(1 for question in questions if question.get("needs_review"))
-    logger.info(
-        "Selected PDF parser profile(s): %s",
-        ", ".join(profiles) if profiles else "generic_profile",
-    )
-    logger.info("PDF parser pages extracted: %s", len(pages))
-    logger.info(
-        "PDF parser sections detected: %s",
-        len({q.get("section_title") for q in questions if q.get("section_title")}),
-    )
-    logger.info("PDF parser question blocks detected: %s", len(blocks))
-    logger.info(
-        "PDF parser answers detected: %s",
-        sum(len(v) for v in answer_keys.by_number.values()),
-    )
-    logger.info("PDF parser questions returned: %s", len(questions))
-    logger.info("PDF parser questions needing review: %s", needs_review)
-    return questions
-
-
-def _normalize_text(text: str) -> str:
-    text = text.replace("\r\n", "\n").replace("\r", "\n")
-    text = text.replace("\u2013", "-").replace("\u2014", "-")
-    text = text.replace("\u2212", "-")
-    text = text.replace("\u00a0", " ")
-    return text
-
-
-def _page_lines(pages: List[PageText]) -> List[SourceLine]:
-    lines: List[SourceLine] = []
-    index = 0
-    for page in pages:
-        for raw in page.text.split("\n"):
-            lines.append(SourceLine(raw.strip(), page.page_number, index))
-            index += 1
-    return lines
-
-
-def _select_profiles(lines: List[SourceLine]) -> List[str]:
-    profiles: List[str] = []
-    text = "\n".join(line.text for line in lines)
-    if ANSWER_KEY_TITLE_RE.search(text):
-        profiles.append("separate_answer_key_profile")
-    if ANSWER_LINE_RE.search(text):
-        profiles.append("inline_answer_profile")
-    if any(
-        _parse_question_boundary(line.text) and _extract_question_type(line.text)
-        for line in lines
-    ):
-        profiles.append("typed_numbered_question_profile")
-    if any(len(list(OPTION_MARKER_RE.finditer(line.text))) > 1 for line in lines):
-        profiles.append("compact_question_profile")
-    return profiles or ["generic_numbered_question_profile"]
-
-
-def _parse_answer_key_sections(lines: List[SourceLine]) -> AnswerKeys:
-    keys = AnswerKeys()
-    in_key = False
-    current_section: Optional[str] = None
-
-    for line in lines:
-        text = line.text.strip()
-        if not text:
-            if in_key:
-                keys.line_indexes.add(line.index)
-            continue
-
-        if ANSWER_KEY_TITLE_RE.match(text):
-            in_key = True
-            current_section = None
-            keys.line_indexes.add(line.index)
-            continue
-
-        if not in_key:
-            solution_match = SOLUTION_ANSWER_RE.search(text)
-            if solution_match:
-                _store_answer(
-                    keys,
-                    int(solution_match.group("num")),
-                    _clean_answer_value(solution_match.group("answer")),
-                    None,
-                )
-            continue
-
-        keys.line_indexes.add(line.index)
-        if _looks_section_title(text):
-            current_section = text
-
-        for q_num, answer in _extract_answer_pairs(text):
-            _store_answer(keys, q_num, answer, current_section)
-
-    return keys
-
-
-def _store_answer(
-    keys: AnswerKeys, q_num: int, answer: str, section_title: Optional[str]
-) -> None:
-    if not answer:
-        return
-    keys.by_number.setdefault(q_num, []).append(answer)
-    if section_title:
-        keys.by_section.setdefault((section_title, q_num), []).append(answer)
-
-
-def _extract_answer_pairs(text: str) -> List[tuple[int, str]]:
-    pairs: List[tuple[int, str]] = []
-    for pattern in (ANSWER_PAIR_RE, ANSWER_PAIR_SPACE_RE):
-        for match in pattern.finditer(text):
-            q_num = int(match.group("num"))
-            answer = _clean_answer_value(match.group("answer"))
-            if answer:
-                pairs.append((q_num, answer))
-        if pairs:
-            break
-    return pairs
-
-
-def _parse_mark_rules(lines: List[SourceLine]) -> List[MarkRule]:
-    rules: List[MarkRule] = []
-    for line in lines:
-        match = MARK_RULE_RE.search(line.text)
-        if not match:
-            continue
-        raw_marks = match.group("marks").lower()
-        marks = WORD_NUMBERS.get(raw_marks, parse_float(raw_marks))
-        if marks is not None:
-            rules.append(
-                MarkRule(int(match.group("start")), int(match.group("end")), marks)
-            )
-    return rules
-
-
-def _detect_question_blocks(
-    lines: List[SourceLine], answer_key_line_indexes: set[int]
-) -> List[QuestionBlock]:
-    blocks: List[QuestionBlock] = []
-    current: Optional[QuestionBlock] = None
-    recent_context: List[str] = []
-    current_section: Optional[str] = None
-    section_index = 0
-    last_question_number: Optional[int] = None
-    global_question_number = 0
-    occurrence_counts: Dict[int, int] = {}
-
-    for line in lines:
-        if line.index in answer_key_line_indexes:
-            if current:
-                blocks.append(current)
-                current = None
-            recent_context.clear()
-            continue
-
-        boundary = _parse_question_boundary(line.text)
-        if boundary:
-            if current:
-                blocks.append(current)
-
-            candidate_section = _latest_section_title(recent_context)
-            if candidate_section and (current_section is None or boundary.number == 1):
-                current_section = candidate_section
-            elif (
-                last_question_number is not None
-                and boundary.number <= last_question_number
-            ):
-                section_index += 1
-                current_section = candidate_section or f"Section {section_index + 1}"
-
-            global_question_number += 1
-            occurrence_counts[boundary.number] = (
-                occurrence_counts.get(boundary.number, 0) + 1
-            )
-            current = QuestionBlock(
-                question_number=boundary.number,
-                global_question_number=global_question_number,
-                section_title=current_section,
-                source_page_start=line.page_number,
-                source_page_end=line.page_number,
-                declared_type=boundary.declared_type,
-                occurrence_index=occurrence_counts[boundary.number],
-            )
-            if boundary.rest:
-                current.lines.append(
-                    SourceLine(boundary.rest, line.page_number, line.index)
-                )
-
-            recent_context.clear()
-            last_question_number = boundary.number
-            continue
-
-        if current:
-            current.lines.append(line)
-            current.source_page_end = max(current.source_page_end, line.page_number)
-        elif line.text:
-            recent_context.append(line.text)
-            recent_context = recent_context[-8:]
-
-    if current:
-        blocks.append(current)
-
-    return blocks
-
-
-def _parse_question_boundary(text: str) -> Optional[QuestionBoundary]:
-    stripped = text.strip()
-    if not stripped:
-        return None
-
-    type_before = TYPE_BEFORE_NUM_RE.match(stripped)
-    if type_before:
-        return QuestionBoundary(
-            number=int(type_before.group("num")),
-            declared_type=_normalize_question_type_label(type_before.group("type")),
-            rest=type_before.group("rest").strip(),
-        )
-
-    q_prefix = Q_PREFIX_RE.match(stripped)
-    if q_prefix:
-        rest = q_prefix.group("rest").strip()
-        return QuestionBoundary(
-            number=int(q_prefix.group("num")),
-            declared_type=_extract_question_type(rest),
-            rest=rest,
-        )
-
-    numbered = NUMBERED_RE.match(stripped)
-    if numbered:
-        number = int(numbered.group("num"))
-        if number > 500:
-            return None
-        rest = numbered.group("rest").strip()
-        return QuestionBoundary(
-            number=number, declared_type=_extract_question_type(rest), rest=rest
-        )
-
-    return None
-
-
-def _parse_question_block(
-    block: QuestionBlock,
-    answer_keys: AnswerKeys,
-    mark_rules: List[MarkRule],
-    question_number_counts: Dict[int, int],
-    source_filename: Optional[str],
-) -> Dict[str, Any]:
-    cleaned_lines: List[SourceLine] = []
-    inline_answer = ""
-
-    for source_line in block.lines:
-        text = source_line.text.strip()
-        if not text:
-            continue
-        answer, remainder = _extract_inline_answer(text)
-        if answer:
-            inline_answer = answer
-            text = remainder.strip()
-        text = _strip_question_metadata(text)
-        if text:
-            cleaned_lines.append(
-                SourceLine(text, source_line.page_number, source_line.index)
-            )
-
-    question_lines, options = _parse_options_and_question_text(cleaned_lines)
-    question_text = _clean_spaces(" ".join(question_lines))
-    raw_text = _clean_spaces(" ".join(line.text for line in cleaned_lines))
-    type_found = bool(block.declared_type or _extract_question_type(raw_text))
-    question_type = block.declared_type or _extract_question_type(raw_text)
-    if not question_type:
-        question_type = _infer_question_type(question_text, options, inline_answer)
-
-    marks, negative_marks, marks_found = _resolve_marks(
-        raw_text, question_type, block.question_number, mark_rules
-    )
-    answer = inline_answer or _lookup_answer(answer_keys, block, question_number_counts)
-    answer = _normalize_answer(answer, question_type)
-    if question_type == "mcq" and len(_choice_tokens(answer)) > 1:
-        question_type = "msq"
-        negative_marks = 0.0
-
-    section_title = block.section_title
-    has_image = bool(IMAGE_CONTEXT_RE.search(question_text))
-    return {
-        "question_type": question_type,
-        "question_text": question_text,
-        "options": options,
-        "correct_answer": answer,
-        "marks": marks,
-        "negative_marks": negative_marks,
-        "subject": None,
-        "topic": section_title,
-        "section_title": section_title,
-        "question_number": block.question_number,
-        "global_question_number": block.global_question_number,
-        "source_filename": source_filename,
-        "source_page_start": block.source_page_start,
-        "source_page_end": block.source_page_end,
-        "has_image": has_image,
-        "_type_found": type_found,
-        "_marks_found": marks_found,
-        "_answer_source": (
-            "inline" if inline_answer else "answer_key" if answer else None
-        ),
-    }
-
-
-def _extract_inline_answer(text: str) -> tuple[str, str]:
-    match = ANSWER_LINE_RE.search(text)
-    if not match:
-        return "", text
-    answer = _clean_answer_value(match.group("answer"))
-    remainder = text[: match.start()].strip()
-    return answer, remainder
-
-
-def _clean_answer_value(value: str) -> str:
-    text = str(value or "").strip()
-    text = re.split(
-        r"\s+(?:because|since|for)\b", text, maxsplit=1, flags=re.IGNORECASE
-    )[0]
-    text = text.strip().strip("[]()")
-    if re.fullmatch(r"[A-Da-d](?:\s*[,;/]\s*[A-Da-d])*[.)]?", text):
-        text = text.rstrip(".)")
-    return text.strip()
-
-
-def _strip_question_metadata(text: str) -> str:
-    if not text:
-        return text
-    match = QUESTION_HEADER_RE.match(text)
-    if match and (
-        match.group("type") or match.group("marks") or match.group("bracket_marks")
-    ):
-        return match.group("rest").strip()
-    text = re.sub(
-        rf"^\s*\[?\s*{TYPE_TOKEN_RE}\s*\]?\s*(?:\|\s*)?", "", text, flags=re.IGNORECASE
-    )
-    text = MARKS_INLINE_RE.sub("", text, count=1).strip()
-    text = MARKS_WORD_RE.sub("", text, count=1).strip()
-    return text.strip(" |")
-
-
-def _parse_options_and_question_text(
-    lines: List[SourceLine],
-) -> tuple[List[str], List[str]]:
-    question_lines: List[str] = []
-    options_by_label: Dict[str, str] = {}
-    current_label: Optional[str] = None
-
-    for line in lines:
-        text = line.text.strip()
-        markers = list(OPTION_MARKER_RE.finditer(text))
-        if markers:
-            prefix = text[: markers[0].start()].strip()
-            if prefix:
-                if current_label:
-                    options_by_label[current_label] = _clean_spaces(
-                        f"{options_by_label.get(current_label, '')} {prefix}"
-                    )
-                else:
-                    question_lines.append(prefix)
-
-            for idx, marker in enumerate(markers):
-                label = (marker.group(1) or marker.group(2)).upper()
-                next_start = (
-                    markers[idx + 1].start() if idx + 1 < len(markers) else len(text)
-                )
-                value = text[marker.end() : next_start].strip()
-                postfixed_value = False
-                if (
-                    not value
-                    and len(markers) == 1
-                    and _looks_postfixed_option_text(
-                        question_lines[-1] if question_lines else ""
-                    )
-                ):
-                    value = question_lines.pop()
-                    postfixed_value = True
-                if label in options_by_label and value:
-                    options_by_label[label] = _clean_spaces(
-                        f"{options_by_label[label]} {value}"
-                    )
-                else:
-                    options_by_label.setdefault(label, value)
-                current_label = None if postfixed_value else label
-            continue
-
-        if current_label:
-            options_by_label[current_label] = _clean_spaces(
-                f"{options_by_label.get(current_label, '')} {text}"
-            )
-        elif text:
-            question_lines.append(text)
-
-    options = [
-        _clean_spaces(options_by_label[label])
-        for label in ("A", "B", "C", "D")
-        if options_by_label.get(label, "").strip()
-    ]
-    return question_lines, options
-
-
-def _looks_postfixed_option_text(text: str) -> bool:
-    value = _clean_spaces(text)
-    if not value or len(value) > 80 or value.endswith(("?", ".")):
-        return False
-    if re.search(r"[,;$¬∧∨→↔≠=]", value):
-        return True
-    return len(value.split()) <= 4 and not re.search(
-        r"\b(choose|select|determine|identify|consider|suppose|which)\b",
-        value,
-        re.IGNORECASE,
-    )
-
-
-def _resolve_marks(
-    raw_text: str,
-    question_type: str,
-    question_number: int,
-    mark_rules: List[MarkRule],
-) -> tuple[float, float, bool]:
-    inline = MARKS_INLINE_RE.search(raw_text)
-    if inline:
-        return float(inline.group("marks")), float(inline.group("negative")), True
-
-    word = MARKS_WORD_RE.search(raw_text)
-    if word:
-        return (
-            float(word.group("marks")),
-            DEFAULT_NEGATIVE.get(question_type, 0.33),
-            True,
-        )
-
-    for rule in mark_rules:
-        if rule.start <= question_number <= rule.end:
-            return rule.marks, DEFAULT_NEGATIVE.get(question_type, 0.33), True
-
-    return (
-        DEFAULT_MARKS.get(question_type, 1.0),
-        DEFAULT_NEGATIVE.get(question_type, 0.33),
-        False,
-    )
-
-
-def _lookup_answer(
-    keys: AnswerKeys, block: QuestionBlock, question_number_counts: Dict[int, int]
-) -> str:
-    if block.section_title:
-        section_answers = keys.by_section.get(
-            (block.section_title, block.question_number)
-        )
-        if section_answers:
-            return section_answers[
-                min(block.occurrence_index - 1, len(section_answers) - 1)
-            ]
-
-    answers = keys.by_number.get(block.question_number, [])
-    if not answers:
-        return ""
-    if question_number_counts.get(block.question_number, 0) == 1 and len(answers) == 1:
-        return answers[0]
-    if len(answers) >= block.occurrence_index:
-        return answers[block.occurrence_index - 1]
-    return ""
-
-
-def _validate_and_score(
-    question: Dict[str, Any], duplicate: bool = False
-) -> Dict[str, Any]:
-    warnings: List[str] = []
-    q_type = question["question_type"]
-    answer = question.get("correct_answer") or ""
-    options = question.get("options") or []
-
-    if not question.get("question_text"):
-        warnings.append("missing_question_text")
-
-    if q_type in {"mcq", "msq"}:
-        if not options:
-            warnings.append("missing_options")
-        elif len(options) < 4:
-            warnings.append("too_few_options")
-        elif len(options) > 4:
-            warnings.append("too_many_options")
-
-    if not answer:
-        warnings.append("missing_answer")
-    elif q_type == "nat" and not is_valid_nat_answer(answer):
-        warnings.append("nat_has_non_numeric_answer")
-    elif q_type == "mcq":
-        tokens = _choice_tokens(answer)
-        if len(tokens) > 1:
-            warnings.append("mcq_has_multiple_answers")
-        elif not tokens or tokens[0] not in {"A", "B", "C", "D"}:
-            warnings.append("invalid_choice_answer")
-    elif q_type == "msq":
-        tokens = _choice_tokens(answer)
-        if not tokens or any(token not in {"A", "B", "C", "D"} for token in tokens):
-            warnings.append("invalid_choice_answer")
-        elif len(tokens) == 1:
-            warnings.append("msq_has_single_answer_but_allowed")
-
-    if question.get("has_image"):
-        warnings.append("image_context_required")
-    if duplicate:
-        warnings.append("duplicate_question_number_in_same_section")
-    if question.get("_answer_source") is None and answer:
-        warnings.append("ambiguous_answer_key")
-
-    confidence = _confidence_score(question, warnings)
-    if confidence < 0.7 and "low_confidence" not in warnings:
-        warnings.append("low_confidence")
-        confidence = _confidence_score(question, warnings)
-
-    question["warnings"] = warnings
-    question["confidence"] = confidence
-    question["needs_review"] = (
-        any(warning in REVIEW_WARNINGS for warning in warnings) or confidence < 0.7
-    )
-    question.pop("_type_found", None)
-    question.pop("_marks_found", None)
-    question.pop("_answer_source", None)
-    return question
-
-
-def _confidence_score(question: Dict[str, Any], warnings: List[str]) -> float:
-    score = 0.0
-    q_type = question["question_type"]
-    options = question.get("options") or []
-    answer = question.get("correct_answer") or ""
-
-    if question.get("question_text"):
-        score += 0.2
-    if question.get("_type_found"):
-        score += 0.15
-    elif q_type:
-        score += 0.08
-
-    if q_type == "nat":
-        score += 0.15 if not options else 0.05
-    elif len(options) == 4:
-        score += 0.2
-    elif 2 <= len(options) < 4:
-        score += 0.1
-
-    if answer:
-        score += 0.25
-    if question.get("_marks_found"):
-        score += 0.1
-    else:
-        score += 0.05
-
-    severe = {
-        "missing_answer",
-        "missing_options",
-        "too_few_options",
-        "too_many_options",
-        "nat_has_non_numeric_answer",
-        "mcq_has_multiple_answers",
-        "invalid_choice_answer",
-        "missing_question_text",
-    }
-    score -= 0.1 * sum(1 for warning in warnings if warning in severe)
-    if "image_context_required" in warnings:
-        score -= 0.05
-    return round(max(0.0, min(1.0, score)), 2)
-
-
-def _infer_question_type(question_text: str, options: List[str], answer: str) -> str:
-    text_type = _extract_question_type(question_text)
-    if text_type:
-        return text_type
-    if options:
-        return "msq" if len(_choice_tokens(answer)) > 1 else "mcq"
-    if is_valid_nat_answer(answer) or re.search(
-        r"\b(value|number|calculate|find|____|___)\b", question_text, re.IGNORECASE
-    ):
-        return "nat"
-    return "mcq"
-
-
-def _extract_question_type(text: str) -> Optional[str]:
-    for pattern, q_type in TYPE_ALIASES:
-        if pattern.search(text or ""):
-            return q_type
-    return None
-
-
-def _normalize_question_type_label(value: str) -> Optional[str]:
-    return _extract_question_type(value)
-
-
-def _normalize_answer(answer: str, question_type: str) -> str:
-    if not answer:
-        return ""
-    if question_type in {"mcq", "msq"}:
-        return _normalize_choice_answer(answer)
-    return _normalize_nat_answer(answer)
-
-
-def _normalize_choice_answer(answer: str) -> str:
-    text = _strip_answer_prefix(answer)
-    match = LEADING_CHOICE_ANSWER_RE.match(text)
-    if not match:
-        return normalize_choice_answer(text)
-
-    labels = []
-    for token in CHOICE_TOKEN_RE.finditer(match.group("choices")):
-        label = token.group(1).upper()
-        if label not in labels:
-            labels.append(label)
-    return ",".join(labels)
-
-
-def _normalize_nat_answer(answer: str) -> str:
-    text = _strip_answer_prefix(answer)
-    if is_valid_nat_answer(text):
-        return ",".join(token.replace(" ", "") for token in split_answer_tokens(text))
-
-    values = []
-    for segment in re.split(r"\s*[,;/]\s*", text):
-        match = NAT_VALUE_RE.search(segment)
-        if not match:
-            continue
-        value = match.group(0).replace(" ", "")
-        value = re.sub(r"(?i)to", "-", value)
-        if value and value not in values:
-            values.append(value)
-    return ",".join(values)
-
-
-def _strip_answer_prefix(answer: str) -> str:
-    text = _clean_spaces(str(answer or ""))
-    text = re.sub(
-        r"^(?:correct\s+answer|answer|ans)\s*(?:is)?\s*[:.)\-]?\s*",
-        "",
-        text,
-        flags=re.IGNORECASE,
-    )
-    return text.strip()
-
-
-def _choice_tokens(answer: str) -> List[str]:
-    return [token.upper() for token in split_answer_tokens(answer)]
-
-
-def _latest_section_title(lines: List[str]) -> Optional[str]:
-    for text in reversed(lines):
-        if _looks_section_title(text):
-            return _clean_spaces(text)
-    return None
-
-
-def _looks_section_title(text: str) -> bool:
-    value = _clean_spaces(text)
-    if not value or len(value) > 120:
-        return False
-    if (
-        _parse_question_boundary(value)
-        or OPTION_MARKER_RE.match(value)
-        or ANSWER_LINE_RE.search(value)
-    ):
-        return False
-    lower = value.lower()
-    if re.search(
-        r"\b(section|chapter|topic|subject|part|test|quiz|dpp|module)\b", lower
-    ):
-        return True
-    words = re.findall(r"[A-Za-z]+", value)
-    return (
-        1 <= len(words) <= 10
-        and value.upper() == value
-        and any(len(word) > 2 for word in words)
-    )
-
-
-def _clean_spaces(text: str) -> str:
-    return re.sub(r"\s+", " ", str(text or "")).strip()
-
-
-def validate_json_questions(data: list) -> List[Dict[str, Any]]:
-    normalized = []
-    for q in data:
-        q_type = str(q.get("question_type", "mcq")).lower()
-        if q_type not in ("mcq", "msq", "nat"):
-            q_type = "mcq"
-
-        correct_answer = str(q.get("correct_answer", "")).strip()
-        if q_type in {"mcq", "msq"}:
-            correct_answer = normalize_choice_answer(correct_answer)
-
-        normalized.append(
-            {
-                "question_type": q_type,
-                "question_text": str(q.get("question_text", "")).strip(),
-                "options": q.get("options", []),
-                "correct_answer": correct_answer,
-                "marks": float(q.get("marks", DEFAULT_MARKS[q_type])),
-                "negative_marks": float(
-                    q.get("negative_marks", DEFAULT_NEGATIVE[q_type])
-                ),
-                "subject": q.get("subject"),
-                "topic": q.get("topic"),
-            }
-        )
-
-    return [q for q in normalized if q["question_text"]]

backend/requirements.txt

@@ -8,8 +8,6 @@ python-jose[cryptography]>=3.3.0
 passlib[bcrypt]>=1.7.4
 bcrypt==4.0.1
 python-multipart>=0.0.9
-pdfplumber>=0.11.0
-PyMuPDF>=1.24.3
 python-dotenv>=1.0.1
 pydantic[email]>=2.7.1
 pydantic-settings>=2.2.1

backend/tests/test_admin_create_test_upload.py

@@ -1,132 +0,0 @@
-import os
-import tempfile
-import unittest
-from unittest.mock import patch
-
-from fastapi import FastAPI
-from fastapi.testclient import TestClient
-from sqlalchemy import create_engine
-from sqlalchemy.orm import sessionmaker
-from sqlalchemy.pool import StaticPool
-
-from app.api.deps import require_admin
-from app.api.routes.admin import router
-from app.core.config import settings
-from app.core.database import Base, get_db
-from app.models.models import Test, User, UserRole
-
-
-class AdminCreateTestUploadTests(unittest.TestCase):
-    def setUp(self):
-        self.original_upload_dir = settings.UPLOAD_DIR
-        self.upload_dir = tempfile.TemporaryDirectory()
-        settings.UPLOAD_DIR = self.upload_dir.name
-        self.addCleanup(self.upload_dir.cleanup)
-        self.addCleanup(self._restore_upload_dir)
-
-        self.engine = create_engine(
-            "sqlite:///:memory:",
-            connect_args={"check_same_thread": False},
-            poolclass=StaticPool,
-        )
-        Base.metadata.create_all(self.engine)
-        self.SessionLocal = sessionmaker(bind=self.engine)
-
-        db = self.SessionLocal()
-        try:
-            self.admin = User(email="admin@example.com", full_name="Admin", role=UserRole.admin)
-            db.add(self.admin)
-            db.commit()
-            db.refresh(self.admin)
-        finally:
-            db.close()
-
-        app = FastAPI()
-        app.include_router(router)
-
-        def override_get_db():
-            db = self.SessionLocal()
-            try:
-                yield db
-            finally:
-                db.close()
-
-        def override_require_admin():
-            return self.admin
-
-        app.dependency_overrides[get_db] = override_get_db
-        app.dependency_overrides[require_admin] = override_require_admin
-        self.client = TestClient(app)
-
-    def _restore_upload_dir(self):
-        settings.UPLOAD_DIR = self.original_upload_dir
-
-    def test_create_test_uses_uuid_pdf_filename_for_traversal_upload_name(self):
-        extracted_questions = [
-            {
-                "question_type": "mcq",
-                "question_text": "Pick one.",
-                "options": ["A", "B", "C", "D"],
-                "correct_answer": "A",
-                "marks": 1.0,
-                "negative_marks": 0.33,
-            }
-        ]
-
-        with patch("app.api.routes.admin.extract_questions_from_pdf", return_value=extracted_questions) as extract:
-            response = self.client.post(
-                "/admin/tests",
-                data={"title": "Traversal test"},
-                files={
-                    "pdf_file": (
-                        "../../../etc/cron.d/malicious.pdf",
-                        b"%PDF-1.4",
-                        "application/pdf",
-                    )
-                },
-            )
-
-        self.assertEqual(response.status_code, 201)
-
-        db = self.SessionLocal()
-        try:
-            test = db.query(Test).one()
-            self.assertRegex(test.pdf_filename, r"^[0-9a-f]{32}\.pdf$")
-            self.assertNotIn("malicious", test.pdf_filename)
-            self.assertNotIn("..", test.pdf_filename)
-            saved_path = os.path.join(settings.UPLOAD_DIR, test.pdf_filename)
-            self.assertTrue(os.path.isfile(saved_path))
-            self.assertEqual(os.path.dirname(os.path.abspath(saved_path)), os.path.abspath(settings.UPLOAD_DIR))
-        finally:
-            db.close()
-
-        extract.assert_called_once()
-        extracted_path = extract.call_args.args[0]
-        self.assertRegex(os.path.basename(extracted_path), r"^[0-9a-f]{32}\.pdf$")
-        self.assertEqual(os.path.dirname(os.path.abspath(extracted_path)), os.path.abspath(settings.UPLOAD_DIR))
-
-    def test_create_test_rejects_pdf_upload_over_size_limit_and_removes_partial_file(self):
-        with (
-            patch("app.api.routes.admin.MAX_PDF_UPLOAD_SIZE_BYTES", 8),
-            patch("app.api.routes.admin.extract_questions_from_pdf") as extract,
-        ):
-            response = self.client.post(
-                "/admin/tests",
-                data={"title": "Oversized PDF"},
-                files={"pdf_file": ("oversized.pdf", b"%PDF-1.4 oversized", "application/pdf")},
-            )
-
-        self.assertEqual(response.status_code, 413)
-        self.assertEqual(response.json()["detail"], "File too large")
-        extract.assert_not_called()
-        self.assertEqual(os.listdir(settings.UPLOAD_DIR), [])
-
-        db = self.SessionLocal()
-        try:
-            self.assertEqual(db.query(Test).count(), 0)
-        finally:
-            db.close()
-
-
-if __name__ == "__main__":
-    unittest.main()

backend/tests/test_admin_pdf_review.py

@@ -1,41 +0,0 @@
-import unittest
-
-from app.api.routes.admin import _pdf_review_detail
-
-
-class AdminPDFReviewTests(unittest.TestCase):
-    def test_non_blocking_review_warnings_do_not_reject_import(self):
-        detail = _pdf_review_detail([
-            {
-                "question_number": 1,
-                "needs_review": True,
-                "warnings": ["image_context_required", "low_confidence"],
-                "correct_answer": "A",
-            }
-        ])
-
-        self.assertEqual(detail, "")
-
-    def test_blocking_warnings_are_reported_with_question_numbers(self):
-        detail = _pdf_review_detail([
-            {
-                "question_number": 1,
-                "needs_review": True,
-                "warnings": ["missing_answer", "low_confidence"],
-                "correct_answer": "",
-            },
-            {
-                "question_number": 2,
-                "needs_review": True,
-                "warnings": ["too_few_options"],
-                "correct_answer": "B",
-            },
-        ])
-
-        self.assertIn("2 have blocking issues", detail)
-        self.assertIn("Q1: missing_answer", detail)
-        self.assertIn("Q2: too_few_options", detail)
-
-
-if __name__ == "__main__":
-    unittest.main()

backend/tests/test_pdf_edge_cases.py

@@ -1,143 +0,0 @@
-import os
-import tempfile
-import pytest
-from app.services.pdf_service import extract_questions_from_pdf, _parse_gate_questions
-
-def _write_temp_file(content: bytes, suffix: str = ".pdf") -> str:
-    fd, path = tempfile.mkstemp(suffix=suffix)
-    os.write(fd, content)
-    os.close(fd)
-    return path
-
-def _create_empty_pdf() -> str:
-    import fitz
-    fd, path = tempfile.mkstemp(suffix=".pdf")
-    os.close(fd)
-    doc = fitz.open()
-    doc.new_page()
-    doc.save(path)
-    doc.close()
-    return path
-
-def _create_pdf_with_text(text: str) -> str:
-    import fitz
-    fd, path = tempfile.mkstemp(suffix=".pdf")
-    os.close(fd)
-    doc = fitz.open()
-    page = doc.new_page()
-    page.insert_text((50, 50), text, fontsize=10)
-    doc.save(path)
-    doc.close()
-    return path
-
-def test_non_existent_file():
-    assert extract_questions_from_pdf("/path/does/not/exist.pdf") == []
-
-def test_corrupted_pdf_file():
-    path = _write_temp_file(b"This is not a pdf file")
-    try:
-        assert extract_questions_from_pdf(path) == []
-    finally:
-        os.remove(path)
-
-def test_empty_pdf():
-    path = _create_empty_pdf()
-    try:
-        assert extract_questions_from_pdf(path) == []
-    finally:
-        os.remove(path)
-
-def test_pdf_with_only_whitespace():
-    path = _create_pdf_with_text("   \n   \t   ")
-    try:
-        assert extract_questions_from_pdf(path) == []
-    finally:
-        os.remove(path)
-
-def test_very_long_question_text():
-    long_text = "A" * 15000
-    questions = _parse_gate_questions(f"Q.1 MCQ\n{long_text}\nA. a\nB. b\nC. c\nD. d\nAnswer: A")
-    assert len(questions) == 1
-    assert questions[0]["question_text"] == long_text
-
-def test_pdf_with_special_unicode_characters():
-    text = "Q.1 MCQ\nCompute α + β ≈ 10.\nA. 10\nB. 20\nC. 30\nD. 40\nAnswer: A"
-    questions = _parse_gate_questions(text)
-    assert len(questions) == 1
-    assert "α + β ≈ 10." in questions[0]["question_text"]
-
-def test_mixed_question_types():
-    text = """
-    Q.1 MCQ | +1 -0.33
-    Choose.
-    A. a
-    B. b
-    C. c
-    D. d
-    Answer: A
-    Q.2 MSQ | +2 -0
-    Choose all.
-    A. a
-    B. b
-    C. c
-    D. d
-    Answer: A,B
-    Q.3 NAT | +2 -0
-    Enter value.
-    Answer: 42
-    """
-    questions = _parse_gate_questions(text)
-    assert len(questions) == 3
-    assert questions[0]["question_type"] == "mcq"
-    assert questions[1]["question_type"] == "msq"
-    assert questions[2]["question_type"] == "nat"
-
-def test_missing_answer_keys():
-    text = """
-    Q.1 MCQ
-    Choose.
-    A. a
-    B. b
-    C. c
-    D. d
-    """
-    questions = _parse_gate_questions(text)
-    assert len(questions) == 1
-    assert questions[0]["needs_review"] == True
-    assert "missing_answer" in questions[0]["warnings"]
-
-def test_duplicate_question_numbers():
-    text = """
-    SECTION 1
-    Q.1 MCQ
-    A. a
-    B. b
-    C. c
-    D. d
-    Answer: A
-    SECTION 2
-    Q.1 MCQ
-    A. a
-    B. b
-    C. c
-    D. d
-    Answer: B
-    """
-    questions = _parse_gate_questions(text)
-    assert len(questions) == 2
-    assert questions[0]["global_question_number"] == 1
-    assert questions[1]["global_question_number"] == 2
-
-def test_malformed_option_labels():
-    text = """
-    Q.1 MCQ
-    Find value.
-    (a) first
-    (b) second
-    (c) third
-    (d) fourth
-    Answer: A
-    """
-    questions = _parse_gate_questions(text)
-    assert len(questions) == 1
-    assert questions[0]["options"] == ["first", "second", "third", "fourth"]

backend/tests/test_pdf_service.py

@@ -1,267 +0,0 @@
-import unittest
-
-from app.services.pdf_service import _parse_gate_questions
-
-
-class PDFServiceParserTests(unittest.TestCase):
-    def test_q_dot_format_with_inline_answer(self):
-        questions = _parse_gate_questions(
-            """
-            Q.1 MCQ | +1 -0.33
-            Choose the true statement.
-            A. one
-            B. two
-            C. three
-            D. four
-            Answer: B
-            """
-        )
-
-        self.assertEqual(len(questions), 1)
-        self.assertEqual(questions[0]["question_type"], "mcq")
-        self.assertEqual(questions[0]["correct_answer"], "B")
-        self.assertEqual(questions[0]["negative_marks"], 0.33)
-        self.assertFalse(questions[0]["needs_review"])
-
-    def test_numbered_mcq_format(self):
-        questions = _parse_gate_questions(
-            """
-            1. [MCQ] Which option is correct?
-            (a) alpha
-            (b) beta
-            (c) gamma
-            (d) delta
-            Correct Answer: c
-            """
-        )
-
-        self.assertEqual(questions[0]["question_type"], "mcq")
-        self.assertEqual(questions[0]["options"], ["alpha", "beta", "gamma", "delta"])
-        self.assertEqual(questions[0]["correct_answer"], "C")
-
-    def test_type_before_number_format(self):
-        questions = _parse_gate_questions(
-            """
-            [MSQ] 1. Select valid propositions.
-            A. p implies q
-            B. q implies p
-            C. p iff q
-            D. not p
-            Correct Answer: A;C
-            """
-        )
-
-        self.assertEqual(questions[0]["question_type"], "msq")
-        self.assertEqual(questions[0]["correct_answer"], "A,C")
-
-    def test_separate_answer_key_is_merged(self):
-        questions = _parse_gate_questions(
-            """
-            Q.1 MCQ | +1 -0.33
-            Choose.
-            A. x
-            B. y
-            C. z
-            D. w
-            Q.2 MSQ | +2 -0
-            Pick all.
-            A. a
-            B. b
-            C. c
-            D. d
-            Answer Key
-            1. B
-            2. A;C
-            """
-        )
-
-        self.assertEqual([q["correct_answer"] for q in questions], ["B", "A,C"])
-        self.assertEqual(questions[1]["question_type"], "msq")
-
-    def test_choice_answers_with_option_prefix_and_explanations(self):
-        questions = _parse_gate_questions(
-            """
-            Q.1 MCQ | +1 -0.33
-            Choose.
-            A. x
-            B. y
-            C. z
-            D. w
-            Answer: Option B
-            Q.2 MCQ | +1 -0.33
-            Choose again.
-            A. x
-            B. y
-            C. z
-            D. w
-            Correct Answer: C. because z is correct
-            Q.3 MSQ | +2 -0
-            Pick all.
-            A. a
-            B. b
-            C. c
-            D. d
-            Answer: A and C are correct
-            """
-        )
-
-        self.assertEqual([q["correct_answer"] for q in questions], ["B", "C", "A,C"])
-        self.assertFalse(any("invalid_choice_answer" in q["warnings"] for q in questions))
-
-    def test_multiple_choice_answer_overrides_mcq_header(self):
-        questions = _parse_gate_questions(
-            """
-            Q.1 MCQ | +1 -0.33
-            Select the true statements.
-            A. true
-            B. false
-            C. also true
-            D. also also true
-            Correct Answer: A;C;D Discuss
-            """
-        )
-
-        self.assertEqual(questions[0]["question_type"], "msq")
-        self.assertEqual(questions[0]["correct_answer"], "A,C,D")
-        self.assertNotIn("mcq_has_multiple_answers", questions[0]["warnings"])
-
-    def test_option_text_before_label_is_recovered(self):
-        questions = _parse_gate_questions(
-            """
-            Q.1 MCQ | +1 -0.33
-            If expression is false, values are respectively:
-            F,T,F
-            A.
-            T,F,T
-            B.
-            T,T,T
-            C.
-            F,F,F
-            D.
-            Correct Answer: B Discuss
-            Q.2 MCQ | +2 -0.67
-            Identify expression.
-            X$Y
-            A.
-            X$¬Y
-            B.
-            ¬X$Y
-            C.
-            D. none of the options
-            Correct Answer: D Discuss
-            """
-        )
-
-        self.assertEqual(questions[0]["options"], ["F,T,F", "T,F,T", "T,T,T", "F,F,F"])
-        self.assertEqual(questions[1]["options"], ["X$Y", "X$¬Y", "¬X$Y", "none of the options"])
-        self.assertFalse(any("too_few_options" in q["warnings"] for q in questions))
-
-    def test_nat_numeric_answer_and_range(self):
-        questions = _parse_gate_questions(
-            """
-            Q1 NAT | +2 -0
-            The value is ____.
-            Answer: -2--1
-            Q2 Numerical answer type | +1 -0
-            Enter the count.
-            Answer: 4,5
-            """
-        )
-
-        self.assertEqual([q["question_type"] for q in questions], ["nat", "nat"])
-        self.assertEqual(questions[0]["correct_answer"], "-2--1")
-        self.assertEqual(questions[1]["correct_answer"], "4,5")
-        self.assertFalse(questions[0]["needs_review"])
-
-    def test_nat_answer_with_units_is_normalized(self):
-        questions = _parse_gate_questions(
-            """
-            Q.1 NAT | +1 -0
-            Count the valid rows.
-            Answer: 4 combinations
-            Q.2 NAT | +1 -0
-            Give the accepted interval.
-            Correct Answer: -2 to -1 approximately
-            """
-        )
-
-        self.assertEqual([q["correct_answer"] for q in questions], ["4", "-2--1"])
-        self.assertFalse(any("nat_has_non_numeric_answer" in q["warnings"] for q in questions))
-
-    def test_marks_from_section_range(self):
-        questions = _parse_gate_questions(
-            """
-            Q.1 to Q.5 carry one mark each
-            Q.1 MCQ
-            Choose.
-            A. a
-            B. b
-            C. c
-            D. d
-            Answer: A
-            """
-        )
-
-        self.assertEqual(questions[0]["marks"], 1.0)
-
-    def test_missing_answer_is_not_guessed_as_a(self):
-        questions = _parse_gate_questions(
-            """
-            Q.1 MCQ | +1 -0.33
-            Choose.
-            A. a
-            B. b
-            C. c
-            D. d
-            """
-        )
-
-        self.assertEqual(questions[0]["correct_answer"], "")
-        self.assertIn("missing_answer", questions[0]["warnings"])
-        self.assertTrue(questions[0]["needs_review"])
-
-    def test_repeated_question_numbers_across_sections(self):
-        questions = _parse_gate_questions(
-            """
-            SECTION A
-            Q.1 MCQ
-            Choose A.
-            A. a
-            B. b
-            C. c
-            D. d
-            Answer: A
-            SECTION B
-            Q.1 MCQ
-            Choose B.
-            A. a
-            B. b
-            C. c
-            D. d
-            Answer: B
-            """
-        )
-
-        self.assertEqual(len(questions), 2)
-        self.assertEqual([q["global_question_number"] for q in questions], [1, 2])
-        self.assertEqual([q["correct_answer"] for q in questions], ["A", "B"])
-
-    def test_image_context_and_low_confidence_detection(self):
-        questions = _parse_gate_questions(
-            """
-            Q.1 MCQ
-            In the following figure, choose the output.
-            A. zero
-            B. one
-            Answer: A
-            """
-        )
-
-        self.assertTrue(questions[0]["has_image"])
-        self.assertIn("image_context_required", questions[0]["warnings"])
-        self.assertIn("too_few_options", questions[0]["warnings"])
-        self.assertTrue(questions[0]["needs_review"])
-
-
-if __name__ == "__main__":
-    unittest.main()

frontend/src/api/api.js

@@ -19,7 +19,7 @@ export const adminAPI = {
   createPasswordReset: (id)         => api.post(`/admin/users/${id}/password-reset`),
   getTests:         ()              => api.get('/admin/tests'),
   getTest:          (id)            => api.get(`/admin/tests/${id}`),
-  createTest:       (form)          => api.post('/admin/tests', form, { headers: { 'Content-Type': 'multipart/form-data' } }),
+  createTest:       (data)          => api.post('/admin/tests', data),
   deleteTest:       (id)            => api.delete(`/admin/tests/${id}`),
   updateTest:       (id, data)       => api.patch(`/admin/tests/${id}`, data),
   getQuestions:     (testId)        => api.get(`/admin/tests/${testId}/questions`),

frontend/src/pages/AdminTests.jsx

@@ -21,9 +21,7 @@ function CreateTestModal({ onClose, onCreated }) {
     title: '', description: '', duration_minutes: 180,
     category: '', series_name: '', test_type: '', subject: ''
   })
-  const [pdf, setPdf] = useState(null)
   const [loading, setLoading] = useState(false)
-  const fileRef = useRef()
 
   const isWeeklyQuiz  = form.category === 'weekly_quiz'
   const isTestSeries  = form.category === 'test_series'
@@ -42,18 +40,8 @@ function CreateTestModal({ onClose, onCreated }) {
 
     setLoading(true)
     try {
-      const fd = new FormData()
-      fd.append('title', form.title)
-      if (form.description) fd.append('description', form.description)
-      fd.append('duration_minutes', form.duration_minutes)
-      fd.append('category', form.category)
-      if (form.series_name) fd.append('series_name', form.series_name)
-      if (form.test_type)   fd.append('test_type', form.test_type)
-      if (form.subject)     fd.append('subject', form.subject)
-      if (pdf) fd.append('pdf_file', pdf)
-
-      const res = await adminAPI.createTest(fd)
-      toast.success(`Test created!${res.data.question_count > 0 ? ` Extracted ${res.data.question_count} questions.` : ''}`)
+      const res = await adminAPI.createTest(form)
+      toast.success('Test created!')
       onCreated(res.data)
     } catch (err) {
       toast.error(err.response?.data?.detail || 'Failed to create test')
@@ -164,29 +152,7 @@ function CreateTestModal({ onClose, onCreated }) {
             </>
           )}
 
-          {/* PDF */}
-          <div className="border-t pt-4" style={{ borderColor: 'var(--border)' }}>
-            <label className="label">Upload PDF (optional)</label>
-            <div role="button" tabIndex={0} onClick={() => fileRef.current?.click()}
-              onKeyDown={e => { if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); fileRef.current?.click(); } }}
-              className="border-2 border-dashed rounded-lg p-4 text-center cursor-pointer transition-colors hover:border-sky-500/40 focus-visible:ring-2 focus-visible:ring-sky-500 outline-none"
-              style={{ borderColor: 'var(--border)' }}>
-              {pdf ? (
-                <div className="flex items-center justify-center gap-2 text-sky-400 text-sm">
-                  <FileText size={15} />{pdf.name}
-                  <button type="button" onClick={e => { e.stopPropagation(); setPdf(null) }}
-                    aria-label="Remove PDF" className="text-red-400"><X size={13} /></button>
-                </div>
-              ) : (
-                <div className="text-sm" style={{ color: 'var(--text-muted)' }}>
-                  <Upload size={16} className="mx-auto mb-1" />
-                  Click to select PDF
-                </div>
-              )}
-            </div>
-            <input type="file" accept=".pdf" ref={fileRef} className="hidden"
-              onChange={e => setPdf(e.target.files[0] || null)} />
-          </div>
+
 
           <div className="flex gap-3">
             <button type="button" onClick={onClose} className="btn-ghost flex-1">Cancel</button>