Update app.py

app.py

@@ -1,50 +1,97 @@
-# app.py
-# Gradio app for transcription + grading using Google Gemini
-# Author: generated for your notebook logic (adapted and sanitized)
-
+import gradio as gr
 import os
-import tempfile
 import io
-import traceback
-import gradio as gr
-
-try:
-    import google.generativeai as genai
-except Exception as e:
-    genai = None
+from google import generativeai as genai
 
-# ---- Configuration ----
-# IMPORTANT: Do NOT hardcode your API key here.
-# Set environment variable GEMINI_API_KEY in Hugging Face Spaces Secrets.
-GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY", None)
-if GEMINI_API_KEY:
-    if genai is not None:
-        genai.configure(api_key=GEMINI_API_KEY)
-else:
-    # genai may be None if package not installed; Gradio UI will show an error if user tries to run
-    pass
-
-# ---- Long instructions copied-from-notebook (transcription) ----
-TRANSCRIPTION_INSTRUCTIONS = """
+def process_exam_papers(question_paper, marking_scheme, answer_sheet, api_key):
+    """
+    Process uploaded exam papers and return transcription and grading
+    """
+    if not api_key:
+        return "Please provide a valid Gemini API key.", ""
+    
+    try:
+        # Configure Gemini API
+        genai.configure(api_key=api_key)
+        
+        # Upload files to Gemini
+        qp_file = genai.upload_file(path=question_paper.name, display_name="Question Paper")
+        ms_file = genai.upload_file(path=marking_scheme.name, display_name="Marking Scheme")
+        ans_file = genai.upload_file(path=answer_sheet.name, display_name="Answer Sheet")
+        
+        # Transcription instructions
+        transcription_instructions = """
 Persona:
 You are an expert transcriptionist specializing in scientific and mathematical documents. Your primary goal is to convert handwritten mathematical work into a perfectly formatted, machine-readable Markdown document using LaTeX for all mathematical notation.
+
 Core Task:
 Your task is to transcribe the provided handwritten student solutions into a single, clean Markdown string.
+
 Key Directives & Rules:
 Absolute Fidelity: Transcribe exactly what is written. Do NOT correct mathematical errors, logical fallacies, or spelling mistakes. Your role is purely that of a scribe, not a grader or editor.
+
 LaTeX for All Math: All mathematical content—including single variables, numbers in equations, fractions, exponents, roots, and symbols—must be enclosed in LaTeX delimiters. Use inline $ ... $ for math within text and block $$ ... $$ for standalone equations.
+
 Handle Strikethroughs: Completely ignore and omit any text, numbers, or expressions that have been struck through by the student. Do not include them in the final output.
+
 Preserve Structure:
 Use Markdown bolding (e.g., **1.**, **2a.**) to clearly separate each question or sub-part.
 Maintain the vertical, step-by-step flow of the student's derivations. For multi-line aligned equations, use the \\begin{align*} ... \\end{align*} environment within a $$ ... $$ block.
+
 Handle Ambiguity: If a character or symbol is genuinely illegible or ambiguous, make your best interpretation and enclose it in square brackets. For example, if a variable could be u or v, write [u?].
+
 Output Format:
 The final output must be a single Markdown string.
 Ensure all LaTeX renders correctly and the structure is clean and readable.
-"""
 
-# ---- Grading system instructions (as in notebook) ----
-GRADING_INSTRUCTIONS = """
+Comprehensive Example:
+If the student's handwritten work for a question looks like this:
+7. Find the value of y.
+y = (x² + 3) / 2
+for x = 3
+y = (3² + 3) / 2
+y = (6+3) / 2
+y = (9 + 3) / 2
+y = 12 / 2
+y = 6
+
+Your expected output should be:
+**7.**
+
+Find the value of y.
+$$
+y = \\frac{x^2 + 3}{2}
+$$
+for $x = 3$
+$$
+\\begin{align*}
+y &= \\frac{3^2 + 3}{2} \\\\
+y &= \\frac{9 + 3}{2} \\\\
+y &= \\frac{12}{2} \\\\
+y &= 6
+\\end{align*}
+$$
+"""
+        
+        # Initialize Gemini model for transcription
+        model = genai.GenerativeModel(
+            "gemini-2.5-pro",
+            generation_config={"temperature": 0}
+        )
+        
+        # Generate transcription
+        response = model.generate_content([
+            transcription_instructions,
+            ans_file
+        ])
+        
+        # Extract transcription safely
+        student_transcription = getattr(response, "text", None)
+        if not student_transcription:
+            student_transcription = response.candidates[0].content.parts[0].text
+        
+        # Grading system instructions
+        grading_system = """
 Instructions to Examiners:
 Abbreviations:
 - M: Marks for correct Method.
