Update app.py

app.py

@@ -14,7 +14,7 @@ import cv2
 import numpy as np 
 from concurrent.futures import ThreadPoolExecutor, as_completed 
 from PyPDF2 import PdfReader, PdfWriter 
-from google.ai.generativelanguage import types
+
 # ---------------- CONFIG ---------------- 
 genai.configure(api_key=os.getenv("GEMINI_API_KEY")) 
 GRID_ROWS, GRID_COLS = 20, 14 
@@ -57,7 +57,6 @@ Answer 2 :
 } 
 , 
 
-    # GRADING_PROMPT unchanged except we will print steps around calling it 
     "GRADING_PROMPT": { 
         "role": "system", 
         "content": """Developer: You are an official examiner. Apply the following grading rules precisely. 
@@ -82,12 +81,12 @@ Answer 2 :
 Produce two sections per question/sub-question, following this structure: 
 ## Question <id> 
 ### Markscheme vs Student Answer 
-| Mark ID | Markscheme Expectation | Student’s Response | Awarded | 
+| Mark ID | Markscheme Expectation | Student's Response | Awarded | 
 |---------|------------------------|--------------------|---------| 
 | M1_1    | Recognise GP           | "r=0.9"            | M1 | 
 ➡️ **Total: X/Y** 
 --- 
-### Examiner’s Report 
+### Examiner's Report 
 At the very end, provide a summary table: 
 | Question Number | Marks | Remark | 
 |-----------------|-------|--------| 
@@ -110,18 +109,6 @@ def save_as_pdf(text, filename="output.pdf"):
     pdf.save(filename) 
     return filename 
 
-# --- Gemini standard upload (no RAG required) ---
-def upload_to_gemini(path, display_name=None):
-    import google.generativeai as genai
-    with open(path, "rb") as f:
-        uploaded_file = genai.upload_file(
-            file=f,                                # <- file object
-            mime_type="application/pdf",            # <- set MIME type
-            display_name=display_name or os.path.basename(path)
-        )
-    return uploaded_file
-
-
 def compress_pdf(input_path, output_path=None, max_size=20*1024*1024): 
     if output_path is None: 
         base, ext = os.path.splitext(input_path) 
@@ -162,21 +149,37 @@ def create_model():
     Create the Gemini model and print which model is selected. 
     """ 
     try: 
-        print("⚡ Attempting to use gemini-2.5-pro model") 
-        model = genai.GenerativeModel("gemini-2.5-pro", generation_config={"temperature": 0}) 
-        print("✅ Selected model: gemini-2.5-pro") 
+        print("⚡ Attempting to use gemini-2.0-flash-exp model") 
+        model = genai.GenerativeModel("gemini-2.0-flash-exp", generation_config={"temperature": 0}) 
+        print("✅ Selected model: gemini-2.0-flash-exp") 
         return model 
     except Exception as e: 
-        print("⚠️ Could not use gemini-2.5-pro:", e) 
+        print("⚠️ Could not use gemini-2.0-flash-exp:", e) 
     try: 
-        print("⚡ Falling back to gemini-2.5-flash model") 
-        model = genai.GenerativeModel("gemini-2.5-flash", generation_config={"temperature": 0}) 
-        print("✅ Selected model: gemini-2.5-flash") 
+        print("⚡ Falling back to gemini-1.5-flash model") 
+        model = genai.GenerativeModel("gemini-1.5-flash", generation_config={"temperature": 0}) 
+        print("✅ Selected model: gemini-1.5-flash") 
         return model 
     except Exception as e: 
         print("❌ Failed to create any Gemini model:", e) 
         raise 
 
+def upload_to_gemini(path, display_name=None):
+    """
+    Upload a file to Gemini using the standard File API (no RAG).
+    """
+    print(f"📤 Uploading {path} to Gemini...")
+    try:
+        uploaded_file = genai.upload_file(
+            path=path,
+            display_name=display_name or os.path.basename(path)
+        )
+        print(f"✅ Uploaded: {uploaded_file.display_name} (URI: {uploaded_file.uri})")
+        return uploaded_file
+    except Exception as e:
+        print(f"❌ Upload failed for {path}: {e}")
+        raise
+
 def merge_pdfs(paths, output_path): 
     writer = PdfWriter() 
     for p in paths: 
@@ -196,19 +199,14 @@ def gemini_generate_content(model, prompt_text, file_upload_obj=None, image_obj=
     if file_upload_obj: 
         inputs.append(file_upload_obj) 
     if image_obj: 
-        # Handle both single images and lists of images
         if isinstance(image_obj, list):
-            # Convert image paths to PIL Image objects
             for img_path in image_obj:
                 if isinstance(img_path, str):
-                    # It's a file path, load as PIL Image
                     pil_img = Image.open(img_path)
                     inputs.append(pil_img)
                 else:
-                    # It's already an image object
                     inputs.append(img_path)
         else:
-            # Single image
             if isinstance(image_obj, str):
                 pil_img = Image.open(image_obj)
                 inputs.append(pil_img)
@@ -226,22 +224,17 @@ def gemini_generate_content(model, prompt_text, file_upload_obj=None, image_obj=
 
 # ---------------- PARSERS ---------------- 
 def extract_question_ids_from_qpms(text: str):
-    """Extract question IDs from QP+MS transcript.
-    Two-step approach: explicit 'Question X' lines, then fallback numbered lists.
-    Robust to hidden whitespace and simple unicode spaces."""
+    """Extract question IDs from QP+MS transcript."""
     print("🔎 Extracting question IDs from QP+MS transcript using regex...")
     
-    # Normalize spaces/tabs/non-breaking spaces
     clean_text = text.replace("\u00A0", " ").replace("\t", " ")
     
-    # Step 1: Look for explicit "Question X" lines
     primary_matches = re.findall(r"^\s*Question\s*[:\s]\s*([\dA-Za-z.()]+)", clean_text, re.MULTILINE)
     if primary_matches:
         print(f"✅ Extracted {len(primary_matches)} question IDs from explicit 'Question X' lines.")
         print("IDs:", primary_matches)
         return primary_matches
     
-    # Step 2: Fallback — numbered/sub-question lists
     fallback_matches = re.findall(r"^\s*(\d+(?:[.)]|\([a-zA-Z0-9]+\))?[a-zA-Z0-9]*)", clean_text, re.MULTILINE)
     if fallback_matches:
         print(f"✅ Extracted {len(fallback_matches)} question IDs (fallback numbered lists).")
@@ -250,12 +243,9 @@ def extract_question_ids_from_qpms(text: str):
         print("⚠️ No question IDs extracted; will send NA placeholder.")
     return fallback_matches 
 
-# Update AS prompt builder to include graph detection
-
 def build_as_prompt_with_expected_ids(expected_ids, qpms_text=None):
     """
     Construct the AS transcription prompt injecting the expected IDs block and graph detection instructions.
-    If qpms_text is provided, instruct the LLM to refer to it for ambiguous handwriting.
     """
     if not expected_ids:
         ids_block = "{NA}"
@@ -288,8 +278,6 @@ AS:
 ==== GRAPH FOUND ANSWERS ====\nGraph found in:\n- Answer <number> → Page <number>\n(one per line)\n==== END GRAPH FOUND ===="""
     return prompt
 
-# Robust parsing functions for graph detection
-
 def extract_graph_questions_from_ms(text: str):
     """Extract graph questions and page numbers from MS transcript."""
     clean_text = text.replace("\u00A0", " ").replace("\t", " ")
@@ -325,9 +313,7 @@ def extract_graph_answers_from_as(text: str):
 
 def extract_marks_from_grading(grading_text): 
     """ 
-    Parse the grading markdown produced by the GRADING_PROMPT and extract marks per question. 
-    Returns dict: {"grading": [{"question": "1.a", "marks_awarded": ["M1","A1"]}, ...]} 
-    Preserves all marks in order, including duplicates. 
+    Parse the grading markdown and extract marks per question. 
     """ 
     print("🔎 Extracting awarded marks from grading output...") 
     grading_json = {"grading": []} 
@@ -353,7 +339,6 @@ def extract_marks_from_grading(grading_text):
 def ask_gemini_for_mapping_batch(model, image_paths, grading_json, expected_ids=None, rows=GRID_ROWS, cols=GRID_COLS):
     """
     Send multiple page images together to Gemini for batch mapping processing.
-    More efficient than sending one by one.
     """
     ids_block = "{NA}"
     if expected_ids:
@@ -375,7 +360,6 @@ Return JSON only, like:
 Grading JSON:
 {json.dumps(grading_json, indent=2)}"""
 
-    # Load all images
     images = [Image.open(p) for p in image_paths]
     
     print(f"📡 Sending batch mapping request for {len(image_paths)} pages to Gemini...")
@@ -391,7 +375,6 @@ Grading JSON:
     print("🔎 Gemini raw batch output:")
     print(raw_text)
     
-    # Try to extract JSON from response
     try:
         match = re.search(r'(\[.*\])', raw_text, re.DOTALL)
         if match:
@@ -408,14 +391,13 @@ Grading JSON:
 def imprint_marks_using_mapping(pdf_path, grading_json, output_pdf, model, expected_ids=None, rows=GRID_ROWS, cols=GRID_COLS): 
     """ 
     Convert PDF to images, create grid-numbered images for batch sending to Gemini, 
-    then annotate and produce imprinted PDF using batch processing for better efficiency.
+    then annotate and produce imprinted PDF.
     """ 
     print("📄 Converting answer PDF to images for imprinting...") 
     pages = convert_from_path(pdf_path, dpi=200) 
     annotated_page_paths = [] 
     temp_grid_images = [] 
 
-    # Create grid images for Gemini
     for p_index, page in enumerate(pages): 
         img = page.convert("RGB") 
         w, h = img.size 
@@ -444,9 +426,8 @@ def imprint_marks_using_mapping(pdf_path, grading_json, output_pdf, model, expec
         temp_grid_images.append(temp_path) 
         print("🛰 Created grid image:", temp_path) 
 
-    # Send pages in batches to Gemini for mapping
     print("📡 Sending page images to Gemini in batches for mapping...")
-    batch_size = 10  # Process 10 pages at a time
+    batch_size = 10
     all_mappings = []
     
     for start in range(0, len(temp_grid_images), batch_size):
@@ -455,7 +436,6 @@ def imprint_marks_using_mapping(pdf_path, grading_json, output_pdf, model, expec
         all_mappings.extend(batch_mapping)
         print(f"✅ Processed batch {start//batch_size + 1}: pages {start+1}-{start+len(batch_paths)}")
 
-    # Annotate original pages according to returned mappings 
     print("🖊 Annotating pages with marks...") 
     for p_index, page in enumerate(pages): 
         page_num = p_index + 1
@@ -465,7 +445,6 @@ def imprint_marks_using_mapping(pdf_path, grading_json, output_pdf, model, expec
         h, w, _ = img_cv.shape 
         cell_w_px, cell_h_px = w / cols, h / rows 
 
-        # Filter mappings for this page
         page_mappings = [m for m in all_mappings if m.get("page") == page_num]
         
         for item in page_mappings: 
@@ -484,11 +463,9 @@ def imprint_marks_using_mapping(pdf_path, grading_json, output_pdf, model, expec
             row = (cell_number - 1) // cols 
             col = (cell_number - 1) % cols 
 
-            # Position marks to the right of the answer, with fallback to left
             x_c = int((col + 1) * cell_w_px - cell_w_px / 4) 
             y_c = int((row + 0.5) * cell_h_px) 
 
-            # Use larger, more visible font
             font_scale = max(1.0, min(2.0, cell_h_px / 40.0)) 
             thickness = max(2, int(font_scale * 2)) 
             cv2.putText(img_cv, marks_text, (x_c, y_c), cv2.FONT_HERSHEY_SIMPLEX, 
@@ -500,7 +477,6 @@ def imprint_marks_using_mapping(pdf_path, grading_json, output_pdf, model, expec
         annotated_page_paths.append(annotated_path) 
         print("✅ Annotated page saved:", annotated_path) 
 
-    # Merge annotated pages into final PDF
     print("📑 Merging annotated pages into final PDF...")
     with open(output_pdf, "wb") as f: 
         f.write(img2pdf.convert(annotated_page_paths)) 
@@ -509,21 +485,14 @@ def imprint_marks_using_mapping(pdf_path, grading_json, output_pdf, model, expec
     print("📑 Imprinted PDF saved to:", compressed) 
     return compressed 
 
-# ---------------- GRAPH DETECTION HELPERS ----------------
-# These functions are now robustly handled by the new_code, so they are no longer needed here.
-
-# ---------------- GRAPH PAGE EXTRACTION HELPER ----------------
 def extract_pdf_pages_as_images(pdf_path, page_numbers, prefix):
     """
     Extracts unique pages (1-based) from a PDF as images, saves as PNG, returns list of file paths.
-    Prints to console when extracting each page.
     """
     unique_pages = sorted(set(page_numbers))
     images = convert_from_path(pdf_path, dpi=200, first_page=min(unique_pages), last_page=max(unique_pages))
     out_paths = []
     for idx, page_num in enumerate(unique_pages):
-        # pdf2image returns images in order, but if not contiguous, we need to map
-        # So, get the image for this page (1-based)
         img_idx = page_num - min(unique_pages)
         img = images[img_idx]
         out_path = f"{prefix}_page_{page_num}.png"
@@ -532,37 +501,28 @@ def extract_pdf_pages_as_images(pdf_path, page_numbers, prefix):
         out_paths.append(out_path)
     return out_paths
 
-# ---------------- PIPELINE UPDATE FOR GRAPH-AWARE GRADING ----------------
+# ---------------- PIPELINE ----------------
 def align_and_grade_pipeline(qp_path, ms_path, ans_path, imprint=False):
     """
-    Final pipeline implementing requested flow and verbose console logging.
-    Now includes Graph-Aware Grading logic.
+    Final pipeline with graph-aware grading logic.
     """
     try:
         print("🔁 Starting pipeline...")
-        # Step 0: compress as needed
         qp_path = compress_pdf(qp_path)
         ms_path = compress_pdf(ms_path)
         ans_path = compress_pdf(ans_path)
 
-        # Merge QP + MS
         merged_qpms_path = os.path.splitext(qp_path)[0] + "_merged_qp_ms.pdf"
         merge_pdfs([qp_path, ms_path], merged_qpms_path)
         print("📎 Merged QP + MS ->", merged_qpms_path)
 
-        # Upload files to Gemini
         print("🔼 Uploading files to Gemini...")
-      
         merged_uploaded = upload_to_gemini(merged_qpms_path, "QP+MS (merged)")
         ans_uploaded = upload_to_gemini(ans_path, "Answer Sheet")
- 
-        
         print("✅ Upload complete.")
 
-        # Create model and print which selected
         model = create_model()
 
-        # Step 1.i: QP+MS transcription (first)
         print("1.i) Transcribing QP+MS (questions first, then full markscheme, with graph detection)...")
         qpms_prompt = PROMPTS["QP_MS_TRANSCRIPTION"]["content"] + "\nAt the end, also list all questions in the markscheme where a graph is expected, in the format:\nGraph expected in:\n- Question <number> → Page <number>\n(One per line, after ==== MARKSCHEME END ====)"
         qpms_text = gemini_generate_content(model, qpms_prompt, file_upload_obj=merged_uploaded)
@@ -570,7 +530,6 @@ def align_and_grade_pipeline(qp_path, ms_path, ans_path, imprint=False):
         with open("debug_qpms_transcript.txt", "w", encoding="utf-8") as f:
             f.write(qpms_text)
 
-        # Step 1.i.a: Extract graph-expected questions from MS
         ms_graph_mapping = extract_graph_questions_from_ms(qpms_text)
         print("🖼️ Graph-expected questions in MS:", ms_graph_mapping)
         ms_graph_pages = list(ms_graph_mapping.values())
@@ -578,12 +537,10 @@ def align_and_grade_pipeline(qp_path, ms_path, ans_path, imprint=False):
         if ms_graph_pages:
             ms_graph_images = extract_pdf_pages_as_images(merged_qpms_path, ms_graph_pages, prefix="qpms_graph")
 
-        # Step 2: extract serial numbers (question IDs) using regex from qpms_text
         extracted_ids = extract_question_ids_from_qpms(qpms_text)
         if not extracted_ids:
             extracted_ids = ["NA"]
 
-        # Step 1.ii: Build AS prompt injecting extracted IDs and transcribe AS
         print("1.ii) Building AS transcription prompt with expected question IDs and graph detection, sending to Gemini...")
         as_prompt = build_as_prompt_with_expected_ids(extracted_ids, qpms_text) + "\nAt the end, also list all answers where a graph is found, in the format:\nGraph found in:\n- Answer <number> → Page <number>\n(One per line, after all answers)"
         as_text = gemini_generate_content(model, as_prompt, file_upload_obj=ans_uploaded)
@@ -591,7 +548,6 @@ def align_and_grade_pipeline(qp_path, ms_path, ans_path, imprint=False):
         with open("debug_as_transcript.txt", "w", encoding="utf-8") as f:
             f.write(as_text)
 
-        # Step 2.a: Extract graph-attempted answers from AS
         as_graph_mapping = extract_graph_answers_from_as(as_text)
         print("🖼️ Graph-attempted answers in AS:", as_graph_mapping)
         as_graph_pages = list(as_graph_mapping.values())
@@ -599,9 +555,6 @@ def align_and_grade_pipeline(qp_path, ms_path, ans_path, imprint=False):
         if as_graph_pages:
             as_graph_images = extract_pdf_pages_as_images(ans_path, as_graph_pages, prefix="as_graph")
 
-        # Step 3: (No graph bundle matching, just collect images)
-
-        # Step 4: Grading - send both transcripts to grading model, inject graph image info
         print("2) Preparing grading input and sending to Gemini for grading...")
         grading_input = (
             "=== QP+MS TRANSCRIPT BEGIN ===\n"
@@ -611,24 +564,20 @@ def align_and_grade_pipeline(qp_path, ms_path, ans_path, imprint=False):
             + as_text
             + "\n=== ANSWER SHEET TRANSCRIPT END ===\n"
         )
-        # Inject graph image note
         if ms_graph_images or as_graph_images:
-            graph_note = "\n\n---\nSome questions require graphs. I’ve attached the relevant graph pages from QP+MS and from the Answer Sheet. Use them as visual context when grading.\n---\n"
+            graph_note = "\n\n---\nSome questions require graphs. I've attached the relevant graph pages from QP+MS and from the Answer Sheet. Use them as visual context when grading.\n---\n"
             grading_input += graph_note
         grading_prompt_system = PROMPTS["GRADING_PROMPT"]["content"]
-        # Pass images as additional input to gemini_generate_content
         grading_images = ms_graph_images + as_graph_images
         grading_text = gemini_generate_content(model, grading_prompt_system + "\n\nPlease grade the following transcripts:\n" + grading_input, image_obj=grading_images if grading_images else None)
         print("🧾 Grading output received. Saving debug file: debug_grading.md")
         with open("debug_grading.md", "w", encoding="utf-8") as f:
             f.write(grading_text)
 
-        # Save grading PDF
         base_name = os.path.splitext(os.path.basename(ans_path))[0]
         grading_pdf_path = save_as_pdf(grading_text, f"{base_name}_graded.pdf")
         print("📄 Grading PDF saved:", grading_pdf_path)
 
-        # Step 4: Extract marks for imprinting
         grading_json = extract_marks_from_grading(grading_text)
         with open("debug_grading_json.json", "w", encoding="utf-8") as f:
             json.dump(grading_json, f, indent=2, ensure_ascii=False)
@@ -646,11 +595,13 @@ def align_and_grade_pipeline(qp_path, ms_path, ans_path, imprint=False):
 
     except Exception as e:
         print("❌ Pipeline error:", e)
+        import traceback
+        traceback.print_exc()
         return f"❌ Error: {e}", None, None, None, None
 
 # ---------------- GRADIO UI ---------------- 
-with gr.Blocks(title=" AI Grading (Final Flow )") as demo: 
-    gr.Markdown("## 📘  AI Grading — Final Flow") 
+with gr.Blocks(title="AI Grading (Final Flow)") as demo: 
+    gr.Markdown("## 📘 AI Grading — Final Flow") 
 
     with gr.Row(): 
         qp_file = gr.File(label="📄 Upload Question Paper (PDF)")