@@ -64,178 +111,111 @@ Marking Rules:
 8. Do not award the final A mark if an incorrect approximation is used in the same part.
 
 Error Avoidance:
-- No incorrect mark allocation: Do not award marks unless they are explicitly justified by the markscheme.
-- No misclassification of errors: Distinguish correctly between "Conceptual Errors" and "Silly Mistakes."
-- Follow markscheme logic exactly: Especially regarding when to withhold accuracy marks if method marks are not earned.
+- **No incorrect mark allocation:** Do not award marks unless they are explicitly justified by the markscheme.
+- **No misclassification of errors:** Distinguish correctly between "Conceptual Errors" and "Silly Mistakes."
+- **Follow markscheme logic exactly:** Especially regarding when to withhold accuracy marks if method marks are not earned.
 """
-
-# ---- Helper functions ----
-def ensure_genai_available():
-    if genai is None:
-        raise RuntimeError("google-generativeai package is not available. Make sure it's in requirements.txt.")
-    if not GEMINI_API_KEY:
-        raise RuntimeError("GEMINI_API_KEY not set. Set it in environment/secrets before running the app.")
-
-def _save_temp_file(uploaded_file) -> str:
-    """
-    uploaded_file is a file-like object provided by Gradio (temp file path).
-    Returns a path to a saved temp file we can pass to genai.upload_file.
-    """
-    if uploaded_file is None:
-        raise ValueError("No file provided.")
-    # Gradio gives a dict with 'name' and 'data' in some modes; but usually it's a path
-    # Attempt to handle multiple types robustly
-    if isinstance(uploaded_file, str):
-        return uploaded_file  # already a path
-    # Otherwise write bytes to a temp file
-    data = None
-    try:
-        # uploaded_file may be a file-like with .read()
-        data = uploaded_file.read()
-    except Exception:
-        # uploaded_file may be a tuple returned by gr.File: (name, data)
-        try:
-            data = uploaded_file[0].read()
-        except Exception:
-            raise
-    fd, path = tempfile.mkstemp(suffix=".pdf")
-    os.close(fd)
-    with open(path, "wb") as f:
-        f.write(data)
-    return path
-
-def upload_file_to_gemini(local_path, display_name="file"):
-    """
-    Upload a local file path to Gemini using genai.upload_file and return the file object (as returned).
-    """
-    ensure_genai_available()
-    # The API used in original notebook: genai.upload_file(path=...)
-    # We'll use the same call and return the object
-    try:
-        file_obj = genai.upload_file(path=local_path, display_name=display_name)
-        return file_obj
-    except Exception as e:
-        # Surface the error
-        raise RuntimeError(f"Failed to upload file to Gemini: {e}")
-
-def call_gemini_generate(inputs_list):
-    """
-    Call Gemini generative model with the provided inputs list (strings and/or uploaded file objects).
-    Returns the textual content (tries several extraction methods).
-    """
-    ensure_genai_available()
-    try:
-        model = genai.GenerativeModel("gemini-2.5-pro", generation_config={"temperature": 0})
-        response = model.generate_content(inputs_list)
-        text = getattr(response, "text", None)
-        if not text:
-            # try legacy path
-            if hasattr(response, "candidates") and response.candidates:
-                # drill into candidates
-                try:
-                    text = response.candidates[0].content.parts[0].text
-                except Exception:
-                    text = str(response.candidates[0])
-        if not text:
-            text = str(response)
-        return text
-    except Exception as e:
-        raise RuntimeError(f"Gemini generation failed: {e}")
-
-# ---- Core operations ----
-def transcribe_answer_sheet(answersheet_file):
-    """
-    Save the uploaded answersheet, upload to Gemini, and request transcription.
-    Returns the transcription string.
-    """
-    try:
-        ensure_genai_available()
-    except Exception as e:
-        return f"ERROR: {e}"
-
-    try:
-        local_ans_path = _save_temp_file(answersheet_file)
-        uploaded_ans = upload_file_to_gemini(local_ans_path, display_name="Answer Sheet")
-        # Call Gemini to transcribe (instructions + uploaded file)
-        response_text = call_gemini_generate([TRANSCRIPTION_INSTRUCTIONS, uploaded_ans])
-        return response_text
-    except Exception as e:
-        tb = traceback.format_exc()
-        return f"Transcription failed: {e}\n\n{tb}"
-
-def grade_answer(qp_file, ms_file, transcription_text):
-    """
-    Upload QP and MS, then call Gemini with grading instructions + the transcription to obtain grading output.
-    """
-    try:
-        ensure_genai_available()
-    except Exception as e:
-        return f"ERROR: {e}"
-
-    if transcription_text is None or transcription_text.strip() == "":
-        return "ERROR: Empty transcription. Please run transcription first or provide transcription text."
-
-    try:
-        local_qp = _save_temp_file(qp_file)
-        local_ms = _save_temp_file(ms_file)
-        uploaded_qp = upload_file_to_gemini(local_qp, display_name="Question Paper")
-        uploaded_ms = upload_file_to_gemini(local_ms, display_name="Marking Scheme")
-
-        # Build the prompt combining grading instructions + strict rules (as in the notebook)
-        grading_prompt = (
-            "You are an official examiner. Use the following grading system and rules to assess the answers:\n\n"
-            + GRADING_INSTRUCTIONS
-            + "\n\nYour output must:\n"
+        
+        # Generate grading
+        grading_response = model.generate_content([
+            f"You are an official examiner. Use the following grading system and rules to assess the answers:\n\n{grading_system}\n\n"
+            "Your output must:\n"
             "1. Apply marks exactly as per the markscheme.\n"
             "2. Justify each awarded or withheld mark with reference to the grading rules.\n"
             "3. Identify and classify all errors accurately (Conceptual Error, Silly Mistake, or None).\n"
             "4. Follow the dependency between M and A marks strictly.\n"
             "5. Avoid giving marks that the markscheme does not allow.\n"
-            "6. Provide a step-by-step reasoning for each mark awarded or withheld, explaining your thought process clearly.\n"
-        )
-
-        response_text = call_gemini_generate([grading_prompt, uploaded_qp, uploaded_ms, transcription_text])
-        return response_text
+            "6. Provide a step-by-step reasoning for each mark awarded or withheld, explaining your thought process clearly.\n",
+            qp_file,
+            ms_file,
+            student_transcription
+        ])
+        
+        # Extract grading safely
+        grading_text = getattr(grading_response, "text", None)
+        if not grading_text and grading_response.candidates:
+            grading_text = grading_response.candidates[0].content.parts[0].text
+        elif not grading_text:
+            grading_text = "No Response"
+        
+        return student_transcription, grading_text
+        
     except Exception as e:
-        tb = traceback.format_exc()
-        return f"Grading failed: {e}\n\n{tb}"
-
-# ---- Gradio UI ----
-with gr.Blocks(title="Exam Transcription & Grading (Gemini)") as demo:
-    gr.Markdown(
-        """
-        # Exam Transcription & Grading
-        Upload three PDFs: Question Paper, Marking Scheme, and Answer Sheet.
-        Click **Transcribe** to get a LaTeX-friendly Markdown transcription of the student's handwritten answers.
-        Click **Grade** to apply the marking scheme to the transcription and get a detailed grading justification.
-        **Important:** set `GEMINI_API_KEY` in environment/secrets before using.
-        """
-    )
-
+        return f"Error processing files: {str(e)}", ""
+
+# Create Gradio interface
+with gr.Blocks(title="Exam Paper Grading System", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 📚 Automated Exam Paper Grading System
+    
+    Upload your question paper, marking scheme, and answer sheet to get automated transcription and grading using Google's Gemini AI.
+    """)
+    
     with gr.Row():
-        qp_in = gr.File(label="Question Paper (PDF)", file_count="single", type="file")
-        ms_in = gr.File(label="Marking Scheme (PDF)", file_count="single", type="file")
-        ans_in = gr.File(label="Answer Sheet (PDF)", file_count="single", type="file")
-
+        with gr.Column():
+            gr.Markdown("### 📋 Upload Files")
+            api_key = gr.Textbox(
+                label="Gemini API Key",
+                placeholder="Enter your Google Gemini API key",
+                type="password"
+            )
+            question_paper = gr.File(
+                label="Question Paper (PDF)",
+                file_types=[".pdf"]
+            )
+            marking_scheme = gr.File(
+                label="Marking Scheme (PDF)",
+                file_types=[".pdf"]
+            )
+            answer_sheet = gr.File(
+                label="Answer Sheet (PDF)",
+                file_types=[".pdf"]
+            )
+            
+            process_btn = gr.Button(
+                "🚀 Process Papers",
+                variant="primary",
+                size="lg"
+            )
+    
     with gr.Row():
-        transcribe_btn = gr.Button("Transcribe Answer Sheet")
-        grade_btn = gr.Button("Grade (use existing transcription)")
-
-    transcription_out = gr.Textbox(label="Transcription (Markdown + LaTeX)", lines=20)
-    grading_out = gr.Textbox(label="Grading Result + Justification", lines=20)
-
-    # Wire buttons
-    transcribe_btn.click(fn=transcribe_answer_sheet, inputs=[ans_in], outputs=[transcription_out])
-    # Grade uses QP, MS and transcription textbox as inputs
-    grade_btn.click(fn=grade_answer, inputs=[qp_in, ms_in, transcription_out], outputs=[grading_out])
-
-    # Provide quick example text area for transcription override (optional)
-    gr.Markdown("If you already have a prepared transcription (or want to edit before grading), paste it below and click Grade.")
-    transcription_manual = gr.Textbox(label="Optional: Edit/Provide Transcription (overrides auto)", lines=8)
-    grade_with_manual_btn = gr.Button("Grade Using Provided Transcription")
-    grade_with_manual_btn.click(fn=grade_answer, inputs=[qp_in, ms_in, transcription_manual], outputs=[grading_out])
-
-    gr.Markdown("⚠️ Note: This app depends on Google Gemini `google-generativeai` SDK and a valid `GEMINI_API_KEY` environment variable.")
+        with gr.Column():
+            gr.Markdown("### 📝 Student Answer Transcription")
+            transcription_output = gr.Textbox(
+                label="Transcribed Answers",
+                lines=15,
+                max_lines=25,
+                show_copy_button=True
+            )
+        
+        with gr.Column():
+            gr.Markdown("### ✅ Grading Results")
+            grading_output = gr.Textbox(
+                label="Detailed Grading",
+                lines=15,
+                max_lines=25,
+                show_copy_button=True
+            )
+    
+    # Set up the processing function
+    process_btn.click(
+        fn=process_exam_papers,
+        inputs=[question_paper, marking_scheme, answer_sheet, api_key],
+        outputs=[transcription_output, grading_output]
+    )
+    
+    gr.Markdown("""
+    ### 📖 How to Use:
+    1. **Get a Gemini API Key**: Visit [Google AI Studio](https://makersuite.google.com/app/apikey) to get your free API key
+    2. **Upload PDFs**: Upload your question paper, marking scheme, and student answer sheet
+    3. **Process**: Click the "Process Papers" button to get transcription and grading
+    4. **Review**: Check the transcribed answers and detailed grading results
+    
+    ### ⚠️ Notes:
+    - All uploaded files are processed securely and not stored permanently
+    - The system transcribes exactly what's written (including errors) for accurate grading
+    - LaTeX mathematical notation is automatically formatted for clarity
+    """)
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()